5 Obsolete marker them self

     5 Obsolete markers

     8 The mutable concept is based on the creation of **obsolete marker**. An obsolete

     8 The mutable concept is based on **obsolete markers**. Creating an obsolete

     9 marker register a relation between the old obsoleted changeset and its newer

     9 marker registers a relation between an old obsoleted changeset and its newer

    12 The old changesets is called **precursors**. Its newer version are called

    12 Old changesets are called **precursors** while their new versions are called

    13 *successors*. A marker always register a single *precursors* but can refer

    13 **successors**. A marker always registers a single *precursor* and:

    14 to:

    14 

    15 

    15 - no *successor*: the *precursor* is just discarded.

    16 - No *successors* at all if the *precursors* if just discarded.

    16 - one *successor*: the *precursor* has been rewritten

    17 - One *successor* at all if the *precursors* have been rewritten

    17 - multiple *successors*: the *precursor* were splits in multiple

    18 - Multiple *successors* if the *precursors* have been splitted in myltiple

    18   changesets.

    19   changeset.

    19 

    20 

    20 .. The *precursors* and *successors* terms can be used on changeset directy:

    21 The **precursors** and **successors** terms can be used on changeset directy:

    21 

    22 

    22 .. :precursors: of a changeset `A` are changesets used as *precursors* by

    23 :precursors: of a changeset `A` are changesets used as *precursors* by

    23 ..              obsolete marker using changeset `A` as *successors*

    24              obsolete marker using changeset `A` as *successors*

    24 

    25 

    25 .. :successors: of a changeset `B` are changesets used as *successors* by

    26 :successors: of a changeset `B` are changesets used as *successors* by

    26 ..              obsolete marker using changeset `B` as *precursors*

    27              obsolete marker using changeset `B` as *precursors*

    27 

    28 

    28 Chaining obsolete markers is allowed to rewrite a changeset that is already a

    29 *Precursors* and *successors* directly related within the same marker are called

    29 *successor*. This is a kind of *second order version control*.

    30 **direct precursors** and **direct successors** in ambiguous situation.

    30 To clarify ambiguous situations one can use **direct precursors** or

    31 

    31 **direct successors** to name changesets that are directly related.

    32 The set of all *obsolete markers* create a direct acyclic graph the same way

    32 

    33 standard *parent* and *children* relation do. In this graph we have:

    33 The set of all *obsolete markers* forms a direct acyclic graph the same way

    34 

    34 standard *parents*/*children* relation does. In this graph we have:

    35 :any precursors: of a `A` are transitive precursors of `A`. (*direct

    35 

    36                  precursors* of `A` and *precursors*  of *precursors*)

    36 :any precursors: are transitive precursors of a changeset: *direct precursors*

    37 

    37                  and *precursors* of *precursors*.

    38 :any successors: of a `A` are transitive successors of `A`. (*direct

    38 

    39                  successors* of `A` and *precursors*  of *precursors*)

    39 :any successors: are transitive successors of a changeset: *direct successors*

    40 

    40                  and *successors*  of *successors*)

    41 Obsolete markers may revert to changesets that are not known locally. *Direct

    41 

    42 precursors* of a changeset may be unknown locally. This is why we usually focus

    42 Obsolete markers may refer changesets that are not known locally.

    43 on the **first known precursors**  of changeset

    43 So, *direct precursors* of a changeset may be unknown locally.

    44 

    44 This is why we usually focus on the **first known precursors**  of the rewritten

    45 (The same apply for successors)

    45 changeset. The same apply for *successors*.

    46 

    46 

    47 Item in *Any successors* which are not *obsolete* are called **newest

    47 Changeset in *any successors* which are not **obsolete** are called

    48 successors** 

    48 **newest successors**..

    51           better distinction between direct-successors, any-successors.

    51           better distinction between *direct successors* and **any successors*.

    56 The following table describe name and behavior of changesets affected by

    56 The following table describes names and behaviors of changesets affected by

    57 obsolete marker. Left column describe generic category and right column are

    57 obsolete markers. The left column describes generic categories and the right

    58 about sub-category.

    58 columns are about sub-categories.

    64 | Changeset in either | Obsolete changesets are  | Extinct changesets are      |

    64 | Changeset in either | Obsolete changeset is    | *extinct* changeset is      |

    65 | *draft* or *secret* | mutable changeset used   | obsolete one with obsolete  |

    65 | *draft* or *secret* | *mutable* used as a      | *obsolete* which has only   |

    66 | phases.             | as a precursors.         | only descendants.           |

    66 | phase.              | *precursor*.             | *obsolete* descendants.     |

    67 |                     |                          |                             |

    67 |                     |                          |                             |

    68 |                     | A changeset is used as   | They can be safely:         |

    68 |                     | A changeset is used as   | They can safely be:         |

    69 |                     | a precursors when at     |                             |

    69 |                     | a *precursor* when at    |                             |

    71 |                     | refer to it in the       | - silently excluded from pp |

    71 |                     | marker refers to it      | - silently excluded from    |

    72 |                     | precursors field.        |   pull and push,t operation |

    72 |                     | as precursors.           |   pull and push operations  |

    73 |                     |                          | - ignored by most operation |

    73 |                     |                          | - mostly ignored            |

    74 |                     |                          | - garbage collected.        |

    74 |                     |                          | - garbage collected         |

    80 |                     |                          | Suspended changesets are    |

    80 |                     |                          | *suspended* changeset is    |

    81 |                     |                          | obsolete one with at least  |

    81 |                     |                          | *obsolete* with at least    |

    94 |                     | Troublesome commit have  | Unstable changesets are     |

    94 |                     | *troublesome* has        | *unstable* is a changeset   |

    95 |                     | unresolved issue caused  | changesets with obsolete    |

    95 |                     | unresolved issue caused  | with obsolete ancestors.    |

    96 |                     | by obsolete relations.   | ancestors.                  |

    96 |                     | by *obsolete* relations. |                             |

    97 |                     |                          |                             |

    97 |                     |                          |                             |

    98 |                     | Possible issues are      | They must be rebased on a   |

    98 |                     | Possible issues are      | It must be rebased on a     |

    99 |                     | listed in the next       | better base to solve the    |

    99 |                     | listed in the next       | non *troublesome* base to   |

   100 |                     | column. It is possible   | situation.                  |

   100 |                     | column. It is possible   | solve the problem.          |

   101 |                     | for troublesome          |                             |

   101 |                     | for *troublesome*        |                             |

   104 |                     | (eg: conflicting and     |                             |

   104 |                     | (a.k.a. conflicting and  |                             |

   108 |                     | name: unsettled,         |                             |

   108 |                     | names: unsettled,        |                             |

   109 |                     | troubled)                | Latecomer changesets are    |

   109 |                     | troubled)                | *latecomer* is a changeset  |

   110 |                     |                          | changesets that try to      |

   110 |                     |                          | that tries to be successor  |

   111 |                     |                          | be successors of public     |

   111 |                     |                          | of  public changesets.      |

   112 |                     |                          | changesets.                 |

   115 |                     |                          | be obsolete. Latecomer      |

   114 |                     |                          | be deleted and replace      |

   116 |                     |                          | changeset need to be        |

   115 |                     |                          | *latecomer*                 |

   117 |                     |                          | rewritten as an overlay     |

   116 |                     |                          | need to be converted into   |

   118 |                     |                          | to this public changeset.   |

   117 |                     |                          | an overlay to this public   |

   119 |                     |                          |                             |

   118 |                     |                          | changeset.                  |

   120 |                     |                          | (possible alternative names |

   119 |                     |                          |                             |

   120 |                     |                          | (possible alternative names:|

   127 |                     |                          | Conflicting changesets      |

   127 |                     |                          | *conflicting* is changeset  |

   128 |                     |                          | happen when multiple        |

   128 |                     |                          | that appears when multiple  |

   130 |                     |                          | of the same obsolete        |

   130 |                     |                          | of the same precursor.      |

   131 |                     |                          | changeset.                  |

   131 |                     |                          |                             |

   132 |                     |                          |                             |

   132 |                     |                          | *conflicting* are solved    |

   133 |                     |                          | Conflicting changesets are  |

   133 |                     |                          | through a three ways merge  |

   134 |                     |                          | resolve through a three     |

   134 |                     |                          | between the two             |

   135 |                     |                          | ways merging between the    |

   135 |                     |                          | *conflictings*,             |

   136 |                     |                          | two conflicting changesets, |

   141 |                     |                          | (Changeset splitting is     |

   140 |                     |                          | (*splitting* is             |

   166 | no effect on the precussors changeset (but may have effect on the            |

   165 | no effect on the precussors but may have effect on the successors.           |

   167 | successors)                                                                  |

   166 |                                                                              |

   168 |                                                                              |

   167 | When a *mutable* changeset becomes *immutable* (changing its phase from draft|

   169 | When a mutable changeset becomes immutable its is just *immutable* and loose |

   168 | to public) it is just *immutable* and loose any property of it's former      |

   170 | any property of it's former state.                                           |

   169 | state.                                                                       |

   171 |                                                                              |

   170 |                                                                              |

   172 | By phase property, once a changeset becomes a public immutable changeset,    |

   171 | The phase properties says that public changesets stay as *immutable* forever.|

   173 | you can expect it to remain as such forever.                                 |

   193 Mercurial already use the following terms:

   191 Mercurial core already uses the following terms:

   194 

   192 

   195 :amend: rewrite a changeset

   193 :amend: to rewrite a changeset

   196 :graft: copy a changeset

   194 :graft: to copy a changeset

   197 :rebase: move a changeset

   195 :rebase: to move a changeset

   203 remove files from a commit (and leave them as dirty in the working directory)

   201 Remove files from a commit (and leave them as dirty in the working directory)

   204 

   202 

   205 The evolve extension have an `uncommit` command that aims to replace most

   203 The *evolve* extension have an `uncommit` command that aims to replace most

   211 Collapse multiple changeset into one

   209 Collapse multiple changesets into a unique one.

   212 

   210 

   213 The evolve extensions *will* have a `fold` commands

   211 The *evolve* extension will have a `fold` command.

   220 This an important operation as it should replace strip in 95% of the case.

   218 This an important operation as it should mostly replace *strip*.

   221 

   219 

   222 alternative name:

   220 Alternative names:

   223 

   221 

   224 - kill: nice name for effect when you forget the "hg" in front on "hg kill".

   222 - kill: shall has funny effects when you forget "hg" in front of ``hg kill``.

   225 - obsolete: too vague, long and generic.

   223 - obsolete: too vague, too long and too generic.

   230 Automatically resolve troublesome changesets

   228 Automatically resolve *troublesome* changesets

   231 (unstable, latecomer and conflicting)

   229 (*unstable*, *latecomer* and *conflicting*)

   232 

   230 

   233 This is an important name as hg pull/pussh will suggest it the same way it

   231 This is an important name as hg pull/push will suggest it the same way it

   238 alternative name:

   236 alternative names: