/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: 2020-02-21 04:28:46 UTC
  • mfrom: (7494 work)
  • mto: This revision was merged to the branch mainline in revision 7496.
  • Revision ID: jelmer@jelmer.uk-20200221042846-r8lzqu0jetkw772i
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
from __future__ import absolute_import
18
 
 
 
17
import contextlib
19
18
import os
20
19
import errno
21
20
from stat import S_ISREG, S_IEXEC
33
32
from breezy import (
34
33
    annotate,
35
34
    bencode,
36
 
    cleanup,
37
35
    controldir,
38
36
    commit,
39
37
    conflicts,
65
63
    supports_symlinks,
66
64
    )
67
65
from .progress import ProgressPhase
68
 
from .sixish import (
69
 
    text_type,
70
 
    viewitems,
71
 
    viewvalues,
72
 
    )
73
66
from .tree import (
74
67
    InterTree,
75
68
    TreeChange,
239
232
        irrelevant.
240
233
 
241
234
        """
242
 
        new_roots = [k for k, v in viewitems(self._new_parent)
 
235
        new_roots = [k for k, v in self._new_parent.items()
243
236
                     if v == ROOT_PARENT]
244
237
        if len(new_roots) < 1:
245
238
            return
480
473
        file_id = self.tree_file_id(trans_id)
481
474
        if file_id is not None:
482
475
            return file_id
483
 
        for key, value in viewitems(self._non_present_ids):
 
476
        for key, value in self._non_present_ids.items():
484
477
            if value == trans_id:
485
478
                return key
486
479
 
510
503
        Only new paths and parents of tree files with assigned ids are used.
511
504
        """
512
505
        by_parent = {}
513
 
        items = list(viewitems(self._new_parent))
 
506
        items = list(self._new_parent.items())
514
507
        items.extend((t, self.final_parent(t))
515
508
                     for t in list(self._tree_id_paths))
516
509
        for trans_id, parent_id in items:
635
628
    def _unversioned_parents(self, by_parent):
636
629
        """If parent directories are versioned, children must be versioned."""
637
630
        conflicts = []
638
 
        for parent_id, children in viewitems(by_parent):
 
631
        for parent_id, children in by_parent.items():
639
632
            if parent_id == ROOT_PARENT:
640
633
                continue
641
634
            if self.final_file_id(parent_id) is not None:
697
690
        conflicts = []
698
691
        if (self._new_name, self._new_parent) == ({}, {}):
699
692
            return conflicts
700
 
        for children in viewvalues(by_parent):
 
693
        for children in by_parent.values():
701
694
            name_ids = []
702
695
            for child_tid in children:
703
696
                name = self.final_name(child_tid)
732
725
        removed_tree_ids = set((self.tree_file_id(trans_id) for trans_id in
733
726
                                self._removed_id))
734
727
        active_tree_ids = all_ids.difference(removed_tree_ids)
735
 
        for trans_id, file_id in viewitems(self._new_id):
 
728
        for trans_id, file_id in self._new_id.items():
736
729
            if file_id in active_tree_ids:
737
730
                path = self._tree.id2path(file_id)
738
731
                old_trans_id = self.trans_id_tree_path(path)
742
735
    def _parent_type_conflicts(self, by_parent):
743
736
        """Children must have a directory parent"""
744
737
        conflicts = []
745
 
        for parent_id, children in viewitems(by_parent):
 
738
        for parent_id, children in by_parent.items():
746
739
            if parent_id == ROOT_PARENT:
747
740
                continue
748
741
            no_children = True
1112
1105
        :param serializer: A Serialiser like pack.ContainerSerializer.
1113
1106
        """
1114
1107
        new_name = {k.encode('utf-8'): v.encode('utf-8')
1115
 
                    for k, v in viewitems(self._new_name)}
 
1108
                    for k, v in self._new_name.items()}
1116
1109
        new_parent = {k.encode('utf-8'): v.encode('utf-8')
1117
 
                      for k, v in viewitems(self._new_parent)}
 
1110
                      for k, v in self._new_parent.items()}
1118
1111
        new_id = {k.encode('utf-8'): v
1119
 
                  for k, v in viewitems(self._new_id)}
 
1112
                  for k, v in self._new_id.items()}
1120
1113
        new_executability = {k.encode('utf-8'): int(v)
1121
 
                             for k, v in viewitems(self._new_executability)}
 
1114
                             for k, v in self._new_executability.items()}
1122
1115
        tree_path_ids = {k.encode('utf-8'): v.encode('utf-8')
1123
 
                         for k, v in viewitems(self._tree_path_ids)}
 
1116
                         for k, v in self._tree_path_ids.items()}
1124
1117
        non_present_ids = {k: v.encode('utf-8')
1125
 
                           for k, v in viewitems(self._non_present_ids)}
 
1118
                           for k, v in self._non_present_ids.items()}
1126
1119
        removed_contents = [trans_id.encode('utf-8')
1127
1120
                            for trans_id in self._removed_contents]
1128
1121
        removed_id = [trans_id.encode('utf-8')
1140
1133
            }
1141
1134
        yield serializer.bytes_record(bencode.bencode(attribs),
1142
1135
                                      ((b'attribs',),))
1143
 
        for trans_id, kind in sorted(viewitems(self._new_contents)):
 
1136
        for trans_id, kind in sorted(self._new_contents.items()):
1144
1137
            if kind == 'file':
1145
1138
                with open(self._limbo_name(trans_id), 'rb') as cur_file:
1146
1139
                    lines = cur_file.readlines()
1166
1159
        attribs = bencode.bdecode(content)
1167
1160
        self._id_number = attribs[b'_id_number']
1168
1161
        self._new_name = {k.decode('utf-8'): v.decode('utf-8')
1169
 
                          for k, v in viewitems(attribs[b'_new_name'])}
 
1162
                          for k, v in attribs[b'_new_name'].items()}
1170
1163
        self._new_parent = {k.decode('utf-8'): v.decode('utf-8')
1171
 
                            for k, v in viewitems(attribs[b'_new_parent'])}
 
1164
                            for k, v in attribs[b'_new_parent'].items()}
1172
1165
        self._new_executability = {
1173
1166
            k.decode('utf-8'): bool(v)
1174
 
            for k, v in viewitems(attribs[b'_new_executability'])}
 
1167
            for k, v in attribs[b'_new_executability'].items()}
1175
1168
        self._new_id = {k.decode('utf-8'): v
1176
 
                        for k, v in viewitems(attribs[b'_new_id'])}
1177
 
        self._r_new_id = {v: k for k, v in viewitems(self._new_id)}
 
1169
                        for k, v in attribs[b'_new_id'].items()}
 
1170
        self._r_new_id = {v: k for k, v in self._new_id.items()}
1178
1171
        self._tree_path_ids = {}
1179
1172
        self._tree_id_paths = {}
1180
 
        for bytepath, trans_id in viewitems(attribs[b'_tree_path_ids']):
 
1173
        for bytepath, trans_id in attribs[b'_tree_path_ids'].items():
1181
1174
            path = bytepath.decode('utf-8')
1182
1175
            trans_id = trans_id.decode('utf-8')
1183
1176
            self._tree_path_ids[path] = trans_id
1189
1182
            for trans_id in attribs[b'_removed_contents'])
1190
1183
        self._non_present_ids = {
1191
1184
            k: v.decode('utf-8')
1192
 
            for k, v in viewitems(attribs[b'_non_present_ids'])}
 
1185
            for k, v in attribs[b'_non_present_ids'].items()}
1193
1186
        for ((trans_id, kind),), content in records:
1194
1187
            trans_id = trans_id.decode('utf-8')
1195
1188
            kind = kind.decode('ascii')
1280
1273
        if self._tree is None:
1281
1274
            return
1282
1275
        try:
1283
 
            limbo_paths = list(viewvalues(self._limbo_files))
 
1276
            limbo_paths = list(self._limbo_files.values())
1284
1277
            limbo_paths.extend(self._possibly_stale_limbo_files)
1285
1278
            limbo_paths.sort(reverse=True)
1286
1279
            for path in limbo_paths:
1748
1741
                            in (trans_id, None)):
1749
1742
                        use_direct_path = True
1750
1743
                else:
1751
 
                    for l_filename, l_trans_id in viewitems(
1752
 
                            self._limbo_children_names[parent]):
 
1744
                    for l_filename, l_trans_id in (
 
1745
                            self._limbo_children_names[parent].items()):
1753
1746
                        if l_trans_id == trans_id:
1754
1747
                            continue
1755
1748
                        if l_filename.lower() == filename.lower():
1878
1871
 
1879
1872
        If inventory_delta is None, no inventory delta generation is performed.
1880
1873
        """
1881
 
        tree_paths = sorted(viewitems(self._tree_path_ids), reverse=True)
 
1874
        tree_paths = sorted(self._tree_path_ids.items(), reverse=True)
1882
1875
        with ui.ui_factory.nested_progress_bar() as child_pb:
1883
1876
            for num, (path, trans_id) in enumerate(tree_paths):
1884
1877
                # do not attempt to move root into a subdirectory of itself.
1963
1956
        #       problems. (we could observe start time, and finish time, and if
1964
1957
        #       it is less than eg 10% overhead, add a sleep call.)
1965
1958
        paths = FinalPaths(self)
1966
 
        for trans_id, observed in viewitems(self._observed_sha1s):
 
1959
        for trans_id, observed in self._observed_sha1s.items():
1967
1960
            path = paths.get_path(trans_id)
1968
1961
            self._tree._observed_sha1(path, observed)
1969
1962
 
2110
2103
        tree_ids = set(self._transform._tree.all_file_ids())
2111
2104
        tree_ids.difference_update(self._transform.tree_file_id(t)
2112
2105
                                   for t in self._transform._removed_id)
2113
 
        tree_ids.update(viewvalues(self._transform._new_id))
 
2106
        tree_ids.update(self._transform._new_id.values())
2114
2107
        return tree_ids
2115
2108
 
2116
2109
    def all_versioned_paths(self):
2408
2401
                executable = None
2409
2402
            if kind == 'symlink':
2410
2403
                link_or_sha1 = os.readlink(limbo_name)
2411
 
                if not isinstance(link_or_sha1, text_type):
 
2404
                if not isinstance(link_or_sha1, str):
2412
2405
                    link_or_sha1 = link_or_sha1.decode(osutils._fs_enc)
2413
2406
        executable = tt._new_executability.get(trans_id, executable)
2414
2407
        return kind, size, executable, link_or_sha1
2593
2586
    :param delta_from_tree: If true, build_tree may use the input Tree to
2594
2587
        generate the inventory delta.
2595
2588
    """
2596
 
    with cleanup.ExitStack() as exit_stack:
 
2589
    with contextlib.ExitStack() as exit_stack:
2597
2590
        exit_stack.enter_context(wt.lock_tree_write())
2598
2591
        exit_stack.enter_context(tree.lock_read())
2599
2592
        if accelerator_tree is not None:
2702
2695
            precomputed_delta = None
2703
2696
        conflicts = cook_conflicts(raw_conflicts, tt)
2704
2697
        for conflict in conflicts:
2705
 
            trace.warning(text_type(conflict))
 
2698
            trace.warning(str(conflict))
2706
2699
        try:
2707
2700
            wt.add_conflicts(conflicts)
2708
2701
        except errors.UnsupportedOperation:
2896
2889
                    unversioned_filter=working_tree.is_ignored)
2897
2890
                delta.report_changes(tt.iter_changes(), change_reporter)
2898
2891
            for conflict in conflicts:
2899
 
                trace.warning(text_type(conflict))
 
2892
                trace.warning(str(conflict))
2900
2893
            pp.next_phase()
2901
2894
            tt.apply()
2902
2895
            if working_tree.supports_merge_modified():