/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2018-11-16 15:19:49 UTC
  • mfrom: (7141.7.6 no-file-ids)
  • Revision ID: breezy.the.bot@gmail.com-20181116151949-hrmuv6s7ow1cqdhi
Drop file_id argument from read functions in Tree.

Merged from https://code.launchpad.net/~jelmer/brz/no-file-ids/+merge/357984

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transform.py
1914
1914
        paths = FinalPaths(self)
1915
1915
        for trans_id, observed in viewitems(self._observed_sha1s):
1916
1916
            path = paths.get_path(trans_id)
1917
 
            # We could get the file_id, but dirstate prefers to use the path
1918
 
            # anyway, and it is 'cheaper' to determine.
1919
 
            # file_id = self._new_id[trans_id]
1920
 
            self._tree._observed_sha1(None, path, observed)
 
1917
            self._tree._observed_sha1(path, observed)
1921
1918
 
1922
1919
 
1923
1920
class TransformPreview(DiskTreeTransform):
2010
2007
 
2011
2008
    def _get_file_revision(self, path, file_id, vf, tree_revision):
2012
2009
        parent_keys = [
2013
 
                (file_id, t.get_file_revision(t.id2path(file_id), file_id))
 
2010
                (file_id, t.get_file_revision(t.id2path(file_id)))
2014
2011
                for t in self._iter_parent_trees()]
2015
2012
        vf.add_lines((file_id, tree_revision), parent_keys,
2016
 
                     self.get_file_lines(path, file_id))
 
2013
                     self.get_file_lines(path))
2017
2014
        repo = self._get_repository()
2018
2015
        base_vf = repo.texts
2019
2016
        if base_vf not in vf.fallback_versionedfiles:
2037
2034
            executable = False
2038
2035
        else:
2039
2036
            file_id = self._transform.final_file_id(self._path2trans_id(path))
2040
 
            executable = self.is_executable(path, file_id)
 
2037
            executable = self.is_executable(path)
2041
2038
        return kind, executable, None
2042
2039
 
2043
2040
    def is_locked(self):
2177
2174
                ordered_ids.append((trans_id, parent_file_id))
2178
2175
        return ordered_ids
2179
2176
 
2180
 
    def iter_child_entries(self, path, file_id=None):
 
2177
    def iter_child_entries(self, path):
2181
2178
        trans_id = self._path2trans_id(path)
2182
2179
        if trans_id is None:
2183
2180
            raise errors.NoSuchFile(path)
2236
2233
            for path, entry in entries:
2237
2234
                yield path, 'V', entry.kind, entry.file_id, entry
2238
2235
 
2239
 
    def kind(self, path, file_id=None):
 
2236
    def kind(self, path):
2240
2237
        trans_id = self._path2trans_id(path)
2241
2238
        if trans_id is None:
2242
2239
            raise errors.NoSuchFile(path)
2243
2240
        return self._transform.final_kind(trans_id)
2244
2241
 
2245
 
    def stored_kind(self, path, file_id=None):
 
2242
    def stored_kind(self, path):
2246
2243
        trans_id = self._path2trans_id(path)
2247
2244
        if trans_id is None:
2248
2245
            raise errors.NoSuchFile(path)
2249
2246
        try:
2250
2247
            return self._transform._new_contents[trans_id]
2251
2248
        except KeyError:
2252
 
            return self._transform._tree.stored_kind(path, file_id)
 
2249
            return self._transform._tree.stored_kind(path)
2253
2250
 
2254
 
    def get_file_mtime(self, path, file_id=None):
 
2251
    def get_file_mtime(self, path):
2255
2252
        """See Tree.get_file_mtime"""
2256
 
        if file_id is None:
2257
 
            file_id = self.path2id(path)
 
2253
        file_id = self.path2id(path)
2258
2254
        if file_id is None:
2259
2255
            raise errors.NoSuchFile(path)
2260
2256
        if not self._content_change(file_id):
2261
2257
            return self._transform._tree.get_file_mtime(
2262
 
                    self._transform._tree.id2path(file_id), file_id)
 
2258
                    self._transform._tree.id2path(file_id))
2263
2259
        trans_id = self._path2trans_id(path)
2264
2260
        return self._stat_limbo_file(trans_id).st_mtime
2265
2261
 
2266
 
    def get_file_size(self, path, file_id=None):
 
2262
    def get_file_size(self, path):
2267
2263
        """See Tree.get_file_size"""
2268
2264
        trans_id = self._path2trans_id(path)
2269
2265
        if trans_id is None:
2273
2269
            return None
2274
2270
        if trans_id in self._transform._new_contents:
2275
2271
            return self._stat_limbo_file(trans_id).st_size
2276
 
        if self.kind(path, file_id) == 'file':
2277
 
            return self._transform._tree.get_file_size(path, file_id)
 
2272
        if self.kind(path) == 'file':
 
2273
            return self._transform._tree.get_file_size(path)
2278
2274
        else:
2279
2275
            return None
2280
2276
 
2281
 
    def get_file_verifier(self, path, file_id=None, stat_value=None):
 
2277
    def get_file_verifier(self, path, stat_value=None):
2282
2278
        trans_id = self._path2trans_id(path)
2283
2279
        if trans_id is None:
2284
2280
            raise errors.NoSuchFile(path)
2285
2281
        kind = self._transform._new_contents.get(trans_id)
2286
2282
        if kind is None:
2287
 
            return self._transform._tree.get_file_verifier(path, file_id)
 
2283
            return self._transform._tree.get_file_verifier(path)
2288
2284
        if kind == 'file':
2289
 
            with self.get_file(path, file_id) as fileobj:
 
2285
            with self.get_file(path) as fileobj:
2290
2286
                return ("SHA1", sha_file(fileobj))
2291
2287
 
2292
 
    def get_file_sha1(self, path, file_id=None, stat_value=None):
 
2288
    def get_file_sha1(self, path, stat_value=None):
2293
2289
        trans_id = self._path2trans_id(path)
2294
2290
        if trans_id is None:
2295
2291
            raise errors.NoSuchFile(path)
2296
2292
        kind = self._transform._new_contents.get(trans_id)
2297
2293
        if kind is None:
2298
 
            return self._transform._tree.get_file_sha1(path, file_id)
 
2294
            return self._transform._tree.get_file_sha1(path)
2299
2295
        if kind == 'file':
2300
 
            with self.get_file(path, file_id) as fileobj:
 
2296
            with self.get_file(path) as fileobj:
2301
2297
                return sha_file(fileobj)
2302
2298
 
2303
 
    def is_executable(self, path, file_id=None):
 
2299
    def is_executable(self, path):
2304
2300
        trans_id = self._path2trans_id(path)
2305
2301
        if trans_id is None:
2306
2302
            return False
2308
2304
            return self._transform._new_executability[trans_id]
2309
2305
        except KeyError:
2310
2306
            try:
2311
 
                return self._transform._tree.is_executable(path, file_id)
 
2307
                return self._transform._tree.is_executable(path)
2312
2308
            except OSError as e:
2313
2309
                if e.errno == errno.ENOENT:
2314
2310
                    return False
2378
2374
            raise ValueError('want_unversioned is not supported')
2379
2375
        return self._transform.iter_changes()
2380
2376
 
2381
 
    def get_file(self, path, file_id=None):
 
2377
    def get_file(self, path):
2382
2378
        """See Tree.get_file"""
2383
 
        if file_id is None:
2384
 
            file_id = self.path2id(path)
 
2379
        file_id = self.path2id(path)
2385
2380
        if not self._content_change(file_id):
2386
 
            return self._transform._tree.get_file(path, file_id)
 
2381
            return self._transform._tree.get_file(path)
2387
2382
        trans_id = self._path2trans_id(path)
2388
2383
        name = self._transform._limbo_name(trans_id)
2389
2384
        return open(name, 'rb')
2390
2385
 
2391
 
    def get_file_with_stat(self, path, file_id=None):
2392
 
        return self.get_file(path, file_id), None
 
2386
    def get_file_with_stat(self, path):
 
2387
        return self.get_file(path), None
2393
2388
 
2394
 
    def annotate_iter(self, path, file_id=None,
 
2389
    def annotate_iter(self, path,
2395
2390
                      default_revision=_mod_revision.CURRENT_REVISION):
2396
 
        if file_id is None:
2397
 
            file_id = self.path2id(path)
 
2391
        file_id = self.path2id(path)
2398
2392
        changes = self._iter_changes_cache.get(file_id)
2399
2393
        if changes is None:
2400
2394
            get_old = True
2406
2400
            get_old = (kind[0] == 'file' and versioned[0])
2407
2401
        if get_old:
2408
2402
            old_annotation = self._transform._tree.annotate_iter(
2409
 
                    path, file_id=file_id, default_revision=default_revision)
 
2403
                    path, default_revision=default_revision)
2410
2404
        else:
2411
2405
            old_annotation = []
2412
2406
        if changes is None:
2421
2415
        #       It would be nice to be able to use the new Annotator based
2422
2416
        #       approach, as well.
2423
2417
        return annotate.reannotate([old_annotation],
2424
 
                                   self.get_file(path, file_id).readlines(),
 
2418
                                   self.get_file(path).readlines(),
2425
2419
                                   default_revision)
2426
2420
 
2427
 
    def get_symlink_target(self, path, file_id=None):
 
2421
    def get_symlink_target(self, path):
2428
2422
        """See Tree.get_symlink_target"""
2429
 
        if file_id is None:
2430
 
            file_id = self.path2id(path)
 
2423
        file_id = self.path2id(path)
2431
2424
        if not self._content_change(file_id):
2432
2425
            return self._transform._tree.get_symlink_target(path)
2433
2426
        trans_id = self._path2trans_id(path)
2453
2446
                else:
2454
2447
                    kind = 'unknown'
2455
2448
                    versioned_kind = self._transform._tree.stored_kind(
2456
 
                            self._transform._tree.id2path(file_id),
2457
 
                            file_id)
 
2449
                            self._transform._tree.id2path(file_id))
2458
2450
                if versioned_kind == 'directory':
2459
2451
                    subdirs.append(child_id)
2460
2452
                children.append((path_from_root, basename, kind, None,
2632
2624
                    trans_id = tt.create_path(entry.name, parent_id)
2633
2625
                    file_trans_id[file_id] = trans_id
2634
2626
                    tt.version_file(file_id, trans_id)
2635
 
                    executable = tree.is_executable(tree_path, file_id)
 
2627
                    executable = tree.is_executable(tree_path)
2636
2628
                    if executable:
2637
2629
                        tt.set_executability(executable, trans_id)
2638
2630
                    trans_data = (trans_id, file_id, tree_path, entry.text_sha1)
2733
2725
        return True
2734
2726
    if entry.kind == "file":
2735
2727
        with open(target_path, 'rb') as f1, \
2736
 
             tree.get_file(tree_path, file_id) as f2:
 
2728
             tree.get_file(tree_path) as f2:
2737
2729
            if osutils.compare_files(f1, f2):
2738
2730
                return True
2739
2731
    elif entry.kind == "symlink":
2740
 
        if tree.get_symlink_target(tree_path, file_id) == os.readlink(target_path):
 
2732
        if tree.get_symlink_target(tree_path) == os.readlink(target_path):
2741
2733
            return True
2742
2734
    return False
2743
2735
 
2777
2769
    name = entry.name
2778
2770
    kind = entry.kind
2779
2771
    if kind == 'file':
2780
 
        with tree.get_file(path, entry.file_id) as f:
2781
 
            executable = tree.is_executable(path, entry.file_id)
 
2772
        with tree.get_file(path) as f:
 
2773
            executable = tree.is_executable(path)
2782
2774
            return tt.new_file(
2783
2775
                    name, parent_id, osutils.file_iterator(f), entry.file_id,
2784
2776
                    executable)
2788
2780
            tt.set_tree_reference(entry.reference_revision, trans_id)
2789
2781
        return trans_id
2790
2782
    elif kind == 'symlink':
2791
 
        target = tree.get_symlink_target(path, entry.file_id)
 
2783
        target = tree.get_symlink_target(path)
2792
2784
        return tt.new_symlink(name, parent_id, target, entry.file_id)
2793
2785
    else:
2794
2786
        raise errors.BadFileKindError(name, kind)
2802
2794
      content filters to apply to the bytes output in the working tree.
2803
2795
      This only applies if the working tree supports content filtering.
2804
2796
    """
2805
 
    kind = tree.kind(path, file_id)
 
2797
    kind = tree.kind(path)
2806
2798
    if kind == 'directory':
2807
2799
        tt.create_directory(trans_id)
2808
2800
    elif kind == "file":
2809
2801
        if chunks is None:
2810
 
            f = tree.get_file(path, file_id)
 
2802
            f = tree.get_file(path)
2811
2803
            chunks = osutils.file_iterator(f)
2812
2804
        else:
2813
2805
            f = None
2822
2814
            if f is not None:
2823
2815
                f.close()
2824
2816
    elif kind == "symlink":
2825
 
        tt.create_symlink(tree.get_symlink_target(path, file_id), trans_id)
 
2817
        tt.create_symlink(tree.get_symlink_target(path), trans_id)
2826
2818
    else:
2827
2819
        raise AssertionError('Unknown kind %r' % kind)
2828
2820
 
2904
2896
            if changed_content:
2905
2897
                keep_content = False
2906
2898
                if wt_kind == 'file' and (backups or target_kind is None):
2907
 
                    wt_sha1 = working_tree.get_file_sha1(wt_path, file_id)
 
2899
                    wt_sha1 = working_tree.get_file_sha1(wt_path)
2908
2900
                    if merge_modified.get(file_id) != wt_sha1:
2909
2901
                        # acquire the basis tree lazily to prevent the
2910
2902
                        # expense of accessing it when it's not needed ?
2917
2909
                            if target_kind is None and not target_versioned:
2918
2910
                                keep_content = True
2919
2911
                        else:
2920
 
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path, file_id):
 
2912
                            if wt_sha1 != basis_tree.get_file_sha1(basis_path):
2921
2913
                                keep_content = True
2922
2914
                if wt_kind is not None:
2923
2915
                    if not keep_content:
2939
2931
                    tt.create_directory(trans_id)
2940
2932
                    if target_kind == 'tree-reference':
2941
2933
                        revision = target_tree.get_reference_revision(
2942
 
                                target_path, file_id)
 
2934
                                target_path)
2943
2935
                        tt.set_tree_reference(revision, trans_id)
2944
2936
                elif target_kind == 'symlink':
2945
2937
                    tt.create_symlink(target_tree.get_symlink_target(
2946
 
                            target_path, file_id), trans_id)
 
2938
                            target_path), trans_id)
2947
2939
                elif target_kind == 'file':
2948
2940
                    deferred_files.append((target_path, (trans_id, mode_id, file_id)))
2949
2941
                    if basis_tree is None:
2950
2942
                        basis_tree = working_tree.basis_tree()
2951
2943
                        basis_tree.lock_read()
2952
 
                    new_sha1 = target_tree.get_file_sha1(target_path, file_id)
 
2944
                    new_sha1 = target_tree.get_file_sha1(target_path)
2953
2945
                    basis_path = find_previous_path(target_tree, basis_tree, target_path)
2954
2946
                    if (basis_path is not None and
2955
 
                        new_sha1 == basis_tree.get_file_sha1(basis_path, file_id)):
 
2947
                        new_sha1 == basis_tree.get_file_sha1(basis_path)):
2956
2948
                        if file_id in merge_modified:
2957
2949
                            del merge_modified[file_id]
2958
2950
                    else: