mercurial-scm/hg: comparison mercurial/subrepo.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 reporelpath = subrepoutil.reporelpath
 subrelpath = subrepoutil.subrelpath
 _abssource = subrepoutil._abssource
 propertycache = util.propertycache
 def _expandedabspath(path):
 '''
 get a path or url and if it is a path expand it and return an absolute path
 '''
 expandedpath = util.urllocalpath(util.expandpath(path))
 u = util.url(expandedpath)
 if not u.scheme:
 path = util.normpath(os.path.abspath(u.path))
 return path
 def _getstorehashcachename(remotepath):
 '''get a unique filename for the store hash cache of a remote repository'''
 return node.hex(hashlib.sha1(_expandedabspath(remotepath)).digest())[0:12]
 class SubrepoAbort(error.Abort):
 """Exception class used to avoid handling a subrepo error more than once"""
 def __init__(self, *args, **kw):
 self.subrepo = kw.pop(r'subrepo', None)
 self.cause = kw.pop(r'cause', None)
 error.Abort.__init__(self, *args, **kw)
 def annotatesubrepoerror(func):
 def decoratedmethod(self, *args, **kargs):
 try:
 res = func(self, *args, **kargs)
 except SubrepoAbort as ex:
 # This exception has already been handled
 raise ex
 except error.Abort as ex:
 subrepo = subrelpath(self)
-errormsg = (stringutil.forcebytestr(ex) + ' '
+errormsg = (
-+ _('(in subrepository "%s")') % subrepo)
+stringutil.forcebytestr(ex)
++ ' '
++ _('(in subrepository "%s")') % subrepo
+)
 # avoid handling this exception by raising a SubrepoAbort exception
-raise SubrepoAbort(errormsg, hint=ex.hint, subrepo=subrepo,
+raise SubrepoAbort(
-cause=sys.exc_info())
+errormsg, hint=ex.hint, subrepo=subrepo, cause=sys.exc_info()
+)
 return res
 return decoratedmethod
 def _updateprompt(ui, sub, dirty, local, remote):
 if dirty:
-msg = (_(' subrepository sources for %s differ\n'
+msg = _(
-'you can use (l)ocal source (%s) or (r)emote source (%s).\n'
+' subrepository sources for %s differ\n'
-'what do you want to do?'
+'you can use (l)ocal source (%s) or (r)emote source (%s).\n'
-'$$ &Local $$ &Remote')
+'what do you want to do?'
-% (subrelpath(sub), local, remote))
+'$$ &Local $$ &Remote'
+) % (subrelpath(sub), local, remote)
 else:
-msg = (_(' subrepository sources for %s differ (in checked out '
+msg = _(
-'version)\n'
+' subrepository sources for %s differ (in checked out '
-'you can use (l)ocal source (%s) or (r)emote source (%s).\n'
+'version)\n'
-'what do you want to do?'
+'you can use (l)ocal source (%s) or (r)emote source (%s).\n'
-'$$ &Local $$ &Remote')
+'what do you want to do?'
-% (subrelpath(sub), local, remote))
+'$$ &Local $$ &Remote'
+) % (subrelpath(sub), local, remote)
 return ui.promptchoice(msg, 0)
 def _sanitize(ui, vfs, ignore):
 for dirname, dirs, names in vfs.walk():
 for i, d in enumerate(dirs):
 if d.lower() == ignore:
 break
 if vfs.basename(dirname).lower() != '.hg':
 continue
 for f in names:
 if f.lower() == 'hgrc':
-ui.warn(_("warning: removing potentially hostile 'hgrc' "
+ui.warn(
-"in '%s'\n") % vfs.join(dirname))
+_(
+"warning: removing potentially hostile 'hgrc' "
+"in '%s'\n"
+)
+% vfs.join(dirname)
+)
 vfs.unlink(vfs.reljoin(dirname, f))
 def _auditsubrepopath(repo, path):
 # sanity check for potentially unsafe paths such as '~' and '$FOO'
 if path.startswith('~') or '$' in path or util.expandpath(path) != path:
-raise error.Abort(_('subrepo path contains illegal component: %s')
+raise error.Abort(
-% path)
+_('subrepo path contains illegal component: %s') % path
+)
 # auditor doesn't check if the path itself is a symlink
 pathutil.pathauditor(repo.root)(path)
 if repo.wvfs.islink(path):
 raise error.Abort(_("subrepo '%s' traverses symbolic link") % path)
 SUBREPO_ALLOWED_DEFAULTS = {
 'hg': True,
 'git': False,
 'svn': False,
 }
 def _checktype(ui, kind):
 # subrepos.allowed is a master kill switch. If disabled, subrepos are
 # disabled period.
 if not ui.configbool('subrepos', 'allowed', True):
-raise error.Abort(_('subrepos not enabled'),
+raise error.Abort(
-hint=_("see 'hg help config.subrepos' for details"))
+_('subrepos not enabled'),
+hint=_("see 'hg help config.subrepos' for details"),
+)
 default = SUBREPO_ALLOWED_DEFAULTS.get(kind, False)
 if not ui.configbool('subrepos', '%s:allowed' % kind, default):
-raise error.Abort(_('%s subrepos not allowed') % kind,
+raise error.Abort(
-hint=_("see 'hg help config.subrepos' for details"))
+_('%s subrepos not allowed') % kind,
+hint=_("see 'hg help config.subrepos' for details"),
+)
 if kind not in types:
 raise error.Abort(_('unknown subrepo type %s') % kind)
 def subrepo(ctx, path, allowwdir=False, allowcreate=True):
 """return instance of the right subrepo class for subrepo in path"""
 # subrepo inherently violates our import layering rules
 # because it wants to make repo objects from deep inside the stack
 # so we manually delay the circular imports to not break
 # scripts that don't use our demand-loading
 global hg
 from . import hg as h
 hg = h
 repo = ctx.repo()
 _auditsubrepopath(repo, path)
 state = ctx.substate[path]
 _checktype(repo.ui, state[2])
 if allowwdir:
 state = (state[0], ctx.subrev(path), state[2])
 return types[state[2]](ctx, path, state[:2], allowcreate)
 def nullsubrepo(ctx, path, pctx):
 """return an empty subrepo in pctx for the extant subrepo in ctx"""
 # subrepo inherently violates our import layering rules
 # because it wants to make repo objects from deep inside the stack
 # so we manually delay the circular imports to not break
 # scripts that don't use our demand-loading
 global hg
 from . import hg as h
 hg = h
 repo = ctx.repo()
 _auditsubrepopath(repo, path)
 state = ctx.substate[path]
 subrev = ''
 if state[2] == 'hg':
 subrev = "0" * 40
 return types[state[2]](pctx, path, (state[0], subrev), True)
 # subrepo classes need to implement the following abstract class:
 class abstractsubrepo(object):
 def __init__(self, ctx, path):
 """Initialize abstractsubrepo part
 ``ctx`` is the context referring this subrepository in the
 parent repository.
 of exception.
 This returns None, otherwise.
 """
 if self.dirty(ignoreupdate=ignoreupdate, missing=missing):
-return _('uncommitted changes in subrepository "%s"'
+return _('uncommitted changes in subrepository "%s"') % subrelpath(
-) % subrelpath(self)
+self
+)
 def bailifchanged(self, ignoreupdate=False, hint=None):
 """raise Abort if subrepository is ``dirty()``
 """
-dirtyreason = self.dirtyreason(ignoreupdate=ignoreupdate,
+dirtyreason = self.dirtyreason(ignoreupdate=ignoreupdate, missing=True)
-missing=True)
 if dirtyreason:
 raise error.Abort(dirtyreason, hint=hint)
 def basestate(self):
 """current working directory base state, disregarding .hgsubstate
 files = [f for f in self.files() if match(f)]
 else:
 files = self.files()
 total = len(files)
 relpath = subrelpath(self)
-progress = self.ui.makeprogress(_('archiving (%s)') % relpath,
+progress = self.ui.makeprogress(
-unit=_('files'), total=total)
+_('archiving (%s)') % relpath, unit=_('files'), total=total
+)
 progress.update(0)
 for name in files:
 flags = self.fileflags(name)
 mode = 'x' in flags and 0o755 or 0o644
 symlink = 'l' in flags
-archiver.addfile(prefix + name, mode, symlink,
+archiver.addfile(
-self.filedata(name, decode))
+prefix + name, mode, symlink, self.filedata(name, decode)
+)
 progress.increment()
 progress.complete()
 return total
 def walk(self, match):
 '''
 def forget(self, match, prefix, uipathfn, dryrun, interactive):
 return ([], [])
-def removefiles(self, matcher, prefix, uipathfn, after, force, subrepos,
+def removefiles(
-dryrun, warnings):
+self,
+matcher,
+prefix,
+uipathfn,
+after,
+force,
+subrepos,
+dryrun,
+warnings,
+):
 """remove the matched files from the subrepository and the filesystem,
 possibly by force and/or after the file has been removed from the
 filesystem.  Return 0 on success, 1 on any warning.
 """
-warnings.append(_("warning: removefiles not implemented (%s)")
+warnings.append(
-% self._path)
+_("warning: removefiles not implemented (%s)") % self._path
+)
 return 1
 def revert(self, substate, *pats, **opts):
-self.ui.warn(_('%s: reverting %s subrepos is unsupported\n')
+self.ui.warn(
-% (substate[0], substate[2]))
+_('%s: reverting %s subrepos is unsupported\n')
+% (substate[0], substate[2])
+)
 return []
 def shortid(self, revid):
 return revid
 @propertycache
 def _relpath(self):
 """return path to this subrepository as seen from outermost repository
 """
 return self.wvfs.reljoin(reporelpath(self._ctx.repo()), self._path)
 class hgsubrepo(abstractsubrepo):
 def __init__(self, ctx, path, state, allowcreate):
 super(hgsubrepo, self).__init__(ctx, path)
 self._state = state
 root = r.wjoin(util.localpath(path))
 create = allowcreate and not r.wvfs.exists('%s/.hg' % path)
 # repository constructor does expand variables in path, which is
 # unsafe since subrepo path might come from untrusted source.
 if os.path.realpath(util.expandpath(root)) != root:
-raise error.Abort(_('subrepo path contains illegal component: %s')
+raise error.Abort(
-% path)
+_('subrepo path contains illegal component: %s') % path
+)
 self._repo = hg.repository(r.baseui, root, create=create)
 if self._repo.root != root:
-raise error.ProgrammingError('failed to reject unsafe subrepo '
+raise error.ProgrammingError(
-'path: %s (expanded to %s)'
+'failed to reject unsafe subrepo '
-% (root, self._repo.root))
+'path: %s (expanded to %s)' % (root, self._repo.root)
+)
 # Propagate the parent's --hidden option
 if r is r.unfiltered():
 self._repo = self._repo.unfiltered()
 self._repo.vfs.write('hgrc', util.tonativeeol(''.join(lines)))
 @annotatesubrepoerror
 def add(self, ui, match, prefix, uipathfn, explicitonly, **opts):
-return cmdutil.add(ui, self._repo, match, prefix, uipathfn,
+return cmdutil.add(
-explicitonly, **opts)
+ui, self._repo, match, prefix, uipathfn, explicitonly, **opts
+)
 @annotatesubrepoerror
 def addremove(self, m, prefix, uipathfn, opts):
 # In the same way as sub directories are processed, once in a subrepo,
 # always entry any of its subrepos.  Don't corrupt the options that will
 @annotatesubrepoerror
 def cat(self, match, fm, fntemplate, prefix, **opts):
 rev = self._state[1]
 ctx = self._repo[rev]
-return cmdutil.cat(self.ui, self._repo, ctx, match, fm, fntemplate,
+return cmdutil.cat(
-prefix, **opts)
+self.ui, self._repo, ctx, match, fm, fntemplate, prefix, **opts
+)
 @annotatesubrepoerror
 def status(self, rev2, **opts):
 try:
 rev1 = self._state[1]
 ctx1 = self._repo[rev1]
 ctx2 = self._repo[rev2]
 return self._repo.status(ctx1, ctx2, **opts)
 except error.RepoLookupError as inst:
-self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
+self.ui.warn(
-% (inst, subrelpath(self)))
+_('warning: error "%s" in subrepository "%s"\n')
+% (inst, subrelpath(self))
+)
 return scmutil.status([], [], [], [], [], [], [])
 @annotatesubrepoerror
 def diff(self, ui, diffopts, node2, match, prefix, **opts):
 try:
 node1 = node.bin(self._state[1])
 # We currently expect node2 to come from substate and be
 # in hex format
 if node2 is not None:
 node2 = node.bin(node2)
-logcmdutil.diffordiffstat(ui, self._repo, diffopts, node1, node2,
+logcmdutil.diffordiffstat(
-match, prefix=prefix, listsubrepos=True,
+ui,
-**opts)
+self._repo,
+diffopts,
+node1,
+node2,
+match,
+prefix=prefix,
+listsubrepos=True,
+**opts
+)
 except error.RepoLookupError as inst:
-self.ui.warn(_('warning: error "%s" in subrepository "%s"\n')
+self.ui.warn(
-% (inst, subrelpath(self)))
+_('warning: error "%s" in subrepository "%s"\n')
+% (inst, subrelpath(self))
+)
 @annotatesubrepoerror
 def archive(self, archiver, prefix, match=None, decode=True):
 self._get(self._state + ('hg',))
 files = self.files()
 if match:
 files = [f for f in files if match(f)]
 rev = self._state[1]
 ctx = self._repo[rev]
-scmutil.prefetchfiles(self._repo, [ctx.rev()],
+scmutil.prefetchfiles(
-scmutil.matchfiles(self._repo, files))
+self._repo, [ctx.rev()], scmutil.matchfiles(self._repo, files)
+)
 total = abstractsubrepo.archive(self, archiver, prefix, match)
 for subpath in ctx.substate:
 s = subrepo(ctx, subpath, True)
 submatch = matchmod.subdirmatcher(subpath, match)
 subprefix = prefix + subpath + '/'
-total += s.archive(archiver, subprefix, submatch,
+total += s.archive(archiver, subprefix, submatch, decode)
-decode)
 return total
 @annotatesubrepoerror
 def dirty(self, ignoreupdate=False, missing=False):
 r = self._state[1]
-if r == '' and not ignoreupdate: # no state recorded
+if r == '' and not ignoreupdate:  # no state recorded
 return True
 w = self._repo[None]
 if r != w.p1().hex() and not ignoreupdate:
 # different version checked out
 return True
-return w.dirty(missing=missing) # working directory changed
+return w.dirty(missing=missing)  # working directory changed
 def basestate(self):
 return self._repo['.'].hex()
 def checknested(self, path):
 if not self.dirty(True):
 return self._repo['.'].hex()
 self.ui.debug("committing subrepo %s\n" % subrelpath(self))
 n = self._repo.commit(text, user, date)
 if not n:
-return self._repo['.'].hex() # different version checked out
+return self._repo['.'].hex()  # different version checked out
 return node.hex(n)
 @annotatesubrepoerror
 def phase(self, state):
 return self._repo[state or '.'].phase()
 # relative to the parent's share source.  But clone pooling doesn't
 # assemble the repos in a tree, so that can't be consistently done.
 # A simpler option is for the user to configure clone pooling, and
 # work with that.
 if parentrepo.shared() and hg.islocal(srcurl):
-self.ui.status(_('sharing subrepo %s from %s\n')
+self.ui.status(
-% (subrelpath(self), srcurl))
+_('sharing subrepo %s from %s\n')
-shared = hg.share(self._repo._subparent.baseui,
+% (subrelpath(self), srcurl)
-getpeer(), self._repo.root,
+)
-update=False, bookmarks=False)
+shared = hg.share(
+self._repo._subparent.baseui,
+getpeer(),
+self._repo.root,
+update=False,
+bookmarks=False,
+)
 self._repo = shared.local()
 else:
 # TODO: find a common place for this and this code in the
 # share.py wrap of the clone command.
 if parentrepo.shared():
 'mode': self.ui.config('share', 'poolnaming'),
 }
 else:
 shareopts = {}
-self.ui.status(_('cloning subrepo %s from %s\n')
+self.ui.status(
-% (subrelpath(self), util.hidepassword(srcurl)))
+_('cloning subrepo %s from %s\n')
-other, cloned = hg.clone(self._repo._subparent.baseui, {},
+% (subrelpath(self), util.hidepassword(srcurl))
-getpeer(), self._repo.root,
+)
-update=False, shareopts=shareopts)
+other, cloned = hg.clone(
+self._repo._subparent.baseui,
+{},
+getpeer(),
+self._repo.root,
+update=False,
+shareopts=shareopts,
+)
 self._repo = cloned.local()
 self._initrepo(parentrepo, source, create=True)
 self._cachestorehash(srcurl)
 else:
-self.ui.status(_('pulling subrepo %s from %s\n')
+self.ui.status(
-% (subrelpath(self), util.hidepassword(srcurl)))
+_('pulling subrepo %s from %s\n')
+% (subrelpath(self), util.hidepassword(srcurl))
+)
 cleansub = self.storeclean(srcurl)
 exchange.pull(self._repo, getpeer())
 if cleansub:
 # keep the repo clean after pull
 self._cachestorehash(srcurl)
 urepo = repo.unfiltered()
 ctx = urepo[revision]
 if ctx.hidden():
 urepo.ui.warn(
 _('revision %s in subrepository "%s" is hidden\n')
-% (revision[0:12], self._path))
+% (revision[0:12], self._path)
+)
 repo = urepo
 hg.updaterepo(repo, revision, overwrite)
 @annotatesubrepoerror
 def merge(self, state):
 dst = self._repo[state[1]]
 anc = dst.ancestor(cur)
 def mergefunc():
 if anc == cur and dst.branch() == cur.branch():
-self.ui.debug('updating subrepository "%s"\n'
+self.ui.debug(
-% subrelpath(self))
+'updating subrepository "%s"\n' % subrelpath(self)
+)
 hg.update(self._repo, state[1])
 elif anc == dst:
-self.ui.debug('skipping subrepository "%s"\n'
+self.ui.debug(
-% subrelpath(self))
+'skipping subrepository "%s"\n' % subrelpath(self)
+)
 else:
 self.ui.debug('merging subrepository "%s"\n' % subrelpath(self))
 hg.merge(self._repo, state[1], remind=False)
 wctx = self._repo[None]
 newbranch = opts.get('new_branch')
 ssh = opts.get('ssh')
 # push subrepos depth-first for coherent ordering
 c = self._repo['.']
-subs = c.substate # only repos that are committed
+subs = c.substate  # only repos that are committed
 for s in sorted(subs):
 if c.sub(s).push(opts) == 0:
 return False
 dsturl = _abssource(self._repo, True)
 if not force:
 if self.storeclean(dsturl):
 self.ui.status(
 _('no changes made to subrepo %s since last push to %s\n')
-% (subrelpath(self), util.hidepassword(dsturl)))
+% (subrelpath(self), util.hidepassword(dsturl))
+)
 return None
-self.ui.status(_('pushing subrepo %s to %s\n') %
+self.ui.status(
-(subrelpath(self), util.hidepassword(dsturl)))
+_('pushing subrepo %s to %s\n')
+% (subrelpath(self), util.hidepassword(dsturl))
+)
 other = hg.peer(self._repo, {'ssh': ssh}, dsturl)
 res = exchange.push(self._repo, other, force, newbranch=newbranch)
 # the repo is now clean
 self._cachestorehash(dsturl)
 try:
 sm = sub.matchfileset(expr, badfn=badfn)
 pm = matchmod.prefixdirmatcher(subpath, sm, badfn=badfn)
 matchers.append(pm)
 except error.LookupError:
-self.ui.status(_("skipping missing subrepository: %s\n")
+self.ui.status(
-% self.wvfs.reljoin(reporelpath(self), subpath))
+_("skipping missing subrepository: %s\n")
+% self.wvfs.reljoin(reporelpath(self), subpath)
+)
 if len(matchers) == 1:
 return matchers[0]
 return matchmod.unionmatcher(matchers)
 def walk(self, match):
 ctx = self._repo[None]
 return ctx.walk(match)
 @annotatesubrepoerror
 def forget(self, match, prefix, uipathfn, dryrun, interactive):
-return cmdutil.forget(self.ui, self._repo, match, prefix, uipathfn,
+return cmdutil.forget(
-True, dryrun=dryrun, interactive=interactive)
+self.ui,
+self._repo,
-@annotatesubrepoerror
+match,
-def removefiles(self, matcher, prefix, uipathfn, after, force, subrepos,
+prefix,
-dryrun, warnings):
+uipathfn,
-return cmdutil.remove(self.ui, self._repo, matcher, prefix, uipathfn,
+True,
-after, force, subrepos, dryrun)
+dryrun=dryrun,
+interactive=interactive,
+)
+@annotatesubrepoerror
+def removefiles(
+self,
+matcher,
+prefix,
+uipathfn,
+after,
+force,
+subrepos,
+dryrun,
+warnings,
+):
+return cmdutil.remove(
+self.ui,
+self._repo,
+matcher,
+prefix,
+uipathfn,
+after,
+force,
+subrepos,
+dryrun,
+)
 @annotatesubrepoerror
 def revert(self, substate, *pats, **opts):
 # reverting a subrepo is a 2 step process:
 # 1. if the no_backup is not set, revert all modified
 # because it wants to make repo objects from deep inside the stack
 # so we manually delay the circular imports to not break
 # scripts that don't use our demand-loading
 global hg
 from . import hg as h
 hg = h
 # Nothing prevents a user from sharing in a repo, and then making that a
 # subrepo.  Alternately, the previous unshare attempt may have failed
 # part way through.  So recurse whether or not this layer is shared.
 ctx = self._repo.unfiltered()[rev]
 if ctx.hidden():
 # Since hidden revisions aren't pushed/pulled, it seems worth an
 # explicit warning.
 ui = self._repo.ui
-ui.warn(_("subrepo '%s' is hidden in revision %s\n") %
+ui.warn(
-(self._relpath, node.short(self._ctx.node())))
+_("subrepo '%s' is hidden in revision %s\n")
+% (self._relpath, node.short(self._ctx.node()))
+)
 return 0
 except error.RepoLookupError:
 # A missing subrepo revision may be a case of needing to pull it, so
 # don't treat this as an error.
-self._repo.ui.warn(_("subrepo '%s' not found in revision %s\n") %
+self._repo.ui.warn(
-(self._relpath, node.short(self._ctx.node())))
+_("subrepo '%s' not found in revision %s\n")
+% (self._relpath, node.short(self._ctx.node()))
+)
 return 0
 @propertycache
 def wvfs(self):
 """return own wvfs for efficiency and consistency
 """return path to this subrepository as seen from outermost repository
 """
 # Keep consistent dir separators by avoiding vfs.join(self._path)
 return reporelpath(self._repo)
 class svnsubrepo(abstractsubrepo):
 def __init__(self, ctx, path, state, allowcreate):
 super(svnsubrepo, self).__init__(ctx, path)
 self._state = state
 self._exe = procutil.findexe('svn')
 if not self._exe:
-raise error.Abort(_("'svn' executable not found for subrepo '%s'")
+raise error.Abort(
-% self._path)
+_("'svn' executable not found for subrepo '%s'") % self._path
+)
 def _svncommand(self, commands, filename='', failok=False):
 cmd = [self._exe]
 extrakw = {}
 if not self.ui.interactive():
 # --non-interactive.
 if commands[0] in ('update', 'checkout', 'commit'):
 cmd.append('--non-interactive')
 cmd.extend(commands)
 if filename is not None:
-path = self.wvfs.reljoin(self._ctx.repo().origroot,
+path = self.wvfs.reljoin(
-self._path, filename)
+self._ctx.repo().origroot, self._path, filename
+)
 cmd.append(path)
 env = dict(encoding.environ)
 # Avoid localized output, preserve current locale for everything else.
 lc_all = env.get('LC_ALL')
 if lc_all:
 env['LANG'] = lc_all
 del env['LC_ALL']
 env['LC_MESSAGES'] = 'C'
-p = subprocess.Popen(pycompat.rapply(procutil.tonativestr, cmd),
+p = subprocess.Popen(
-bufsize=-1, close_fds=procutil.closefds,
+pycompat.rapply(procutil.tonativestr, cmd),
-stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+bufsize=-1,
-env=procutil.tonativeenv(env), **extrakw)
+close_fds=procutil.closefds,
+stdout=subprocess.PIPE,
+stderr=subprocess.PIPE,
+env=procutil.tonativeenv(env),
+**extrakw
+)
 stdout, stderr = map(util.fromnativeeol, p.communicate())
 stderr = stderr.strip()
 if not failok:
 if p.returncode:
-raise error.Abort(stderr or 'exited with code %d'
+raise error.Abort(
-% p.returncode)
+stderr or 'exited with code %d' % p.returncode
+)
 if stderr:
 self.ui.warn(stderr + '\n')
 return stdout, stderr
 @propertycache
 lastrev, rev = '0', '0'
 if entries:
 rev = pycompat.bytestr(entries[0].getAttribute(r'revision')) or '0'
 commits = entries[0].getElementsByTagName(r'commit')
 if commits:
-lastrev = pycompat.bytestr(
+lastrev = (
-commits[0].getAttribute(r'revision')) or '0'
+pycompat.bytestr(commits[0].getAttribute(r'revision'))
+or '0'
+)
 return (lastrev, rev)
 def _wcrev(self):
 return self._wcrevs()[0]
 path = e.getAttribute(r'path').encode('utf8')
 if item == r'external':
 externals.append(path)
 elif item == r'missing':
 missing.append(path)
-if (item not in (r'', r'normal', r'unversioned', r'external')
+if item not in (
-or props not in (r'', r'none', r'normal')):
+r'',
+r'normal',
+r'unversioned',
+r'external',
+) or props not in (r'', r'none', r'normal'):
 changes.append(path)
 for path in changes:
 for ext in externals:
 if path == ext or path.startswith(ext + pycompat.ossep):
 return True, True, bool(missing)
 return newrev
 @annotatesubrepoerror
 def remove(self):
 if self.dirty():
-self.ui.warn(_('not removing repo %s because '
+self.ui.warn(
-'it has changes.\n') % self._path)
+_('not removing repo %s because ' 'it has changes.\n')
+% self._path
+)
 return
 self.ui.note(_('removing subrepo %s\n') % self._path)
 self.wvfs.rmtree(forcibly=True)
 try:
 util.checksafessh(state[0])
 status, err = self._svncommand(args, failok=True)
 _sanitize(self.ui, self.wvfs, '.svn')
 if not re.search('Checked out revision [0-9]+.', status):
-if ('is already a working copy for a different URL' in err
+if 'is already a working copy for a different URL' in err and (
-and (self._wcchanged()[:2] == (False, False))):
+self._wcchanged()[:2] == (False, False)
+):
 # obstructed but clean working copy, so just blow it away.
 self.remove()
 self.get(state, overwrite=False)
 return
 raise error.Abort((status or err).splitlines()[-1])
 paths = []
 for e in doc.getElementsByTagName(r'entry'):
 kind = pycompat.bytestr(e.getAttribute(r'kind'))
 if kind != 'file':
 continue
-name = r''.join(c.data for c
+name = r''.join(
-in e.getElementsByTagName(r'name')[0].childNodes
+c.data
-if c.nodeType == c.TEXT_NODE)
+for c in e.getElementsByTagName(r'name')[0].childNodes
+if c.nodeType == c.TEXT_NODE
+)
 paths.append(name.encode('utf8'))
 return paths
 def filedata(self, name, decode):
 return self._svncommand(['cat'], name)[0]
 out, err = self._gitnodir(['--version'])
 except OSError as e:
 genericerror = _("error executing git for subrepo '%s': %s")
 notfoundhint = _("check git is installed and in your PATH")
 if e.errno != errno.ENOENT:
-raise error.Abort(genericerror % (
+raise error.Abort(
-self._path, encoding.strtolocal(e.strerror)))
+genericerror % (self._path, encoding.strtolocal(e.strerror))
+)
 elif pycompat.iswindows:
 try:
 self._gitexecutable = 'git.cmd'
 out, err = self._gitnodir(['--version'])
 except OSError as e2:
 if e2.errno == errno.ENOENT:
-raise error.Abort(_("couldn't find 'git' or 'git.cmd'"
+raise error.Abort(
-" for subrepo '%s'") % self._path,
+_(
-hint=notfoundhint)
+"couldn't find 'git' or 'git.cmd'"
+" for subrepo '%s'"
+)
+% self._path,
+hint=notfoundhint,
+)
 else:
-raise error.Abort(genericerror % (self._path,
+raise error.Abort(
-encoding.strtolocal(e2.strerror)))
+genericerror
+% (self._path, encoding.strtolocal(e2.strerror))
+)
 else:
-raise error.Abort(_("couldn't find git for subrepo '%s'")
+raise error.Abort(
-% self._path, hint=notfoundhint)
+_("couldn't find git for subrepo '%s'") % self._path,
+hint=notfoundhint,
+)
 versionstatus = self._checkversion(out)
 if versionstatus == 'unknown':
 self.ui.warn(_('cannot retrieve git version\n'))
 elif versionstatus == 'abort':
 raise error.Abort(_('git subrepo requires at least 1.6.0 or later'))
 def _gitcommand(self, commands, env=None, stream=False):
 return self._gitdir(commands, env=env, stream=stream)[0]
 def _gitdir(self, commands, env=None, stream=False):
-return self._gitnodir(commands, env=env, stream=stream,
+return self._gitnodir(
-cwd=self._abspath)
+commands, env=env, stream=stream, cwd=self._abspath
+)
 def _gitnodir(self, commands, env=None, stream=False, cwd=None):
 """Calls the git command
 The methods tries to call the git command. versions prior to 1.6.0
 errpipe = open(os.devnull, 'w')
 if self.ui._colormode and len(commands) and commands[0] == "diff":
 # insert the argument in the front,
 # the end of git diff arguments is used for paths
 commands.insert(1, '--color')
-p = subprocess.Popen(pycompat.rapply(procutil.tonativestr,
+p = subprocess.Popen(
-[self._gitexecutable] + commands),
+pycompat.rapply(
-bufsize=-1,
+procutil.tonativestr, [self._gitexecutable] + commands
-cwd=pycompat.rapply(procutil.tonativestr, cwd),
+),
-env=procutil.tonativeenv(env),
+bufsize=-1,
-close_fds=procutil.closefds,
+cwd=pycompat.rapply(procutil.tonativestr, cwd),
-stdout=subprocess.PIPE, stderr=errpipe)
+env=procutil.tonativeenv(env),
+close_fds=procutil.closefds,
+stdout=subprocess.PIPE,
+stderr=errpipe,
+)
 if stream:
 return p.stdout, None
 retdata = p.stdout.read().strip()
 # wait for the child to exit to avoid race condition.
 # there are certain error codes that are ok
 command = commands[0]
 if command in ('cat-file', 'symbolic-ref'):
 return retdata, p.returncode
 # for all others, abort
-raise error.Abort(_('git %s error %d in %s') %
+raise error.Abort(
-(command, p.returncode, self._relpath))
+_('git %s error %d in %s')
+% (command, p.returncode, self._relpath)
+)
 return retdata, p.returncode
 def _gitmissing(self):
 return not self.wvfs.exists('.git')
 a map from git branch to revision
 a map from revision to branches'''
 branch2rev = {}
 rev2branch = {}
-out = self._gitcommand(['for-each-ref', '--format',
+out = self._gitcommand(
-'%(objectname) %(refname)'])
+['for-each-ref', '--format', '%(objectname) %(refname)']
+)
 for line in out.split('\n'):
 revision, ref = line.split(' ')
-if (not ref.startswith('refs/heads/') and
+if not ref.startswith('refs/heads/') and not ref.startswith(
-not ref.startswith('refs/remotes/')):
+'refs/remotes/'
+):
 continue
 if ref.startswith('refs/remotes/') and ref.endswith('/HEAD'):
-continue # ignore remote/HEAD redirects
+continue  # ignore remote/HEAD redirects
 branch2rev[ref] = revision
 rev2branch.setdefault(revision, []).append(ref)
 return branch2rev, rev2branch
 def _gittracking(self, branches):
 continue
 bname = b.split('/', 2)[2]
 remote = self._gitcommand(['config', 'branch.%s.remote' % bname])
 if remote:
 ref = self._gitcommand(['config', 'branch.%s.merge' % bname])
-tracking['refs/remotes/%s/%s' %
+tracking[
-(remote, ref.split('/', 2)[2])] = b
+'refs/remotes/%s/%s' % (remote, ref.split('/', 2)[2])
+] = b
 return tracking
 def _abssource(self, source):
 if '://' not in source:
 # recognize the scp syntax as an absolute source
 if self._gitmissing():
 # SEC: check for safe ssh url
 util.checksafessh(source)
 source = self._abssource(source)
-self.ui.status(_('cloning subrepo %s from %s\n') %
+self.ui.status(
-(self._relpath, source))
+_('cloning subrepo %s from %s\n') % (self._relpath, source)
+)
 self._gitnodir(['clone', source, self._abspath])
 if self._githavelocally(revision):
 return
-self.ui.status(_('pulling subrepo %s from %s\n') %
+self.ui.status(
-(self._relpath, self._gitremote('origin')))
+_('pulling subrepo %s from %s\n')
+% (self._relpath, self._gitremote('origin'))
+)
 # try only origin: the originally cloned repo
 self._gitcommand(['fetch'])
 if not self._githavelocally(revision):
-raise error.Abort(_('revision %s does not exist in subrepository '
+raise error.Abort(
-'"%s"\n') % (revision, self._relpath))
+_('revision %s does not exist in subrepository ' '"%s"\n')
+% (revision, self._relpath)
+)
 @annotatesubrepoerror
 def dirty(self, ignoreupdate=False, missing=False):
 if self._gitmissing():
 return self._state[1] != ''
 self._gitcommand(cmd + args)
 _sanitize(self.ui, self.wvfs, '.git')
 def rawcheckout():
 # no branch to checkout, check it out with no branch
-self.ui.warn(_('checking out detached HEAD in '
+self.ui.warn(
-'subrepository "%s"\n') % self._relpath)
+_('checking out detached HEAD in ' 'subrepository "%s"\n')
-self.ui.warn(_('check out a git branch if you intend '
+% self._relpath
-'to make changes\n'))
+)
+self.ui.warn(
+_('check out a git branch if you intend ' 'to make changes\n')
+)
 checkout(['-q', revision])
 if revision not in rev2branch:
 rawcheckout()
 return
 if user:
 cmd += ['--author', user]
 if date:
 # git's date parser silently ignores when seconds < 1e9
 # convert to ISO8601
-env['GIT_AUTHOR_DATE'] = dateutil.datestr(date,
+env['GIT_AUTHOR_DATE'] = dateutil.datestr(
-'%Y-%m-%dT%H:%M:%S %1%2')
+date, '%Y-%m-%dT%H:%M:%S %1%2'
+)
 self._gitcommand(cmd, env=env)
 # make sure commit works otherwise HEAD might not exist under certain
 # circumstances
 return self._gitstate()
 self._gitupdatestat()
 out, code = self._gitdir(['diff-index', '--quiet', 'HEAD'])
 def mergefunc():
 if base == revision:
-self.get(state) # fast forward merge
+self.get(state)  # fast forward merge
 elif base != self._state[1]:
 self._gitcommand(['merge', '--no-commit', revision])
 _sanitize(self.ui, self.wvfs, '.git')
 if self.dirty():
 if self._gitstate() != revision:
 dirty = self._gitstate() == self._state[1] or code != 0
-if _updateprompt(self.ui, self, dirty,
+if _updateprompt(
-self._state[1][:7], revision[:7]):
+self.ui, self, dirty, self._state[1][:7], revision[:7]
+):
 mergefunc()
 else:
 mergefunc()
 @annotatesubrepoerror
 current = self._gitcurrentbranch()
 if current:
 # determine if the current branch is even useful
 if not self._gitisancestor(self._state[1], current):
-self.ui.warn(_('unrelated git branch checked out '
+self.ui.warn(
-'in subrepository "%s"\n') % self._relpath)
+_(
+'unrelated git branch checked out '
+'in subrepository "%s"\n'
+)
+% self._relpath
+)
 return False
-self.ui.status(_('pushing branch %s of subrepository "%s"\n') %
+self.ui.status(
-(current.split('/', 2)[2], self._relpath))
+_('pushing branch %s of subrepository "%s"\n')
+% (current.split('/', 2)[2], self._relpath)
+)
 ret = self._gitdir(cmd + ['origin', current])
 return ret[1] == 0
 else:
-self.ui.warn(_('no branch checked out in subrepository "%s"\n'
+self.ui.warn(
-'cannot push revision %s\n') %
+_(
-(self._relpath, self._state[1]))
+'no branch checked out in subrepository "%s"\n'
+'cannot push revision %s\n'
+)
+% (self._relpath, self._state[1])
+)
 return False
 @annotatesubrepoerror
 def add(self, ui, match, prefix, uipathfn, explicitonly, **opts):
 if self._gitmissing():
 files = [f for f in sorted(set(files)) if match(f)]
 for f in files:
 exact = match.exact(f)
 command = ["add"]
 if exact:
-command.append("-f") #should be added, even if ignored
+command.append("-f")  # should be added, even if ignored
 if ui.verbose or not exact:
 ui.status(_('adding %s\n') % uipathfn(f))
 if f in tracked:  # hg prints 'adding' even if already tracked
 if exact:
 @annotatesubrepoerror
 def remove(self):
 if self._gitmissing():
 return
 if self.dirty():
-self.ui.warn(_('not removing repo %s because '
+self.ui.warn(
-'it has changes.\n') % self._relpath)
+_('not removing repo %s because ' 'it has changes.\n')
+% self._relpath
+)
 return
 # we can't fully delete the repository as it may contain
 # local-only history
 self.ui.note(_('removing subrepo %s\n') % self._relpath)
 self._gitcommand(['config', 'core.bare', 'true'])
 # This should be much faster than manually traversing the trees
 # and objects with many subprocess calls.
 tarstream = self._gitcommand(['archive', revision], stream=True)
 tar = tarfile.open(fileobj=tarstream, mode=r'r|')
 relpath = subrelpath(self)
-progress = self.ui.makeprogress(_('archiving (%s)') % relpath,
+progress = self.ui.makeprogress(
-unit=_('files'))
+_('archiving (%s)') % relpath, unit=_('files')
+)
 progress.update(0)
 for info in tar:
 if info.isdir():
 continue
 bname = pycompat.fsencode(info.name)
 total += 1
 progress.increment()
 progress.complete()
 return total
 @annotatesubrepoerror
 def cat(self, match, fm, fntemplate, prefix, **opts):
 rev = self._state[1]
 if match.anypats():
-return 1 #No support for include/exclude yet
+return 1  # No support for include/exclude yet
 if not match.files():
 return 1
 # TODO: add support for non-plain formatter (see cmdutil.cat())
 for f in match.files():
 output = self._gitcommand(["show", "%s:%s" % (rev, f)])
-fp = cmdutil.makefileobj(self._ctx, fntemplate,
+fp = cmdutil.makefileobj(
-pathname=self.wvfs.reljoin(prefix, f))
+self._ctx, fntemplate, pathname=self.wvfs.reljoin(prefix, f)
+)
 fp.write(output)
 fp.close()
 return 0
 @annotatesubrepoerror
 def status(self, rev2, **opts):
 rev1 = self._state[1]
 if self._gitmissing() or not rev1:
 out = self._gitcommand(command)
 for line in out.split('\n'):
 tab = line.find('\t')
 if tab == -1:
 continue
-status, f = line[tab - 1:tab], line[tab + 1:]
+status, f = line[tab - 1 : tab], line[tab + 1 :]
 if status == 'M':
 modified.append(f)
 elif status == 'A':
 added.append(f)
 elif status == 'D':
 changedfiles.update(removed)
 for line in out.split('\0'):
 if not line:
 continue
 st = line[0:2]
-#moves and copies show 2 files on one line
+# moves and copies show 2 files on one line
 if line.find('\0') >= 0:
 filename1, filename2 = line[3:].split('\0')
 else:
 filename1 = line[3:]
 filename2 = None
 out = self._gitcommand(['ls-files'])
 for f in out.split('\n'):
 if not f in changedfiles:
 clean.append(f)
-return scmutil.status(modified, added, removed, deleted,
+return scmutil.status(
-unknown, ignored, clean)
+modified, added, removed, deleted, unknown, ignored, clean
+)
 @annotatesubrepoerror
 def diff(self, ui, diffopts, node2, match, prefix, **opts):
 node1 = self._state[1]
 cmd = ['diff', '--no-renames']
 else:
 # for Git, this also implies '-p'
 cmd.append('-U%d' % diffopts.context)
 if diffopts.noprefix:
-cmd.extend(['--src-prefix=%s/' % prefix,
+cmd.extend(
-'--dst-prefix=%s/' % prefix])
+['--src-prefix=%s/' % prefix, '--dst-prefix=%s/' % prefix]
+)
 else:
-cmd.extend(['--src-prefix=a/%s/' % prefix,
+cmd.extend(
-'--dst-prefix=b/%s/' % prefix])
+['--src-prefix=a/%s/' % prefix, '--dst-prefix=b/%s/' % prefix]
+)
 if diffopts.ignorews:
 cmd.append('--ignore-all-space')
 if diffopts.ignorewsamount:
 cmd.append('--ignore-space-change')
-if (self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4)
+if (
-and diffopts.ignoreblanklines):
+self._gitversion(self._gitcommand(['--version'])) >= (1, 8, 4)
+and diffopts.ignoreblanklines
+):
 cmd.append('--ignore-blank-lines')
 cmd.append(node1)
 if node2:
 cmd.append(node2)
 names = status.modified
 for name in names:
 # backuppath() expects a path relative to the parent repo (the
 # repo that ui.origbackuppath is relative to)
 parentname = os.path.join(self._path, name)
-bakname = scmutil.backuppath(self.ui, self._subparent,
+bakname = scmutil.backuppath(
-parentname)
+self.ui, self._subparent, parentname
-self.ui.note(_('saving current version of %s as %s\n') %
+)
-(name, os.path.relpath(bakname)))
+self.ui.note(
+_('saving current version of %s as %s\n')
+% (name, os.path.relpath(bakname))
+)
 util.rename(self.wvfs.join(name), bakname)
 if not opts.get(r'dry_run'):
 self.get(substate, overwrite=True)
 return []
 def shortid(self, revid):
 return revid[:7]
 types = {
 'hg': hgsubrepo,
 'svn': svnsubrepo,
 'git': gitsubrepo,
 }

changeset 43076	2372284d9457
parent 42588	f6540aba8e3e
child 43077	687b865b95ad