def get_files_by_revid(self, revid):
try:
return self.idmap.get_files_by_revid(revid)
except KeyError:
delta = self.repo.get_revision_delta(revid)
tree = self.repo.revision_tree(revid)
return files_from_delta(delta, tree, revid)
def dinventories(repo,
mapping,
revids,
manifest_ids,
files,
overlay,
texts,
fileids,
lossy=True):
"""Generate manifests from a series of revision trees.
:param repo: Bazaar repository to fetch revisions from
:param revids: Revision ids to yield manifests for (returned in same order)
:param manifest_ids: Dictionary with revid -> file id mappings for known
manifests. Used to look up parent manifests not processed
:param files: Dictionary to store mercurial file dictionaries in, by revid
:param overlay: Mercurial overlay object for the Bazaar repository
:param texts: Dictionary with node -> (fileid, revision) tuples
:param fileids: Dictionary mapping revision ids to file id lookup dictionaries,
for any "unusual" file ids (not matching that predicted by the mapping).
(only relevant for non-lossy conversions)
:param lossy: Whether or not to do a lossy conversion.
"""
def get_manifest(revid):
if revid in manifest_ids:
try:
return manifests[manifest_ids[revid]]
except KeyError:
pass
return overlay.get_manifest_and_flags_by_revid(revid)
if revids == []:
return
skip_revid = revids[0]
if revids[0] == _mod_revision.NULL_REVISION:
yield "", (mercurial.node.nullid, mercurial.node.nullid), revids[0]
revids = revids[1:]
manifests = {}
# TODO: Very naive and slow:
for tree in repo.revision_trees(revids):
revid = tree.get_revision_id()
rev = repo.get_revision(revid)
lookup_text_node = []
for parent in rev.parent_ids[:2]:
lookup_text_node.append(get_manifest(parent)[0].__getitem__)
while len(lookup_text_node) < 2:
lookup_text_node.append(lambda path: mercurial.node.nullid)
# TODO: This refetches the parent trees, which we'll likely have seen
# earlier in this loop.
parent_trees = list(repo.revision_trees(rev.parent_ids[:2]))
(manifest, flags,
extrafileids) = manifest_and_flags_from_tree(parent_trees, tree,
mapping,
lookup_text_node)
fileids[revid] = extrafileids
manifests[revid] = (manifest, flags)
try:
base_tree = parent_trees[0]
except IndexError:
base_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
files[revid] = files_from_delta(tree.changes_from(base_tree), tree,
revid)
# Avoid sending texts for first revision, it's listed so we get the
# base text for the manifest delta's.
if revid != skip_revid:
for p in files[revid]:
fileid = tree.path2id(p)
if fileid is not None:
# FIXME: This is probably not correct, as 'files'
# don't include new revisions that don't include changes
# (but are e.g. relevant for parents)
texts[p].add((fileid, tree.get_file_revision(p)))
text = format_manifest(manifest, flags)
node_parents = as_hg_parents(rev.parent_ids, manifest_ids.__getitem__)
manifest_id = hghash(text, node_parents[0], node_parents[1])
manifest_ids[revid] = manifest_id
if 'check' in debug.debug_flags:
assert mapping.export_revision(rev)[0] in (None, manifest_id)
yield text, node_parents, revid
:param (expected_manifest, expected_flags): Expected manifest and flags
:param manifest_parents: Manifests of the parents of revision
:param tree: Optional tree for revid, if the caller already had
it
"""
if tree is None:
tree = repository.revision_tree(revid)
tree = repository.revision_tree(revid)
rev = repository.get_revision(revid)
parent_trees = list(repository.revision_trees(rev.parent_ids[:2]))
try:
base_tree = parent_trees[0]
except IndexError:
base_tree = repository.revision_tree(NULL_REVISION)
delta = tree.changes_from(base_tree)
files = files_from_delta(delta, tree, revid)
if expected_files != files:
raise AssertionError
lookup = [m.__getitem__ for m, f in manifest_parents[:2]]
for i in range(2):
if len(lookup) <= i:
lookup.append({}.__getitem__)
(manifest, flags,
unusual_fileids) = manifest_and_flags_from_tree(parent_trees, tree,
mapping, lookup)
if set(manifest.keys()) != set(expected_manifest.keys()):
raise AssertionError("Different contents in manifests: %r, %r" %
(manifest.keys(), expected_manifest.keys()))
if set(flags.keys()) != set(expected_flags.keys()):
raise AssertionError("Different flags: %r, %r" %
(flags, expected_flags))