/brz/remove-bazaar

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

lifeless: the data file is made up of "delta records".  each delta record has a delta header 

that contains; (1) a version id, (2) the size of the delta (in lines), and (3)  the digest of 

the -expanded data- (ie, the delta applied to the parent).  the delta also ends with a 

end robertc@robertcollins.net-20051003014215-ee2990904cc4c7ad 

# TODOS:

# 10:16 < lifeless> make partial index writes safe

# 10:16 < lifeless> implement 'knit.check()' like weave.check()

# 10:17 < lifeless> record known ghosts so we can detect when they are filled in rather than the current 'reweave 

#                    always' approach.

# move sha1 out of the content so that join is faster at verifying parents

# record content length ?

                  

from itertools import izip, chain

        

    def get_bytes(self, factory, annotated_compressed_bytes):

    def get_bytes(self, factory, annotated_compressed_bytes):

    def get_bytes(self, factory, annotated_compressed_bytes):

    def get_bytes(self, factory, annotated_compressed_bytes):

    def get_bytes(self, factory, compressed_bytes):

    def get_bytes(self, factory, compressed_bytes):

    

        annotated, knit=None):

        

            return self._raw_record

    

    plus a flag saying if the final ending is really there or not, because that 

    

        # TODO: jam 20070209 We only do the caching thing to make sure that

        #       the origin is a valid utf-8 line, eventually we could remove it

        if type(key) == tuple:

        return annotator.annotate(key)

    

    

    :ivar _index: A _KnitGraphIndex or similar that can describe the 

        parents, graph, compression and data location of entries in this 

        KnitVersionedFiles.  Note that this is only the index for 

            parent_texts, left_matching_blocks, nostore_sha, random_id)

        left_matching_blocks, nostore_sha, random_id):

        line_bytes = ''.join(lines)

        if lines:

            if lines[-1][-1] != '\n':

                # copy the contents of lines.

                options.append('no-eol')

                lines[-1] = lines[-1] + '\n'

                line_bytes += '\n'

        for element in key:

            if type(element) != str:

        if 'no-eol' in options:

            if self._factory.__class__ == KnitPlainFactory:

                    lines, [line_bytes])

    def check(self, progress_bar=None):

        if contains_whitespace(version_id):

            raise InvalidRevisionId(version_id, self)

        self.check_not_reserved_id(version_id)

        

       

        text_map, contents_map = self._get_content_maps([key])

        return contents_map[key]

 

    def _get_content_maps(self, keys, nonlocal_keys=None):

        """Produce maps of text and KnitContents

        

        :param keys: The keys to produce content maps for.

        :param nonlocal_keys: An iterable of keys(possibly intersecting keys)

            which are known to not be in this knit, but rather in one of the

            fallback knits.

        :return: (text_map, content_map) where text_map contains the texts for

            the requested versions and content_map contains the KnitContents.

        """

        # FUTURE: This function could be improved for the 'extract many' case

        # by tracking each component and only doing the copy when the number of

        # children than need to apply delta's to it is > 1 or it is part of the

        # final output.

        keys = list(keys)

        multiple_versions = len(keys) != 1

        record_map = self._get_record_map(keys, allow_missing=True)

 

        text_map = {}

        content_map = {}

        final_content = {}

        if nonlocal_keys is None:

            nonlocal_keys = set()

        else:

            nonlocal_keys = frozenset(nonlocal_keys)

        missing_keys = set(nonlocal_keys)

        for source in self._fallback_vfs:

            for record in source.get_record_stream(missing_keys,

                'unordered', True):

                if record.storage_kind == 'absent':

                    continue

                missing_keys.remove(record.key)

                lines = osutils.chunks_to_lines(record.get_bytes_as('chunked'))

                text_map[record.key] = lines

                content_map[record.key] = PlainKnitContent(lines, record.key)

                if record.key in keys:

                    final_content[record.key] = content_map[record.key]

        for key in keys:

            if key in nonlocal_keys:

                # already handled

                continue

            components = []

            cursor = key

            while cursor is not None:

                try:

                    record, record_details, digest, next = record_map[cursor]

                except KeyError:

                    raise RevisionNotPresent(cursor, self)

                components.append((cursor, record, record_details, digest))

                cursor = next

                if cursor in content_map:

                    # no need to plan further back

                    components.append((cursor, None, None, None))

                    break

 

            content = None

            for (component_id, record, record_details,

                 digest) in reversed(components):

                if component_id in content_map:

                    content = content_map[component_id]

                else:

                    content, delta = self._factory.parse_record(key[-1],

                        record, record_details, content,

                        copy_base_content=multiple_versions)

                    if multiple_versions:

                        content_map[component_id] = content

 

            final_content[key] = content

 

            # digest here is the digest from the last applied component.

            text = content.text()

            actual_sha = sha_strings(text)

            if actual_sha != digest:

                raise SHA1KnitCorrupt(self, actual_sha, digest, key, text)

            text_map[key] = text

        return text_map, final_content

        

                data returned from read_records

        :param allow_missing: If some records are missing, rather than 

                record_map = {}

                for key, record, digest in self._read_records_iter(records):

                    record_map[key] = record, record_details, digest, next

                return record_map

    def _split_by_prefix(self, keys):

        :return: A dict of {prefix: [key_list]}

                split_by_prefix.setdefault('', []).append(key)

            else:

                split_by_prefix.setdefault(key[0], []).append(key)

        return split_by_prefix

            # Cannot topological order when no graph has been stored.

        if ordering == 'topological':

            # Global topological sort

            present_keys = tsort.topo_sort(global_map)

                    ' "unordered" or "topological" not: %r'

            prefix_split_keys = self._split_by_prefix(present_keys)

            prefix_split_non_local_keys = self._split_by_prefix(non_local_keys)

            for prefix, keys in prefix_split_keys.iteritems():

                non_local = prefix_split_non_local_keys.get(prefix, [])

                non_local = set(non_local)

                text_map, _ = self._get_content_maps(keys, non_local)

                for key in keys:

                    lines = text_map.pop(key)

                    yield ChunkedContentFactory(key, global_map[key], None,

                                                lines)