mercurial-scm/hg: comparison mercurial/utils/storageutil.py

equal deleted inserted replaced

-:57875cf423c9
+:2372284d9457
 pycompat,
 )
 from ..interfaces import repository
 _nullhash = hashlib.sha1(nullid)
 def hashrevisionsha1(text, p1, p2):
 """Compute the SHA-1 for revision data and its parents.
 This hash combines both the current file contents and its history
 s = hashlib.sha1(a)
 s.update(b)
 s.update(text)
 return s.digest()
 METADATA_RE = re.compile(b'\x01\n')
 def parsemeta(text):
 """Parse metadata header from revision data.
 Returns a 2-tuple of (metadata, offset), where both can be None if there
 for l in mtext.splitlines():
 k, v = l.split(b': ', 1)
 meta[k] = v
 return meta, s + 2
 def packmeta(meta, text):
 """Add metadata to fulltext to produce revision text."""
 keys = sorted(meta)
 metatext = b''.join(b'%s: %s\n' % (k, meta[k]) for k in keys)
 return b'\x01\n%s\x01\n%s' % (metatext, text)
 def iscensoredtext(text):
 meta = parsemeta(text)[0]
 return meta and b'censored' in meta
 def filtermetadata(text):
 """Extract just the revision data from source text.
 Returns ``text`` unless it has a metadata header, in which case we return
 a new buffer without hte metadata.
 """
 if not text.startswith(b'\x01\n'):
 return text
 offset = text.index(b'\x01\n', 2)
-return text[offset + 2:]
+return text[offset + 2 :]
 def filerevisioncopied(store, node):
 """Resolve file revision copy metadata.
 Returns ``False`` if the file has no copy metadata. Otherwise a
 if meta and b'copy' in meta and b'copyrev' in meta:
 return meta[b'copy'], bin(meta[b'copyrev'])
 return False
 def filedataequivalent(store, node, filedata):
 """Determines whether file data is equivalent to a stored node.
 Returns True if the passed file data would hash to the same value
 as a stored revision and False otherwise.
 # remains unchanged. Check if that's the case.
 if store.renamed(node):
 return store.read(node) == filedata
 return False
 def iterrevs(storelen, start=0, stop=None):
 """Iterate over revision numbers in a store."""
 step = 1
 else:
 stop = storelen
 return pycompat.xrange(start, stop, step)
 def fileidlookup(store, fileid, identifier):
 """Resolve the file node for a value.
 ``store`` is an object implementing the ``ifileindex`` interface.
 """
 if isinstance(fileid, int):
 try:
 return store.node(fileid)
 except IndexError:
-raise error.LookupError('%d' % fileid, identifier,
+raise error.LookupError(
-_('no match found'))
+'%d' % fileid, identifier, _('no match found')
+)
 if len(fileid) == 20:
 try:
 store.rev(fileid)
 return fileid
 pass
 except (ValueError, OverflowError):
 pass
 raise error.LookupError(fileid, identifier, _('no match found'))
 def resolvestripinfo(minlinkrev, tiprev, headrevs, linkrevfn, parentrevsfn):
 """Resolve information needed to strip revisions.
 Finds the minimum revision number that must be stripped in order to
 if plinkrev >= minlinkrev:
 futurelargelinkrevs.add(plinkrev)
 return strippoint, brokenrevs
-def emitrevisions(store, nodes, nodesorder, resultcls, deltaparentfn=None,
-candeltafn=None, rawsizefn=None, revdifffn=None, flagsfn=None,
+def emitrevisions(
-deltamode=repository.CG_DELTAMODE_STD,
+store,
-revisiondata=False, assumehaveparentrevisions=False):
+nodes,
+nodesorder,
+resultcls,
+deltaparentfn=None,
+candeltafn=None,
+rawsizefn=None,
+revdifffn=None,
+flagsfn=None,
+deltamode=repository.CG_DELTAMODE_STD,
+revisiondata=False,
+assumehaveparentrevisions=False,
+):
 """Generic implementation of ifiledata.emitrevisions().
 Emitting revision data is subtly complex. This function attempts to
 encapsulate all the logic for doing so in a backend-agnostic way.
 if nodesorder == 'nodes':
 revs = [frev(n) for n in nodes]
 elif nodesorder == 'linear':
 revs = set(frev(n) for n in nodes)
 revs = dagop.linearize(revs, store.parentrevs)
-else: # storage and default
+else:  # storage and default
 revs = sorted(frev(n) for n in nodes)
 prevrev = None
 if deltamode == repository.CG_DELTAMODE_PREV or assumehaveparentrevisions:
 if deltaparentrev in available:
 baserev = deltaparentrev
 # Base revision is a parent that hasn't been emitted already.
 # Use it if we can assume the receiver has the parent revision.
-elif (assumehaveparentrevisions
+elif assumehaveparentrevisions and deltaparentrev in (p1rev, p2rev):
-and deltaparentrev in (p1rev, p2rev)):
 baserev = deltaparentrev
 # No guarantee the receiver has the delta parent. Send delta
 # against last revision (if possible), which in the common case
 # should be similar enough to this revision that the delta is
 if rawsizefn:
 baserevisionsize = rawsizefn(baserev)
 else:
 baserevisionsize = len(store.rawdata(baserev))
-elif (baserev == nullrev
+elif (
-and deltamode != repository.CG_DELTAMODE_PREV):
+baserev == nullrev and deltamode != repository.CG_DELTAMODE_PREV
+):
 revision = store.rawdata(node)
 available.add(rev)
 else:
 if revdifffn:
 delta = revdifffn(baserev, rev)
 else:
-delta = mdiff.textdiff(store.rawdata(baserev),
+delta = mdiff.textdiff(
-store.rawdata(rev))
+store.rawdata(baserev), store.rawdata(rev)
+)
 available.add(rev)
 yield resultcls(
 node=node,
 p2node=fnode(p2rev),
 basenode=fnode(baserev),
 flags=flagsfn(rev) if flagsfn else 0,
 baserevisionsize=baserevisionsize,
 revision=revision,
-delta=delta)
+delta=delta,
+)
 prevrev = rev
 def deltaiscensored(delta, baserev, baselenfn):
 """Determine if a delta represents censored revision data.
 ``baserev`` is the base revision this delta is encoded against.
 if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
 return False
 add = "\1\ncensored:"
 addlen = len(add)
-return newlen >= addlen and delta[hlen:hlen + addlen] == add
+return newlen >= addlen and delta[hlen : hlen + addlen] == add

changeset 43076	2372284d9457
parent 42813	268662aac075
child 43077	687b865b95ad