mercurial: comparison mercurial/hg.py

equal deleted inserted replaced

-:fba26990604a
+:c15b4bc0a11c
 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 dup(self):
+def changes(self, files, ignore):
 self.read()
-return self.map.copy()
+dc = self.map.copy()
+lookup, changed, added, unknown = [], [], [], []
+# compare all files by default
+if not files: files = [self.root]
+def uniq(g):
+seen = {}
+for f in g:
+if f not in seen:
+seen[f] = 1
+yield f
+# recursive generator of all files listed
+def walk(files):
+for f in uniq(files):
+if os.path.isdir(f):
+for dir, subdirs, fl in os.walk(f):
+d = dir[len(self.root) + 1:]
+if ".hg" in subdirs: subdirs.remove(".hg")
+for fn in fl:
+fn = util.pconvert(os.path.join(d, fn))
+yield fn
+else:
+yield f[len(self.root) + 1:]
+for fn in uniq(walk(files)):
+try: s = os.stat(os.path.join(self.root, fn))
+except: continue
+if fn in dc:
+c = dc[fn]
+del dc[fn]
+if c[0] == 'm':
+changed.append(fn)
+elif c[0] == 'a':
+added.append(fn)
+elif c[0] == 'r':
+unknown.append(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)
+return (lookup, changed, added, dc.keys(), unknown)
 # used to avoid circular references so destructors work
 def opener(base):
 p = base
 def o(path, mode="r"):
 elif s == 'r':
 remove.append(f)
 else:
 self.ui.warn("%s not tracked!\n" % f)
 else:
-(c, a, d, u) = self.diffdir(self.root)
+(c, a, d, u) = self.changes(None, None)
 commit = c + a
 remove = d
 if not commit and not remove:
 self.ui.status("nothing changed\n")
 self.dirstate.setparents(n)
 self.dirstate.update(new, "n")
 self.dirstate.forget(remove)
-def diffdir(self, path, changeset = None):
+def changes(self, node1, node2, *files):
-changed = []
+# changed, added, deleted, unknown
-added = []
+c, a, d, u, mf1 = [], [], [], [], None
-unknown = []
-mf = {}
+def fcmp(fn, mf):
-if changeset:
-change = self.changelog.read(changeset)
-mf = self.manifest.read(change[0])
-dc = dict.fromkeys(mf)
-else:
-changeset = self.dirstate.parents()[0]
-change = self.changelog.read(changeset)
-mf = self.manifest.read(change[0])
-dc = self.dirstate.dup()
-def fcmp(fn):
 t1 = self.wfile(fn).read()
 t2 = self.file(fn).revision(mf[fn])
 return cmp(t1, t2)
-for dir, subdirs, files in os.walk(path):
+# are we comparing the working directory?
-d = dir[len(self.root)+1:]
+if not node1:
-if ".hg" in subdirs: subdirs.remove(".hg")
+l, c, a, d, u = self.dirstate.changes(files, self.ignore)
-for f in files:
+# are we comparing working dir against its parent?
-fn = util.pconvert(os.path.join(d, f))
+if not node2:
-try: s = os.stat(os.path.join(self.root, fn))
+if l:
-except: continue
+# do a full compare of any files that might have changed
-if fn in dc:
+change = self.changelog.read(self.dirstate.parents()[0])
-c = dc[fn]
+mf1 = self.manifest.read(change[0])
-del dc[fn]
+for f in lookup:
-if not c:
+if fcmp(f, mf):
-if fcmp(fn):
+c.append(f)
-changed.append(fn)
+return (c, a, d, u)
-elif c[0] == 'm':
-changed.append(fn)
+# are we comparing working dir against non-tip?
-elif c[0] == 'a':
+# generate a pseudo-manifest for the working dir
-added.append(fn)
+if not node1:
-elif c[0] == 'r':
+if not mf1:
-unknown.append(fn)
+change = self.changelog.read(self.dirstate.parents()[0])
-elif c[2] != s.st_size or (c[1] ^ s.st_mode) & 0100:
+mf1 = self.manifest.read(change[0])
-changed.append(fn)
+for f in a + c + l:
-elif c[1] != s.st_mode or c[3] != s.st_mtime:
+mf1[f] = ""
-if fcmp(fn):
+for f in d:
-changed.append(fn)
+if f in mf1: del mf1[f]
 else:
-if self.ignore(fn): continue
+change = self.changelog.read(node1)
-unknown.append(fn)
+mf1 = self.manifest.read(change[0])
-deleted = dc.keys()
-deleted.sort()
-return (changed, added, deleted, unknown)
-def diffrevs(self, node1, node2):
-changed, added = [], []
-change = self.changelog.read(node1)
-mf1 = self.manifest.read(change[0])
 change = self.changelog.read(node2)
 mf2 = self.manifest.read(change[0])
 for fn in mf2:
 if mf1.has_key(fn):
 if mf1[fn] != mf2[fn]:
-changed.append(fn)
+if mf1[fn] != "" or fcmp(fn, mf2):
+c.append(fn)
 del mf1[fn]
 else:
-added.append(fn)
+a.append(fn)
-deleted = mf1.keys()
+d = mf1.keys()
-deleted.sort()
+d.sort()
-return (changed, added, deleted)
+return (c, a, d, u)
 def add(self, list):
 for f in list:
 p = self.wjoin(f)
 if not os.path.isfile(p):
 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.diffdir(self.root)
+(c, a, d, u) = self.changes(None, None)
 # 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 536	c15b4bc0a11c
parent 529	aace5b681fe9
child 537	411e05b04ffa