def status(self, match, subrepos, ignored, clean, unknown):
# type: (matchmod.basematcher, List[str], List[str], List[str], List[str]) -> Tuple[List[str], scmutil.status]
'''Determine the status of the working copy relative to the
dirstate and return a pair of (unsure, status), where status is of type
scmutil.status and:
unsure:
files that might have been modified since the dirstate was
written, but need to be read to be sure (size is the same
but mtime differs)
status.modified:
files that have definitely been modified since the dirstate
was written (different size or mode)
status.clean:
files that have definitely not been modified since the
dirstate was written
'''
listignored, listclean, listunknown = ignored, clean, unknown
lookup, modified, added, unknown, ignored = [], [], [], [], []
removed, deleted, clean = [], [], []
madd = modified.append
aadd = added.append
uadd = unknown.append
iadd = ignored.append
radd = removed.append
dadd = deleted.append
cadd = clean.append
mexact = match.exact
map = {
pygit2.GIT_STATUS_INDEX_NEW:
added.append,
pygit2.GIT_STATUS_INDEX_NEW | pygit2.GIT_STATUS_WT_MODIFIED:
added.append,
pygit2.GIT_STATUS_WT_NEW:
unknown.append,
pygit2.GIT_STATUS_CURRENT:
clean.append,
pygit2.GIT_STATUS_IGNORED:
ignored.append,
pygit2.GIT_STATUS_INDEX_DELETED:
removed.append,
pygit2.GIT_STATUS_WT_DELETED:
deleted.append,
# FIXME: need to differentiate staged vs unstaged modified
pygit2.GIT_STATUS_WT_MODIFIED:
modified.append,
pygit2.GIT_STATUS_INDEX_MODIFIED:
modified.append,
}
statuses = self._repo._repo.status()
for path in sorted(statuses):
status = statuses[path]
map[status](path)
return (lookup,
scmutil.status(modified, added, removed, deleted, unknown,
ignored, clean))
def status(self, match, subrepos, ignored, clean, unknown):
# We should never have any files we are unsure about
unsure = []
edenstatus = self.eden_client.getStatus(ignored)
status = scmutil.status(edenstatus.modified, edenstatus.added,
edenstatus.removed, edenstatus.deleted,
edenstatus.unknown, edenstatus.ignored,
edenstatus.clean)
return (unsure, status)
def status(self, *args, **kwargs):
s = super(narrowrepository, self).status(*args, **kwargs)
narrowmatch = self.narrowmatch()
modified = list(filter(narrowmatch, s.modified))
added = list(filter(narrowmatch, s.added))
removed = list(filter(narrowmatch, s.removed))
deleted = list(filter(narrowmatch, s.deleted))
unknown = list(filter(narrowmatch, s.unknown))
ignored = list(filter(narrowmatch, s.ignored))
clean = list(filter(narrowmatch, s.clean))
return scmutil.status(modified, added, removed, deleted, unknown,
ignored, clean)
def _buildstatus(self, other, s, match, listignored, listclean,
listunknown):
# type: (basectx, scmutil.status, Callable, bool, bool, bool) -> scmutil.status
modified, added = [], []
removed = []
clean = []
deleted, unknown, ignored = s.deleted, s.unknown, s.ignored
d = self._repo._repo[self._node]
return scmutil.status(modified, added, removed, deleted, unknown,
ignored, clean)
def __init__(self, repo, name, parentctxs, added):
opts = {
'changes': scmutil.status([], list(added), [], [], [], [], []),
'date': b'0 0',
'extra': {
b'branch': b'default'
},
}
super(simplecommitctx, self).__init__(repo, name, **opts)
self._added = added
self._parents = parentctxs
while len(self._parents) < 2:
self._parents.append(repo[node.nullid])
def _buildstatus(orig, self, other, s, match, listignored, listclean,
listunknown):
s = orig(self, other, s, match, listignored, listclean,
listunknown)
if not listunknown:
return s
unknown = s[4]
results = set()
knowndirs = set(['']) # root is always known
for path in self:
d = os.path.dirname(path)
while d not in knowndirs:
knowndirs.add(d)
d = os.path.dirname(d)
for path in unknown:
prev = path
d = os.path.dirname(prev)
while d not in knowndirs:
prev = d
d = os.path.dirname(prev)
if prev != path:
results.add(prev + '/')
else:
results.add(path)
try:
was_status = isinstance(s, scmutil.status)
except AttributeError:
was_status = False
s = list(s)
s[4] = list(results)
return scmutil.status(*s) if was_status else s
def status(self,
node1='.',
node2=None,
match=None,
ignored=False,
clean=False,
unknown=False,
listsubrepos=False):
listignored, listclean, listunknown = ignored, clean, unknown
orig = super(lfilesrepo, self).status
if not self.lfstatus:
return orig(node1, node2, match, listignored, listclean,
listunknown, listsubrepos)
# some calls in this function rely on the old version of status
self.lfstatus = False
ctx1 = self[node1]
ctx2 = self[node2]
working = ctx2.rev() is None
parentworking = working and ctx1 == self['.']
if match is None:
match = matchmod.always(self.root, self.getcwd())
wlock = None
try:
try:
# updating the dirstate is optional
# so we don't wait on the lock
wlock = self.wlock(False)
except error.LockError:
pass
# First check if paths or patterns were specified on the
# command line. If there were, and they don't match any
# largefiles, we should just bail here and let super
# handle it -- thus gaining a big performance boost.
lfdirstate = lfutil.openlfdirstate(ui, self)
if not match.always():
for f in lfdirstate:
if match(f):
break
else:
return orig(node1, node2, match, listignored,
listclean, listunknown, listsubrepos)
# Create a copy of match that matches standins instead
# of largefiles.
def tostandins(files):
if not working:
return files
newfiles = []
dirstate = self.dirstate
for f in files:
sf = lfutil.standin(f)
if sf in dirstate:
newfiles.append(sf)
elif sf in dirstate.dirs():
# Directory entries could be regular or
# standin, check both
newfiles.extend((f, sf))
else:
newfiles.append(f)
return newfiles
m = copy.copy(match)
m._files = tostandins(m._files)
result = orig(node1, node2, m, ignored, clean, unknown,
listsubrepos)
if working:
def sfindirstate(f):
sf = lfutil.standin(f)
dirstate = self.dirstate
return sf in dirstate or sf in dirstate.dirs()
match._files = [f for f in match._files if sfindirstate(f)]
# Don't waste time getting the ignored and unknown
# files from lfdirstate
unsure, s = lfdirstate.status(match, [], False, listclean,
False)
(modified, added, removed, deleted,
clean) = (s.modified, s.added, s.removed, s.deleted,
s.clean)
if parentworking:
for lfile in unsure:
standin = lfutil.standin(lfile)
if standin not in ctx1:
# from second parent
modified.append(lfile)
elif ctx1[standin].data().strip() \
!= lfutil.hashfile(self.wjoin(lfile)):
modified.append(lfile)
else:
if listclean:
clean.append(lfile)
lfdirstate.normal(lfile)
else:
tocheck = unsure + modified + added + clean
modified, added, clean = [], [], []
checkexec = self.dirstate._checkexec
for lfile in tocheck:
standin = lfutil.standin(lfile)
if standin in ctx1:
abslfile = self.wjoin(lfile)
if ((ctx1[standin].data().strip() !=
lfutil.hashfile(abslfile)) or
(checkexec and ('x' in ctx1.flags(standin))
!= bool(lfutil.getexecutable(abslfile)))):
modified.append(lfile)
elif listclean:
clean.append(lfile)
else:
added.append(lfile)
# at this point, 'removed' contains largefiles
# marked as 'R' in the working context.
# then, largefiles not managed also in the target
# context should be excluded from 'removed'.
removed = [
lfile for lfile in removed
if lfutil.standin(lfile) in ctx1
]
# Standins no longer found in lfdirstate have been deleted
for standin in ctx1.walk(lfutil.getstandinmatcher(self)):
lfile = lfutil.splitstandin(standin)
if not match(lfile):
continue
if lfile not in lfdirstate:
deleted.append(lfile)
# Sync "largefile has been removed" back to the
# standin. Removing a file as a side effect of
# running status is gross, but the alternatives (if
# any) are worse.
self.wvfs.unlinkpath(standin, ignoremissing=True)
# Filter result lists
result = list(result)
# Largefiles are not really removed when they're
# still in the normal dirstate. Likewise, normal
# files are not really removed if they are still in
# lfdirstate. This happens in merges where files
# change type.
removed = [f for f in removed if f not in self.dirstate]
result[2] = [f for f in result[2] if f not in lfdirstate]
lfiles = set(lfdirstate._map)
# Unknown files
result[4] = set(result[4]).difference(lfiles)
# Ignored files
result[5] = set(result[5]).difference(lfiles)
# combine normal files and largefiles
normals = [[
fn for fn in filelist if not lfutil.isstandin(fn)
] for filelist in result]
lfstatus = (modified, added, removed, deleted, [], [],
clean)
result = [
sorted(list1 + list2)
for (list1, list2) in zip(normals, lfstatus)
]
else: # not against working directory
result = [[lfutil.splitstandin(f) or f for f in items]
for items in result]
if wlock:
lfdirstate.write()
finally:
if wlock:
wlock.release()
self.lfstatus = True
return scmutil.status(*result)
print('wctx._status=%s' % (str(wctx._status)))
print(
actx2.status(other=wctx,
match=scmutil.matchfiles(repo, [b'bar-m', b'foo'])))
print('wctx._status=%s' % (str(wctx._status)))
print('=== with "always match" and "listclean=True":')
print(actx1.status(other=wctx, listclean=True))
print('wctx._status=%s' % (str(wctx._status)))
print(actx2.status(other=wctx, listclean=True))
print('wctx._status=%s' % (str(wctx._status)))
print("== checking workingcommitctx.status:")
wcctx = context.workingcommitctx(repo,
scmutil.status([b'bar-m'], [b'bar-a'], [], [],
[], [], []),
text=b'',
date=b'0 0')
print('wcctx._status=%s' % (str(wcctx._status)))
print('=== with "always match":')
print(actx1.status(other=wcctx))
print('wcctx._status=%s' % (str(wcctx._status)))
print(actx2.status(other=wcctx))
print('wcctx._status=%s' % (str(wcctx._status)))
print('=== with "always match" and "listclean=True":')
print(actx1.status(other=wcctx, listclean=True))
print('wcctx._status=%s' % (str(wcctx._status)))
print(actx2.status(other=wcctx, listclean=True))
print('wcctx._status=%s' % (str(wcctx._status)))
def status(self, node1='.', node2=None, match=None, ignored=False,
clean=False, unknown=False, listsubrepos=False):
listignored, listclean, listunknown = ignored, clean, unknown
orig = super(lfilesrepo, self).status
if not self.lfstatus:
return orig(node1, node2, match, listignored, listclean,
listunknown, listsubrepos)
# some calls in this function rely on the old version of status
self.lfstatus = False
ctx1 = self[node1]
ctx2 = self[node2]
working = ctx2.rev() is None
parentworking = working and ctx1 == self['.']
if match is None:
match = match_.always(self.root, self.getcwd())
wlock = None
try:
try:
# updating the dirstate is optional
# so we don't wait on the lock
wlock = self.wlock(False)
except error.LockError:
pass
# First check if paths or patterns were specified on the
# command line. If there were, and they don't match any
# largefiles, we should just bail here and let super
# handle it -- thus gaining a big performance boost.
lfdirstate = lfutil.openlfdirstate(ui, self)
if not match.always():
for f in lfdirstate:
if match(f):
break
else:
return orig(node1, node2, match, listignored, listclean,
listunknown, listsubrepos)
# Create a copy of match that matches standins instead
# of largefiles.
def tostandins(files):
if not working:
return files
newfiles = []
dirstate = self.dirstate
for f in files:
sf = lfutil.standin(f)
if sf in dirstate:
newfiles.append(sf)
elif sf in dirstate.dirs():
# Directory entries could be regular or
# standin, check both
newfiles.extend((f, sf))
else:
newfiles.append(f)
return newfiles
m = copy.copy(match)
m._files = tostandins(m._files)
result = orig(node1, node2, m, ignored, clean, unknown,
listsubrepos)
if working:
def sfindirstate(f):
sf = lfutil.standin(f)
dirstate = self.dirstate
return sf in dirstate or sf in dirstate.dirs()
match._files = [f for f in match._files
if sfindirstate(f)]
# Don't waste time getting the ignored and unknown
# files from lfdirstate
unsure, s = lfdirstate.status(match, [], False, listclean,
False)
(modified, added, removed, clean) = (s.modified, s.added,
s.removed, s.clean)
if parentworking:
for lfile in unsure:
standin = lfutil.standin(lfile)
if standin not in ctx1:
# from second parent
modified.append(lfile)
elif ctx1[standin].data().strip() \
!= lfutil.hashfile(self.wjoin(lfile)):
modified.append(lfile)
else:
if listclean:
clean.append(lfile)
lfdirstate.normal(lfile)
else:
tocheck = unsure + modified + added + clean
modified, added, clean = [], [], []
checkexec = self.dirstate._checkexec
for lfile in tocheck:
standin = lfutil.standin(lfile)
if standin in ctx1:
abslfile = self.wjoin(lfile)
if ((ctx1[standin].data().strip() !=
lfutil.hashfile(abslfile)) or
(checkexec and
('x' in ctx1.flags(standin)) !=
bool(lfutil.getexecutable(abslfile)))):
modified.append(lfile)
elif listclean:
clean.append(lfile)
else:
added.append(lfile)
# at this point, 'removed' contains largefiles
# marked as 'R' in the working context.
# then, largefiles not managed also in the target
# context should be excluded from 'removed'.
removed = [lfile for lfile in removed
if lfutil.standin(lfile) in ctx1]
# Standins no longer found in lfdirstate has been
# removed
for standin in ctx1.walk(lfutil.getstandinmatcher(self)):
lfile = lfutil.splitstandin(standin)
if not match(lfile):
continue
if lfile not in lfdirstate:
removed.append(lfile)
# Filter result lists
result = list(result)
# Largefiles are not really removed when they're
# still in the normal dirstate. Likewise, normal
# files are not really removed if they are still in
# lfdirstate. This happens in merges where files
# change type.
removed = [f for f in removed
if f not in self.dirstate]
result[2] = [f for f in result[2]
if f not in lfdirstate]
lfiles = set(lfdirstate._map)
# Unknown files
result[4] = set(result[4]).difference(lfiles)
# Ignored files
result[5] = set(result[5]).difference(lfiles)
# combine normal files and largefiles
normals = [[fn for fn in filelist
if not lfutil.isstandin(fn)]
for filelist in result]
lfstatus = (modified, added, removed, s.deleted, [], [],
clean)
result = [sorted(list1 + list2)
for (list1, list2) in zip(normals, lfstatus)]
else: # not against working directory
result = [[lfutil.splitstandin(f) or f for f in items]
for items in result]
if wlock:
lfdirstate.write()
finally:
if wlock:
wlock.release()
self.lfstatus = True
return scmutil.status(*result)
match=scmutil.matchfiles(repo, ['bar-m', 'foo']))
print 'wctx._status=%s' % (str(wctx._status))
print actx2.status(other=wctx,
match=scmutil.matchfiles(repo, ['bar-m', 'foo']))
print 'wctx._status=%s' % (str(wctx._status))
print '=== with "always match" and "listclean=True":'
print actx1.status(other=wctx, listclean=True)
print 'wctx._status=%s' % (str(wctx._status))
print actx2.status(other=wctx, listclean=True)
print 'wctx._status=%s' % (str(wctx._status))
print "== checking workingcommitctx.status:"
wcctx = context.workingcommitctx(repo,
scmutil.status(['bar-m'], ['bar-a'], [], [],
[], [], []),
text='',
date='0 0')
print 'wcctx._status=%s' % (str(wcctx._status))
print '=== with "always match":'
print actx1.status(other=wcctx)
print 'wcctx._status=%s' % (str(wcctx._status))
print actx2.status(other=wcctx)
print 'wcctx._status=%s' % (str(wcctx._status))
print '=== with "always match" and "listclean=True":'
print actx1.status(other=wcctx, listclean=True)
print 'wcctx._status=%s' % (str(wcctx._status))
print actx2.status(other=wcctx, listclean=True)
print 'wcctx._status=%s' % (str(wcctx._status))
def overridestatus(
orig, self, node1=".", node2=None, match=None, ignored=False, clean=False, unknown=False, listsubrepos=False
):
listignored = ignored
listclean = clean
listunknown = unknown
def _cmpsets(l1, l2):
try:
if "FSMONITOR_LOG_FILE" in os.environ:
fn = os.environ["FSMONITOR_LOG_FILE"]
f = open(fn, "wb")
else:
fn = "fsmonitorfail.log"
f = self.opener(fn, "wb")
except (IOError, OSError):
self.ui.warn(_("warning: unable to write to %s\n") % fn)
return
try:
for i, (s1, s2) in enumerate(zip(l1, l2)):
if set(s1) != set(s2):
f.write("sets at position %d are unequal\n" % i)
f.write("watchman returned: %s\n" % s1)
f.write("stat returned: %s\n" % s2)
finally:
f.close()
if isinstance(node1, context.changectx):
ctx1 = node1
else:
ctx1 = self[node1]
if isinstance(node2, context.changectx):
ctx2 = node2
else:
ctx2 = self[node2]
working = ctx2.rev() is None
parentworking = working and ctx1 == self["."]
match = match or matchmod.always(self.root, self.getcwd())
# Maybe we can use this opportunity to update Watchman's state.
# Mercurial uses workingcommitctx and/or memctx to represent the part of
# the workingctx that is to be committed. So don't update the state in
# that case.
# HG_PENDING is set in the environment when the dirstate is being updated
# in the middle of a transaction; we must not update our state in that
# case, or we risk forgetting about changes in the working copy.
updatestate = (
parentworking
and match.always()
and not isinstance(ctx2, (context.workingcommitctx, context.memctx))
and "HG_PENDING" not in os.environ
)
try:
if self._fsmonitorstate.walk_on_invalidate:
# Use a short timeout to query the current clock. If that
# takes too long then we assume that the service will be slow
# to answer our query.
# walk_on_invalidate indicates that we prefer to walk the
# tree ourselves because we can ignore portions that Watchman
# cannot and we tend to be faster in the warmer buffer cache
# cases.
self._watchmanclient.settimeout(0.1)
else:
# Give Watchman more time to potentially complete its walk
# and return the initial clock. In this mode we assume that
# the filesystem will be slower than parsing a potentially
# very large Watchman result set.
self._watchmanclient.settimeout(self._fsmonitorstate.timeout + 0.1)
startclock = self._watchmanclient.getcurrentclock()
except Exception as ex:
self._watchmanclient.clearconnection()
_handleunavailable(self.ui, self._fsmonitorstate, ex)
# boo, Watchman failed. bail
return orig(node1, node2, match, listignored, listclean, listunknown, listsubrepos)
if updatestate:
# We need info about unknown files. This may make things slower the
# first time, but whatever.
stateunknown = True
else:
stateunknown = listunknown
r = orig(node1, node2, match, listignored, listclean, stateunknown, listsubrepos)
modified, added, removed, deleted, unknown, ignored, clean = r
if updatestate:
notefiles = modified + added + removed + deleted + unknown
self._fsmonitorstate.set(
self._fsmonitorstate.getlastclock() or startclock, _hashignore(self.dirstate._ignore), notefiles
)
if not listunknown:
unknown = []
# don't do paranoid checks if we're not going to query Watchman anyway
full = listclean or match.traversedir is not None
if self._fsmonitorstate.mode == "paranoid" and not full:
# run status again and fall back to the old walk this time
self.dirstate._fsmonitordisable = True
# shut the UI up
quiet = self.ui.quiet
self.ui.quiet = True
fout, ferr = self.ui.fout, self.ui.ferr
self.ui.fout = self.ui.ferr = open(os.devnull, "wb")
try:
rv2 = orig(node1, node2, match, listignored, listclean, listunknown, listsubrepos)
finally:
self.dirstate._fsmonitordisable = False
self.ui.quiet = quiet
self.ui.fout, self.ui.ferr = fout, ferr
# clean isn't tested since it's set to True above
_cmpsets([modified, added, removed, deleted, unknown, ignored, clean], rv2)
modified, added, removed, deleted, unknown, ignored, clean = rv2
return scmutil.status(modified, added, removed, deleted, unknown, ignored, clean)
def overridestatus(
orig, self, node1='.', node2=None, match=None, ignored=False,
clean=False, unknown=False, listsubrepos=False):
listignored = ignored
listclean = clean
listunknown = unknown
def _cmpsets(l1, l2):
try:
if 'FSMONITOR_LOG_FILE' in os.environ:
fn = os.environ['FSMONITOR_LOG_FILE']
f = open(fn, 'wb')
else:
fn = 'fsmonitorfail.log'
f = self.opener(fn, 'wb')
except (IOError, OSError):
self.ui.warn(_('warning: unable to write to %s\n') % fn)
return
try:
for i, (s1, s2) in enumerate(zip(l1, l2)):
if set(s1) != set(s2):
f.write('sets at position %d are unequal\n' % i)
f.write('watchman returned: %s\n' % s1)
f.write('stat returned: %s\n' % s2)
finally:
f.close()
if isinstance(node1, context.changectx):
ctx1 = node1
else:
ctx1 = self[node1]
if isinstance(node2, context.changectx):
ctx2 = node2
else:
ctx2 = self[node2]
working = ctx2.rev() is None
parentworking = working and ctx1 == self['.']
match = match or matchmod.always(self.root, self.getcwd())
# Maybe we can use this opportunity to update Watchman's state.
# Mercurial uses workingcommitctx and/or memctx to represent the part of
# the workingctx that is to be committed. So don't update the state in
# that case.
# HG_PENDING is set in the environment when the dirstate is being updated
# in the middle of a transaction; we must not update our state in that
# case, or we risk forgetting about changes in the working copy.
updatestate = (parentworking and match.always() and
not isinstance(ctx2, (context.workingcommitctx,
context.memctx)) and
'HG_PENDING' not in os.environ)
try:
if self._fsmonitorstate.walk_on_invalidate:
# Use a short timeout to query the current clock. If that
# takes too long then we assume that the service will be slow
# to answer our query.
# walk_on_invalidate indicates that we prefer to walk the
# tree ourselves because we can ignore portions that Watchman
# cannot and we tend to be faster in the warmer buffer cache
# cases.
self._watchmanclient.settimeout(0.1)
else:
# Give Watchman more time to potentially complete its walk
# and return the initial clock. In this mode we assume that
# the filesystem will be slower than parsing a potentially
# very large Watchman result set.
self._watchmanclient.settimeout(
self._fsmonitorstate.timeout + 0.1)
startclock = self._watchmanclient.getcurrentclock()
except Exception as ex:
self._watchmanclient.clearconnection()
_handleunavailable(self.ui, self._fsmonitorstate, ex)
# boo, Watchman failed. bail
return orig(node1, node2, match, listignored, listclean,
listunknown, listsubrepos)
if updatestate:
# We need info about unknown files. This may make things slower the
# first time, but whatever.
stateunknown = True
else:
stateunknown = listunknown
r = orig(node1, node2, match, listignored, listclean, stateunknown,
listsubrepos)
modified, added, removed, deleted, unknown, ignored, clean = r
if updatestate:
notefiles = modified + added + removed + deleted + unknown
self._fsmonitorstate.set(
self._fsmonitorstate.getlastclock() or startclock,
_hashignore(self.dirstate._ignore),
notefiles)
if not listunknown:
unknown = []
# don't do paranoid checks if we're not going to query Watchman anyway
full = listclean or match.traversedir is not None
if self._fsmonitorstate.mode == 'paranoid' and not full:
# run status again and fall back to the old walk this time
self.dirstate._fsmonitordisable = True
# shut the UI up
quiet = self.ui.quiet
self.ui.quiet = True
fout, ferr = self.ui.fout, self.ui.ferr
self.ui.fout = self.ui.ferr = open(os.devnull, 'wb')
try:
rv2 = orig(
node1, node2, match, listignored, listclean, listunknown,
listsubrepos)
finally:
self.dirstate._fsmonitordisable = False
self.ui.quiet = quiet
self.ui.fout, self.ui.ferr = fout, ferr
# clean isn't tested since it's set to True above
_cmpsets([modified, added, removed, deleted, unknown, ignored, clean],
rv2)
modified, added, removed, deleted, unknown, ignored, clean = rv2
return scmutil.status(
modified, added, removed, deleted, unknown, ignored, clean)
def status(self, match, subrepos, ignored, clean, unknown):
listclean = clean
# TODO handling of clean files - can we get that from git.status()?
modified, added, removed, deleted, unknown, ignored, clean = (
[],
[],
[],
[],
[],
[],
[],
)
gstatus = self.git.status()
for path, status in gstatus.items():
path = pycompat.fsencode(path)
if not match(path):
continue
if status == pygit2.GIT_STATUS_IGNORED:
if path.endswith(b'/'):
continue
ignored.append(path)
elif status in (
pygit2.GIT_STATUS_WT_MODIFIED,
pygit2.GIT_STATUS_INDEX_MODIFIED,
pygit2.GIT_STATUS_WT_MODIFIED
| pygit2.GIT_STATUS_INDEX_MODIFIED,
):
modified.append(path)
elif status == pygit2.GIT_STATUS_INDEX_NEW:
added.append(path)
elif status == pygit2.GIT_STATUS_WT_NEW:
unknown.append(path)
elif status == pygit2.GIT_STATUS_WT_DELETED:
deleted.append(path)
elif status == pygit2.GIT_STATUS_INDEX_DELETED:
removed.append(path)
else:
raise error.Abort(b'unhandled case: status for %r is %r' %
(path, status))
if listclean:
observed = set(modified + added + removed + deleted + unknown +
ignored)
index = self.git.index
index.read()
for entry in index:
path = pycompat.fsencode(entry.path)
if not match(path):
continue
if path in observed:
continue # already in some other set
if path[-1] == b'/':
continue # directory
clean.append(path)
# TODO are we really always sure of status here?
return (
False,
scmutil.status(modified, added, removed, deleted, unknown, ignored,
clean),
)
def deserialize(string):
ll = json.loads(string)
ls = []
for l in ll:
ls.append([f.decode('base64') for f in l])
return status(*ls)
print 'wctx._status=%s' % (str(wctx._status))
print actx2.status(other=wctx,
match=scmutil.matchfiles(repo, ['bar-m', 'foo']))
print 'wctx._status=%s' % (str(wctx._status))
print '=== with "always match" and "listclean=True":'
print actx1.status(other=wctx, listclean=True)
print 'wctx._status=%s' % (str(wctx._status))
print actx2.status(other=wctx, listclean=True)
print 'wctx._status=%s' % (str(wctx._status))
print "== checking workingcommitctx.status:"
wcctx = context.workingcommitctx(repo,
scmutil.status(['bar-m'],
['bar-a'],
[],
[], [], [], []),
text='', date='0 0')
print 'wcctx._status=%s' % (str(wcctx._status))
print '=== with "always match":'
print actx1.status(other=wcctx)
print 'wcctx._status=%s' % (str(wcctx._status))
print actx2.status(other=wcctx)
print 'wcctx._status=%s' % (str(wcctx._status))
print '=== with "always match" and "listclean=True":'
print actx1.status(other=wcctx, listclean=True)
print 'wcctx._status=%s' % (str(wcctx._status))
print actx2.status(other=wcctx, listclean=True)
print 'wcctx._status=%s' % (str(wcctx._status))
