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

comparison mercurial/localrepo.py @ 3044:fcadf7a32425

Merge with mpm

author	Josef "Jeff" Sipek <jeffpc@josefsipek.net>
date	Sun, 03 Sep 2006 06:06:02 -0400
parents	eef469259745
children	aebc3f64b20f

comparison

equal deleted inserted replaced

-:2a4d4aecb2b4
+:fcadf7a32425
 # localrepo.py - read/write repository class for mercurial
 #
-# Copyright 2005 Matt Mackall <mpm@selenic.com>
+# Copyright 2005, 2006 Matt Mackall <mpm@selenic.com>
 #
 # This software may be used and distributed according to the terms
 # of the GNU General Public License, incorporated herein by reference.
 from node import *
 r = runhook(hname, cmd) or r
 return r
 tag_disallowed = ':\r\n'
-def tag(self, name, node, local=False, message=None, user=None, date=None):
+def tag(self, name, node, message, local, user, date):
 '''tag a revision with a symbolic name.
 if local is True, the tag is stored in a per-repository file.
 otherwise, it is stored in the .hgtags file, and a new
 changeset is committed with the change.
 for c in self.tag_disallowed:
 if c in name:
 raise util.Abort(_('%r cannot be used in a tag name') % c)
-self.hook('pretag', throw=True, node=node, tag=name, local=local)
+self.hook('pretag', throw=True, node=hex(node), tag=name, local=local)
 if local:
-self.opener('localtags', 'a').write('%s %s\n' % (node, name))
+self.opener('localtags', 'a').write('%s %s\n' % (hex(node), name))
-self.hook('tag', node=node, tag=name, local=local)
+self.hook('tag', node=hex(node), tag=name, local=local)
 return
-for x in self.changes():
+for x in self.status()[:5]:
 if '.hgtags' in x:
 raise util.Abort(_('working copy of .hgtags is changed '
 '(please commit .hgtags manually)'))
-self.wfile('.hgtags', 'ab').write('%s %s\n' % (node, name))
+self.wfile('.hgtags', 'ab').write('%s %s\n' % (hex(node), name))
 if self.dirstate.state('.hgtags') == '?':
 self.add(['.hgtags'])
-if not message:
-message = _('Added tag %s for changeset %s') % (name, node)
 self.commit(['.hgtags'], message, user, date)
-self.hook('tag', node=node, tag=name, local=local)
+self.hook('tag', node=hex(node), tag=name, local=local)
 def tags(self):
 '''return a mapping of tag to node'''
 if not self.tagscache:
 self.tagscache = {}
 def lookup(self, key):
 try:
 return self.tags()[key]
 except KeyError:
+if key == '.':
+key = self.dirstate.parents()[0]
+if key == nullid:
+raise repo.RepoError(_("no revision checked out"))
 try:
 return self.changelog.lookup(key)
 except:
 raise repo.RepoError(_("unknown revision '%s'") % key)
 orig_parent = self.dirstate.parents()[0] or nullid
 p1 = p1 or self.dirstate.parents()[0] or nullid
 p2 = p2 or self.dirstate.parents()[1] or nullid
 c1 = self.changelog.read(p1)
 c2 = self.changelog.read(p2)
-m1 = self.manifest.read(c1[0])
+m1 = self.manifest.read(c1[0]).copy()
-mf1 = self.manifest.readflags(c1[0])
 m2 = self.manifest.read(c2[0])
 changed = []
 if orig_parent == p1:
 update_dirstate = 1
 if not wlock:
 wlock = self.wlock()
 l = self.lock()
 tr = self.transaction()
-mm = m1.copy()
-mfm = mf1.copy()
 linkrev = self.changelog.count()
 for f in files:
 try:
 t = self.wread(f)
-tm = util.is_exec(self.wjoin(f), mfm.get(f, False))
+m1.set(f, util.is_exec(self.wjoin(f), m1.execf(f)))
 r = self.file(f)
-mfm[f] = tm
 (entry, fp1, fp2) = self.checkfilemerge(f, t, r, m1, m2)
 if entry:
-mm[f] = entry
+m1[f] = entry
 continue
-mm[f] = r.add(t, {}, tr, linkrev, fp1, fp2)
+m1[f] = r.add(t, {}, tr, linkrev, fp1, fp2)
 changed.append(f)
 if update_dirstate:
 self.dirstate.update([f], "n")
 except IOError:
 try:
-del mm[f]
+del m1[f]
-del mfm[f]
 if update_dirstate:
 self.dirstate.forget([f])
 except:
 # deleted from p2?
 pass
-mnode = self.manifest.add(mm, mfm, tr, linkrev, c1[0], c2[0])
+mnode = self.manifest.add(m1, tr, linkrev, c1[0], c2[0])
 user = user or self.ui.username()
 n = self.changelog.add(mnode, changed, text, tr, p1, p2, user, date)
 tr.close()
 if update_dirstate:
 self.dirstate.setparents(n, nullid)
 elif s == 'r':
 remove.append(f)
 else:
 self.ui.warn(_("%s not tracked!\n") % f)
 else:
-modified, added, removed, deleted, unknown = self.changes(match=match)
+modified, added, removed, deleted, unknown = self.status(match=match)[:5]
 commit = modified + added
 remove = removed
 p1, p2 = self.dirstate.parents()
 c1 = self.changelog.read(p1)
 c2 = self.changelog.read(p2)
-m1 = self.manifest.read(c1[0])
+m1 = self.manifest.read(c1[0]).copy()
-mf1 = self.manifest.readflags(c1[0])
 m2 = self.manifest.read(c2[0])
 if not commit and not remove and not force and p2 == nullid:
 self.ui.status(_("nothing changed\n"))
 return None
 linkrev = self.changelog.count()
 commit.sort()
 for f in commit:
 self.ui.note(f + "\n")
 try:
-mf1[f] = util.is_exec(self.wjoin(f), mf1.get(f, False))
+m1.set(f, util.is_exec(self.wjoin(f), m1.execf(f)))
 t = self.wread(f)
 except IOError:
 self.ui.warn(_("trouble committing %s!\n") % f)
 raise
 # remember what we've added so that we can later calculate
 # the files to pull from a set of changesets
 changed.append(f)
 # update manifest
-m1 = m1.copy()
 m1.update(new)
 for f in remove:
 if f in m1:
 del m1[f]
-mn = self.manifest.add(m1, mf1, tr, linkrev, c1[0], c2[0],
+mn = self.manifest.add(m1, tr, linkrev, c1[0], c2[0],
 (new, remove))
 # add changeset
 new = new.keys()
 new.sort()
 If node2 is None, compare node1 with working directory.
 """
 def fcmp(fn, mf):
 t1 = self.wread(fn)
-t2 = self.file(fn).read(mf.get(fn, nullid))
+return self.file(fn).cmp(mf.get(fn, nullid), t1)
-return cmp(t1, t2)
 def mfmatches(node):
 change = self.changelog.read(node)
 mf = dict(self.manifest.read(change[0]))
 for fn in mf.keys():
 # do a full compare of any files that might have changed
 mf2 = mfmatches(self.dirstate.parents()[0])
 for f in lookup:
 if fcmp(f, mf2):
 modified.append(f)
-elif wlock is not None:
+else:
-self.dirstate.update([f], "n")
+clean.append(f)
+if wlock is not None:
+self.dirstate.update([f], "n")
 else:
 # we are comparing working dir against non-parent
 # generate a pseudo-manifest for the working dir
 mf2 = mfmatches(self.dirstate.parents()[0])
 for f in lookup + modified + added:
 # sort and return results:
 for l in modified, added, removed, deleted, unknown, ignored, clean:
 l.sort()
 return (modified, added, removed, deleted, unknown, ignored, clean)
-def changes(self, node1=None, node2=None, files=[], match=util.always,
-wlock=None, list_ignored=False, list_clean=False):
-'''DEPRECATED - use status instead'''
-marduit = self.status(node1, node2, files, match, wlock,
-list_ignored, list_clean)
-if list_ignored:
-return marduit[:-1]
-else:
-return marduit[:-2]
 def add(self, list, wlock=None):
 if not wlock:
 wlock = self.wlock()
 for f in list:
 self.dirstate.update([f], "r")
 def undelete(self, list, wlock=None):
 p = self.dirstate.parents()[0]
 mn = self.changelog.read(p)[0]
-mf = self.manifest.readflags(mn)
 m = self.manifest.read(mn)
 if not wlock:
 wlock = self.wlock()
 for f in list:
 if self.dirstate.state(f) not in  "r":
 self.ui.warn("%s not removed!\n" % f)
 else:
 t = self.file(f).read(m[f])
 self.wwrite(f, t)
-util.set_exec(self.wjoin(f), mf[f])
+util.set_exec(self.wjoin(f), m.execf(f))
 self.dirstate.update([f], "n")
 def copy(self, source, dest, wlock=None):
 p = self.wjoin(dest)
 if not os.path.exists(p):
 if force:
 self.ui.warn(_("warning: repository is unrelated\n"))
 else:
 raise util.Abort(_("repository is unrelated"))
-self.ui.note(_("found new changesets starting at ") +
+self.ui.debug(_("found new changesets starting at ") +
 " ".join([short(f) for f in fetch]) + "\n")
 self.ui.debug(_("%d total queries\n") % reqcnt)
 return fetch.keys()
 if heads:
 return subset, updated_heads.keys()
 else:
 return subset
-def pull(self, remote, heads=None, force=False):
+def pull(self, remote, heads=None, force=False, lock=None):
-l = self.lock()
+mylock = False
+if not lock:
-fetch = self.findincoming(remote, force=force)
+lock = self.lock()
-if fetch == [nullid]:
+mylock = True
-self.ui.status(_("requesting all changes\n"))
+try:
-if not fetch:
+fetch = self.findincoming(remote, force=force)
-self.ui.status(_("no changes found\n"))
+if fetch == [nullid]:
-return 0
+self.ui.status(_("requesting all changes\n"))
-if heads is None:
+if not fetch:
-cg = remote.changegroup(fetch, 'pull')
+self.ui.status(_("no changes found\n"))
-else:
+return 0
-cg = remote.changegroupsubset(fetch, heads, 'pull')
-return self.addchangegroup(cg, 'pull', remote.url())
+if heads is None:
+cg = remote.changegroup(fetch, 'pull')
+else:
+cg = remote.changegroupsubset(fetch, heads, 'pull')
+return self.addchangegroup(cg, 'pull', remote.url())
+finally:
+if mylock:
+lock.release()
 def push(self, remote, force=False, revs=None):
 # there are two ways to push to remote repo:
 #
 # addchangegroup assumes local user can lock remote
 self.hook("incoming", node=hex(self.changelog.node(i)),
 source=srctype, url=url)
 return newheads - oldheads + 1
-def update(self, node, allow=False, force=False, choose=None,
-moddirstate=True, forcemerge=False, wlock=None, show_stats=True):
-pl = self.dirstate.parents()
-if not force and pl[1] != nullid:
-raise util.Abort(_("outstanding uncommitted merges"))
-err = False
-p1, p2 = pl[0], node
-pa = self.changelog.ancestor(p1, p2)
-m1n = self.changelog.read(p1)[0]
-m2n = self.changelog.read(p2)[0]
-man = self.manifest.ancestor(m1n, m2n)
-m1 = self.manifest.read(m1n)
-mf1 = self.manifest.readflags(m1n)
-m2 = self.manifest.read(m2n).copy()
-mf2 = self.manifest.readflags(m2n)
-ma = self.manifest.read(man)
-mfa = self.manifest.readflags(man)
-modified, added, removed, deleted, unknown = 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)
-if allow and linear_path:
-raise util.Abort(_("there is nothing to merge, just use "
-"'hg update' or look at 'hg heads'"))
-if allow and not forcemerge:
-if modified or added or removed:
-raise util.Abort(_("outstanding uncommitted changes"))
-if not forcemerge and not force:
-for f in unknown:
-if f in m2:
-t1 = self.wread(f)
-t2 = self.file(f).read(m2[f])
-if cmp(t1, t2) != 0:
-raise util.Abort(_("'%s' already exists in the working"
-" dir and differs from remote") % f)
-# resolve the manifest to determine which files
-# we care about merging
-self.ui.note(_("resolving manifests\n"))
-self.ui.debug(_(" force %s allow %s moddirstate %s linear %s\n") %
-(force, allow, moddirstate, linear_path))
-self.ui.debug(_(" ancestor %s local %s remote %s\n") %
-(short(man), short(m1n), short(m2n)))
-merge = {}
-get = {}
-remove = []
-# construct a working dir manifest
-mw = m1.copy()
-mfw = mf1.copy()
-umap = dict.fromkeys(unknown)
-for f in added + modified + unknown:
-mw[f] = ""
-mfw[f] = util.is_exec(self.wjoin(f), mfw.get(f, False))
-if moddirstate and not wlock:
-wlock = self.wlock()
-for f in deleted + removed:
-if f in mw:
-del mw[f]
-# If we're jumping between revisions (as opposed to merging),
-# and if neither the working directory nor the target rev has
-# the file, then we need to remove it from the dirstate, to
-# prevent the dirstate from listing the file when it is no
-# longer in the manifest.
-if moddirstate and linear_path and f not in m2:
-self.dirstate.forget((f,))
-# Compare manifests
-for f, n in mw.iteritems():
-if choose and not choose(f):
-continue
-if f in m2:
-s = 0
-# is the wfile new since m1, and match m2?
-if f not in m1:
-t1 = self.wread(f)
-t2 = self.file(f).read(m2[f])
-if cmp(t1, t2) == 0:
-n = m2[f]
-del t1, t2
-# are files different?
-if n != m2[f]:
-a = ma.get(f, nullid)
-# are both different from the ancestor?
-if n != a and m2[f] != a:
-self.ui.debug(_(" %s versions differ, resolve\n") % f)
-# merge executable bits
-# "if we changed or they changed, change in merge"
-a, b, c = mfa.get(f, 0), mfw[f], mf2[f]
-mode = ((a^b) | (a^c)) ^ a
-merge[f] = (m1.get(f, nullid), m2[f], mode)
-s = 1
-# are we clobbering?
-# is remote's version newer?
-# or are we going back in time?
-elif force or m2[f] != a or (p2 == pa and mw[f] == m1[f]):
-self.ui.debug(_(" remote %s is newer, get\n") % f)
-get[f] = m2[f]
-s = 1
-elif f in umap or f in added:
-# this unknown file is the same as the checkout
-# we need to reset the dirstate if the file was added
-get[f] = m2[f]
-if not s and mfw[f] != mf2[f]:
-if force:
-self.ui.debug(_(" updating permissions for %s\n") % f)
-util.set_exec(self.wjoin(f), mf2[f])
-else:
-a, b, c = mfa.get(f, 0), mfw[f], mf2[f]
-mode = ((a^b) | (a^c)) ^ a
-if mode != b:
-self.ui.debug(_(" updating permissions for %s\n")
-% f)
-util.set_exec(self.wjoin(f), mode)
-del m2[f]
-elif f in ma:
-if n != ma[f]:
-r = _("d")
-if not force and (linear_path or allow):
-r = self.ui.prompt(
-(_(" local changed %s which remote deleted\n") % f) +
-_("(k)eep or (d)elete?"), _("[kd]"), _("k"))
-if r == _("d"):
-remove.append(f)
-else:
-self.ui.debug(_("other deleted %s\n") % f)
-remove.append(f) # other deleted it
-else:
-# file is created on branch or in working directory
-if force and f not in umap:
-self.ui.debug(_("remote deleted %s, clobbering\n") % f)
-remove.append(f)
-elif n == m1.get(f, nullid): # same as parent
-if p2 == pa: # going backwards?
-self.ui.debug(_("remote deleted %s\n") % f)
-remove.append(f)
-else:
-self.ui.debug(_("local modified %s, keeping\n") % f)
-else:
-self.ui.debug(_("working dir created %s, keeping\n") % f)
-for f, n in m2.iteritems():
-if choose and not choose(f):
-continue
-if f[0] == "/":
-continue
-if f in ma and n != ma[f]:
-r = _("k")
-if not force and (linear_path or allow):
-r = self.ui.prompt(
-(_("remote changed %s which local deleted\n") % f) +
-_("(k)eep or (d)elete?"), _("[kd]"), _("k"))
-if r == _("k"):
-get[f] = n
-elif f not in ma:
-self.ui.debug(_("remote created %s\n") % f)
-get[f] = n
-else:
-if force or p2 == pa: # going backwards?
-self.ui.debug(_("local deleted %s, recreating\n") % f)
-get[f] = n
-else:
-self.ui.debug(_("local deleted %s\n") % f)
-del mw, m1, m2, ma
-if force:
-for f in merge:
-get[f] = merge[f][1]
-merge = {}
-if linear_path or force:
-# we don't need to do any magic, just jump to the new rev
-branch_merge = False
-p1, p2 = p2, nullid
-else:
-if not allow:
-self.ui.status(_("this update spans a branch"
-" affecting the following files:\n"))
-fl = merge.keys() + get.keys()
-fl.sort()
-for f in fl:
-cf = ""
-if f in merge:
-cf = _(" (resolve)")
-self.ui.status(" %s%s\n" % (f, cf))
-self.ui.warn(_("aborting update spanning branches!\n"))
-self.ui.status(_("(use 'hg merge' to merge across branches"
-" or 'hg update -C' to lose changes)\n"))
-return 1
-branch_merge = True
-xp1 = hex(p1)
-xp2 = hex(p2)
-if p2 == nullid: xxp2 = ''
-else: xxp2 = xp2
-self.hook('preupdate', throw=True, parent1=xp1, parent2=xxp2)
-# get the files we don't need to change
-files = get.keys()
-files.sort()
-for f in files:
-if f[0] == "/":
-continue
-self.ui.note(_("getting %s\n") % f)
-t = self.file(f).read(get[f])
-self.wwrite(f, t)
-util.set_exec(self.wjoin(f), mf2[f])
-if moddirstate:
-if branch_merge:
-self.dirstate.update([f], 'n', st_mtime=-1)
-else:
-self.dirstate.update([f], 'n')
-# merge the tricky bits
-failedmerge = []
-files = merge.keys()
-files.sort()
-for f in files:
-self.ui.status(_("merging %s\n") % f)
-my, other, flag = merge[f]
-ret = self.merge3(f, my, other, xp1, xp2)
-if ret:
-err = True
-failedmerge.append(f)
-util.set_exec(self.wjoin(f), flag)
-if moddirstate:
-if branch_merge:
-# We've done a branch merge, mark this file as merged
-# so that we properly record the merger later
-self.dirstate.update([f], 'm')
-else:
-# We've update-merged a locally modified file, so
-# we set the dirstate to emulate a normal checkout
-# of that file some time in the past. Thus our
-# merge will appear as a normal local file
-# modification.
-f_len = len(self.file(f).read(other))
-self.dirstate.update([f], 'n', st_size=f_len, st_mtime=-1)
-remove.sort()
-for f in remove:
-self.ui.note(_("removing %s\n") % f)
-util.audit_path(f)
-try:
-util.unlink(self.wjoin(f))
-except OSError, inst:
-if inst.errno != errno.ENOENT:
-self.ui.warn(_("update failed to remove %s: %s!\n") %
-(f, inst.strerror))
-if moddirstate:
-if branch_merge:
-self.dirstate.update(remove, 'r')
-else:
-self.dirstate.forget(remove)
-if moddirstate:
-self.dirstate.setparents(p1, p2)
-if show_stats:
-stats = ((len(get), _("updated")),
-(len(merge) - len(failedmerge), _("merged")),
-(len(remove), _("removed")),
-(len(failedmerge), _("unresolved")))
-note = ", ".join([_("%d files %s") % s for s in stats])
-self.ui.status("%s\n" % note)
-if moddirstate:
-if branch_merge:
-if failedmerge:
-self.ui.status(_("There are unresolved merges,"
-" you can redo the full merge using:\n"
-"  hg update -C %s\n"
-"  hg merge %s\n"
-% (self.changelog.rev(p1),
-self.changelog.rev(p2))))
-else:
-self.ui.status(_("(branch merge, don't forget to commit)\n"))
-elif failedmerge:
-self.ui.status(_("There are unresolved merges with"
-" locally modified files.\n"))
-self.hook('update', parent1=xp1, parent2=xxp2, error=int(err))
-return err
-def merge3(self, fn, my, other, p1, p2):
-"""perform a 3-way merge in the working directory"""
-def temp(prefix, node):
-pre = "%s~%s." % (os.path.basename(fn), prefix)
-(fd, name) = tempfile.mkstemp(prefix=pre)
-f = os.fdopen(fd, "wb")
-self.wwrite(fn, fl.read(node), f)
-f.close()
-return name
-fl = self.file(fn)
-base = fl.ancestor(my, other)
-a = self.wjoin(fn)
-b = temp("base", base)
-c = temp("other", other)
-self.ui.note(_("resolving %s\n") % fn)
-self.ui.debug(_("file %s: my %s other %s ancestor %s\n") %
-(fn, short(my), short(other), short(base)))
-cmd = (os.environ.get("HGMERGE") or self.ui.config("ui", "merge")
-or "hgmerge")
-r = util.system('%s "%s" "%s" "%s"' % (cmd, a, b, c), cwd=self.root,
-environ={'HG_FILE': fn,
-'HG_MY_NODE': p1,
-'HG_OTHER_NODE': p2,
-'HG_FILE_MY_NODE': hex(my),
-'HG_FILE_OTHER_NODE': hex(other),
-'HG_FILE_BASE_NODE': hex(base)})
-if r:
-self.ui.warn(_("merging %s failed!\n") % fn)
-os.unlink(b)
-os.unlink(c)
-return r
-def verify(self):
-filelinkrevs = {}
-filenodes = {}
-changesets = revisions = files = 0
-errors = [0]
-warnings = [0]
-neededmanifests = {}
-def err(msg):
-self.ui.warn(msg + "\n")
-errors[0] += 1
-def warn(msg):
-self.ui.warn(msg + "\n")
-warnings[0] += 1
-def checksize(obj, name):
-d = obj.checksize()
-if d[0]:
-err(_("%s data length off by %d bytes") % (name, d[0]))
-if d[1]:
-err(_("%s index contains %d extra bytes") % (name, d[1]))
-def checkversion(obj, name):
-if obj.version != revlog.REVLOGV0:
-if not revlogv1:
-warn(_("warning: `%s' uses revlog format 1") % name)
-elif revlogv1:
-warn(_("warning: `%s' uses revlog format 0") % name)
-revlogv1 = self.revlogversion != revlog.REVLOGV0
-if self.ui.verbose or revlogv1 != self.revlogv1:
-self.ui.status(_("repository uses revlog format %d\n") %
-(revlogv1 and 1 or 0))
-seen = {}
-self.ui.status(_("checking changesets\n"))
-checksize(self.changelog, "changelog")
-for i in range(self.changelog.count()):
-changesets += 1
-n = self.changelog.node(i)
-l = self.changelog.linkrev(n)
-if l != i:
-err(_("incorrect link (%d) for changeset revision %d") %(l, i))
-if n in seen:
-err(_("duplicate changeset at revision %d") % i)
-seen[n] = 1
-for p in self.changelog.parents(n):
-if p not in self.changelog.nodemap:
-err(_("changeset %s has unknown parent %s") %
-(short(n), short(p)))
-try:
-changes = self.changelog.read(n)
-except KeyboardInterrupt:
-self.ui.warn(_("interrupted"))
-raise
-except Exception, inst:
-err(_("unpacking changeset %s: %s") % (short(n), inst))
-continue
-neededmanifests[changes[0]] = n
-for f in changes[3]:
-filelinkrevs.setdefault(f, []).append(i)
-seen = {}
-self.ui.status(_("checking manifests\n"))
-checkversion(self.manifest, "manifest")
-checksize(self.manifest, "manifest")
-for i in range(self.manifest.count()):
-n = self.manifest.node(i)
-l = self.manifest.linkrev(n)
-if l < 0 or l >= self.changelog.count():
-err(_("bad manifest link (%d) at revision %d") % (l, i))
-if n in neededmanifests:
-del neededmanifests[n]
-if n in seen:
-err(_("duplicate manifest at revision %d") % i)
-seen[n] = 1
-for p in self.manifest.parents(n):
-if p not in self.manifest.nodemap:
-err(_("manifest %s has unknown parent %s") %
-(short(n), short(p)))
-try:
-delta = mdiff.patchtext(self.manifest.delta(n))
-except KeyboardInterrupt:
-self.ui.warn(_("interrupted"))
-raise
-except Exception, inst:
-err(_("unpacking manifest %s: %s") % (short(n), inst))
-continue
-try:
-ff = [ l.split('\0') for l in delta.splitlines() ]
-for f, fn in ff:
-filenodes.setdefault(f, {})[bin(fn[:40])] = 1
-except (ValueError, TypeError), inst:
-err(_("broken delta in manifest %s: %s") % (short(n), inst))
-self.ui.status(_("crosschecking files in changesets and manifests\n"))
-for m, c in neededmanifests.items():
-err(_("Changeset %s refers to unknown manifest %s") %
-(short(m), short(c)))
-del neededmanifests
-for f in filenodes:
-if f not in filelinkrevs:
-err(_("file %s in manifest but not in changesets") % f)
-for f in filelinkrevs:
-if f not in filenodes:
-err(_("file %s in changeset but not in manifest") % f)
-self.ui.status(_("checking files\n"))
-ff = filenodes.keys()
-ff.sort()
-for f in ff:
-if f == "/dev/null":
-continue
-files += 1
-if not f:
-err(_("file without name in manifest %s") % short(n))
-continue
-fl = self.file(f)
-checkversion(fl, f)
-checksize(fl, f)
-nodes = {nullid: 1}
-seen = {}
-for i in range(fl.count()):
-revisions += 1
-n = fl.node(i)
-if n in seen:
-err(_("%s: duplicate revision %d") % (f, i))
-if n not in filenodes[f]:
-err(_("%s: %d:%s not in manifests") % (f, i, short(n)))
-else:
-del filenodes[f][n]
-flr = fl.linkrev(n)
-if flr not in filelinkrevs.get(f, []):
-err(_("%s:%s points to unexpected changeset %d")
-% (f, short(n), flr))
-else:
-filelinkrevs[f].remove(flr)
-# verify contents
-try:
-t = fl.read(n)
-except KeyboardInterrupt:
-self.ui.warn(_("interrupted"))
-raise
-except Exception, inst:
-err(_("unpacking file %s %s: %s") % (f, short(n), inst))
-# verify parents
-(p1, p2) = fl.parents(n)
-if p1 not in nodes:
-err(_("file %s:%s unknown parent 1 %s") %
-(f, short(n), short(p1)))
-if p2 not in nodes:
-err(_("file %s:%s unknown parent 2 %s") %
-(f, short(n), short(p1)))
-nodes[n] = 1
-# cross-check
-for node in filenodes[f]:
-err(_("node %s in manifests not in %s") % (hex(node), f))
-self.ui.status(_("%d files, %d changesets, %d total revisions\n") %
-(files, changesets, revisions))
-if warnings[0]:
-self.ui.warn(_("%d warnings encountered!\n") % warnings[0])
-if errors[0]:
-self.ui.warn(_("%d integrity errors encountered!\n") % errors[0])
-return 1
 def stream_in(self, remote):
 fp = remote.stream_out()
 resp = int(fp.readline())
 if resp != 0:
 self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %
 (util.bytecount(total_bytes), elapsed,
 util.bytecount(total_bytes / elapsed)))
 self.reload()
 return len(self.heads()) + 1
 def clone(self, remote, heads=[], stream=False):
 '''clone remote repository.
 keyword arguments:
 heads: list of revs to clone (forces use of pull)
 util.rename(os.path.join(p, "journal"), os.path.join(p, "undo"))
 util.rename(os.path.join(p, "journal.dirstate"),
 os.path.join(p, "undo.dirstate"))
 return a
+def instance(ui, path, create):
+return localrepository(ui, util.drop_scheme('file', path), create)
+def islocal(path):
+return True

Mercurial > hg > mercurial-crew-with-dirclash

comparison mercurial/localrepo.py @ 3044:fcadf7a32425