largefiles: more work on cleaning up comments

- always say "largefile", not "lfile"
- cleanup mangled syntax, hopefully correctly
  (punctuation: it's your friend!)
- wrap to 75 columns (where feasible)

hgext/largefiles/lfcommands.py

@@ -1,482 +1,482 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.
 
 '''High-level command function for lfconvert, plus the cmdtable.'''
 
 import os
 import shutil
 
 from mercurial import util, match as match_, hg, node, context, error
 from mercurial.i18n import _
 
 import lfutil
 import basestore
 
 # -- Commands ----------------------------------------------------------
 
 def lfconvert(ui, src, dest, *pats, **opts):
     '''convert a normal repository to a largefiles repository
 
     Convert repository SOURCE to a new repository DEST, identical to
     SOURCE except that certain files will be converted as largefiles:
     specifically, any file that matches any PATTERN *or* whose size is
     above the minimum size threshold is converted as a largefile. The
     size used to determine whether or not to track a file as a
     largefile is the size of the first version of the file. The
     minimum size can be specified either with --size or in
     configuration as ``largefiles.size``.
 
     After running this command you will need to make sure that
     largefiles is enabled anywhere you intend to push the new
     repository.
 
     Use --tonormal to convert largefiles back to normal files; after
     this, the DEST repository can be used without largefiles at all.'''
 
     if opts['tonormal']:
         tolfile = False
     else:
         tolfile = True
         size = lfutil.getminsize(ui, True, opts.get('size'), default=None)
     try:
         rsrc = hg.repository(ui, src)
         if not rsrc.local():
             raise util.Abort(_('%s is not a local Mercurial repo') % src)
     except error.RepoError, err:
         ui.traceback()
         raise util.Abort(err.args[0])
     if os.path.exists(dest):
         if not os.path.isdir(dest):
             raise util.Abort(_('destination %s already exists') % dest)
         elif os.listdir(dest):
             raise util.Abort(_('destination %s is not empty') % dest)
     try:
         ui.status(_('initializing destination %s\n') % dest)
         rdst = hg.repository(ui, dest, create=True)
         if not rdst.local():
             raise util.Abort(_('%s is not a local Mercurial repo') % dest)
     except error.RepoError:
         ui.traceback()
         raise util.Abort(_('%s is not a repo') % dest)
 
     success = False
     try:
         # 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()
 
         # Get a list of all changesets in the source.  The easy way to do this
         # is to simply walk the changelog, using changelog.nodesbewteen().
         # Take a look at mercurial/revlog.py:639 for more details.
         # Use a generator instead of a list to decrease memory usage
         ctxs = (rsrc[ctx] for ctx in rsrc.changelog.nodesbetween(None,
             rsrc.heads())[0])
         revmap = {node.nullid: node.nullid}
         if tolfile:
             lfiles = set()
             normalfiles = set()
             if not pats:
                 pats = ui.config(lfutil.longname, 'patterns', default=())
                 if pats:
                     pats = pats.split(' ')
             if pats:
                 matcher = match_.match(rsrc.root, '', list(pats))
             else:
                 matcher = None
 
             lfiletohash = {}
             for ctx in ctxs:
                 ui.progress(_('converting revisions'), ctx.rev(),
                     unit=_('revision'), total=rsrc['tip'].rev())
                 _lfconvert_addchangeset(rsrc, rdst, ctx, revmap,
                     lfiles, normalfiles, matcher, size, lfiletohash)
             ui.progress(_('converting revisions'), None)
 
             if os.path.exists(rdst.wjoin(lfutil.shortname)):
                 shutil.rmtree(rdst.wjoin(lfutil.shortname))
 
             for f in lfiletohash.keys():
                 if os.path.isfile(rdst.wjoin(f)):
                     os.unlink(rdst.wjoin(f))
                 try:
                     os.removedirs(os.path.dirname(rdst.wjoin(f)))
                 except OSError:
                     pass
 
         else:
             for ctx in ctxs:
                 ui.progress(_('converting revisions'), ctx.rev(),
                     unit=_('revision'), total=rsrc['tip'].rev())
                 _addchangeset(ui, rsrc, rdst, ctx, revmap)
 
             ui.progress(_('converting revisions'), None)
         success = True
     finally:
         if not success:
             # we failed, remove the new directory
             shutil.rmtree(rdst.root)
         dst_lock.release()
 
 def _addchangeset(ui, rsrc, rdst, ctx, revmap):
  # Convert src parents to dst parents
     parents = []
     for p in ctx.parents():
         parents.append(revmap[p.node()])
     while len(parents) < 2:
         parents.append(node.nullid)
 
     # Generate list of changed files
     files = set(ctx.files())
     if node.nullid not in parents:
         mc = ctx.manifest()
         mp1 = ctx.parents()[0].manifest()
         mp2 = ctx.parents()[1].manifest()
         files |= (set(mp1) | set(mp2)) - set(mc)
         for f in mc:
             if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None):
                 files.add(f)
 
     def getfilectx(repo, memctx, f):
         if lfutil.standin(f) in files:
             # if the file isn't in the manifest then it was removed
             # or renamed, raise IOError to indicate this
             try:
                 fctx = ctx.filectx(lfutil.standin(f))
             except error.LookupError:
                 raise IOError()
             renamed = fctx.renamed()
             if renamed:
                 renamed = lfutil.splitstandin(renamed[0])
 
             hash = fctx.data().strip()
             path = lfutil.findfile(rsrc, hash)
             ### TODO: What if the file is not cached?
             data = ''
             fd = None
             try:
                 fd = open(path, 'rb')
                 data = fd.read()
             finally:
                 if fd:
                     fd.close()
             return context.memfilectx(f, data, 'l' in fctx.flags(),
                                       'x' in fctx.flags(), renamed)
         else:
             try:
                 fctx = ctx.filectx(f)
             except error.LookupError:
                 raise IOError()
             renamed = fctx.renamed()
             if renamed:
                 renamed = renamed[0]
             data = fctx.data()
             if f == '.hgtags':
                 newdata = []
                 for line in data.splitlines():
                     id, name = line.split(' ', 1)
                     newdata.append('%s %s\n' % (node.hex(revmap[node.bin(id)]),
                         name))
                 data = ''.join(newdata)
             return context.memfilectx(f, data, 'l' in fctx.flags(),
                                       'x' in fctx.flags(), renamed)
 
     dstfiles = []
     for file in files:
         if lfutil.isstandin(file):
             dstfiles.append(lfutil.splitstandin(file))
         else:
             dstfiles.append(file)
     # Commit
     mctx = context.memctx(rdst, parents, ctx.description(), dstfiles,
                           getfilectx, ctx.user(), ctx.date(), ctx.extra())
     ret = rdst.commitctx(mctx)
     rdst.dirstate.setparents(ret)
     revmap[ctx.node()] = rdst.changelog.tip()
 
 def _lfconvert_addchangeset(rsrc, rdst, ctx, revmap, lfiles, normalfiles,
         matcher, size, lfiletohash):
     # Convert src parents to dst parents
     parents = []
     for p in ctx.parents():
         parents.append(revmap[p.node()])
     while len(parents) < 2:
         parents.append(node.nullid)
 
     # Generate list of changed files
     files = set(ctx.files())
     if node.nullid not in parents:
         mc = ctx.manifest()
         mp1 = ctx.parents()[0].manifest()
         mp2 = ctx.parents()[1].manifest()
         files |= (set(mp1) | set(mp2)) - set(mc)
         for f in mc:
             if mc[f] != mp1.get(f, None) or mc[f] != mp2.get(f, None):
                 files.add(f)
 
     dstfiles = []
     for f in files:
         if f not in lfiles and f not in normalfiles:
             islfile = _islfile(f, ctx, matcher, size)
             # If this file was renamed or copied then copy
             # the lfileness of its predecessor
             if f in ctx.manifest():
                 fctx = ctx.filectx(f)
                 renamed = fctx.renamed()
                 renamedlfile = renamed and renamed[0] in lfiles
                 islfile |= renamedlfile
                 if 'l' in fctx.flags():
                     if renamedlfile:
                         raise util.Abort(
                             _('Renamed/copied largefile %s becomes symlink')
                             % f)
                     islfile = False
             if islfile:
                 lfiles.add(f)
             else:
                 normalfiles.add(f)
 
         if f in lfiles:
             dstfiles.append(lfutil.standin(f))
-            # lfile in manifest if it has not been removed/renamed
+            # largefile in manifest if it has not been removed/renamed
             if f in ctx.manifest():
                 if 'l' in ctx.filectx(f).flags():
                     if renamed and renamed[0] in lfiles:
                         raise util.Abort(_('largefile %s becomes symlink') % f)
 
-                # lfile was modified, update standins
+                # largefile was modified, update standins
                 fullpath = rdst.wjoin(f)
                 lfutil.createdir(os.path.dirname(fullpath))
                 m = util.sha1('')
                 m.update(ctx[f].data())
                 hash = m.hexdigest()
                 if f not in lfiletohash or lfiletohash[f] != hash:
                     try:
                         fd = open(fullpath, 'wb')
                         fd.write(ctx[f].data())
                     finally:
                         if fd:
                             fd.close()
                     executable = 'x' in ctx[f].flags()
                     os.chmod(fullpath, lfutil.getmode(executable))
                     lfutil.writestandin(rdst, lfutil.standin(f), hash,
                         executable)
                     lfiletohash[f] = hash
         else:
             # normal file
             dstfiles.append(f)
 
     def getfilectx(repo, memctx, f):
         if lfutil.isstandin(f):
             # if the file isn't in the manifest then it was removed
             # or renamed, raise IOError to indicate this
             srcfname = lfutil.splitstandin(f)
             try:
                 fctx = ctx.filectx(srcfname)
             except error.LookupError:
                 raise IOError()
             renamed = fctx.renamed()
             if renamed:
-                # standin is always a lfile because lfileness
+                # standin is always a largefile because largefile-ness
                 # doesn't change after rename or copy
                 renamed = lfutil.standin(renamed[0])
 
             return context.memfilectx(f, lfiletohash[srcfname], 'l' in
                 fctx.flags(), 'x' in fctx.flags(), renamed)
         else:
             try:
                 fctx = ctx.filectx(f)
             except error.LookupError:
                 raise IOError()
             renamed = fctx.renamed()
             if renamed:
                 renamed = renamed[0]
 
             data = fctx.data()
             if f == '.hgtags':
                 newdata = []
                 for line in data.splitlines():
                     id, name = line.split(' ', 1)
                     newdata.append('%s %s\n' % (node.hex(revmap[node.bin(id)]),
                         name))
                 data = ''.join(newdata)
             return context.memfilectx(f, data, 'l' in fctx.flags(),
                                       'x' in fctx.flags(), renamed)
 
     # Commit
     mctx = context.memctx(rdst, parents, ctx.description(), dstfiles,
                           getfilectx, ctx.user(), ctx.date(), ctx.extra())
     ret = rdst.commitctx(mctx)
     rdst.dirstate.setparents(ret)
     revmap[ctx.node()] = rdst.changelog.tip()
 
 def _islfile(file, ctx, matcher, size):
     '''Return true if file should be considered a largefile, i.e.
     matcher matches it or it is larger than size.'''
     # never store special .hg* files as largefiles
     if file == '.hgtags' or file == '.hgignore' or file == '.hgsigs':
         return False
     if matcher and matcher(file):
         return True
     try:
         return ctx.filectx(file).size() >= size * 1024 * 1024
     except error.LookupError:
         return False
 
 def uploadlfiles(ui, rsrc, rdst, files):
     '''upload largefiles to the central store'''
 
     # Don't upload locally. All largefiles are in the system wide cache
     # so the other repo can just get them from there.
     if not files or rdst.local():
         return
 
     store = basestore._openstore(rsrc, rdst, put=True)
 
     at = 0
     files = filter(lambda h: not store.exists(h), files)
     for hash in files:
         ui.progress(_('uploading largefiles'), at, unit='largefile',
                     total=len(files))
         source = lfutil.findfile(rsrc, hash)
         if not source:
             raise util.Abort(_('largefile %s missing from store'
                                ' (needs to be uploaded)') % hash)
         # XXX check for errors here
         store.put(source, hash)
         at += 1
     ui.progress(_('uploading largefiles'), None)
 
 def verifylfiles(ui, repo, all=False, contents=False):
     '''Verify that every big file revision in the current changeset
     exists in the central store.  With --contents, also verify that
     the contents of each big file revision are correct (SHA-1 hash
     matches the revision ID).  With --all, check every changeset in
     this repository.'''
     if all:
         # Pass a list to the function rather than an iterator because we know a
         # list will work.
         revs = range(len(repo))
     else:
         revs = ['.']
 
     store = basestore._openstore(repo)
     return store.verify(revs, contents=contents)
 
 def cachelfiles(ui, repo, node):
     '''cachelfiles ensures that all largefiles needed by the specified revision
     are present in the repository's largefile cache.
 
     returns a tuple (cached, missing).  cached is the list of files downloaded
     by this operation; missing is the list of files that were needed but could
     not be found.'''
     lfiles = lfutil.listlfiles(repo, node)
     toget = []
 
     for lfile in lfiles:
         expectedhash = repo[node][lfutil.standin(lfile)].data().strip()
         # if it exists and its hash matches, it might have been locally
         # modified before updating and the user chose 'local'.  in this case,
         # it will not be in any store, so don't look for it.
         if (not os.path.exists(repo.wjoin(lfile)) \
                 or expectedhash != lfutil.hashfile(repo.wjoin(lfile))) and \
                 not lfutil.findfile(repo, expectedhash):
             toget.append((lfile, expectedhash))
 
     if toget:
         store = basestore._openstore(repo)
         ret = store.get(toget)
         return ret
 
     return ([], [])
 
 def updatelfiles(ui, repo, filelist=None, printmessage=True):
     wlock = repo.wlock()
     try:
         lfdirstate = lfutil.openlfdirstate(ui, repo)
         lfiles = set(lfutil.listlfiles(repo)) | set(lfdirstate)
 
         if filelist is not None:
             lfiles = [f for f in lfiles if f in filelist]
 
         printed = False
         if printmessage and lfiles:
             ui.status(_('getting changed largefiles\n'))
             printed = True
             cachelfiles(ui, repo, '.')
 
         updated, removed = 0, 0
         for i in map(lambda f: _updatelfile(repo, lfdirstate, f), lfiles):
             # increment the appropriate counter according to _updatelfile's
             # return value
             updated += i > 0 and i or 0
             removed -= i < 0 and i or 0
             if printmessage and (removed or updated) and not printed:
                 ui.status(_('getting changed largefiles\n'))
                 printed = True
 
         lfdirstate.write()
         if printed and printmessage:
             ui.status(_('%d largefiles updated, %d removed\n') % (updated,
                 removed))
     finally:
         wlock.release()
 
 def _updatelfile(repo, lfdirstate, lfile):
     '''updates a single largefile and copies the state of its standin from
     the repository's dirstate to its state in the lfdirstate.
 
     returns 1 if the file was modified, -1 if the file was removed, 0 if the
     file was unchanged, and None if the needed largefile was missing from the
     cache.'''
     ret = 0
     abslfile = repo.wjoin(lfile)
     absstandin = repo.wjoin(lfutil.standin(lfile))
     if os.path.exists(absstandin):
         if os.path.exists(absstandin+'.orig'):
             shutil.copyfile(abslfile, abslfile+'.orig')
         expecthash = lfutil.readstandin(repo, lfile)
         if expecthash != '' and \
                 (not os.path.exists(abslfile) or \
                 expecthash != lfutil.hashfile(abslfile)):
             if not lfutil.copyfromcache(repo, expecthash, lfile):
                 return None # don't try to set the mode or update the dirstate
             ret = 1
         mode = os.stat(absstandin).st_mode
         if mode != os.stat(abslfile).st_mode:
             os.chmod(abslfile, mode)
             ret = 1
     else:
         if os.path.exists(abslfile):
             os.unlink(abslfile)
             ret = -1
     state = repo.dirstate[lfutil.standin(lfile)]
     if state == 'n':
         lfdirstate.normal(lfile)
     elif state == 'r':
         lfdirstate.remove(lfile)
     elif state == 'a':
         lfdirstate.add(lfile)
     elif state == '?':
         lfdirstate.drop(lfile)
     return ret
 
 # -- hg commands declarations ------------------------------------------------
 
 
 cmdtable = {
     'lfconvert': (lfconvert,
                   [('s', 'size', '',
                     _('minimum size (MB) for files to be converted '
                       'as largefiles'),
                     'SIZE'),
                   ('', 'tonormal', False,
                    _('convert from a largefiles repo to a normal repo')),
                   ],
                   _('hg lfconvert SOURCE DEST [FILE ...]')),
     }

hgext/largefiles/overrides.py

@@ -1,824 +1,826 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, match as match_, node, \
         archival, error, merge
 from mercurial.i18n import _
 from mercurial.node import hex
 from hgext import rebase
 import lfutil
 
 try:
     from mercurial import scmutil
 except ImportError:
     pass
 
 import lfutil
 import lfcommands
 
 def installnormalfilesmatchfn(manifest):
     '''overrides scmutil.match so that the matcher it returns will ignore all
     largefiles'''
     oldmatch = None # for the closure
     def override_match(repo, pats=[], opts={}, globbed=False,
             default='relpath'):
         match = oldmatch(repo, 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)
         orig_matchfn = m.matchfn
         m.matchfn = lambda f: notlfile(f) and orig_matchfn(f) or None
         return m
     oldmatch = installmatchfn(override_match)
 
 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)
 
 # -- 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 override_add(orig, ui, repo, *pats, **opts):
     large = opts.pop('large', None)
     lfsize = lfutil.getminsize(
         ui, lfutil.islfilesrepo(repo), opts.pop('lfsize', None))
 
     lfmatcher = None
     if os.path.exists(repo.wjoin(lfutil.shortname)):
         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:
             if large or (lfsize and os.path.getsize(repo.wjoin(f)) >= \
                     lfsize * 1024 * 1024) 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.repo_add(repo,
                 standins) if f in m.files()]
     finally:
         wlock.release()
 
     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):
     manifest = repo[None].manifest()
     installnormalfilesmatchfn(manifest)
     orig(ui, repo, *pats, **opts)
     restorematchfn()
 
     after, force = opts.get('after'), opts.get('force')
     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
     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: file %s (use -f to force removal)\n')
                     % (m.rel(f), reason))
 
     if force:
         remove, forget = modified + deleted + clean, added
     elif after:
         remove, forget = deleted, []
         warn(modified + added + clean, _('still exists'))
     else:
         remove, forget = deleted + clean, []
         warn(modified, _('is modified'))
         warn(added, _('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:
                 os.unlink(repo.wjoin(f))
                 currentdir = os.path.split(f)[0]
                 while currentdir and not os.listdir(repo.wjoin(currentdir)):
                     os.rmdir(repo.wjoin(currentdir))
                     currentdir = os.path.split(currentdir)[0]
             lfdirstate.remove(f)
         lfdirstate.write()
 
         forget = [lfutil.standin(f) for f in forget]
         remove = [lfutil.standin(f) for f in remove]
         lfutil.repo_forget(repo, forget)
         lfutil.repo_remove(repo, remove, unlink=True)
     finally:
         wlock.release()
 
 def override_status(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):
     try:
         repo.lfstatus = True
         orig(ui, repo, *pats, **opts)
     finally:
         repo.lfstatus = False
 
 def override_verify(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 override_update(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)
 
 # 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):
     # 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 override_copy(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(os.path.relpath('.', repo.getcwd()),
             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 largefiles 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
-    # lfiles and run it again
+    # 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:
         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:
         # 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 override_match(repo, 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(repo, 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)
             orig_matchfn = m.matchfn
             m.matchfn = lambda f: lfutil.isstandin(f) and \
                 lfile(lfutil.splitstandin(f)) and \
                 orig_matchfn(lfutil.splitstandin(f)) or None
             return m
         oldmatch = installmatchfn(override_match)
         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 override_copyfile(src, dest):
                 if lfutil.shortname in src and lfutil.shortname in dest:
                     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 = override_copyfile
             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 lfutil.shortname in dest:
                 srclfile = src.replace(lfutil.shortname, '')
                 destlfile = dest.replace(lfutil.shortname, '')
                 destlfiledir = os.path.dirname(destlfile) or '.'
                 if not os.path.isdir(destlfiledir):
                     os.makedirs(destlfiledir)
                 if rename:
                     os.rename(srclfile, destlfile)
                     lfdirstate.remove(os.path.relpath(srclfile,
                         repo.root))
                 else:
                     util.copyfile(srclfile, destlfile)
                 lfdirstate.add(os.path.relpath(destlfile,
                     repo.root))
         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 lfiles accidentally.  This means we have to keep track of the lfiles
-# that are being reverted so we only pull down the necessary lfiles.
+# 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 lfiles) before commits.
-# Update the standins then run the original revert (changing the matcher to hit
-# standins instead of lfiles). Based on the resulting standins update the
-# lfiles. Then return the standins to their proper state
+# 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 override_revert(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.
+    # 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.lfdirstate_status(lfdirstate, repo, repo['.'].rev())
         for lfile in modified:
             lfutil.updatestandin(repo, lfutil.standin(lfile))
 
         try:
             ctx = repo[opts.get('rev')]
             oldmatch = None # for the closure
             def override_match(ctxorrepo, pats=[], opts={}, globbed=False,
                     default='relpath'):
                 if util.safehasattr(ctxorrepo, 'match'):
                     ctx0 = ctxorrepo
                 else:
                     ctx0 = ctxorrepo[None]
                 match = oldmatch(ctxorrepo, pats, opts, globbed, default)
                 m = copy.copy(match)
                 def tostandin(f):
                     if lfutil.standin(f) in ctx0 or 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)
                 orig_matchfn = m.matchfn
                 def matchfn(f):
                     if lfutil.isstandin(f):
-                        # We need to keep track of what lfiles are being
-                        # matched so we know which ones to update later
-                        # (otherwise we revert changes to other lfiles
-                        # accidentally).  This is repo specific, so duckpunch
-                        # the repo object to keep the list of lfiles for us
+                        # 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 orig_matchfn(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 orig_matchfn(f)
                 m.matchfn = matchfn
                 return m
             oldmatch = installmatchfn(override_match)
             scmutil.match
             matches = override_match(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 lfiles list so we start fresh next time
+
+        # 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 hg_update(orig, repo, node):
     result = orig(repo, node)
     # XXX check if it worked first
     lfcommands.updatelfiles(repo.ui, repo)
     return result
 
 def hg_clean(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):
     result = orig(repo, node, force, remind)
     lfcommands.updatelfiles(repo.ui, repo)
     return result
 
-# When we rebase a repository with remotely changed lfiles, we need
-# to take some extra care so that the lfiles are correctly updated
-# in the working copy
+# 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):
     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'
         result = orig(ui, repo, source, **opts)
     return result
 
 def override_rebase(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,
             prefix=None, mtime=None, subrepos=None):
-    # No need to lock because we are only reading history and lfile caches
-    # neither of which are modified
-
+    # 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())
             f = lfutil.splitstandin(f)
 
             def getdatafn():
                 try:
                     fd = open(path, 'rb')
                     return fd.read()
                 finally:
                     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)
             try:
                 sub.archive(repo.ui, archiver, prefix)
             except TypeError:
                 sub.archive(archiver, prefix)
 
     archiver.done()
 
-# If a lfile 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 lfiles were changed. This is
-# used by bisect and backout.
+# 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 override_bailifchanged(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.bail_if_changed so override it to add the check
 def override_fetch(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 override_forget(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.repo_remove(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 override_outgoing(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 override_summary(orig, ui, repo, *pats, **opts):
     orig(ui, repo, *pats, **opts)
 
     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 override_addremove(orig, ui, repo, *pats, **opts):
-    # Check if the parent or child has lfiles if they do don't allow it.  If
-    # there is a symlink in the manifest then getting the manifest throws an
-    # exception catch it and let addremove deal with it. This happens in
-    # Mercurial's test test-addremove-symlink
+    # Check if the parent or child has largefiles; if so, disallow
+    # addremove. If there is a symlink in the manifest then getting
+    # the manifest throws an exception: catch it and let addremove
+    # deal with it.
     try:
         manifesttip = set(repo['tip'].manifest())
     except util.Abort:
         manifesttip = set()
     try:
         manifestworking = set(repo[None].manifest())
     except util.Abort:
         manifestworking = set()
 
     # Manifests are only iterable so turn them into sets then union
     for file in manifesttip.union(manifestworking):
         if file.startswith(lfutil.shortname):
             raise util.Abort(
                 _('addremove cannot be run on a repo with largefiles'))
 
     return orig(ui, repo, *pats, **opts)
 
-# Calling purge with --all will cause the lfiles to be deleted.
+# 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):
     oldstatus = repo.status
     def override_status(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 = override_status
     orig(ui, repo, *dirs, **opts)
     repo.status = oldstatus
 
 def override_rollback(orig, ui, repo, **opts):
     result = orig(ui, repo, **opts)
     merge.update(repo, node=None, branchmerge=False, force=True,
         partial=lfutil.isstandin)
     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()
     return result

hgext/largefiles/reposetup.py

@@ -1,412 +1,412 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
 import re
 
 from mercurial import context, error, manifest, match as match_, \
         node, util
 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 not (isinstance(method, types.MethodType) and
         #        method.im_func is repo.__class__.commitctx.im_func):
         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 lfiles_repo(repo.__class__):
         lfstatus = False
         def status_nolfiles(self, *args, **kwargs):
             return super(lfiles_repo, 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)
             if self.lfstatus:
                 class lfiles_manifestdict(manifest.manifestdict):
                     def __contains__(self, filename):
                         if super(lfiles_manifestdict,
                                 self).__contains__(filename):
                             return True
                         return super(lfiles_manifestdict,
                             self).__contains__(lfutil.shortname+'/' + filename)
                 class lfiles_ctx(ctx.__class__):
                     def files(self):
                         filenames = super(lfiles_ctx, self).files()
                         return [re.sub('^\\'+lfutil.shortname+'/', '',
                                        filename) for filename in filenames]
                     def manifest(self):
                         man1 = super(lfiles_ctx, self).manifest()
                         man1.__class__ = lfiles_manifestdict
                         return man1
                     def filectx(self, path, fileid=None, filelog=None):
                         try:
                             result = super(lfiles_ctx, self).filectx(path,
                                 fileid, filelog)
                         except error.LookupError:
                             # Adding a null character will cause Mercurial to
                             # identify this as a binary file.
                             result = super(lfiles_ctx, self).filectx(
                                 lfutil.shortname + '/' + path, fileid,
                                 filelog)
                             olddata = result.data
                             result.data = lambda: olddata() + '\0'
                         return result
                 ctx.__class__ = lfiles_ctx
             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:
                 try:
                     return super(lfiles_repo, self).status(node1, node2, match,
                         listignored, listclean, listunknown, listsubrepos)
                 except TypeError:
                     return super(lfiles_repo, self).status(node1, node2, match,
                         listignored, listclean, listunknown)
             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
 
-                # create a copy of match that matches standins instead of
-                # lfiles if matcher not set then it is the always matcher so
-                # overwrite that
                 if match is None:
                     match = match_.always(self.root, self.getcwd())
 
+                # 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
 
                 m = copy.copy(match)
                 m._files = [tostandin(f) for f in m._files]
 
                 # get ignored, clean, and unknown but remove them
                 # later if they were not asked for
                 try:
                     result = super(lfiles_repo, self).status(node1, node2, m,
                         True, True, True, listsubrepos)
                 except TypeError:
                     result = super(lfiles_repo, self).status(node1, node2, m,
                         True, True, True)
                 if working:
                     # hold the wlock while we read largefiles and
                     # update the lfdirstate
                     wlock = repo.wlock()
                     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.
                         lfdirstate = lfutil.openlfdirstate(ui, self)
                         match._files = [f for f in match._files if f in
                             lfdirstate]
                         s = lfdirstate.status(match, [], listignored,
                                 listclean, listunknown)
                         (unsure, modified, added, removed, missing, unknown,
                                 ignored, clean) = s
                         if parentworking:
                             for lfile in unsure:
                                 if ctx1[lfutil.standin(lfile)].data().strip() \
                                         != lfutil.hashfile(self.wjoin(lfile)):
                                     modified.append(lfile)
                                 else:
                                     clean.append(lfile)
                                     lfdirstate.normal(lfile)
                             lfdirstate.write()
                         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:
                         wlock.release()
 
                     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)
                     # Handle unknown and ignored differently
                     lfiles = (modified, added, removed, missing, [], [], clean)
                     result = list(result)
                     # Unknown files
                     result[4] = [f for f in unknown if repo.dirstate[f] == '?'\
                         and not lfutil.isstandin(f)]
                     # Ignored files must be ignored by both the dirstate and
                     # lfdirstate
                     result[5] = set(ignored).intersection(set(result[5]))
-                    # combine normal files and lfiles
+                    # combine normal files and largefiles
                     normals = [[fn for fn in filelist if not \
                         lfutil.isstandin(fn)] for filelist in result]
                     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
 
-        # This call happens after a commit has occurred. Copy all of the lfiles
-        # into the cache
+        # 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)
             ctx = self[node]
             for filename in ctx.files():
                 if lfutil.isstandin(filename) and filename in ctx.manifest():
                     realfile = lfutil.splitstandin(filename)
                     lfutil.copytocache(self, ctx.node(), realfile)
 
             return node
 
-        # This call happens before a commit has occurred. The lfile standins
-        # have not had their contents updated (to reflect the hash of their
-        # lfile).  Do that here.
+        # 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(lfiles_repo, self).commit
 
             wlock = repo.wlock()
             try:
                 if getattr(repo, "_isrebasing", False):
-                    # We have to take the time to pull down the new lfiles now.
-                    # Otherwise if we are rebasing, any lfiles that were
-                    # modified in the changesets we are rebasing on top of get
-                    # overwritten either by the rebase or in the first commit
-                    # after the rebase.
+                    # We have to take the time to pull down the new
+                    # largefiles now. Otherwise if we are rebasing,
+                    # any largefiles that were modified in the
+                    # destination changesets get overwritten, either
+                    # by the rebase or in the first commit after the
+                    # rebase.
                     lfcommands.updatelfiles(repo.ui, repo)
                 # 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 lfiles that exist (not
+                    # 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))):
                                 # 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)
                     lfdirstate.write()
 
                     return orig(text=text, user=user, date=date, match=match,
                                     force=force, editor=editor, extra=extra)
 
                 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.dirstate_walk(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)
                 lfdirstate.write()
 
                 # 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)
                 orig_matchfn = match.matchfn
 
-                # Check both the list of lfiles and the list of standins
-                # because if a lfile was removed, it won't be in the list of
-                # lfiles at this point
+                # 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 lfutil.any_(st for st in match._files if \
                             st.startswith(fstandin)):
                         continue
                     actualfiles.append(f)
                 match._files = actualfiles
 
                 def matchfn(f):
                     if orig_matchfn(f):
                         return f not in lfiles
                     else:
                         return f in standins
 
                 match.matchfn = matchfn
                 return orig(text=text, user=user, date=date, match=match,
                                 force=force, editor=editor, extra=extra)
             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(lfiles_repo, self).push(remote, force, revs,
                 newbranch)
 
     repo.__class__ = lfiles_repo
 
     def checkrequireslfiles(ui, repo, **kwargs):
         if 'largefiles' not in repo.requirements and lfutil.any_(
                 lfutil.shortname+'/' in f[0] for f in repo.store.datafiles()):
             # workaround bug in Mercurial 1.9 whereby requirements is
             # a list on newly-cloned repos
             repo.requirements = set(repo.requirements)
 
             repo.requirements |= set(['largefiles'])
             repo._writerequirements()
 
     checkrequireslfiles(ui, repo)
 
     ui.setconfig('hooks', 'changegroup.lfiles', checkrequireslfiles)
     ui.setconfig('hooks', 'commit.lfiles', checkrequireslfiles)

hgext/largefiles/uisetup.py

@@ -1,138 +1,138 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 extension: uisetup'''
 
 from mercurial import archival, cmdutil, commands, extensions, filemerge, hg, \
     httprepo, localrepo, sshrepo, sshserver, util, wireproto
 from mercurial.i18n import _
 from mercurial.hgweb import hgweb_mod, protocol
 
 import overrides
 import proto
 
 def uisetup(ui):
     # Disable auto-status for some commands which assume that all
     # files in the result are under Mercurial's control
 
     entry = extensions.wrapcommand(commands.table, 'add',
                                    overrides.override_add)
     addopt = [('', 'large', None, _('add as largefile')),
             ('', 'lfsize', '', _('add all files above this size (in megabytes)'
                                  'as largefiles (default: 10)'))]
     entry[1].extend(addopt)
 
     entry = extensions.wrapcommand(commands.table, 'addremove',
             overrides.override_addremove)
     entry = extensions.wrapcommand(commands.table, 'remove',
                                    overrides.override_remove)
     entry = extensions.wrapcommand(commands.table, 'forget',
                                    overrides.override_forget)
     entry = extensions.wrapcommand(commands.table, 'status',
                                    overrides.override_status)
     entry = extensions.wrapcommand(commands.table, 'log',
                                    overrides.override_log)
     entry = extensions.wrapcommand(commands.table, 'rollback',
                                    overrides.override_rollback)
     entry = extensions.wrapcommand(commands.table, 'verify',
                                    overrides.override_verify)
 
     verifyopt = [('', 'large', None, _('verify largefiles')),
                  ('', 'lfa', None,
                      _('verify all revisions of largefiles not just current')),
                  ('', 'lfc', None,
                      _('verify largefile contents not just existence'))]
     entry[1].extend(verifyopt)
 
     entry = extensions.wrapcommand(commands.table, 'outgoing',
         overrides.override_outgoing)
     outgoingopt = [('', 'large', None, _('display outgoing largefiles'))]
     entry[1].extend(outgoingopt)
     entry = extensions.wrapcommand(commands.table, 'summary',
                                    overrides.override_summary)
     summaryopt = [('', 'large', None, _('display outgoing largefiles'))]
     entry[1].extend(summaryopt)
 
     entry = extensions.wrapcommand(commands.table, 'update',
                                    overrides.override_update)
     entry = extensions.wrapcommand(commands.table, 'pull',
                                    overrides.override_pull)
     entry = extensions.wrapfunction(filemerge, 'filemerge',
                                     overrides.override_filemerge)
     entry = extensions.wrapfunction(cmdutil, 'copy',
                                     overrides.override_copy)
 
     # Backout calls revert so we need to override both the command and the
     # function
     entry = extensions.wrapcommand(commands.table, 'revert',
                                    overrides.override_revert)
     entry = extensions.wrapfunction(commands, 'revert',
                                     overrides.override_revert)
 
     # 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(archival, 'archive', overrides.override_archive)
     if util.safehasattr(cmdutil, 'bailifchanged'):
         extensions.wrapfunction(cmdutil, 'bailifchanged',
             overrides.override_bailifchanged)
     else:
         extensions.wrapfunction(cmdutil, 'bail_if_changed',
             overrides.override_bailifchanged)
 
     # create the new wireproto commands ...
     wireproto.commands['putlfile'] = (proto.putlfile, 'sha')
     wireproto.commands['getlfile'] = (proto.getlfile, 'sha')
     wireproto.commands['statlfile'] = (proto.statlfile, 'sha')
 
     # ... and wrap some existing ones
     wireproto.commands['capabilities'] = (proto.capabilities, '')
     wireproto.commands['heads'] = (proto.heads, '')
     wireproto.commands['lheads'] = (wireproto.heads, '')
 
-    # make putlfile behave the same as push and {get,stat}lfile behave the same
-    # as pull w.r.t. permissions checks
+    # make putlfile behave the same as push and {get,stat}lfile behave
+    # the same as pull w.r.t. permissions checks
     hgweb_mod.perms['putlfile'] = 'push'
     hgweb_mod.perms['getlfile'] = 'pull'
     hgweb_mod.perms['statlfile'] = 'pull'
 
     # 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
     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
 
     # 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
 
     # don't die on seeing a repo with the largefiles requirement
     localrepo.localrepository.supported |= set(['largefiles'])
 
     # override some extensions' stuff as well
     for name, module in extensions.extensions():
         if name == 'fetch':
             extensions.wrapcommand(getattr(module, 'cmdtable'), 'fetch',
                 overrides.override_fetch)
         if name == 'purge':
             extensions.wrapcommand(getattr(module, 'cmdtable'), 'purge',
                 overrides.override_purge)
         if name == 'rebase':
             extensions.wrapcommand(getattr(module, 'cmdtable'), 'rebase',
                 overrides.override_rebase)