mercurial-scm/hg-stable: mercurial/localrepo.py comparison

comparison mercurial/localrepo.py @ 7803:6d99ff7b79b5

Merge with stable

author	Matt Mackall <mpm@selenic.com>
date	Fri, 27 Feb 2009 08:13:42 -0600
parents	dd970a311ea8 b8d750daadde
children	4421abf8c85d

comparison

equal deleted inserted replaced

-:dd970a311ea8
+:6d99ff7b79b5
 from node import bin, hex, nullid, nullrev, short
 from i18n import _
 import repo, changegroup
 import changelog, dirstate, filelog, manifest, context, weakref
 import lock, transaction, stat, errno, ui, store
-import os, revlog, time, util, extensions, hook, inspect
+import os, time, util, extensions, hook, inspect, error
 import match as match_
 import merge as merge_
 class localrepository(repo.repository):
 capabilities = util.set(('lookup', 'changegroupsubset'))
 reqfile = self.opener("requires", "w")
 for r in requirements:
 reqfile.write("%s\n" % r)
 reqfile.close()
 else:
-raise repo.RepoError(_("repository %s not found") % path)
+raise error.RepoError(_("repository %s not found") % path)
 elif create:
-raise repo.RepoError(_("repository %s already exists") % path)
+raise error.RepoError(_("repository %s already exists") % path)
 else:
 # find requirements
 requirements = []
 try:
 requirements = self.opener("requires").read().splitlines()
 for r in requirements:
 if r not in self.supported:
-raise repo.RepoError(_("requirement '%s' not supported") % r)
+raise error.RepoError(_("requirement '%s' not supported") % r)
 except IOError, inst:
 if inst.errno != errno.ENOENT:
 raise
 self.store = store.store(requirements, self.path, util.opener)
 self._transref = self._lockref = self._wlockref = None
 def __getattr__(self, name):
 if name == 'changelog':
 self.changelog = changelog.changelog(self.sopener)
+if 'HG_PENDING' in os.environ:
+p = os.environ['HG_PENDING']
+if p.startswith(self.root):
+self.changelog.readpending('00changelog.i.a')
 self.sopener.defversion = self.changelog.version
 return self.changelog
 if name == 'manifest':
 self.changelog
 self.manifest = manifest.manifest(self.sopener)
 else:
 prevtags = fp.read()
 else:
 try:
 prevtags = self.filectx('.hgtags', parent).data()
-except revlog.LookupError:
+except error.LookupError:
 pass
 fp = self.wfile('.hgtags', 'wb')
 if prevtags:
 fp.write(prevtags)
 if key in filetags:
 n, h = filetags[key]
 h.append(n)
 filetags[key] = (bin_n, h)
-for k, nh in filetags.items():
+for k, nh in filetags.iteritems():
 if k not in globaltags:
 globaltags[k] = nh
 tagtypes[k] = tagtype
 continue
 except IOError:
 pass
 self.tagscache = {}
 self._tagstypecache = {}
-for k,nh in globaltags.items():
+for k, nh in globaltags.iteritems():
 n = nh[0]
 if n != nullid:
 self.tagscache[k] = n
 self._tagstypecache[k] = tagtypes[k]
 self.tagscache['tip'] = self.changelog.tip()
 for node in heads:
 c = self[node]
 rev = c.rev()
 try:
 fnode = c.filenode('.hgtags')
-except revlog.LookupError:
+except error.LookupError:
 continue
 ret.append((rev, node, fnode))
 if fnode in last:
 ret[last[fnode]] = None
 last[fnode] = len(ret) - 1
 return [item for item in ret if item]
 def tagslist(self):
 '''return a list of tags ordered by revision'''
 l = []
-for t, n in self.tags().items():
+for t, n in self.tags().iteritems():
 try:
 r = self.changelog.rev(n)
 except:
 r = -2 # sort to the beginning of the list if unknown
 l.append((r, t, n))
 def nodetags(self, node):
 '''return the tags associated with a node'''
 if not self.nodetagscache:
 self.nodetagscache = {}
-for t, n in self.tags().items():
+for t, n in self.tags().iteritems():
 self.nodetagscache.setdefault(n, []).append(t)
 return self.nodetagscache.get(node, [])
 def _branchtags(self, partial, lrev):
+# TODO: rename this function?
 tiprev = len(self) - 1
 if lrev != tiprev:
 self._updatebranchcache(partial, lrev+1, tiprev+1)
 self._writebranchcache(partial, self.changelog.tip(), tiprev)
 return partial
-def branchtags(self):
+def _branchheads(self):
 tip = self.changelog.tip()
 if self.branchcache is not None and self._branchcachetip == tip:
 return self.branchcache
 oldtip = self._branchcachetip
 else:
 lrev = self.changelog.rev(oldtip)
 partial = self._ubranchcache
 self._branchtags(partial, lrev)
+# this private cache holds all heads (not just tips)
+self._ubranchcache = partial
 # the branch cache is stored on disk as UTF-8, but in the local
 # charset internally
-for k, v in partial.items():
+for k, v in partial.iteritems():
 self.branchcache[util.tolocal(k)] = v
-self._ubranchcache = partial
 return self.branchcache
+def branchtags(self):
+'''return a dict where branch names map to the tipmost head of
+the branch, open heads come before closed'''
+bt = {}
+for bn, heads in self._branchheads().iteritems():
+head = None
+for i in range(len(heads)-1, -1, -1):
+h = heads[i]
+if 'close' not in self.changelog.read(h)[5]:
+head = h
+break
+# no open heads were found
+if head is None:
+head = heads[-1]
+bt[bn] = head
+return bt
 def _readbranchcache(self):
 partial = {}
 try:
-f = self.opener("branch.cache")
+f = self.opener("branchheads.cache")
 lines = f.read().split('\n')
 f.close()
 except (IOError, OSError):
 return {}, nullid, nullrev
 # invalidate the cache
 raise ValueError('invalidating branch cache (tip differs)')
 for l in lines:
 if not l: continue
 node, label = l.split(" ", 1)
-partial[label.strip()] = bin(node)
+partial.setdefault(label.strip(), []).append(bin(node))
-except (KeyboardInterrupt, util.SignalInterrupt):
+except KeyboardInterrupt:
 raise
 except Exception, inst:
 if self.ui.debugflag:
 self.ui.warn(str(inst), '\n')
 partial, last, lrev = {}, nullid, nullrev
 return partial, last, lrev
 def _writebranchcache(self, branches, tip, tiprev):
 try:
-f = self.opener("branch.cache", "w", atomictemp=True)
+f = self.opener("branchheads.cache", "w", atomictemp=True)
 f.write("%s %s\n" % (hex(tip), tiprev))
-for label, node in branches.iteritems():
+for label, nodes in branches.iteritems():
-f.write("%s %s\n" % (hex(node), label))
+for node in nodes:
+f.write("%s %s\n" % (hex(node), label))
 f.rename()
 except (IOError, OSError):
 pass
 def _updatebranchcache(self, partial, start, end):
 for r in xrange(start, end):
 c = self[r]
 b = c.branch()
-partial[b] = c.node()
+bheads = partial.setdefault(b, [])
+bheads.append(c.node())
+for p in c.parents():
+pn = p.node()
+if pn in bheads:
+bheads.remove(pn)
 def lookup(self, key):
 if isinstance(key, int):
 return self.changelog.node(key)
 elif key == '.':
 try:
 if len(key) == 20:
 key = hex(key)
 except:
 pass
-raise repo.RepoError(_("unknown revision '%s'") % key)
+raise error.RepoError(_("unknown revision '%s'") % key)
 def local(self):
 return True
 def join(self, f):
 if self._transref and self._transref():
 return self._transref().nest()
 # abort here if the journal already exists
 if os.path.exists(self.sjoin("journal")):
-raise repo.RepoError(_("journal already exists - run hg recover"))
+raise error.RepoError(_("journal already exists - run hg recover"))
 # save dirstate for rollback
 try:
 ds = self.opener("dirstate").read()
 except IOError:
 self._branchcachetip = None
 def _lock(self, lockname, wait, releasefn, acquirefn, desc):
 try:
 l = lock.lock(lockname, 0, releasefn, desc=desc)
-except lock.LockHeld, inst:
+except error.LockHeld, inst:
 if not wait:
 raise
 self.ui.warn(_("waiting for lock on %s held by %r\n") %
 (desc, inst.locker))
 # default to 600 seconds timeout
 def commit(self, files=None, text="", user=None, date=None,
 match=None, force=False, force_editor=False,
 p1=None, p2=None, extra={}, empty_ok=False):
 wlock = lock = None
+if extra.get("close"):
+force = True
 if files:
 files = util.unique(files)
 try:
 wlock = self.wlock()
 lock = self.lock()
 del lines[0]
 if not lines and use_dirstate:
 raise util.Abort(_("empty commit message"))
 text = '\n'.join(lines)
+self.changelog.delayupdate()
 n = self.changelog.add(mn, changed + removed, text, trp, p1, p2,
 user, wctx.date(), extra)
+p = lambda: self.changelog.writepending() and self.root or ""
 self.hook('pretxncommit', throw=True, node=hex(n), parent1=xp1,
-parent2=xp2)
+parent2=xp2, pending=p)
+self.changelog.finalize(trp)
 tr.close()
 if self.branchcache:
 self.branchtags()
 try:
 try:
 wlock = self.wlock(False)
 for f in fixup:
 self.dirstate.normal(f)
-except lock.LockException:
+except lock.LockError:
 pass
 finally:
 del wlock
 if not parentworking:
 self.dirstate.add(dest)
 self.dirstate.copy(source, dest)
 finally:
 del wlock
-def heads(self, start=None):
+def heads(self, start=None, closed=True):
 heads = self.changelog.heads(start)
+def display(head):
+if closed:
+return True
+extras = self.changelog.read(head)[5]
+return ('close' not in extras)
 # sort the output in rev descending order
-heads = [(-self.changelog.rev(h), h) for h in heads]
+heads = [(-self.changelog.rev(h), h) for h in heads if display(h)]
 return [n for (r, n) in util.sort(heads)]
-def branchheads(self, branch=None, start=None):
+def branchheads(self, branch=None, start=None, closed=True):
 if branch is None:
 branch = self[None].branch()
-branches = self.branchtags()
+branches = self._branchheads()
 if branch not in branches:
 return []
-# The basic algorithm is this:
+bheads = branches[branch]
-#
+# the cache returns heads ordered lowest to highest
-# Start from the branch tip since there are no later revisions that can
+bheads.reverse()
-# possibly be in this branch, and the tip is a guaranteed head.
-#
-# Remember the tip's parents as the first ancestors, since these by
-# definition are not heads.
-#
-# Step backwards from the brach tip through all the revisions. We are
-# guaranteed by the rules of Mercurial that we will now be visiting the
-# nodes in reverse topological order (children before parents).
-#
-# If a revision is one of the ancestors of a head then we can toss it
-# out of the ancestors set (we've already found it and won't be
-# visiting it again) and put its parents in the ancestors set.
-#
-# Otherwise, if a revision is in the branch it's another head, since it
-# wasn't in the ancestor list of an existing head.  So add it to the
-# head list, and add its parents to the ancestor list.
-#
-# If it is not in the branch ignore it.
-#
-# Once we have a list of heads, use nodesbetween to filter out all the
-# heads that cannot be reached from startrev.  There may be a more
-# efficient way to do this as part of the previous algorithm.
-set = util.set
-heads = [self.changelog.rev(branches[branch])]
-# Don't care if ancestors contains nullrev or not.
-ancestors = set(self.changelog.parentrevs(heads[0]))
-for rev in xrange(heads[0] - 1, nullrev, -1):
-if rev in ancestors:
-ancestors.update(self.changelog.parentrevs(rev))
-ancestors.remove(rev)
-elif self[rev].branch() == branch:
-heads.append(rev)
-ancestors.update(self.changelog.parentrevs(rev))
-heads = [self.changelog.node(rev) for rev in heads]
 if start is not None:
-heads = self.changelog.nodesbetween([start], heads)[2]
+# filter out the heads that cannot be reached from startrev
-return heads
+bheads = self.changelog.nodesbetween([start], bheads)[2]
+if not closed:
+bheads = [h for h in bheads if
+('close' not in self.changelog.read(h)[5])]
+return bheads
 def branches(self, nodes):
 if not nodes:
 nodes = [self.changelog.tip()]
 b = []
 search = newsearch
 # sanity check our fetch list
 for f in fetch.keys():
 if f in m:
-raise repo.RepoError(_("already have changeset ") + short(f[:4]))
+raise error.RepoError(_("already have changeset ")
++ short(f[:4]))
 if base.keys() == [nullid]:
 if force:
 self.ui.warn(_("warning: repository is unrelated\n"))
 else:
 def changegroupinfo(self, nodes, source):
 if self.ui.verbose or source == 'bundle':
 self.ui.status(_("%d changesets found\n") % len(nodes))
 if self.ui.debugflag:
-self.ui.debug(_("List of changesets:\n"))
+self.ui.debug(_("list of changesets:\n"))
 for node in nodes:
 self.ui.debug("%s\n" % hex(node))
 def changegroupsubset(self, bases, heads, source, extranodes=None):
 """This function generates a changegroup consisting of all the nodes
 if r == next_rev[0]:
 # If the last rev we looked at was the one just previous,
 # we only need to see a diff.
 deltamf = mnfst.readdelta(mnfstnode)
 # For each line in the delta
-for f, fnode in deltamf.items():
+for f, fnode in deltamf.iteritems():
 f = changedfiles.get(f, None)
 # And if the file is in the list of files we care
 # about.
 if f is not None:
 # Get the changenode this manifest belongs to
 if fl.addgroup(chunkiter, revmap, trp) is None:
 raise util.Abort(_("received file revlog group is empty"))
 revisions += len(fl) - o
 files += 1
-# make changelog see real files again
-cl.finalize(trp)
 newheads = len(self.changelog.heads())
 heads = ""
 if oldheads and newheads != oldheads:
 heads = _(" (%+d heads)") % (newheads - oldheads)
 self.ui.status(_("added %d changesets"
 " with %d changes to %d files%s\n")
 % (changesets, revisions, files, heads))
 if changesets > 0:
+p = lambda: self.changelog.writepending() and self.root or ""
 self.hook('pretxnchangegroup', throw=True,
 node=hex(self.changelog.node(cor+1)), source=srctype,
-url=url)
+url=url, pending=p)
+# make changelog see real files again
+cl.finalize(trp)
 tr.close()
 finally:
 del tr
 fp = remote.stream_out()
 l = fp.readline()
 try:
 resp = int(l)
 except ValueError:
-raise util.UnexpectedOutput(
+raise error.ResponseError(
 _('Unexpected response from remote server:'), l)
 if resp == 1:
 raise util.Abort(_('operation forbidden by server'))
 elif resp == 2:
 raise util.Abort(_('locking the remote repository failed'))
 self.ui.status(_('streaming all changes\n'))
 l = fp.readline()
 try:
 total_files, total_bytes = map(int, l.split(' ', 1))
 except (ValueError, TypeError):
-raise util.UnexpectedOutput(
+raise error.ResponseError(
 _('Unexpected response from remote server:'), l)
 self.ui.status(_('%d files to transfer, %s of data\n') %
 (total_files, util.bytecount(total_bytes)))
 start = time.time()
 for i in xrange(total_files):
 l = fp.readline()
 try:
 name, size = l.split('\0', 1)
 size = int(size)
 except (ValueError, TypeError):
-raise util.UnexpectedOutput(
+raise error.ResponseError(
 _('Unexpected response from remote server:'), l)
 self.ui.debug(_('adding %s (%s)\n') % (name, util.bytecount(size)))
 ofp = self.sopener(name, 'w')
 for chunk in util.filechunkiter(fp, limit=size):
 ofp.write(chunk)

Mercurial > public > mercurial-scm > hg-stable

comparison mercurial/localrepo.py @ 7803:6d99ff7b79b5