mercurial-crew-with-dirclash: comparison mercurial/hg.py

equal deleted inserted replaced

-:f94dbc6c7eaf
+:06154aff2b1a
 from node import *
 from repo import *
 from i18n import _
 import localrepo, bundlerepo, httprepo, sshrepo, statichttprepo
-import errno, lock, os, shutil, util, cmdutil
+import errno, lock, os, shutil, util, cmdutil, extensions
 import merge as _merge
 import verify as _verify
 def _local(path):
 return (os.path.isfile(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(':')
 return _lookup(repo).islocal(repo)
 except AttributeError:
 return False
 return repo.local()
-repo_setup_hooks = []
 def repository(ui, path='', create=False):
 """return a repository object for the specified path"""
 repo = _lookup(path).instance(ui, path, create)
 ui = getattr(repo, "ui", ui)
-for hook in repo_setup_hooks:
+for hook in extensions.setuphooks:
 hook(ui, repo)
 return repo
 def defaultdest(source):
 '''return default destination of clone if none is given'''
 self.dir_ = None
 def __del__(self):
 if self.dir_:
 self.rmtree(self.dir_, True)
-dir_cleanup = None
+src_lock = dest_lock = dir_cleanup = None
-if islocal(dest):
+try:
-dir_cleanup = DirCleanup(dest)
+if islocal(dest):
+dir_cleanup = DirCleanup(dest)
-abspath = origsource
-copy = False
+abspath = origsource
-if src_repo.local() and islocal(dest):
+copy = False
-abspath = os.path.abspath(origsource)
+if src_repo.local() and islocal(dest):
-copy = not pull and not rev
+abspath = os.path.abspath(origsource)
+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:
-def force_copy(src, dst):
 try:
-util.copyfiles(src, dst)
+# we use a lock here because if we race with commit, we
-except OSError, inst:
+# can end up with extra data in the cloned revlogs that's
-if inst.errno != errno.ENOENT:
+# not pointed to by changesets, thus causing verify to
-raise
+# fail
+src_lock = src_repo.lock()
-src_store = os.path.realpath(src_repo.spath)
+except lock.LockException:
-if not os.path.exists(dest):
+copy = False
-os.mkdir(dest)
-dest_path = os.path.realpath(os.path.join(dest, ".hg"))
+if copy:
-os.mkdir(dest_path)
+def force_copy(src, dst):
-if src_repo.spath != src_repo.path:
+try:
-dest_store = os.path.join(dest_path, "store")
+util.copyfiles(src, dst)
-os.mkdir(dest_store)
+except OSError, inst:
+if inst.errno != errno.ENOENT:
+raise
+src_store = os.path.realpath(src_repo.spath)
+if not os.path.exists(dest):
+os.mkdir(dest)
+dest_path = os.path.realpath(os.path.join(dest, ".hg"))
+os.mkdir(dest_path)
+if src_repo.spath != src_repo.path:
+dest_store = os.path.join(dest_path, "store")
+os.mkdir(dest_store)
+else:
+dest_store = dest_path
+# copy the requires file
+force_copy(src_repo.join("requires"),
+os.path.join(dest_path, "requires"))
+# we lock here to avoid premature writing to the target
+dest_lock = lock.lock(os.path.join(dest_store, "lock"))
+files = ("data",
+"00manifest.d", "00manifest.i",
+"00changelog.d", "00changelog.i")
+for f in files:
+src = os.path.join(src_store, f)
+dst = os.path.join(dest_store, f)
+force_copy(src, dst)
+# we need to re-init the repo after manually copying the data
+# into it
+dest_repo = repository(ui, dest)
 else:
-dest_store = dest_path
+dest_repo = repository(ui, dest, create=True)
-# copy the requires file
-force_copy(src_repo.join("requires"),
+revs = None
-os.path.join(dest_path, "requires"))
+if rev:
-# we lock here to avoid premature writing to the target
+if 'lookup' not in src_repo.capabilities:
-dest_lock = lock.lock(os.path.join(dest_store, "lock"))
+raise util.Abort(_("src repository does not support revision "
+"lookup and so doesn't support clone by "
-files = ("data",
+"revision"))
-"00manifest.d", "00manifest.i",
+revs = [src_repo.lookup(r) for r in rev]
-"00changelog.d", "00changelog.i")
-for f in files:
+if dest_repo.local():
-src = os.path.join(src_store, f)
+dest_repo.clone(src_repo, heads=revs, stream=stream)
-dst = os.path.join(dest_store, f)
+elif src_repo.local():
-force_copy(src, dst)
+src_repo.push(dest_repo, revs=revs)
+else:
-# we need to re-init the repo after manually copying the data
+raise util.Abort(_("clone from remote to remote not supported"))
-# into it
-dest_repo = repository(ui, dest)
-else:
-dest_repo = repository(ui, dest, create=True)
-revs = None
-if rev:
-if 'lookup' not in src_repo.capabilities:
-raise util.Abort(_("src repository does not support revision "
-"lookup and so doesn't support clone by "
-"revision"))
-revs = [src_repo.lookup(r) for r in rev]
 if dest_repo.local():
-dest_repo.clone(src_repo, heads=revs, stream=stream)
+fp = dest_repo.opener("hgrc", "w", text=True)
-elif src_repo.local():
+fp.write("[paths]\n")
-src_repo.push(dest_repo, revs=revs)
+fp.write("default = %s\n" % abspath)
-else:
+fp.close()
-raise util.Abort(_("clone from remote to remote not supported"))
+if update:
-if src_lock:
+try:
-src_lock.release()
+checkout = dest_repo.lookup("default")
+except:
-if dest_repo.local():
+checkout = dest_repo.changelog.tip()
-fp = dest_repo.opener("hgrc", "w", text=True)
+_update(dest_repo, checkout)
-fp.write("[paths]\n")
+if dir_cleanup:
-fp.write("default = %s\n" % abspath)
+dir_cleanup.close()
-fp.close()
+return src_repo, dest_repo
-if dest_lock:
+finally:
-dest_lock.release()
+del src_lock, dest_lock, dir_cleanup
-if update:
-try:
-checkout = dest_repo.lookup("default")
-except:
-checkout = dest_repo.changelog.tip()
-_update(dest_repo, checkout)
-if dir_cleanup:
-dir_cleanup.close()
-return src_repo, dest_repo
 def _showstats(repo, stats):
 stats = ((stats[0], _("updated")),
 (stats[1], _("merged")),
 (stats[2], _("removed")),
 def _update(repo, node): return update(repo, node)
 def update(repo, node):
 """update the working directory to node, merging linear changes"""
 pl = repo.parents()
-stats = _merge.update(repo, node, False, False, None, None)
+stats = _merge.update(repo, node, False, False, None)
 _showstats(repo, stats)
 if stats[3]:
 repo.ui.status(_("There are unresolved merges with"
 " locally modified files.\n"))
 if stats[1]:
 # len(pl)==1, otherwise _merge.update() would have raised util.Abort:
 repo.ui.status(_("  hg update %s\n  hg update %s\n")
 % (pl[0].rev(), repo.changectx(node).rev()))
 return stats[3]
-def clean(repo, node, wlock=None, show_stats=True):
+def clean(repo, node, show_stats=True):
 """forcibly switch the working directory to node, clobbering changes"""
-stats = _merge.update(repo, node, False, True, None, wlock)
+stats = _merge.update(repo, node, False, True, None)
 if show_stats: _showstats(repo, stats)
 return stats[3]
-def merge(repo, node, force=None, remind=True, wlock=None):
+def merge(repo, node, force=None, remind=True):
 """branch merge with node, resolving changes"""
-stats = _merge.update(repo, node, True, force, False, wlock)
+stats = _merge.update(repo, node, True, force, False)
 _showstats(repo, stats)
 if stats[3]:
 pl = repo.parents()
 repo.ui.status(_("There are unresolved merges,"
 " you can redo the full merge using:\n"
 % (pl[0].rev(), pl[1].rev()))
 elif remind:
 repo.ui.status(_("(branch merge, don't forget to commit)\n"))
 return stats[3]
-def revert(repo, node, choose, wlock):
+def revert(repo, node, choose):
 """revert changes to revision in node without updating dirstate"""
-return _merge.update(repo, node, False, True, choose, wlock)[3]
+return _merge.update(repo, node, False, True, choose)[3]
 def verify(repo):
 """verify the consistency of a repository"""
 return _verify.verify(repo)

changeset 5124	06154aff2b1a
parent 4961	126f527b3ba3
child 5180	0d5d03844927
child 5184	92236732d5a1