bundlerepo: reintroduce dirstate

hgext/keyword.py

@@ -1,532 +1,536 b''
 # keyword.py - $Keyword$ expansion for Mercurial
 #
 # Copyright 2007, 2008 Christian Ebert <[e-mail]>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 #
 # $Id$
 #
 # Keyword expansion hack against the grain of a DSCM
 #
 # There are many good reasons why this is not needed in a distributed
 # SCM, still it may be useful in very small projects based on single
 # files (like LaTeX packages), that are mostly addressed to an audience
 # not running a version control system.
 #
 # For in-depth discussion refer to
 # <http://www.selenic.com/mercurial/wiki/index.cgi/KeywordPlan>.
 #
 # Keyword expansion is based on Mercurial's changeset template mappings.
 #
 # Binary files are not touched.
 #
 # Setup in hgrc:
 #
 #   [extensions]
 #   # enable extension
 #   hgext.keyword =
 #
 # Files to act upon/ignore are specified in the [keyword] section.
 # Customized keyword template mappings in the [keywordmaps] section.
 #
 # Run "hg help keyword" and "hg kwdemo" to get info on configuration.
 
 '''keyword expansion in local repositories
 
 This extension expands RCS/CVS-like or self-customized $Keywords$
 in tracked text files selected by your configuration.
 
 Keywords are only expanded in local repositories and not stored in
 the change history. The mechanism can be regarded as a convenience
 for the current user or for archive distribution.
 
 Configuration is done in the [keyword] and [keywordmaps] sections
 of hgrc files.
 
 Example:
 
     [keyword]
     # expand keywords in every python file except those matching "x*"
     **.py =
     x*    = ignore
 
 Note: the more specific you are in your filename patterns
       the less you lose speed in huge repos.
 
 For [keywordmaps] template mapping and expansion demonstration and
 control run "hg kwdemo".
 
 An additional date template filter {date|utcdate} is provided.
 
 The default template mappings (view with "hg kwdemo -d") can be replaced
 with customized keywords and templates.
 Again, run "hg kwdemo" to control the results of your config changes.
 
 Before changing/disabling active keywords, run "hg kwshrink" to avoid
 the risk of inadvertedly storing expanded keywords in the change history.
 
 To force expansion after enabling it, or a configuration change, run
 "hg kwexpand".
 
 Also, when committing with the record extension or using mq's qrecord, be aware
 that keywords cannot be updated. Again, run "hg kwexpand" on the files in
 question to update keyword expansions after all changes have been checked in.
 
 Expansions spanning more than one line and incremental expansions,
 like CVS' $Log$, are not supported. A keyword template map
 "Log = {desc}" expands to the first line of the changeset description.
 '''
 
 from mercurial import commands, cmdutil, dispatch, filelog, revlog, extensions
 from mercurial import patch, localrepo, templater, templatefilters, util
 from mercurial.hgweb import webcommands
 from mercurial.node import nullid, hex
 from mercurial.i18n import _
 import re, shutil, tempfile, time
 
 commands.optionalrepo += ' kwdemo'
 
 # hg commands that do not act on keywords
 nokwcommands = ('add addremove annotate bundle copy export grep incoming init'
                 ' log outgoing push rename rollback tip verify'
                 ' convert email glog')
 
 # hg commands that trigger expansion only when writing to working dir,
 # not when reading filelog, and unexpand when reading from working dir
 restricted = 'merge record resolve qfold qimport qnew qpush qrefresh qrecord'
 
 def utcdate(date):
     '''Returns hgdate in cvs-like UTC format.'''
     return time.strftime('%Y/%m/%d %H:%M:%S', time.gmtime(date[0]))
 
 # make keyword tools accessible
 kwtools = {'templater': None, 'hgcmd': '', 'inc': [], 'exc': ['.hg*']}
 
 
 class kwtemplater(object):
     '''
     Sets up keyword templates, corresponding keyword regex, and
     provides keyword substitution functions.
     '''
     templates = {
         'Revision': '{node|short}',
         'Author': '{author|user}',
         'Date': '{date|utcdate}',
         'RCSFile': '{file|basename},v',
         'Source': '{root}/{file},v',
         'Id': '{file|basename},v {node|short} {date|utcdate} {author|user}',
         'Header': '{root}/{file},v {node|short} {date|utcdate} {author|user}',
     }
 
     def __init__(self, ui, repo):
         self.ui = ui
         self.repo = repo
         self.matcher = util.matcher(repo.root,
                                     inc=kwtools['inc'], exc=kwtools['exc'])[1]
         self.restrict = kwtools['hgcmd'] in restricted.split()
 
         kwmaps = self.ui.configitems('keywordmaps')
         if kwmaps: # override default templates
             kwmaps = [(k, templater.parsestring(v, False))
                       for (k, v) in kwmaps]
             self.templates = dict(kwmaps)
         escaped = map(re.escape, self.templates.keys())
         kwpat = r'\$(%s)(: [^$\n\r]*? )??\$' % '|'.join(escaped)
         self.re_kw = re.compile(kwpat)
 
         templatefilters.filters['utcdate'] = utcdate
         self.ct = cmdutil.changeset_templater(self.ui, self.repo,
                                               False, None, '', False)
 
     def substitute(self, data, path, ctx, subfunc):
         '''Replaces keywords in data with expanded template.'''
         def kwsub(mobj):
             kw = mobj.group(1)
             self.ct.use_template(self.templates[kw])
             self.ui.pushbuffer()
             self.ct.show(ctx, root=self.repo.root, file=path)
             ekw = templatefilters.firstline(self.ui.popbuffer())
             return '$%s: %s $' % (kw, ekw)
         return subfunc(kwsub, data)
 
     def expand(self, path, node, data):
         '''Returns data with keywords expanded.'''
         if not self.restrict and self.matcher(path) and not util.binary(data):
             ctx = self.repo.filectx(path, fileid=node).changectx()
             return self.substitute(data, path, ctx, self.re_kw.sub)
         return data
 
     def iskwfile(self, path, flagfunc):
         '''Returns true if path matches [keyword] pattern
         and is not a symbolic link.
         Caveat: localrepository._link fails on Windows.'''
         return self.matcher(path) and not 'l' in flagfunc(path)
 
     def overwrite(self, node, expand, files):
         '''Overwrites selected files expanding/shrinking keywords.'''
         ctx = self.repo[node]
         mf = ctx.manifest()
         if node is not None:     # commit
             files = [f for f in ctx.files() if f in mf]
             notify = self.ui.debug
         else:                    # kwexpand/kwshrink
             notify = self.ui.note
         candidates = [f for f in files if self.iskwfile(f, ctx.flags)]
         if candidates:
             self.restrict = True # do not expand when reading
             action = expand and 'expanding' or 'shrinking'
             for f in candidates:
                 fp = self.repo.file(f)
                 data = fp.read(mf[f])
                 if util.binary(data):
                     continue
                 if expand:
                     if node is None:
                         ctx = self.repo.filectx(f, fileid=mf[f]).changectx()
                     data, found = self.substitute(data, f, ctx,
                                                   self.re_kw.subn)
                 else:
                     found = self.re_kw.search(data)
                 if found:
                     notify(_('overwriting %s %s keywords\n') % (f, action))
                     self.repo.wwrite(f, data, mf.flags(f))
                     self.repo.dirstate.normal(f)
             self.restrict = False
 
     def shrinktext(self, text):
         '''Unconditionally removes all keyword substitutions from text.'''
         return self.re_kw.sub(r'$\1$', text)
 
     def shrink(self, fname, text):
         '''Returns text with all keyword substitutions removed.'''
         if self.matcher(fname) and not util.binary(text):
             return self.shrinktext(text)
         return text
 
     def shrinklines(self, fname, lines):
         '''Returns lines with keyword substitutions removed.'''
         if self.matcher(fname):
             text = ''.join(lines)
             if not util.binary(text):
                 return self.shrinktext(text).splitlines(True)
         return lines
 
     def wread(self, fname, data):
         '''If in restricted mode returns data read from wdir with
         keyword substitutions removed.'''
         return self.restrict and self.shrink(fname, data) or data
 
 class kwfilelog(filelog.filelog):
     '''
     Subclass of filelog to hook into its read, add, cmp methods.
     Keywords are "stored" unexpanded, and processed on reading.
     '''
     def __init__(self, opener, kwt, path):
         super(kwfilelog, self).__init__(opener, path)
         self.kwt = kwt
         self.path = path
 
     def read(self, node):
         '''Expands keywords when reading filelog.'''
         data = super(kwfilelog, self).read(node)
         return self.kwt.expand(self.path, node, data)
 
     def add(self, text, meta, tr, link, p1=None, p2=None):
         '''Removes keyword substitutions when adding to filelog.'''
         text = self.kwt.shrink(self.path, text)
         return super(kwfilelog, self).add(text, meta, tr, link, p1, p2)
 
     def cmp(self, node, text):
         '''Removes keyword substitutions for comparison.'''
         text = self.kwt.shrink(self.path, text)
         if self.renamed(node):
             t2 = super(kwfilelog, self).read(node)
             return t2 != text
         return revlog.revlog.cmp(self, node, text)
 
 def _status(ui, repo, kwt, unknown, *pats, **opts):
     '''Bails out if [keyword] configuration is not active.
     Returns status of working directory.'''
     if kwt:
         matcher = cmdutil.match(repo, pats, opts)
         return repo.status(match=matcher, unknown=unknown, clean=True)
     if ui.configitems('keyword'):
         raise util.Abort(_('[keyword] patterns cannot match'))
     raise util.Abort(_('no [keyword] patterns configured'))
 
 def _kwfwrite(ui, repo, expand, *pats, **opts):
     '''Selects files and passes them to kwtemplater.overwrite.'''
     if repo.dirstate.parents()[1] != nullid:
         raise util.Abort(_('outstanding uncommitted merge'))
     kwt = kwtools['templater']
     status = _status(ui, repo, kwt, False, *pats, **opts)
     modified, added, removed, deleted = status[:4]
     if modified or added or removed or deleted:
         raise util.Abort(_('outstanding uncommitted changes'))
     wlock = lock = None
     try:
         wlock = repo.wlock()
         lock = repo.lock()
         kwt.overwrite(None, expand, status[6])
     finally:
         del wlock, lock
 
 
 def demo(ui, repo, *args, **opts):
     '''print [keywordmaps] configuration and an expansion example
 
     Show current, custom, or default keyword template maps
     and their expansion.
 
     Extend current configuration by specifying maps as arguments
     and optionally by reading from an additional hgrc file.
 
     Override current keyword template maps with "default" option.
     '''
     def demostatus(stat):
         ui.status(_('\n\t%s\n') % stat)
 
     def demoitems(section, items):
         ui.write('[%s]\n' % section)
         for k, v in items:
             ui.write('%s = %s\n' % (k, v))
 
     msg = 'hg keyword config and expansion example'
     kwstatus = 'current'
     fn = 'demo.txt'
     branchname = 'demobranch'
     tmpdir = tempfile.mkdtemp('', 'kwdemo.')
     ui.note(_('creating temporary repo at %s\n') % tmpdir)
     repo = localrepo.localrepository(ui, tmpdir, True)
     ui.setconfig('keyword', fn, '')
     if args or opts.get('rcfile'):
         kwstatus = 'custom'
     if opts.get('rcfile'):
         ui.readconfig(opts.get('rcfile'))
     if opts.get('default'):
         kwstatus = 'default'
         kwmaps = kwtemplater.templates
         if ui.configitems('keywordmaps'):
             # override maps from optional rcfile
             for k, v in kwmaps.iteritems():
                 ui.setconfig('keywordmaps', k, v)
     elif args:
         # simulate hgrc parsing
         rcmaps = ['[keywordmaps]\n'] + [a + '\n' for a in args]
         fp = repo.opener('hgrc', 'w')
         fp.writelines(rcmaps)
         fp.close()
         ui.readconfig(repo.join('hgrc'))
     if not opts.get('default'):
         kwmaps = dict(ui.configitems('keywordmaps')) or kwtemplater.templates
     uisetup(ui)
     reposetup(ui, repo)
     for k, v in ui.configitems('extensions'):
         if k.endswith('keyword'):
             extension = '%s = %s' % (k, v)
             break
     demostatus('config using %s keyword template maps' % kwstatus)
     ui.write('[extensions]\n%s\n' % extension)
     demoitems('keyword', ui.configitems('keyword'))
     demoitems('keywordmaps', kwmaps.iteritems())
     keywords = '$' + '$\n$'.join(kwmaps.keys()) + '$\n'
     repo.wopener(fn, 'w').write(keywords)
     repo.add([fn])
     path = repo.wjoin(fn)
     ui.note(_('\n%s keywords written to %s:\n') % (kwstatus, path))
     ui.note(keywords)
     ui.note('\nhg -R "%s" branch "%s"\n' % (tmpdir, branchname))
     # silence branch command if not verbose
     quiet = ui.quiet
     ui.quiet = not ui.verbose
     commands.branch(ui, repo, branchname)
     ui.quiet = quiet
     for name, cmd in ui.configitems('hooks'):
         if name.split('.', 1)[0].find('commit') > -1:
             repo.ui.setconfig('hooks', name, '')
     ui.note(_('unhooked all commit hooks\n'))
     ui.note('hg -R "%s" ci -m "%s"\n' % (tmpdir, msg))
     repo.commit(text=msg)
     fmt = ui.verbose and ' in %s' % path or ''
     demostatus('%s keywords expanded%s' % (kwstatus, fmt))
     ui.write(repo.wread(fn))
     ui.debug(_('\nremoving temporary repo %s\n') % tmpdir)
     shutil.rmtree(tmpdir, ignore_errors=True)
 
 def expand(ui, repo, *pats, **opts):
     '''expand keywords in working directory
 
     Run after (re)enabling keyword expansion.
 
     kwexpand refuses to run if given files contain local changes.
     '''
     # 3rd argument sets expansion to True
     _kwfwrite(ui, repo, True, *pats, **opts)
 
 def files(ui, repo, *pats, **opts):
     '''print files currently configured for keyword expansion
 
     Crosscheck which files in working directory are potential targets for
     keyword expansion.
     That is, files matched by [keyword] config patterns but not symlinks.
     '''
     kwt = kwtools['templater']
     status = _status(ui, repo, kwt, opts.get('untracked'), *pats, **opts)
     modified, added, removed, deleted, unknown, ignored, clean = status
     files = util.sort(modified + added + clean + unknown)
     wctx = repo[None]
     kwfiles = [f for f in files if kwt.iskwfile(f, wctx.flags)]
     cwd = pats and repo.getcwd() or ''
     kwfstats = not opts.get('ignore') and (('K', kwfiles),) or ()
     if opts.get('all') or opts.get('ignore'):
         kwfstats += (('I', [f for f in files if f not in kwfiles]),)
     for char, filenames in kwfstats:
         fmt = (opts.get('all') or ui.verbose) and '%s %%s\n' % char or '%s\n'
         for f in filenames:
             ui.write(fmt % repo.pathto(f, cwd))
 
 def shrink(ui, repo, *pats, **opts):
     '''revert expanded keywords in working directory
 
     Run before changing/disabling active keywords
     or if you experience problems with "hg import" or "hg merge".
 
     kwshrink refuses to run if given files contain local changes.
     '''
     # 3rd argument sets expansion to False
     _kwfwrite(ui, repo, False, *pats, **opts)
 
 
 def uisetup(ui):
     '''Collects [keyword] config in kwtools.
     Monkeypatches dispatch._parse if needed.'''
 
     for pat, opt in ui.configitems('keyword'):
         if opt != 'ignore':
             kwtools['inc'].append(pat)
         else:
             kwtools['exc'].append(pat)
 
     if kwtools['inc']:
         def kwdispatch_parse(orig, ui, args):
             '''Monkeypatch dispatch._parse to obtain running hg command.'''
             cmd, func, args, options, cmdoptions = orig(ui, args)
             kwtools['hgcmd'] = cmd
             return cmd, func, args, options, cmdoptions
 
         extensions.wrapfunction(dispatch, '_parse', kwdispatch_parse)
 
 def reposetup(ui, repo):
     '''Sets up repo as kwrepo for keyword substitution.
     Overrides file method to return kwfilelog instead of filelog
     if file matches user configuration.
     Wraps commit to overwrite configured files with updated
     keyword substitutions.
     Monkeypatches patch and webcommands.'''
 
-    if (not hasattr(repo, 'dirstate') or not kwtools['inc']
-        or kwtools['hgcmd'] in nokwcommands.split()
-        or '.hg' in util.splitpath(repo.root)):
-        return
+    try:
+        if (not repo.local() or not kwtools['inc']
+            or kwtools['hgcmd'] in nokwcommands.split()
+            or '.hg' in util.splitpath(repo.root)
+            or repo._url.startswith('bundle:')):
+            return
+    except AttributeError:
+        pass
 
     kwtools['templater'] = kwt = kwtemplater(ui, repo)
 
     class kwrepo(repo.__class__):
         def file(self, f):
             if f[0] == '/':
                 f = f[1:]
             return kwfilelog(self.sopener, kwt, f)
 
         def wread(self, filename):
             data = super(kwrepo, self).wread(filename)
             return kwt.wread(filename, data)
 
         def commit(self, files=None, text='', user=None, date=None,
                    match=None, force=False, force_editor=False,
                    p1=None, p2=None, extra={}, empty_ok=False):
             wlock = lock = None
             _p1 = _p2 = None
             try:
                 wlock = self.wlock()
                 lock = self.lock()
                 # store and postpone commit hooks
                 commithooks = {}
                 for name, cmd in ui.configitems('hooks'):
                     if name.split('.', 1)[0] == 'commit':
                         commithooks[name] = cmd
                         ui.setconfig('hooks', name, None)
                 if commithooks:
                     # store parents for commit hook environment
                     if p1 is None:
                         _p1, _p2 = repo.dirstate.parents()
                     else:
                         _p1, _p2 = p1, p2 or nullid
                     _p1 = hex(_p1)
                     if _p2 == nullid:
                         _p2 = ''
                     else:
                         _p2 = hex(_p2)
 
                 n = super(kwrepo, self).commit(files, text, user, date, match,
                                                force, force_editor, p1, p2,
                                                extra, empty_ok)
 
                 # restore commit hooks
                 for name, cmd in commithooks.iteritems():
                     ui.setconfig('hooks', name, cmd)
                 if n is not None:
                     kwt.overwrite(n, True, None)
                     repo.hook('commit', node=n, parent1=_p1, parent2=_p2)
                 return n
             finally:
                 del wlock, lock
 
     # monkeypatches
     def kwpatchfile_init(orig, self, ui, fname, opener, missing=False):
         '''Monkeypatch/wrap patch.patchfile.__init__ to avoid
         rejects or conflicts due to expanded keywords in working dir.'''
         orig(self, ui, fname, opener, missing)
         # shrink keywords read from working dir
         self.lines = kwt.shrinklines(self.fname, self.lines)
 
     def kw_diff(orig, repo, node1=None, node2=None, match=None, changes=None,
                 opts=None):
         '''Monkeypatch patch.diff to avoid expansion except when
         comparing against working dir.'''
         if node2 is not None:
             kwt.matcher = util.never
         elif node1 is not None and node1 != repo['.'].node():
             kwt.restrict = True
         return orig(repo, node1, node2, match, changes, opts)
 
     def kwweb_skip(orig, web, req, tmpl):
         '''Wraps webcommands.x turning off keyword expansion.'''
         kwt.matcher = util.never
         return orig(web, req, tmpl)
 
     repo.__class__ = kwrepo
 
     extensions.wrapfunction(patch.patchfile, '__init__', kwpatchfile_init)
     extensions.wrapfunction(patch, 'diff', kw_diff)
     for c in 'annotate changeset rev filediff diff'.split():
         extensions.wrapfunction(webcommands, c, kwweb_skip)
 
 cmdtable = {
     'kwdemo':
         (demo,
          [('d', 'default', None, _('show default keyword template maps')),
           ('f', 'rcfile', [], _('read maps from rcfile'))],
          _('hg kwdemo [-d] [-f RCFILE] [TEMPLATEMAP]...')),
     'kwexpand': (expand, commands.walkopts,
                  _('hg kwexpand [OPTION]... [FILE]...')),
     'kwfiles':
         (files,
          [('a', 'all', None, _('show keyword status flags of all files')),
           ('i', 'ignore', None, _('show files excluded from expansion')),
           ('u', 'untracked', None, _('additionally show untracked files')),
          ] + commands.walkopts,
          _('hg kwfiles [OPTION]... [FILE]...')),
     'kwshrink': (shrink, commands.walkopts,
                  _('hg kwshrink [OPTION]... [FILE]...')),
 }

mercurial/bundlerepo.py

@@ -1,298 +1,298 b''
 """
 bundlerepo.py - repository class for viewing uncompressed bundles
 
 This provides a read-only repository interface to bundles as if
 they were part of the actual repository.
 
 Copyright 2006, 2007 Benoit Boissinot <[e-mail]>
 
 This software may be used and distributed according to the terms
 of the GNU General Public License, incorporated herein by reference.
 """
 
 from node import hex, nullid, short
 from i18n import _
 import changegroup, util, os, struct, bz2, zlib, tempfile, shutil, mdiff
 import repo, localrepo, changelog, manifest, filelog, revlog, context, error
 
 class bundlerevlog(revlog.revlog):
     def __init__(self, opener, indexfile, bundlefile,
                  linkmapper=None):
         # How it works:
         # to retrieve a revision, we need to know the offset of
         # the revision in the bundlefile (an opened file).
         #
         # We store this offset in the index (start), to differentiate a
         # rev in the bundle and from a rev in the revlog, we check
         # len(index[r]). If the tuple is bigger than 7, it is a bundle
         # (it is bigger since we store the node to which the delta is)
         #
         revlog.revlog.__init__(self, opener, indexfile)
         self.bundlefile = bundlefile
         self.basemap = {}
         def chunkpositer():
             for chunk in changegroup.chunkiter(bundlefile):
                 pos = bundlefile.tell()
                 yield chunk, pos - len(chunk)
         n = len(self)
         prev = None
         for chunk, start in chunkpositer():
             size = len(chunk)
             if size < 80:
                 raise util.Abort(_("invalid changegroup"))
             start += 80
             size -= 80
             node, p1, p2, cs = struct.unpack("20s20s20s20s", chunk[:80])
             if node in self.nodemap:
                 prev = node
                 continue
             for p in (p1, p2):
                 if not p in self.nodemap:
                     raise error.LookupError(p1, self.indexfile,
                                             _("unknown parent"))
             if linkmapper is None:
                 link = n
             else:
                 link = linkmapper(cs)
 
             if not prev:
                 prev = p1
             # start, size, full unc. size, base (unused), link, p1, p2, node
             e = (revlog.offset_type(start, 0), size, -1, -1, link,
                  self.rev(p1), self.rev(p2), node)
             self.basemap[n] = prev
             self.index.insert(-1, e)
             self.nodemap[node] = n
             prev = node
             n += 1
 
     def bundle(self, rev):
         """is rev from the bundle"""
         if rev < 0:
             return False
         return rev in self.basemap
     def bundlebase(self, rev): return self.basemap[rev]
     def chunk(self, rev, df=None, cachelen=4096):
         # Warning: in case of bundle, the diff is against bundlebase,
         # not against rev - 1
         # XXX: could use some caching
         if not self.bundle(rev):
             return revlog.revlog.chunk(self, rev, df)
         self.bundlefile.seek(self.start(rev))
         return self.bundlefile.read(self.length(rev))
 
     def revdiff(self, rev1, rev2):
         """return or calculate a delta between two revisions"""
         if self.bundle(rev1) and self.bundle(rev2):
             # hot path for bundle
             revb = self.rev(self.bundlebase(rev2))
             if revb == rev1:
                 return self.chunk(rev2)
         elif not self.bundle(rev1) and not self.bundle(rev2):
             return revlog.revlog.revdiff(self, rev1, rev2)
 
         return mdiff.textdiff(self.revision(self.node(rev1)),
                          self.revision(self.node(rev2)))
 
     def revision(self, node):
         """return an uncompressed revision of a given"""
         if node == nullid: return ""
 
         text = None
         chain = []
         iter_node = node
         rev = self.rev(iter_node)
         # reconstruct the revision if it is from a changegroup
         while self.bundle(rev):
             if self._cache and self._cache[0] == iter_node:
                 text = self._cache[2]
                 break
             chain.append(rev)
             iter_node = self.bundlebase(rev)
             rev = self.rev(iter_node)
         if text is None:
             text = revlog.revlog.revision(self, iter_node)
 
         while chain:
             delta = self.chunk(chain.pop())
             text = mdiff.patches(text, [delta])
 
         p1, p2 = self.parents(node)
         if node != revlog.hash(text, p1, p2):
             raise error.RevlogError(_("integrity check failed on %s:%d")
                                      % (self.datafile, self.rev(node)))
 
         self._cache = (node, self.rev(node), text)
         return text
 
     def addrevision(self, text, transaction, link, p1=None, p2=None, d=None):
         raise NotImplementedError
     def addgroup(self, revs, linkmapper, transaction):
         raise NotImplementedError
     def strip(self, rev, minlink):
         raise NotImplementedError
     def checksize(self):
         raise NotImplementedError
 
 class bundlechangelog(bundlerevlog, changelog.changelog):
     def __init__(self, opener, bundlefile):
         changelog.changelog.__init__(self, opener)
         bundlerevlog.__init__(self, opener, self.indexfile, bundlefile)
 
 class bundlemanifest(bundlerevlog, manifest.manifest):
     def __init__(self, opener, bundlefile, linkmapper):
         manifest.manifest.__init__(self, opener)
         bundlerevlog.__init__(self, opener, self.indexfile, bundlefile,
                               linkmapper)
 
 class bundlefilelog(bundlerevlog, filelog.filelog):
     def __init__(self, opener, path, bundlefile, linkmapper):
         filelog.filelog.__init__(self, opener, path)
         bundlerevlog.__init__(self, opener, self.indexfile, bundlefile,
                               linkmapper)
 
 class bundlerepository(localrepo.localrepository):
     def __init__(self, ui, path, bundlename):
         self._tempparent = None
         try:
             localrepo.localrepository.__init__(self, ui, path)
         except error.RepoError:
             self._tempparent = tempfile.mkdtemp()
             tmprepo = localrepo.instance(ui,self._tempparent,1)
             localrepo.localrepository.__init__(self, ui, self._tempparent)
 
         if path:
             self._url = 'bundle:' + path + '+' + bundlename
         else:
             self._url = 'bundle:' + bundlename
 
         self.tempfile = None
         self.bundlefile = open(bundlename, "rb")
         header = self.bundlefile.read(6)
         if not header.startswith("HG"):
             raise util.Abort(_("%s: not a Mercurial bundle file") % bundlename)
         elif not header.startswith("HG10"):
             raise util.Abort(_("%s: unknown bundle version") % bundlename)
         elif (header == "HG10BZ") or (header == "HG10GZ"):
             fdtemp, temp = tempfile.mkstemp(prefix="hg-bundle-",
                                             suffix=".hg10un", dir=self.path)
             self.tempfile = temp
             fptemp = os.fdopen(fdtemp, 'wb')
             def generator(f):
                 if header == "HG10BZ":
                     zd = bz2.BZ2Decompressor()
                     zd.decompress("BZ")
                 elif header == "HG10GZ":
                     zd = zlib.decompressobj()
                 for chunk in f:
                     yield zd.decompress(chunk)
             gen = generator(util.filechunkiter(self.bundlefile, 4096))
 
             try:
                 fptemp.write("HG10UN")
                 for chunk in gen:
                     fptemp.write(chunk)
             finally:
                 fptemp.close()
                 self.bundlefile.close()
 
             self.bundlefile = open(self.tempfile, "rb")
             # seek right after the header
             self.bundlefile.seek(6)
         elif header == "HG10UN":
             # nothing to do
             pass
         else:
             raise util.Abort(_("%s: unknown bundle compression type")
                              % bundlename)
         # dict with the mapping 'filename' -> position in the bundle
         self.bundlefilespos = {}
 
     def __getattr__(self, name):
         if name == 'changelog':
             self.changelog = bundlechangelog(self.sopener, self.bundlefile)
             self.manstart = self.bundlefile.tell()
             return self.changelog
         elif name == 'manifest':
             self.bundlefile.seek(self.manstart)
             self.manifest = bundlemanifest(self.sopener, self.bundlefile,
                                            self.changelog.rev)
             self.filestart = self.bundlefile.tell()
             return self.manifest
         elif name == 'manstart':
             self.changelog
             return self.manstart
         elif name == 'filestart':
             self.manifest
             return self.filestart
         else:
-            raise AttributeError(name)
+            return localrepo.localrepository.__getattr__(self, name)
 
     def url(self):
         return self._url
 
     def file(self, f):
         if not self.bundlefilespos:
             self.bundlefile.seek(self.filestart)
             while 1:
                 chunk = changegroup.getchunk(self.bundlefile)
                 if not chunk:
                     break
                 self.bundlefilespos[chunk] = self.bundlefile.tell()
                 for c in changegroup.chunkiter(self.bundlefile):
                     pass
 
         if f[0] == '/':
             f = f[1:]
         if f in self.bundlefilespos:
             self.bundlefile.seek(self.bundlefilespos[f])
             return bundlefilelog(self.sopener, f, self.bundlefile,
                                  self.changelog.rev)
         else:
             return filelog.filelog(self.sopener, f)
 
     def close(self):
         """Close assigned bundle file immediately."""
         self.bundlefile.close()
 
     def __del__(self):
         bundlefile = getattr(self, 'bundlefile', None)
         if bundlefile and not bundlefile.closed:
             bundlefile.close()
         tempfile = getattr(self, 'tempfile', None)
         if tempfile is not None:
             os.unlink(tempfile)
         if self._tempparent:
             shutil.rmtree(self._tempparent, True)
 
     def cancopy(self):
         return False
 
     def getcwd(self):
         return os.getcwd() # always outside the repo
 
 def instance(ui, path, create):
     if create:
         raise util.Abort(_('cannot create new bundle repository'))
     parentpath = ui.config("bundle", "mainreporoot", "")
     if parentpath:
         # Try to make the full path relative so we get a nice, short URL.
         # In particular, we don't want temp dir names in test outputs.
         cwd = os.getcwd()
         if parentpath == cwd:
             parentpath = ''
         else:
             cwd = os.path.join(cwd,'')
             if parentpath.startswith(cwd):
                 parentpath = parentpath[len(cwd):]
     path = util.drop_scheme('file', path)
     if path.startswith('bundle:'):
         path = util.drop_scheme('bundle', path)
         s = path.split("+", 1)
         if len(s) == 1:
             repopath, bundlename = parentpath, s[0]
         else:
             repopath, bundlename = s
     else:
         repopath, bundlename = parentpath, path
     return bundlerepository(ui, repopath, bundlename)

tests/test-bundle

@@ -1,142 +1,149 b''
 #!/bin/sh
 
 cp "$TESTDIR"/printenv.py .
 
 echo "====== Setting up test"
 hg init test
 cd test
 echo 0 > afile
 hg add afile
 hg commit -m "0.0" -d "1000000 0"
 echo 1 >> afile
 hg commit -m "0.1" -d "1000000 0"
 echo 2 >> afile
 hg commit -m "0.2" -d "1000000 0"
 echo 3 >> afile
 hg commit -m "0.3" -d "1000000 0"
 hg update -C 0
 echo 1 >> afile
 hg commit -m "1.1" -d "1000000 0"
 echo 2 >> afile
 hg commit -m "1.2" -d "1000000 0"
 echo "a line" > fred
 echo 3 >> afile
 hg add fred
 hg commit -m "1.3" -d "1000000 0"
 hg mv afile adifferentfile
 hg commit -m "1.3m" -d "1000000 0"
 hg update -C 3
 hg mv afile anotherfile
 hg commit -m "0.3m" -d "1000000 0"
 hg verify
 cd ..
 hg init empty
 
 echo "====== Bundle --all"
 hg -R test bundle --all all.hg
+
 echo "====== Bundle test to full.hg"
 hg -R test bundle full.hg empty
 echo "====== Unbundle full.hg in test"
 hg -R test unbundle full.hg
 echo "====== Verify empty"
 hg -R empty heads
 hg -R empty verify
 
 echo "====== Pull full.hg into test (using --cwd)"
 hg --cwd test pull ../full.hg
 echo "====== Pull full.hg into empty (using --cwd)"
 hg --cwd empty pull ../full.hg
 echo "====== Rollback empty"
 hg -R empty rollback
 echo "====== Pull full.hg into empty again (using --cwd)"
 hg --cwd empty pull ../full.hg
 
 echo "====== Pull full.hg into test (using -R)"
 hg -R test pull full.hg
 echo "====== Pull full.hg into empty (using -R)"
 hg -R empty pull full.hg
 echo "====== Rollback empty"
 hg -R empty rollback
 echo "====== Pull full.hg into empty again (using -R)"
 hg -R empty pull full.hg
 
 echo "====== Log -R full.hg in fresh empty"
 rm -r empty
 hg init empty
 cd empty
 hg -R bundle://../full.hg log
 
 echo "====== Pull ../full.hg into empty (with hook)"
 echo '[hooks]' >> .hg/hgrc
 echo 'changegroup = python ../printenv.py changegroup' >> .hg/hgrc
 #doesn't work (yet ?)
 #hg -R bundle://../full.hg verify
 hg pull bundle://../full.hg
 echo "====== Rollback empty"
 hg rollback
 cd ..
 echo "====== Log -R bundle:empty+full.hg"
 hg -R bundle:empty+full.hg log --template="{rev} "
 echo ""
 echo "====== Pull full.hg into empty again (using -R; with hook)"
 hg -R empty pull full.hg
 
 echo "====== Create partial clones"
 rm -r empty
 hg init empty
 hg clone -r 3 test partial
 hg clone partial partial2
 cd partial
 echo "====== Log -R full.hg in partial"
 hg -R bundle://../full.hg log
 echo "====== Incoming full.hg in partial"
 hg incoming bundle://../full.hg
 echo "====== Outgoing -R full.hg vs partial2 in partial"
 hg -R bundle://../full.hg outgoing ../partial2
 echo "====== Outgoing -R does-not-exist.hg vs partial2 in partial"
 hg -R bundle://../does-not-exist.hg outgoing ../partial2
 cd ..
 
 echo "====== Direct clone from bundle (all-history)"
 hg clone full.hg full-clone
 hg -R full-clone heads
 rm -r full-clone
 
 # test for http://www.selenic.com/mercurial/bts/issue216
 echo "====== Unbundle incremental bundles into fresh empty in one go"
 rm -r empty
 hg init empty
 hg -R test bundle --base null -r 0 ../0.hg
 hg -R test bundle --base 0    -r 1 ../1.hg
 hg -R empty unbundle -u ../0.hg ../1.hg
 
 # test for 540d1059c802
 echo "====== test for 540d1059c802"
 hg init orig
 cd orig
 echo foo > foo
 hg add foo
 hg ci -m 'add foo' -d '0 0'
 
 hg clone . ../copy
 hg tag -d '0 0' foo
 
 cd ../copy
 echo >> foo
 hg ci -m 'change foo' -d '0 0'
 hg bundle ../bundle.hg ../orig
 
 cd ../orig
 hg incoming ../bundle.hg
 cd ..
 
 # test for http://www.selenic.com/mercurial/bts/issue1144
 echo "===== test that verify bundle does not traceback"
 # partial history bundle, fails w/ unkown parent
 hg -R bundle.hg verify
 # full history bundle, refuses to verify non-local repo
 hg -R all.hg verify
 # but, regular verify must continue to work
 hg -R orig verify
 
+echo "====== diff against bundle"
+hg init b
+cd b
+hg -R ../all.hg diff -r tip
+cd ..
 
+

tests/test-bundle.out

@@ -1,319 +1,328 b''
 ====== Setting up test
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 created new head
 1 files updated, 0 files merged, 2 files removed, 0 files unresolved
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 4 files, 9 changesets, 7 total revisions
 ====== Bundle --all
 9 changesets found
 ====== Bundle test to full.hg
 searching for changes
 9 changesets found
 ====== Unbundle full.hg in test
 adding changesets
 adding manifests
 adding file changes
 added 0 changesets with 0 changes to 4 files
 (run 'hg update' to get a working copy)
 ====== Verify empty
 changeset:   -1:000000000000
 tag:         tip
 user:        
 date:        Thu Jan 01 00:00:00 1970 +0000
 
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 0 files, 0 changesets, 0 total revisions
 ====== Pull full.hg into test (using --cwd)
 pulling from ../full.hg
 searching for changes
 no changes found
 ====== Pull full.hg into empty (using --cwd)
 pulling from ../full.hg
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 9 changesets with 7 changes to 4 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 ====== Rollback empty
 rolling back last transaction
 ====== Pull full.hg into empty again (using --cwd)
 pulling from ../full.hg
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 9 changesets with 7 changes to 4 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 ====== Pull full.hg into test (using -R)
 pulling from full.hg
 searching for changes
 no changes found
 ====== Pull full.hg into empty (using -R)
 pulling from full.hg
 searching for changes
 no changes found
 ====== Rollback empty
 rolling back last transaction
 ====== Pull full.hg into empty again (using -R)
 pulling from full.hg
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 9 changesets with 7 changes to 4 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 ====== Log -R full.hg in fresh empty
 changeset:   8:836ac62537ab
 tag:         tip
 parent:      3:ac69c658229d
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.3m
 
 changeset:   7:80fe151401c2
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3m
 
 changeset:   6:1e3f6b843bd6
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3
 
 changeset:   5:024e4e7df376
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.2
 
 changeset:   4:5f4f3ceb285e
 parent:      0:5649c9d34dd8
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.1
 
 changeset:   3:ac69c658229d
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.3
 
 changeset:   2:d62976ca1e50
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.2
 
 changeset:   1:10b2180f755b
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.1
 
 changeset:   0:5649c9d34dd8
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.0
 
 ====== Pull ../full.hg into empty (with hook)
 changegroup hook: HG_NODE=5649c9d34dd87d0ecb5fd39672128376e83b22e1 HG_SOURCE=pull HG_URL=bundle:../full.hg 
 pulling from bundle://../full.hg
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 9 changesets with 7 changes to 4 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 ====== Rollback empty
 rolling back last transaction
 ====== Log -R bundle:empty+full.hg
 8 7 6 5 4 3 2 1 0 
 ====== Pull full.hg into empty again (using -R; with hook)
 changegroup hook: HG_NODE=5649c9d34dd87d0ecb5fd39672128376e83b22e1 HG_SOURCE=pull HG_URL=bundle:empty+full.hg 
 pulling from full.hg
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 9 changesets with 7 changes to 4 files (+1 heads)
 (run 'hg heads' to see heads, 'hg merge' to merge)
 ====== Create partial clones
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 4 changesets with 4 changes to 1 files
 updating working directory
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 updating working directory
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 ====== Log -R full.hg in partial
 changeset:   8:836ac62537ab
 tag:         tip
 parent:      3:ac69c658229d
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.3m
 
 changeset:   7:80fe151401c2
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3m
 
 changeset:   6:1e3f6b843bd6
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3
 
 changeset:   5:024e4e7df376
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.2
 
 changeset:   4:5f4f3ceb285e
 parent:      0:5649c9d34dd8
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.1
 
 changeset:   3:ac69c658229d
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.3
 
 changeset:   2:d62976ca1e50
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.2
 
 changeset:   1:10b2180f755b
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.1
 
 changeset:   0:5649c9d34dd8
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.0
 
 ====== Incoming full.hg in partial
 comparing with bundle://../full.hg
 searching for changes
 changeset:   4:5f4f3ceb285e
 parent:      0:5649c9d34dd8
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.1
 
 changeset:   5:024e4e7df376
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.2
 
 changeset:   6:1e3f6b843bd6
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3
 
 changeset:   7:80fe151401c2
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3m
 
 changeset:   8:836ac62537ab
 tag:         tip
 parent:      3:ac69c658229d
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.3m
 
 ====== Outgoing -R full.hg vs partial2 in partial
 comparing with ../partial2
 searching for changes
 changeset:   4:5f4f3ceb285e
 parent:      0:5649c9d34dd8
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.1
 
 changeset:   5:024e4e7df376
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.2
 
 changeset:   6:1e3f6b843bd6
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3
 
 changeset:   7:80fe151401c2
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3m
 
 changeset:   8:836ac62537ab
 tag:         tip
 parent:      3:ac69c658229d
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.3m
 
 ====== Outgoing -R does-not-exist.hg vs partial2 in partial
 abort: No such file or directory: ../does-not-exist.hg
 ====== Direct clone from bundle (all-history)
 requesting all changes
 adding changesets
 adding manifests
 adding file changes
 added 9 changesets with 7 changes to 4 files (+1 heads)
 updating working directory
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 changeset:   8:836ac62537ab
 tag:         tip
 parent:      3:ac69c658229d
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     0.3m
 
 changeset:   7:80fe151401c2
 user:        test
 date:        Mon Jan 12 13:46:40 1970 +0000
 summary:     1.3m
 
 ====== Unbundle incremental bundles into fresh empty in one go
 1 changesets found
 1 changesets found
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 adding changesets
 adding manifests
 adding file changes
 added 1 changesets with 1 changes to 1 files
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 ====== test for 540d1059c802
 updating working directory
 1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 searching for changes
 1 changesets found
 comparing with ../bundle.hg
 searching for changes
 changeset:   2:ed1b79f46b9a
 tag:         tip
 parent:      0:bbd179dfa0a7
 user:        test
 date:        Thu Jan 01 00:00:00 1970 +0000
 summary:     change foo
 
 ===== test that verify bundle does not traceback
 abort: 00changelog.i@bbd179dfa0a7: unknown parent!
 abort: cannot verify bundle or remote repos
 checking changesets
 checking manifests
 crosschecking files in changesets and manifests
 checking files
 2 files, 2 changesets, 2 total revisions
+====== diff against bundle
+diff -r 836ac62537ab anotherfile
+--- a/anotherfile	Mon Jan 12 13:46:40 1970 +0000
++++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
+@@ -1,4 +0,0 @@
+-0
+-1
+-2
+-3