This page is primarily intended for developers of Mercurial.
A (speculative) plan for topic branching that would work more seamlessly with common Mercurial workflows. Still very early prototype stage. Everything is subject to change.
- Problem Statement
- General semantics
- General effect on named branch
- Behavior for update
- Behavior for merge
- Behavior for push to publishing (default repo)
- Behavior for push to non-publisehd repo
- Stacked diffs workflow
- User Transition
- Pro and Cons
- Other questions
- Open ideas
- Current Implementation
- See also
1. Problem Statement
The Mercurial community has been struggling for years to define a nice way to handle 'topic' branches (sometimes also called 'feature' branches), especially when it comes to sharing them with other people (mainly for code review or other collaboration.)
Bookmarks are a clone of git's refs, which seems to work more poorly in Mercurial than they do in Git, in part because the synchronization parts of bookmarks aren't really done. Adding the remaining bits of git's refs to Mercurial has been controversial, and may represent enough of a behavior change that it's infeasible.
Named branches are visible forever in the revision history, which makes them unsuitable for feature branch work as the feature branch names rapidly pollute the output of things like hg branches.
2. Current Target
This describe the target semantic and behavior for topics. Of course some adjustement can be built.
2.1. General semantics
TL;DR; topic are an extra "light-branch" data relevant to draft changesets.
Topic is a name explicitly attached to changesets,
This Topic data is primarily meant to categorize draft changeset and fade out when things become public,
Changeset have both a topic and a 'branch'. The topic allow to gather related in progress work, while the branch data refer to the long terms line of development.
Behaviors focus on ensuring any name have a single head.
- Behaviors related to named branches behave mostly as if the draft-with topic are not on the branch (yet).
- Behaviors within a topic are similar (with minor sensible difference) to named branches one within the topic.
2.2. General effect on named branch
Changeset with topic are only aspiring to be part of the named branch, but not fully in that branch yet. When you have branch foo name foo is resolved to the heads of foo with no topic.
There is a couple of examples:
Multiple heads are not longer ambiguous,
The name foo resolve to C,
The name bar resolve to Y,
Partial data does not have radical change on the definition,
The name foo resolve to B,
The name var resolve to Y,
Usual traversal rules apply:
The name foo resolve to B,
The name var resolve to X,
2.3. Behavior for update
(This implies change in hg update behavior (but are not super relevant))
2.3.1. Case 1: active branch
Currently active: branch foo', no active topic. Running hg update bring you on the head of foo.
* Currently active branch: foo * Currently active topic: ø * Running hg update bring you on the head of foo branch (untopiced-head).
2.3.2. Case 2: active topic
* Currently active branch foo * Currently active topic: bar * Running hg update bring you on the head of bar topic.
2.3.3. Case 3: active topic, lagging behind
W was on topic bar, but it is now public so bar does not apply to W. However, the working copy is still having an active topic.
* Currently active branch: foo * Currently active topic: bar * Running hg update bring you on the head of bar topic.
Classical case for getting in that situation is to hg up bar that bring you on W with bar active, then pull that bring you B, C, X, Y and turn W public.
The intent here is to work on topic bar and hg update should make you up-to-date in the bar context.
Alternatively we could requires more data from the user.
2.3.4. Case 4: active topic, topic is closed
W was on topic bar, but it is now public so bar does not apply to W anymore. However, the working copy is still having an active topic.
* Currently active branch: foo * Currently active topic: bar * Running hg update bring you on the head of foo branch. * The baris de-activated
Classical case for getting in that situation is to be working on topic bar then bar got 'accepted' and get public. As you former bar is not the new head of foo, people merge/rebase and publish more changesets on top of that.
In that case inferring that you topic is "done" and being up to date mean "bring me to the latest of my branch seems to make sense.
A possible issue, hg update; hg pull can provide different from `hg pull; hg update, in the case where hg update is bringing changeset on the bar` topic again.
Alternatively we could not update, pointing at a command to disable the topic.
2.4. Behavior for merge
This assume hg rebase and hg merge to be identical,
2.5. Behavior for push to publishing (default repo)
2.6. Behavior for push to non-publisehd repo
2.7. Stacked diffs workflow
2.8. User Transition
3. Pro and Cons
4. Other questions
5. Open ideas
This is a list of idea that emerged while brainstorming. This served as base for the current things.
- Topic could be a property attached to each changeset (grouping them by similar topic)
- Topic could fade away when changesets become public (either archived or plain dropped)
A benefit of archiving them is that users can query for topics, eg you could say hg log -r topic(issue123) which would help
- Tracking could be achieved through the naming scheme. eg:
- 'default//feature-foo' would be a topic 'feature-foo' tracking the 'default' branch.
- 'stable//issue4700' would be a topic 'issue4700' tracking branch stable.
- '@//feature-bar' would be a topic 'feature-bar' tracking bookmark '@' ?
- 'stable//issue4689//issue4700' would be a topic 'issue4700' tracking the topic 'stable//issue4689'. When topic 'issue4686' face away (because published), the tracking fallback to 'stable'.
Topics could be non contiguous (mpm idea) feature-foo -> fix-bar -> feature-foo. Allowing a streamlined work that is automatically split apart after that.
- Topics could be hierarchical 'issue4700.test' 'issue4700.preparation', activation//reference could be done at any level 'issue4700' or 'issue4700' (this could help handle branching/different approach)
pushing a new head on a new topic to a non-publishing server would be allowed.
- that is, it'd be legal to have one head per topic on a non-publishing server.
- A changeset could maybe have multiple topic.
- Augie doesn't feel great about this option just because of UI complexity.
- Users can name patches (in a sense) without mq
- One of the major complaints about evolve from veteran mq users is that their patches no longer have explicit names. Topics provide a potential way to name patches again.
6. Current Implementation
Assign topics to non-public changesets. A topic is like a named branch, in that it is a label stored in a changeset's extra, but that topics just disappear when the change moves to public phase (the data still exists, it's just not shown.)
Code is available at http://hg.durin42.com/hg-topic-experiment/.
- Topics are not suitable for long term branches. We have named branches for that (and possibly also bookmarks, depending on workflow.)
- Topics are not suitable for tracking a moving point in public history. This seems to be a perfect fit for bookmarks.
6.1. Open Questions
- Right now we use changeset extra for storing the topic. That might lead to bonus divergence problems. They might be easily fixed, but should we avoid that?
- Should changesets be allowed multiple topics?
- How permissive should we be on topic names?