This is an archive of the discontinued Mercurial Phabricator instance.

Differential D8268

git: don't fail import when pygit2 is not install
ClosedPublic

Authored by martinvonz on Mar 9 2020, 5:18 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGec54b3d2af0b: git: don't fail import when pygit2 is not install
Summary

test-duplicateoptions.py was failing on py2 for be because I didn't
have pygit2 installed. It failed because we depend on pygit2 at import
time. This patch makes it so we successfully load the git extension
even if pygit2 doesn't exist -- we just won't be able to use it in
that case.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

martinvonz created this revision.Mar 9 2020, 5:18 PM
mharbison72 added a subscriber: mharbison72.Mar 9 2020, 6:37 PM
mharbison72 added inline comments.
hgext/git/__init__.py
95

s/py2git2/pygit2/ ? Pip isn't finding the former for me.

martinvonz updated this revision to Diff 20646.Mar 9 2020, 6:38 PM
martinvonz marked an inline comment as done.Mar 9 2020, 6:38 PM
martinvonz added inline comments.
hgext/git/__init__.py
95

That was just a typo (a typo that I made many times while writing these two patches).

martinvonz marked an inline comment as done.Mar 9 2020, 6:58 PM
martinvonz added a commit: rHGec54b3d2af0b: git: don't fail import when pygit2 is not install.
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGec54b3d2af0b: git: don't fail import when pygit2 is not install (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

PathPackages
Mhgext/git/__init__.py (17 lines)
Mhgext/git/dirstate.py (40 lines)
Mhgext/git/gitlog.py (4 lines)
Mhgext/git/gitutil.py (14 lines)
Mhgext/git/index.py (14 lines)
Mhgext/git/manifest.py (5 lines)

Diff 20646

hgext/git/__init__.py

"""grant Mercurial the ability to operate on Git repositories. (EXPERIMENTAL) """grant Mercurial the ability to operate on Git repositories. (EXPERIMENTAL)
This is currently super experimental. It probably will consume your This is currently super experimental. It probably will consume your
firstborn a la Rumpelstiltskin, etc. firstborn a la Rumpelstiltskin, etc.
""" """
from __future__ import absolute_import from __future__ import absolute_import
import os import os
import pygit2
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
commands, commands,
error, error,
extensions, extensions,
localrepo, localrepo,
pycompat, pycompat,
store, store,
util, util,
) )
from . import ( from . import (
dirstate, dirstate,
gitlog, gitlog,
gitutil, gitutil,
index, index,
) )
# TODO: extract an interface for this in core # TODO: extract an interface for this in core
class gitstore(object): # store.basicstore): class gitstore(object): # store.basicstore):
def __init__(self, path, vfstype): def __init__(self, path, vfstype):
self.vfs = vfstype(path) self.vfs = vfstype(path)
self.path = self.vfs.base self.path = self.vfs.base
self.createmode = store._calcmode(self.vfs) self.createmode = store._calcmode(self.vfs)
# above lines should go away in favor of: # above lines should go away in favor of:
# super(gitstore, self).__init__(path, vfstype) # super(gitstore, self).__init__(path, vfstype)
self.git = pygit2.Repository( self.git = gitutil.get_pygit2().Repository(
os.path.normpath(os.path.join(path, b'..', b'.git')) os.path.normpath(os.path.join(path, b'..', b'.git'))
) )
self._progress_factory = lambda *args, **kwargs: None self._progress_factory = lambda *args, **kwargs: None
@util.propertycache @util.propertycache
def _db(self): def _db(self):
# We lazy-create the database because we want to thread a # We lazy-create the database because we want to thread a
# progress callback down to the indexing process if it's # progress callback down to the indexing process if it's
pass pass
def write(self, tr=None): def write(self, tr=None):
# normally this handles things like fncache writes, which we don't have # normally this handles things like fncache writes, which we don't have
pass pass
def _makestore(orig, requirements, storebasepath, vfstype): def _makestore(orig, requirements, storebasepath, vfstype):
# Check for presence of pygit2 only here. The assumption is that we'll
# run this code iff we'll later need pygit2.
if gitutil.get_pygit2() is None:
raise error.Abort(
_(
b'the git extension requires the Python '
b'pygit2 library to be installed'
mharbison72Unsubmitted
Done

s/py2git2/pygit2/ ? Pip isn't finding the former for me.

mharbison72: s/py2git2/pygit2/ ? Pip isn't finding the former for me.
martinvonzAuthorUnsubmitted
Done

That was just a typo (a typo that I made many times while writing these two patches).

martinvonz: That was just a typo (a typo that I made many times while writing these two patches).
)
)
if os.path.exists( if os.path.exists(
os.path.join(storebasepath, b'this-is-git') os.path.join(storebasepath, b'this-is-git')
) and os.path.exists(os.path.join(storebasepath, b'..', b'.git')): ) and os.path.exists(os.path.join(storebasepath, b'..', b'.git')):
return gitstore(storebasepath, vfstype) return gitstore(storebasepath, vfstype)
return orig(requirements, storebasepath, vfstype) return orig(requirements, storebasepath, vfstype)
class gitfilestorage(object): class gitfilestorage(object):
.id.raw .id.raw
) )
def get(self, k, default=None): def get(self, k, default=None):
try: try:
if k in self: if k in self:
return self[k] return self[k]
return default return default
except pygit2.InvalidSpecError: except gitutil.get_pygit2().InvalidSpecError:
return default return default
@property @property
def active(self): def active(self):
h = self.gitrepo.references['HEAD'] h = self.gitrepo.references['HEAD']
if not isinstance(h.target, str) or not h.target.startswith( if not isinstance(h.target, str) or not h.target.startswith(
_BMS_PREFIX _BMS_PREFIX
): ):

hgext/git/dirstate.py

from __future__ import absolute_import from __future__ import absolute_import
import contextlib import contextlib
import errno import errno
import os import os
import pygit2
from mercurial import ( from mercurial import (
error, error,
extensions, extensions,
match as matchmod, match as matchmod,
node as nodemod, node as nodemod,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.interfaces import ( from mercurial.interfaces import (
dirstate as intdirstate, dirstate as intdirstate,
util as interfaceutil, util as interfaceutil,
) )
from . import gitutil from . import gitutil
pygit2 = gitutil.get_pygit2()
def readpatternfile(orig, filepath, warn, sourceinfo=False): def readpatternfile(orig, filepath, warn, sourceinfo=False):
if not (b'info/exclude' in filepath or filepath.endswith(b'.gitignore')): if not (b'info/exclude' in filepath or filepath.endswith(b'.gitignore')):
return orig(filepath, warn, sourceinfo=False) return orig(filepath, warn, sourceinfo=False)
result = [] result = []
warnings = [] warnings = []
with open(filepath, b'rb') as fp: with open(filepath, b'rb') as fp:
for l in fp: for l in fp:
l = l.strip() l = l.strip()
if not l or l.startswith(b'#'): if not l or l.startswith(b'#'):
continue continue
if l.startswith(b'!'): if l.startswith(b'!'):
warnings.append(b'unsupported ignore pattern %s' % l) warnings.append(b'unsupported ignore pattern %s' % l)
continue continue
if l.startswith(b'/'): if l.startswith(b'/'):
result.append(b'rootglob:' + l[1:]) result.append(b'rootglob:' + l[1:])
else: else:
result.append(b'relglob:' + l) result.append(b'relglob:' + l)
return result, warnings return result, warnings
extensions.wrapfunction(matchmod, b'readpatternfile', readpatternfile) extensions.wrapfunction(matchmod, b'readpatternfile', readpatternfile)
_STATUS_MAP = {}
if pygit2:
_STATUS_MAP = { _STATUS_MAP = {
pygit2.GIT_STATUS_CONFLICTED: b'm', pygit2.GIT_STATUS_CONFLICTED: b'm',
pygit2.GIT_STATUS_CURRENT: b'n', pygit2.GIT_STATUS_CURRENT: b'n',
pygit2.GIT_STATUS_IGNORED: b'?', pygit2.GIT_STATUS_IGNORED: b'?',
pygit2.GIT_STATUS_INDEX_DELETED: b'r', pygit2.GIT_STATUS_INDEX_DELETED: b'r',
pygit2.GIT_STATUS_INDEX_MODIFIED: b'n', pygit2.GIT_STATUS_INDEX_MODIFIED: b'n',
pygit2.GIT_STATUS_INDEX_NEW: b'a', pygit2.GIT_STATUS_INDEX_NEW: b'a',
pygit2.GIT_STATUS_INDEX_RENAMED: b'a', pygit2.GIT_STATUS_INDEX_RENAMED: b'a',
pygit2.GIT_STATUS_INDEX_TYPECHANGE: b'n', pygit2.GIT_STATUS_INDEX_TYPECHANGE: b'n',
pygit2.GIT_STATUS_WT_DELETED: b'r', pygit2.GIT_STATUS_WT_DELETED: b'r',
pygit2.GIT_STATUS_WT_MODIFIED: b'n', pygit2.GIT_STATUS_WT_MODIFIED: b'n',
pygit2.GIT_STATUS_WT_NEW: b'?', pygit2.GIT_STATUS_WT_NEW: b'?',
pygit2.GIT_STATUS_WT_RENAMED: b'a', pygit2.GIT_STATUS_WT_RENAMED: b'a',
pygit2.GIT_STATUS_WT_TYPECHANGE: b'n', pygit2.GIT_STATUS_WT_TYPECHANGE: b'n',
pygit2.GIT_STATUS_WT_UNREADABLE: b'?', pygit2.GIT_STATUS_WT_UNREADABLE: b'?',
pygit2.GIT_STATUS_INDEX_MODIFIED | pygit2.GIT_STATUS_WT_MODIFIED: 'm', pygit2.GIT_STATUS_INDEX_MODIFIED | pygit2.GIT_STATUS_WT_MODIFIED: 'm',
} }
@interfaceutil.implementer(intdirstate.idirstate) @interfaceutil.implementer(intdirstate.idirstate)
class gitdirstate(object): class gitdirstate(object):
def __init__(self, ui, root, gitrepo): def __init__(self, ui, root, gitrepo):
self._ui = ui self._ui = ui
self._root = os.path.dirname(root) self._root = os.path.dirname(root)
self.git = gitrepo self.git = gitrepo

hgext/git/gitlog.py

from __future__ import absolute_import from __future__ import absolute_import
import pygit2
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
ancestor, ancestor,
changelog as hgchangelog, changelog as hgchangelog,
dagop, dagop,
encoding, encoding,
error, error,
manifest, manifest,
node as nodemod, node as nodemod,
pycompat, pycompat,
) )
from mercurial.interfaces import ( from mercurial.interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from mercurial.utils import stringutil from mercurial.utils import stringutil
from . import ( from . import (
gitutil, gitutil,
index, index,
manifest as gitmanifest, manifest as gitmanifest,
) )
pygit2 = gitutil.get_pygit2()
class baselog(object): # revlog.revlog): class baselog(object): # revlog.revlog):
"""Common implementations between changelog and manifestlog.""" """Common implementations between changelog and manifestlog."""
def __init__(self, gr, db): def __init__(self, gr, db):
self.gitrepo = gr self.gitrepo = gr
self._db = db self._db = db

hgext/git/gitutil.py

"""utilities to assist in working with pygit2""" """utilities to assist in working with pygit2"""
from __future__ import absolute_import from __future__ import absolute_import
from mercurial.node import bin, hex, nullid from mercurial.node import bin, hex, nullid
from mercurial import pycompat from mercurial import pycompat
pygit2_module = None
def get_pygit2():
global pygit2_module
if pygit2_module is None:
try:
import pygit2 as pygit2_module
pygit2_module.InvalidSpecError
except (ImportError, AttributeError):
pass
return pygit2_module
def togitnode(n): def togitnode(n):
"""Wrapper to convert a Mercurial binary node to a unicode hexlified node. """Wrapper to convert a Mercurial binary node to a unicode hexlified node.
pygit2 and sqlite both need nodes as strings, not bytes. pygit2 and sqlite both need nodes as strings, not bytes.
""" """
assert len(n) == 20 assert len(n) == 20
return pycompat.sysstr(hex(n)) return pycompat.sysstr(hex(n))

hgext/git/index.py

from __future__ import absolute_import from __future__ import absolute_import
import collections import collections
import os import os
import sqlite3 import sqlite3
import pygit2
from mercurial.i18n import _ from mercurial.i18n import _
from mercurial import ( from mercurial import (
encoding, encoding,
error, error,
node as nodemod, node as nodemod,
pycompat, pycompat,
) )
from . import gitutil from . import gitutil
pygit2 = gitutil.get_pygit2()
_CURRENT_SCHEMA_VERSION = 1 _CURRENT_SCHEMA_VERSION = 1
_SCHEMA = ( _SCHEMA = (
""" """
CREATE TABLE refs ( CREATE TABLE refs (
-- node and name are unique together. There may be more than one name for -- node and name are unique together. There may be more than one name for
-- a given node, and there may be no name at all for a given node (in the -- a given node, and there may be no name at all for a given node (in the
-- case of an anonymous hg head). -- case of an anonymous hg head).
node TEXT NOT NULL, node TEXT NOT NULL,
else: else:
raise error.Abort(_(b'sqlite database has unrecognized version')) raise error.Abort(_(b'sqlite database has unrecognized version'))
db.execute('PRAGMA journal_mode=WAL') db.execute('PRAGMA journal_mode=WAL')
return db return db
_OUR_ORDER = ()
if pygit2:
_OUR_ORDER = ( _OUR_ORDER = (
pygit2.GIT_SORT_TOPOLOGICAL | pygit2.GIT_SORT_TIME | pygit2.GIT_SORT_REVERSE pygit2.GIT_SORT_TOPOLOGICAL
| pygit2.GIT_SORT_TIME
| pygit2.GIT_SORT_REVERSE
) )
_DIFF_FLAGS = 1 << 21 # GIT_DIFF_FORCE_BINARY, which isn't exposed by pygit2 _DIFF_FLAGS = 1 << 21 # GIT_DIFF_FORCE_BINARY, which isn't exposed by pygit2
def _find_nearest_ancestor_introducing_node( def _find_nearest_ancestor_introducing_node(
db, gitrepo, file_path, walk_start, filenode db, gitrepo, file_path, walk_start, filenode
): ):
"""Find the nearest ancestor that introduces a file node. """Find the nearest ancestor that introduces a file node.

hgext/git/manifest.py

from __future__ import absolute_import from __future__ import absolute_import
import pygit2
from mercurial import ( from mercurial import (
match as matchmod, match as matchmod,
pathutil, pathutil,
pycompat, pycompat,
util, util,
) )
from mercurial.interfaces import ( from mercurial.interfaces import (
repository, repository,
util as interfaceutil, util as interfaceutil,
) )
from . import gitutil from . import gitutil
pygit2 = gitutil.get_pygit2()
@interfaceutil.implementer(repository.imanifestdict) @interfaceutil.implementer(repository.imanifestdict)
class gittreemanifest(object): class gittreemanifest(object):
"""Expose git trees (and optionally a builder's overlay) as a manifestdict. """Expose git trees (and optionally a builder's overlay) as a manifestdict.
Very similar to mercurial.manifest.treemanifest. Very similar to mercurial.manifest.treemanifest.
""" """
def __init__(self, git_repo, root_tree, pending_changes): def __init__(self, git_repo, root_tree, pending_changes):