← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/workingtree.py

  • Committer: Jelmer Vernooij
  • Date: 2011-02-19 15:23:08 UTC
  • mto: (5582.12.2 weave-plugin)
  • mto: This revision was merged to the branch mainline in revision 5718.
  • Revision ID: jelmer@samba.org-20110219152308-5shhc4rj0ez4oa12
move xml4 to weave plugin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/workingtree.py
58
58
    ignores,
59
59
    inventory,
60
60
    merge,
61
 
    registry,
62
61
    revision as _mod_revision,
63
62
    revisiontree,
64
63
    trace,
254
253
    def control_transport(self):
255
254
        return self._transport
256
255
 
257
 
    def is_control_filename(self, filename):
258
 
        """True if filename is the name of a control file in this tree.
259
 
 
260
 
        :param filename: A filename within the tree. This is a relative path
261
 
        from the root of this tree.
262
 
 
263
 
        This is true IF and ONLY IF the filename is part of the meta data
264
 
        that bzr controls in this tree. I.E. a random .bzr directory placed
265
 
        on disk will not be a control file for this tree.
266
 
        """
267
 
        return self.bzrdir.is_control_filename(filename)
268
 
 
269
256
    def _detect_case_handling(self):
270
257
        wt_trans = self.bzrdir.get_workingtree_transport(None)
271
258
        try:
526
513
        return self.get_file_with_stat(file_id, path, filtered=filtered)[0]
527
514
 
528
515
    def get_file_with_stat(self, file_id, path=None, filtered=True,
529
 
                           _fstat=osutils.fstat):
 
516
        _fstat=os.fstat):
530
517
        """See Tree.get_file_with_stat."""
531
518
        if path is None:
532
519
            path = self.id2path(file_id)
2773
2760
            self.branch.unlock()
2774
2761
 
2775
2762
 
2776
 
class WorkingTreeFormatRegistry(controldir.ControlComponentFormatRegistry):
2777
 
    """Registry for working tree formats."""
2778
 
 
2779
 
    def __init__(self, other_registry=None):
2780
 
        super(WorkingTreeFormatRegistry, self).__init__(other_registry)
2781
 
        self._default_format = None
2782
 
 
2783
 
    def get_default(self):
2784
 
        """Return the current default format."""
2785
 
        return self._default_format
2786
 
 
2787
 
    def set_default(self, format):
2788
 
        self._default_format = format
2789
 
 
2790
 
 
2791
 
format_registry = WorkingTreeFormatRegistry()
2792
 
 
2793
 
 
2794
 
class WorkingTreeFormat(controldir.ControlComponentFormat):
 
2763
class WorkingTreeFormat(object):
2795
2764
    """An encapsulation of the initialization and open routines for a format.
2796
2765
 
2797
2766
    Formats provide three things:
2809
2778
    object will be created every time regardless.
2810
2779
    """
2811
2780
 
 
2781
    _default_format = None
 
2782
    """The default format used for new trees."""
 
2783
 
 
2784
    _formats = {}
 
2785
    """The known formats."""
 
2786
 
 
2787
    _extra_formats = []
 
2788
    """Extra formats that can not be used in a metadir."""
 
2789
 
2812
2790
    requires_rich_root = False
2813
2791
 
2814
2792
    upgrade_recommended = False
2826
2804
        try:
2827
2805
            transport = a_bzrdir.get_workingtree_transport(None)
2828
2806
            format_string = transport.get_bytes("format")
2829
 
            return format_registry.get(format_string)
 
2807
            return klass._formats[format_string]
2830
2808
        except errors.NoSuchFile:
2831
2809
            raise errors.NoWorkingTree(base=transport.base)
2832
2810
        except KeyError:
2833
2811
            raise errors.UnknownFormatError(format=format_string,
2834
2812
                                            kind="working tree")
2835
2813
 
2836
 
    def initialize(self, a_bzrdir, revision_id=None, from_branch=None,
2837
 
                   accelerator_tree=None, hardlink=False):
2838
 
        """Initialize a new working tree in a_bzrdir.
2839
 
 
2840
 
        :param a_bzrdir: BzrDir to initialize the working tree in.
2841
 
        :param revision_id: allows creating a working tree at a different
2842
 
            revision than the branch is at.
2843
 
        :param from_branch: Branch to checkout
2844
 
        :param accelerator_tree: A tree which can be used for retrieving file
2845
 
            contents more quickly than the revision tree, i.e. a workingtree.
2846
 
            The revision tree will be used for cases where accelerator_tree's
2847
 
            content is different.
2848
 
        :param hardlink: If true, hard-link files from accelerator_tree,
2849
 
            where possible.
2850
 
        """
2851
 
        raise NotImplementedError(self.initialize)
2852
 
 
2853
2814
    def __eq__(self, other):
2854
2815
        return self.__class__ is other.__class__
2855
2816
 
2857
2818
        return not (self == other)
2858
2819
 
2859
2820
    @classmethod
2860
 
    @symbol_versioning.deprecated_method(
2861
 
        symbol_versioning.deprecated_in((2, 4, 0)))
2862
2821
    def get_default_format(klass):
2863
2822
        """Return the current default format."""
2864
 
        return format_registry.get_default()
 
2823
        return klass._default_format
2865
2824
 
2866
2825
    def get_format_string(self):
2867
2826
        """Return the ASCII format string that identifies this format."""
2889
2848
        return False
2890
2849
 
2891
2850
    @classmethod
2892
 
    @symbol_versioning.deprecated_method(
2893
 
        symbol_versioning.deprecated_in((2, 4, 0)))
2894
2851
    def register_format(klass, format):
2895
 
        format_registry.register(format)
 
2852
        klass._formats[format.get_format_string()] = format
2896
2853
 
2897
2854
    @classmethod
2898
 
    @symbol_versioning.deprecated_method(
2899
 
        symbol_versioning.deprecated_in((2, 4, 0)))
2900
2855
    def register_extra_format(klass, format):
2901
 
        format_registry.register_extra(format)
 
2856
        klass._extra_formats.append(format)
2902
2857
 
2903
2858
    @classmethod
2904
 
    @symbol_versioning.deprecated_method(
2905
 
        symbol_versioning.deprecated_in((2, 4, 0)))
2906
2859
    def unregister_extra_format(klass, format):
2907
 
        format_registry.unregister_extra(format)
 
2860
        klass._extra_formats.remove(format)
2908
2861
 
2909
2862
    @classmethod
2910
 
    @symbol_versioning.deprecated_method(
2911
 
        symbol_versioning.deprecated_in((2, 4, 0)))
2912
2863
    def get_formats(klass):
2913
 
        return format_registry._get_all()
 
2864
        return klass._formats.values() + klass._extra_formats
2914
2865
 
2915
2866
    @classmethod
2916
 
    @symbol_versioning.deprecated_method(
2917
 
        symbol_versioning.deprecated_in((2, 4, 0)))
2918
2867
    def set_default_format(klass, format):
2919
 
        format_registry.set_default(format)
 
2868
        klass._default_format = format
2920
2869
 
2921
2870
    @classmethod
2922
 
    @symbol_versioning.deprecated_method(
2923
 
        symbol_versioning.deprecated_in((2, 4, 0)))
2924
2871
    def unregister_format(klass, format):
2925
 
        format_registry.remove(format)
 
2872
        del klass._formats[format.get_format_string()]
2926
2873
 
2927
2874
 
2928
2875
class WorkingTreeFormat3(WorkingTreeFormat):
3059
3006
 
3060
3007
 
3061
3008
__default_format = WorkingTreeFormat6()
3062
 
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
3063
 
    "bzrlib.workingtree_4", "WorkingTreeFormat4")
3064
 
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
3065
 
    "bzrlib.workingtree_4", "WorkingTreeFormat5")
3066
 
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
3067
 
    "bzrlib.workingtree_4", "WorkingTreeFormat6")
3068
 
format_registry.register(WorkingTreeFormat3())
3069
 
format_registry.set_default(__default_format)
 
3009
WorkingTreeFormat.register_format(__default_format)
 
3010
WorkingTreeFormat.register_format(WorkingTreeFormat5())
 
3011
WorkingTreeFormat.register_format(WorkingTreeFormat4())
 
3012
WorkingTreeFormat.register_format(WorkingTreeFormat3())
 
3013
WorkingTreeFormat.set_default_format(__default_format)