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))