mercurial: comparison mercurial/hg.py

equal deleted inserted replaced

-:db8037e38085
+:a4c19a162615
 srcpeer = peer(ui, peeropts, source)
 else:
 srcpeer = source.peer()  # in case we were called with a localrepo
 branches = (None, branch or [])
 origsource = source = srcpeer.url()
-revs, checkout = addbranchrevs(srcpeer, srcpeer, branches, revs)
+srclock = destlock = cleandir = None
+destpeer = None
-if dest is None:
+try:
-dest = defaultdest(source)
+revs, checkout = addbranchrevs(srcpeer, srcpeer, branches, revs)
-if dest:
-ui.status(_(b"destination directory: %s\n") % dest)
+if dest is None:
-else:
+dest = defaultdest(source)
-dest = ui.expandpath(dest)
+if dest:
+ui.status(_(b"destination directory: %s\n") % dest)
-dest = util.urllocalpath(dest)
+else:
-source = util.urllocalpath(source)
+dest = ui.expandpath(dest)
-if not dest:
+dest = util.urllocalpath(dest)
-raise error.InputError(_(b"empty destination path is not valid"))
+source = util.urllocalpath(source)
-destvfs = vfsmod.vfs(dest, expandpath=True)
+if not dest:
-if destvfs.lexists():
+raise error.InputError(_(b"empty destination path is not valid"))
-if not destvfs.isdir():
-raise error.InputError(_(b"destination '%s' already exists") % dest)
+destvfs = vfsmod.vfs(dest, expandpath=True)
-elif destvfs.listdir():
+if destvfs.lexists():
-raise error.InputError(_(b"destination '%s' is not empty") % dest)
+if not destvfs.isdir():
+raise error.InputError(
-createopts = {}
+_(b"destination '%s' already exists") % dest
-narrow = False
-if storeincludepats is not None:
-narrowspec.validatepatterns(storeincludepats)
-narrow = True
-if storeexcludepats is not None:
-narrowspec.validatepatterns(storeexcludepats)
-narrow = True
-if narrow:
-# Include everything by default if only exclusion patterns defined.
-if storeexcludepats and not storeincludepats:
-storeincludepats = {b'path:.'}
-createopts[b'narrowfiles'] = True
-if depth:
-createopts[b'shallowfilestore'] = True
-if srcpeer.capable(b'lfs-serve'):
-# Repository creation honors the config if it disabled the extension, so
-# we can't just announce that lfs will be enabled.  This check avoids
-# saying that lfs will be enabled, and then saying it's an unknown
-# feature.  The lfs creation option is set in either case so that a
-# requirement is added.  If the extension is explicitly disabled but the
-# requirement is set, the clone aborts early, before transferring any
-# data.
-createopts[b'lfs'] = True
-if extensions.disabled_help(b'lfs'):
-ui.status(
-_(
-b'(remote is using large file support (lfs), but it is '
-b'explicitly disabled in the local configuration)\n'
 )
-)
+elif destvfs.listdir():
-else:
+raise error.InputError(
-ui.status(
+_(b"destination '%s' is not empty") % dest
-_(
-b'(remote is using large file support (lfs); lfs will '
-b'be enabled for this repository)\n'
 )
-)
+createopts = {}
-shareopts = shareopts or {}
+narrow = False
-sharepool = shareopts.get(b'pool')
-sharenamemode = shareopts.get(b'mode')
+if storeincludepats is not None:
-if sharepool and islocal(dest):
+narrowspec.validatepatterns(storeincludepats)
-sharepath = None
+narrow = True
-if sharenamemode == b'identity':
-# Resolve the name from the initial changeset in the remote
+if storeexcludepats is not None:
-# repository. This returns nullid when the remote is empty. It
+narrowspec.validatepatterns(storeexcludepats)
-# raises RepoLookupError if revision 0 is filtered or otherwise
+narrow = True
-# not available. If we fail to resolve, sharing is not enabled.
-try:
+if narrow:
-with srcpeer.commandexecutor() as e:
+# Include everything by default if only exclusion patterns defined.
-rootnode = e.callcommand(
+if storeexcludepats and not storeincludepats:
-b'lookup',
+storeincludepats = {b'path:.'}
-{
-b'key': b'0',
+createopts[b'narrowfiles'] = True
-},
-).result()
+if depth:
+createopts[b'shallowfilestore'] = True
-if rootnode != nullid:
-sharepath = os.path.join(sharepool, hex(rootnode))
+if srcpeer.capable(b'lfs-serve'):
-else:
+# Repository creation honors the config if it disabled the extension, so
+# we can't just announce that lfs will be enabled.  This check avoids
+# saying that lfs will be enabled, and then saying it's an unknown
+# feature.  The lfs creation option is set in either case so that a
+# requirement is added.  If the extension is explicitly disabled but the
+# requirement is set, the clone aborts early, before transferring any
+# data.
+createopts[b'lfs'] = True
+if extensions.disabled_help(b'lfs'):
+ui.status(
+_(
+b'(remote is using large file support (lfs), but it is '
+b'explicitly disabled in the local configuration)\n'
+)
+)
+else:
+ui.status(
+_(
+b'(remote is using large file support (lfs); lfs will '
+b'be enabled for this repository)\n'
+)
+)
+shareopts = shareopts or {}
+sharepool = shareopts.get(b'pool')
+sharenamemode = shareopts.get(b'mode')
+if sharepool and islocal(dest):
+sharepath = None
+if sharenamemode == b'identity':
+# Resolve the name from the initial changeset in the remote
+# repository. This returns nullid when the remote is empty. It
+# raises RepoLookupError if revision 0 is filtered or otherwise
+# not available. If we fail to resolve, sharing is not enabled.
+try:
+with srcpeer.commandexecutor() as e:
+rootnode = e.callcommand(
+b'lookup',
+{
+b'key': b'0',
+},
+).result()
+if rootnode != nullid:
+sharepath = os.path.join(sharepool, hex(rootnode))
+else:
+ui.status(
+_(
+b'(not using pooled storage: '
+b'remote appears to be empty)\n'
+)
+)
+except error.RepoLookupError:
 ui.status(
 _(
 b'(not using pooled storage: '
-b'remote appears to be empty)\n'
+b'unable to resolve identity of remote)\n'
 )
 )
-except error.RepoLookupError:
+elif sharenamemode == b'remote':
+sharepath = os.path.join(
+sharepool, hex(hashutil.sha1(source).digest())
+)
+else:
+raise error.Abort(
+_(b'unknown share naming mode: %s') % sharenamemode
+)
+# TODO this is a somewhat arbitrary restriction.
+if narrow:
 ui.status(
-_(
+_(b'(pooled storage not supported for narrow clones)\n')
-b'(not using pooled storage: '
-b'unable to resolve identity of remote)\n'
-)
 )
-elif sharenamemode == b'remote':
+sharepath = None
-sharepath = os.path.join(
-sharepool, hex(hashutil.sha1(source).digest())
+if sharepath:
-)
+return clonewithshare(
-else:
+ui,
-raise error.Abort(
+peeropts,
-_(b'unknown share naming mode: %s') % sharenamemode
+sharepath,
-)
+source,
+srcpeer,
-# TODO this is a somewhat arbitrary restriction.
+dest,
-if narrow:
+pull=pull,
-ui.status(_(b'(pooled storage not supported for narrow clones)\n'))
+rev=revs,
-sharepath = None
+update=update,
+stream=stream,
-if sharepath:
+)
-return clonewithshare(
-ui,
+srcrepo = srcpeer.local()
-peeropts,
-sharepath,
-source,
-srcpeer,
-dest,
-pull=pull,
-rev=revs,
-update=update,
-stream=stream,
-)
-srclock = destlock = cleandir = None
-srcrepo = srcpeer.local()
-try:
 abspath = origsource
 if islocal(origsource):
 abspath = os.path.abspath(util.urllocalpath(origsource))
 if islocal(dest):
 release(srclock, destlock)
 if cleandir is not None:
 shutil.rmtree(cleandir, True)
 if srcpeer is not None:
 srcpeer.close()
+if destpeer and destpeer.local() is None:
+destpeer.close()
 return srcpeer, destpeer
 def _showstats(repo, stats, quietempty=False):
 if quietempty and stats.isempty():
 (remoterepo, incomingchangesetlist, displayer) parameters,
 and is supposed to contain only code that can't be unified.
 """
 source, branches = parseurl(ui.expandpath(source), opts.get(b'branch'))
 other = peer(repo, opts, source)
-ui.status(_(b'comparing with %s\n') % util.hidepassword(source))
+cleanupfn = other.close
-revs, checkout = addbranchrevs(repo, other, branches, opts.get(b'rev'))
-if revs:
-revs = [other.lookup(rev) for rev in revs]
-other, chlist, cleanupfn = bundlerepo.getremotechanges(
-ui, repo, other, revs, opts[b"bundle"], opts[b"force"]
-)
 try:
+ui.status(_(b'comparing with %s\n') % util.hidepassword(source))
+revs, checkout = addbranchrevs(repo, other, branches, opts.get(b'rev'))
+if revs:
+revs = [other.lookup(rev) for rev in revs]
+other, chlist, cleanupfn = bundlerepo.getremotechanges(
+ui, repo, other, revs, opts[b"bundle"], opts[b"force"]
+)
 if not chlist:
 ui.status(_(b"no changes found\n"))
 return subreporecurse()
 ui.pager(b'incoming')
 displayer = logcmdutil.changesetdisplayer(
 revs, checkout = addbranchrevs(repo, repo, branches, opts.get(b'rev'))
 if revs:
 revs = [repo[rev].node() for rev in scmutil.revrange(repo, revs)]
 other = peer(repo, opts, dest)
-outgoing = discovery.findcommonoutgoing(
+try:
-repo, other, revs, force=opts.get(b'force')
+outgoing = discovery.findcommonoutgoing(
-)
+repo, other, revs, force=opts.get(b'force')
-o = outgoing.missing
+)
-if not o:
+o = outgoing.missing
-scmutil.nochangesfound(repo.ui, repo, outgoing.excluded)
+if not o:
-return o, other
+scmutil.nochangesfound(repo.ui, repo, outgoing.excluded)
+return o, other
+except:  # re-raises
+other.close()
+raise
 def outgoing(ui, repo, dest, opts):
 def recurse():
 ret = 1
 ret = min(ret, sub.outgoing(ui, dest, opts))
 return ret
 limit = logcmdutil.getlimit(opts)
 o, other = _outgoing(ui, repo, dest, opts)
-if not o:
+try:
+if not o:
+cmdutil.outgoinghooks(ui, repo, other, opts, o)
+return recurse()
+if opts.get(b'newest_first'):
+o.reverse()
+ui.pager(b'outgoing')
+displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
+count = 0
+for n in o:
+if limit is not None and count >= limit:
+break
+parents = [p for p in repo.changelog.parents(n) if p != nullid]
+if opts.get(b'no_merges') and len(parents) == 2:
+continue
+count += 1
+displayer.show(repo[n])
+displayer.close()
 cmdutil.outgoinghooks(ui, repo, other, opts, o)
-return recurse()
+recurse()
+return 0  # exit code is zero since we found outgoing changes
-if opts.get(b'newest_first'):
+finally:
-o.reverse()
+other.close()
-ui.pager(b'outgoing')
-displayer = logcmdutil.changesetdisplayer(ui, repo, opts)
-count = 0
-for n in o:
-if limit is not None and count >= limit:
-break
-parents = [p for p in repo.changelog.parents(n) if p != nullid]
-if opts.get(b'no_merges') and len(parents) == 2:
-continue
-count += 1
-displayer.show(repo[n])
-displayer.close()
-cmdutil.outgoinghooks(ui, repo, other, opts, o)
-recurse()
-return 0  # exit code is zero since we found outgoing changes
 def verify(repo, level=None):
 """verify the consistency of a repository"""
 ret = verifymod.verify(repo, level=level)

changeset 46663	a4c19a162615
parent 46314	95a615dd77bf
child 46720	66fb04552122