mercurial-crew-with-dirclash: comparison mercurial/hg.py

equal deleted inserted replaced

-:574869103985
+:9e0f3ba4a9c2
 from revlog import *
 from demandload import *
 demandload(globals(), "re lock urllib urllib2 transaction time socket")
 demandload(globals(), "tempfile httprangereader bdiff")
 demandload(globals(), "bisect select")
+def always(fn):
+return True
 class filelog(revlog):
 def __init__(self, opener, path):
 revlog.__init__(self, opener,
 os.path.join("data", path + ".i"),
 self.dirty = 0
 self.ui = ui
 self.map = None
 self.pl = None
 self.copies = {}
+self.ignorefunc = None
+def wjoin(self, f):
+return os.path.join(self.root, f)
+def ignore(self, f):
+if not self.ignorefunc:
+bigpat = []
+try:
+l = file(self.wjoin(".hgignore"))
+for pat in l:
+if pat != "\n":
+p = util.pconvert(pat[:-1])
+try:
+r = re.compile(p)
+except:
+self.ui.warn("ignoring invalid ignore"
++ " regular expression '%s'\n" % p)
+else:
+bigpat.append(util.pconvert(pat[:-1]))
+except IOError: pass
+s = "(?:%s)" % (")|(?:".join(bigpat))
+r = re.compile(s)
+self.ignorefunc = r.search
+return self.ignorefunc(f)
 def __del__(self):
 if self.dirty:
 self.write()
 def parents(self):
 if not self.pl:
 self.read()
 return self.pl
+def markdirty(self):
+if not self.dirty:
+self.dirty = 1
 def setparents(self, p1, p2 = nullid):
-self.dirty = 1
+self.markdirty()
 self.pl = p1, p2
 def state(self, key):
 try:
 return self[key][0]
 self.map[f] = e[:4]
 pos += l
 def copy(self, source, dest):
 self.read()
-self.dirty = 1
+self.markdirty()
 self.copies[dest] = source
 def copied(self, file):
 return self.copies.get(file, None)
 r  marked for removal
 a  marked for addition'''
 if not files: return
 self.read()
-self.dirty = 1
+self.markdirty()
 for f in files:
 if state == "r":
 self.map[f] = ('r', 0, 0, 0)
 else:
 s = os.stat(os.path.join(self.root, f))
 self.map[f] = (state, s.st_mode, s.st_size, s.st_mtime)
 def forget(self, files):
 if not files: return
 self.read()
-self.dirty = 1
+self.markdirty()
 for f in files:
 try:
 del self.map[f]
 except KeyError:
 self.ui.warn("not in dirstate: %s!\n" % f)
 pass
 def clear(self):
 self.map = {}
-self.dirty = 1
+self.markdirty()
 def write(self):
 st = self.opener("dirstate", "w")
 st.write("".join(self.pl))
 for f, e in self.map.items():
 f = f + "\0" + c
 e = struct.pack(">cllll", e[0], e[1], e[2], e[3], len(f))
 st.write(e + f)
 self.dirty = 0
-def changes(self, files, ignore):
+def walk(self, files = None, match = always):
 self.read()
 dc = self.map.copy()
-lookup, changed, added, unknown = [], [], [], []
+# walk all files by default
-# compare all files by default
 if not files: files = [self.root]
+def traverse():
-# recursive generator of all files listed
-def walk(files):
 for f in util.unique(files):
 f = os.path.join(self.root, f)
 if os.path.isdir(f):
 for dir, subdirs, fl in os.walk(f):
 d = dir[len(self.root) + 1:]
+if d == '.hg':
+subdirs[:] = []
+continue
 for sd in subdirs:
-if ignore(os.path.join(d, sd +'/')):
+ds = os.path.join(d, sd +'/')
+if self.ignore(ds) or not match(ds):
 subdirs.remove(sd)
 for fn in fl:
 fn = util.pconvert(os.path.join(d, fn))
 yield fn
 else:
 yield f[len(self.root) + 1:]
 for k in dc.keys():
 yield k
-for fn in util.unique(walk(files)):
+# yield only files that match: all in dirstate, others only if
+# not in .hgignore
+for fn in util.unique(traverse()):
+if fn in dc:
+del dc[fn]
+elif self.ignore(fn):
+continue
+if match(fn):
+yield fn
+def changes(self, files = None, match = always):
+self.read()
+dc = self.map.copy()
+lookup, changed, added, unknown = [], [], [], []
+for fn in self.walk(files, match):
 try: s = os.stat(os.path.join(self.root, fn))
 except: continue
 if fn in dc:
 c = dc[fn]
 elif c[2] != s.st_size or (c[1] ^ s.st_mode) & 0100:
 changed.append(fn)
 elif c[1] != s.st_mode or c[3] != s.st_mtime:
 lookup.append(fn)
 else:
-if not ignore(fn): unknown.append(fn)
+if match(fn): unknown.append(fn)
 return (lookup, changed, added, dc.keys(), unknown)
 # used to avoid circular references so destructors work
 def opener(base):
 self.opener = opener(self.path)
 self.wopener = opener(self.root)
 self.manifest = manifest(self.opener)
 self.changelog = changelog(self.opener)
-self.ignorefunc = None
 self.tagscache = None
 self.nodetagscache = None
 if not self.remote:
 self.dirstate = dirstate(self.opener, ui, self.root)
 try:
 self.ui.readconfig(self.opener("hgrc"))
 except IOError: pass
-def ignore(self, f):
-if not self.ignorefunc:
-bigpat = ["^.hg/$"]
-try:
-l = file(self.wjoin(".hgignore"))
-for pat in l:
-if pat != "\n":
-p = util.pconvert(pat[:-1])
-try:
-r = re.compile(p)
-except:
-self.ui.warn("ignoring invalid ignore"
-+ " regular expression '%s'\n" % p)
-else:
-bigpat.append(util.pconvert(pat[:-1]))
-except IOError: pass
-s = "(?:%s)" % (")|(?:".join(bigpat))
-r = re.compile(s)
-self.ignorefunc = r.search
-return self.ignorefunc(f)
 def hook(self, name, **args):
 s = self.ui.config("hooks", name)
 if s:
 self.ui.note("running hook %s: %s\n" % (name, s))
 elif s == 'r':
 remove.append(f)
 else:
 self.ui.warn("%s not tracked!\n" % f)
 else:
-(c, a, d, u) = self.changes(None, None)
+(c, a, d, u) = self.changes()
 commit = c + a
 remove = d
 if not commit and not remove:
 self.ui.status("nothing changed\n")
 self.dirstate.forget(remove)
 if not self.hook("commit", node=hex(n)):
 return 1
-def changes(self, node1, node2, files=None):
+def walk(self, rev = None, files = [], match = always):
+if rev is None: fns = self.dirstate.walk(files, match)
+else: fns = filter(match, self.manifest.read(rev))
+for fn in fns: yield fn
+def changes(self, node1 = None, node2 = None, files = [], match = always):
 mf2, u = None, []
 def fcmp(fn, mf):
 t1 = self.wfile(fn).read()
 t2 = self.file(fn).revision(mf[fn])
 return cmp(t1, t2)
+def mfmatches(node):
+mf = dict(self.manifest.read(node))
+for fn in mf.keys():
+if not match(fn):
+del mf[fn]
+return mf
 # are we comparing the working directory?
 if not node2:
-l, c, a, d, u = self.dirstate.changes(files, self.ignore)
+l, c, a, d, u = self.dirstate.changes(files, match)
 # are we comparing working dir against its parent?
 if not node1:
 if l:
 # do a full compare of any files that might have changed
 change = self.changelog.read(self.dirstate.parents()[0])
-mf2 = self.manifest.read(change[0])
+mf2 = mfmatches(change[0])
 for f in l:
 if fcmp(f, mf2):
 c.append(f)
 for l in c, a, d, u:
 # are we comparing working dir against non-tip?
 # generate a pseudo-manifest for the working dir
 if not node2:
 if not mf2:
 change = self.changelog.read(self.dirstate.parents()[0])
-mf2 = self.manifest.read(change[0]).copy()
+mf2 = mfmatches(change[0])
 for f in a + c + l:
 mf2[f] = ""
 for f in d:
 if f in mf2: del mf2[f]
 else:
 change = self.changelog.read(node2)
-mf2 = self.manifest.read(change[0])
+mf2 = mfmatches(change[0])
 # flush lists from dirstate before comparing manifests
 c, a = [], []
 change = self.changelog.read(node1)
-mf1 = self.manifest.read(change[0]).copy()
+mf1 = mfmatches(change[0])
 for fn in mf2:
 if mf1.has_key(fn):
 if mf1[fn] != mf2[fn]:
 if mf2[fn] != "" or fcmp(fn, mf1):
 m2 = self.manifest.read(m2n)
 mf2 = self.manifest.readflags(m2n)
 ma = self.manifest.read(man)
 mfa = self.manifest.readflags(man)
-(c, a, d, u) = self.changes(None, None)
+(c, a, d, u) = self.changes()
 # is this a jump, or a merge?  i.e. is there a linear path
 # from p1 to p2?
 linear_path = (pa == p1 or pa == p2)

changeset 723	9e0f3ba4a9c2
parent 705	574869103985
child 724	1c0c413cccdd