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

equal deleted inserted replaced

-:06abdaf78788
+:fc44c8df9d99
 s.update(text)
 return s.digest()
 def compress(text):
 """ generate a possibly-compressed representation of text """
-if not text: return ("", text)
+if not text:
+return ("", text)
 if len(text) < 44:
-if text[0] == '\0': return ("", text)
+if text[0] == '\0':
+return ("", text)
 return ('u', text)
 bin = zlib.compress(text)
 if len(bin) > len(text):
-if text[0] == '\0': return ("", text)
+if text[0] == '\0':
+return ("", text)
 return ('u', text)
 return ("", bin)
 def decompress(bin):
 """ decompress the given input """
-if not bin: return bin
+if not bin:
+return bin
 t = bin[0]
-if t == '\0': return bin
+if t == '\0':
-if t == 'x': return zlib.decompress(bin)
+return bin
-if t == 'u': return bin[1:]
+if t == 'x':
+return zlib.decompress(bin)
+if t == 'u':
+return bin[1:]
 raise RevlogError(_("unknown compression type %r") % t)
 indexformatv0 = ">4l20s20s20s"
 v0shaoffset = 56
 # index ng:
 during a commit, we need to make sure the rev being added is
 not a duplicate.  This requires loading the entire index,
 which is fairly slow.  loadmap can load up just the node map,
 which takes much less time.
 """
-if self.allmap: return
+if self.allmap:
+return
 end = self.datasize
 self.allmap = 1
 cur = 0
 count = 0
 blocksize = self.s * 256
 break
 off += self.s
 cur += blocksize
 def loadblock(self, blockstart, blocksize, data=None):
-if self.all: return
+if self.all:
+return
 if data is None:
 self.dataf.seek(blockstart)
 if blockstart + blocksize > self.datasize:
 # the revlog may have grown since we've started running,
 # but we don't have space in self.index for more entries.
 self.map[n] = i + x
 off += self.s
 def findnode(self, node):
 """search backwards through the index file for a specific node"""
-if self.allmap: return None
+if self.allmap:
+return None
 # hg log will cause many many searches for the manifest
 # nodes.  After we get called a few times, just load the whole
 # thing.
 if self.mapfind_count > 8:
 break
 end -= blocksize
 return None
 def loadindex(self, i=None, end=None):
-if self.all: return
+if self.all:
+return
 all = False
 if i == None:
 blockstart = 0
 blocksize = (512 / self.s) * self.s
 end = self.datasize
 blocksize = self.s * 64
 end = blockstart + blocksize
 while blockstart < end:
 self.loadblock(blockstart, blocksize)
 blockstart += blocksize
-if all: self.all = True
+if all:
+self.all = True
 class lazyindex(object):
 """a lazy version of the index array"""
 def __init__(self, parser):
 self.p = parser
 def __setitem__(self, key, val):
 self.p.map[key] = val
 def __delitem__(self, key):
 del self.p.map[key]
-class RevlogError(Exception): pass
+class RevlogError(Exception):
-class LookupError(RevlogError): pass
+pass
+class LookupError(RevlogError):
+pass
 def getoffset(q):
 if q & 0xFFFF:
 raise RevlogError(_('incompatible revision flag %x') % q)
 return int(q >> 16)
 """loads the map from the lazy parser"""
 if isinstance(self.nodemap, lazymap):
 self.nodemap.p.loadmap()
 self.nodemap = self.nodemap.p.map
-def _inline(self): return self.version & REVLOGNGINLINEDATA
+def _inline(self):
+return self.version & REVLOGNGINLINEDATA
-def tip(self): return self.node(len(self.index) - 2)
+def tip(self):
-def count(self): return len(self.index) - 1
+return self.node(len(self.index) - 2)
-def node(self, rev):
+def count(self):
-return self.index[rev][7]
+return len(self.index) - 1
 def rev(self, node):
 try:
 return self.nodemap[node]
 except KeyError:
 raise LookupError(_('%s: no node %s') % (self.indexfile, hex(node)))
+def node(self, rev):
+return self.index[rev][7]
 def linkrev(self, node):
 return self.index[self.rev(node)][4]
 def parents(self, node):
 d = self.index[self.rev(node)][5:7]
 return (self.node(d[0]), self.node(d[1]))
 def parentrevs(self, rev):
 return self.index[rev][5:7]
 def start(self, rev):
 return getoffset(self.index[rev][0])
-def end(self, rev): return self.start(rev) + self.length(rev)
+def end(self, rev):
+return self.start(rev) + self.length(rev)
+def length(self, rev):
+return self.index[rev][1]
+def base(self, rev):
+return self.index[rev][3]
 def size(self, rev):
 """return the length of the uncompressed text for a given revision"""
 l = self.index[rev][2]
 if l >= 0:
 l = len(text)
 for x in xrange(base + 1, rev + 1):
 l = mdiff.patchedsize(l, self.chunk(x))
 return l
 """
-def length(self, rev):
-return self.index[rev][1]
-def base(self, rev):
-return self.index[rev][3]
 def reachable(self, node, stop=None):
 """return a hash of all nodes ancestral to a given node, including
 the node itself, stopping when stop is matched"""
 reachable = {}
 except LookupError:
 pass # may be partial hex id
 try:
 # str(rev)
 rev = int(id)
-if str(rev) != id: raise ValueError
+if str(rev) != id:
-if rev < 0: rev = self.count() + rev
+raise ValueError
-if rev < 0 or rev >= self.count(): raise ValueError
+if rev < 0:
+rev = self.count() + rev
+if rev < 0 or rev >= self.count():
+raise ValueError
 return self.node(rev)
 except (ValueError, OverflowError):
 pass
 if len(id) == 40:
 try:
 def lookup(self, id):
 """locate a node based on:
 - revision number or str(revision number)
 - nodeid or subset of hex nodeid
 """
 n = self._match(id)
 if n is not None:
 return n
 n = self._partialmatch(id)
 if n:
 offset = start - cache_start
 else:
 loadcache(df)
 offset = 0
-#def checkchunk():
-#    df = self.opener(self.datafile)
-#    df.seek(start)
-#    return df.read(length)
-#assert s == checkchunk()
 return decompress(self._io.chunkcache[1][offset:offset + length])
 def delta(self, node):
 """return or calculate a delta between a node and its predecessor"""
 r = self.rev(node)
 return self.diff(self.revision(self.node(rev1)),
 self.revision(self.node(rev2)))
 def revision(self, node):
 """return an uncompressed revision of a given"""
-if node == nullid: return ""
+if node == nullid:
-if self.cache and self.cache[0] == node: return self.cache[2]
+return ""
+if self.cache and self.cache[0] == node:
+return self.cache[2]
 # look up what we need to read
 text = None
 rev = self.rev(node)
 base = self.base(rev)
 dfh = None
 ifh = self.opener(self.indexfile, "a+")
 return self._addrevision(text, transaction, link, p1, p2, d, ifh, dfh)
 def _addrevision(self, text, transaction, link, p1, p2, d, ifh, dfh):
-if text is None: text = ""
+if text is None:
-if p1 is None: p1 = self.tip()
+text = ""
-if p2 is None: p2 = nullid
+if p1 is None:
+p1 = self.tip()
+if p2 is None:
+p2 = nullid
 node = hash(text, p1, p2)
 if node in self.nodemap:
 return node

changeset 4980	fc44c8df9d99
parent 4979	06abdaf78788
child 4981	e7131935fbb3