2011-05-24 22:16:45 +04:00
|
|
|
# overlay classes for repositories
|
|
|
|
# unifies access to unimported git objects and committed hg objects
|
|
|
|
# designed to support incoming
|
|
|
|
#
|
|
|
|
# incomplete, implemented on demand
|
|
|
|
|
2013-10-06 01:40:50 +04:00
|
|
|
from mercurial import ancestor
|
|
|
|
from mercurial import manifest
|
2011-05-24 22:16:45 +04:00
|
|
|
from mercurial import context
|
|
|
|
from mercurial.node import bin, hex, nullid
|
2013-10-06 01:40:50 +04:00
|
|
|
from mercurial import localrepo
|
2011-05-24 22:16:45 +04:00
|
|
|
|
2013-12-13 21:54:39 +04:00
|
|
|
def _maybehex(n):
|
|
|
|
if len(n) == 20:
|
|
|
|
return hex(n)
|
|
|
|
return n
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
class overlaymanifest(object):
|
|
|
|
def __init__(self, repo, sha):
|
|
|
|
self.repo = repo
|
|
|
|
self.tree = repo.handler.git.get_object(sha)
|
|
|
|
self._map = None
|
|
|
|
self._flagmap = None
|
|
|
|
|
2012-07-27 03:59:19 +04:00
|
|
|
def withflags(self):
|
|
|
|
self.load()
|
|
|
|
return set([path for path, flag in self._flagmap.iteritems()
|
|
|
|
if flag & 020100])
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
def copy(self):
|
|
|
|
return overlaymanifest(self.repo, self.tree.id)
|
|
|
|
|
|
|
|
def keys(self):
|
|
|
|
self.load()
|
|
|
|
return self._map.keys()
|
|
|
|
|
2013-10-06 01:40:50 +04:00
|
|
|
def iterkeys(self):
|
|
|
|
return iter(self.keys())
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
def flags(self, path):
|
|
|
|
self.load()
|
|
|
|
|
|
|
|
def hgflag(gitflag):
|
|
|
|
if gitflag & 0100:
|
|
|
|
return 'x'
|
|
|
|
elif gitflag & 020000:
|
|
|
|
return 'l'
|
|
|
|
else:
|
|
|
|
return ''
|
|
|
|
|
|
|
|
return hgflag(self._flagmap[path])
|
|
|
|
|
|
|
|
def load(self):
|
|
|
|
if self._map is not None:
|
|
|
|
return
|
|
|
|
|
|
|
|
self._map = {}
|
|
|
|
self._flagmap = {}
|
|
|
|
|
|
|
|
def addtree(tree, dirname):
|
2011-09-09 22:44:58 +04:00
|
|
|
for entry in tree.iteritems():
|
|
|
|
if entry.mode & 040000:
|
2011-05-24 22:16:45 +04:00
|
|
|
# expand directory
|
2011-09-09 22:44:58 +04:00
|
|
|
subtree = self.repo.handler.git.get_object(entry.sha)
|
|
|
|
addtree(subtree, dirname + entry.path + '/')
|
2011-05-24 22:16:45 +04:00
|
|
|
else:
|
2011-09-09 22:44:58 +04:00
|
|
|
path = dirname + entry.path
|
|
|
|
self._map[path] = bin(entry.sha)
|
|
|
|
self._flagmap[path] = entry.mode
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
addtree(self.tree, '')
|
|
|
|
|
2013-04-03 23:37:13 +04:00
|
|
|
def iteritems(self):
|
|
|
|
self.load()
|
|
|
|
return self._map.iteritems()
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
def __iter__(self):
|
|
|
|
self.load()
|
|
|
|
return self._map.__iter__()
|
|
|
|
|
|
|
|
def __getitem__(self, path):
|
|
|
|
self.load()
|
|
|
|
return self._map[path]
|
|
|
|
|
|
|
|
def __delitem__(self, path):
|
|
|
|
del self._map[path]
|
|
|
|
|
|
|
|
class overlayfilectx(object):
|
|
|
|
def __init__(self, repo, path, fileid=None):
|
|
|
|
self.repo = repo
|
|
|
|
self._path = path
|
|
|
|
self.fileid = fileid
|
|
|
|
|
|
|
|
# this is a hack to skip copy detection
|
|
|
|
def ancestors(self):
|
|
|
|
return [self, self]
|
|
|
|
|
2013-10-06 01:40:50 +04:00
|
|
|
def filenode(self):
|
|
|
|
return nullid
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
def rev(self):
|
|
|
|
return -1
|
|
|
|
|
|
|
|
def path(self):
|
|
|
|
return self._path
|
|
|
|
|
|
|
|
def filelog(self):
|
|
|
|
return self.fileid
|
|
|
|
|
|
|
|
def data(self):
|
2013-12-13 21:54:39 +04:00
|
|
|
blob = self.repo.handler.git.get_object(_maybehex(self.fileid))
|
2011-05-24 22:16:45 +04:00
|
|
|
return blob.data
|
|
|
|
|
|
|
|
class overlaychangectx(context.changectx):
|
|
|
|
def __init__(self, repo, sha):
|
|
|
|
self.repo = repo
|
2013-10-06 01:40:50 +04:00
|
|
|
if not isinstance(sha, basestring):
|
|
|
|
sha = sha.hex()
|
2013-12-13 21:54:39 +04:00
|
|
|
self.commit = repo.handler.git.get_object(_maybehex(sha))
|
2013-10-06 01:40:50 +04:00
|
|
|
self._overlay = getattr(repo, 'gitoverlay', repo)
|
|
|
|
self._rev = self._overlay.rev(bin(self.commit.id))
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
def node(self):
|
|
|
|
return bin(self.commit.id)
|
|
|
|
|
|
|
|
def rev(self):
|
2013-10-06 01:40:50 +04:00
|
|
|
return self._rev
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
def date(self):
|
|
|
|
return self.commit.author_time, self.commit.author_timezone
|
|
|
|
|
|
|
|
def branch(self):
|
|
|
|
return 'default'
|
|
|
|
|
|
|
|
def user(self):
|
|
|
|
return self.commit.author
|
|
|
|
|
|
|
|
def files(self):
|
|
|
|
return []
|
|
|
|
|
|
|
|
def extra(self):
|
|
|
|
return {}
|
|
|
|
|
|
|
|
def description(self):
|
|
|
|
return self.commit.message
|
|
|
|
|
|
|
|
def parents(self):
|
|
|
|
return [overlaychangectx(self.repo, sha) for sha in self.commit.parents]
|
|
|
|
|
|
|
|
def manifestnode(self):
|
|
|
|
return bin(self.commit.tree)
|
|
|
|
|
|
|
|
def hex(self):
|
|
|
|
return self.commit.id
|
|
|
|
|
|
|
|
def tags(self):
|
|
|
|
return []
|
|
|
|
|
|
|
|
def bookmarks(self):
|
|
|
|
return []
|
|
|
|
|
|
|
|
def manifest(self):
|
2013-10-06 01:40:50 +04:00
|
|
|
return overlaymanifest(self._overlay, self.commit.tree)
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
def filectx(self, path, filelog=None):
|
|
|
|
mf = self.manifest()
|
2013-10-06 01:40:50 +04:00
|
|
|
return overlayfilectx(self._overlay, path, mf[path])
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
def flags(self, path):
|
|
|
|
mf = self.manifest()
|
|
|
|
return mf.flags(path)
|
|
|
|
|
|
|
|
def __nonzero__(self):
|
|
|
|
return True
|
|
|
|
|
overlaychangectx: fix compatibility with mercurial 2.4-rc (no attribute _repo)
This isn't a real implementation of phases support. Rather, it's just enough
to avoid the traceback.
Traceback (most recent call last):
File "/usr/local/share/python/hg", line 38, in <module>
mercurial.dispatch.run()
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 28, in run
sys.exit((dispatch(request(sys.argv[1:])) or 0) & 255)
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 65, in dispatch
return _runcatch(req)
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 88, in _runcatch
return _dispatch(req)
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 741, in _dispatch
cmdpats, cmdoptions)
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 514, in runcommand
ret = _runcommand(ui, options, cmd, d)
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 831, in _runcommand
return checkargs()
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 802, in checkargs
return cmdfunc()
File "/usr/local/lib/python2.7/site-packages/mercurial/dispatch.py", line 738, in <lambda>
d = lambda: util.checksignature(func)(ui, *args, **cmdoptions)
File "/usr/local/lib/python2.7/site-packages/mercurial/util.py", line 472, in check
return func(*args, **kwargs)
File "/usr/local/lib/python2.7/site-packages/mercurial/commands.py", line 3942, in incoming
return hg.incoming(ui, repo, source, opts)
File "/usr/local/lib/python2.7/site-packages/mercurial/hg.py", line 525, in incoming
return _incoming(display, subreporecurse, ui, repo, source, opts)
File "/usr/local/lib/python2.7/site-packages/mercurial/hg.py", line 494, in _incoming
displaychlist(other, chlist, displayer)
File "/usr/local/lib/python2.7/site-packages/mercurial/hg.py", line 524, in display
displayer.show(other[n])
File "/usr/local/lib/python2.7/site-packages/mercurial/cmdutil.py", line 670, in show
self._show(ctx, copies, matchfn, props)
File "/usr/local/lib/python2.7/site-packages/mercurial/cmdutil.py", line 691, in _show
label='log.changeset changeset.%s' % ctx.phasestr())
File "/usr/local/lib/python2.7/site-packages/mercurial/context.py", line 203, in phasestr
return phases.phasenames[self.phase()]
File "/usr/local/lib/python2.7/site-packages/mercurial/context.py", line 201, in phase
return self._repo._phasecache.phase(self._repo, self._rev)
AttributeError: 'overlaychangectx' object has no attribute '_repo'
2012-10-30 04:16:00 +04:00
|
|
|
def phase(self):
|
|
|
|
try:
|
|
|
|
from mercurial import phases
|
|
|
|
return phases.draft
|
|
|
|
except ImportError:
|
|
|
|
return 1
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
class overlayrevlog(object):
|
|
|
|
def __init__(self, repo, base):
|
|
|
|
self.repo = repo
|
|
|
|
self.base = base
|
|
|
|
|
|
|
|
def parents(self, n):
|
|
|
|
gitrev = self.repo.revmap.get(n)
|
|
|
|
if not gitrev:
|
|
|
|
# we've reached a revision we have
|
|
|
|
return self.base.parents(n)
|
2013-12-13 21:54:39 +04:00
|
|
|
commit = self.repo.handler.git.get_object(_maybehex(n))
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
def gitorhg(n):
|
|
|
|
hn = self.repo.handler.map_hg_get(hex(n))
|
|
|
|
if hn is not None:
|
|
|
|
return bin(hn)
|
|
|
|
return n
|
|
|
|
|
|
|
|
# currently ignores the octopus
|
|
|
|
p1 = gitorhg(bin(commit.parents[0]))
|
|
|
|
if len(commit.parents) > 1:
|
|
|
|
p2 = gitorhg(bin(commit.parents[1]))
|
|
|
|
else:
|
|
|
|
p2 = nullid
|
|
|
|
|
|
|
|
return [p1, p2]
|
|
|
|
|
2013-10-06 01:40:50 +04:00
|
|
|
def ancestor(self, a, b):
|
|
|
|
anode = self.repo.nodemap.get(a)
|
|
|
|
bnode = self.repo.nodemap.get(b)
|
|
|
|
if anode is None and bnode is None:
|
|
|
|
return self.base.ancestor(a, b)
|
|
|
|
ancs = ancestor.ancestors(self.parentrevs, a, b)
|
|
|
|
if ancs:
|
|
|
|
return min(map(self.node, ancs))
|
|
|
|
return nullid
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
def parentrevs(self, rev):
|
|
|
|
return [self.rev(p) for p in self.parents(self.node(rev))]
|
|
|
|
|
|
|
|
def node(self, rev):
|
|
|
|
gitnode = self.repo.nodemap.get(rev)
|
|
|
|
if gitnode is None:
|
|
|
|
return self.base.node(rev)
|
|
|
|
return gitnode
|
|
|
|
|
|
|
|
def rev(self, n):
|
|
|
|
gitrev = self.repo.revmap.get(n)
|
|
|
|
if gitrev is None:
|
|
|
|
return self.base.rev(n)
|
|
|
|
return gitrev
|
|
|
|
|
|
|
|
def nodesbetween(self, nodelist, revs):
|
|
|
|
# this is called by pre-1.9 incoming with the nodelist we returned from
|
|
|
|
# getremotechanges. Just return it back.
|
|
|
|
return [nodelist]
|
|
|
|
|
|
|
|
def __len__(self):
|
|
|
|
return len(self.repo.handler.repo) + len(self.repo.revmap)
|
|
|
|
|
2013-10-06 01:40:50 +04:00
|
|
|
class overlaymanifestlog(overlayrevlog):
|
|
|
|
def read(self, sha):
|
|
|
|
if sha == nullid:
|
|
|
|
return manifest.manifestdict()
|
|
|
|
return overlaymanifest(self.repo, sha)
|
|
|
|
|
|
|
|
class overlaychangelog(overlayrevlog):
|
|
|
|
def read(self, sha):
|
|
|
|
if isinstance(sha, int):
|
|
|
|
sha = self.node(sha)
|
|
|
|
if sha == nullid:
|
|
|
|
return (nullid, "", (0, 0), [], "", {})
|
|
|
|
return overlaychangectx(self.repo, sha)
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
class overlayrepo(object):
|
|
|
|
def __init__(self, handler, commits, refs):
|
|
|
|
self.handler = handler
|
|
|
|
|
2013-10-06 01:40:50 +04:00
|
|
|
self.changelog = overlaychangelog(self, handler.repo.changelog)
|
|
|
|
self.manifest = overlaymanifestlog(self, handler.repo.manifest)
|
2011-05-24 22:16:45 +04:00
|
|
|
|
|
|
|
# for incoming -p
|
|
|
|
self.root = handler.repo.root
|
|
|
|
self.getcwd = handler.repo.getcwd
|
2013-10-06 01:40:50 +04:00
|
|
|
# self.status = handler.repo.status
|
2011-05-24 22:16:45 +04:00
|
|
|
self.ui = handler.repo.ui
|
|
|
|
|
|
|
|
self.revmap = None
|
|
|
|
self.nodemap = None
|
|
|
|
self.refmap = None
|
|
|
|
self.tagmap = None
|
|
|
|
|
|
|
|
self._makemaps(commits, refs)
|
|
|
|
|
|
|
|
def __getitem__(self, n):
|
|
|
|
if n not in self.revmap:
|
|
|
|
return self.handler.repo[n]
|
|
|
|
return overlaychangectx(self, n)
|
|
|
|
|
2013-10-06 01:40:50 +04:00
|
|
|
def _handlerhack(self, method, *args, **kwargs):
|
|
|
|
nothing = object()
|
|
|
|
r = self.handler.repo
|
|
|
|
oldhandler = getattr(r, 'handler', nothing)
|
|
|
|
oldoverlay = getattr(r, 'gitoverlay', nothing)
|
|
|
|
r.handler = self.handler
|
|
|
|
r.gitoverlay = self
|
|
|
|
try:
|
|
|
|
return getattr(r, method)(*args, **kwargs)
|
|
|
|
finally:
|
|
|
|
if oldhandler is nothing:
|
|
|
|
del r.handler
|
|
|
|
else:
|
|
|
|
r.handler = oldhandler
|
|
|
|
if oldoverlay is nothing:
|
|
|
|
del r.gitoverlay
|
|
|
|
else:
|
|
|
|
r.gitoverlay = oldoverlay
|
|
|
|
|
|
|
|
def status(self, *args, **kwargs):
|
|
|
|
return self._handlerhack('status', *args, **kwargs)
|
|
|
|
|
2012-10-26 04:49:08 +04:00
|
|
|
def node(self, n):
|
|
|
|
"""Returns an Hg or Git hash for the specified Git hash"""
|
|
|
|
if bin(n) in self.revmap:
|
|
|
|
return n
|
|
|
|
return self.handler.map_hg_get(n)
|
|
|
|
|
2011-05-24 22:16:45 +04:00
|
|
|
def nodebookmarks(self, n):
|
|
|
|
return self.refmap.get(n, [])
|
|
|
|
|
|
|
|
def nodetags(self, n):
|
|
|
|
return self.tagmap.get(n, [])
|
|
|
|
|
|
|
|
def rev(self, n):
|
|
|
|
return self.revmap[n]
|
|
|
|
|
|
|
|
def filectx(self, path, fileid=None):
|
|
|
|
return overlayfilectx(self, path, fileid=fileid)
|
|
|
|
|
|
|
|
def _makemaps(self, commits, refs):
|
|
|
|
baserev = self.handler.repo['tip'].rev()
|
|
|
|
self.revmap = {}
|
|
|
|
self.nodemap = {}
|
|
|
|
for i, n in enumerate(commits):
|
|
|
|
rev = baserev + i + 1
|
|
|
|
self.revmap[n] = rev
|
|
|
|
self.nodemap[rev] = n
|
|
|
|
|
|
|
|
self.refmap = {}
|
|
|
|
self.tagmap = {}
|
|
|
|
for ref in refs:
|
|
|
|
if ref.startswith('refs/heads/'):
|
|
|
|
refname = ref[11:]
|
|
|
|
self.refmap.setdefault(bin(refs[ref]), []).append(refname)
|
|
|
|
elif ref.startswith('refs/tags/'):
|
|
|
|
tagname = ref[10:]
|
|
|
|
self.tagmap.setdefault(bin(refs[ref]), []).append(tagname)
|