def hg_readactive(repo):
if hg_version() >= '3.7':
return _readactive(repo,repo._bookmarks)
elif hg_version() >= '3.5' and hg_version() < '3.7':
return readactive(repo)
else:
return readcurrent(repo)
def __init__(self, alias, url):
if hg.islocal(url.encode("utf-8")):
url = p(url).abspath()
# Force git to use an absolute path in the future
remote_name = os.path.basename(sys.argv[0]).replace("git-remote-", "")
cmd = ["git", "config", "remote.%s.url" % alias, "%s::%s" % (remote_name, url)]
subprocess.call(cmd)
# use hash of URL as unique identifier in various places.
# this has the advantage over 'alias' that it stays constant
# when the user does a "git remote rename old new".
if hg_version() >= "4.0.1":
d = digester(["md5", "sha1"])
d.update(url.encode("utf-8"))
self.uuid = d["sha1"]
else:
self.uuid = sha1(url.encode("utf-8")).hexdigest()
gitdir = p(os.environ["GIT_DIR"].decode("utf-8"))
self.remotedir = gitdir.joinpath("hg", self.uuid)
self.marks_git_path = self.remotedir.joinpath("marks-git")
self.marks_hg_path = self.remotedir.joinpath("marks-hg")
self.marks = HGMarks(self.marks_hg_path)
self.git_marks = GitMarks(self.marks_git_path)
self.parsed_refs = {}
self.blob_marks = {}
self.branches = {}
self.bookmarks = {}
self.prefix = "refs/hg/%s" % alias
self.alias = alias
self.url = url
self.build_repo(url)
def hg_sha1(url):
encoded = url.encode('utf-8')
if hg_version() >= '3.2':
d = digester(['md5', 'sha1'])
d.update(encoded)
return d['sha1']
else:
return sha1(encoded).hexdigest()
def hg_strip(repo, processed_nodes):
class dummyui(object):
def debug(self, msg):
pass
if StrictVersion(hg_version()) >= StrictVersion('2.8'):
stripext = extensions.load(dummyui(), 'strip', '')
return stripext.strip(dummyui(), repo, processed_nodes)
else:
return repo.mq.strip(repo, processed_nodes)
def handle_deleted_file():
if hg_version() >= '3.2':
return
else:
raise IOError
def hg_memfilectx(repo, path, data, is_link=False, is_exec=False, copied=None):
if hg_version() >= '3.1':
return memfilectx(repo, path, data, is_link, is_exec, copied)
else:
return memfilectx(path, data, is_link, is_exec, copied)
from mercurial.context import memctx, memfilectx
from mercurial.util import version as hg_version
from distutils.version import StrictVersion
from mercurial import extensions
# Conditional imports depending on Mercurial version
if hg_version() >= '3.7':
from mercurial.bookmarks import _readactive
elif hg_version() >= '3.5' and hg_version() < '3.7':
from mercurial.bookmarks import readactive
else:
from mercurial.bookmarks import readcurrent
if hg_version() >= '3.2':
from mercurial.util import digester
else:
from mercurial.util import sha1
if hg_version() >= '3.0':
from mercurial import exchange
else:
from mercurial.localrepo import localrepository as exchange
# Functions wrapping the Mercurial API. They follow the naming convention of
# hg_[function name]
def hg_pull(repo, peer, heads=None, force=False):
return exchange.pull(repo, peer, heads=heads, force=force)
def hg_push(repo, peer, force=False, newbranch=None):
return exchange.push(repo, peer, force=force, newbranch=newbranch)
from mercurial.node import hex as hghex # What idiot overroad a builtin?
from mercurial.node import short as hgshort
from mercurial.bookmarks import pushbookmark
from mercurial.scmutil import revsingle
from mercurial.util import version as hg_version
from distutils.version import StrictVersion
from .util import (die, output, git_to_hg_spaces, hgmode, branch_tip,
ref_to_name_reftype, BRANCH, BOOKMARK, TAG, user_config)
class dummyui(object):
def debug(self, msg):
pass
if StrictVersion(hg_version()) >= StrictVersion('2.8'):
stripext = extensions.load(dummyui(), 'strip', '')
def strip_revs(repo, processed_nodes):
stripext.strip(dummyui(), repo, processed_nodes)
else:
def strip_revs(repo, processed_nodes):
repo.mq.strip(repo, processed_nodes)
class GitExporter(object):
'''A processor when the remote receives a git-remote `export` command.
Provides export information to push commits from git to the mercurial
repository.'''
NULL_PARENT = '\0' * 20
def log_versions(level="DEBUG"):
log("gitifyhg version %s" % version(), level=level)
log("Mercurial version %s" % hg_version(), level=level)
log("Python version %s" % (sys.version.replace("\n", "")), level=level)
def do_list(self, parser):
"""List all references in the mercurial repository. This includes
the current head, all branches, tags, and bookmarks."""
current_branch = self.repo.dirstate.branch()
# Update the head reference
if hg_version() >= "4.0.1":
head = _readactive(self.repo, self.repo._bookmarks)
else:
head = readcurrent(self.repo)
if head:
node = self.repo[head]
else:
# If there is no bookmark for head, mock one
head = current_branch
node = self.repo["."]
# I think this means an initial clone occured and we haven't
# hg updated yet in the local clone
if not node:
if "default" in self.repo:
node = self.repo["default"]
else: # empty repository or head is at 0 commit
output()
return
head = head if head != "default" else "master"
# self.bookmarks[head] = node
self.headnode = (head, node)
# Update the bookmark references
for bookmark, node in listbookmarks(self.repo).iteritems():
self.bookmarks[bookmark] = self.repo[node]
# update the named branch references
for branch in self.repo.branchmap():
# FIXME: Probably a git config instead of an env var would make
# people happier here.
clone_closed = os.environ.get("GITIFYHG_ALLOW_CLOSED_BRANCHES") != None
heads = self.repo.branchheads(branch, closed=clone_closed)
if heads:
self.branches[branch] = heads
# list the head reference
output("@refs/heads/%s HEAD" % self.headnode[0])
# list the named branch references
for branch in self.branches:
output(
"%s %s"
% (self._change_hash(branch_head(self, branch)), name_reftype_to_ref(hg_to_git_spaces(branch), BRANCH))
)
# list the bookmark references
for bookmark, changectx in self.bookmarks.items():
if bookmark != "master":
output(
"%s %s" % (self._change_hash(changectx), name_reftype_to_ref(hg_to_git_spaces(bookmark), BOOKMARK))
)
# list the tags
for tag, node in self.repo.tagslist():
if tag != "tip":
output("%s %s" % (self._change_hash(self.repo[node]), name_reftype_to_ref(hg_to_git_spaces(tag), TAG)))
output()
import sys
import os
import re
import optparse
import subprocess
from path import path as p
# Enable "plain" mode to make us resilient against changes to the locale, as we
# rely on parsing certain messages produced by Mercurial. See issue #26.
os.environ["HGPLAIN"] = "1"
# Disable loading of the user's $HOME/.hgrc as extensions can cause weird
# interactions and it's better to run in a known state.
os.environ["HGRCPATH"] = ""
# Version specific libraries from the Mercurial API
if hg_version() >= "4.0.1":
from mercurial.util import digester
from mercurial.bookmarks import _readactive
else:
from mercurial.util import sha1
from mercurial.bookmarks import readcurrent
from mercurial import hg
from mercurial.bookmarks import listbookmarks
from mercurial.ui import ui
from mercurial.error import Abort, RepoError
from mercurial.util import version as hg_version
from .util import (
log,
die,
def log_versions(level="DEBUG"):
log("gitifyhg version %s" % version(), level=level)
log("Mercurial version %s" % hg_version(), level=level)
log("Python version %s" % (sys.version.replace("\n", "")), level=level)
