Next: , Up: Command Reference



5.1 Tree

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.