This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12567

git: adapt to some recent dirstate API changes
ClosedPublic

Authored by mharbison72 on Apr 18 2022, 12:39 PM.

Details

Reviewers
durin42
Alphare
Group Reviewers
hg-reviewers
Commits
rHG20d151e43429: git: adapt to some recent dirstate API changes
rHGaa400bf66880: git: adapt to some recent dirstate API changes
Summary

There are still old methods like add() and drop(). I don't see anything that
looks equivalent, so there's likely more work to do. But this allows diff and
commit to work again on the simple webpage repo for thg.

Diff Detail

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

Revision Contents
Changeset List

PathPackages
Mhgext/git/__init__.py (9 lines)
Mhgext/git/dirstate.py (41 lines)

Diff 33193

hgext/git/__init__.py

from mercurial import ( from mercurial import (
commands, commands,
error, error,
extensions, extensions,
localrepo, localrepo,
pycompat, pycompat,
registrar, registrar,
requirements as requirementsmod,
scmutil, scmutil,
store, store,
util, util,
) )
from . import ( from . import (
dirstate, dirstate,
gitlog, gitlog,
if repo.local() and isinstance(repo.store, gitstore): if repo.local() and isinstance(repo.store, gitstore):
orig = repo.__class__ orig = repo.__class__
repo.store._progress_factory = repo.ui.makeprogress repo.store._progress_factory = repo.ui.makeprogress
if ui.configbool(b'git', b'log-index-cache-miss'): if ui.configbool(b'git', b'log-index-cache-miss'):
repo.store._logfn = repo.ui.warn repo.store._logfn = repo.ui.warn
class gitlocalrepo(orig): class gitlocalrepo(orig):
def _makedirstate(self): def _makedirstate(self):
v2_req = requirementsmod.DIRSTATE_V2_REQUIREMENT
use_dirstate_v2 = v2_req in self.requirements
# TODO narrow support here # TODO narrow support here
return dirstate.gitdirstate( return dirstate.gitdirstate(
self.ui, self.vfs.base, self.store.git self.ui,
self.vfs,
self.store.git,
use_dirstate_v2,
) )
def commit(self, *args, **kwargs): def commit(self, *args, **kwargs):
ret = orig.commit(self, *args, **kwargs) ret = orig.commit(self, *args, **kwargs)
if ret is None: if ret is None:
# there was nothing to commit, so we should skip # there was nothing to commit, so we should skip
# the index fixup logic we'd otherwise do. # the index fixup logic we'd otherwise do.
return None return None

hgext/git/dirstate.py

import contextlib import contextlib
import errno import errno
import os import os
from mercurial.node import sha1nodeconstants from mercurial.node import sha1nodeconstants
from mercurial import ( from mercurial import (
dirstatemap,
error, error,
extensions, extensions,
match as matchmod, match as matchmod,
pycompat, pycompat,
scmutil, scmutil,
util, util,
) )
from mercurial.dirstateutils import (
timestamp,
)
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
DirstateItem = dirstatemap.DirstateItem
propertycache = util.propertycache
pygit2 = gitutil.get_pygit2() 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 = []
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: b'm', pygit2.GIT_STATUS_INDEX_MODIFIED | pygit2.GIT_STATUS_WT_MODIFIED: b'm',
} }
@interfaceutil.implementer(intdirstate.idirstate) @interfaceutil.implementer(intdirstate.idirstate)
class gitdirstate: class gitdirstate:
def __init__(self, ui, root, gitrepo): def __init__(self, ui, vfs, gitrepo, use_dirstate_v2):
self._ui = ui self._ui = ui
self._root = os.path.dirname(root) self._root = os.path.dirname(vfs.base)
self._opener = vfs
self.git = gitrepo self.git = gitrepo
self._plchangecallbacks = {} self._plchangecallbacks = {}
# TODO: context.poststatusfixup is bad and uses this attribute # TODO: context.poststatusfixup is bad and uses this attribute
self._dirty = False self._dirty = False
self._mapcls = dirstatemap.dirstatemap
self._use_dirstate_v2 = use_dirstate_v2
@propertycache
def _map(self):
"""Return the dirstate contents (see documentation for dirstatemap)."""
self._map = self._mapcls(
self._ui,
self._opener,
self._root,
sha1nodeconstants,
self._use_dirstate_v2,
)
return self._map
def p1(self): def p1(self):
try: try:
return self.git.head.peel().id.raw return self.git.head.peel().id.raw
except pygit2.GitError: except pygit2.GitError:
# Typically happens when peeling HEAD fails, as in an # Typically happens when peeling HEAD fails, as in an
# empty repository. # empty repository.
return sha1nodeconstants.nullid return sha1nodeconstants.nullid
[], [],
[], [],
[], [],
[], [],
[], [],
[], [],
[], [],
) )
try:
mtime_boundary = timestamp.get_fs_now(self._opener)
except OSError:
# In largefiles or readonly context
mtime_boundary = None
gstatus = self.git.status() gstatus = self.git.status()
for path, status in gstatus.items(): for path, status in gstatus.items():
path = pycompat.fsencode(path) path = pycompat.fsencode(path)
if not match(path): if not match(path):
continue continue
if status == pygit2.GIT_STATUS_IGNORED: if status == pygit2.GIT_STATUS_IGNORED:
if path.endswith(b'/'): if path.endswith(b'/'):
continue continue
clean.append(path) clean.append(path)
# TODO are we really always sure of status here? # TODO are we really always sure of status here?
return ( return (
False, False,
scmutil.status( scmutil.status(
modified, added, removed, deleted, unknown, ignored, clean modified, added, removed, deleted, unknown, ignored, clean
), ),
mtime_boundary,
) )
def flagfunc(self, buildfallback): def flagfunc(self, buildfallback):
# TODO we can do better # TODO we can do better
return buildfallback() return buildfallback()
def getcwd(self): def getcwd(self):
# TODO is this a good way to do this? # TODO is this a good way to do this?
return os.path.dirname( return os.path.dirname(
os.path.dirname(pycompat.fsencode(self.git.path)) os.path.dirname(pycompat.fsencode(self.git.path))
) )
def get_entry(self, path):
"""return a DirstateItem for the associated path"""
entry = self._map.get(path)
if entry is None:
return DirstateItem()
return entry
def normalize(self, path): def normalize(self, path):
normed = util.normcase(path) normed = util.normcase(path)
assert normed == path, b"TODO handling of case folding: %s != %s" % ( assert normed == path, b"TODO handling of case folding: %s != %s" % (
normed, normed,
path, path,
) )
return path return path