← 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-24 16:09:47 UTC
  • mto: (5582.10.69 weave-fmt-plugin)
  • mto: This revision was merged to the branch mainline in revision 5688.
  • Revision ID: jelmer@samba.org-20110224160947-e7kqclxnjif28v5q
merge bzr.dev.

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,
61
62
    revision as _mod_revision,
62
63
    revisiontree,
63
64
    trace,
2858
2859
            return path[:-len(suffix)]
2859
2860
 
2860
2861
 
 
2862
class WorkingTreeFormatRegistry(registry.FormatRegistry):
 
2863
    """Registry for working tree formats."""
 
2864
 
 
2865
    def __init__(self, other_registry=None):
 
2866
        super(WorkingTreeFormatRegistry, self).__init__(other_registry)
 
2867
        self._extra_formats = []
 
2868
        self._default_format = None
 
2869
 
 
2870
    def register(self, format):
 
2871
        """Register a new repository format."""
 
2872
        super(WorkingTreeFormatRegistry, self).register(
 
2873
            format.get_format_string(), format)
 
2874
 
 
2875
    def remove(self, format):
 
2876
        """Remove a registered repository format."""
 
2877
        super(WorkingTreeFormatRegistry, self).remove(format.get_format_string())
 
2878
 
 
2879
    def register_extra(self, format):
 
2880
        """Register a repository format that can not be used in a metadir.
 
2881
 
 
2882
        This is mainly useful to allow custom repository formats, such as older
 
2883
        Bazaar formats and foreign formats, to be tested.
 
2884
        """
 
2885
        self._extra_formats.append(registry._ObjectGetter(format))
 
2886
 
 
2887
    def remove_extra(self, format):
 
2888
        """Remove an extra repository format.
 
2889
        """
 
2890
        self._extra_formats.remove(registry._ObjectGetter(format))
 
2891
 
 
2892
    def register_extra_lazy(self, module_name, member_name):
 
2893
        """Register a repository format lazily.
 
2894
        """
 
2895
        self._extra_formats.append(
 
2896
            registry._LazyObjectGetter(module_name, member_name))
 
2897
 
 
2898
    def get_default(self):
 
2899
        """Return the current default format."""
 
2900
        return self._default_format
 
2901
 
 
2902
    def set_default(self, format):
 
2903
        self._default_format = format
 
2904
 
 
2905
    def _get_extra(self):
 
2906
        result = []
 
2907
        for getter in self._extra_formats:
 
2908
            f = getter.get_obj()
 
2909
            if callable(f):
 
2910
                f = f()
 
2911
            result.append(f)
 
2912
        return result
 
2913
 
 
2914
    def _get_all(self):
 
2915
        """Return all repository formats, even those not usable in metadirs.
 
2916
        """
 
2917
        return [self.get(k) for k in self.keys()] + self._get_extra()
 
2918
 
 
2919
 
 
2920
format_registry = WorkingTreeFormatRegistry()
 
2921
 
 
2922
 
2861
2923
class WorkingTreeFormat(object):
2862
2924
    """An encapsulation of the initialization and open routines for a format.
2863
2925
 
2876
2938
    object will be created every time regardless.
2877
2939
    """
2878
2940
 
2879
 
    _default_format = None
2880
 
    """The default format used for new trees."""
2881
 
 
2882
 
    _formats = {}
2883
 
    """The known formats."""
2884
 
 
2885
 
    _extra_formats = []
2886
 
    """Extra formats that can not be used in a metadir."""
2887
 
 
2888
2941
    requires_rich_root = False
2889
2942
 
2890
2943
    upgrade_recommended = False
2902
2955
        try:
2903
2956
            transport = a_bzrdir.get_workingtree_transport(None)
2904
2957
            format_string = transport.get_bytes("format")
2905
 
            return klass._formats[format_string]
 
2958
            return format_registry.get(format_string)
2906
2959
        except errors.NoSuchFile:
2907
2960
            raise errors.NoWorkingTree(base=transport.base)
2908
2961
        except KeyError:
2916
2969
        return not (self == other)
2917
2970
 
2918
2971
    @classmethod
 
2972
    @symbol_versioning.deprecated_method(
 
2973
        symbol_versioning.deprecated_in((2, 4, 0)))
2919
2974
    def get_default_format(klass):
2920
2975
        """Return the current default format."""
2921
 
        return klass._default_format
 
2976
        return format_registry.get_default()
2922
2977
 
2923
2978
    def get_format_string(self):
2924
2979
        """Return the ASCII format string that identifies this format."""
2946
3001
        return False
2947
3002
 
2948
3003
    @classmethod
 
3004
    @symbol_versioning.deprecated_method(
 
3005
        symbol_versioning.deprecated_in((2, 4, 0)))
2949
3006
    def register_format(klass, format):
2950
 
        klass._formats[format.get_format_string()] = format
 
3007
        format_registry.register(format)
2951
3008
 
2952
3009
    @classmethod
 
3010
    @symbol_versioning.deprecated_method(
 
3011
        symbol_versioning.deprecated_in((2, 4, 0)))
2953
3012
    def register_extra_format(klass, format):
2954
 
        klass._extra_formats.append(format)
 
3013
        format_registry.register_extra(format)
2955
3014
 
2956
3015
    @classmethod
 
3016
    @symbol_versioning.deprecated_method(
 
3017
        symbol_versioning.deprecated_in((2, 4, 0)))
2957
3018
    def unregister_extra_format(klass, format):
2958
 
        klass._extra_formats.remove(format)
 
3019
        format_registry.unregister_extra(format)
2959
3020
 
2960
3021
    @classmethod
 
3022
    @symbol_versioning.deprecated_method(
 
3023
        symbol_versioning.deprecated_in((2, 4, 0)))
2961
3024
    def get_formats(klass):
2962
 
        return klass._formats.values() + klass._extra_formats
 
3025
        return format_registry._get_all()
2963
3026
 
2964
3027
    @classmethod
 
3028
    @symbol_versioning.deprecated_method(
 
3029
        symbol_versioning.deprecated_in((2, 4, 0)))
2965
3030
    def set_default_format(klass, format):
2966
 
        klass._default_format = format
 
3031
        format_registry.set_default(format)
2967
3032
 
2968
3033
    @classmethod
 
3034
    @symbol_versioning.deprecated_method(
 
3035
        symbol_versioning.deprecated_in((2, 4, 0)))
2969
3036
    def unregister_format(klass, format):
2970
 
        del klass._formats[format.get_format_string()]
 
3037
        format_registry.remove(format)
2971
3038
 
2972
3039
 
2973
3040
class WorkingTreeFormat2(WorkingTreeFormat):
3194
3261
 
3195
3262
 
3196
3263
__default_format = WorkingTreeFormat6()
3197
 
WorkingTreeFormat.register_format(__default_format)
3198
 
WorkingTreeFormat.register_format(WorkingTreeFormat5())
3199
 
WorkingTreeFormat.register_format(WorkingTreeFormat4())
3200
 
WorkingTreeFormat.register_format(WorkingTreeFormat3())
3201
 
WorkingTreeFormat.set_default_format(__default_format)
 
3264
format_registry.register_lazy("Bazaar Working Tree Format 4 (bzr 0.15)\n",
 
3265
    "bzrlib.workingtree_4", "WorkingTreeFormat4")
 
3266
format_registry.register_lazy("Bazaar Working Tree Format 5 (bzr 1.11)\n",
 
3267
    "bzrlib.workingtree_4", "WorkingTreeFormat5")
 
3268
format_registry.register_lazy("Bazaar Working Tree Format 6 (bzr 1.14)\n",
 
3269
    "bzrlib.workingtree_4", "WorkingTreeFormat6")
 
3270
format_registry.register(WorkingTreeFormat3())
 
3271
format_registry.set_default(__default_format)
3202
3272
# Register extra formats which have no format string are not discoverable
3203
3273
# and not independently creatable. They are implicitly created as part of
3204
3274
# e.g. older Bazaar formats or foreign formats.
3205
 
WorkingTreeFormat.register_extra_format(WorkingTreeFormat2())
 
3275
format_registry.register_extra(WorkingTreeFormat2())