Commits

Pierre-Yves David committed 135827b Merge

merge with backout

Comments (0)

Files changed (5)

docs/evolve-collaboration.rst

 After having written some code for ticket #42, M W. start a patch (this
 will be kind of like a 'work-in-progress' checkpoint initially)::
 
-    $ ci -m '[entities] remove magic'
+    $ hg ci -m '[entities] remove magic'
 
 Instant patch ! Note how the default phase of this changeset is (still)
 in "draft" state.
 "publishing" since they do not have the notion of non-public changesets
 (or mutable history).
 
-In the transition ... phase from older mercurial servers, this will
+During the transition from older mercurial servers to new ones, this will
 happen often, so be careful.
 
 Now let's come back to our patch. Next hour sees good progress and W.
 
     $ hg push # was done with a modern mercurial, draft phase is preserved
 
-The next day, Mr C.W, which arrives very very early, can immediately
+The next day, Mr C.W., who arrives very early, can immediately
 work out some glitches in the patch.
 
 He then starts another one, for ticket #43 and finally commits it.
 Add a changeset: ``commit``
 ------------------------------------------------------------
 
-Just use commit as usual. New changeset will be in the `draft` phase.
+Just use commit as usual. New changesets will be in the `draft` phase.
 
 Rewrite a changeset: ``amend``
 ------------------------------------------------------------
 
 
 .. [#] add this `-O` to graft instead of a dedicated command is probably
-       abusive. But this was very convenient for experimental purpose.
+       abusive. But this was very convenient for experimental purposes.
        This will likely change in non experimental release.
 
 Delete a changeset: ``kill``
 ------------------------------------------------------------
 
-A new ``kill`` command allows to remove a changeset.
+A new ``kill`` command allows removing a changeset.
 
 Just use ``hg kill <some-rev>``.
 
 .. note:: those command only exist for the convenience of getting qpush and qpop
           feeling back.
 
-collapse changesets: ``amend``
+Collapse changesets: ``amend``
 ------------------------------------------------------------
 
 you can use amend -c to collapse multiple changeset in a single one.
 
+Split changesets?
+-----------------------
+
+**TODO: Is it possible to split changesets, for example with record or crecord?**
+
 Move multiple changesets: ``rebase``
 ------------------------------------------------------------
 
-You can still use rebase to move whole part of the changeset graph at once.
+You can still use rebase to move a whole segment of the changeset graph together.
 
-.. warning:: Beware that rebasing obsolete changeset will result in new
-             conflicting version.
+.. warning:: Beware that rebasing obsolete changesets will result in
+             conflicting versions of the changesets.
 
 Stabilize history: ``stabilize``
 ------------------------------------------------------------
 those children you create *unstable* changesets and *suspended
 obsolete* changesets.
 
-When you are finished amending a given changeset you will want to
+When you are finished amending a given changeset, you will want to
 declare it stable, in other words rebase its former descendants on its
 newest version. This is not done automatically to avoid the
 proliferation of useless hidden changesets.
 
 .. warning:: stabilization does not handle deletion yet.
 
-.. warning:: obsolete currently rely on secret changeset to not exchange
-             obsolete and unstable changeset.
+.. warning:: obsolete currently relies on changesets in secret phase
+              to avoid exchanging obsolete and unstable changesets.
 
              XXX details issue here
 
 ------------------------------------------------------------
 
 Sometimes you need to create an obsolete marker by hand. This may happen when
-upstream has applied some of you patches for example.
+upstream has applied some of your patches for example.
 
 you can use ``hg kill --new <new-changeset> <old-changeset>`` to add obsolete
 marker.
 hg qseries
 ```````````
 
-All your work in progress are now real changeset all the time.
+All your work in progress is now in real changeset all the time.
 
-You can then use standard log to display them. You can use phase revset to
-display unfinished business only and template to have the same kind of compact
-output qseries have.
+You can use the standard log to display them. You can use the phase revset to
+display unfinished business only and templates to have the same kind of compact
+output qseries has.
 
 This will result in something like that::
 
 hg qnew
 ````````
 
-With evolve you handle standard changeset without additional overlay.
+With evolve you handle standard changesets without an additional overlay.
 
-Standard changeset are created using hg commit as usual.
+Standard changeset are created using hg commit as usual.::
 
   $ hg commit
 
 setting your changeset in the secret phase using the phase command.
 
 Note that you only need it for the first commit you want to be secret. Later
-commit will inherit their parents phase.
+commits will inherit their parents phase.
 
 If you always want your new commit to be in the secret phase, your should
 consider updating your configuration:
   $ hg amend
 
 
-This command takes the same option than commit  plus useful switch '-e' (--edit)
-to edit the commit message.
+This command takes the same options as commit, plus the switch '-e' (--edit)
+to edit the commit message in an editor.
 
-Amend have also a -c switch which allow you to make and explicit amending
-commit before rewriting a changeset.
+Amend have also a -c switch which allow you to make an explicit amending
+commit before rewriting a changeset.::
 
   $ hg record -m 'feature A'
   # oups, I forget some stuff
 hg qpush
 ````````
 
-When you rewrite changeset, descendant of rewritten changeset are marked as
-"out of sync". You new to rewrite them on top of the new version of their
+When you rewrite changesets, descendants of rewritten changesets are marked as
+"out of sync". You need to rewrite them on top of the new version of their
 ancestor.
 
-The evolution extension add a command to rewrite the next changeset:
+The evolution extension adds a command to rewrite the "out of sync" changesets:::
 
   $ hg stabilize
 
-You can also decide to do it manually using
+You can also decide to do it manually using::
 
   $ hg graft -O <old-version>
 
-or 
+or::
 
   $ hg rebase -r <revset for old version> -d .
 
 hg qrm
 ```````
 
-evolution introduce a new command to mark a changeset as "not wanted anymore".
+evolution introduce a new command to mark a changeset as "not wanted anymore".::
 
   $ hg kill <revset>
 
 or later::
 
   $ hg collapse # XXX not implemented
-
   $ hg rebase --collapse # XXX not tested
 
 
 hg qdiff
 `````````
 
-``odiff`` is an alias for `hg diff -r .^` it works as qdiff event outside mq.
+``odiff`` is an alias for `hg diff -r .^` it works as qdiff, but outside mq.
 
 
 
 hg qfinish and hg qimport
 ````````````````````````````
 
-Is not useful anymore if you want to controll exchange and mutability of
-changeset see the phase feature
+Is not necessary anymore. If you want to control exchange and mutability of
+changesets, see the phase feature
 
 
 
 hg qcommit
 ```````````````
 
-If you really need to send patches through a versionned mq patches you should
+If you really need to send patches through versioned mq patches, you should
 look at the qsync extension.
 :obsolete marker:
     express a relation from 0..n new changesets to 1 old changeset
 :obsolete changesets:
-    non public changeset target of a obsolete marker
+    non public changeset which are target of a obsolete marker
 
 :unstable changeset:
     changeset not obsolete but with obsolete ancestor
     diff between a changeset and it's obsolete parent
 
 :obsolete-tip:
-    obsolete-descendants not obsolete themself.
+    obsolete-descendants which are not obsolete themselves.
 
 :conflicting changeset:
     multiple obsolete-tip for an obsolete changeset through diverging obsolete
-    marker (no changeset split marker)
+    markers (no changeset split marker)
 from mercurial import commands
 from mercurial import util
 from mercurial.i18n import _
-from mercurial.commands import walkopts, commitopts, commitopts2, logopt
+from mercurial.commands import walkopts, commitopts, commitopts2, logopts
 from mercurial import hg
 
 ### util function