← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Andrew Bennetts
  • Date: 2010-10-13 00:26:41 UTC
  • mto: This revision was merged to the branch mainline in revision 5498.
  • Revision ID: andrew.bennetts@canonical.com-20101013002641-9tlh9k89mlj1666m
Keep docs-plain working.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
209
209
        else:
210
210
            self._branch = self.bzrdir.open_branch()
211
211
        self.basedir = realpath(basedir)
212
 
        self._control_files = _control_files
 
212
        # if branch is at our basedir and is a format 6 or less
 
213
        if isinstance(self._format, WorkingTreeFormat2):
 
214
            # share control object
 
215
            self._control_files = self.branch.control_files
 
216
        else:
 
217
            # assume all other formats have their own control files.
 
218
            self._control_files = _control_files
213
219
        self._transport = self._control_files._transport
214
220
        # update the whole cache up front and write to disk if anything changed;
215
221
        # in the future we might want to do this more selectively
256
262
    def _detect_case_handling(self):
257
263
        wt_trans = self.bzrdir.get_workingtree_transport(None)
258
264
        try:
259
 
            wt_trans.stat(self._format.case_sensitive_filename)
 
265
            wt_trans.stat("FoRMaT")
260
266
        except errors.NoSuchFile:
261
267
            self.case_sensitive = True
262
268
        else:
347
353
        return control.open_workingtree(), relpath
348
354
 
349
355
    @staticmethod
350
 
    def open_containing_paths(file_list, default_directory=None,
351
 
                              canonicalize=True, apply_view=True):
 
356
    def open_containing_paths(file_list, default_directory='.',
 
357
        canonicalize=True, apply_view=True):
352
358
        """Open the WorkingTree that contains a set of paths.
353
359
 
354
360
        Fail if the paths given are not all in a single tree.
356
362
        This is used for the many command-line interfaces that take a list of
357
363
        any number of files and that require they all be in the same tree.
358
364
        """
359
 
        if default_directory is None:
360
 
            default_directory = u'.'
361
365
        # recommended replacement for builtins.internal_tree_files
362
366
        if file_list is None or len(file_list) == 0:
363
367
            tree = WorkingTree.open_containing(default_directory)[0]
371
375
                    view_str = views.view_display_str(view_files)
372
376
                    note("Ignoring files outside view. View is %s" % view_str)
373
377
            return tree, file_list
374
 
        if default_directory == u'.':
375
 
            seed = file_list[0]
376
 
        else:
377
 
            seed = default_directory
378
 
            file_list = [osutils.pathjoin(default_directory, f)
379
 
                         for f in file_list]
380
 
        tree = WorkingTree.open_containing(seed)[0]
 
378
        tree = WorkingTree.open_containing(file_list[0])[0]
381
379
        return tree, tree.safe_relpath_files(file_list, canonicalize,
382
 
                                             apply_view=apply_view)
 
380
            apply_view=apply_view)
383
381
 
384
382
    def safe_relpath_files(self, file_list, canonicalize=True, apply_view=True):
385
383
        """Convert file_list into a list of relpaths in tree.
1384
1382
        to_dir_id = inv.path2id(to_dir)
1385
1383
        if to_dir_id is None:
1386
1384
            raise errors.BzrMoveFailedError('',to_dir,
1387
 
                errors.NotVersionedError(path=to_dir))
 
1385
                errors.NotVersionedError(path=str(to_dir)))
1388
1386
 
1389
1387
        to_dir_ie = inv[to_dir_id]
1390
1388
        if to_dir_ie.kind != 'directory':
1397
1395
            from_id = inv.path2id(from_rel)
1398
1396
            if from_id is None:
1399
1397
                raise errors.BzrMoveFailedError(from_rel,to_dir,
1400
 
                    errors.NotVersionedError(path=from_rel))
 
1398
                    errors.NotVersionedError(path=str(from_rel)))
1401
1399
 
1402
1400
            from_entry = inv[from_id]
1403
1401
            from_parent_id = from_entry.parent_id
1445
1443
            # check the inventory for source and destination
1446
1444
            if from_id is None:
1447
1445
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1448
 
                    errors.NotVersionedError(path=from_rel))
 
1446
                    errors.NotVersionedError(path=str(from_rel)))
1449
1447
            if to_id is not None:
1450
1448
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1451
 
                    errors.AlreadyVersionedError(path=to_rel))
 
1449
                    errors.AlreadyVersionedError(path=str(to_rel)))
1452
1450
 
1453
1451
            # try to determine the mode for rename (only change inv or change
1454
1452
            # inv and file system)
1455
1453
            if after:
1456
1454
                if not self.has_filename(to_rel):
1457
1455
                    raise errors.BzrMoveFailedError(from_id,to_rel,
1458
 
                        errors.NoSuchFile(path=to_rel,
 
1456
                        errors.NoSuchFile(path=str(to_rel),
1459
1457
                        extra="New file has not been created yet"))
1460
1458
                only_change_inv = True
1461
1459
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1563
1561
            from_id = basis_tree.path2id(from_rel)
1564
1562
            if from_id is None:
1565
1563
                raise errors.BzrRenameFailedError(from_rel,to_rel,
1566
 
                    errors.NotVersionedError(path=from_rel))
 
1564
                    errors.NotVersionedError(path=str(from_rel)))
1567
1565
            # put entry back in the inventory so we can rename it
1568
1566
            from_entry = basis_tree.inventory[from_id].copy()
1569
1567
            inv.add(from_entry)
1587
1585
        # versioned
1588
1586
        if to_dir_id is None:
1589
1587
            raise errors.BzrMoveFailedError(from_rel,to_rel,
1590
 
                errors.NotVersionedError(path=to_dir))
 
1588
                errors.NotVersionedError(path=str(to_dir)))
1591
1589
 
1592
1590
        # all checks done. now we can continue with our actual work
1593
1591
        mutter('rename_one:\n'
2082
2080
                    files_to_backup.append(path[1])
2083
2081
 
2084
2082
        def backup(file_to_backup):
2085
 
            backup_name = self.bzrdir._available_backup_name(file_to_backup)
 
2083
            backup_name = self.bzrdir.generate_backup_name(file_to_backup)
2086
2084
            osutils.rename(abs_path, self.abspath(backup_name))
2087
 
            return "removed %s (but kept a copy: %s)" % (file_to_backup,
2088
 
                                                         backup_name)
 
2085
            return "removed %s (but kept a copy: %s)" % (file_to_backup, backup_name)
2089
2086
 
2090
2087
        # Build inv_delta and delete files where applicable,
2091
2088
        # do this before any modifications to inventory.
2675
2672
        """
2676
2673
        return
2677
2674
 
2678
 
    @needs_read_lock
2679
 
    def check_state(self):
2680
 
        """Check that the working state is/isn't valid."""
2681
 
        check_refs = self._get_check_refs()
2682
 
        refs = {}
2683
 
        for ref in check_refs:
2684
 
            kind, value = ref
2685
 
            if kind == 'trees':
2686
 
                refs[ref] = self.branch.repository.revision_tree(value)
2687
 
        self._check(refs)
2688
 
 
2689
 
    @needs_tree_write_lock
2690
 
    def reset_state(self, revision_ids=None):
2691
 
        """Reset the state of the working tree.
2692
 
 
2693
 
        This does a hard-reset to a last-known-good state. This is a way to
2694
 
        fix if something got corrupted (like the .bzr/checkout/dirstate file)
2695
 
        """
2696
 
        if revision_ids is None:
2697
 
            revision_ids = self.get_parent_ids()
2698
 
        if not revision_ids:
2699
 
            rt = self.branch.repository.revision_tree(
2700
 
                _mod_revision.NULL_REVISION)
2701
 
        else:
2702
 
            rt = self.branch.repository.revision_tree(revision_ids[0])
2703
 
        self._write_inventory(rt.inventory)
2704
 
        self.set_parent_ids(revision_ids)
2705
 
 
2706
2675
    def _get_rules_searcher(self, default_searcher):
2707
2676
        """See Tree._get_rules_searcher."""
2708
2677
        if self._rules_searcher is None:
2882
2851
    _formats = {}
2883
2852
    """The known formats."""
2884
2853
 
2885
 
    _extra_formats = []
2886
 
    """Extra formats that can not be used in a metadir."""
2887
 
 
2888
2854
    requires_rich_root = False
2889
2855
 
2890
2856
    upgrade_recommended = False
2891
2857
 
2892
 
    requires_normalized_unicode_filenames = False
2893
 
 
2894
 
    case_sensitive_filename = "FoRMaT"
2895
 
 
2896
 
    missing_parent_conflicts = False
2897
 
    """If this format supports missing parent conflicts."""
2898
 
 
2899
2858
    @classmethod
2900
2859
    def find_format(klass, a_bzrdir):
2901
2860
        """Return the format for the working tree object in a_bzrdir."""
2950
2909
        klass._formats[format.get_format_string()] = format
2951
2910
 
2952
2911
    @classmethod
2953
 
    def register_extra_format(klass, format):
2954
 
        klass._extra_formats.append(format)
2955
 
 
2956
 
    @classmethod
2957
 
    def unregister_extra_format(klass, format):
2958
 
        klass._extra_formats.remove(format)
2959
 
 
2960
 
    @classmethod
2961
 
    def get_formats(klass):
2962
 
        return klass._formats.values() + klass._extra_formats
2963
 
 
2964
 
    @classmethod
2965
2912
    def set_default_format(klass, format):
2966
2913
        klass._default_format = format
2967
2914
 
2978
2925
 
2979
2926
    upgrade_recommended = True
2980
2927
 
2981
 
    requires_normalized_unicode_filenames = True
2982
 
 
2983
 
    case_sensitive_filename = "Branch-FoRMaT"
2984
 
 
2985
 
    missing_parent_conflicts = False
2986
 
 
2987
2928
    def get_format_description(self):
2988
2929
        """See WorkingTreeFormat.get_format_description()."""
2989
2930
        return "Working tree format 2"
3024
2965
                         inv,
3025
2966
                         _internal=True,
3026
2967
                         _format=self,
3027
 
                         _bzrdir=a_bzrdir,
3028
 
                         _control_files=branch.control_files)
 
2968
                         _bzrdir=a_bzrdir)
3029
2969
        basis_tree = branch.repository.revision_tree(revision_id)
3030
2970
        if basis_tree.inventory.root is not None:
3031
2971
            wt.set_root_id(basis_tree.get_root_id())
3056
2996
        wt = WorkingTree2(a_bzrdir.root_transport.local_abspath('.'),
3057
2997
                           _internal=True,
3058
2998
                           _format=self,
3059
 
                           _bzrdir=a_bzrdir,
3060
 
                           _control_files=a_bzrdir.open_branch().control_files)
 
2999
                           _bzrdir=a_bzrdir)
3061
3000
        return wt
3062
3001
 
3063
3002
class WorkingTreeFormat3(WorkingTreeFormat):
3074
3013
 
3075
3014
    upgrade_recommended = True
3076
3015
 
3077
 
    missing_parent_conflicts = True
3078
 
 
3079
3016
    def get_format_string(self):
3080
3017
        """See WorkingTreeFormat.get_format_string()."""
3081
3018
        return "Bazaar-NG Working Tree format 3"
3199
3136
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3200
3137
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3201
3138
WorkingTreeFormat.set_default_format(__default_format)
3202
 
# Register extra formats which have no format string are not discoverable
3203
 
# and not independently creatable. They are implicitly created as part of
3204
 
# e.g. older Bazaar formats or foreign formats.
3205
 
WorkingTreeFormat.register_extra_format(WorkingTreeFormat2())
 
3139
# formats which have no format string are not discoverable
 
3140
# and not independently creatable, so are not registered.
 
3141
_legacy_formats = [WorkingTreeFormat2(),
 
3142
                   ]