/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

Improve the API for Transform.

Merged from https://code.launchpad.net/~jelmer/brz/transform/+merge/386855

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
23
23
 
24
24
from . import (
25
25
    config as _mod_config,
 
26
    controldir,
26
27
    errors,
27
28
    lazy_import,
 
29
    osutils,
28
30
    registry,
29
31
    trace,
30
32
    tree,
32
34
lazy_import.lazy_import(globals(), """
33
35
from breezy import (
34
36
    annotate,
35
 
    bencode,
36
37
    cleanup,
37
 
    controldir,
38
38
    commit,
39
39
    conflicts,
40
 
    delta,
41
40
    lock,
42
41
    multiparent,
43
 
    osutils,
44
42
    revision as _mod_revision,
45
43
    ui,
46
44
    urlutils,
47
45
    )
 
46
from breezy.i18n import gettext
48
47
from breezy.bzr import (
49
48
    inventory,
50
49
    inventorytree,
51
50
    )
52
 
from breezy.i18n import gettext
53
51
""")
 
52
 
54
53
from .errors import (DuplicateKey,
55
54
                     CantMoveRoot,
56
55
                     BzrError, InternalBzrError)
188
187
        """Support Context Manager API."""
189
188
        self.finalize()
190
189
 
 
190
    def iter_tree_children(self, trans_id):
 
191
        """Iterate through the entry's tree children, if any.
 
192
 
 
193
        :param trans_id: trans id to iterate
 
194
        :returns: Iterator over paths
 
195
        """
 
196
        raise NotImplementedError(self.iter_tree_children)
 
197
 
 
198
    def _read_symlink_target(self, trans_id):
 
199
        raise NotImplementedError(self._read_symlink_target)
 
200
 
 
201
    def canonical_path(self, path):
 
202
        return path
 
203
 
 
204
    def tree_kind(self, trans_id):
 
205
        raise NotImplementedError(self.tree_kind)
 
206
 
191
207
    def finalize(self):
192
208
        """Release the working tree lock, if held.
193
209
 
247
263
            file_id = self.final_file_id(child_id)
248
264
            if file_id is not None:
249
265
                self.unversion_file(child_id)
250
 
            self.version_file(file_id, child_id)
 
266
            self.version_file(child_id, file_id=file_id)
251
267
 
252
268
        # the physical root needs a new transaction id
253
269
        self._tree_path_ids.pop("")
257
273
            parent = self._new_root
258
274
        self.adjust_path(name, parent, old_root)
259
275
        self.create_directory(old_root)
260
 
        self.version_file(old_root_file_id, old_root)
 
276
        self.version_file(old_root, file_id=old_root_file_id)
261
277
        self.unversion_file(self._new_root)
262
278
 
263
279
    def fixup_new_roots(self):
297
313
                and self._new_root not in self._removed_id):
298
314
            self.unversion_file(self._new_root)
299
315
        if file_id is not None:
300
 
            self.version_file(file_id, self._new_root)
 
316
            self.version_file(self._new_root, file_id=file_id)
301
317
 
302
318
        # Now move children of new root into old root directory.
303
319
        # Ensure all children are registered with the transaction, but don't
391
407
        """Set the reference associated with a directory"""
392
408
        unique_add(self._new_reference_revision, trans_id, revision_id)
393
409
 
394
 
    def version_file(self, file_id, trans_id):
 
410
    def version_file(self, trans_id, file_id=None):
395
411
        """Schedule a file to become versioned."""
396
412
        if file_id is None:
397
413
            raise ValueError()
819
835
        """Helper function to create a new filesystem entry."""
820
836
        trans_id = self.create_path(name, parent_id)
821
837
        if file_id is not None:
822
 
            self.version_file(file_id, trans_id)
 
838
            self.version_file(trans_id, file_id=file_id)
823
839
        return trans_id
824
840
 
825
841
    def new_file(self, name, parent_id, contents, file_id=None,
897
913
                # The child is removed as part of the transform. Since it was
898
914
                # versioned before, it's not an orphan
899
915
                continue
900
 
            elif self.final_file_id(child_tid) is None:
 
916
            if self.final_file_id(child_tid) is None:
901
917
                # The child is not versioned
902
918
                orphans.append(child_tid)
903
919
            else:
1144
1160
 
1145
1161
        :param serializer: A Serialiser like pack.ContainerSerializer.
1146
1162
        """
 
1163
        from . import bencode
1147
1164
        new_name = {k.encode('utf-8'): v.encode('utf-8')
1148
1165
                    for k, v in viewitems(self._new_name)}
1149
1166
        new_parent = {k.encode('utf-8'): v.encode('utf-8')
1195
1212
        :param records: An iterable of (names, content) tuples, as per
1196
1213
            pack.ContainerPushParser.
1197
1214
        """
 
1215
        from . import bencode
1198
1216
        names, content = next(records)
1199
1217
        attribs = bencode.bdecode(content)
1200
1218
        self._id_number = attribs[b'_id_number']
1403
1421
            descendants.update(self._limbo_descendants(descendant))
1404
1422
        return descendants
1405
1423
 
 
1424
    def _set_mode(self, trans_id, mode_id, typefunc):
 
1425
        raise NotImplementedError(self._set_mode)
 
1426
 
1406
1427
    def create_file(self, contents, trans_id, mode_id=None, sha1=None):
1407
1428
        """Schedule creation of a new file.
1408
1429
 
2014
2035
        limbodir = osutils.mkdtemp(prefix='bzr-limbo-')
2015
2036
        DiskTreeTransform.__init__(self, tree, limbodir, pb, case_sensitive)
2016
2037
 
2017
 
    def canonical_path(self, path):
2018
 
        return path
2019
 
 
2020
2038
    def tree_kind(self, trans_id):
2021
2039
        path = self._tree_id_paths.get(trans_id)
2022
2040
        if path is None:
2709
2727
                    # getting the file text, and get them all at once.
2710
2728
                    trans_id = tt.create_path(entry.name, parent_id)
2711
2729
                    file_trans_id[file_id] = trans_id
2712
 
                    tt.version_file(file_id, trans_id)
 
2730
                    tt.version_file(trans_id, file_id=file_id)
2713
2731
                    executable = tree.is_executable(tree_path)
2714
2732
                    if executable:
2715
2733
                        tt.set_executability(executable, trans_id)
2925
2943
            conflicts, merge_modified = _prepare_revert_transform(
2926
2944
                working_tree, target_tree, tt, filenames, backups, pp)
2927
2945
            if change_reporter:
 
2946
                from . import delta
2928
2947
                change_reporter = delta._ChangeReporter(
2929
2948
                    unversioned_filter=working_tree.is_ignored)
2930
2949
                delta.report_changes(tt.iter_changes(), change_reporter)
3013
3032
                        new_trans_id = tt.create_path(wt_name, parent_trans_id)
3014
3033
                        if wt_versioned and target_versioned:
3015
3034
                            tt.unversion_file(trans_id)
3016
 
                            tt.version_file(file_id, new_trans_id)
 
3035
                            tt.version_file(new_trans_id, file_id=file_id)
3017
3036
                        # New contents should have the same unix perms as old
3018
3037
                        # contents
3019
3038
                        mode_id = trans_id
3051
3070
                elif target_kind is not None:
3052
3071
                    raise AssertionError(target_kind)
3053
3072
            if not wt_versioned and target_versioned:
3054
 
                tt.version_file(file_id, trans_id)
 
3073
                tt.version_file(trans_id, file_id=file_id)
3055
3074
            if wt_versioned and not target_versioned:
3056
3075
                tt.unversion_file(trans_id)
3057
3076
            if (target_name is not None
3196
3215
            if path_tree and path_tree.path2id('') == file_id:
3197
3216
                # This is the root entry, skip it
3198
3217
                continue
3199
 
            tt.version_file(file_id, conflict[1])
 
3218
            tt.version_file(conflict[1], file_id=file_id)
3200
3219
            new_conflicts.add((c_type, 'Versioned directory', conflict[1]))
3201
3220
        elif c_type == 'non-directory parent':
3202
3221
            parent_id = conflict[1]