Merge: combine force and forcemerge arguments

mercurial/hg.py

@@ -1,230 +1,230
 # hg.py - repository classes for mercurial
 #
 # Copyright 2005 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import *
 from repo import *
 from demandload import *
 from i18n import gettext as _
 demandload(globals(), "localrepo bundlerepo httprepo sshrepo statichttprepo")
 demandload(globals(), "errno lock os shutil util merge@_merge verify@_verify")
 
 def _local(path):
     return (os.path.isfile(path and util.drop_scheme('file', path)) and
             bundlerepo or localrepo)
 
 schemes = {
     'bundle': bundlerepo,
     'file': _local,
     'hg': httprepo,
     'http': httprepo,
     'https': httprepo,
     'old-http': statichttprepo,
     'ssh': sshrepo,
     'static-http': statichttprepo,
     }
 
 def _lookup(path):
     scheme = 'file'
     if path:
         c = path.find(':')
         if c > 0:
             scheme = path[:c]
     thing = schemes.get(scheme) or schemes['file']
     try:
         return thing(path)
     except TypeError:
         return thing
 
 def islocal(repo):
     '''return true if repo or path is local'''
     if isinstance(repo, str):
         try:
             return _lookup(repo).islocal(repo)
         except AttributeError:
             return False
     return repo.local()
 
 def repository(ui, path=None, create=False):
     """return a repository object for the specified path"""
     return _lookup(path).instance(ui, path, create)
 
 def defaultdest(source):
     '''return default destination of clone if none is given'''
     return os.path.basename(os.path.normpath(source))
 
 def clone(ui, source, dest=None, pull=False, rev=None, update=True,
           stream=False):
     """Make a copy of an existing repository.
 
     Create a copy of an existing repository in a new directory.  The
     source and destination are URLs, as passed to the repository
     function.  Returns a pair of repository objects, the source and
     newly created destination.
 
     The location of the source is added to the new repository's
     .hg/hgrc file, as the default to be used for future pulls and
     pushes.
 
     If an exception is raised, the partly cloned/updated destination
     repository will be deleted.
 
     Arguments:
 
     source: repository object or URL
 
     dest: URL of destination repository to create (defaults to base
     name of source repository)
 
     pull: always pull from source repository, even in local case
 
     stream: stream raw data uncompressed from repository (fast over
     LAN, slow over WAN)
 
     rev: revision to clone up to (implies pull=True)
 
     update: update working directory after clone completes, if
     destination is local repository
     """
     if isinstance(source, str):
         src_repo = repository(ui, source)
     else:
         src_repo = source
         source = src_repo.url()
 
     if dest is None:
         dest = defaultdest(source)
 
     def localpath(path):
         if path.startswith('file://'):
             return path[7:]
         if path.startswith('file:'):
             return path[5:]
         return path
 
     dest = localpath(dest)
     source = localpath(source)
 
     if os.path.exists(dest):
         raise util.Abort(_("destination '%s' already exists"), dest)
 
     class DirCleanup(object):
         def __init__(self, dir_):
             self.rmtree = shutil.rmtree
             self.dir_ = dir_
         def close(self):
             self.dir_ = None
         def __del__(self):
             if self.dir_:
                 self.rmtree(self.dir_, True)
 
     dest_repo = None
     try:
         dest_repo = repository(ui, dest)
         raise util.Abort(_("destination '%s' already exists." % dest))
     except RepoError:
         dest_repo = repository(ui, dest, create=True)
 
     dest_path = None
     dir_cleanup = None
     if dest_repo.local():
         dest_path = os.path.realpath(dest_repo.root)
         dir_cleanup = DirCleanup(dest_path)
 
     abspath = source
     copy = False
     if src_repo.local() and dest_repo.local():
         abspath = os.path.abspath(source)
         copy = not pull and not rev
 
     src_lock, dest_lock = None, None
     if copy:
         try:
             # we use a lock here because if we race with commit, we
             # can end up with extra data in the cloned revlogs that's
             # not pointed to by changesets, thus causing verify to
             # fail
             src_lock = src_repo.lock()
         except lock.LockException:
             copy = False
 
     if copy:
         # we lock here to avoid premature writing to the target
         dest_lock = lock.lock(os.path.join(dest_path, ".hg", "lock"))
 
         # we need to remove the (empty) data dir in dest so copyfiles
         # can do its work
         os.rmdir(os.path.join(dest_path, ".hg", "data"))
         files = "data 00manifest.d 00manifest.i 00changelog.d 00changelog.i"
         for f in files.split():
             src = os.path.join(source, ".hg", f)
             dst = os.path.join(dest_path, ".hg", f)
             try:
                 util.copyfiles(src, dst)
             except OSError, inst:
                 if inst.errno != errno.ENOENT:
                     raise
 
         # we need to re-init the repo after manually copying the data
         # into it
         dest_repo = repository(ui, dest)
 
     else:
         revs = None
         if rev:
             if not src_repo.local():
                 raise util.Abort(_("clone by revision not supported yet "
                                    "for remote repositories"))
             revs = [src_repo.lookup(r) for r in rev]
 
         if dest_repo.local():
             dest_repo.clone(src_repo, heads=revs, stream=stream)
         elif src_repo.local():
             src_repo.push(dest_repo, revs=revs)
         else:
             raise util.Abort(_("clone from remote to remote not supported"))
 
     if src_lock:
         src_lock.release()
 
     if dest_repo.local():
         fp = dest_repo.opener("hgrc", "w", text=True)
         fp.write("[paths]\n")
         fp.write("default = %s\n" % abspath)
         fp.close()
 
         if dest_lock:
             dest_lock.release()
 
         if update:
             _merge.update(dest_repo, dest_repo.changelog.tip())
     if dir_cleanup:
         dir_cleanup.close()
 
     return src_repo, dest_repo
 
 def update(repo, node):
     """update the working directory to node, merging linear changes"""
     return _merge.update(repo, node)
 
 def clean(repo, node, wlock=None, show_stats=True):
     """forcibly switch the working directory to node, clobbering changes"""
     return _merge.update(repo, node, force=True, wlock=wlock,
                          show_stats=show_stats)
 
 def merge(repo, node, force=None, remind=True, wlock=None):
     """branch merge with node, resolving changes"""
-    return _merge.update(repo, node, branchmerge=True, forcemerge=force,
+    return _merge.update(repo, node, branchmerge=True, force=force,
                          remind=remind, wlock=wlock)
 
 def revert(repo, node, choose, wlock):
     """revert changes to revision in node without updating dirstate"""
     return _merge.update(repo, node, force=True, partial=choose,
                          show_stats=False, wlock=wlock)
 
 def verify(repo):
     """verify the consistency of a repository"""
     return _verify.verify(repo)

mercurial/merge.py

@@ -1,334 +1,337
 # merge.py - directory-level update/merge handling for Mercurial
 #
 # Copyright 2006 Matt Mackall <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 
 from node import *
 from i18n import gettext as _
 from demandload import *
 demandload(globals(), "util os tempfile")
 
 def merge3(repo, fn, my, other, p1, p2):
     """perform a 3-way merge in the working directory"""
 
     def temp(prefix, node):
         pre = "%s~%s." % (os.path.basename(fn), prefix)
         (fd, name) = tempfile.mkstemp(prefix=pre)
         f = os.fdopen(fd, "wb")
         repo.wwrite(fn, fl.read(node), f)
         f.close()
         return name
 
     fl = repo.file(fn)
     base = fl.ancestor(my, other)
     a = repo.wjoin(fn)
     b = temp("base", base)
     c = temp("other", other)
 
     repo.ui.note(_("resolving %s\n") % fn)
     repo.ui.debug(_("file %s: my %s other %s ancestor %s\n") %
                           (fn, short(my), short(other), short(base)))
 
     cmd = (os.environ.get("HGMERGE") or repo.ui.config("ui", "merge")
            or "hgmerge")
     r = util.system('%s "%s" "%s" "%s"' % (cmd, a, b, c), cwd=repo.root,
                     environ={'HG_FILE': fn,
                              'HG_MY_NODE': p1,
                              'HG_OTHER_NODE': p2,
                              'HG_FILE_MY_NODE': hex(my),
                              'HG_FILE_OTHER_NODE': hex(other),
                              'HG_FILE_BASE_NODE': hex(base)})
     if r:
         repo.ui.warn(_("merging %s failed!\n") % fn)
 
     os.unlink(b)
     os.unlink(c)
     return r
 
 def update(repo, node, branchmerge=False, force=False, partial=None,
-           forcemerge=False, wlock=None, show_stats=True, remind=True):
+           wlock=None, show_stats=True, remind=True):
+
+    overwrite = force and not branchmerge
+    forcemerge = force and branchmerge
 
     if not wlock:
         wlock = repo.wlock()
 
     ### check phase
 
     pl = repo.dirstate.parents()
-    if not force and pl[1] != nullid:
+    if not overwrite and pl[1] != nullid:
         raise util.Abort(_("outstanding uncommitted merges"))
 
     p1, p2 = pl[0], node
     pa = repo.changelog.ancestor(p1, p2)
 
     # is there a linear path from p1 to p2?
     linear_path = (pa == p1 or pa == p2)
     if branchmerge and linear_path:
         raise util.Abort(_("there is nothing to merge, just use "
                            "'hg update' or look at 'hg heads'"))
 
-    if not force and not linear_path and not branchmerge:
-        raise util.Abort(_("this update spans a branch, use 'hg merge' "
+    if not overwrite and not linear_path and not branchmerge:
+        raise util.Abort(_("update spans branches, use 'hg merge' "
                            "or 'hg update -C' to lose changes"))
 
     modified, added, removed, deleted, unknown = repo.changes()
     if branchmerge and not forcemerge:
         if modified or added or removed:
             raise util.Abort(_("outstanding uncommitted changes"))
 
     m1n = repo.changelog.read(p1)[0]
     m2n = repo.changelog.read(p2)[0]
     man = repo.manifest.ancestor(m1n, m2n)
     m1 = repo.manifest.read(m1n)
     mf1 = repo.manifest.readflags(m1n)
     m2 = repo.manifest.read(m2n).copy()
     mf2 = repo.manifest.readflags(m2n)
     ma = repo.manifest.read(man)
     mfa = repo.manifest.readflags(man)
 
-    if not forcemerge and not force:
+    if not forcemerge and not overwrite:
         for f in unknown:
             if f in m2:
                 t1 = repo.wread(f)
                 t2 = repo.file(f).read(m2[f])
                 if cmp(t1, t2) != 0:
                     raise util.Abort(_("'%s' already exists in the working"
                                        " dir and differs from remote") % f)
 
     # resolve the manifest to determine which files
     # we care about merging
     repo.ui.note(_("resolving manifests\n"))
-    repo.ui.debug(_(" force %s branchmerge %s partial %s linear %s\n") %
-                  (force, branchmerge, partial and True or False, linear_path))
+    repo.ui.debug(_(" overwrite %s branchmerge %s partial %s linear %s\n") %
+                  (overwrite, branchmerge, partial and True or False, linear_path))
     repo.ui.debug(_(" ancestor %s local %s remote %s\n") %
                   (short(man), short(m1n), short(m2n)))
 
     merge = {}
     get = {}
     remove = []
 
     # construct a working dir manifest
     mw = m1.copy()
     mfw = mf1.copy()
     umap = dict.fromkeys(unknown)
 
     for f in added + modified + unknown:
         mw[f] = ""
         mfw[f] = util.is_exec(repo.wjoin(f), mfw.get(f, False))
 
     for f in deleted + removed:
         if f in mw:
             del mw[f]
 
         # If we're jumping between revisions (as opposed to merging),
         # and if neither the working directory nor the target rev has
         # the file, then we need to remove it from the dirstate, to
         # prevent the dirstate from listing the file when it is no
         # longer in the manifest.
         if not partial and linear_path and f not in m2:
             repo.dirstate.forget((f,))
 
     # Compare manifests
     for f, n in mw.iteritems():
         if partial and not partial(f):
             continue
         if f in m2:
             s = 0
 
             # is the wfile new since m1, and match m2?
             if f not in m1:
                 t1 = repo.wread(f)
                 t2 = repo.file(f).read(m2[f])
                 if cmp(t1, t2) == 0:
                     n = m2[f]
                 del t1, t2
 
             # are files different?
             if n != m2[f]:
                 a = ma.get(f, nullid)
                 # are both different from the ancestor?
                 if n != a and m2[f] != a:
                     repo.ui.debug(_(" %s versions differ, resolve\n") % f)
                     # merge executable bits
                     # "if we changed or they changed, change in merge"
                     a, b, c = mfa.get(f, 0), mfw[f], mf2[f]
                     mode = ((a^b) | (a^c)) ^ a
                     merge[f] = (m1.get(f, nullid), m2[f], mode)
                     s = 1
                 # are we clobbering?
                 # is remote's version newer?
                 # or are we going back in time?
-                elif force or m2[f] != a or (p2 == pa and mw[f] == m1[f]):
+                elif overwrite or m2[f] != a or (p2 == pa and mw[f] == m1[f]):
                     repo.ui.debug(_(" remote %s is newer, get\n") % f)
                     get[f] = m2[f]
                     s = 1
             elif f in umap or f in added:
                 # this unknown file is the same as the checkout
                 # we need to reset the dirstate if the file was added
                 get[f] = m2[f]
 
             if not s and mfw[f] != mf2[f]:
-                if force:
+                if overwrite:
                     repo.ui.debug(_(" updating permissions for %s\n") % f)
                     util.set_exec(repo.wjoin(f), mf2[f])
                 else:
                     a, b, c = mfa.get(f, 0), mfw[f], mf2[f]
                     mode = ((a^b) | (a^c)) ^ a
                     if mode != b:
                         repo.ui.debug(_(" updating permissions for %s\n")
                                       % f)
                         util.set_exec(repo.wjoin(f), mode)
             del m2[f]
         elif f in ma:
             if n != ma[f]:
                 r = _("d")
-                if not force and (linear_path or branchmerge):
+                if not overwrite and (linear_path or branchmerge):
                     r = repo.ui.prompt(
                         (_(" local changed %s which remote deleted\n") % f) +
                          _("(k)eep or (d)elete?"), _("[kd]"), _("k"))
                 if r == _("d"):
                     remove.append(f)
             else:
                 repo.ui.debug(_("other deleted %s\n") % f)
                 remove.append(f) # other deleted it
         else:
             # file is created on branch or in working directory
-            if force and f not in umap:
+            if overwrite and f not in umap:
                 repo.ui.debug(_("remote deleted %s, clobbering\n") % f)
                 remove.append(f)
             elif n == m1.get(f, nullid): # same as parent
                 if p2 == pa: # going backwards?
                     repo.ui.debug(_("remote deleted %s\n") % f)
                     remove.append(f)
                 else:
                     repo.ui.debug(_("local modified %s, keeping\n") % f)
             else:
                 repo.ui.debug(_("working dir created %s, keeping\n") % f)
 
     for f, n in m2.iteritems():
         if partial and not partial(f):
             continue
         if f[0] == "/":
             continue
         if f in ma and n != ma[f]:
             r = _("k")
-            if not force and (linear_path or branchmerge):
+            if not overwrite and (linear_path or branchmerge):
                 r = repo.ui.prompt(
                     (_("remote changed %s which local deleted\n") % f) +
                      _("(k)eep or (d)elete?"), _("[kd]"), _("k"))
             if r == _("k"):
                 get[f] = n
         elif f not in ma:
             repo.ui.debug(_("remote created %s\n") % f)
             get[f] = n
         else:
-            if force or p2 == pa: # going backwards?
+            if overwrite or p2 == pa: # going backwards?
                 repo.ui.debug(_("local deleted %s, recreating\n") % f)
                 get[f] = n
             else:
                 repo.ui.debug(_("local deleted %s\n") % f)
 
     del mw, m1, m2, ma
 
-    if force:
+    if overwrite:
         for f in merge:
             get[f] = merge[f][1]
         merge = {}
 
-    if linear_path or force:
+    if linear_path or overwrite:
         # we don't need to do any magic, just jump to the new rev
         p1, p2 = p2, nullid
 
     xp1 = hex(p1)
     xp2 = hex(p2)
     if p2 == nullid: xxp2 = ''
     else: xxp2 = xp2
 
     repo.hook('preupdate', throw=True, parent1=xp1, parent2=xxp2)
 
     # get the files we don't need to change
     files = get.keys()
     files.sort()
     for f in files:
         if f[0] == "/":
             continue
         repo.ui.note(_("getting %s\n") % f)
         t = repo.file(f).read(get[f])
         repo.wwrite(f, t)
         util.set_exec(repo.wjoin(f), mf2[f])
         if not partial:
             if branchmerge:
                 repo.dirstate.update([f], 'n', st_mtime=-1)
             else:
                 repo.dirstate.update([f], 'n')
 
     # merge the tricky bits
     unresolved = []
     files = merge.keys()
     files.sort()
     for f in files:
         repo.ui.status(_("merging %s\n") % f)
         my, other, flag = merge[f]
         ret = merge3(repo, f, my, other, xp1, xp2)
         if ret:
             unresolved.append(f)
         util.set_exec(repo.wjoin(f), flag)
         if not partial:
             if branchmerge:
                 # We've done a branch merge, mark this file as merged
                 # so that we properly record the merger later
                 repo.dirstate.update([f], 'm')
             else:
                 # We've update-merged a locally modified file, so
                 # we set the dirstate to emulate a normal checkout
                 # of that file some time in the past. Thus our
                 # merge will appear as a normal local file
                 # modification.
                 f_len = len(repo.file(f).read(other))
                 repo.dirstate.update([f], 'n', st_size=f_len, st_mtime=-1)
 
     remove.sort()
     for f in remove:
         repo.ui.note(_("removing %s\n") % f)
         util.audit_path(f)
         try:
             util.unlink(repo.wjoin(f))
         except OSError, inst:
             if inst.errno != errno.ENOENT:
                 repo.ui.warn(_("update failed to remove %s: %s!\n") %
                              (f, inst.strerror))
     if not partial:
         if branchmerge:
             repo.dirstate.update(remove, 'r')
         else:
             repo.dirstate.forget(remove)
 
     if not partial:
         repo.dirstate.setparents(p1, p2)
 
     if show_stats:
         stats = ((len(get), _("updated")),
                  (len(merge) - len(unresolved), _("merged")),
                  (len(remove), _("removed")),
                  (len(unresolved), _("unresolved")))
         note = ", ".join([_("%d files %s") % s for s in stats])
         repo.ui.status("%s\n" % note)
     if not partial:
         if branchmerge:
             if unresolved:
                 repo.ui.status(_("There are unresolved merges,"
                                 " you can redo the full merge using:\n"
                                 "  hg update -C %s\n"
                                 "  hg merge %s\n"
                                 % (repo.changelog.rev(p1),
                                     repo.changelog.rev(p2))))
             elif remind:
                 repo.ui.status(_("(branch merge, don't forget to commit)\n"))
         elif unresolved:
             repo.ui.status(_("There are unresolved merges with"
                              " locally modified files.\n"))
 
     repo.hook('update', parent1=xp1, parent2=xxp2, error=len(unresolved))
     return len(unresolved)