moinsetup

Help

Merge Tools
"""""""""""

    To merge files Mercurial uses merge tools.
    
    A merge tool combines two different versions of a file into a merged
    file. Merge tools are given the two files and the greatest common
    ancestor of the two file versions, so they can determine the changes
    made on both branches.
    
    Merge tools are used both for :hg:`resolve`, :hg:`merge`, :hg:`update`,
    :hg:`backout` and in several extensions.
    
    Usually, the merge tool tries to automatically reconcile the files by
    combining all non-overlapping changes that occurred separately in
    the two different evolutions of the same initial base file. Furthermore, some
    interactive merge programs make it easier to manually resolve
    conflicting merges, either in a graphical way, or by inserting some
    conflict markers. Mercurial does not include any interactive merge
    programs but relies on external tools for that.
    
    Available merge tools
    =====================
    
    External merge tools and their properties are configured in the
    merge-tools configuration section - see hgrc(5) - but they can often just
    be named by their executable.
    
    A merge tool is generally usable if its executable can be found on the
    system and if it can handle the merge. The executable is found if it
    is an absolute or relative executable path or the name of an
    application in the executable search path. The tool is assumed to be
    able to handle the merge if it can handle symlinks if the file is a
    symlink, if it can handle binary files if the file is binary, and if a
    GUI is available if the tool requires a GUI.
    
    There are some internal merge tools which can be used. The internal
    merge tools are:
    
    ``:dump``
      Creates three versions of the files to merge, containing the
      contents of local, other and base. These files can then be used to
      perform a merge manually. If the file to be merged is named
      ``a.txt``, these files will accordingly be named ``a.txt.local``,
      ``a.txt.other`` and ``a.txt.base`` and they will be placed in the
      same directory as ``a.txt``.
      
      This implies premerge. Therefore, files aren't dumped, if premerge
      runs successfully. Use :forcedump to forcibly write files out.
      
      (actual capabilities: binary, symlink)
    
    ``:fail``
      Rather than attempting to merge files that were modified on both
      branches, it marks them as unresolved. The resolve command must be
      used to resolve these conflicts.
      
      (actual capabilities: binary, symlink)
    
    ``:forcedump``
      Creates three versions of the files as same as :dump, but omits premerge.
      
      (actual capabilities: binary, symlink)
    
    ``:local``
      Uses the local `p1()` version of files as the merged version.
      
      (actual capabilities: binary, symlink)
    
    ``:merge``
      Uses the internal non-interactive simple merge algorithm for merging
      files. It will fail if there are any conflicts and leave markers in
      the partially merged file. Markers will have two sections, one for each side
      of merge.
    
    ``:merge-local``
      Like :merge, but resolve all conflicts non-interactively in favor
      of the local `p1()` changes.
    
    ``:merge-other``
      Like :merge, but resolve all conflicts non-interactively in favor
      of the other `p2()` changes.
    
    ``:merge3``
      Uses the internal non-interactive simple merge algorithm for merging
      files. It will fail if there are any conflicts and leave markers in
      the partially merged file. Marker will have three sections, one from each
      side of the merge and one for the base content.
    
    ``:other``
      Uses the other `p2()` version of files as the merged version.
      
      (actual capabilities: binary, symlink)
    
    ``:prompt``
      Asks the user which of the local `p1()` or the other `p2()` version to
      keep as the merged version.
      
      (actual capabilities: binary, symlink)
    
    ``:tagmerge``
      Uses the internal tag merge algorithm (experimental).
    
    ``:union``
      Uses the internal non-interactive simple merge algorithm for merging
      files. It will use both left and right sides for conflict regions.
      No markers are inserted.
    
    Internal tools are always available and do not require a GUI but will
    by default not handle symlinks or binary files. See next section for
    detail about "actual capabilities" described above.
    
    Choosing a merge tool
    =====================
    
    Mercurial uses these rules when deciding which merge tool to use:
    
    1. If a tool has been specified with the --tool option to merge or resolve, it
       is used.  If it is the name of a tool in the merge-tools configuration, its
       configuration is used. Otherwise the specified tool must be executable by
       the shell.
    
    2. If the ``HGMERGE`` environment variable is present, its value is used and
       must be executable by the shell.
    
    3. If the filename of the file to be merged matches any of the patterns in the
       merge-patterns configuration section, the first usable merge tool
       corresponding to a matching pattern is used.
    
    4. If ui.merge is set it will be considered next. If the value is not the name
       of a configured tool, the specified value is used and must be executable by
       the shell. Otherwise the named tool is used if it is usable.
    
    5. If any usable merge tools are present in the merge-tools configuration
       section, the one with the highest priority is used.
    
    6. If a program named ``hgmerge`` can be found on the system, it is used - but
       it will by default not be used for symlinks and binary files.
    
    7. If the file to be merged is not binary and is not a symlink, then
       internal ``:merge`` is used.
    
    8. Otherwise, ``:prompt`` is used.
    
    For historical reason, Mercurial treats merge tools as below while
    examining rules above.
    
    ==== =============== ====== =======
    step specified via   binary symlink
    ==== =============== ====== =======
    1.   --tool          o/o    o/o
    2.   HGMERGE         o/o    o/o
    3.   merge-patterns  o/o(*) x/?(*)
    4.   ui.merge        x/?(*) x/?(*)
    ==== =============== ====== =======
    
    Each capability column indicates Mercurial behavior for
    internal/external merge tools at examining each rule.
    
    - "o": "assume that a tool has capability"
    - "x": "assume that a tool does not have capability"
    - "?": "check actual capability of a tool"
    
    If ``merge.strict-capability-check`` configuration is true, Mercurial
    checks capabilities of merge tools strictly in (*) cases above (= each
    capability column becomes "?/?"). It is false by default for backward
    compatibility.
    
    .. note::
    
       After selecting a merge program, Mercurial will by default attempt
       to merge the files using a simple merge algorithm first. Only if it doesn't
       succeed because of conflicting changes will Mercurial actually execute the
       merge program. Whether to use the simple merge algorithm first can be
       controlled by the premerge setting of the merge tool. Premerge is enabled by
       default unless the file is binary or a symlink.
    
    See the merge-tools and ui sections of hgrc(5) for details on the
    configuration of merge tools.