/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-11-19 18:35:20 UTC
  • mfrom: (6809.4.27 swap-arguments)
  • Revision ID: jelmer@jelmer.uk-20171119183520-fmw89uw30e0tbhwz
Merge lp:~jelmer/brz/swap-arguments.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
568
568
                        self.tree_kind(t) == 'directory'])
569
569
        for trans_id in self._removed_id:
570
570
            file_id = self.tree_file_id(trans_id)
 
571
            path = self._tree.id2path(file_id)
571
572
            if file_id is not None:
572
 
                if self._tree.stored_kind(file_id) == 'directory':
 
573
                if self._tree.stored_kind(path, file_id) == 'directory':
573
574
                    parents.append(trans_id)
574
575
            elif self.tree_kind(trans_id) == 'directory':
575
576
                parents.append(trans_id)
1078
1079
    def _text_parent(self, trans_id):
1079
1080
        file_id = self.tree_file_id(trans_id)
1080
1081
        try:
1081
 
            if file_id is None or self._tree.kind(file_id) != 'file':
 
1082
            if (file_id is None or
 
1083
                    self._tree.kind(self._tree.id2path(file_id), file_id) != 'file'):
1082
1084
                return None
1083
1085
        except errors.NoSuchFile:
1084
1086
            return None
1089
1091
        file_id = self._text_parent(trans_id)
1090
1092
        if file_id is None:
1091
1093
            return ()
1092
 
        return (self._tree.get_file_text(file_id),)
 
1094
        return (self._tree.get_file_text(self._tree.id2path(file_id), file_id),)
1093
1095
 
1094
1096
    def _get_parents_lines(self, trans_id):
1095
1097
        """Get lines for compression parents of this file."""
1096
1098
        file_id = self._text_parent(trans_id)
1097
1099
        if file_id is None:
1098
1100
            return ()
1099
 
        return (self._tree.get_file_lines(file_id),)
 
1101
        return (self._tree.get_file_lines(self._tree.id2path(file_id), file_id),)
1100
1102
 
1101
1103
    def serialize(self, serializer):
1102
1104
        """Serialize this TreeTransform.
1787
1789
                needs_entry = False
1788
1790
                kind = self.final_kind(trans_id)
1789
1791
                if kind is None:
1790
 
                    kind = self._tree.stored_kind(file_id)
 
1792
                    kind = self._tree.stored_kind(
 
1793
                            self._tree.id2path(file_id), file_id)
1791
1794
                parent_trans_id = self.final_parent(trans_id)
1792
1795
                parent_file_id = new_path_file_ids.get(parent_trans_id)
1793
1796
                if parent_file_id is None:
2008
2011
            except errors.NoSuchRevisionInTree:
2009
2012
                yield self._get_repository().revision_tree(revision_id)
2010
2013
 
2011
 
    def _get_file_revision(self, file_id, vf, tree_revision):
2012
 
        parent_keys = [(file_id, t.get_file_revision(file_id)) for t in
2013
 
                       self._iter_parent_trees()]
 
2014
    def _get_file_revision(self, path, file_id, vf, tree_revision):
 
2015
        parent_keys = [
 
2016
                (file_id, t.get_file_revision(t.id2path(file_id), file_id))
 
2017
                for t in self._iter_parent_trees()]
2014
2018
        vf.add_lines((file_id, tree_revision), parent_keys,
2015
 
                     self.get_file_lines(file_id))
 
2019
                     self.get_file_lines(path, file_id))
2016
2020
        repo = self._get_repository()
2017
2021
        base_vf = repo.texts
2018
2022
        if base_vf not in vf.fallback_versionedfiles:
2038
2042
            executable = False
2039
2043
        else:
2040
2044
            file_id = self._transform.final_file_id(self._path2trans_id(path))
2041
 
            executable = self.is_executable(file_id, path)
 
2045
            executable = self.is_executable(path, file_id)
2042
2046
        return kind, executable, None
2043
2047
 
2044
2048
    def is_locked(self):
2156
2160
                continue
2157
2161
            kind = self._transform.final_kind(trans_id)
2158
2162
            if kind is None:
2159
 
                kind = self._transform._tree.stored_kind(file_id)
 
2163
                kind = self._transform._tree.stored_kind(
 
2164
                    self._transform._tree.id2path(file_id),
 
2165
                    file_id)
2160
2166
            new_entry = inventory.make_entry(
2161
2167
                kind,
2162
2168
                self._transform.final_name(trans_id),
2232
2238
            for path, entry in entries:
2233
2239
                yield path, 'V', entry.kind, entry.file_id, entry
2234
2240
 
2235
 
    def kind(self, file_id):
 
2241
    def kind(self, path, file_id=None):
 
2242
        if file_id is None:
 
2243
            file_id = self.path2id(path)
2236
2244
        trans_id = self._transform.trans_id_file_id(file_id)
2237
2245
        return self._transform.final_kind(trans_id)
2238
2246
 
2239
 
    def stored_kind(self, file_id):
 
2247
    def stored_kind(self, path, file_id=None):
 
2248
        if file_id is None:
 
2249
            file_id = self.path2id(path)
2240
2250
        trans_id = self._transform.trans_id_file_id(file_id)
2241
2251
        try:
2242
2252
            return self._transform._new_contents[trans_id]
2243
2253
        except KeyError:
2244
 
            return self._transform._tree.stored_kind(file_id)
 
2254
            return self._transform._tree.stored_kind(path, file_id)
2245
2255
 
2246
 
    def get_file_mtime(self, file_id, path=None):
 
2256
    def get_file_mtime(self, path, file_id=None):
2247
2257
        """See Tree.get_file_mtime"""
 
2258
        if file_id is None:
 
2259
            file_id = self.path2id(path)
 
2260
        if file_id is None:
 
2261
            raise errors.NoSuchFile(path)
2248
2262
        if not self._content_change(file_id):
2249
 
            return self._transform._tree.get_file_mtime(file_id)
 
2263
            return self._transform._tree.get_file_mtime(
 
2264
                    self._transform._tree.id2path(file_id), file_id)
2250
2265
        return self._stat_limbo_file(file_id).st_mtime
2251
2266
 
2252
2267
    def _file_size(self, entry, stat_value):
2253
 
        return self.get_file_size(entry.file_id)
 
2268
        path = self.id2path(entry.file_id)
 
2269
        return self.get_file_size(path, entry.file_id)
2254
2270
 
2255
 
    def get_file_size(self, file_id):
 
2271
    def get_file_size(self, path, file_id=None):
2256
2272
        """See Tree.get_file_size"""
 
2273
        if file_id is None:
 
2274
            file_id = self.path2id(path)
2257
2275
        trans_id = self._transform.trans_id_file_id(file_id)
2258
2276
        kind = self._transform.final_kind(trans_id)
2259
2277
        if kind != 'file':
2260
2278
            return None
2261
2279
        if trans_id in self._transform._new_contents:
2262
2280
            return self._stat_limbo_file(trans_id=trans_id).st_size
2263
 
        if self.kind(file_id) == 'file':
2264
 
            return self._transform._tree.get_file_size(file_id)
 
2281
        if self.kind(path, file_id) == 'file':
 
2282
            return self._transform._tree.get_file_size(path, file_id)
2265
2283
        else:
2266
2284
            return None
2267
2285
 
2268
 
    def get_file_verifier(self, file_id, path=None, stat_value=None):
 
2286
    def get_file_verifier(self, path, file_id=None, stat_value=None):
 
2287
        if file_id is None:
 
2288
            file_id = self.path2id(path)
2269
2289
        trans_id = self._transform.trans_id_file_id(file_id)
2270
2290
        kind = self._transform._new_contents.get(trans_id)
2271
2291
        if kind is None:
2272
 
            return self._transform._tree.get_file_verifier(file_id)
 
2292
            return self._transform._tree.get_file_verifier(path, file_id)
2273
2293
        if kind == 'file':
2274
 
            fileobj = self.get_file(file_id)
 
2294
            fileobj = self.get_file(path, file_id)
2275
2295
            try:
2276
2296
                return ("SHA1", sha_file(fileobj))
2277
2297
            finally:
2278
2298
                fileobj.close()
2279
2299
 
2280
 
    def get_file_sha1(self, file_id, path=None, stat_value=None):
 
2300
    def get_file_sha1(self, path, file_id=None, stat_value=None):
 
2301
        if file_id is None:
 
2302
            file_id = self.path2id(path)
2281
2303
        trans_id = self._transform.trans_id_file_id(file_id)
2282
2304
        kind = self._transform._new_contents.get(trans_id)
2283
2305
        if kind is None:
2284
 
            return self._transform._tree.get_file_sha1(file_id)
 
2306
            return self._transform._tree.get_file_sha1(path, file_id)
2285
2307
        if kind == 'file':
2286
 
            fileobj = self.get_file(file_id)
 
2308
            fileobj = self.get_file(path, file_id)
2287
2309
            try:
2288
2310
                return sha_file(fileobj)
2289
2311
            finally:
2290
2312
                fileobj.close()
2291
2313
 
2292
 
    def is_executable(self, file_id, path=None):
 
2314
    def is_executable(self, path, file_id=None):
 
2315
        if file_id is None:
 
2316
            file_id = self.path2id(path)
2293
2317
        if file_id is None:
2294
2318
            return False
2295
2319
        trans_id = self._transform.trans_id_file_id(file_id)
2297
2321
            return self._transform._new_executability[trans_id]
2298
2322
        except KeyError:
2299
2323
            try:
2300
 
                return self._transform._tree.is_executable(file_id, path)
 
2324
                return self._transform._tree.is_executable(path, file_id)
2301
2325
            except OSError as e:
2302
2326
                if e.errno == errno.ENOENT:
2303
2327
                    return False
2365
2389
            raise ValueError('want_unversioned is not supported')
2366
2390
        return self._transform.iter_changes()
2367
2391
 
2368
 
    def get_file(self, file_id, path=None):
 
2392
    def get_file(self, path, file_id=None):
2369
2393
        """See Tree.get_file"""
 
2394
        if file_id is None:
 
2395
            file_id = self.path2id(path)
2370
2396
        if not self._content_change(file_id):
2371
 
            return self._transform._tree.get_file(file_id, path)
 
2397
            return self._transform._tree.get_file(path, file_id)
2372
2398
        trans_id = self._transform.trans_id_file_id(file_id)
2373
2399
        name = self._transform._limbo_name(trans_id)
2374
2400
        return open(name, 'rb')
2375
2401
 
2376
 
    def get_file_with_stat(self, file_id, path=None):
2377
 
        return self.get_file(file_id, path), None
 
2402
    def get_file_with_stat(self, path, file_id=None):
 
2403
        return self.get_file(path, file_id), None
2378
2404
 
2379
 
    def annotate_iter(self, file_id,
 
2405
    def annotate_iter(self, path, file_id=None,
2380
2406
                      default_revision=_mod_revision.CURRENT_REVISION):
 
2407
        if file_id is None:
 
2408
            file_id = self.path2id(path)
2381
2409
        changes = self._iter_changes_cache.get(file_id)
2382
2410
        if changes is None:
2383
2411
            get_old = True
2388
2416
                return None
2389
2417
            get_old = (kind[0] == 'file' and versioned[0])
2390
2418
        if get_old:
2391
 
            old_annotation = self._transform._tree.annotate_iter(file_id,
2392
 
                default_revision=default_revision)
 
2419
            old_annotation = self._transform._tree.annotate_iter(
 
2420
                    path, file_id=file_id, default_revision=default_revision)
2393
2421
        else:
2394
2422
            old_annotation = []
2395
2423
        if changes is None:
2404
2432
        #       It would be nice to be able to use the new Annotator based
2405
2433
        #       approach, as well.
2406
2434
        return annotate.reannotate([old_annotation],
2407
 
                                   self.get_file(file_id).readlines(),
 
2435
                                   self.get_file(path, file_id).readlines(),
2408
2436
                                   default_revision)
2409
2437
 
2410
 
    def get_symlink_target(self, file_id, path=None):
 
2438
    def get_symlink_target(self, path, file_id=None):
2411
2439
        """See Tree.get_symlink_target"""
 
2440
        if file_id is None:
 
2441
            file_id = self.path2id(path)
2412
2442
        if not self._content_change(file_id):
2413
 
            return self._transform._tree.get_symlink_target(file_id)
 
2443
            return self._transform._tree.get_symlink_target(path)
2414
2444
        trans_id = self._transform.trans_id_file_id(file_id)
2415
2445
        name = self._transform._limbo_name(trans_id)
2416
2446
        return osutils.readlink(name)
2433
2463
                    versioned_kind = kind
2434
2464
                else:
2435
2465
                    kind = 'unknown'
2436
 
                    versioned_kind = self._transform._tree.stored_kind(file_id)
 
2466
                    versioned_kind = self._transform._tree.stored_kind(
 
2467
                            self._transform._tree.id2path(file_id),
 
2468
                            file_id)
2437
2469
                if versioned_kind == 'directory':
2438
2470
                    subdirs.append(child_id)
2439
2471
                children.append((path_from_root, basename, kind, None,
2613
2645
                    trans_id = tt.create_path(entry.name, parent_id)
2614
2646
                    file_trans_id[file_id] = trans_id
2615
2647
                    tt.version_file(file_id, trans_id)
2616
 
                    executable = tree.is_executable(file_id, tree_path)
 
2648
                    executable = tree.is_executable(tree_path, file_id)
2617
2649
                    if executable:
2618
2650
                        tt.set_executability(executable, trans_id)
2619
2651
                    trans_data = (trans_id, tree_path, entry.text_sha1)
2620
2652
                    deferred_contents.append((file_id, trans_data))
2621
2653
                else:
2622
 
                    file_trans_id[file_id] = new_by_entry(tt, entry, parent_id,
2623
 
                                                          tree)
 
2654
                    file_trans_id[file_id] = new_by_entry(
 
2655
                            tree_path, tt, entry, parent_id, tree)
2624
2656
                if reparent:
2625
2657
                    new_trans_id = file_trans_id[file_id]
2626
2658
                    old_parent = tt.trans_id_tree_path(tree_path)
2678
2710
                tt.create_hardlink(accelerator_tree.abspath(accelerator_path),
2679
2711
                                   trans_id)
2680
2712
            else:
2681
 
                contents = accelerator_tree.get_file(file_id, accelerator_path)
 
2713
                contents = accelerator_tree.get_file(accelerator_path, file_id)
2682
2714
                if wt.supports_content_filtering():
2683
2715
                    filters = wt._content_filter_stack(tree_path)
2684
2716
                    contents = filtered_output_bytes(contents, filters,
2720
2752
        return False
2721
2753
    if entry.kind == "directory":
2722
2754
        return True
 
2755
    path = tree.id2path(file_id)
2723
2756
    if entry.kind == "file":
2724
2757
        f = file(target_path, 'rb')
2725
2758
        try:
2726
 
            if tree.get_file_text(file_id) == f.read():
 
2759
            if tree.get_file_text(path, file_id) == f.read():
2727
2760
                return True
2728
2761
        finally:
2729
2762
            f.close()
2730
2763
    elif entry.kind == "symlink":
2731
 
        if tree.get_symlink_target(file_id) == os.readlink(target_path):
 
2764
        if tree.get_symlink_target(path, file_id) == os.readlink(target_path):
2732
2765
            return True
2733
2766
    return False
2734
2767
 
2763
2796
    return new_conflicts
2764
2797
 
2765
2798
 
2766
 
def new_by_entry(tt, entry, parent_id, tree):
 
2799
def new_by_entry(path, tt, entry, parent_id, tree):
2767
2800
    """Create a new file according to its inventory entry"""
2768
2801
    name = entry.name
2769
2802
    kind = entry.kind
2770
2803
    if kind == 'file':
2771
 
        contents = tree.get_file(entry.file_id).readlines()
2772
 
        executable = tree.is_executable(entry.file_id)
 
2804
        contents = tree.get_file(path, entry.file_id).readlines()
 
2805
        executable = tree.is_executable(path, entry.file_id)
2773
2806
        return tt.new_file(name, parent_id, contents, entry.file_id,
2774
2807
                           executable)
2775
2808
    elif kind in ('directory', 'tree-reference'):
2778
2811
            tt.set_tree_reference(entry.reference_revision, trans_id)
2779
2812
        return trans_id
2780
2813
    elif kind == 'symlink':
2781
 
        target = tree.get_symlink_target(entry.file_id)
 
2814
        target = tree.get_symlink_target(path, entry.file_id)
2782
2815
        return tt.new_symlink(name, parent_id, target, entry.file_id)
2783
2816
    else:
2784
2817
        raise errors.BadFileKindError(name, kind)
2785
2818
 
2786
2819
 
2787
 
def create_from_tree(tt, trans_id, tree, file_id, bytes=None,
 
2820
def create_from_tree(tt, trans_id, tree, path, file_id=None, bytes=None,
2788
2821
    filter_tree_path=None):
2789
2822
    """Create new file contents according to tree contents.
2790
 
    
 
2823
 
2791
2824
    :param filter_tree_path: the tree path to use to lookup
2792
2825
      content filters to apply to the bytes output in the working tree.
2793
2826
      This only applies if the working tree supports content filtering.
2794
2827
    """
2795
 
    kind = tree.kind(file_id)
 
2828
    kind = tree.kind(path, file_id)
2796
2829
    if kind == 'directory':
2797
2830
        tt.create_directory(trans_id)
2798
2831
    elif kind == "file":
2799
2832
        if bytes is None:
2800
 
            tree_file = tree.get_file(file_id)
 
2833
            tree_file = tree.get_file(path, file_id)
2801
2834
            try:
2802
2835
                bytes = tree_file.readlines()
2803
2836
            finally:
2809
2842
                ContentFilterContext(filter_tree_path, tree))
2810
2843
        tt.create_file(bytes, trans_id)
2811
2844
    elif kind == "symlink":
2812
 
        tt.create_symlink(tree.get_symlink_target(file_id), trans_id)
 
2845
        tt.create_symlink(tree.get_symlink_target(path, file_id), trans_id)
2813
2846
    else:
2814
2847
        raise AssertionError('Unknown kind %r' % kind)
2815
2848
 
2899
2932
            if changed_content:
2900
2933
                keep_content = False
2901
2934
                if wt_kind == 'file' and (backups or target_kind is None):
2902
 
                    wt_sha1 = working_tree.get_file_sha1(file_id)
 
2935
                    wt_sha1 = working_tree.get_file_sha1(wt_path, file_id)
2903
2936
                    if merge_modified.get(file_id) != wt_sha1:
2904
2937
                        # acquire the basis tree lazily to prevent the
2905
2938
                        # expense of accessing it when it's not needed ?
2907
2940
                        if basis_tree is None:
2908
2941
                            basis_tree = working_tree.basis_tree()
2909
2942
                            basis_tree.lock_read()
2910
 
                        if basis_tree.has_id(file_id):
2911
 
                            if wt_sha1 != basis_tree.get_file_sha1(file_id):
2912
 
                                keep_content = True
2913
 
                        elif target_kind is None and not target_versioned:
2914
 
                            keep_content = True
 
2943
                        try:
 
2944
                            basis_path = basis_tree.id2path(file_id)
 
2945
                        except errors.NoSuchId:
 
2946
                            if target_kind is None and not target_versioned:
 
2947
                                keep_content = True
 
2948
                        else:
 
2949
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path, file_id):
 
2950
                                keep_content = True
2915
2951
                if wt_kind is not None:
2916
2952
                    if not keep_content:
2917
2953
                        tt.delete_contents(trans_id)
2931
2967
                if target_kind in ('directory', 'tree-reference'):
2932
2968
                    tt.create_directory(trans_id)
2933
2969
                    if target_kind == 'tree-reference':
2934
 
                        revision = target_tree.get_reference_revision(file_id,
2935
 
                                                                      target_path)
 
2970
                        revision = target_tree.get_reference_revision(
 
2971
                                target_path, file_id)
2936
2972
                        tt.set_tree_reference(revision, trans_id)
2937
2973
                elif target_kind == 'symlink':
2938
 
                    tt.create_symlink(target_tree.get_symlink_target(file_id),
2939
 
                                      trans_id)
 
2974
                    tt.create_symlink(target_tree.get_symlink_target(
 
2975
                            target_path, file_id), trans_id)
2940
2976
                elif target_kind == 'file':
2941
2977
                    deferred_files.append((file_id, (trans_id, mode_id)))
2942
2978
                    if basis_tree is None:
2943
2979
                        basis_tree = working_tree.basis_tree()
2944
2980
                        basis_tree.lock_read()
2945
 
                    new_sha1 = target_tree.get_file_sha1(file_id)
2946
 
                    if (basis_tree.has_id(file_id) and
2947
 
                        new_sha1 == basis_tree.get_file_sha1(file_id)):
 
2981
                    new_sha1 = target_tree.get_file_sha1(target_path, file_id)
 
2982
                    try:
 
2983
                        basis_path = basis_tree.id2path(file_id)
 
2984
                    except errors.NoSuchId:
 
2985
                        basis_path = None
 
2986
                    if (basis_path is not None and
 
2987
                        new_sha1 == basis_tree.get_file_sha1(basis_path, file_id)):
2948
2988
                        if file_id in merge_modified:
2949
2989
                            del merge_modified[file_id]
2950
2990
                    else: