/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/transform.py

  • Committer: Jelmer Vernooij
  • Date: 2017-06-10 00:06:46 UTC
  • mfrom: (6673 work)
  • mto: This revision was merged to the branch mainline in revision 6675.
  • Revision ID: jelmer@jelmer.uk-20170610000646-xj6jh277lo4xuo10
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
61
61
    splitpath,
62
62
    )
63
63
from .progress import ProgressPhase
 
64
from .sixish import (
 
65
    viewitems,
 
66
    viewvalues,
 
67
    )
64
68
 
65
69
 
66
70
ROOT_PARENT = "root-parent"
228
232
        irrelevant.
229
233
 
230
234
        """
231
 
        new_roots = [k for k, v in self._new_parent.iteritems() if v ==
232
 
                     ROOT_PARENT]
 
235
        new_roots = [k for k, v in viewitems(self._new_parent)
 
236
                     if v == ROOT_PARENT]
233
237
        if len(new_roots) < 1:
234
238
            return
235
239
        if len(new_roots) != 1:
479
483
        file_id = self.tree_file_id(trans_id)
480
484
        if file_id is not None:
481
485
            return file_id
482
 
        for key, value in self._non_present_ids.iteritems():
 
486
        for key, value in viewitems(self._non_present_ids):
483
487
            if value == trans_id:
484
488
                return key
485
489
 
509
513
        Only new paths and parents of tree files with assigned ids are used.
510
514
        """
511
515
        by_parent = {}
512
 
        items = list(self._new_parent.iteritems())
513
 
        items.extend((t, self.final_parent(t)) for t in
514
 
                      self._tree_id_paths.keys())
 
516
        items = list(viewitems(self._new_parent))
 
517
        items.extend((t, self.final_parent(t))
 
518
            for t in list(self._tree_id_paths))
515
519
        for trans_id, parent_id in items:
516
520
            if parent_id not in by_parent:
517
521
                by_parent[parent_id] = set()
555
559
        Active parents are those which gain children, and those which are
556
560
        removed.  This is a necessary first step in detecting conflicts.
557
561
        """
558
 
        parents = self.by_parent().keys()
 
562
        parents = list(self.by_parent())
559
563
        parents.extend([t for t in self._removed_contents if
560
564
                        self.tree_kind(t) == 'directory'])
561
565
        for trans_id in self._removed_id:
634
638
    def _unversioned_parents(self, by_parent):
635
639
        """If parent directories are versioned, children must be versioned."""
636
640
        conflicts = []
637
 
        for parent_id, children in by_parent.iteritems():
 
641
        for parent_id, children in viewitems(by_parent):
638
642
            if parent_id == ROOT_PARENT:
639
643
                continue
640
644
            if self.final_file_id(parent_id) is not None:
651
655
        However, existing entries with no contents are okay.
652
656
        """
653
657
        conflicts = []
654
 
        for trans_id in self._new_id.iterkeys():
 
658
        for trans_id in self._new_id:
655
659
            kind = self.final_kind(trans_id)
656
660
            if kind is None:
657
661
                conflicts.append(('versioning no contents', trans_id))
693
697
        conflicts = []
694
698
        if (self._new_name, self._new_parent) == ({}, {}):
695
699
            return conflicts
696
 
        for children in by_parent.itervalues():
 
700
        for children in viewvalues(by_parent):
697
701
            name_ids = []
698
702
            for child_tid in children:
699
703
                name = self.final_name(child_tid)
724
728
                                self._removed_id))
725
729
        all_ids = self._tree.all_file_ids()
726
730
        active_tree_ids = all_ids.difference(removed_tree_ids)
727
 
        for trans_id, file_id in self._new_id.iteritems():
 
731
        for trans_id, file_id in viewitems(self._new_id):
728
732
            if file_id in active_tree_ids:
729
733
                old_trans_id = self.trans_id_tree_file_id(file_id)
730
734
                conflicts.append(('duplicate id', old_trans_id, trans_id))
733
737
    def _parent_type_conflicts(self, by_parent):
734
738
        """Children must have a directory parent"""
735
739
        conflicts = []
736
 
        for parent_id, children in by_parent.iteritems():
 
740
        for parent_id, children in viewitems(by_parent):
737
741
            if parent_id == ROOT_PARENT:
738
742
                continue
739
743
            no_children = True
868
872
    def _affected_ids(self):
869
873
        """Return the set of transform ids affected by the transform"""
870
874
        trans_ids = set(self._removed_id)
871
 
        trans_ids.update(self._new_id.keys())
 
875
        trans_ids.update(self._new_id)
872
876
        trans_ids.update(self._removed_contents)
873
 
        trans_ids.update(self._new_contents.keys())
874
 
        trans_ids.update(self._new_executability.keys())
875
 
        trans_ids.update(self._new_name.keys())
876
 
        trans_ids.update(self._new_parent.keys())
 
877
        trans_ids.update(self._new_contents)
 
878
        trans_ids.update(self._new_executability)
 
879
        trans_ids.update(self._new_name)
 
880
        trans_ids.update(self._new_parent)
877
881
        return trans_ids
878
882
 
879
883
    def _get_file_id_maps(self):
953
957
        from_trans_ids, to_trans_ids = self._get_file_id_maps()
954
958
        results = []
955
959
        # Now iterate through all active file_ids
956
 
        for file_id in set(from_trans_ids.keys() + to_trans_ids.keys()):
 
960
        for file_id in set(from_trans_ids).union(to_trans_ids):
957
961
            modified = False
958
962
            from_trans_id = from_trans_ids.get(file_id)
959
963
            # find file ids, and determine versioning state
1096
1100
        :param serializer: A Serialiser like pack.ContainerSerializer.
1097
1101
        """
1098
1102
        new_name = dict((k, v.encode('utf-8')) for k, v in
1099
 
                        self._new_name.items())
 
1103
                        viewitems(self._new_name))
1100
1104
        new_executability = dict((k, int(v)) for k, v in
1101
 
                                 self._new_executability.items())
 
1105
                                 viewitems(self._new_executability))
1102
1106
        tree_path_ids = dict((k.encode('utf-8'), v)
1103
 
                             for k, v in self._tree_path_ids.items())
 
1107
                             for k, v in viewitems(self._tree_path_ids))
1104
1108
        attribs = {
1105
1109
            '_id_number': self._id_number,
1106
1110
            '_new_name': new_name,
1114
1118
            }
1115
1119
        yield serializer.bytes_record(bencode.bencode(attribs),
1116
1120
                                      (('attribs',),))
1117
 
        for trans_id, kind in self._new_contents.items():
 
1121
        for trans_id, kind in viewitems(self._new_contents):
1118
1122
            if kind == 'file':
1119
1123
                lines = osutils.chunks_to_lines(
1120
1124
                    self._read_file_chunks(trans_id))
1137
1141
        attribs = bencode.bdecode(content)
1138
1142
        self._id_number = attribs['_id_number']
1139
1143
        self._new_name = dict((k, v.decode('utf-8'))
1140
 
                            for k, v in attribs['_new_name'].items())
 
1144
                              for k, v in viewitems(attribs['_new_name']))
1141
1145
        self._new_parent = attribs['_new_parent']
1142
 
        self._new_executability = dict((k, bool(v)) for k, v in
1143
 
            attribs['_new_executability'].items())
 
1146
        self._new_executability = dict((k, bool(v))
 
1147
            for k, v in viewitems(attribs['_new_executability']))
1144
1148
        self._new_id = attribs['_new_id']
1145
 
        self._r_new_id = dict((v, k) for k, v in self._new_id.items())
 
1149
        self._r_new_id = dict((v, k) for k, v in viewitems(self._new_id))
1146
1150
        self._tree_path_ids = {}
1147
1151
        self._tree_id_paths = {}
1148
 
        for bytepath, trans_id in attribs['_tree_path_ids'].items():
 
1152
        for bytepath, trans_id in viewitems(attribs['_tree_path_ids']):
1149
1153
            path = bytepath.decode('utf-8')
1150
1154
            self._tree_path_ids[path] = trans_id
1151
1155
            self._tree_id_paths[trans_id] = path
1201
1205
        if self._tree is None:
1202
1206
            return
1203
1207
        try:
1204
 
            limbo_paths = self._limbo_files.values() + list(
1205
 
                self._possibly_stale_limbo_files)
1206
 
            limbo_paths = sorted(limbo_paths, reverse=True)
 
1208
            limbo_paths = list(viewvalues(self._limbo_files))
 
1209
            limbo_paths.extend(self._possibly_stale_limbo_files)
 
1210
            limbo_paths.sort(reverse=True)
1207
1211
            for path in limbo_paths:
1208
1212
                try:
1209
1213
                    delete_any(path)
1676
1680
                        in (trans_id, None)):
1677
1681
                        use_direct_path = True
1678
1682
                else:
1679
 
                    for l_filename, l_trans_id in\
1680
 
                        self._limbo_children_names[parent].iteritems():
 
1683
                    for l_filename, l_trans_id in viewitems(
 
1684
                            self._limbo_children_names[parent]):
1681
1685
                        if l_trans_id == trans_id:
1682
1686
                            continue
1683
1687
                        if l_filename.lower() == filename.lower():
1767
1771
            new_path_file_ids = dict((t, self.final_file_id(t)) for p, t in
1768
1772
                                     new_paths)
1769
1773
            entries = self._tree.iter_entries_by_dir(
1770
 
                new_path_file_ids.values())
 
1774
                viewvalues(new_path_file_ids))
1771
1775
            old_paths = dict((e.file_id, p) for p, e in entries)
1772
1776
            final_kinds = {}
1773
1777
            for num, (path, trans_id) in enumerate(new_paths):
1814
1818
 
1815
1819
        If inventory_delta is None, no inventory delta generation is performed.
1816
1820
        """
1817
 
        tree_paths = list(self._tree_path_ids.iteritems())
1818
 
        tree_paths.sort(reverse=True)
 
1821
        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
1819
1822
        child_pb = ui.ui_factory.nested_progress_bar()
1820
1823
        try:
1821
1824
            for num, (path, trans_id) in enumerate(tree_paths):
1907
1910
        #       problems. (we could observe start time, and finish time, and if
1908
1911
        #       it is less than eg 10% overhead, add a sleep call.)
1909
1912
        paths = FinalPaths(self)
1910
 
        for trans_id, observed in self._observed_sha1s.iteritems():
 
1913
        for trans_id, observed in viewitems(self._observed_sha1s):
1911
1914
            path = paths.get_path(trans_id)
1912
1915
            # We could get the file_id, but dirstate prefers to use the path
1913
1916
            # anyway, and it is 'cheaper' to determine.
2057
2060
        tree_ids = set(self._transform._tree.all_file_ids())
2058
2061
        tree_ids.difference_update(self._transform.tree_file_id(t)
2059
2062
                                   for t in self._transform._removed_id)
2060
 
        tree_ids.update(self._transform._new_id.values())
 
2063
        tree_ids.update(viewvalues(self._transform._new_id))
2061
2064
        return tree_ids
2062
2065
 
2063
2066
    def __iter__(self):
2120
2123
            return children
2121
2124
        children = set(self._transform.iter_tree_children(trans_id))
2122
2125
        # children in the _new_parent set are provided by _by_parent.
2123
 
        children.difference_update(self._transform._new_parent.keys())
 
2126
        children.difference_update(self._transform._new_parent)
2124
2127
        children.update(self._by_parent.get(trans_id, []))
2125
2128
        self._all_children_cache[trans_id] = children
2126
2129
        return children