largefiles: fix check-code errors.

hgext/largefiles/overrides.py

@@ -1,968 +1,968 b''
 # Copyright 2009-2010 Gregory P. Ward
 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
 # Copyright 2010-2011 Fog Creek Software
 # Copyright 2010-2011 Unity Technologies
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''Overridden Mercurial commands and functions for the largefiles extension'''
 
 import os
 import copy
 
 from mercurial import hg, commands, util, cmdutil, scmutil, match as match_, \
     node, archival, error, merge
 from mercurial.i18n import _
 from mercurial.node import hex
 from hgext import rebase
 
 import lfutil
 import lfcommands
 
 # -- Utility functions: commonly/repeatedly needed functionality ---------------
 
 def installnormalfilesmatchfn(manifest):
     '''overrides scmutil.match so that the matcher it returns will ignore all
     largefiles'''
     oldmatch = None # for the closure
     def overridematch(ctx, pats=[], opts={}, globbed=False,
             default='relpath'):
         match = oldmatch(ctx, pats, opts, globbed, default)
         m = copy.copy(match)
         notlfile = lambda f: not (lfutil.isstandin(f) or lfutil.standin(f) in
                 manifest)
         m._files = filter(notlfile, m._files)
         m._fmap = set(m._files)
         origmatchfn = m.matchfn
         m.matchfn = lambda f: notlfile(f) and origmatchfn(f) or None
         return m
     oldmatch = installmatchfn(overridematch)
 
 def installmatchfn(f):
     oldmatch = scmutil.match
     setattr(f, 'oldmatch', oldmatch)
     scmutil.match = f
     return oldmatch
 
 def restorematchfn():
     '''restores scmutil.match to what it was before installnormalfilesmatchfn
     was called.  no-op if scmutil.match is its original function.
 
     Note that n calls to installnormalfilesmatchfn will require n calls to
     restore matchfn to reverse'''
     scmutil.match = getattr(scmutil.match, 'oldmatch', scmutil.match)
 
 def addlargefiles(ui, repo, *pats, **opts):
     large = opts.pop('large', None)
     lfsize = lfutil.getminsize(
         ui, lfutil.islfilesrepo(repo), opts.pop('lfsize', None))
 
     lfmatcher = None
     if lfutil.islfilesrepo(repo):
         lfpats = ui.configlist(lfutil.longname, 'patterns', default=[])
         if lfpats:
             lfmatcher = match_.match(repo.root, '', list(lfpats))
 
     lfnames = []
     m = scmutil.match(repo[None], pats, opts)
     m.bad = lambda x, y: None
     wctx = repo[None]
     for f in repo.walk(m):
         exact = m.exact(f)
         lfile = lfutil.standin(f) in wctx
         nfile = f in wctx
         exists = lfile or nfile
 
         # Don't warn the user when they attempt to add a normal tracked file.
         # The normal add code will do that for us.
         if exact and exists:
             if lfile:
                 ui.warn(_('%s already a largefile\n') % f)
             continue
 
         if exact or not exists:
             abovemin = (lfsize and
                         os.lstat(repo.wjoin(f)).st_size >= lfsize * 1024 * 1024)
             if large or abovemin or (lfmatcher and lfmatcher(f)):
                 lfnames.append(f)
                 if ui.verbose or not exact:
                     ui.status(_('adding %s as a largefile\n') % m.rel(f))
 
     bad = []
     standins = []
 
     # Need to lock, otherwise there could be a race condition between
     # when standins are created and added to the repo.
     wlock = repo.wlock()
     try:
         if not opts.get('dry_run'):
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             for f in lfnames:
                 standinname = lfutil.standin(f)
                 lfutil.writestandin(repo, standinname, hash='',
                     executable=lfutil.getexecutable(repo.wjoin(f)))
                 standins.append(standinname)
                 if lfdirstate[f] == 'r':
                     lfdirstate.normallookup(f)
                 else:
                     lfdirstate.add(f)
             lfdirstate.write()
             bad += [lfutil.splitstandin(f)
                     for f in lfutil.repoadd(repo, standins)
                     if f in m.files()]
     finally:
         wlock.release()
     return bad
 
 def removelargefiles(ui, repo, *pats, **opts):
     after = opts.get('after')
     if not pats and not after:
         raise util.Abort(_('no files specified'))
     m = scmutil.match(repo[None], pats, opts)
     try:
         repo.lfstatus = True
         s = repo.status(match=m, clean=True)
     finally:
         repo.lfstatus = False
     manifest = repo[None].manifest()
     modified, added, deleted, clean = [[f for f in list
                                         if lfutil.standin(f) in manifest]
                                        for list in [s[0], s[1], s[3], s[6]]]
 
     def warn(files, reason):
         for f in files:
             ui.warn(_('not removing %s: %s (use forget to undo)\n')
                     % (m.rel(f), reason))
 
     if after:
         remove, forget = deleted, []
         warn(modified + added + clean, _('file still exists'))
     else:
         remove, forget = deleted + clean, []
         warn(modified, _('file is modified'))
         warn(added, _('file has been marked for add'))
 
     for f in sorted(remove + forget):
         if ui.verbose or not m.exact(f):
             ui.status(_('removing %s\n') % m.rel(f))
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race inbetween.
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in remove:
             if not after:
                 # If this is being called by addremove, notify the user that we
                 # are removing the file.
                 if getattr(repo, "_isaddremove", False):
                     ui.status(_('removing %s\n') % f)
                 if os.path.exists(repo.wjoin(f)):
                     util.unlinkpath(repo.wjoin(f))
             lfdirstate.remove(f)
         lfdirstate.write()
         forget = [lfutil.standin(f) for f in forget]
         remove = [lfutil.standin(f) for f in remove]
         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.reporemove(repo, remove, unlink=True)
     finally:
         wlock.release()
 
 # -- Wrappers: modify existing commands --------------------------------
 
 # Add works by going through the files that the user wanted to add and
 # 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 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 = 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 overrideremove(orig, ui, repo, *pats, **opts):
     installnormalfilesmatchfn(repo[None].manifest())
     orig(ui, repo, *pats, **opts)
     restorematchfn()
     removelargefiles(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 overridelog(orig, ui, repo, *pats, **opts):
     try:
         repo.lfstatus = True
         orig(ui, repo, *pats, **opts)
     finally:
         repo.lfstatus = False
 
 def overrideverify(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', False)
     all = opts.pop('lfa', False)
     contents = opts.pop('lfc', False)
 
     result = orig(ui, repo, *pats, **opts)
     if large:
         result = result or lfcommands.verifylfiles(ui, repo, all, contents)
     return result
 
 # Override needs to refresh standins so that update's normal merge
 # 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 overrideupdate(orig, ui, repo, *pats, **opts):
     lfdirstate = lfutil.openlfdirstate(ui, repo)
     s = lfdirstate.status(match_.always(repo.root, repo.getcwd()), [], False,
         False, False)
     (unsure, modified, added, removed, missing, unknown, ignored, clean) = s
 
     # Need to lock between the standins getting updated and their
     # largefiles getting updated
     wlock = repo.wlock()
     try:
         if opts['check']:
             mod = len(modified) > 0
             for lfile in unsure:
                 standin = lfutil.standin(lfile)
                 if repo['.'][standin].data().strip() != \
                         lfutil.hashfile(repo.wjoin(lfile)):
                     mod = True
                 else:
                     lfdirstate.normal(lfile)
             lfdirstate.write()
             if mod:
                 raise util.Abort(_('uncommitted local changes'))
         # XXX handle removed differently
         if not opts['clean']:
             for lfile in unsure + modified + added:
                 lfutil.updatestandin(repo, lfutil.standin(lfile))
     finally:
         wlock.release()
     return orig(ui, repo, *pats, **opts)
 
 # Before starting the manifest merge, merge.updates will call
 # _checkunknown to check if there are any files in the merged-in
 # changeset that collide with unknown files in the working copy.
 #
 # The largefiles are seen as unknown, so this prevents us from merging
 # in a file 'foo' if we already have a largefile with the same name.
 #
 # 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 overridecheckunknownfile(origfn, repo, wctx, mctx, f):
     if lfutil.standin(f) in wctx:
         return False
     return origfn(repo, wctx, mctx, f)
 
 # The manifest merge handles conflicts on the manifest level. We want
 # to handle changes in largefile-ness of files at this level too.
 #
 # The strategy is to run the original manifestmerge and then process
 # the action list it outputs. There are two cases we need to deal with:
 #
 # 1. Normal file in p1, largefile in p2. Here the largefile is
 #    detected via its standin file, which will enter the working copy
 #    with a "get" action. It is not "merge" since the standin is all
 #    Mercurial is concerned with at this level -- the link to the
 #    existing normal file is not relevant here.
 #
 # 2. Largefile in p1, normal file in p2. Here we get a "merge" action
 #    since the largefile will be present in the working copy and
 #    different from the normal file in p2. Mercurial therefore
 #    triggers a merge action.
 #
 # In both cases, we prompt the user and emit new actions to either
 # remove the standin (if the normal file was kept) or to remove the
 # normal file and get the standin (if the largefile was kept). The
 # default prompt answer is to use the largefile version since it was
 # presumably changed on purpose.
 #
 # 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 overridemanifestmerge(origfn, repo, p1, p2, pa, overwrite, partial):
     actions = origfn(repo, p1, p2, pa, overwrite, partial)
     processed = []
 
     for action in actions:
         if overwrite:
             processed.append(action)
             continue
         f, m = action[:2]
 
         choices = (_('&Largefile'), _('&Normal file'))
         if m == "g" and lfutil.splitstandin(f) in p1 and f in p2:
             # Case 1: normal file in the working copy, largefile in
             # the second parent
             lfile = lfutil.splitstandin(f)
             standin = f
             msg = _('%s has been turned into a largefile\n'
                     'use (l)argefile or keep as (n)ormal file?') % lfile
             if repo.ui.promptchoice(msg, choices, 0) == 0:
                 processed.append((lfile, "r"))
                 processed.append((standin, "g", p2.flags(standin)))
             else:
                 processed.append((standin, "r"))
         elif m == "g" and lfutil.standin(f) in p1 and f in p2:
             # Case 2: largefile in the working copy, normal file in
             # the second parent
             standin = lfutil.standin(f)
             lfile = f
             msg = _('%s has been turned into a normal file\n'
                     'keep as (l)argefile or use (n)ormal file?') % lfile
             if repo.ui.promptchoice(msg, choices, 0) == 0:
                 processed.append((lfile, "r"))
             else:
                 processed.append((standin, "r"))
                 processed.append((lfile, "g", p2.flags(lfile)))
         else:
             processed.append(action)
 
     return processed
 
 # 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 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
     if not lfutil.isstandin(orig):
         return origfn(repo, mynode, orig, fcdest, fcother, fcancestor)
     else:
         if not fcother.cmp(fcdest): # files identical?
             return None
 
         # backwards, use working dir parent as ancestor
         if fcancestor == fcother:
             fcancestor = fcdest.parents()[0]
 
         if orig != fcother.path():
             repo.ui.status(_('merging %s and %s to %s\n')
                            % (lfutil.splitstandin(orig),
                               lfutil.splitstandin(fcother.path()),
                               lfutil.splitstandin(fcdest.path())))
         else:
             repo.ui.status(_('merging %s\n')
                            % lfutil.splitstandin(fcdest.path()))
 
         if fcancestor.path() != fcother.path() and fcother.data() == \
                 fcancestor.data():
             return 0
         if fcancestor.path() != fcdest.path() and fcdest.data() == \
                 fcancestor.data():
             repo.wwrite(fcdest.path(), fcother.data(), fcother.flags())
             return 0
 
         if repo.ui.promptchoice(_('largefile %s has a merge conflict\n'
                              'keep (l)ocal or take (o)ther?') %
                              lfutil.splitstandin(orig),
                              (_('&Local'), _('&Other')), 0) == 0:
             return 0
         else:
             repo.wwrite(fcdest.path(), fcother.data(), fcother.flags())
             return 0
 
 # Copy first changes the matchers to match standins instead of
 # largefiles.  Then it overrides util.copyfile in that function it
 # 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 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
         return orig(ui, repo, pats, opts, rename)
 
     def makestandin(relpath):
         path = scmutil.canonpath(repo.root, repo.getcwd(), relpath)
         return os.path.join(repo.wjoin(lfutil.standin(path)))
 
     fullpats = scmutil.expandpats(pats)
     dest = fullpats[-1]
 
     if os.path.isdir(dest):
         if not os.path.isdir(makestandin(dest)):
             os.makedirs(makestandin(dest))
     # This could copy both lfiles and normal files in one command,
     # but we don't want to do that. First replace their matcher to
     # only match normal files and run it, then replace it to just
     # match largefiles and run it again.
     nonormalfiles = False
     nolfiles = False
     try:
         try:
             installnormalfilesmatchfn(repo[None].manifest())
             result = orig(ui, repo, pats, opts, rename)
         except util.Abort, e:
             if str(e) != 'no files to copy':
                 raise e
             else:
                 nonormalfiles = True
             result = 0
     finally:
         restorematchfn()
 
     # The first rename can cause our current working directory to be removed.
     # In that case there is nothing left to copy/rename so just quit.
     try:
         repo.getcwd()
     except OSError:
         return result
 
     try:
         try:
-            # When we call orig below it creates the standins but we don't add them
-            # to the dir state until later so lock during that time.
+            # When we call orig below it creates the standins but we don't add
+            # them to the dir state until later so lock during that time.
             wlock = repo.wlock()
 
             manifest = repo[None].manifest()
             oldmatch = None # for the closure
             def overridematch(ctx, pats=[], opts={}, globbed=False,
                     default='relpath'):
                 newpats = []
                 # The patterns were previously mangled to add the standin
                 # directory; we need to remove that now
                 for pat in pats:
                     if match_.patkind(pat) is None and lfutil.shortname in pat:
                         newpats.append(pat.replace(lfutil.shortname, ''))
                     else:
                         newpats.append(pat)
                 match = oldmatch(ctx, newpats, opts, globbed, default)
                 m = copy.copy(match)
                 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)
                 origmatchfn = m.matchfn
                 m.matchfn = lambda f: (lfutil.isstandin(f) and
                                     (f in manifest) and
                                     origmatchfn(lfutil.splitstandin(f)) or
                                     None)
                 return m
             oldmatch = installmatchfn(overridematch)
             listpats = []
             for pat in pats:
                 if match_.patkind(pat) is not None:
                     listpats.append(pat)
                 else:
                     listpats.append(makestandin(pat))
 
             try:
                 origcopyfile = util.copyfile
                 copiedfiles = []
                 def overridecopyfile(src, dest):
                     if (lfutil.shortname in src and
                         dest.startswith(repo.wjoin(lfutil.shortname))):
                         destlfile = dest.replace(lfutil.shortname, '')
                         if not opts['force'] and os.path.exists(destlfile):
                             raise IOError('',
                                 _('destination largefile already exists'))
                     copiedfiles.append((src, dest))
                     origcopyfile(src, dest)
 
                 util.copyfile = overridecopyfile
                 result += orig(ui, repo, listpats, opts, rename)
             finally:
                 util.copyfile = origcopyfile
 
             lfdirstate = lfutil.openlfdirstate(ui, repo)
             for (src, dest) in copiedfiles:
                 if (lfutil.shortname in src and
                     dest.startswith(repo.wjoin(lfutil.shortname))):
                     srclfile = src.replace(repo.wjoin(lfutil.standin('')), '')
                     destlfile = dest.replace(repo.wjoin(lfutil.standin('')), '')
                     destlfiledir = os.path.dirname(destlfile) or '.'
                     if not os.path.isdir(destlfiledir):
                         os.makedirs(destlfiledir)
                     if rename:
                         os.rename(repo.wjoin(srclfile), repo.wjoin(destlfile))
                         lfdirstate.remove(srclfile)
                     else:
                         util.copyfile(srclfile, destlfile)
                     lfdirstate.add(destlfile)
             lfdirstate.write()
         except util.Abort, e:
             if str(e) != 'no files to copy':
                 raise e
             else:
                 nolfiles = True
     finally:
         restorematchfn()
         wlock.release()
 
     if nolfiles and nonormalfiles:
         raise util.Abort(_('no files to copy'))
 
     return result
 
 # When the user calls revert, we have to be careful to not revert any
 # changes to other largefiles accidentally. This means we have to keep
 # track of the largefiles that are being reverted so we only pull down
 # the necessary largefiles.
 #
 # Standins are only updated (to match the hash of largefiles) before
 # commits. Update the standins then run the original revert, changing
 # 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 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.
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         (modified, added, removed, missing, unknown, ignored, clean) = \
             lfutil.lfdirstatestatus(lfdirstate, repo, repo['.'].rev())
         for lfile in modified:
             lfutil.updatestandin(repo, lfutil.standin(lfile))
         for lfile in missing:
             os.unlink(repo.wjoin(lfutil.standin(lfile)))
 
         try:
             ctx = repo[opts.get('rev')]
             oldmatch = None # for the closure
             def overridematch(ctx, pats=[], opts={}, globbed=False,
                     default='relpath'):
                 match = oldmatch(ctx, pats, opts, globbed, default)
                 m = copy.copy(match)
                 def tostandin(f):
                     if lfutil.standin(f) in ctx:
                         return lfutil.standin(f)
                     elif lfutil.standin(f) in repo[None]:
                         return None
                     return f
                 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)
                 origmatchfn = m.matchfn
                 def matchfn(f):
                     if lfutil.isstandin(f):
                         # We need to keep track of what largefiles are being
                         # matched so we know which ones to update later --
                         # otherwise we accidentally revert changes to other
                         # largefiles. This is repo-specific, so duckpunch the
                         # repo object to keep the list of largefiles for us
                         # later.
                         if origmatchfn(lfutil.splitstandin(f)) and \
                                 (f in repo[None] or f in ctx):
                             lfileslist = getattr(repo, '_lfilestoupdate', [])
                             lfileslist.append(lfutil.splitstandin(f))
                             repo._lfilestoupdate = lfileslist
                             return True
                         else:
                             return False
                     return origmatchfn(f)
                 m.matchfn = matchfn
                 return m
             oldmatch = installmatchfn(overridematch)
             scmutil.match
             matches = overridematch(repo[None], pats, opts)
             orig(ui, repo, *pats, **opts)
         finally:
             restorematchfn()
         lfileslist = getattr(repo, '_lfilestoupdate', [])
         lfcommands.updatelfiles(ui, repo, filelist=lfileslist,
                                 printmessage=False)
 
         # empty out the largefiles list so we start fresh next time
         repo._lfilestoupdate = []
         for lfile in modified:
             if lfile in lfileslist:
                 if os.path.exists(repo.wjoin(lfutil.standin(lfile))) and lfile\
                         in repo['.']:
                     lfutil.writestandin(repo, lfutil.standin(lfile),
                         repo['.'][lfile].data().strip(),
                         'x' in repo['.'][lfile].flags())
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for lfile in added:
             standin = lfutil.standin(lfile)
             if standin not in ctx and (standin in matches or opts.get('all')):
                 if lfile in lfdirstate:
                     lfdirstate.drop(lfile)
                 util.unlinkpath(repo.wjoin(standin))
         lfdirstate.write()
     finally:
         wlock.release()
 
 def hgupdate(orig, repo, node):
     # Only call updatelfiles the standins that have changed to save time
     oldstandins = lfutil.getstandinsstate(repo)
     result = orig(repo, node)
     newstandins = lfutil.getstandinsstate(repo)
     filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
     lfcommands.updatelfiles(repo.ui, repo, filelist=filelist, printmessage=True)
     return result
 
 def hgclean(orig, repo, node, show_stats=True):
     result = orig(repo, node, show_stats)
     lfcommands.updatelfiles(repo.ui, repo)
     return result
 
 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
     repo._ismerging = True
     try:
         result = orig(repo, node, force, remind)
         lfcommands.updatelfiles(repo.ui, repo)
     finally:
         repo._ismerging = False
     return result
 
 # 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 overridepull(orig, ui, repo, source=None, **opts):
     if opts.get('rebase', False):
         repo._isrebasing = True
         try:
             if opts.get('update'):
                  del opts['update']
                  ui.debug('--update and --rebase are not compatible, ignoring '
                           'the update flag\n')
             del opts['rebase']
             cmdutil.bailifchanged(repo)
             revsprepull = len(repo)
             origpostincoming = commands.postincoming
             def _dummy(*args, **kwargs):
                 pass
             commands.postincoming = _dummy
             repo.lfpullsource = source
             if not source:
                 source = 'default'
             try:
                 result = commands.pull(ui, repo, source, **opts)
             finally:
                 commands.postincoming = origpostincoming
             revspostpull = len(repo)
             if revspostpull > revsprepull:
                 result = result or rebase.rebase(ui, repo)
         finally:
             repo._isrebasing = False
     else:
         repo.lfpullsource = source
         if not source:
             source = 'default'
         oldheads = lfutil.getcurrentheads(repo)
         result = orig(ui, repo, source, **opts)
         # If we do not have the new largefiles for any new heads we pulled, we
         # will run into a problem later if we try to merge or rebase with one of
         # these heads, so cache the largefiles now direclty into the system
         # cache.
         ui.status(_("caching new largefiles\n"))
         numcached = 0
         heads = lfutil.getcurrentheads(repo)
         newheads = set(heads).difference(set(oldheads))
         for head in newheads:
             (cached, missing) = lfcommands.cachelfiles(ui, repo, head)
             numcached += len(cached)
         ui.status(_("%d largefiles cached\n") % numcached)
     return result
 
 def overriderebase(orig, ui, repo, **opts):
     repo._isrebasing = True
     try:
         orig(ui, repo, **opts)
     finally:
         repo._isrebasing = False
 
 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.
     lfcommands.cachelfiles(repo.ui, repo, node)
 
     if kind not in archival.archivers:
         raise util.Abort(_("unknown archive type '%s'") % kind)
 
     ctx = repo[node]
 
     if kind == 'files':
         if prefix:
             raise util.Abort(
                 _('cannot give prefix when archiving to files'))
     else:
         prefix = archival.tidyprefix(dest, kind, prefix)
 
     def write(name, mode, islink, getdata):
         if matchfn and not matchfn(name):
             return
         data = getdata()
         if decode:
             data = repo.wwritedata(name, data)
         archiver.addfile(prefix + name, mode, islink, data)
 
     archiver = archival.archivers[kind](dest, mtime or ctx.date()[0])
 
     if repo.ui.configbool("ui", "archivemeta", True):
         def metadata():
             base = 'repo: %s\nnode: %s\nbranch: %s\n' % (
                 hex(repo.changelog.node(0)), hex(node), ctx.branch())
 
             tags = ''.join('tag: %s\n' % t for t in ctx.tags()
                            if repo.tagtype(t) == 'global')
             if not tags:
                 repo.ui.pushbuffer()
                 opts = {'template': '{latesttag}\n{latesttagdistance}',
                         'style': '', 'patch': None, 'git': None}
                 cmdutil.show_changeset(repo.ui, repo, opts).show(ctx)
                 ltags, dist = repo.ui.popbuffer().split('\n')
                 tags = ''.join('latesttag: %s\n' % t for t in ltags.split(':'))
                 tags += 'latesttagdistance: %s\n' % dist
 
             return base + tags
 
         write('.hg_archival.txt', 0644, False, metadata)
 
     for f in ctx:
         ff = ctx.flags(f)
         getdata = ctx[f].data
         if lfutil.isstandin(f):
             path = lfutil.findfile(repo, getdata().strip())
             if path is None:
                 raise util.Abort(
                     _('largefile %s not found in repo store or system cache')
                     % lfutil.splitstandin(f))
             f = lfutil.splitstandin(f)
 
             def getdatafn():
                 fd = None
                 try:
                     fd = open(path, 'rb')
                     return fd.read()
                 finally:
                     if fd:
                         fd.close()
 
             getdata = getdatafn
         write(f, 'x' in ff and 0755 or 0644, 'l' in ff, getdata)
 
     if subrepos:
         for subpath in ctx.substate:
             sub = ctx.sub(subpath)
             sub.archive(repo.ui, archiver, prefix)
 
     archiver.done()
 
 # If a largefile is modified, the change is not reflected in its
 # 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 overridebailifchanged(orig, repo):
     orig(repo)
     repo.lfstatus = True
     modified, added, removed, deleted = repo.status()[:4]
     repo.lfstatus = False
     if modified or added or removed or deleted:
         raise util.Abort(_('outstanding uncommitted changes'))
 
 # 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
     if modified or added or removed or deleted:
         raise util.Abort(_('outstanding uncommitted changes'))
     return orig(ui, repo, *pats, **opts)
 
 def overrideforget(orig, ui, repo, *pats, **opts):
     installnormalfilesmatchfn(repo[None].manifest())
     orig(ui, repo, *pats, **opts)
     restorematchfn()
     m = scmutil.match(repo[None], pats, opts)
 
     try:
         repo.lfstatus = True
         s = repo.status(match=m, clean=True)
     finally:
         repo.lfstatus = False
     forget = sorted(s[0] + s[1] + s[3] + s[6])
     forget = [f for f in forget if lfutil.standin(f) in repo[None].manifest()]
 
     for f in forget:
         if lfutil.standin(f) not in repo.dirstate and not \
                 os.path.isdir(m.rel(lfutil.standin(f))):
             ui.warn(_('not removing %s: file is already untracked\n')
                     % m.rel(f))
 
     for f in forget:
         if ui.verbose or not m.exact(f):
             ui.status(_('removing %s\n') % m.rel(f))
 
     # Need to lock because standin files are deleted then removed from the
     # repository and we could race inbetween.
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         for f in forget:
             if lfdirstate[f] == 'a':
                 lfdirstate.drop(f)
             else:
                 lfdirstate.remove(f)
         lfdirstate.write()
         lfutil.reporemove(repo, [lfutil.standin(f) for f in forget],
             unlink=True)
     finally:
         wlock.release()
 
 def getoutgoinglfiles(ui, repo, dest=None, **opts):
     dest = ui.expandpath(dest or 'default-push', dest or 'default')
     dest, branches = hg.parseurl(dest, opts.get('branch'))
     revs, checkout = hg.addbranchrevs(repo, repo, branches, opts.get('rev'))
     if revs:
         revs = [repo.lookup(rev) for rev in revs]
 
     remoteui = hg.remoteui
 
     try:
         remote = hg.repository(remoteui(repo, opts), dest)
     except error.RepoError:
         return None
     o = lfutil.findoutgoing(repo, remote, False)
     if not o:
         return None
     o = repo.changelog.nodesbetween(o, revs)[0]
     if opts.get('newest_first'):
         o.reverse()
 
     toupload = set()
     for n in o:
         parents = [p for p in repo.changelog.parents(n) if p != node.nullid]
         ctx = repo[n]
         files = set(ctx.files())
         if len(parents) == 2:
             mc = ctx.manifest()
             mp1 = ctx.parents()[0].manifest()
             mp2 = ctx.parents()[1].manifest()
             for f in mp1:
                 if f not in mc:
                         files.add(f)
             for f in mp2:
                 if f not in mc:
                     files.add(f)
             for f in mc:
                 if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None):
                     files.add(f)
         toupload = toupload.union(
             set([f for f in files if lfutil.isstandin(f) and f in ctx]))
     return toupload
 
 def overrideoutgoing(orig, ui, repo, dest=None, **opts):
     orig(ui, repo, dest, **opts)
 
     if opts.pop('large', None):
         toupload = getoutgoinglfiles(ui, repo, dest, **opts)
         if toupload is None:
             ui.status(_('largefiles: No remote repo\n'))
         else:
             ui.status(_('largefiles to upload:\n'))
             for file in toupload:
                 ui.status(lfutil.splitstandin(file) + '\n')
             ui.status('\n')
 
 def overridesummary(orig, ui, repo, *pats, **opts):
     try:
         repo.lfstatus = True
         orig(ui, repo, *pats, **opts)
     finally:
         repo.lfstatus = False
 
     if opts.pop('large', None):
         toupload = getoutgoinglfiles(ui, repo, None, **opts)
         if toupload is None:
             ui.status(_('largefiles: No remote repo\n'))
         else:
             ui.status(_('largefiles: %d to upload\n') % len(toupload))
 
 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,
         False, False)
     (unsure, modified, added, removed, missing, unknown, ignored, clean) = s
 
     # Call into the normal remove code, but the removing of the standin, we want
     # to have handled by original addremove.  Monkey patching here makes sure
     # we don't remove the standin in the largefiles code, preventing a very
     # confused state later.
     if missing:
         repo._isaddremove = True
         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
     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.
     installnormalfilesmatchfn(repo[None].manifest())
     result = orig(ui, repo, *pats, **opts)
     restorematchfn()
     return result
 
 # Calling purge with --all will cause the largefiles to be deleted.
 # Override repo.status to prevent this from happening.
 def overridepurge(orig, ui, repo, *dirs, **opts):
     oldstatus = repo.status
     def overridestatus(node1='.', node2=None, match=None, ignored=False,
                         clean=False, unknown=False, listsubrepos=False):
         r = oldstatus(node1, node2, match, ignored, clean, unknown,
                       listsubrepos)
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         modified, added, removed, deleted, unknown, ignored, clean = r
         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 = overridestatus
     orig(ui, repo, *dirs, **opts)
     repo.status = oldstatus
 
 def overriderollback(orig, ui, repo, **opts):
     result = orig(ui, repo, **opts)
     merge.update(repo, node=None, branchmerge=False, force=True,
         partial=lfutil.isstandin)
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         lfiles = lfutil.listlfiles(repo)
         oldlfiles = lfutil.listlfiles(repo, repo[None].parents()[0].rev())
         for file in lfiles:
             if file in oldlfiles:
                 lfdirstate.normallookup(file)
             else:
                 lfdirstate.add(file)
         lfdirstate.write()
     finally:
         wlock.release()
     return result
 
 def overridetransplant(orig, ui, repo, *revs, **opts):
     try:
         oldstandins = lfutil.getstandinsstate(repo)
         repo._istransplanting = True
         result = orig(ui, repo, *revs, **opts)
         newstandins = lfutil.getstandinsstate(repo)
         filelist = lfutil.getlfilestoupdate(oldstandins, newstandins)
         lfcommands.updatelfiles(repo.ui, repo, filelist=filelist,
                                 printmessage=True)
     finally:
         repo._istransplanting = False
     return result

hgext/largefiles/reposetup.py

@@ -1,458 +1,459 b''
 # Copyright 2009-2010 Gregory P. Ward
 # Copyright 2009-2010 Intelerad Medical Systems Incorporated
 # Copyright 2010-2011 Fog Creek Software
 # Copyright 2010-2011 Unity Technologies
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 '''setup for largefiles repositories: reposetup'''
 import copy
 import types
 import os
 
 from mercurial import context, error, manifest, match as match_, util
 from mercurial import node as node_
 from mercurial.i18n import _
 
 import lfcommands
 import proto
 import lfutil
 
 def reposetup(ui, repo):
     # wire repositories should be given new wireproto functions but not the
     # other largefiles modifications
     if not repo.local():
         return proto.wirereposetup(ui, repo)
 
     for name in ('status', 'commitctx', 'commit', 'push'):
         method = getattr(repo, name)
         if (isinstance(method, types.FunctionType) and
             method.func_name == 'wrap'):
             ui.warn(_('largefiles: repo method %r appears to have already been'
                     ' wrapped by another extension: '
                     'largefiles may behave incorrectly\n')
                     % name)
 
     class lfilesrepo(repo.__class__):
         lfstatus = False
         def status_nolfiles(self, *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(lfilesrepo, self).__getitem__(changeid)
             if self.lfstatus:
                 class lfilesmanifestdict(manifest.manifestdict):
                     def __contains__(self, filename):
                         if super(lfilesmanifestdict,
                                 self).__contains__(filename):
                             return True
                         return super(lfilesmanifestdict,
                             self).__contains__(lfutil.standin(filename))
                 class lfilesctx(ctx.__class__):
                     def files(self):
                         filenames = super(lfilesctx, self).files()
                         return [lfutil.splitstandin(f) or f for f in filenames]
                     def manifest(self):
                         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(lfilesctx, self).filectx(
                                     path, fileid, filelog)
                             else:
                                 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(lfilesctx, self).filectx(
                                     lfutil.standin(path), fileid, filelog)
                             else:
                                 result = super(lfilesctx, self).filectx(
                                     lfutil.standin(path), fileid)
                             olddata = result.data
                             result.data = lambda: olddata() + '\0'
                         return result
                 ctx.__class__ = lfilesctx
             return ctx
 
         # Figure out the status of big files and insert them into the
         # appropriate list in the result. Also removes standin files
         # from the listing. Revert to the original status if
         # self.lfstatus is False.
         def status(self, node1='.', node2=None, match=None, ignored=False,
                 clean=False, unknown=False, listsubrepos=False):
             listignored, listclean, listunknown = ignored, clean, unknown
             if not self.lfstatus:
                 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
                 self.lfstatus = False
                 if isinstance(node1, context.changectx):
                     ctx1 = node1
                 else:
                     ctx1 = repo[node1]
                 if isinstance(node2, context.changectx):
                     ctx2 = node2
                 else:
                     ctx2 = repo[node2]
                 working = ctx2.rev() is None
                 parentworking = working and ctx1 == self['.']
 
                 def inctx(file, ctx):
                     try:
                         if ctx.rev() is None:
                             return file in ctx.manifest()
                         ctx[file]
                         return True
                     except KeyError:
                         return False
 
                 if match is None:
                     match = match_.always(self.root, self.getcwd())
 
                 # First check if there were files specified on the
                 # command line.  If there were, and none of them were
                 # largefiles, we should just bail here and let super
                 # handle it -- thus gaining a big performance boost.
                 lfdirstate = lfutil.openlfdirstate(ui, self)
                 if match.files() and not match.anypats():
                     for f in lfdirstate:
                         if match(f):
                             break
                     else:
                         return super(lfilesrepo, self).status(node1, node2,
                                 match, listignored, listclean,
                                 listunknown, listsubrepos)
 
                 # Create a copy of match that matches standins instead
                 # of largefiles.
                 def tostandin(file):
                     if inctx(lfutil.standin(file), ctx2):
                         return lfutil.standin(file)
                     return file
 
                 # Create a function that we can use to override what is
                 # normally the ignore matcher.  We've already checked
                 # for ignored files on the first dirstate walk, and
                 # unecessarily re-checking here causes a huge performance
                 # hit because lfdirstate only knows about largefiles
                 def _ignoreoverride(self):
                     return False
 
                 m = copy.copy(match)
                 m._files = [tostandin(f) for f in m._files]
 
                 # Get ignored files here even if we weren't asked for them; we
                 # must use the result here for filtering later
                 result = super(lfilesrepo, self).status(node1, node2, m,
                     True, clean, unknown, listsubrepos)
                 if working:
                     try:
                         # Any non-largefiles that were explicitly listed must be
                         # taken out or lfdirstate.status will report an error.
                         # The status of these files was already computed using
                         # super's status.
                         # Override lfdirstate's ignore matcher to not do
                         # anything
                         origignore = lfdirstate._ignore
                         lfdirstate._ignore = _ignoreoverride
 
                         match._files = [f for f in match._files if f in
                             lfdirstate]
                         # Don't waste time getting the ignored and unknown
                         # files again; we already have them
                         s = lfdirstate.status(match, [], False,
                                 listclean, False)
                         (unsure, modified, added, removed, missing, unknown,
                                 ignored, clean) = s
                         # Replace the list of ignored and unknown files with
                         # the previously caclulated lists, and strip out the
                         # largefiles
                         lfiles = set(lfdirstate._map)
                         ignored = set(result[5]).difference(lfiles)
                         unknown = set(result[4]).difference(lfiles)
                         if parentworking:
                             for lfile in unsure:
                                 standin = lfutil.standin(lfile)
                                 if standin not in ctx1:
                                     # from second parent
                                     modified.append(lfile)
                                 elif ctx1[standin].data().strip() \
                                         != lfutil.hashfile(self.wjoin(lfile)):
                                     modified.append(lfile)
                                 else:
                                     clean.append(lfile)
                                     lfdirstate.normal(lfile)
                         else:
                             tocheck = unsure + modified + added + clean
                             modified, added, clean = [], [], []
 
                             for lfile in tocheck:
                                 standin = lfutil.standin(lfile)
                                 if inctx(standin, ctx1):
                                     if ctx1[standin].data().strip() != \
                                             lfutil.hashfile(self.wjoin(lfile)):
                                         modified.append(lfile)
                                     else:
                                         clean.append(lfile)
                                 else:
                                     added.append(lfile)
                     finally:
                         # Replace the original ignore function
                         lfdirstate._ignore = origignore
 
                     for standin in ctx1.manifest():
                         if not lfutil.isstandin(standin):
                             continue
                         lfile = lfutil.splitstandin(standin)
                         if not match(lfile):
                             continue
                         if lfile not in lfdirstate:
                             removed.append(lfile)
 
                     # Filter result lists
                     result = list(result)
 
                     # Largefiles are not really removed when they're
                     # still in the normal dirstate. Likewise, normal
                     # files are not really removed if it's still in
                     # lfdirstate. This happens in merges where files
                     # change type.
                     removed = [f for f in removed if f not in repo.dirstate]
                     result[2] = [f for f in result[2] if f not in lfdirstate]
 
                     # Unknown files
                     unknown = set(unknown).difference(ignored)
                     result[4] = [f for f in unknown
                                  if (repo.dirstate[f] == '?' and
                                      not lfutil.isstandin(f))]
                     # Ignored files were calculated earlier by the dirstate,
                     # and we already stripped out the largefiles from the list
                     result[5] = ignored
                     # combine normal files and largefiles
                     normals = [[fn for fn in filelist
                                 if not lfutil.isstandin(fn)]
                                for filelist in result]
                     lfiles = (modified, added, removed, missing, [], [], clean)
                     result = [sorted(list1 + list2)
                               for (list1, list2) in zip(normals, lfiles)]
                 else:
                     def toname(f):
                         if lfutil.isstandin(f):
                             return lfutil.splitstandin(f)
                         return f
                     result = [[toname(f) for f in items] for items in result]
 
                 if not listunknown:
                     result[4] = []
                 if not listignored:
                     result[5] = []
                 if not listclean:
                     result[6] = []
                 self.lfstatus = True
                 return result
 
         # As part of committing, copy all of the largefiles into the
         # cache.
         def commitctx(self, *args, **kwargs):
             node = super(lfilesrepo, self).commitctx(*args, **kwargs)
             lfutil.copyalltostore(self, node)
             return node
 
         # Before commit, largefile standins have not had their
         # contents updated to reflect the hash of their largefile.
         # Do that here.
         def commit(self, text="", user=None, date=None, match=None,
                 force=False, editor=False, extra={}):
             orig = super(lfilesrepo, self).commit
 
             wlock = repo.wlock()
             try:
                 # Case 0: Rebase or Transplant
                 # We have to take the time to pull down the new largefiles now.
                 # Otherwise, any largefiles that were modified in the
                 # destination changesets get overwritten, either by the rebase
                 # or in the first commit after the rebase or transplant.
                 # updatelfiles will update the dirstate to mark any pulled
                 # largefiles as modified
                 if getattr(repo, "_isrebasing", False) or \
                         getattr(repo, "_istransplanting", False):
                     lfcommands.updatelfiles(repo.ui, repo, filelist=None,
                                             printmessage=False)
                     result = orig(text=text, user=user, date=date, match=match,
                                     force=force, editor=editor, extra=extra)
                     return result
                 # Case 1: user calls commit with no specific files or
                 # include/exclude patterns: refresh and commit all files that
                 # are "dirty".
                 if ((match is None) or
                     (not match.anypats() and not match.files())):
                     # Spend a bit of time here to get a list of files we know
                     # are modified so we can compare only against those.
                     # It can cost a lot of time (several seconds)
                     # otherwise to update all standins if the largefiles are
                     # large.
                     lfdirstate = lfutil.openlfdirstate(ui, self)
                     dirtymatch = match_.always(repo.root, repo.getcwd())
                     s = lfdirstate.status(dirtymatch, [], False, False, False)
                     modifiedfiles = []
                     for i in s:
                         modifiedfiles.extend(i)
                     lfiles = lfutil.listlfiles(self)
                     # this only loops through largefiles that exist (not
                     # removed/renamed)
                     for lfile in lfiles:
                         if lfile in modifiedfiles:
-                            if os.path.exists(self.wjoin(lfutil.standin(lfile))):
+                            if os.path.exists(
+                                    self.wjoin(lfutil.standin(lfile))):
                                 # this handles the case where a rebase is being
                                 # performed and the working copy is not updated
                                 # yet.
                                 if os.path.exists(self.wjoin(lfile)):
                                     lfutil.updatestandin(self,
                                         lfutil.standin(lfile))
                                     lfdirstate.normal(lfile)
                     for lfile in lfdirstate:
                         if lfile in modifiedfiles:
                             if not os.path.exists(
                                     repo.wjoin(lfutil.standin(lfile))):
                                 lfdirstate.drop(lfile)
 
                     result = orig(text=text, user=user, date=date, match=match,
                                     force=force, editor=editor, extra=extra)
                     # This needs to be after commit; otherwise precommit hooks
                     # get the wrong status
                     lfdirstate.write()
                     return result
 
                 for f in match.files():
                     if lfutil.isstandin(f):
                         raise util.Abort(
                             _('file "%s" is a largefile standin') % f,
                             hint=('commit the largefile itself instead'))
 
                 # Case 2: user calls commit with specified patterns: refresh
                 # any matching big files.
                 smatcher = lfutil.composestandinmatcher(self, match)
                 standins = lfutil.dirstatewalk(self.dirstate, smatcher)
 
                 # No matching big files: get out of the way and pass control to
                 # the usual commit() method.
                 if not standins:
                     return orig(text=text, user=user, date=date, match=match,
                                     force=force, editor=editor, extra=extra)
 
                 # Refresh all matching big files.  It's possible that the
                 # commit will end up failing, in which case the big files will
                 # stay refreshed.  No harm done: the user modified them and
                 # asked to commit them, so sooner or later we're going to
                 # refresh the standins.  Might as well leave them refreshed.
                 lfdirstate = lfutil.openlfdirstate(ui, self)
                 for standin in standins:
                     lfile = lfutil.splitstandin(standin)
                     if lfdirstate[lfile] <> 'r':
                         lfutil.updatestandin(self, standin)
                         lfdirstate.normal(lfile)
                     else:
                         lfdirstate.drop(lfile)
 
                 # Cook up a new matcher that only matches regular files or
                 # standins corresponding to the big files requested by the
                 # user.  Have to modify _files to prevent commit() from
                 # complaining "not tracked" for big files.
                 lfiles = lfutil.listlfiles(repo)
                 match = copy.copy(match)
                 origmatchfn = match.matchfn
 
                 # Check both the list of largefiles and the list of
                 # standins because if a largefile was removed, it
                 # won't be in the list of largefiles at this point
                 match._files += sorted(standins)
 
                 actualfiles = []
                 for f in match._files:
                     fstandin = lfutil.standin(f)
 
                     # ignore known largefiles and standins
                     if f in lfiles or fstandin in standins:
                         continue
 
                     # append directory separator to avoid collisions
                     if not fstandin.endswith(os.sep):
                         fstandin += os.sep
 
                     # prevalidate matching standin directories
                     if util.any(st for st in match._files
                                    if st.startswith(fstandin)):
                         continue
                     actualfiles.append(f)
                 match._files = actualfiles
 
                 def matchfn(f):
                     if origmatchfn(f):
                         return f not in lfiles
                     else:
                         return f in standins
 
                 match.matchfn = matchfn
                 result = orig(text=text, user=user, date=date, match=match,
                                 force=force, editor=editor, extra=extra)
                 # This needs to be after commit; otherwise precommit hooks
                 # get the wrong status
                 lfdirstate.write()
                 return result
             finally:
                 wlock.release()
 
         def push(self, remote, force=False, revs=None, newbranch=False):
             o = lfutil.findoutgoing(repo, remote, force)
             if o:
                 toupload = set()
                 o = repo.changelog.nodesbetween(o, revs)[0]
                 for n in o:
                     parents = [p for p in repo.changelog.parents(n)
                                if p != node_.nullid]
                     ctx = repo[n]
                     files = set(ctx.files())
                     if len(parents) == 2:
                         mc = ctx.manifest()
                         mp1 = ctx.parents()[0].manifest()
                         mp2 = ctx.parents()[1].manifest()
                         for f in mp1:
                             if f not in mc:
                                 files.add(f)
                         for f in mp2:
                             if f not in mc:
                                 files.add(f)
                         for f in mc:
                             if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f,
                                     None):
                                 files.add(f)
 
                     toupload = toupload.union(
                         set([ctx[f].data().strip()
                              for f in files
                              if lfutil.isstandin(f) and f in ctx]))
                 lfcommands.uploadlfiles(ui, self, remote, toupload)
             return super(lfilesrepo, self).push(remote, force, revs,
                 newbranch)
 
     repo.__class__ = lfilesrepo
 
     def checkrequireslfiles(ui, repo, **kwargs):
         if 'largefiles' not in repo.requirements and util.any(
                 lfutil.shortname+'/' in f[0] for f in repo.store.datafiles()):
             repo.requirements.add('largefiles')
             repo._writerequirements()
 
     ui.setconfig('hooks', 'changegroup.lfiles', checkrequireslfiles)
     ui.setconfig('hooks', 'commit.lfiles', checkrequireslfiles)

tests/test-check-code-hg.t

@@ -1,656 +1,650 b''
   $ check_code="$TESTDIR"/../contrib/check-code.py
   $ cd "$TESTDIR"/..
   $ if ! hg identify -q > /dev/null; then
   >     echo "skipped: not a Mercurial working dir" >&2
   >     exit 80
   > fi
   $ hg manifest | xargs "$check_code" || echo 'FAILURE IS NOT AN OPTION!!!'
 
   $ hg manifest | xargs "$check_code" --warnings --nolineno --per-file=0 || true
   contrib/check-code.py:0:
    > #    (r'^\s+[^_ \n][^_. \n]+_[^_\n]+\s*=', "don't use underbars in identifiers"),
    warning: line over 80 characters
   contrib/perf.py:0:
    >         except:
    warning: naked except clause
   contrib/perf.py:0:
    >     #timer(lambda: sum(map(len, repo.dirstate.status(m, [], False, False, False))))
    warning: line over 80 characters
   contrib/perf.py:0:
    >     except:
    warning: naked except clause
   contrib/setup3k.py:0:
    >         except:
    warning: naked except clause
   contrib/setup3k.py:0:
    >     except:
    warning: naked except clause
   contrib/setup3k.py:0:
    > except:
    warning: naked except clause
    warning: naked except clause
    warning: naked except clause
   contrib/shrink-revlog.py:0:
    >                    '(You can delete those files when you are satisfied that your\n'
    warning: line over 80 characters
   contrib/shrink-revlog.py:0:
    >                 ('', 'sort', 'reversepostorder', 'name of sort algorithm to use'),
    warning: line over 80 characters
   contrib/shrink-revlog.py:0:
    >                [('', 'revlog', '', _('index (.i) file of the revlog to shrink')),
    warning: line over 80 characters
   contrib/shrink-revlog.py:0:
    >         except:
    warning: naked except clause
   doc/gendoc.py:0:
    >                "together with Mercurial. Help for other extensions is available "
    warning: line over 80 characters
   hgext/bugzilla.py:0:
    >                 raise util.Abort(_('cannot find bugzilla user id for %s or %s') %
    warning: line over 80 characters
   hgext/bugzilla.py:0:
    >             bzdir = self.ui.config('bugzilla', 'bzdir', '/var/www/html/bugzilla')
    warning: line over 80 characters
   hgext/convert/__init__.py:0:
    >           ('', 'ancestors', '', _('show current changeset in ancestor branches')),
    warning: line over 80 characters
   hgext/convert/bzr.py:0:
    >         except:
    warning: naked except clause
   hgext/convert/common.py:0:
    >             except:
    warning: naked except clause
   hgext/convert/common.py:0:
    >         except:
    warning: naked except clause
    warning: naked except clause
   hgext/convert/convcmd.py:0:
    >         except:
    warning: naked except clause
   hgext/convert/cvs.py:0:
    >                                 # /1 :pserver:[e-mail]:2401/cvsroot/foo Ah<Z
    warning: line over 80 characters
   hgext/convert/cvsps.py:0:
    >                     assert len(branches) == 1, 'unknown branch: %s' % e.mergepoint
    warning: line over 80 characters
   hgext/convert/cvsps.py:0:
    >                     ui.write('Ancestors: %s\n' % (','.join(r)))
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >                     ui.write('Parent: %d\n' % cs.parents[0].id)
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >                     ui.write('Parents: %s\n' %
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >                 except:
    warning: naked except clause
   hgext/convert/cvsps.py:0:
    >                 ui.write('Branchpoints: %s \n' % ', '.join(branchpoints))
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >             ui.write('Author: %s\n' % cs.author)
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >             ui.write('Branch: %s\n' % (cs.branch or 'HEAD'))
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >             ui.write('Date: %s\n' % util.datestr(cs.date,
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >             ui.write('Log:\n')
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >             ui.write('Members: \n')
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >             ui.write('PatchSet %d \n' % cs.id)
    warning: unwrapped ui message
   hgext/convert/cvsps.py:0:
    >             ui.write('Tag%s: %s \n' % (['', 's'][len(cs.tags) > 1],
    warning: unwrapped ui message
   hgext/convert/git.py:0:
    >             except:
    warning: naked except clause
   hgext/convert/git.py:0:
    >             fh = self.gitopen('git diff-tree --name-only --root -r %s "%s^%s" --'
    warning: line over 80 characters
   hgext/convert/hg.py:0:
    >             # detect missing revlogs and abort on errors or populate self.ignored
    warning: line over 80 characters
   hgext/convert/hg.py:0:
    >             except:
    warning: naked except clause
    warning: naked except clause
   hgext/convert/hg.py:0:
    >         except:
    warning: naked except clause
   hgext/convert/monotone.py:0:
    >             except:
    warning: naked except clause
   hgext/convert/monotone.py:0:
    >         except:
    warning: naked except clause
   hgext/convert/subversion.py:0:
    >                 raise util.Abort(_('svn: branch has no revision %s') % to_revnum)
    warning: line over 80 characters
   hgext/convert/subversion.py:0:
    >             except:
    warning: naked except clause
   hgext/convert/subversion.py:0:
    >         args = [self.baseurl, relpaths, start, end, limit, discover_changed_paths,
    warning: line over 80 characters
   hgext/convert/subversion.py:0:
    >         self.trunkname = self.ui.config('convert', 'svn.trunk', 'trunk').strip('/')
    warning: line over 80 characters
   hgext/convert/subversion.py:0:
    >     except:
    warning: naked except clause
   hgext/convert/subversion.py:0:
    > def get_log_child(fp, url, paths, start, end, limit=0, discover_changed_paths=True,
    warning: line over 80 characters
   hgext/eol.py:0:
    >     if ui.configbool('eol', 'fix-trailing-newline', False) and s and s[-1] != '\n':
    warning: line over 80 characters
    warning: line over 80 characters
   hgext/gpg.py:0:
    >                 except:
    warning: naked except clause
   hgext/hgcia.py:0:
    > except:
    warning: naked except clause
   hgext/hgk.py:0:
    >         ui.write("%s%s\n" % (prefix, description.replace('\n', nlprefix).strip()))
    warning: line over 80 characters
   hgext/hgk.py:0:
    >         ui.write("parent %s\n" % p)
    warning: unwrapped ui message
   hgext/hgk.py:0:
    >         ui.write('k=%s\nv=%s\n' % (name, value))
    warning: unwrapped ui message
   hgext/hgk.py:0:
    >     ui.write("author %s %s %s\n" % (ctx.user(), int(date[0]), date[1]))
    warning: unwrapped ui message
   hgext/hgk.py:0:
    >     ui.write("branch %s\n\n" % ctx.branch())
    warning: unwrapped ui message
   hgext/hgk.py:0:
    >     ui.write("committer %s %s %s\n" % (committer, int(date[0]), date[1]))
    warning: unwrapped ui message
   hgext/hgk.py:0:
    >     ui.write("revision %d\n" % ctx.rev())
    warning: unwrapped ui message
   hgext/hgk.py:0:
    >     ui.write("tree %s\n" % short(ctx.changeset()[0])) # use ctx.node() instead ??
    warning: line over 80 characters
    warning: unwrapped ui message
   hgext/highlight/__init__.py:0:
    >     extensions.wrapfunction(webcommands, '_filerevision', filerevision_highlight)
    warning: line over 80 characters
   hgext/highlight/__init__.py:0:
    >     return ['/* pygments_style = %s */\n\n' % pg_style, fmter.get_style_defs('')]
    warning: line over 80 characters
   hgext/inotify/__init__.py:0:
    >             if self._inotifyon and not ignored and not subrepos and not self._dirty:
    warning: line over 80 characters
   hgext/inotify/server.py:0:
    >                     except:
    warning: naked except clause
   hgext/inotify/server.py:0:
    >             except:
    warning: naked except clause
   hgext/keyword.py:0:
    >     ui.note("hg ci -m '%s'\n" % msg)
    warning: unwrapped ui message
-  hgext/largefiles/overrides.py:0:
-   >             # When we call orig below it creates the standins but we don't add them
-   warning: line over 80 characters
-  hgext/largefiles/reposetup.py:0:
-   >                             if os.path.exists(self.wjoin(lfutil.standin(lfile))):
-   warning: line over 80 characters
   hgext/mq.py:0:
    >                     raise util.Abort(_("cannot push --exact with applied patches"))
    warning: line over 80 characters
   hgext/mq.py:0:
    >                     raise util.Abort(_("cannot use --exact and --move together"))
    warning: line over 80 characters
   hgext/mq.py:0:
    >                     self.ui.warn(_('Tag %s overrides mq patch of the same name\n')
    warning: line over 80 characters
   hgext/mq.py:0:
    >                 except:
    warning: naked except clause
    warning: naked except clause
   hgext/mq.py:0:
    >             except:
    warning: naked except clause
    warning: naked except clause
    warning: naked except clause
    warning: naked except clause
   hgext/mq.py:0:
    >             raise util.Abort(_('cannot mix -l/--list with options or arguments'))
    warning: line over 80 characters
   hgext/mq.py:0:
    >             raise util.Abort(_('qfold cannot fold already applied patch %s') % p)
    warning: line over 80 characters
   hgext/mq.py:0:
    >           ('', 'move', None, _('reorder patch series and apply only the patch'))],
    warning: line over 80 characters
   hgext/mq.py:0:
    >           ('U', 'noupdate', None, _('do not update the new working directories')),
    warning: line over 80 characters
   hgext/mq.py:0:
    >           ('e', 'exact', None, _('apply the target patch to its recorded parent')),
    warning: line over 80 characters
   hgext/mq.py:0:
    >         except:
    warning: naked except clause
   hgext/mq.py:0:
    >         ui.write("mq:     %s\n" % ', '.join(m))
    warning: unwrapped ui message
   hgext/mq.py:0:
    >     repo.mq.qseries(repo, missing=opts.get('missing'), summary=opts.get('summary'))
    warning: line over 80 characters
   hgext/notify.py:0:
    >                 ui.note(_('notify: suppressing notification for merge %d:%s\n') %
    warning: line over 80 characters
   hgext/patchbomb.py:0:
    >                                                   binnode, seqno=idx, total=total)
    warning: line over 80 characters
   hgext/patchbomb.py:0:
    >             except:
    warning: naked except clause
   hgext/patchbomb.py:0:
    >             ui.write('Subject: %s\n' % subj)
    warning: unwrapped ui message
   hgext/patchbomb.py:0:
    >         p = mail.mimetextpatch('\n'.join(patchlines), 'x-patch', opts.get('test'))
    warning: line over 80 characters
   hgext/patchbomb.py:0:
    >         ui.write('From: %s\n' % sender)
    warning: unwrapped ui message
   hgext/record.py:0:
    >                                   ignoreblanklines=opts.get('ignore_blank_lines'))
    warning: line over 80 characters
   hgext/record.py:0:
    >                                   ignorewsamount=opts.get('ignore_space_change'),
    warning: line over 80 characters
   hgext/zeroconf/__init__.py:0:
    >             publish(name, desc, path, util.getport(u.config("web", "port", 8000)))
    warning: line over 80 characters
   hgext/zeroconf/__init__.py:0:
    >     except:
    warning: naked except clause
    warning: naked except clause
   mercurial/bundlerepo.py:0:
    >       is a bundlerepo for the obtained bundle when the original "other" is remote.
    warning: line over 80 characters
   mercurial/bundlerepo.py:0:
    >     "local" is a local repo from which to obtain the actual incoming changesets; it
    warning: line over 80 characters
   mercurial/bundlerepo.py:0:
    >     tmp = discovery.findcommonincoming(repo, other, heads=onlyheads, force=force)
    warning: line over 80 characters
   mercurial/commands.py:0:
    >                  "     size " + basehdr + "   link     p1     p2       nodeid\n")
    warning: line over 80 characters
   mercurial/commands.py:0:
    >                 raise util.Abort('cannot use localheads with old style discovery')
    warning: line over 80 characters
   mercurial/commands.py:0:
    >                 ui.note('branch %s\n' % data)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >                 ui.note('node %s\n' % str(data))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >                 ui.note('tag %s\n' % name)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >                 ui.write("unpruned common: %s\n" % " ".join([short(n)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >                 yield 'n', (r, list(set(p for p in cl.parentrevs(r) if p != -1)))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >                 yield 'n', (r, list(set(p for p in rlog.parentrevs(r) if p != -1)))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >             except:
    warning: naked except clause
   mercurial/commands.py:0:
    >             ui.status(_("(run 'hg heads .' to see heads, 'hg merge' to merge)\n"))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >             ui.write("format: id, p1, p2, cset, delta base, len(delta)\n")
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >             ui.write("local is subset\n")
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >             ui.write("remote is subset\n")
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >             ui.write('    other            : ' + fmt2 % pcfmt(numoprev, numprev))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >             ui.write('    where prev = p1  : ' + fmt2 % pcfmt(nump1prev, numprev))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >             ui.write('    where prev = p2  : ' + fmt2 % pcfmt(nump2prev, numprev))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >             ui.write('deltas against other : ' + fmt % pcfmt(numother, numdeltas))
    warning: line over 80 characters
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >             ui.write('deltas against p1    : ' + fmt % pcfmt(nump1, numdeltas))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >             ui.write('deltas against p2    : ' + fmt % pcfmt(nump2, numdeltas))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >         cmd, ext, mod = extensions.disabledcmd(ui, name, ui.config('ui', 'strict'))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >         except:
    warning: naked except clause
   mercurial/commands.py:0:
    >         revs, checkout = hg.addbranchrevs(repo, other, branches, opts.get('rev'))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >         ui.write("common heads: %s\n" % " ".join([short(n) for n in common]))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >         ui.write("match: %s\n" % m(d[0]))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >         ui.write('deltas against prev  : ' + fmt % pcfmt(numprev, numdeltas))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >         ui.write('path %s\n' % k)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >         ui.write('uncompressed data size (min/max/avg) : %d / %d / %d\n'
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     Every ID must be a full-length hex node id string. Returns a list of 0s and 1s
    warning: line over 80 characters
   mercurial/commands.py:0:
    >     remoteurl, branches = hg.parseurl(ui.expandpath(remoteurl), opts.get('branch'))
    warning: line over 80 characters
   mercurial/commands.py:0:
    >     ui.write("digraph G {\n")
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write("internal: %s %s\n" % d)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write("standard: %s\n" % util.datestr(d))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('avg chain length  : ' + fmt % avgchainlen)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('case-sensitive: %s\n' % (util.checkcase('.debugfsinfo')
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('compression ratio : ' + fmt % compratio)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('delta size (min/max/avg)             : %d / %d / %d\n'
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('exec: %s\n' % (util.checkexec(path) and 'yes' or 'no'))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('flags  : %s\n' % ', '.join(flags))
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('format : %d\n' % format)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('full revision size (min/max/avg)     : %d / %d / %d\n'
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('revision size : ' + fmt2 % totalsize)
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('revisions     : ' + fmt2 % numrevs)
    warning: unwrapped ui message
    warning: unwrapped ui message
   mercurial/commands.py:0:
    >     ui.write('symlink: %s\n' % (util.checklink(path) and 'yes' or 'no'))
    warning: unwrapped ui message
   mercurial/commandserver.py:0:
    >         # the ui here is really the repo ui so take its baseui so we don't end up
    warning: line over 80 characters
   mercurial/context.py:0:
    >                 return self._manifestdelta[path], self._manifestdelta.flags(path)
    warning: line over 80 characters
   mercurial/dagparser.py:0:
    >             raise util.Abort(_("invalid character in dag description: %s...") % s)
    warning: line over 80 characters
   mercurial/dagparser.py:0:
    >         >>> dagtext([('n', (0, [-1])), ('C', 'my command line'), ('n', (1, [0]))])
    warning: line over 80 characters
   mercurial/dirstate.py:0:
    >                 if not st is None and not getkind(st.st_mode) in (regkind, lnkkind):
    warning: line over 80 characters
   mercurial/discovery.py:0:
    >     If onlyheads is given, only nodes ancestral to nodes in onlyheads (inclusive)
    warning: line over 80 characters
   mercurial/discovery.py:0:
    > def findcommonoutgoing(repo, other, onlyheads=None, force=False, commoninc=None):
    warning: line over 80 characters
   mercurial/dispatch.py:0:
    >                                                 " (.hg not found)") % os.getcwd())
    warning: line over 80 characters
   mercurial/dispatch.py:0:
    >         aliases, entry = cmdutil.findcmd(cmd, cmdtable, lui.config("ui", "strict"))
    warning: line over 80 characters
   mercurial/dispatch.py:0:
    >         except:
    warning: naked except clause
   mercurial/dispatch.py:0:
    >         return lambda: runcommand(lui, None, cmd, args[:1], ui, options, d, [], {})
    warning: line over 80 characters
   mercurial/dispatch.py:0:
    >     def __init__(self, args, ui=None, repo=None, fin=None, fout=None, ferr=None):
    warning: line over 80 characters
   mercurial/dispatch.py:0:
    >     except:
    warning: naked except clause
   mercurial/hg.py:0:
    >     except:
    warning: naked except clause
   mercurial/hgweb/hgweb_mod.py:0:
    >             self.maxshortchanges = int(self.config("web", "maxshortchanges", 60))
    warning: line over 80 characters
   mercurial/keepalive.py:0:
    >         except:
    warning: naked except clause
   mercurial/keepalive.py:0:
    >     except:
    warning: naked except clause
   mercurial/localrepo.py:0:
    >                         # we return an integer indicating remote head count change
    warning: line over 80 characters
   mercurial/localrepo.py:0:
    >                     raise util.Abort(_("empty or missing revlog for %s") % fname)
    warning: line over 80 characters
    warning: line over 80 characters
   mercurial/localrepo.py:0:
    >                 if self._tagscache.tagtypes and name in self._tagscache.tagtypes:
    warning: line over 80 characters
   mercurial/localrepo.py:0:
    >                 self.hook("precommit", throw=True, parent1=hookp1, parent2=hookp2)
    warning: line over 80 characters
   mercurial/localrepo.py:0:
    >             # new requirements = old non-format requirements + new format-related
    warning: line over 80 characters
   mercurial/localrepo.py:0:
    >             except:
    warning: naked except clause
   mercurial/localrepo.py:0:
    >         """return status of files between two nodes or node and working directory
    warning: line over 80 characters
   mercurial/localrepo.py:0:
    >         '''Returns a tagscache object that contains various tags related caches.'''
    warning: line over 80 characters
   mercurial/manifest.py:0:
    >             return "".join(struct.pack(">lll", start, end, len(content)) + content
    warning: line over 80 characters
   mercurial/merge.py:0:
    >                 subrepo.submerge(repo, wctx, mctx, wctx.ancestor(mctx), overwrite)
    warning: line over 80 characters
   mercurial/patch.py:0:
    >                  modified, added, removed, copy, getfilectx, opts, losedata, prefix)
    warning: line over 80 characters
   mercurial/patch.py:0:
    >         diffhelpers.addlines(lr, self.hunk, self.lena, self.lenb, self.a, self.b)
    warning: line over 80 characters
   mercurial/patch.py:0:
    >         output.append(_(' %d files changed, %d insertions(+), %d deletions(-)\n')
    warning: line over 80 characters
   mercurial/patch.py:0:
    >     except:
    warning: naked except clause
   mercurial/pure/base85.py:0:
    >             raise OverflowError('Base85 overflow in hunk starting at byte %d' % i)
    warning: line over 80 characters
   mercurial/pure/mpatch.py:0:
    >         frags.extend(reversed(new))                    # what was left at the end
    warning: line over 80 characters
   mercurial/repair.py:0:
    >         except:
    warning: naked except clause
   mercurial/repair.py:0:
    >     except:
    warning: naked except clause
   mercurial/revset.py:0:
    >         elif c.isalnum() or c in '._' or ord(c) > 127: # gather up a symbol/keyword
    warning: line over 80 characters
   mercurial/revset.py:0:
    >     Changesets that are the Nth ancestor (first parents only) of a changeset in set.
    warning: line over 80 characters
   mercurial/scmutil.py:0:
    >                         raise util.Abort(_("path '%s' is inside nested repo %r") %
    warning: line over 80 characters
   mercurial/scmutil.py:0:
    >             "requires features '%s' (upgrade Mercurial)") % "', '".join(missings))
    warning: line over 80 characters
   mercurial/scmutil.py:0:
    >         elif repo.dirstate[abs] != 'r' and (not good or not os.path.lexists(target)
    warning: line over 80 characters
   mercurial/setdiscovery.py:0:
    >     # treat remote heads (and maybe own heads) as a first implicit sample response
    warning: line over 80 characters
   mercurial/setdiscovery.py:0:
    >     undecided = dag.nodeset() # own nodes where I don't know if remote knows them
    warning: line over 80 characters
   mercurial/similar.py:0:
    >         repo.ui.progress(_('searching for similar files'), i, total=len(removed))
    warning: line over 80 characters
   mercurial/simplemerge.py:0:
    >         for zmatch, zend, amatch, aend, bmatch, bend in self.find_sync_regions():
    warning: line over 80 characters
   mercurial/sshrepo.py:0:
    >             self._abort(error.RepoError(_("no suitable response from remote hg")))
    warning: line over 80 characters
   mercurial/sshrepo.py:0:
    >         except:
    warning: naked except clause
   mercurial/subrepo.py:0:
    >                 other, self._repo = hg.clone(self._repo._subparent.ui, {}, other,
    warning: line over 80 characters
   mercurial/subrepo.py:0:
    >         msg = (_(' subrepository sources for %s differ (in checked out version)\n'
    warning: line over 80 characters
   mercurial/transaction.py:0:
    >             except:
    warning: naked except clause
   mercurial/ui.py:0:
    >                 traceback.print_exception(exc[0], exc[1], exc[2], file=self.ferr)
    warning: line over 80 characters
   mercurial/url.py:0:
    >             conn = httpsconnection(host, port, keyfile, certfile, *args, **kwargs)
    warning: line over 80 characters
   mercurial/util.py:0:
    >             except:
    warning: naked except clause
   mercurial/util.py:0:
    >     except:
    warning: naked except clause
   mercurial/verify.py:0:
    >                     except:
    warning: naked except clause
   mercurial/verify.py:0:
    >                 except:
    warning: naked except clause
   mercurial/wireproto.py:0:
    >         # Assuming the future to be filled with the result from the batched request
    warning: line over 80 characters
   mercurial/wireproto.py:0:
    >         '''remote must support _submitbatch(encbatch) and _submitone(op, encargs)'''
    warning: line over 80 characters
   mercurial/wireproto.py:0:
    >     All methods invoked on instances of this class are simply queued and return a
    warning: line over 80 characters
   mercurial/wireproto.py:0:
    >     The decorator returns a function which wraps this coroutine as a plain method,
    warning: line over 80 characters
   setup.py:0:
    >                 raise SystemExit("Python headers are required to build Mercurial")
    warning: line over 80 characters
   setup.py:0:
    >         except:
    warning: naked except clause
   setup.py:0:
    >     # build_py), it will not find osutil & friends, thinking that those modules are
    warning: line over 80 characters
   setup.py:0:
    >     except:
    warning: naked except clause
    warning: naked except clause
   setup.py:0:
    >     isironpython = platform.python_implementation().lower().find("ironpython") != -1
    warning: line over 80 characters
   setup.py:0:
    > except:
    warning: naked except clause
    warning: naked except clause
    warning: naked except clause
   tests/autodiff.py:0:
    >         ui.write('data lost for: %s\n' % fn)
    warning: unwrapped ui message
   tests/run-tests.py:0:
    >     except:
    warning: naked except clause
   tests/test-commandserver.py:0:
    >                         'hooks.pre-identify=python:test-commandserver.hook', 'id'],
    warning: line over 80 characters
   tests/test-commandserver.py:0:
    >     # the cached repo local hgrc contains ui.foo=bar, so showconfig should show it
    warning: line over 80 characters
   tests/test-commandserver.py:0:
    >     print '%c, %r' % (ch, re.sub('encoding: [a-zA-Z0-9-]+', 'encoding: ***', data))
    warning: line over 80 characters
   tests/test-filecache.py:0:
    >     except:
    warning: naked except clause
   tests/test-filecache.py:0:
    > if subprocess.call(['python', '%s/hghave' % os.environ['TESTDIR'], 'cacheable']):
    warning: line over 80 characters
   tests/test-ui-color.py:0:
    > testui.warn('warning\n')
    warning: unwrapped ui message
   tests/test-ui-color.py:0:
    > testui.write('buffered\n')
    warning: unwrapped ui message
   tests/test-walkrepo.py:0:
    >         print "Found %d repositories when I should have found 2" % (len(reposet),)
    warning: line over 80 characters
   tests/test-walkrepo.py:0:
    >         print "Found %d repositories when I should have found 3" % (len(reposet),)
    warning: line over 80 characters