view mercurial/help/merge-tools.txt @ 29375:fcaf20175b1b

demandimport: delay loading for "from a import b" with absolute_import

Before this patch, "from a import b" doesn't delay loading module "b",
if absolute_import is enabled, even though "from . import b" does.

For example:

  - it is assumed that extension X has "from P import M" for module M
    under package P with absolute_import feature

  - if importing module M is already delayed before loading extension
    X, loading module M in extension X is delayed until actually
    referring

    util, cmdutil, scmutil or so of Mercurial itself should be
    imported by "from . import M" style before loading extension X

  - otherwise, module M is loaded immediately at loading extension X,
    even if extension X itself isn't used at that "hg" command invocation

    Some minor modules (e.g. filemerge or so) of Mercurial itself
    aren't imported by "from . import M" style before loading
    extension X. And of course, external libraries aren't, too.

This might cause startup performance problem of hg command, because
many bundled extensions already enable absolute_import feature.

To delay loading module for "from a import b" with absolute_import
feature, this patch does below in "from a (or .a) import b" with
absolute_import case:

  1. import root module of "name" by system built-in __import__
     (referred as _origimport)

  2. recurse down the module chain for hierarchical "name"

     This logic can be shared with non absolute_import
     case. Therefore, this patch also centralizes it into chainmodules().

  3. and fall through to process elements in "fromlist" for the leaf
     module of "name"

     Processing elements in "fromlist" is executed in the code path
     after "if _pypy: .... else: ..." clause. Therefore, this patch
     replaces "if _pypy:" with "elif _pypy:" to share it.

At 4f1144c3c72b introducing original "work around" for "from a import
b" case, elements in "fromlist" were imported with "level=level". But
"level" might be grater than 1 (e.g. level=2 in "from .. import b"
case) at demandimport() invocation, and importing direct sub-module in
"fromlist" with level grater than 1 causes unexpected result.

IMHO, this seems main reason of "errors for unknown reason" described
in 4f1144c3c72b, and we don't have to worry about it, because this
issue was already fixed by 78d05778907b.

This is reason why this patch removes "errors for unknown reasons"
comment.

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:

.. internaltoolsmarker

Internal tools are always available and do not require a GUI but will by default
not handle symlinks or binary files.

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. Here, binary capabilities of the
   merge tool are not considered.

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. The merge of the file fails and must be resolved before commit.

.. 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 Mercurial will 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.