git: show the version of `pygit2` with verbose version output

This seems like useful info to have when debugging.  I followed the precedent of
hg-git, which prints something like:

      hggit        external  0.9.0a1 (dulwich 0.19.15)

We don't have a version number assigned (because it's internal), so it's just
the parenthetical.

Differential Revision: https://phab.mercurial-scm.org/D9436

hgext/git/__init__.py

@@ -1,340 +1,343
 """grant Mercurial the ability to operate on Git repositories. (EXPERIMENTAL)
 
 This is currently super experimental. It probably will consume your
 firstborn a la Rumpelstiltskin, etc.
 """
 
 from __future__ import absolute_import
 
 import os
 
 from mercurial.i18n import _
 
 from mercurial import (
     commands,
     error,
     extensions,
     localrepo,
     pycompat,
     registrar,
     scmutil,
     store,
     util,
 )
 
 from . import (
     dirstate,
     gitlog,
     gitutil,
     index,
 )
 
 # Note for extension authors: ONLY specify testedwith = 'ships-with-hg-core' for
 # extensions which SHIP WITH MERCURIAL. Non-mainline extensions should
 # be specifying the version(s) of Mercurial they are tested with, or
 # leave the attribute unspecified.
 testedwith = b'ships-with-hg-core'
 
 configtable = {}
 configitem = registrar.configitem(configtable)
 # git.log-index-cache-miss: internal knob for testing
 configitem(
     b"git",
     b"log-index-cache-miss",
     default=False,
 )
 
+getversion = gitutil.pygit2_version
+
+
 # TODO: extract an interface for this in core
 class gitstore(object):  # store.basicstore):
     def __init__(self, path, vfstype):
         self.vfs = vfstype(path)
         self.path = self.vfs.base
         self.createmode = store._calcmode(self.vfs)
         # above lines should go away in favor of:
         # super(gitstore, self).__init__(path, vfstype)
 
         self.git = gitutil.get_pygit2().Repository(
             os.path.normpath(os.path.join(path, b'..', b'.git'))
         )
         self._progress_factory = lambda *args, **kwargs: None
         self._logfn = lambda x: None
 
     @util.propertycache
     def _db(self):
         # We lazy-create the database because we want to thread a
         # progress callback down to the indexing process if it's
         # required, and we don't have a ui handle in makestore().
         return index.get_index(self.git, self._logfn, self._progress_factory)
 
     def join(self, f):
         """Fake store.join method for git repositories.
 
         For the most part, store.join is used for @storecache
         decorators to invalidate caches when various files
         change. We'll map the ones we care about, and ignore the rest.
         """
         if f in (b'00changelog.i', b'00manifest.i'):
             # This is close enough: in order for the changelog cache
             # to be invalidated, HEAD will have to change.
             return os.path.join(self.path, b'HEAD')
         elif f == b'lock':
             # TODO: we probably want to map this to a git lock, I
             # suspect index.lock. We should figure out what the
             # most-alike file is in git-land. For now we're risking
             # bad concurrency errors if another git client is used.
             return os.path.join(self.path, b'hgit-bogus-lock')
         elif f in (b'obsstore', b'phaseroots', b'narrowspec', b'bookmarks'):
             return os.path.join(self.path, b'..', b'.hg', f)
         raise NotImplementedError(b'Need to pick file for %s.' % f)
 
     def changelog(self, trypending):
         # TODO we don't have a plan for trypending in hg's git support yet
         return gitlog.changelog(self.git, self._db)
 
     def manifestlog(self, repo, storenarrowmatch):
         # TODO handle storenarrowmatch and figure out if we need the repo arg
         return gitlog.manifestlog(self.git, self._db)
 
     def invalidatecaches(self):
         pass
 
     def write(self, tr=None):
         # normally this handles things like fncache writes, which we don't have
         pass
 
 
 def _makestore(orig, requirements, storebasepath, vfstype):
     if b'git' in requirements:
         if not os.path.exists(os.path.join(storebasepath, b'..', b'.git')):
             raise error.Abort(
                 _(
                     b'repository specified git format in '
                     b'.hg/requires but has no .git directory'
                 )
             )
         # 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'
                 )
             )
 
         return gitstore(storebasepath, vfstype)
     return orig(requirements, storebasepath, vfstype)
 
 
 class gitfilestorage(object):
     def file(self, path):
         if path[0:1] == b'/':
             path = path[1:]
         return gitlog.filelog(self.store.git, self.store._db, path)
 
 
 def _makefilestorage(orig, requirements, features, **kwargs):
     store = kwargs['store']
     if isinstance(store, gitstore):
         return gitfilestorage
     return orig(requirements, features, **kwargs)
 
 
 def _setupdothg(ui, path):
     dothg = os.path.join(path, b'.hg')
     if os.path.exists(dothg):
         ui.warn(_(b'git repo already initialized for hg\n'))
     else:
         os.mkdir(os.path.join(path, b'.hg'))
         # TODO is it ok to extend .git/info/exclude like this?
         with open(
             os.path.join(path, b'.git', b'info', b'exclude'), 'ab'
         ) as exclude:
             exclude.write(b'\n.hg\n')
     with open(os.path.join(dothg, b'requires'), 'wb') as f:
         f.write(b'git\n')
 
 
 _BMS_PREFIX = 'refs/heads/'
 
 
 class gitbmstore(object):
     def __init__(self, gitrepo):
         self.gitrepo = gitrepo
         self._aclean = True
         self._active = gitrepo.references['HEAD']  # git head, not mark
 
     def __contains__(self, name):
         return (
             _BMS_PREFIX + pycompat.fsdecode(name)
         ) in self.gitrepo.references
 
     def __iter__(self):
         for r in self.gitrepo.listall_references():
             if r.startswith(_BMS_PREFIX):
                 yield pycompat.fsencode(r[len(_BMS_PREFIX) :])
 
     def __getitem__(self, k):
         return (
             self.gitrepo.references[_BMS_PREFIX + pycompat.fsdecode(k)]
             .peel()
             .id.raw
         )
 
     def get(self, k, default=None):
         try:
             if k in self:
                 return self[k]
             return default
         except gitutil.get_pygit2().InvalidSpecError:
             return default
 
     @property
     def active(self):
         h = self.gitrepo.references['HEAD']
         if not isinstance(h.target, str) or not h.target.startswith(
             _BMS_PREFIX
         ):
             return None
         return pycompat.fsencode(h.target[len(_BMS_PREFIX) :])
 
     @active.setter
     def active(self, mark):
         githead = mark is not None and (_BMS_PREFIX + mark) or None
         if githead is not None and githead not in self.gitrepo.references:
             raise AssertionError(b'bookmark %s does not exist!' % mark)
 
         self._active = githead
         self._aclean = False
 
     def _writeactive(self):
         if self._aclean:
             return
         self.gitrepo.references.create('HEAD', self._active, True)
         self._aclean = True
 
     def names(self, node):
         r = []
         for ref in self.gitrepo.listall_references():
             if not ref.startswith(_BMS_PREFIX):
                 continue
             if self.gitrepo.references[ref].peel().id.raw != node:
                 continue
             r.append(pycompat.fsencode(ref[len(_BMS_PREFIX) :]))
         return r
 
     # Cleanup opportunity: this is *identical* to core's bookmarks store.
     def expandname(self, bname):
         if bname == b'.':
             if self.active:
                 return self.active
             raise error.RepoLookupError(_(b"no active bookmark"))
         return bname
 
     def applychanges(self, repo, tr, changes):
         """Apply a list of changes to bookmarks"""
         # TODO: this should respect transactions, but that's going to
         # require enlarging the gitbmstore to know how to do in-memory
         # temporary writes and read those back prior to transaction
         # finalization.
         for name, node in changes:
             if node is None:
                 self.gitrepo.references.delete(
                     _BMS_PREFIX + pycompat.fsdecode(name)
                 )
             else:
                 self.gitrepo.references.create(
                     _BMS_PREFIX + pycompat.fsdecode(name),
                     gitutil.togitnode(node),
                     force=True,
                 )
 
     def checkconflict(self, mark, force=False, target=None):
         githead = _BMS_PREFIX + mark
         cur = self.gitrepo.references['HEAD']
         if githead in self.gitrepo.references and not force:
             if target:
                 if self.gitrepo.references[githead] == target and target == cur:
                     # re-activating a bookmark
                     return []
                 # moving a bookmark - forward?
                 raise NotImplementedError
             raise error.Abort(
                 _(b"bookmark '%s' already exists (use -f to force)") % mark
             )
         if len(mark) > 3 and not force:
             try:
                 shadowhash = scmutil.isrevsymbol(self._repo, mark)
             except error.LookupError:  # ambiguous identifier
                 shadowhash = False
             if shadowhash:
                 self._repo.ui.warn(
                     _(
                         b"bookmark %s matches a changeset hash\n"
                         b"(did you leave a -r out of an 'hg bookmark' "
                         b"command?)\n"
                     )
                     % mark
                 )
         return []
 
 
 def init(orig, ui, dest=b'.', **opts):
     if opts.get('git', False):
         path = os.path.abspath(dest)
         # TODO: walk up looking for the git repo
         _setupdothg(ui, path)
         return 0
     return orig(ui, dest=dest, **opts)
 
 
 def reposetup(ui, repo):
     if repo.local() and isinstance(repo.store, gitstore):
         orig = repo.__class__
         repo.store._progress_factory = repo.ui.makeprogress
         if ui.configbool(b'git', b'log-index-cache-miss'):
             repo.store._logfn = repo.ui.warn
 
         class gitlocalrepo(orig):
             def _makedirstate(self):
                 # TODO narrow support here
                 return dirstate.gitdirstate(
                     self.ui, self.vfs.base, self.store.git
                 )
 
             def commit(self, *args, **kwargs):
                 ret = orig.commit(self, *args, **kwargs)
                 if ret is None:
                     # there was nothing to commit, so we should skip
                     # the index fixup logic we'd otherwise do.
                     return None
                 tid = self.store.git[gitutil.togitnode(ret)].tree.id
                 # DANGER! This will flush any writes staged to the
                 # index in Git, but we're sidestepping the index in a
                 # way that confuses git when we commit. Alas.
                 self.store.git.index.read_tree(tid)
                 self.store.git.index.write()
                 return ret
 
             @property
             def _bookmarks(self):
                 return gitbmstore(self.store.git)
 
         repo.__class__ = gitlocalrepo
     return repo
 
 
 def _featuresetup(ui, supported):
     # don't die on seeing a repo with the git requirement
     supported |= {b'git'}
 
 
 def extsetup(ui):
     extensions.wrapfunction(localrepo, b'makestore', _makestore)
     extensions.wrapfunction(localrepo, b'makefilestorage', _makefilestorage)
     # Inject --git flag for `hg init`
     entry = extensions.wrapcommand(commands.table, b'init', init)
     entry[1].extend(
         [(b'', b'git', None, b'setup up a git repository instead of hg')]
     )
     localrepo.featuresetupfuncs.add(_featuresetup)

hgext/git/gitutil.py

@@ -1,40 +1,53
 """utilities to assist in working with pygit2"""
 from __future__ import absolute_import
 
 from mercurial.node import bin, hex, nullid
 
 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 pygit2_version():
+    mod = get_pygit2()
+    v = "N/A"
+
+    if mod:
+        try:
+            v = mod.__version__
+        except AttributeError:
+            pass
+
+    return b"(pygit2 %s)" % v.encode("utf-8")
+
+
 def togitnode(n):
     """Wrapper to convert a Mercurial binary node to a unicode hexlified node.
 
     pygit2 and sqlite both need nodes as strings, not bytes.
     """
     assert len(n) == 20
     return pycompat.sysstr(hex(n))
 
 
 def fromgitnode(n):
     """Opposite of togitnode."""
     assert len(n) == 40
     if pycompat.ispy3:
         return bin(n.encode('ascii'))
     return bin(n)
 
 
 nullgit = togitnode(nullid)

tests/test-git-interop.t

@@ -1,354 +1,358
 #require pygit2
 
 Setup:
   $ GIT_AUTHOR_NAME='test'; export GIT_AUTHOR_NAME
   > GIT_AUTHOR_EMAIL='[e-mail]'; export GIT_AUTHOR_EMAIL
   > GIT_AUTHOR_DATE="2007-01-01 00:00:00 +0000"; export GIT_AUTHOR_DATE
   > GIT_COMMITTER_NAME="$GIT_AUTHOR_NAME"; export GIT_COMMITTER_NAME
   > GIT_COMMITTER_EMAIL="$GIT_AUTHOR_EMAIL"; export GIT_COMMITTER_EMAIL
   > GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"; export GIT_COMMITTER_DATE
   > count=10
   > gitcommit() {
   >    GIT_AUTHOR_DATE="2007-01-01 00:00:$count +0000";
   >    GIT_COMMITTER_DATE="$GIT_AUTHOR_DATE"
   >    git commit "$@" >/dev/null 2>/dev/null || echo "git commit error"
   >    count=`expr $count + 1`
   >  }
 
 
+  $ hg version -v --config extensions.git= | grep '^[E ]'
+  Enabled extensions:
+    git  internal  (pygit2 *) (glob)
+
 Test auto-loading extension works:
   $ mkdir nogit
   $ cd nogit
   $ mkdir .hg
   $ echo git >> .hg/requires
   $ hg status
   abort: repository specified git format in .hg/requires but has no .git directory
   [255]
   $ git init
   Initialized empty Git repository in $TESTTMP/nogit/.git/
 This status invocation shows some hg gunk because we didn't use
 `hg init --git`, which fixes up .git/info/exclude for us.
   $ hg status
   ? .hg/cache/git-commits.sqlite
   ? .hg/cache/git-commits.sqlite-shm
   ? .hg/cache/git-commits.sqlite-wal
   ? .hg/requires
   $ cd ..
 
 Now globally enable extension for the rest of the test:
   $ cat <<EOF >> $HGRCPATH
   > [extensions]
   > git=
   > [git]
   > log-index-cache-miss = yes
   > EOF
 
 Make a new repo with git:
   $ mkdir foo
   $ cd foo
   $ git init
   Initialized empty Git repository in $TESTTMP/foo/.git/
 Ignore the .hg directory within git:
   $ echo .hg >> .git/info/exclude
   $ echo alpha > alpha
   $ git add alpha
   $ gitcommit -am 'Add alpha'
   $ echo beta > beta
   $ git add beta
   $ gitcommit -am 'Add beta'
   $ echo gamma > gamma
   $ git status
   On branch master
   Untracked files:
     (use "git add <file>..." to include in what will be committed)
   	gamma
   
   nothing added to commit but untracked files present (use "git add" to track)
 
 Without creating the .hg, hg status fails:
   $ hg status
   abort: no repository found in '$TESTTMP/foo' (.hg not found)
   [10]
 But if you run hg init --git, it works:
   $ hg init --git
   $ hg id --traceback
   heads mismatch, rebuilding dagcache
   3d9be8deba43 tip master
   $ hg status
   ? gamma
 Log works too:
   $ hg log
   changeset:   1:3d9be8deba43
   bookmark:    master
   tag:         tip
   user:        test <[e-mail]>
   date:        Mon Jan 01 00:00:11 2007 +0000
   summary:     Add beta
   
   changeset:   0:c5864c9d16fb
   user:        test <[e-mail]>
   date:        Mon Jan 01 00:00:10 2007 +0000
   summary:     Add alpha
   
 
 
 and bookmarks:
   $ hg bookmarks
    * master                    1:3d9be8deba43
 
 diff even works transparently in both systems:
   $ echo blah >> alpha
   $ git diff
   diff --git a/alpha b/alpha
   index 4a58007..faed1b7 100644
   --- a/alpha
   +++ b/alpha
   @@ -1* +1,2 @@ (glob)
    alpha
   +blah
   $ hg diff --git
   diff --git a/alpha b/alpha
   --- a/alpha
   +++ b/alpha
   @@ -1,1 +1,2 @@
    alpha
   +blah
 
 Remove a file, it shows as such:
   $ rm alpha
   $ hg status
   ! alpha
   ? gamma
 
 Revert works:
   $ hg revert alpha --traceback
   $ hg status
   ? gamma
   $ git status
   On branch master
   Untracked files:
     (use "git add <file>..." to include in what will be committed)
   	gamma
   
   nothing added to commit but untracked files present (use "git add" to track)
 
 Add shows sanely in both:
   $ hg add gamma
   $ hg status
   A gamma
   $ hg files
   alpha
   beta
   gamma
   $ git ls-files
   alpha
   beta
   gamma
   $ git status
   On branch master
   Changes to be committed:
     (use "git restore --staged <file>..." to unstage)
   	new file:   gamma
   
 
 forget does what it should as well:
   $ hg forget gamma
   $ hg status
   ? gamma
   $ git status
   On branch master
   Untracked files:
     (use "git add <file>..." to include in what will be committed)
   	gamma
   
   nothing added to commit but untracked files present (use "git add" to track)
 
 clean up untracked file
   $ rm gamma
 
 hg log FILE
 
   $ echo a >> alpha
   $ hg ci -m 'more alpha' --traceback --date '1583522787 18000'
   $ echo b >> beta
   $ hg ci -m 'more beta'
   heads mismatch, rebuilding dagcache
   $ echo a >> alpha
   $ hg ci -m 'even more alpha'
   heads mismatch, rebuilding dagcache
   $ hg log -G alpha
   heads mismatch, rebuilding dagcache
   @  changeset:   4:6626247b7dc8
   :  bookmark:    master
   :  tag:         tip
   :  user:        test <test>
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     even more alpha
   :
   o  changeset:   2:a1983dd7fb19
   :  user:        test <test>
   :  date:        Fri Mar 06 14:26:27 2020 -0500
   :  summary:     more alpha
   :
   o  changeset:   0:c5864c9d16fb
      user:        test <[e-mail]>
      date:        Mon Jan 01 00:00:10 2007 +0000
      summary:     Add alpha
   
   $ hg log -G beta
   o  changeset:   3:d8ee22687733
   :  user:        test <test>
   :  date:        Thu Jan 01 00:00:00 1970 +0000
   :  summary:     more beta
   :
   o  changeset:   1:3d9be8deba43
   |  user:        test <[e-mail]>
   ~  date:        Mon Jan 01 00:00:11 2007 +0000
      summary:     Add beta
   
 
   $ hg log -r "children(3d9be8deba43)" -T"{node|short} {children}\n"
   a1983dd7fb19 3:d8ee22687733
 
 hg annotate
 
   $ hg annotate alpha
   0: alpha
   2: a
   4: a
   $ hg annotate beta
   1: beta
   3: b
 
 
 Files in subdirectories. TODO: case-folding support, make this `A`
 instead of `a`.
 
   $ mkdir a
   $ echo "This is file mu." > a/mu
   $ hg ci -A -m 'Introduce file a/mu'
   adding a/mu
 
 Both hg and git agree a/mu is part of the repo
 
   $ git ls-files
   a/mu
   alpha
   beta
   $ hg files
   a/mu
   alpha
   beta
 
 hg and git status both clean
 
   $ git status
   On branch master
   nothing to commit, working tree clean
   $ hg status
   heads mismatch, rebuilding dagcache
 
 
 node|shortest works correctly
   $ hg log -T '{node}\n' | sort
   3d9be8deba43482be2c81a4cb4be1f10d85fa8bc
   6626247b7dc8f231b183b8a4761c89139baca2ad
   a1983dd7fb19cbd83ad5a1c2fc8bf3d775dea12f
   ae1ab744f95bfd5b07cf573baef98a778058537b
   c5864c9d16fb3431fe2c175ff84dc6accdbb2c18
   d8ee22687733a1991813560b15128cd9734f4b48
   $ hg log -r ae1ab744f95bfd5b07cf573baef98a778058537b --template "{shortest(node,1)}\n"
   ae
 
 This coveres changelog.findmissing()
   $ hg merge --preview 3d9be8deba43
 
 This covers manifest.diff()
   $ hg diff -c 3d9be8deba43
   diff -r c5864c9d16fb -r 3d9be8deba43 beta
   --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   +++ b/beta	Mon Jan 01 00:00:11 2007 +0000
   @@ -0,0 +1,1 @@
   +beta
 
 
 Interactive commit should work as expected
 
   $ echo bar >> alpha
   $ echo bar >> beta
   $ hg commit -m "test interactive commit" -i --config ui.interactive=true --config ui.interface=text << EOF
   > y
   > y
   > n
   > EOF
   diff --git a/alpha b/alpha
   1 hunks, 1 lines changed
   examine changes to 'alpha'?
   (enter ? for help) [Ynesfdaq?] y
   
   @@ -1,3 +1,4 @@
    alpha
    a
    a
   +bar
   record change 1/2 to 'alpha'?
   (enter ? for help) [Ynesfdaq?] y
   
   diff --git a/beta b/beta
   1 hunks, 1 lines changed
   examine changes to 'beta'?
   (enter ? for help) [Ynesfdaq?] n
   
 Status should be consistent for both systems
 
   $ hg status
   heads mismatch, rebuilding dagcache
   M beta
   $ git status | egrep -v '^$|^  \(use '
   On branch master
   Changes not staged for commit:
   	modified:   beta
   no changes added to commit (use "git add" and/or "git commit -a")
 
 Contents of each commit should be the same
 
   $ hg ex -r .
   # HG changeset patch
   # User test <test>
   # Date 0 0
   #      Thu Jan 01 00:00:00 1970 +0000
   # Node ID 80adc61cf57e99f6a412d83fee6239d1556cefcf
   # Parent  ae1ab744f95bfd5b07cf573baef98a778058537b
   test interactive commit
   
   diff -r ae1ab744f95b -r 80adc61cf57e alpha
   --- a/alpha	Thu Jan 01 00:00:00 1970 +0000
   +++ b/alpha	Thu Jan 01 00:00:00 1970 +0000
   @@ -1,3 +1,4 @@
    alpha
    a
    a
   +bar
   $ git show
   commit 80adc61cf57e99f6a412d83fee6239d1556cefcf
   Author: test <test>
   Date:   Thu Jan 1 00:00:00 1970 +0000
   
       test interactive commit
   
   diff --git a/alpha b/alpha
   index d112a75..d2a2e9a 100644
   --- a/alpha
   +++ b/alpha
   @@ -1,3 +1,4 @@
    alpha
    a
    a
   +bar
 
 Deleting files should also work (this was issue6398)
   $ hg revert -r . --all
   reverting beta
   $ hg rm beta
   $ hg ci -m 'remove beta'