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

equal deleted inserted replaced

-:e0db0b7934f2
+:bd8339976504
 self.root = os.path.abspath(path)
 self.origroot = path
 self.ui = ui.ui(parentui=parentui)
 self.opener = util.opener(self.path)
+self.sopener = util.opener(self.path)
 self.wopener = util.opener(self.root)
 try:
 self.ui.readconfig(self.join("hgrc"), self.root)
 except IOError:
 flags |= revlog.flagstr(x)
 elif self.revlogv1:
 flags = revlog.REVLOG_DEFAULT_FLAGS
 v = self.revlogversion | flags
-self.manifest = manifest.manifest(self.opener, v)
+self.manifest = manifest.manifest(self.sopener, v)
-self.changelog = changelog.changelog(self.opener, v)
+self.changelog = changelog.changelog(self.sopener, v)
 # the changelog might not have the inline index flag
 # on.  If the format of the changelog is the same as found in
 # .hgrc, apply any flags found in the .hgrc as well.
 # Otherwise, just version from the changelog
 # read the tags file from each head, ending with the tip,
 # and add each tag found to the map, with "newer" ones
 # taking precedence
 heads = self.heads()
 heads.reverse()
-fl = self.file(".hgtags")
+seen = {}
 for node in heads:
-change = self.changelog.read(node)
+f = self.filectx('.hgtags', node)
-rev = self.changelog.rev(node)
+if not f or f.filerev() in seen: continue
-fn, ff = self.manifest.find(change[0], '.hgtags')
+seen[f.filerev()] = 1
-if fn is None: continue
 count = 0
-for l in fl.read(fn).splitlines():
+for l in f.data().splitlines():
 count += 1
-parsetag(l, _(".hgtags (rev %d:%s), line %d") %
+parsetag(l, _("%s, line %d") % (str(f), count))
-(rev, short(node), count))
 try:
 f = self.opener("localtags")
 count = 0
 for l in f:
 count += 1
 def lookup(self, key):
 if key == '.':
 key = self.dirstate.parents()[0]
 if key == nullid:
 raise repo.RepoError(_("no revision checked out"))
+n = self.changelog._match(key)
+if n:
+return n
 if key in self.tags():
 return self.tags()[key]
 if key in self.branchtags():
 return self.branchtags()[key]
-try:
+n = self.changelog._partialmatch(key)
-return self.changelog.lookup(key)
+if n:
-except:
+return n
 raise repo.RepoError(_("unknown revision '%s'") % key)
 def dev(self):
 return os.lstat(self.path).st_dev
 def local(self):
 return True
 def join(self, f):
+return os.path.join(self.path, f)
+def sjoin(self, f):
 return os.path.join(self.path, f)
 def wjoin(self, f):
 return os.path.join(self.root, f)
 def file(self, f):
 if f[0] == '/':
 f = f[1:]
-return filelog.filelog(self.opener, f, self.revlogversion)
+return filelog.filelog(self.sopener, f, self.revlogversion)
 def changectx(self, changeid=None):
 return context.changectx(self, changeid)
 def workingctx(self):
 ds = self.opener("dirstate").read()
 except IOError:
 ds = ""
 self.opener("journal.dirstate", "w").write(ds)
-tr = transaction.transaction(self.ui.warn, self.opener,
+tr = transaction.transaction(self.ui.warn, self.sopener,
-self.join("journal"),
+self.sjoin("journal"),
 aftertrans(self.path))
 self.transhandle = tr
 return tr
 def recover(self):
 l = self.lock()
-if os.path.exists(self.join("journal")):
+if os.path.exists(self.sjoin("journal")):
 self.ui.status(_("rolling back interrupted transaction\n"))
-transaction.rollback(self.opener, self.join("journal"))
+transaction.rollback(self.sopener, self.sjoin("journal"))
 self.reload()
 return True
 else:
 self.ui.warn(_("no interrupted transaction available\n"))
 return False
 def rollback(self, wlock=None):
 if not wlock:
 wlock = self.wlock()
 l = self.lock()
-if os.path.exists(self.join("undo")):
+if os.path.exists(self.sjoin("undo")):
 self.ui.status(_("rolling back last transaction\n"))
-transaction.rollback(self.opener, self.join("undo"))
+transaction.rollback(self.sopener, self.sjoin("undo"))
 util.rename(self.join("undo.dirstate"), self.join("dirstate"))
 self.reload()
 self.wreload()
 else:
 self.ui.warn(_("no rollback information available\n"))
 self.nodetagscache = None
 def do_lock(self, lockname, wait, releasefn=None, acquirefn=None,
 desc=None):
 try:
-l = lock.lock(self.join(lockname), 0, releasefn, desc=desc)
+l = lock.lock(lockname, 0, releasefn, desc=desc)
 except lock.LockHeld, inst:
 if not wait:
 raise
 self.ui.warn(_("waiting for lock on %s held by %s\n") %
 (desc, inst.args[0]))
 # default to 600 seconds timeout
-l = lock.lock(self.join(lockname),
+l = lock.lock(lockname, int(self.ui.config("ui", "timeout", "600")),
-int(self.ui.config("ui", "timeout") or 600),
 releasefn, desc=desc)
 if acquirefn:
 acquirefn()
 return l
 def lock(self, wait=1):
-return self.do_lock("lock", wait, acquirefn=self.reload,
+return self.do_lock(self.sjoin("lock"), wait, acquirefn=self.reload,
 desc=_('repository %s') % self.origroot)
 def wlock(self, wait=1):
-return self.do_lock("wlock", wait, self.dirstate.write,
+return self.do_lock(self.join("wlock"), wait, self.dirstate.write,
 self.wreload,
 desc=_('working directory of %s') % self.origroot)
 def filecommit(self, fn, manifest1, manifest2, linkrev, transaction, changelist):
 """
 # write changelog data to temp files so concurrent readers will not see
 # inconsistent view
 cl = None
 try:
-cl = appendfile.appendchangelog(self.opener, self.changelog.version)
+cl = appendfile.appendchangelog(self.sopener,
+self.changelog.version)
 oldheads = len(cl.heads())
 # pull off the changeset group
 self.ui.status(_("adding changesets\n"))
 finally:
 if cl:
 cl.cleanup()
 # make changelog see real files again
-self.changelog = changelog.changelog(self.opener, self.changelog.version)
+self.changelog = changelog.changelog(self.sopener,
+self.changelog.version)
 self.changelog.checkinlinesize(tr)
 newheads = len(self.changelog.heads())
 heads = ""
 if oldheads and newheads != oldheads:
 start = time.time()
 for i in xrange(total_files):
 name, size = fp.readline().split('\0', 1)
 size = int(size)
 self.ui.debug('adding %s (%s)\n' % (name, util.bytecount(size)))
-ofp = self.opener(name, 'w')
+ofp = self.sopener(name, 'w')
 for chunk in util.filechunkiter(fp, limit=size):
 ofp.write(chunk)
 ofp.close()
 elapsed = time.time() - start
 self.ui.status(_('transferred %s in %.1f seconds (%s/sec)\n') %

changeset 3500	bd8339976504
parent 3485	23cffef5d424
parent 3499	ceaa3fefc10c
child 3510	9383af6f236d