← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

Merge pt1 hooks branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 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
256
256
    def _detect_case_handling(self):
257
257
        wt_trans = self.bzrdir.get_workingtree_transport(None)
258
258
        try:
259
 
            wt_trans.stat("FoRMaT")
 
259
            wt_trans.stat(self._format.case_sensitive_filename)
260
260
        except errors.NoSuchFile:
261
261
            self.case_sensitive = True
262
262
        else:
1384
1384
        to_dir_id = inv.path2id(to_dir)
1385
1385
        if to_dir_id is None:
1386
1386
            raise errors.BzrMoveFailedError('',to_dir,
1387
 
                errors.NotVersionedError(path=str(to_dir)))
 
1387
                errors.NotVersionedError(path=to_dir))
1388
1388
 
1389
1389
        to_dir_ie = inv[to_dir_id]
1390
1390
        if to_dir_ie.kind != 'directory':
1397
1397
            from_id = inv.path2id(from_rel)
1398
1398
            if from_id is None:
1399
1399
                raise errors.BzrMoveFailedError(from_rel,to_dir,
1400
 
                    errors.NotVersionedError(path=str(from_rel)))
 
1400
                    errors.NotVersionedError(path=from_rel))
1401
1401
 
1402
1402
            from_entry = inv[from_id]
1403
1403
            from_parent_id = from_entry.parent_id
1445
1445
            # check the inventory for source and destination
1446
1446
            if from_id is None:
1447
1447
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1448
 
                    errors.NotVersionedError(path=str(from_rel)))
 
1448
                    errors.NotVersionedError(path=from_rel))
1449
1449
            if to_id is not None:
1450
1450
                raise errors.BzrMoveFailedError(from_rel,to_rel,
1451
 
                    errors.AlreadyVersionedError(path=str(to_rel)))
 
1451
                    errors.AlreadyVersionedError(path=to_rel))
1452
1452
 
1453
1453
            # try to determine the mode for rename (only change inv or change
1454
1454
            # inv and file system)
1455
1455
            if after:
1456
1456
                if not self.has_filename(to_rel):
1457
1457
                    raise errors.BzrMoveFailedError(from_id,to_rel,
1458
 
                        errors.NoSuchFile(path=str(to_rel),
 
1458
                        errors.NoSuchFile(path=to_rel,
1459
1459
                        extra="New file has not been created yet"))
1460
1460
                only_change_inv = True
1461
1461
            elif not self.has_filename(from_rel) and self.has_filename(to_rel):
1563
1563
            from_id = basis_tree.path2id(from_rel)
1564
1564
            if from_id is None:
1565
1565
                raise errors.BzrRenameFailedError(from_rel,to_rel,
1566
 
                    errors.NotVersionedError(path=str(from_rel)))
 
1566
                    errors.NotVersionedError(path=from_rel))
1567
1567
            # put entry back in the inventory so we can rename it
1568
1568
            from_entry = basis_tree.inventory[from_id].copy()
1569
1569
            inv.add(from_entry)
1587
1587
        # versioned
1588
1588
        if to_dir_id is None:
1589
1589
            raise errors.BzrMoveFailedError(from_rel,to_rel,
1590
 
                errors.NotVersionedError(path=str(to_dir)))
 
1590
                errors.NotVersionedError(path=to_dir))
1591
1591
 
1592
1592
        # all checks done. now we can continue with our actual work
1593
1593
        mutter('rename_one:\n'
2675
2675
        """
2676
2676
        return
2677
2677
 
 
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
 
2678
2706
    def _get_rules_searcher(self, default_searcher):
2679
2707
        """See Tree._get_rules_searcher."""
2680
2708
        if self._rules_searcher is None:
2854
2882
    _formats = {}
2855
2883
    """The known formats."""
2856
2884
 
 
2885
    _extra_formats = []
 
2886
    """Extra formats that can not be used in a metadir."""
 
2887
 
2857
2888
    requires_rich_root = False
2858
2889
 
2859
2890
    upgrade_recommended = False
2860
2891
 
 
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
 
2861
2899
    @classmethod
2862
2900
    def find_format(klass, a_bzrdir):
2863
2901
        """Return the format for the working tree object in a_bzrdir."""
2912
2950
        klass._formats[format.get_format_string()] = format
2913
2951
 
2914
2952
    @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
2915
2965
    def set_default_format(klass, format):
2916
2966
        klass._default_format = format
2917
2967
 
2928
2978
 
2929
2979
    upgrade_recommended = True
2930
2980
 
 
2981
    requires_normalized_unicode_filenames = True
 
2982
 
 
2983
    case_sensitive_filename = "Branch-FoRMaT"
 
2984
 
 
2985
    missing_parent_conflicts = False
 
2986
 
2931
2987
    def get_format_description(self):
2932
2988
        """See WorkingTreeFormat.get_format_description()."""
2933
2989
        return "Working tree format 2"
3018
3074
 
3019
3075
    upgrade_recommended = True
3020
3076
 
 
3077
    missing_parent_conflicts = True
 
3078
 
3021
3079
    def get_format_string(self):
3022
3080
        """See WorkingTreeFormat.get_format_string()."""
3023
3081
        return "Bazaar-NG Working Tree format 3"
3141
3199
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3142
3200
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3143
3201
WorkingTreeFormat.set_default_format(__default_format)
3144
 
# formats which have no format string are not discoverable
3145
 
# and not independently creatable, so are not registered.
3146
 
_legacy_formats = [WorkingTreeFormat2(),
3147
 
                   ]
 
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())