Mercurial > hg-stable
changeset 16247:d87d9d8a8e03
largefiles: remove use of underscores that breaks coding convention
| author | Na'Tosha Bard <natosha@unity3d.com> |
|---|---|
| date | Fri, 09 Mar 2012 16:11:52 +0100 |
| parents | 169525f8ffbb |
| children | 51e6f318bdf1 |
| files | hgext/largefiles/basestore.py hgext/largefiles/lfcommands.py hgext/largefiles/lfutil.py hgext/largefiles/overrides.py hgext/largefiles/proto.py hgext/largefiles/reposetup.py hgext/largefiles/uisetup.py |
| diffstat | 7 files changed, 154 insertions(+), 154 deletions(-) [+] |
line wrap: on
line diff
--- a/hgext/largefiles/basestore.py Fri Mar 09 15:26:13 2012 +0100 +++ b/hgext/largefiles/basestore.py Fri Mar 09 16:11:52 2012 +0100 @@ -114,14 +114,14 @@ failed = util.any(self._verifyfile( cctx, cset, contents, standin, verified) for standin in cctx) - num_revs = len(verified) - num_lfiles = len(set([fname for (fname, fnode) in verified])) + numrevs = len(verified) + numlfiles = len(set([fname for (fname, fnode) in verified])) if contents: write(_('verified contents of %d revisions of %d largefiles\n') - % (num_revs, num_lfiles)) + % (numrevs, numlfiles)) else: write(_('verified existence of %d revisions of %d largefiles\n') - % (num_revs, num_lfiles)) + % (numrevs, numlfiles)) return int(failed) @@ -186,9 +186,9 @@ except KeyError: raise util.Abort(_('unsupported URL scheme %r') % scheme) - for class_obj in storeproviders: + for classobj in storeproviders: try: - return class_obj(ui, repo, remote) + return classobj(ui, repo, remote) except lfutil.storeprotonotcapable: pass
--- a/hgext/largefiles/lfcommands.py Fri Mar 09 15:26:13 2012 +0100 +++ b/hgext/largefiles/lfcommands.py Fri Mar 09 16:11:52 2012 +0100 @@ -58,7 +58,7 @@ # Lock destination to prevent modification while it is converted to. # Don't need to lock src because we are just reading from its history # which can't change. - dst_lock = rdst.lock() + dstlock = rdst.lock() # Get a list of all changesets in the source. The easy way to do this # is to simply walk the changelog, using changelog.nodesbewteen(). @@ -113,7 +113,7 @@ if not success: # we failed, remove the new directory shutil.rmtree(rdst.root) - dst_lock.release() + dstlock.release() def _addchangeset(ui, rsrc, rdst, ctx, revmap): # Convert src parents to dst parents @@ -451,7 +451,7 @@ expecthash != lfutil.hashfile(abslfile))): if not lfutil.copyfromcache(repo, expecthash, lfile): # use normallookup() to allocate entry in largefiles dirstate, - # because lack of it misleads lfiles_repo.status() into + # because lack of it misleads lfilesrepo.status() into # recognition that such cache missing files are REMOVED. lfdirstate.normallookup(lfile) return None # don't try to set the mode
--- a/hgext/largefiles/lfutil.py Fri Mar 09 15:26:13 2012 +0100 +++ b/hgext/largefiles/lfutil.py Fri Mar 09 16:11:52 2012 +0100 @@ -23,14 +23,14 @@ # -- Portability wrappers ---------------------------------------------- -def dirstate_walk(dirstate, matcher, unknown=False, ignored=False): +def dirstatewalk(dirstate, matcher, unknown=False, ignored=False): return dirstate.walk(matcher, [], unknown, ignored) -def repo_add(repo, list): +def repoadd(repo, list): add = repo[None].add return add(list) -def repo_remove(repo, list, unlink=False): +def reporemove(repo, list, unlink=False): def remove(list, unlink): wlock = repo.wlock() try: @@ -46,7 +46,7 @@ wlock.release() return remove(list, unlink=unlink) -def repo_forget(repo, list): +def repoforget(repo, list): forget = repo[None].forget return forget(list) @@ -125,21 +125,21 @@ return path return None -class largefiles_dirstate(dirstate.dirstate): +class largefilesdirstate(dirstate.dirstate): def __getitem__(self, key): - return super(largefiles_dirstate, self).__getitem__(unixpath(key)) + return super(largefilesdirstate, self).__getitem__(unixpath(key)) def normal(self, f): - return super(largefiles_dirstate, self).normal(unixpath(f)) + return super(largefilesdirstate, self).normal(unixpath(f)) def remove(self, f): - return super(largefiles_dirstate, self).remove(unixpath(f)) + return super(largefilesdirstate, self).remove(unixpath(f)) def add(self, f): - return super(largefiles_dirstate, self).add(unixpath(f)) + return super(largefilesdirstate, self).add(unixpath(f)) def drop(self, f): - return super(largefiles_dirstate, self).drop(unixpath(f)) + return super(largefilesdirstate, self).drop(unixpath(f)) def forget(self, f): - return super(largefiles_dirstate, self).forget(unixpath(f)) + return super(largefilesdirstate, self).forget(unixpath(f)) def normallookup(self, f): - return super(largefiles_dirstate, self).normallookup(unixpath(f)) + return super(largefilesdirstate, self).normallookup(unixpath(f)) def openlfdirstate(ui, repo): ''' @@ -148,7 +148,7 @@ ''' admin = repo.join(longname) opener = scmutil.opener(admin) - lfdirstate = largefiles_dirstate(opener, ui, repo.root, + lfdirstate = largefilesdirstate(opener, ui, repo.root, repo.dirstate._validate) # If the largefiles dirstate does not exist, populate and create @@ -157,7 +157,7 @@ if not os.path.exists(os.path.join(admin, 'dirstate')): util.makedirs(admin) matcher = getstandinmatcher(repo) - for standin in dirstate_walk(repo.dirstate, matcher): + for standin in dirstatewalk(repo.dirstate, matcher): lfile = splitstandin(standin) hash = readstandin(repo, lfile) lfdirstate.normallookup(lfile) @@ -169,7 +169,7 @@ raise return lfdirstate -def lfdirstate_status(lfdirstate, repo, rev): +def lfdirstatestatus(lfdirstate, repo, rev): match = match_.always(repo.root, repo.getcwd()) s = lfdirstate.status(match, [], False, False, False) unsure, modified, added, removed, missing, unknown, ignored, clean = s @@ -286,9 +286,9 @@ as the paths specified by the user.''' smatcher = getstandinmatcher(repo, rmatcher.files()) isstandin = smatcher.matchfn - def composed_matchfn(f): + def composedmatchfn(f): return isstandin(f) and rmatcher.matchfn(splitstandin(f)) - smatcher.matchfn = composed_matchfn + smatcher.matchfn = composedmatchfn return smatcher @@ -296,8 +296,8 @@ '''Return the repo-relative path to the standin for the specified big file.''' # Notes: - # 1) Most callers want an absolute path, but _create_standin() needs - # it repo-relative so lfadd() can pass it to repo_add(). So leave + # 1) Most callers want an absolute path, but _createstandin() needs + # it repo-relative so lfadd() can pass it to repoadd(). So leave # it up to the caller to use repo.wjoin() to get an absolute path. # 2) Join with '/' because that's what dirstate always uses, even on # Windows. Change existing separator to '/' first in case we are @@ -453,7 +453,7 @@ def getstandinsstate(repo): standins = [] matcher = getstandinmatcher(repo) - for standin in dirstate_walk(repo.dirstate, matcher): + for standin in dirstatewalk(repo.dirstate, matcher): lfile = splitstandin(standin) standins.append((lfile, readstandin(repo, lfile))) return standins
--- a/hgext/largefiles/overrides.py Fri Mar 09 15:26:13 2012 +0100 +++ b/hgext/largefiles/overrides.py Fri Mar 09 16:11:52 2012 +0100 @@ -26,7 +26,7 @@ '''overrides scmutil.match so that the matcher it returns will ignore all largefiles''' oldmatch = None # for the closure - def override_match(ctx, pats=[], opts={}, globbed=False, + def overridematch(ctx, pats=[], opts={}, globbed=False, default='relpath'): match = oldmatch(ctx, pats, opts, globbed, default) m = copy.copy(match) @@ -34,10 +34,10 @@ manifest) m._files = filter(notlfile, m._files) m._fmap = set(m._files) - orig_matchfn = m.matchfn - m.matchfn = lambda f: notlfile(f) and orig_matchfn(f) or None + origmatchfn = m.matchfn + m.matchfn = lambda f: notlfile(f) and origmatchfn(f) or None return m - oldmatch = installmatchfn(override_match) + oldmatch = installmatchfn(overridematch) def installmatchfn(f): oldmatch = scmutil.match @@ -53,7 +53,7 @@ restore matchfn to reverse''' scmutil.match = getattr(scmutil.match, 'oldmatch', scmutil.match) -def add_largefiles(ui, repo, *pats, **opts): +def addlargefiles(ui, repo, *pats, **opts): large = opts.pop('large', None) lfsize = lfutil.getminsize( ui, lfutil.islfilesrepo(repo), opts.pop('lfsize', None)) @@ -109,13 +109,13 @@ lfdirstate.add(f) lfdirstate.write() bad += [lfutil.splitstandin(f) - for f in lfutil.repo_add(repo, standins) + for f in lfutil.repoadd(repo, standins) if f in m.files()] finally: wlock.release() return bad -def remove_largefiles(ui, repo, *pats, **opts): +def removelargefiles(ui, repo, *pats, **opts): after = opts.get('after') if not pats and not after: raise util.Abort(_('no files specified')) @@ -164,11 +164,11 @@ lfdirstate.write() forget = [lfutil.standin(f) for f in forget] remove = [lfutil.standin(f) for f in remove] - lfutil.repo_forget(repo, forget) + lfutil.repoforget(repo, forget) # If this is being called by addremove, let the original addremove # function handle this. if not getattr(repo, "_isaddremove", False): - lfutil.repo_remove(repo, remove, unlink=True) + lfutil.reporemove(repo, remove, unlink=True) finally: wlock.release() @@ -178,40 +178,40 @@ # checking if they should be added as largefiles. Then it makes a new # matcher which matches only the normal files and runs the original # version of add. -def override_add(orig, ui, repo, *pats, **opts): +def overrideadd(orig, ui, repo, *pats, **opts): normal = opts.pop('normal') if normal: if opts.get('large'): raise util.Abort(_('--normal cannot be used with --large')) return orig(ui, repo, *pats, **opts) - bad = add_largefiles(ui, repo, *pats, **opts) + bad = addlargefiles(ui, repo, *pats, **opts) installnormalfilesmatchfn(repo[None].manifest()) result = orig(ui, repo, *pats, **opts) restorematchfn() return (result == 1 or bad) and 1 or 0 -def override_remove(orig, ui, repo, *pats, **opts): +def overrideremove(orig, ui, repo, *pats, **opts): installnormalfilesmatchfn(repo[None].manifest()) orig(ui, repo, *pats, **opts) restorematchfn() - remove_largefiles(ui, repo, *pats, **opts) + removelargefiles(ui, repo, *pats, **opts) -def override_status(orig, ui, repo, *pats, **opts): +def overridestatus(orig, ui, repo, *pats, **opts): try: repo.lfstatus = True return orig(ui, repo, *pats, **opts) finally: repo.lfstatus = False -def override_log(orig, ui, repo, *pats, **opts): +def overridelog(orig, ui, repo, *pats, **opts): try: repo.lfstatus = True orig(ui, repo, *pats, **opts) finally: repo.lfstatus = False -def override_verify(orig, ui, repo, *pats, **opts): +def overrideverify(orig, ui, repo, *pats, **opts): large = opts.pop('large', False) all = opts.pop('lfa', False) contents = opts.pop('lfc', False) @@ -225,7 +225,7 @@ # will go through properly. Then the other update hook (overriding repo.update) # will get the new files. Filemerge is also overriden so that the merge # will merge standins correctly. -def override_update(orig, ui, repo, *pats, **opts): +def overrideupdate(orig, ui, repo, *pats, **opts): lfdirstate = lfutil.openlfdirstate(ui, repo) s = lfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False, False, False) @@ -265,7 +265,7 @@ # The overridden function filters the unknown files by removing any # largefiles. This makes the merge proceed and we can then handle this # case further in the overridden manifestmerge function below. -def override_checkunknownfile(origfn, repo, wctx, mctx, f): +def overridecheckunknownfile(origfn, repo, wctx, mctx, f): if lfutil.standin(f) in wctx: return False return origfn(repo, wctx, mctx, f) @@ -296,7 +296,7 @@ # Finally, the merge.applyupdates function will then take care of # writing the files into the working copy and lfcommands.updatelfiles # will update the largefiles. -def override_manifestmerge(origfn, repo, p1, p2, pa, overwrite, partial): +def overridemanifestmerge(origfn, repo, p1, p2, pa, overwrite, partial): actions = origfn(repo, p1, p2, pa, overwrite, partial) processed = [] @@ -339,7 +339,7 @@ # Override filemerge to prompt the user about how they wish to merge # largefiles. This will handle identical edits, and copy/rename + # edit without prompting the user. -def override_filemerge(origfn, repo, mynode, orig, fcd, fco, fca): +def overridefilemerge(origfn, repo, mynode, orig, fcd, fco, fca): # Use better variable names here. Because this is a wrapper we cannot # change the variable names in the function declaration. fcdest, fcother, fcancestor = fcd, fco, fca @@ -384,7 +384,7 @@ # checks if the destination largefile already exists. It also keeps a # list of copied files so that the largefiles can be copied and the # dirstate updated. -def override_copy(orig, ui, repo, pats, opts, rename=False): +def overridecopy(orig, ui, repo, pats, opts, rename=False): # doesn't remove largefile on rename if len(pats) < 2: # this isn't legal, let the original function deal with it @@ -434,7 +434,7 @@ manifest = repo[None].manifest() oldmatch = None # for the closure - def override_match(ctx, pats=[], opts={}, globbed=False, + def overridematch(ctx, pats=[], opts={}, globbed=False, default='relpath'): newpats = [] # The patterns were previously mangled to add the standin @@ -449,13 +449,13 @@ lfile = lambda f: lfutil.standin(f) in manifest m._files = [lfutil.standin(f) for f in m._files if lfile(f)] m._fmap = set(m._files) - orig_matchfn = m.matchfn + origmatchfn = m.matchfn m.matchfn = lambda f: (lfutil.isstandin(f) and (f in manifest) and - orig_matchfn(lfutil.splitstandin(f)) or + origmatchfn(lfutil.splitstandin(f)) or None) return m - oldmatch = installmatchfn(override_match) + oldmatch = installmatchfn(overridematch) listpats = [] for pat in pats: if match_.patkind(pat) is not None: @@ -466,7 +466,7 @@ try: origcopyfile = util.copyfile copiedfiles = [] - def override_copyfile(src, dest): + def overridecopyfile(src, dest): if (lfutil.shortname in src and dest.startswith(repo.wjoin(lfutil.shortname))): destlfile = dest.replace(lfutil.shortname, '') @@ -476,7 +476,7 @@ copiedfiles.append((src, dest)) origcopyfile(src, dest) - util.copyfile = override_copyfile + util.copyfile = overridecopyfile result += orig(ui, repo, listpats, opts, rename) finally: util.copyfile = origcopyfile @@ -521,7 +521,7 @@ # the matcher to hit standins instead of largefiles. Based on the # resulting standins update the largefiles. Then return the standins # to their proper state -def override_revert(orig, ui, repo, *pats, **opts): +def overriderevert(orig, ui, repo, *pats, **opts): # Because we put the standins in a bad state (by updating them) # and then return them to a correct state we need to lock to # prevent others from changing them in their incorrect state. @@ -529,7 +529,7 @@ try: lfdirstate = lfutil.openlfdirstate(ui, repo) (modified, added, removed, missing, unknown, ignored, clean) = \ - lfutil.lfdirstate_status(lfdirstate, repo, repo['.'].rev()) + lfutil.lfdirstatestatus(lfdirstate, repo, repo['.'].rev()) for lfile in modified: lfutil.updatestandin(repo, lfutil.standin(lfile)) for lfile in missing: @@ -538,7 +538,7 @@ try: ctx = repo[opts.get('rev')] oldmatch = None # for the closure - def override_match(ctx, pats=[], opts={}, globbed=False, + def overridematch(ctx, pats=[], opts={}, globbed=False, default='relpath'): match = oldmatch(ctx, pats, opts, globbed, default) m = copy.copy(match) @@ -551,7 +551,7 @@ m._files = [tostandin(f) for f in m._files] m._files = [f for f in m._files if f is not None] m._fmap = set(m._files) - orig_matchfn = m.matchfn + origmatchfn = m.matchfn def matchfn(f): if lfutil.isstandin(f): # We need to keep track of what largefiles are being @@ -560,7 +560,7 @@ # largefiles. This is repo-specific, so duckpunch the # repo object to keep the list of largefiles for us # later. - if orig_matchfn(lfutil.splitstandin(f)) and \ + if origmatchfn(lfutil.splitstandin(f)) and \ (f in repo[None] or f in ctx): lfileslist = getattr(repo, '_lfilestoupdate', []) lfileslist.append(lfutil.splitstandin(f)) @@ -568,12 +568,12 @@ return True else: return False - return orig_matchfn(f) + return origmatchfn(f) m.matchfn = matchfn return m - oldmatch = installmatchfn(override_match) + oldmatch = installmatchfn(overridematch) scmutil.match - matches = override_match(repo[None], pats, opts) + matches = overridematch(repo[None], pats, opts) orig(ui, repo, *pats, **opts) finally: restorematchfn() @@ -601,7 +601,7 @@ finally: wlock.release() -def hg_update(orig, repo, node): +def hgupdate(orig, repo, node): # Only call updatelfiles the standins that have changed to save time oldstandins = lfutil.getstandinsstate(repo) result = orig(repo, node) @@ -610,12 +610,12 @@ lfcommands.updatelfiles(repo.ui, repo, filelist=filelist, printmessage=True) return result -def hg_clean(orig, repo, node, show_stats=True): +def hgclean(orig, repo, node, show_stats=True): result = orig(repo, node, show_stats) lfcommands.updatelfiles(repo.ui, repo) return result -def hg_merge(orig, repo, node, force=None, remind=True): +def hgmerge(orig, repo, node, force=None, remind=True): # Mark the repo as being in the middle of a merge, so that # updatelfiles() will know that it needs to trust the standins in # the working copy, not in the standins in the current node @@ -630,7 +630,7 @@ # When we rebase a repository with remotely changed largefiles, we need to # take some extra care so that the largefiles are correctly updated in the # working copy -def override_pull(orig, ui, repo, source=None, **opts): +def overridepull(orig, ui, repo, source=None, **opts): if opts.get('rebase', False): repo._isrebasing = True try: @@ -677,14 +677,14 @@ ui.status(_("%d largefiles cached\n") % numcached) return result -def override_rebase(orig, ui, repo, **opts): +def overriderebase(orig, ui, repo, **opts): repo._isrebasing = True try: orig(ui, repo, **opts) finally: repo._isrebasing = False -def override_archive(orig, repo, dest, node, kind, decode=True, matchfn=None, +def overridearchive(orig, repo, dest, node, kind, decode=True, matchfn=None, prefix=None, mtime=None, subrepos=None): # No need to lock because we are only reading history and # largefile caches, neither of which are modified. @@ -766,7 +766,7 @@ # standin until a commit. cmdutil.bailifchanged() raises an exception # if the repo has uncommitted changes. Wrap it to also check if # largefiles were changed. This is used by bisect and backout. -def override_bailifchanged(orig, repo): +def overridebailifchanged(orig, repo): orig(repo) repo.lfstatus = True modified, added, removed, deleted = repo.status()[:4] @@ -774,8 +774,8 @@ if modified or added or removed or deleted: raise util.Abort(_('outstanding uncommitted changes')) -# Fetch doesn't use cmdutil.bail_if_changed so override it to add the check -def override_fetch(orig, ui, repo, *pats, **opts): +# Fetch doesn't use cmdutil.bailifchanged so override it to add the check +def overridefetch(orig, ui, repo, *pats, **opts): repo.lfstatus = True modified, added, removed, deleted = repo.status()[:4] repo.lfstatus = False @@ -783,7 +783,7 @@ raise util.Abort(_('outstanding uncommitted changes')) return orig(ui, repo, *pats, **opts) -def override_forget(orig, ui, repo, *pats, **opts): +def overrideforget(orig, ui, repo, *pats, **opts): installnormalfilesmatchfn(repo[None].manifest()) orig(ui, repo, *pats, **opts) restorematchfn() @@ -818,7 +818,7 @@ else: lfdirstate.remove(f) lfdirstate.write() - lfutil.repo_remove(repo, [lfutil.standin(f) for f in forget], + lfutil.reporemove(repo, [lfutil.standin(f) for f in forget], unlink=True) finally: wlock.release() @@ -865,7 +865,7 @@ set([f for f in files if lfutil.isstandin(f) and f in ctx])) return toupload -def override_outgoing(orig, ui, repo, dest=None, **opts): +def overrideoutgoing(orig, ui, repo, dest=None, **opts): orig(ui, repo, dest, **opts) if opts.pop('large', None): @@ -878,7 +878,7 @@ ui.status(lfutil.splitstandin(file) + '\n') ui.status('\n') -def override_summary(orig, ui, repo, *pats, **opts): +def overridesummary(orig, ui, repo, *pats, **opts): try: repo.lfstatus = True orig(ui, repo, *pats, **opts) @@ -892,7 +892,7 @@ else: ui.status(_('largefiles: %d to upload\n') % len(toupload)) -def override_addremove(orig, ui, repo, *pats, **opts): +def overrideaddremove(orig, ui, repo, *pats, **opts): # Get the list of missing largefiles so we can remove them lfdirstate = lfutil.openlfdirstate(ui, repo) s = lfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False, @@ -905,11 +905,11 @@ # confused state later. if missing: repo._isaddremove = True - remove_largefiles(ui, repo, *missing, **opts) + removelargefiles(ui, repo, *missing, **opts) repo._isaddremove = False # Call into the normal add code, and any files that *should* be added as # largefiles will be - add_largefiles(ui, repo, *pats, **opts) + addlargefiles(ui, repo, *pats, **opts) # Now that we've handled largefiles, hand off to the original addremove # function to take care of the rest. Make sure it doesn't do anything with # largefiles by installing a matcher that will ignore them. @@ -920,9 +920,9 @@ # Calling purge with --all will cause the largefiles to be deleted. # Override repo.status to prevent this from happening. -def override_purge(orig, ui, repo, *dirs, **opts): +def overridepurge(orig, ui, repo, *dirs, **opts): oldstatus = repo.status - def override_status(node1='.', node2=None, match=None, ignored=False, + def overridestatus(node1='.', node2=None, match=None, ignored=False, clean=False, unknown=False, listsubrepos=False): r = oldstatus(node1, node2, match, ignored, clean, unknown, listsubrepos) @@ -931,11 +931,11 @@ unknown = [f for f in unknown if lfdirstate[f] == '?'] ignored = [f for f in ignored if lfdirstate[f] == '?'] return modified, added, removed, deleted, unknown, ignored, clean - repo.status = override_status + repo.status = overridestatus orig(ui, repo, *dirs, **opts) repo.status = oldstatus -def override_rollback(orig, ui, repo, **opts): +def overriderollback(orig, ui, repo, **opts): result = orig(ui, repo, **opts) merge.update(repo, node=None, branchmerge=False, force=True, partial=lfutil.isstandin) @@ -954,7 +954,7 @@ wlock.release() return result -def override_transplant(orig, ui, repo, *revs, **opts): +def overridetransplant(orig, ui, repo, *revs, **opts): try: oldstandins = lfutil.getstandinsstate(repo) repo._istransplanting = True
--- a/hgext/largefiles/proto.py Fri Mar 09 15:26:13 2012 +0100 +++ b/hgext/largefiles/proto.py Fri Mar 09 16:11:52 2012 +0100 @@ -131,15 +131,15 @@ # advertise the largefiles=serve capability def capabilities(repo, proto): - return capabilities_orig(repo, proto) + ' largefiles=serve' + return capabilitiesorig(repo, proto) + ' largefiles=serve' # duplicate what Mercurial's new out-of-band errors mechanism does, because # clients old and new alike both handle it well -def webproto_refuseclient(self, message): +def webprotorefuseclient(self, message): self.req.header([('Content-Type', 'application/hg-error')]) return message -def sshproto_refuseclient(self, message): +def sshprotorefuseclient(self, message): self.ui.write_err('%s\n-\n' % message) self.fout.write('\n') self.fout.flush() @@ -151,16 +151,16 @@ return wireproto.ooberror(LARGEFILES_REQUIRED_MSG) return wireproto.heads(repo, proto) -def sshrepo_callstream(self, cmd, **args): +def sshrepocallstream(self, cmd, **args): if cmd == 'heads' and self.capable('largefiles'): cmd = 'lheads' if cmd == 'batch' and self.capable('largefiles'): args['cmds'] = args['cmds'].replace('heads ', 'lheads ') - return ssh_oldcallstream(self, cmd, **args) + return ssholdcallstream(self, cmd, **args) -def httprepo_callstream(self, cmd, **args): +def httprepocallstream(self, cmd, **args): if cmd == 'heads' and self.capable('largefiles'): cmd = 'lheads' if cmd == 'batch' and self.capable('largefiles'): args['cmds'] = args['cmds'].replace('heads ', 'lheads ') - return http_oldcallstream(self, cmd, **args) + return httpoldcallstream(self, cmd, **args)
--- a/hgext/largefiles/reposetup.py Fri Mar 09 15:26:13 2012 +0100 +++ b/hgext/largefiles/reposetup.py Fri Mar 09 16:11:52 2012 +0100 @@ -34,54 +34,54 @@ 'largefiles may behave incorrectly\n') % name) - class lfiles_repo(repo.__class__): + class lfilesrepo(repo.__class__): lfstatus = False def status_nolfiles(self, *args, **kwargs): - return super(lfiles_repo, self).status(*args, **kwargs) + return super(lfilesrepo, self).status(*args, **kwargs) # When lfstatus is set, return a context that gives the names # of largefiles instead of their corresponding standins and # identifies the largefiles as always binary, regardless of # their actual contents. def __getitem__(self, changeid): - ctx = super(lfiles_repo, self).__getitem__(changeid) + ctx = super(lfilesrepo, self).__getitem__(changeid) if self.lfstatus: - class lfiles_manifestdict(manifest.manifestdict): + class lfilesmanifestdict(manifest.manifestdict): def __contains__(self, filename): - if super(lfiles_manifestdict, + if super(lfilesmanifestdict, self).__contains__(filename): return True - return super(lfiles_manifestdict, + return super(lfilesmanifestdict, self).__contains__(lfutil.standin(filename)) - class lfiles_ctx(ctx.__class__): + class lfilesctx(ctx.__class__): def files(self): - filenames = super(lfiles_ctx, self).files() + filenames = super(lfilesctx, self).files() return [lfutil.splitstandin(f) or f for f in filenames] def manifest(self): - man1 = super(lfiles_ctx, self).manifest() - man1.__class__ = lfiles_manifestdict + man1 = super(lfilesctx, self).manifest() + man1.__class__ = lfilesmanifestdict return man1 def filectx(self, path, fileid=None, filelog=None): try: if filelog is not None: - result = super(lfiles_ctx, self).filectx( + result = super(lfilesctx, self).filectx( path, fileid, filelog) else: - result = super(lfiles_ctx, self).filectx( + result = super(lfilesctx, self).filectx( path, fileid) except error.LookupError: # Adding a null character will cause Mercurial to # identify this as a binary file. if filelog is not None: - result = super(lfiles_ctx, self).filectx( + result = super(lfilesctx, self).filectx( lfutil.standin(path), fileid, filelog) else: - result = super(lfiles_ctx, self).filectx( + result = super(lfilesctx, self).filectx( lfutil.standin(path), fileid) olddata = result.data result.data = lambda: olddata() + '\0' return result - ctx.__class__ = lfiles_ctx + ctx.__class__ = lfilesctx return ctx # Figure out the status of big files and insert them into the @@ -92,7 +92,7 @@ clean=False, unknown=False, listsubrepos=False): listignored, listclean, listunknown = ignored, clean, unknown if not self.lfstatus: - return super(lfiles_repo, self).status(node1, node2, match, + return super(lfilesrepo, self).status(node1, node2, match, listignored, listclean, listunknown, listsubrepos) else: # some calls in this function rely on the old version of status @@ -130,7 +130,7 @@ if match(f): break else: - return super(lfiles_repo, self).status(node1, node2, + return super(lfilesrepo, self).status(node1, node2, match, listignored, listclean, listunknown, listsubrepos) @@ -154,7 +154,7 @@ # Get ignored files here even if we weren't asked for them; we # must use the result here for filtering later - result = super(lfiles_repo, self).status(node1, node2, m, + result = super(lfilesrepo, self).status(node1, node2, m, True, clean, unknown, listsubrepos) if working: try: @@ -164,7 +164,7 @@ # super's status. # Override lfdirstate's ignore matcher to not do # anything - orig_ignore = lfdirstate._ignore + origignore = lfdirstate._ignore lfdirstate._ignore = _ignoreoverride match._files = [f for f in match._files if f in @@ -209,7 +209,7 @@ added.append(lfile) finally: # Replace the original ignore function - lfdirstate._ignore = orig_ignore + lfdirstate._ignore = origignore for standin in ctx1.manifest(): if not lfutil.isstandin(standin): @@ -265,7 +265,7 @@ # As part of committing, copy all of the largefiles into the # cache. def commitctx(self, *args, **kwargs): - node = super(lfiles_repo, self).commitctx(*args, **kwargs) + node = super(lfilesrepo, self).commitctx(*args, **kwargs) lfutil.copyalltostore(self, node) return node @@ -274,7 +274,7 @@ # Do that here. def commit(self, text="", user=None, date=None, match=None, force=False, editor=False, extra={}): - orig = super(lfiles_repo, self).commit + orig = super(lfilesrepo, self).commit wlock = repo.wlock() try: @@ -343,7 +343,7 @@ # Case 2: user calls commit with specified patterns: refresh # any matching big files. smatcher = lfutil.composestandinmatcher(self, match) - standins = lfutil.dirstate_walk(self.dirstate, smatcher) + standins = lfutil.dirstatewalk(self.dirstate, smatcher) # No matching big files: get out of the way and pass control to # the usual commit() method. @@ -371,7 +371,7 @@ # complaining "not tracked" for big files. lfiles = lfutil.listlfiles(repo) match = copy.copy(match) - orig_matchfn = match.matchfn + origmatchfn = match.matchfn # Check both the list of largefiles and the list of # standins because if a largefile was removed, it @@ -398,7 +398,7 @@ match._files = actualfiles def matchfn(f): - if orig_matchfn(f): + if origmatchfn(f): return f not in lfiles else: return f in standins @@ -443,10 +443,10 @@ for f in files if lfutil.isstandin(f) and f in ctx])) lfcommands.uploadlfiles(ui, self, remote, toupload) - return super(lfiles_repo, self).push(remote, force, revs, + return super(lfilesrepo, self).push(remote, force, revs, newbranch) - repo.__class__ = lfiles_repo + repo.__class__ = lfilesrepo def checkrequireslfiles(ui, repo, **kwargs): if 'largefiles' not in repo.requirements and util.any(
--- a/hgext/largefiles/uisetup.py Fri Mar 09 15:26:13 2012 +0100 +++ b/hgext/largefiles/uisetup.py Fri Mar 09 16:11:52 2012 +0100 @@ -21,7 +21,7 @@ # files in the result are under Mercurial's control entry = extensions.wrapcommand(commands.table, 'add', - overrides.override_add) + overrides.overrideadd) addopt = [('', 'large', None, _('add as largefile')), ('', 'normal', None, _('add as normal file')), ('', 'lfsize', '', _('add all files above this size ' @@ -30,19 +30,19 @@ entry[1].extend(addopt) entry = extensions.wrapcommand(commands.table, 'addremove', - overrides.override_addremove) + overrides.overrideaddremove) entry = extensions.wrapcommand(commands.table, 'remove', - overrides.override_remove) + overrides.overrideremove) entry = extensions.wrapcommand(commands.table, 'forget', - overrides.override_forget) + overrides.overrideforget) entry = extensions.wrapcommand(commands.table, 'status', - overrides.override_status) + overrides.overridestatus) entry = extensions.wrapcommand(commands.table, 'log', - overrides.override_log) + overrides.overridelog) entry = extensions.wrapcommand(commands.table, 'rollback', - overrides.override_rollback) + overrides.overriderollback) entry = extensions.wrapcommand(commands.table, 'verify', - overrides.override_verify) + overrides.overrideverify) verifyopt = [('', 'large', None, _('verify largefiles')), ('', 'lfa', None, @@ -52,44 +52,44 @@ entry[1].extend(verifyopt) entry = extensions.wrapcommand(commands.table, 'outgoing', - overrides.override_outgoing) + overrides.overrideoutgoing) outgoingopt = [('', 'large', None, _('display outgoing largefiles'))] entry[1].extend(outgoingopt) entry = extensions.wrapcommand(commands.table, 'summary', - overrides.override_summary) + overrides.overridesummary) summaryopt = [('', 'large', None, _('display outgoing largefiles'))] entry[1].extend(summaryopt) entry = extensions.wrapcommand(commands.table, 'update', - overrides.override_update) + overrides.overrideupdate) entry = extensions.wrapcommand(commands.table, 'pull', - overrides.override_pull) + overrides.overridepull) entry = extensions.wrapfunction(merge, '_checkunknownfile', - overrides.override_checkunknownfile) + overrides.overridecheckunknownfile) entry = extensions.wrapfunction(merge, 'manifestmerge', - overrides.override_manifestmerge) + overrides.overridemanifestmerge) entry = extensions.wrapfunction(filemerge, 'filemerge', - overrides.override_filemerge) + overrides.overridefilemerge) entry = extensions.wrapfunction(cmdutil, 'copy', - overrides.override_copy) + overrides.overridecopy) # Backout calls revert so we need to override both the command and the # function entry = extensions.wrapcommand(commands.table, 'revert', - overrides.override_revert) + overrides.overriderevert) entry = extensions.wrapfunction(commands, 'revert', - overrides.override_revert) + overrides.overriderevert) # clone uses hg._update instead of hg.update even though they are the # same function... so wrap both of them) - extensions.wrapfunction(hg, 'update', overrides.hg_update) - extensions.wrapfunction(hg, '_update', overrides.hg_update) - extensions.wrapfunction(hg, 'clean', overrides.hg_clean) - extensions.wrapfunction(hg, 'merge', overrides.hg_merge) + extensions.wrapfunction(hg, 'update', overrides.hgupdate) + extensions.wrapfunction(hg, '_update', overrides.hgupdate) + extensions.wrapfunction(hg, 'clean', overrides.hgclean) + extensions.wrapfunction(hg, 'merge', overrides.hgmerge) - extensions.wrapfunction(archival, 'archive', overrides.override_archive) + extensions.wrapfunction(archival, 'archive', overrides.overridearchive) extensions.wrapfunction(cmdutil, 'bailifchanged', - overrides.override_bailifchanged) + overrides.overridebailifchanged) # create the new wireproto commands ... wireproto.commands['putlfile'] = (proto.putlfile, 'sha') @@ -109,20 +109,20 @@ # the hello wireproto command uses wireproto.capabilities, so it won't see # our largefiles capability unless we replace the actual function as well. - proto.capabilities_orig = wireproto.capabilities + proto.capabilitiesorig = wireproto.capabilities wireproto.capabilities = proto.capabilities # these let us reject non-largefiles clients and make them display # our error messages - protocol.webproto.refuseclient = proto.webproto_refuseclient - sshserver.sshserver.refuseclient = proto.sshproto_refuseclient + protocol.webproto.refuseclient = proto.webprotorefuseclient + sshserver.sshserver.refuseclient = proto.sshprotorefuseclient # can't do this in reposetup because it needs to have happened before # wirerepo.__init__ is called - proto.ssh_oldcallstream = sshrepo.sshrepository._callstream - proto.http_oldcallstream = httprepo.httprepository._callstream - sshrepo.sshrepository._callstream = proto.sshrepo_callstream - httprepo.httprepository._callstream = proto.httprepo_callstream + proto.ssholdcallstream = sshrepo.sshrepository._callstream + proto.httpoldcallstream = httprepo.httprepository._callstream + sshrepo.sshrepository._callstream = proto.sshrepocallstream + httprepo.httprepository._callstream = proto.httprepocallstream # don't die on seeing a repo with the largefiles requirement localrepo.localrepository.supported |= set(['largefiles']) @@ -131,13 +131,13 @@ for name, module in extensions.extensions(): if name == 'fetch': extensions.wrapcommand(getattr(module, 'cmdtable'), 'fetch', - overrides.override_fetch) + overrides.overridefetch) if name == 'purge': extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge', - overrides.override_purge) + overrides.overridepurge) if name == 'rebase': extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase', - overrides.override_rebase) + overrides.overriderebase) if name == 'transplant': extensions.wrapcommand(getattr(module, 'cmdtable'), 'transplant', - overrides.override_transplant) + overrides.overridetransplant)