mercurial: comparison hgext/largefiles/overrides.py

equal deleted inserted replaced

-:61881b170140
+:84a0102c05c7
 # GNU General Public License version 2 or any later version.
 '''Overridden Mercurial commands and functions for the largefiles extension'''
 from __future__ import absolute_import
-import contextlib
 import copy
 import os
 from mercurial.i18n import _
 storefactory,
 )
 eh = exthelper.exthelper()
+lfstatus = lfutil.lfstatus
 # -- Utility functions: commonly/repeatedly needed functionality ---------------
 def composelargefilematcher(match, manifest):
 '''create a matcher that matches only the largefiles in the original
 m.matchfn = lambda f: notlfile(f) and origmatchfn(f)
 return m
 def addlargefiles(ui, repo, isaddremove, matcher, uipathfn, **opts):
-large = opts.get(r'large')
+large = opts.get('large')
 lfsize = lfutil.getminsize(
-ui, lfutil.islfilesrepo(repo), opts.get(r'lfsize')
+ui, lfutil.islfilesrepo(repo), opts.get('lfsize')
 )
 lfmatcher = None
 if lfutil.islfilesrepo(repo):
 lfpats = ui.configlist(lfutil.longname, b'patterns')
 bad = []
 # Need to lock, otherwise there could be a race condition between
 # when standins are created and added to the repo.
 with repo.wlock():
-if not opts.get(r'dry_run'):
+if not opts.get('dry_run'):
 standins = []
 lfdirstate = lfutil.openlfdirstate(ui, repo)
 for f in lfnames:
 standinname = lfutil.standin(f)
 lfutil.writestandin(
 added = [f for f in lfnames if f not in bad]
 return added, bad
-@contextlib.contextmanager
-def lfstatus(repo):
-oldvalue = getattr(repo, 'lfstatus', False)
-repo.lfstatus = True
-try:
-yield
-finally:
-repo.lfstatus = oldvalue
 def removelargefiles(ui, repo, isaddremove, matcher, uipathfn, dryrun, **opts):
-after = opts.get(r'after')
+after = opts.get('after')
 m = composelargefilematcher(matcher, repo[None].manifest())
 with lfstatus(repo):
 s = repo.status(match=m, clean=not isaddremove)
 manifest = repo[None].manifest()
 modified, added, deleted, clean = [
 ),
 ),
 ],
 )
 def overrideadd(orig, ui, repo, *pats, **opts):
-if opts.get(r'normal') and opts.get(r'large'):
+if opts.get('normal') and opts.get('large'):
 raise error.Abort(_(b'--normal cannot be used with --large'))
 return orig(ui, repo, *pats, **opts)
 @eh.wrapfunction(cmdutil, b'add')
 def cmdutiladd(orig, ui, repo, matcher, prefix, uipathfn, explicitonly, **opts):
 # The --normal flag short circuits this override
-if opts.get(r'normal'):
+if opts.get('normal'):
 return orig(ui, repo, matcher, prefix, uipathfn, explicitonly, **opts)
 ladded, lbad = addlargefiles(ui, repo, False, matcher, uipathfn, **opts)
 normalmatcher = composenormalfilematcher(
 matcher, repo[None].manifest(), ladded
 _(b'verify local largefile contents, not just existence'),
 ),
 ],
 )
 def overrideverify(orig, ui, repo, *pats, **opts):
-large = opts.pop(r'large', False)
+large = opts.pop('large', False)
-all = opts.pop(r'lfa', False)
+all = opts.pop('lfa', False)
-contents = opts.pop(r'lfc', False)
+contents = opts.pop('lfc', False)
 result = orig(ui, repo, *pats, **opts)
 if large or all or contents:
 result = result or lfcommands.verifylfiles(ui, repo, all, contents)
 return result
 @eh.wrapcommand(
 b'debugstate',
 opts=[(b'', b'large', None, _(b'display largefiles dirstate'))],
 )
 def overridedebugstate(orig, ui, repo, *pats, **opts):
-large = opts.pop(r'large', False)
+large = opts.pop('large', False)
 if large:
 class fakerepo(object):
 dirstate = lfutil.openlfdirstate(ui, repo)
 if not source:
 source = b'default'
 repo.lfpullsource = source
 result = orig(ui, repo, source, **opts)
 revspostpull = len(repo)
-lfrevs = opts.get(r'lfrev', [])
+lfrevs = opts.get('lfrev', [])
-if opts.get(r'all_largefiles'):
+if opts.get('all_largefiles'):
 lfrevs.append(b'pulled()')
 if lfrevs and revspostpull > revsprepull:
 numcached = 0
 repo.firstpulled = revsprepull  # for pulled() revset expression
 try:
 )
 ],
 )
 def overridepush(orig, ui, repo, *args, **kwargs):
 """Override push command and store --lfrev parameters in opargs"""
-lfrevs = kwargs.pop(r'lfrev', None)
+lfrevs = kwargs.pop('lfrev', None)
 if lfrevs:
-opargs = kwargs.setdefault(r'opargs', {})
+opargs = kwargs.setdefault('opargs', {})
 opargs[b'lfrevs'] = scmutil.revrange(repo, lfrevs)
 return orig(ui, repo, *args, **kwargs)
 @eh.wrapfunction(exchange, b'pushoperation')
 def exchangepushoperation(orig, *args, **kwargs):
 """Override pushoperation constructor and store lfrevs parameter"""
-lfrevs = kwargs.pop(r'lfrevs', None)
+lfrevs = kwargs.pop('lfrevs', None)
 pushop = orig(*args, **kwargs)
 pushop.lfrevs = lfrevs
 return pushop
 )
 def overrideclone(orig, ui, source, dest=None, **opts):
 d = dest
 if d is None:
 d = hg.defaultdest(source)
-if opts.get(r'all_largefiles') and not hg.islocal(d):
+if opts.get('all_largefiles') and not hg.islocal(d):
 raise error.Abort(
 _(b'--all-largefiles is incompatible with non-local destination %s')
 % d
 )
 @eh.wrapcommand(b'rebase', extension=b'rebase')
 def overriderebase(orig, ui, repo, **opts):
 if not util.safehasattr(repo, b'_largefilesenabled'):
 return orig(ui, repo, **opts)
-resuming = opts.get(r'continue')
+resuming = opts.get('continue')
 repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
 repo._lfstatuswriters.append(lambda *msg, **opts: None)
 try:
 return orig(ui, repo, **opts)
 finally:
 return result
 @eh.wrapcommand(b'transplant', extension=b'transplant')
 def overridetransplant(orig, ui, repo, *revs, **opts):
-resuming = opts.get(r'continue')
+resuming = opts.get('continue')
 repo._lfcommithooks.append(lfutil.automatedcommithook(resuming))
 repo._lfstatuswriters.append(lambda *msg, **opts: None)
 try:
 result = orig(ui, repo, *revs, **opts)
 finally:
 return err
 @eh.wrapfunction(merge, b'update')
 def mergeupdate(orig, repo, node, branchmerge, force, *args, **kwargs):
-matcher = kwargs.get(r'matcher', None)
+matcher = kwargs.get('matcher', None)
 # note if this is a partial update
 partial = matcher and not matcher.always()
 with repo.wlock():
 # branch |       |         |
 #  merge | force | partial | action
 oldstandins = lfutil.getstandinsstate(repo)
 # Make sure the merge runs on disk, not in-memory. largefiles is not a
 # good candidate for in-memory merge (large files, custom dirstate,
 # matcher usage).
-kwargs[r'wc'] = repo[None]
+kwargs['wc'] = repo[None]
 result = orig(repo, node, branchmerge, force, *args, **kwargs)
 newstandins = lfutil.getstandinsstate(repo)
 filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)

branch	stable
changeset 44129	84a0102c05c7
parent 44015	7ca8aa8840c0
parent 43583	73e6d3346e4f
child 44452	9d2b2df2c2ba