merge-tools: fixed typos

Spotted by Patrick Mézard.

doc/gendoc.py

@@ -1,167 +1,167
 import os, sys, textwrap
 # import from the live mercurial repo
 sys.path.insert(0, "..")
 # fall back to pure modules if required C extensions are not available
 sys.path.append(os.path.join('..', 'mercurial', 'pure'))
 from mercurial import demandimport; demandimport.enable()
 from mercurial import encoding
 from mercurial.commands import table, globalopts
 from mercurial.i18n import _
 from mercurial.help import helptable
 from mercurial import extensions
 
 def get_desc(docstr):
     if not docstr:
         return "", ""
     # sanitize
     docstr = docstr.strip("\n")
     docstr = docstr.rstrip()
     shortdesc = docstr.splitlines()[0].strip()
 
     i = docstr.find("\n")
     if i != -1:
         desc = docstr[i + 2:]
     else:
         desc = shortdesc
 
     desc = textwrap.dedent(desc)
 
     return (shortdesc, desc)
 
 def get_opts(opts):
     for opt in opts:
         if len(opt) == 5:
             shortopt, longopt, default, desc, optlabel = opt
         else:
             shortopt, longopt, default, desc = opt
         allopts = []
         if shortopt:
             allopts.append("-%s" % shortopt)
         if longopt:
             allopts.append("--%s" % longopt)
         desc += default and _(" (default: %s)") % default or ""
         yield(", ".join(allopts), desc)
 
 def get_cmd(cmd, cmdtable):
     d = {}
     attr = cmdtable[cmd]
     cmds = cmd.lstrip("^").split("|")
 
     d['cmd'] = cmds[0]
     d['aliases'] = cmd.split("|")[1:]
     d['desc'] = get_desc(attr[0].__doc__)
     d['opts'] = list(get_opts(attr[1]))
 
     s = 'hg ' + cmds[0]
     if len(attr) > 2:
         if not attr[2].startswith('hg'):
             s += ' ' + attr[2]
         else:
             s = attr[2]
     d['synopsis'] = s.strip()
 
     return d
 
 def section(ui, s):
     ui.write("%s\n%s\n\n" % (s, "-" * encoding.colwidth(s)))
 
 def subsection(ui, s):
     ui.write("%s\n%s\n\n" % (s, '"' * encoding.colwidth(s)))
 
 def subsubsection(ui, s):
     ui.write("%s\n%s\n\n" % (s, "." * encoding.colwidth(s)))
 
 def subsubsubsection(ui, s):
     ui.write("%s\n%s\n\n" % (s, "#" * encoding.colwidth(s)))
 
 
 def show_doc(ui):
     # print options
     section(ui, _("Options"))
     for optstr, desc in get_opts(globalopts):
         ui.write("%s\n%s\n\n" % (optstr, desc))
 
     # print cmds
     section(ui, _("Commands"))
     commandprinter(ui, table, subsection)
 
     # print topics
     for names, sec, doc in helptable:
         for name in names:
             ui.write(".. _%s:\n" % name)
         ui.write("\n")
         section(ui, sec)
         if hasattr(doc, '__call__'):
             doc = doc()
         ui.write(doc)
         ui.write("\n")
 
     section(ui, _("Extensions"))
-    ui.write(_("This section contains help for extensions that is distributed "
+    ui.write(_("This section contains help for extensions that are distributed "
                "together with Mercurial. Help for other extensions is available "
                "in the help system."))
     ui.write("\n\n"
              ".. contents::\n"
              "   :class: htmlonly\n"
              "   :local:\n"
              "   :depth: 1\n\n")
 
     for extensionname in sorted(allextensionnames()):
         mod = extensions.load(None, extensionname, None)
         subsection(ui, extensionname)
         ui.write("%s\n\n" % mod.__doc__)
         cmdtable = getattr(mod, 'cmdtable', None)
         if cmdtable:
             subsubsection(ui, _('Commands'))
             commandprinter(ui, cmdtable, subsubsubsection)
 
 def commandprinter(ui, cmdtable, sectionfunc):
     h = {}
     for c, attr in cmdtable.items():
         f = c.split("|")[0]
         f = f.lstrip("^")
         h[f] = c
     cmds = h.keys()
     cmds.sort()
 
     for f in cmds:
         if f.startswith("debug"):
             continue
         d = get_cmd(h[f], cmdtable)
         sectionfunc(ui, d['cmd'])
         # synopsis
         ui.write("``%s``\n" % d['synopsis'].replace("hg ","", 1))
         ui.write("\n")
         # description
         ui.write("%s\n\n" % d['desc'][1])
         # options
         opt_output = list(d['opts'])
         if opt_output:
             opts_len = max([len(line[0]) for line in opt_output])
             ui.write(_("options:\n\n"))
             for optstr, desc in opt_output:
                 if desc:
                     s = "%-*s  %s" % (opts_len, optstr, desc)
                 else:
                     s = optstr
                 ui.write("%s\n" % s)
             ui.write("\n")
         # aliases
         if d['aliases']:
             ui.write(_("    aliases: %s\n\n") % " ".join(d['aliases']))
 
 
 def allextensionnames():
     extensionnames = []
 
     extensionsdictionary = extensions.enabled()[0]
     extensionnames.extend(extensionsdictionary.keys())
 
     extensionsdictionary = extensions.disabled()[0]
     extensionnames.extend(extensionsdictionary.keys())
 
     return extensionnames
 
 
 if __name__ == "__main__":
     show_doc(sys.stdout)

mercurial/help/merge-tools.txt

@@ -1,85 +1,86
 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.
 
 The merge tools are used both for :hg:`resolve` and :hg:`merge`.
 
-Usually, the merge tool tries to automatically, by combining all the
-non-overlapping changes that occurred separately in the two different
+Usually, the merge tool tries to automatically reconcile the files by
+combining all the 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. External merge tools
 and their properties and usage is configured in merge-tools section -
 see hgrc(5).
 
 There are a some internal merge tools which can be used. The internal
 merge tools are:
 
 ``internal:merge``
    Uses the internal non-interactive merge tool for merging files.
 
 ``internal:fail``
    Rather than attempting to merge files that were modified on both
    branches, it marks these files as unresolved. Then the resolve
    command must be used to mark files resolved.
 
 ``internal:local``
    Uses the local version of files as the merged version.
 
 ``internal:other``
    Uses the remote version of files as the merged version.
 
 ``internal:prompt``
    Asks the user which of the local or the other version to keep as
    the merged version.
 
 ``internal: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 merged is name ``a.txt``,
-   these files will accordingly be named ``a.txt.local``,
+   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 the file to merge.
+   same directory as ``a.txt``.
 
 How Mercurial decides which merge program to use
 
 1. If the ``HGMERGE`` environment variable is present, it is used. If
    specified it must be either an executable path or the name of an
    application in your executable search path.
 
 2. If the filename of the file to be merged matches any of the
    patterns in the merge-patterns configuration section, then the
    corresponding merge tool is used, unless the file to be merged is a
    symlink. Here binary capabilities of the merge tool are not
    considered.
 
 3. If ui.merge is set, it is used.
 
 4. If any merge tools are present in the merge-tools configuration
    section, and any of the tools can be found on the system, the
    priority settings are used to determine which one to use. Binary,
    symlink and GUI capabilities do also have to match.
 
 5. If a program named ``hgmerge`` exists on the system, it is used.
 
 6. If the file to be merged is not binary and is not a symlink, then
    ``internal:merge`` is used.
 
 7. The merge fails.
 
 .. note::
    After selecting a merge program, Mercurial will by default attempt
    to merge the files using a simple merge algorithm first, to see if
    they can be merged without conflicts. Only if there are conflicting
    changes Mercurial will actually execute the merge program. Whether
-   to use the simple merge algorithm first can be controlled be the
-   premerge setting of the merge tool, which is enabled by default
+   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 symlink.
 
 See the merge-tools and ui sections of hgrc(5) for details on
 configuration of merge tools.