- monotone cat file id
- monotone cat file rid path
- monotone cat manifest
- monotone cat manifest id
- monotone cat revision
- monotone cat revision id
-
These commands write the contents of a specific file, manifest or
revision id to standard output, or the contents of the file
path as it was at revision rid. They are useful if you wish
to inspect a version without checking it out into your working copy. An
unspecified manifest or revision id is allowed from within a
working copy and refers to the current manifest or revision.
- monotone checkout id directory
- monotone co id directory
- monotone --branch=branchname checkout directory
- monotone --branch=branchname co directory
-
These commands copy a revision id out of your database, writing
the string id into the file
directory/MT/revision. These commands then copy every
file version listed in the revision's manifest to paths under
directory. For example, if the revision's manifest contains
these entries:
84e2c30a2571bd627918deee1e6613d34e64a29e Makefile
c61af2e67eb9b81e46357bb3c409a9a53a7cdfc6 include/hello.h
97dfc6fd4f486df95868d85b4b81197014ae2a84 src/hello.c
Then the following files are created:
directory/Makefile
directory/include/hello.h
directory/src/hello.c
If you wish to checkout in the current directory, you can
supply the special name . (a single period) for
directory.
If no id is provided, as in the latter two commands, you
must provide a branchname; monotone will attempt to infer
id as the unique head of branchname if it exists.
- monotone disapprove id
-
This command records a disapproval of the changes between id's
ancestor and id. It does this by committing the inverse
changes as a new revision descending from id. The new revision
will show up as a new head and thus a subsequent merge will
incorporate the inverse of the disapproved changes in the other head(s).
Note that this command only works if id has exactly one ancestor.
- monotone heads --branch=branchname
- This command lists the “heads” of branchname.
The “heads” of a branch is the set of revisions which are members of
the branch, but which have no descendants. These revisions are
generally the “newest” revisions committed by you or your
colleagues, at least in terms of ancestry. The heads of a branch may
not be the newest revisions, in terms of time, but synchronization of
computer clocks is not reliable, so monotone usually ignores time.
- monotone merge --branch=branchname
- This command merges the “heads” of branchname, if there are
multiple heads, and commits the results to the database, marking the
resulting merged revision as a member of branchname. The merged
revision will contain each of the head revision IDs as ancestors.
Merging is performed by repeated pairwise merges: two heads are
selected, then their least common ancestor is located in the ancestry
graph and these 3 revisions are provided to the built-in 3-way merge
algorithm. The process then repeats for each additional head, using
the result of each previous merge as an input to the next.
- monotone propagate sourcebranch destbranch
- This command takes a unique head from sourcebranch and merges it
with a unique head of destbranch, using the least common
ancestor of the two heads for a 3-way merge. The resulting revision is
committed to destbranch. If
either sourcebranch or destbranch has multiple heads,
propagate aborts, doing nothing.
The purpose of propagate is to copy all the changes on
sourcebranch, since the last propagate, to
destbranch. This command supports the idea of making separate
branches for medium-length development activities, such as
maintenance branches for stable software releases, trivial bug fix
branches, public contribution branches, or branches devoted to the
development of a single module within a larger project.
- monotone explicit_merge id id destbranch
- monotone explicit_merge id id ancestor destbranch
- This command merges exactly the two ids you give it, and places
the result in branch destbranch. It is useful when you need more
control over the merging process than
propagate
or merge
give you. For instance, if you have a branch with three heads, and you
only want to merge two of them, you can use this command. Or if you
have a branch with two heads, and you want to propagate one of them to
another branch, again, you can use this command. If the optional
ancestor argument is given, the merge uses that revision as the
common ancestor instead of the default ancestor.