/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: 2019-06-15 22:53:27 UTC
  • mfrom: (7337 work)
  • mto: This revision was merged to the branch mainline in revision 7347.
  • Revision ID: jelmer@jelmer.uk-20190615225327-g77kw1v105svs31i
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
71
71
    )
72
72
from .tree import (
73
73
    find_previous_path,
 
74
    TreeChange,
74
75
    )
75
76
 
76
77
 
1002
1003
                and from_parent == to_parent and from_name == to_name
1003
1004
                    and from_executable == to_executable):
1004
1005
                continue
1005
 
            results.append((file_id, (from_path, to_path), modified,
1006
 
                            (from_versioned, to_versioned),
1007
 
                            (from_parent, to_parent),
1008
 
                            (from_name, to_name),
1009
 
                            (from_kind, to_kind),
1010
 
                            (from_executable, to_executable)))
 
1006
            results.append(
 
1007
                TreeChange(
 
1008
                    file_id, (from_path, to_path), modified,
 
1009
                    (from_versioned, to_versioned),
 
1010
                    (from_parent, to_parent),
 
1011
                    (from_name, to_name),
 
1012
                    (from_kind, to_kind),
 
1013
                    (from_executable, to_executable)))
1011
1014
 
1012
 
        def path_key(t):
1013
 
            paths = t[1]
1014
 
            return (paths[0] or '', paths[1] or '')
 
1015
        def path_key(c):
 
1016
            return (c.path[0] or '', c.path[1] or '')
1015
1017
        return iter(sorted(results, key=path_key))
1016
1018
 
1017
1019
    def get_preview_tree(self):
1991
1993
        self._all_children_cache = {}
1992
1994
        self._path2trans_id_cache = {}
1993
1995
        self._final_name_cache = {}
1994
 
        self._iter_changes_cache = dict((c[0], c) for c in
 
1996
        self._iter_changes_cache = dict((c.file_id, c) for c in
1995
1997
                                        self._transform.iter_changes())
1996
1998
 
1997
1999
    def _content_change(self, file_id):
2413
2415
        if changes is None:
2414
2416
            get_old = True
2415
2417
        else:
2416
 
            changed_content, versioned, kind = (changes[2], changes[3],
2417
 
                                                changes[6])
 
2418
            changed_content, versioned, kind = (
 
2419
                changes.changed_content, changes.versioned, changes.kind)
2418
2420
            if kind[1] is None:
2419
2421
                return None
2420
2422
            get_old = (kind[0] == 'file' and versioned[0])
2693
2695
        new_desired_files = desired_files
2694
2696
    else:
2695
2697
        iter = accelerator_tree.iter_changes(tree, include_unchanged=True)
2696
 
        unchanged = [(p[0], p[1]) for (f, p, c, v, d, n, k, e)
2697
 
                     in iter if not (c or e[0] != e[1])]
 
2698
        unchanged = [
 
2699
            change.path for change in iter
 
2700
            if not (change.changed_content or change.executable[0] != change.executable[1])]
2698
2701
        if accelerator_tree.supports_content_filtering():
2699
2702
            unchanged = [(tp, ap) for (tp, ap) in unchanged
2700
2703
                         if not next(accelerator_tree.iter_search_rules([ap]))]
2907
2910
        skip_root = False
2908
2911
    try:
2909
2912
        deferred_files = []
2910
 
        for id_num, (file_id, path, changed_content, versioned, parent, name,
2911
 
                     kind, executable) in enumerate(change_list):
2912
 
            target_path, wt_path = path
2913
 
            target_versioned, wt_versioned = versioned
2914
 
            target_parent, wt_parent = parent
2915
 
            target_name, wt_name = name
2916
 
            target_kind, wt_kind = kind
2917
 
            target_executable, wt_executable = executable
 
2913
        for id_num, change in enumerate(change_list):
 
2914
            file_id = change.file_id
 
2915
            target_path, wt_path = change.path
 
2916
            target_versioned, wt_versioned = change.versioned
 
2917
            target_parent, wt_parent = change.parent_id
 
2918
            target_name, wt_name = change.name
 
2919
            target_kind, wt_kind = change.kind
 
2920
            target_executable, wt_executable = change.executable
2918
2921
            if skip_root and wt_parent is None:
2919
2922
                continue
2920
2923
            trans_id = tt.trans_id_file_id(file_id)
2921
2924
            mode_id = None
2922
 
            if changed_content:
 
2925
            if change.changed_content:
2923
2926
                keep_content = False
2924
2927
                if wt_kind == 'file' and (backups or target_kind is None):
2925
2928
                    wt_sha1 = working_tree.get_file_sha1(wt_path)
3231
3234
    """
3232
3235
    tt = TreeTransform(target_tree)
3233
3236
    try:
3234
 
        for (file_id, paths, changed_content, versioned, parent, name, kind,
3235
 
             executable) in target_tree.iter_changes(source_tree,
3236
 
                                                     include_unchanged=True):
3237
 
            if changed_content:
3238
 
                continue
3239
 
            if kind != ('file', 'file'):
3240
 
                continue
3241
 
            if executable[0] != executable[1]:
3242
 
                continue
3243
 
            trans_id = tt.trans_id_tree_path(paths[1])
 
3237
        for change in target_tree.iter_changes(source_tree, include_unchanged=True):
 
3238
            if change.changed_content:
 
3239
                continue
 
3240
            if change.kind != ('file', 'file'):
 
3241
                continue
 
3242
            if change.executable[0] != change.executable[1]:
 
3243
                continue
 
3244
            trans_id = tt.trans_id_tree_path(change.path[1])
3244
3245
            tt.delete_contents(trans_id)
3245
 
            tt.create_hardlink(source_tree.abspath(paths[0]), trans_id)
 
3246
            tt.create_hardlink(source_tree.abspath(change.path[0]), trans_id)
3246
3247
        tt.apply()
3247
3248
    finally:
3248
3249
        tt.finalize()