/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

Support user.signingkey configuration variable in .git/config.

Merged from https://code.launchpad.net/~jelmer/brz/local-git-key/+merge/381000

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