git.py
385 lines
| 13.3 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. | ||
|
r4536 | |||
import os | ||||
|
r18570 | import subprocess | ||
|
r17929 | from mercurial import util, config | ||
|
r12144 | from mercurial.node import hex, nullid | ||
|
r10939 | from mercurial.i18n import _ | ||
|
r4536 | |||
|
r5497 | from common import NoRepo, commit, converter_source, checktool | ||
|
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) | ||||
|
r4536 | class convert_git(converter_source): | ||
|
r5217 | # Windows does not support GIT_DIR= construct while other systems | ||
# cannot remove environment variable. Just assume none have | ||||
# both issues. | ||||
|
r14945 | if util.safehasattr(os, 'unsetenv'): | ||
|
r18570 | def gitopen(self, s, err=None): | ||
|
r5217 | prevgitdir = os.environ.get('GIT_DIR') | ||
os.environ['GIT_DIR'] = self.path | ||||
try: | ||||
|
r18570 | if err == subprocess.PIPE: | ||
|
r13756 | (stdin, stdout, stderr) = util.popen3(s) | ||
return stdout | ||||
|
r18570 | elif err == subprocess.STDOUT: | ||
return self.popen_with_stderr(s) | ||||
|
r13756 | else: | ||
return util.popen(s, 'rb') | ||||
|
r5217 | finally: | ||
if prevgitdir is None: | ||||
del os.environ['GIT_DIR'] | ||||
else: | ||||
os.environ['GIT_DIR'] = prevgitdir | ||||
|
r21630 | |||
def gitpipe(self, s): | ||||
prevgitdir = os.environ.get('GIT_DIR') | ||||
os.environ['GIT_DIR'] = self.path | ||||
try: | ||||
return util.popen3(s) | ||||
finally: | ||||
if prevgitdir is None: | ||||
del os.environ['GIT_DIR'] | ||||
else: | ||||
os.environ['GIT_DIR'] = prevgitdir | ||||
|
r5217 | else: | ||
|
r18570 | def gitopen(self, s, err=None): | ||
if err == subprocess.PIPE: | ||||
|
r13756 | (sin, so, se) = util.popen3('GIT_DIR=%s %s' % (self.path, s)) | ||
|
r14177 | return so | ||
|
r18570 | elif err == subprocess.STDOUT: | ||
return self.popen_with_stderr(s) | ||||
|
r13756 | else: | ||
|
r14735 | return util.popen('GIT_DIR=%s %s' % (self.path, s), 'rb') | ||
|
r4767 | |||
|
r21630 | def gitpipe(self, s): | ||
return util.popen3('GIT_DIR=%s %s' % (self.path, s)) | ||||
|
r18570 | def popen_with_stderr(self, s): | ||
p = subprocess.Popen(s, shell=True, bufsize=-1, | ||||
close_fds=util.closefds, | ||||
stdin=subprocess.PIPE, | ||||
stdout=subprocess.PIPE, | ||||
stderr=subprocess.STDOUT, | ||||
universal_newlines=False, | ||||
env=None) | ||||
return p.stdout | ||||
|
r10986 | def gitread(self, s): | ||
fh = self.gitopen(s) | ||||
data = fh.read() | ||||
return data, fh.close() | ||||
|
r4760 | def __init__(self, ui, path, rev=None): | ||
|
r4807 | super(convert_git, self).__init__(ui, path, rev=rev) | ||
|
r4536 | if os.path.isdir(path + "/.git"): | ||
path += "/.git" | ||||
if not os.path.exists(path + "/objects"): | ||||
|
r10939 | raise 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: | ||
raise util.Abort(_('similarity must be between 0 and 100')) | ||||
if similarity > 0: | ||||
|
r23206 | self.simopt = '-C%d%%' % similarity | ||
|
r22471 | findcopiesharder = ui.configbool('convert', 'git.findcopiesharder', | ||
False) | ||||
if findcopiesharder: | ||||
self.simopt += ' --find-copies-harder' | ||||
|
r22470 | else: | ||
self.simopt = '' | ||||
|
r6837 | checktool('git', 'git') | ||
|
r5497 | |||
|
r4536 | self.path = path | ||
|
r17929 | self.submodules = [] | ||
|
r4536 | |||
|
r21630 | self.catfilepipe = self.gitpipe('git cat-file --batch') | ||
def after(self): | ||||
for f in self.catfilepipe: | ||||
f.close() | ||||
|
r4536 | def getheads(self): | ||
|
r4768 | if not self.rev: | ||
|
r10986 | heads, ret = self.gitread('git rev-parse --branches --remotes') | ||
heads = heads.splitlines() | ||||
|
r4768 | else: | ||
|
r10986 | heads, ret = self.gitread("git rev-parse --verify %s" % self.rev) | ||
heads = [heads[:-1]] | ||||
if ret: | ||||
raise util.Abort(_('cannot retrieve git heads')) | ||||
return heads | ||||
|
r4536 | |||
def catfile(self, rev, type): | ||||
|
r12144 | if rev == hex(nullid): | ||
|
r16687 | raise IOError | ||
|
r21630 | self.catfilepipe[0].write(rev+'\n') | ||
self.catfilepipe[0].flush() | ||||
info = self.catfilepipe[1].readline().split() | ||||
if info[1] != type: | ||||
|
r10986 | raise util.Abort(_('cannot read %r object at %s') % (type, rev)) | ||
|
r21630 | size = int(info[2]) | ||
data = self.catfilepipe[1].read(size) | ||||
if len(data) < size: | ||||
|
r21958 | raise util.Abort(_('cannot read %r object at %s: unexpected size') | ||
% (type, rev)) | ||||
|
r21630 | # read the trailing newline | ||
self.catfilepipe[1].read(1) | ||||
|
r10986 | return data | ||
|
r4536 | |||
def getfile(self, name, rev): | ||||
|
r21868 | if rev == hex(nullid): | ||
|
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): | ||
null = hex(nullid) | ||||
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() | ||||
# Each item in .gitmodules starts with \t that cant be parsed | ||||
c.parse('.gitmodules', content.replace('\t','')) | ||||
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): | ||||
modules, ret = self.gitread("git show %s:%s" % (version, '.gitmodules')) | ||||
if ret: | ||||
|
r17930 | raise util.Abort(_('cannot read submodules config file in %s') % | ||
version) | ||||
|
r17929 | self.parsegitmodules(modules) | ||
for m in self.submodules: | ||||
node, ret = self.gitread("git rev-parse %s:%s" % (version, m.path)) | ||||
if ret: | ||||
continue | ||||
m.node = node.strip() | ||||
|
r22300 | def getchanges(self, version, full): | ||
if full: | ||||
raise util.Abort(_("convert from git do not support --full")) | ||||
|
r4536 | self.modecache = {} | ||
|
r22470 | fh = self.gitopen("git diff-tree -z --root -m -r %s %s" % ( | ||
self.simopt, version)) | ||||
|
r4536 | changes = [] | ||
|
r22470 | copies = {} | ||
|
r8456 | seen = set() | ||
|
r7242 | entry = None | ||
|
r22469 | subexists = [False] | ||
subdeleted = [False] | ||||
|
r22467 | difftree = fh.read().split('\x00') | ||
lcount = len(difftree) | ||||
i = 0 | ||||
|
r22469 | |||
|
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': | ||||
subexists[0] = True | ||||
|
r22470 | if entry[4] == 'D' or renamesource: | ||
|
r22469 | subdeleted[0] = True | ||
changes.append(('.hgsub', hex(nullid))) | ||||
else: | ||||
changes.append(('.hgsub', '')) | ||||
elif entry[1] == '160000' or entry[0] == ':160000': | ||||
subexists[0] = True | ||||
else: | ||||
|
r22470 | if renamesource: | ||
h = hex(nullid) | ||||
|
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 | ||
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. | ||||
if entry[4][0] in 'RC': | ||||
# rename or copy: next line is the destination | ||||
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 | ||
|
r10987 | if fh.close(): | ||
raise util.Abort(_('cannot read changes in %s') % version) | ||||
|
r17929 | |||
|
r22469 | if subexists[0]: | ||
if subdeleted[0]: | ||||
|
r21868 | changes.append(('.hgsubstate', hex(nullid))) | ||
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) | ||||
|
r4873 | c = commit(parents=parents, date=date, author=author, desc=message, | ||
rev=version) | ||||
|
r4536 | return c | ||
|
r22413 | def numcommits(self): | ||
return len([None for _ in self.gitopen('git rev-list --all')]) | ||||
|
r4536 | def gettags(self): | ||
tags = {} | ||||
|
r16259 | alltags = {} | ||
|
r18570 | fh = self.gitopen('git ls-remote --tags "%s"' % self.path, | ||
err=subprocess.STDOUT) | ||||
|
r4536 | prefix = 'refs/tags/' | ||
|
r16259 | |||
# Build complete list of tags, both annotated and bare ones | ||||
|
r4536 | for line in fh: | ||
line = line.strip() | ||||
|
r18572 | if line.startswith("error:") or line.startswith("fatal:"): | ||
|
r18570 | raise util.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 | ||
|
r10987 | if fh.close(): | ||
raise util.Abort(_('cannot read tags from %s') % self.path) | ||||
|
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: | ||||
|
r10985 | fh = self.gitopen("git diff-tree --root -m -r %s" % version) | ||
|
r5380 | for l in fh: | ||
if "\t" not in l: | ||||
continue | ||||
m, f = l[:-1].split("\t") | ||||
changes.append(f) | ||||
else: | ||||
|
r16683 | fh = self.gitopen('git diff-tree --name-only --root -r %s ' | ||
'"%s^%s" --' % (version, version, i + 1)) | ||||
|
r5380 | changes = [f.rstrip('\n') for f in fh] | ||
|
r10987 | if fh.close(): | ||
raise util.Abort(_('cannot read changes in %s') % version) | ||||
|
r5380 | |||
return changes | ||||
|
r13756 | |||
def getbookmarks(self): | ||||
bookmarks = {} | ||||
# Interesting references in git are prefixed | ||||
prefix = 'refs/heads/' | ||||
prefixlen = len(prefix) | ||||
# factor two commands | ||||
gitcmd = { 'remote/': 'git ls-remote --heads origin', | ||||
'': 'git show-ref'} | ||||
# Origin heads | ||||
for reftype in gitcmd: | ||||
try: | ||||
|
r18570 | fh = self.gitopen(gitcmd[reftype], err=subprocess.PIPE) | ||
|
r13756 | for line in fh: | ||
line = line.strip() | ||||
rev, name = line.split(None, 1) | ||||
if not name.startswith(prefix): | ||||
continue | ||||
name = '%s%s' % (reftype, name[prefixlen:]) | ||||
bookmarks[name] = rev | ||||
|
r16689 | except Exception: | ||
|
r13756 | pass | ||
return bookmarks | ||||
|
r19121 | |||
|
r20373 | def checkrevformat(self, revstr, mapname='splicemap'): | ||
|
r19121 | """ git revision string is a 40 byte hex """ | ||
|
r20373 | self.checkhexformat(revstr, mapname) | ||