evolve: comparison hgext/evolve.py

equal deleted inserted replaced

-:4c305b8d4259
+:98b5ac44a259
 this feature,
 - improves some aspect of the early implementation in 2.3
 '''
 testedwith = 'default'
 buglink = 'https://bitbucket.org/marmoute/mutable-history/issues'
 import sys
 import random
 from StringIO import StringIO
 ui.write('        median length:      %9i\n' % median)
 mean = sum(len(x[1]) for x in allpclusters) // nbcluster
 ui.write('        mean length:        %9i\n' % mean)
 @command('^evolve|stabilize|solve',
-[('n', 'dry-run', False, 'do not perform actions, print what to be done'),
+[('n', 'dry-run', False, 'do not perform actions, just print what would be done'),
 ('A', 'any', False, 'evolve any troubled changeset'),
 ('a', 'all', False, 'evolve all troubled changesets'),
 ('c', 'continue', False, 'continue an interrupted evolution'), ],
 _('[OPTIONS]...'))
 def evolve(ui, repo, **opts):
 """Solve trouble in your repository
-- rebase unstable changeset to make it stable again,
+- rebase unstable changesets to make them stable again,
-- create proper diff from bumped changeset,
+- create proper diffs from bumped changesets,
-- merge divergent changesets.
+- merge divergent changesets,
 - update to a successor if the working directory parent is
 obsolete
-By default, take the first trouble changeset that looks relevant.
+By default, takes the first troubled changeset that looks relevant.
 (The logic is still a bit fuzzy)
 - For unstable, this means taking the first which could be rebased as a
 child of the working directory parent revision or one of its descendants
 and rebasing it.
 - For divergent, this means taking "." if applicable.
-With --any, evolve picks any troubled changeset to solve.
+With --any, evolve picks any troubled changeset to repair.
 The working directory is updated to the newly created revision.
 """
 contopt = opts['continue']
 parents = wparents[0].parents()
 displayer = cmdutil.show_changeset(ui, repo, {'template': shorttemplate})
 if len(parents) == 1:
 p = parents[0]
-hg.update(repo, p.rev())
+bm = bookmarks.readcurrent(repo)
+shouldmove = bm is not None and bookmarks.iscurrent(repo, bm)
+ret = hg.update(repo, p.rev())
+if not ret and shouldmove:
+repo._bookmarks[bm] = p.node()
+repo._bookmarks.write()
 displayer.show(p)
 return 0
 else:
 for p in parents:
 displayer.show(p)
 if not children:
 ui.warn(_('no non-obsolete children\n'))
 return 1
 if len(children) == 1:
 c = children[0]
-hg.update(repo, c.rev())
+bm = bookmarks.readcurrent(repo)
+shouldmove = bm is not None and bookmarks.iscurrent(repo, bm)
+ret = hg.update(repo, c.rev())
+if not ret and shouldmove:
+repo._bookmarks[bm] = c.node()
+repo._bookmarks.write()
 displayer.show(c)
 return 0
 else:
 for c in children:
 displayer.show(c)
 ('B', 'bookmark', '', _("remove revs only reachable from given"
 " bookmark"))] + metadataopts,
 _('[OPTION] [-r] REV...'))
 # -U  --noupdate option to prevent wc update and or bookmarks update ?
 def cmdprune(ui, repo, *revs, **opts):
-"""get rid of changesets by marking them obsolete
+"""hide changesets by marking them obsolete
 Obsolete changesets becomes invisible to all commands.
-Non-pruned descendant of pruned changesets becomes "unstable". Use the
+Unpruned descendants of pruned changesets becomes "unstable". Use the
 :hg:`evolve` to handle such situation.
-When the working directory parent is pruned the repository is updated to a
+When the working directory parent is pruned, the repository is updated to a
-non obsolete parents.
+non-obsolete parent.
-You can use the ``--succ`` option to informs mercurial that a newer version
+You can use the ``--succ`` option to inform mercurial that a newer version
 of the pruned changeset exists.
 You can use the ``--biject`` option to specify a 1-1 (bijection) between
 revisions to prune and successor changesets. This option may be removed in
-a future release (with the functionality absored automatically).
+a future release (with the functionality absorbed automatically).
 """
 revs = set(scmutil.revrange(repo, list(revs) + opts.get('rev')))
 succs = opts['new'] + opts['succ']
 bookmark = opts.get('bookmark')
 ] + commands.walkopts,
 _('[OPTION]... [NAME]'))
 def uncommit(ui, repo, *pats, **opts):
 """move changes from parent revision to working directory
-Changes to selected files in parent revision appear again as
+Changes to selected files in the checked out revision appear again as
 uncommitted changed in the working directory. A new revision
-without selected changes is created, becomes the new parent and
+without the selected changes is created, becomes the checked out
-obsoletes the previous one.
+revision, and obsoletes the previous one.
 The --include option specifies patterns to uncommit.
 The --exclude option specifies patterns to keep in the commit.
 Return 0 if changed files are uncommitted.
 ('D', 'duplicate', False,
 'do not mark the new revision as successor of the old one')],
 # allow to choose the seed ?
 _('[-r] revs'))
 def touch(ui, repo, *revs, **opts):
-"""Create successors with exact same property but hash
+"""Create successors that are identical to their predecessors except for the changeset ID
 This is used to "resurrect" changesets
 """
 duplicate = opts['duplicate']
 revs = list(revs)
 # allow to choose the seed ?
 _('rev'))
 def fold(ui, repo, *revs, **opts):
 """Fold multiple revisions into a single one
-Revision from your current working directory to the specified one are fold
+The revisions from your current working directory to the given one are folded
-as a new one replacing the other
+into a single successor revision.
-you can alternatively use --rev to explicitly specify revision to be fold
+you can alternatively use --rev to explicitly specify revisions to be folded,
 ignoring the current working directory parent.
 """
 revs = list(revs)
 if revs:
 if opts.get('rev', ()):

changeset 900	98b5ac44a259
parent 898	934b6f0feffd
parent 893	12ed6dfa8eea
child 907	c17ab719da56