git.py
399 lines
| 13.7 KiB
| text/x-python
|
PythonLexer
|
r8250 | # git.py - git support for the convert extension | ||
# | ||||
# Copyright 2005-2009 Matt Mackall <mpm@selenic.com> and others | ||||
# | ||||
# This software may be used and distributed according to the terms of the | ||||
|
r10263 | # GNU General Public License version 2 or any later version. | ||
|
r28365 | from __future__ import absolute_import | ||
|
r4536 | |||
import os | ||||
|
r29205 | |||
from mercurial.i18n import _ | ||||
|
r28365 | from mercurial import ( | ||
config, | ||||
error, | ||||
node as nodemod, | ||||
) | ||||
|
r4536 | |||
|
r28365 | from . import ( | ||
common, | ||||
) | ||||
|
r4536 | |||
|
r17929 | class submodule(object): | ||
def __init__(self, path, node, url): | ||||
self.path = path | ||||
self.node = node | ||||
self.url = url | ||||
def hgsub(self): | ||||
return "%s = [git]%s" % (self.path, self.url) | ||||
def hgsubstate(self): | ||||
return "%s %s" % (self.node, self.path) | ||||
|
r28670 | class convert_git(common.converter_source, common.commandline): | ||
|
r5217 | # Windows does not support GIT_DIR= construct while other systems | ||
# cannot remove environment variable. Just assume none have | ||||
# both issues. | ||||
|
r21630 | |||
|
r28659 | def _gitcmd(self, cmd, *args, **kwargs): | ||
return cmd('--git-dir=%s' % self.path, *args, **kwargs) | ||||
def gitrun0(self, *args, **kwargs): | ||||
return self._gitcmd(self.run0, *args, **kwargs) | ||||
def gitrun(self, *args, **kwargs): | ||||
return self._gitcmd(self.run, *args, **kwargs) | ||||
def gitrunlines0(self, *args, **kwargs): | ||||
return self._gitcmd(self.runlines0, *args, **kwargs) | ||||
def gitrunlines(self, *args, **kwargs): | ||||
return self._gitcmd(self.runlines, *args, **kwargs) | ||||
|
r28662 | def gitpipe(self, *args, **kwargs): | ||
return self._gitcmd(self._run3, *args, **kwargs) | ||||
|
r25748 | def __init__(self, ui, path, revs=None): | ||
super(convert_git, self).__init__(ui, path, revs=revs) | ||||
|
r28670 | common.commandline.__init__(self, ui, 'git') | ||
|
r25748 | |||
|
r29051 | # Pass an absolute path to git to prevent from ever being interpreted | ||
# as a URL | ||||
path = os.path.abspath(path) | ||||
|
r4536 | if os.path.isdir(path + "/.git"): | ||
path += "/.git" | ||||
if not os.path.exists(path + "/objects"): | ||||
|
r28365 | raise common.NoRepo(_("%s does not look like a Git repository") % | ||
path) | ||||
|
r5497 | |||
|
r22512 | # The default value (50) is based on the default for 'git diff'. | ||
similarity = ui.configint('convert', 'git.similarity', default=50) | ||||
|
r22470 | if similarity < 0 or similarity > 100: | ||
|
r26587 | raise error.Abort(_('similarity must be between 0 and 100')) | ||
|
r22470 | if similarity > 0: | ||
|
r28660 | self.simopt = ['-C%d%%' % similarity] | ||
|
r22471 | findcopiesharder = ui.configbool('convert', 'git.findcopiesharder', | ||
False) | ||||
if findcopiesharder: | ||||
|
r28660 | self.simopt.append('--find-copies-harder') | ||
|
r22470 | else: | ||
|
r28660 | self.simopt = [] | ||
|
r22470 | |||
|
r28365 | common.checktool('git', 'git') | ||
|
r5497 | |||
|
r4536 | self.path = path | ||
|
r17929 | self.submodules = [] | ||
|
r4536 | |||
|
r28662 | self.catfilepipe = self.gitpipe('cat-file', '--batch') | ||
|
r21630 | |||
def after(self): | ||||
for f in self.catfilepipe: | ||||
f.close() | ||||
|
r4536 | def getheads(self): | ||
|
r25748 | if not self.revs: | ||
|
r28660 | output, status = self.gitrun('rev-parse', '--branches', '--remotes') | ||
heads = output.splitlines() | ||||
if status: | ||||
|
r26587 | raise error.Abort(_('cannot retrieve git heads')) | ||
|
r4768 | else: | ||
|
r25749 | heads = [] | ||
for rev in self.revs: | ||||
|
r28660 | rawhead, ret = self.gitrun('rev-parse', '--verify', rev) | ||
|
r25749 | heads.append(rawhead[:-1]) | ||
if ret: | ||||
|
r26587 | raise error.Abort(_('cannot retrieve git head "%s"') % rev) | ||
|
r10986 | return heads | ||
|
r4536 | |||
def catfile(self, rev, type): | ||||
|
r28365 | if rev == nodemod.nullhex: | ||
|
r16687 | raise IOError | ||
|
r21630 | self.catfilepipe[0].write(rev+'\n') | ||
self.catfilepipe[0].flush() | ||||
info = self.catfilepipe[1].readline().split() | ||||
if info[1] != type: | ||||
|
r26587 | raise error.Abort(_('cannot read %r object at %s') % (type, rev)) | ||
|
r21630 | size = int(info[2]) | ||
data = self.catfilepipe[1].read(size) | ||||
if len(data) < size: | ||||
|
r26587 | raise error.Abort(_('cannot read %r object at %s: unexpected size') | ||
|
r21958 | % (type, rev)) | ||
|
r21630 | # read the trailing newline | ||
self.catfilepipe[1].read(1) | ||||
|
r10986 | return data | ||
|
r4536 | |||
def getfile(self, name, rev): | ||||
|
r28365 | if rev == nodemod.nullhex: | ||
|
r22296 | return None, None | ||
|
r17929 | if name == '.hgsub': | ||
data = '\n'.join([m.hgsub() for m in self.submoditer()]) | ||||
mode = '' | ||||
elif name == '.hgsubstate': | ||||
data = '\n'.join([m.hgsubstate() for m in self.submoditer()]) | ||||
mode = '' | ||||
else: | ||||
data = self.catfile(rev, "blob") | ||||
mode = self.modecache[(name, rev)] | ||||
|
r11134 | return data, mode | ||
|
r4536 | |||
|
r17929 | def submoditer(self): | ||
|
r28365 | null = nodemod.nullhex | ||
|
r17929 | for m in sorted(self.submodules, key=lambda p: p.path): | ||
if m.node != null: | ||||
yield m | ||||
def parsegitmodules(self, content): | ||||
"""Parse the formatted .gitmodules file, example file format: | ||||
[submodule "sub"]\n | ||||
\tpath = sub\n | ||||
\turl = git://giturl\n | ||||
""" | ||||
self.submodules = [] | ||||
c = config.config() | ||||
|
r25698 | # Each item in .gitmodules starts with whitespace that cant be parsed | ||
c.parse('.gitmodules', '\n'.join(line.strip() for line in | ||||
content.split('\n'))) | ||||
|
r17929 | for sec in c.sections(): | ||
s = c[sec] | ||||
if 'url' in s and 'path' in s: | ||||
self.submodules.append(submodule(s['path'], '', s['url'])) | ||||
def retrievegitmodules(self, version): | ||||
|
r28660 | modules, ret = self.gitrun('show', '%s:%s' % (version, '.gitmodules')) | ||
|
r17929 | if ret: | ||
|
r25699 | # This can happen if a file is in the repo that has permissions | ||
# 160000, but there is no .gitmodules file. | ||||
self.ui.warn(_("warning: cannot read submodules config file in " | ||||
"%s\n") % version) | ||||
return | ||||
try: | ||||
self.parsegitmodules(modules) | ||||
except error.ParseError: | ||||
self.ui.warn(_("warning: unable to parse .gitmodules in %s\n") | ||||
% version) | ||||
return | ||||
|
r17929 | for m in self.submodules: | ||
|
r28660 | node, ret = self.gitrun('rev-parse', '%s:%s' % (version, m.path)) | ||
|
r17929 | if ret: | ||
continue | ||||
m.node = node.strip() | ||||
|
r22300 | def getchanges(self, version, full): | ||
if full: | ||||
|
r26779 | raise error.Abort(_("convert from git does not support --full")) | ||
|
r4536 | self.modecache = {} | ||
|
r28660 | cmd = ['diff-tree','-z', '--root', '-m', '-r'] + self.simopt + [version] | ||
output, status = self.gitrun(*cmd) | ||||
if status: | ||||
raise error.Abort(_('cannot read changes in %s') % version) | ||||
|
r4536 | changes = [] | ||
|
r22470 | copies = {} | ||
|
r8456 | seen = set() | ||
|
r7242 | entry = None | ||
|
r22469 | subexists = [False] | ||
subdeleted = [False] | ||||
|
r28660 | difftree = output.split('\x00') | ||
|
r22467 | lcount = len(difftree) | ||
i = 0 | ||||
|
r22469 | |||
|
r26077 | skipsubmodules = self.ui.configbool('convert', 'git.skipsubmodules', | ||
False) | ||||
|
r22470 | def add(entry, f, isdest): | ||
|
r22469 | seen.add(f) | ||
h = entry[3] | ||||
p = (entry[1] == "100755") | ||||
s = (entry[1] == "120000") | ||||
|
r22470 | renamesource = (not isdest and entry[4][0] == 'R') | ||
|
r22469 | |||
if f == '.gitmodules': | ||||
|
r26077 | if skipsubmodules: | ||
return | ||||
|
r22469 | subexists[0] = True | ||
|
r22470 | if entry[4] == 'D' or renamesource: | ||
|
r22469 | subdeleted[0] = True | ||
|
r28365 | changes.append(('.hgsub', nodemod.nullhex)) | ||
|
r22469 | else: | ||
changes.append(('.hgsub', '')) | ||||
elif entry[1] == '160000' or entry[0] == ':160000': | ||||
|
r26077 | if not skipsubmodules: | ||
subexists[0] = True | ||||
|
r22469 | else: | ||
|
r22470 | if renamesource: | ||
|
r28365 | h = nodemod.nullhex | ||
|
r22469 | self.modecache[(f, h)] = (p and "x") or (s and "l") or "" | ||
changes.append((f, h)) | ||||
|
r22467 | while i < lcount: | ||
l = difftree[i] | ||||
i += 1 | ||||
|
r7242 | if not entry: | ||
if not l.startswith(':'): | ||||
continue | ||||
|
r22468 | entry = l.split() | ||
|
r5335 | continue | ||
|
r7242 | f = l | ||
|
r25997 | if entry[4][0] == 'C': | ||
copysrc = f | ||||
copydest = difftree[i] | ||||
i += 1 | ||||
f = copydest | ||||
copies[copydest] = copysrc | ||||
|
r7242 | if f not in seen: | ||
|
r22470 | add(entry, f, False) | ||
# A file can be copied multiple times, or modified and copied | ||||
# simultaneously. So f can be repeated even if fdest isn't. | ||||
|
r25997 | if entry[4][0] == 'R': | ||
# rename: next line is the destination | ||||
|
r22470 | fdest = difftree[i] | ||
i += 1 | ||||
if fdest not in seen: | ||||
add(entry, fdest, True) | ||||
# .gitmodules isn't imported at all, so it being copied to | ||||
# and fro doesn't really make sense | ||||
if f != '.gitmodules' and fdest != '.gitmodules': | ||||
copies[fdest] = f | ||||
|
r7242 | entry = None | ||
|
r17929 | |||
|
r22469 | if subexists[0]: | ||
if subdeleted[0]: | ||||
|
r28365 | changes.append(('.hgsubstate', nodemod.nullhex)) | ||
|
r21868 | else: | ||
self.retrievegitmodules(version) | ||||
changes.append(('.hgsubstate', '')) | ||||
|
r24395 | return (changes, copies, set()) | ||
|
r4536 | |||
def getcommit(self, version): | ||||
c = self.catfile(version, "commit") # read the commit hash | ||||
end = c.find("\n\n") | ||||
|
r10282 | message = c[end + 2:] | ||
|
r4759 | message = self.recode(message) | ||
|
r4536 | l = c[:end].splitlines() | ||
parents = [] | ||||
|
r8271 | author = committer = None | ||
|
r4536 | for e in l[1:]: | ||
n, v = e.split(" ", 1) | ||||
if n == "author": | ||||
p = v.split() | ||||
tm, tz = p[-2:] | ||||
author = " ".join(p[:-2]) | ||||
if author[0] == "<": author = author[1:-1] | ||||
|
r4759 | author = self.recode(author) | ||
|
r4536 | if n == "committer": | ||
p = v.split() | ||||
tm, tz = p[-2:] | ||||
committer = " ".join(p[:-2]) | ||||
if committer[0] == "<": committer = committer[1:-1] | ||||
|
r4759 | committer = self.recode(committer) | ||
|
r10282 | if n == "parent": | ||
parents.append(v) | ||||
|
r4536 | |||
|
r8271 | if committer and committer != author: | ||
message += "\ncommitter: %s\n" % committer | ||||
|
r4536 | tzs, tzh, tzm = tz[-5:-4] + "1", tz[-4:-2], tz[-2:] | ||
tz = -int(tzs) * (int(tzh) * 3600 + int(tzm)) | ||||
date = tm + " " + str(tz) | ||||
|
r28365 | c = common.commit(parents=parents, date=date, author=author, | ||
desc=message, | ||||
rev=version) | ||||
|
r4536 | return c | ||
|
r22413 | def numcommits(self): | ||
|
r28660 | output, ret = self.gitrunlines('rev-list', '--all') | ||
if ret: | ||||
raise error.Abort(_('cannot retrieve number of commits in %s') \ | ||||
% self.path) | ||||
return len(output) | ||||
|
r22413 | |||
|
r4536 | def gettags(self): | ||
tags = {} | ||||
|
r16259 | alltags = {} | ||
|
r28660 | output, status = self.gitrunlines('ls-remote', '--tags', self.path) | ||
if status: | ||||
raise error.Abort(_('cannot read tags from %s') % self.path) | ||||
|
r4536 | prefix = 'refs/tags/' | ||
|
r16259 | |||
# Build complete list of tags, both annotated and bare ones | ||||
|
r28660 | for line in output: | ||
|
r4536 | line = line.strip() | ||
|
r18572 | if line.startswith("error:") or line.startswith("fatal:"): | ||
|
r26587 | raise error.Abort(_('cannot read tags from %s') % self.path) | ||
|
r4536 | node, tag = line.split(None, 1) | ||
if not tag.startswith(prefix): | ||||
continue | ||||
|
r16259 | alltags[tag[len(prefix):]] = node | ||
|
r4536 | |||
|
r16259 | # Filter out tag objects for annotated tag refs | ||
for tag in alltags: | ||||
if tag.endswith('^{}'): | ||||
tags[tag[:-3]] = alltags[tag] | ||||
else: | ||||
if tag + '^{}' in alltags: | ||||
continue | ||||
else: | ||||
tags[tag] = alltags[tag] | ||||
|
r4536 | return tags | ||
|
r5380 | |||
def getchangedfiles(self, version, i): | ||||
changes = [] | ||||
if i is None: | ||||
|
r28660 | output, status = self.gitrunlines('diff-tree', '--root', '-m', | ||
'-r', version) | ||||
if status: | ||||
raise error.Abort(_('cannot read changes in %s') % version) | ||||
for l in output: | ||||
|
r5380 | if "\t" not in l: | ||
continue | ||||
m, f = l[:-1].split("\t") | ||||
changes.append(f) | ||||
else: | ||||
|
r28660 | output, status = self.gitrunlines('diff-tree', '--name-only', | ||
'--root', '-r', version, | ||||
'%s^%s' % (version, i + 1), '--') | ||||
|
r28816 | if status: | ||
raise error.Abort(_('cannot read changes in %s') % version) | ||||
|
r28660 | changes = [f.rstrip('\n') for f in output] | ||
|
r5380 | |||
return changes | ||||
|
r13756 | |||
def getbookmarks(self): | ||||
bookmarks = {} | ||||
|
r25905 | # Handle local and remote branches | ||
remoteprefix = self.ui.config('convert', 'git.remoteprefix', 'remote') | ||||
reftypes = [ | ||||
# (git prefix, hg prefix) | ||||
('refs/remotes/origin/', remoteprefix + '/'), | ||||
('refs/heads/', '') | ||||
] | ||||
|
r13756 | |||
|
r25905 | exclude = set([ | ||
'refs/remotes/origin/HEAD', | ||||
]) | ||||
|
r13756 | |||
|
r25905 | try: | ||
|
r28660 | output, status = self.gitrunlines('show-ref') | ||
for line in output: | ||||
|
r25905 | line = line.strip() | ||
rev, name = line.split(None, 1) | ||||
# Process each type of branch | ||||
for gitprefix, hgprefix in reftypes: | ||||
if not name.startswith(gitprefix) or name in exclude: | ||||
|
r13756 | continue | ||
|
r25905 | name = '%s%s' % (hgprefix, name[len(gitprefix):]) | ||
|
r13756 | bookmarks[name] = rev | ||
|
r25905 | except Exception: | ||
pass | ||||
|
r13756 | |||
return bookmarks | ||||
|
r19121 | |||
|
r20373 | def checkrevformat(self, revstr, mapname='splicemap'): | ||
|
r19121 | """ git revision string is a 40 byte hex """ | ||
|
r20373 | self.checkhexformat(revstr, mapname) | ||