~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Jelmer Vernooij
  • Date: 2012-08-02 10:38:21 UTC
  • mto: This revision was merged to the branch mainline in revision 6555.
  • Revision ID: jelmer@samba.org-20120802103821-pto2dgacjtmpzl1n
Move color feature into bzrlib.tests.features.

Show diffs side-by-side

added added

removed removed

Lines of Context:
89
89
    atomicfile,
90
90
    controldir,
91
91
    debug,
92
 
    directory_service,
93
92
    errors,
94
93
    lazy_regex,
95
94
    library_state,
1557
1556
def xdg_cache_dir():
1558
1557
    # See http://standards.freedesktop.org/basedir-spec/latest/ar01s03.html
1559
1558
    # Possibly this should be different on Windows?
1560
 
    e = os.environ.get('XDG_CACHE_HOME', None)
 
1559
    e = os.environ.get('XDG_CACHE_DIR', None)
1561
1560
    if e:
1562
1561
        return e
1563
1562
    else:
2135
2134
 
2136
2135
class Base64CredentialStore(CredentialStore):
2137
2136
    __doc__ = """Base64 credential store for the authentication.conf file"""
2138
 
 
 
2137
    
2139
2138
    def decode_password(self, credentials):
2140
2139
        """See CredentialStore.decode_password."""
2141
2140
        # GZ 2012-07-28: Will raise binascii.Error if password is not base64,
2161
2160
        for those under repositories.
2162
2161
        """
2163
2162
        if self._config is None:
2164
 
            raise errors.BzrError("Cannot set configuration in %s"
2165
 
                                  % self._bzrdir)
 
2163
            raise errors.BzrError("Cannot set configuration in %s" % self._bzrdir)
2166
2164
        if value is None:
2167
2165
            self._config.set_option('', 'default_stack_on')
2168
2166
        else:
2316
2314
        :param help: a doc string to explain the option to the user.
2317
2315
 
2318
2316
        :param from_unicode: a callable to convert the unicode string
2319
 
            representing the option value in a store or its default value.
 
2317
            representing the option value in a store. This is not called for
 
2318
            the default value.
2320
2319
 
2321
2320
        :param invalid: the action to be taken when an invalid value is
2322
2321
            encountered in a store. This is called only when from_unicode is
2473
2472
    return float(unicode_str)
2474
2473
 
2475
2474
 
2476
 
# Use an empty dict to initialize an empty configobj avoiding all parsing and
2477
 
# encoding checks
 
2475
# Use a an empty dict to initialize an empty configobj avoiding all
 
2476
# parsing and encoding checks
2478
2477
_list_converter_config = configobj.ConfigObj(
2479
2478
    {}, encoding='utf-8', list_values=True, interpolation=False)
2480
2479
 
2552
2551
        return "".join(ret)
2553
2552
 
2554
2553
 
2555
 
_option_ref_re = lazy_regex.lazy_compile('({[^\d\W](?:\.\w|\w)*})')
2556
 
"""Describes an expandable option reference.
2557
 
 
2558
 
We want to match the most embedded reference first.
2559
 
 
2560
 
I.e. for '{{foo}}' we will get '{foo}',
2561
 
for '{bar{baz}}' we will get '{baz}'
2562
 
"""
2563
 
 
2564
 
def iter_option_refs(string):
2565
 
    # Split isolate refs so every other chunk is a ref
2566
 
    is_ref = False
2567
 
    for chunk  in _option_ref_re.split(string):
2568
 
        yield is_ref, chunk
2569
 
        is_ref = not is_ref
2570
 
 
2571
 
 
2572
2554
class OptionRegistry(registry.Registry):
2573
2555
    """Register config options by their name.
2574
2556
 
2576
2558
    some information from the option object itself.
2577
2559
    """
2578
2560
 
2579
 
    def _check_option_name(self, option_name):
2580
 
        """Ensures an option name is valid.
2581
 
 
2582
 
        :param option_name: The name to validate.
2583
 
        """
2584
 
        if _option_ref_re.match('{%s}' % option_name) is None:
2585
 
            raise errors.IllegalOptionName(option_name)
2586
 
 
2587
2561
    def register(self, option):
2588
2562
        """Register a new option to its name.
2589
2563
 
2590
2564
        :param option: The option to register. Its name is used as the key.
2591
2565
        """
2592
 
        self._check_option_name(option.name)
2593
2566
        super(OptionRegistry, self).register(option.name, option,
2594
2567
                                             help=option.help)
2595
2568
 
2604
2577
        :param member_name: the member of the module to return.  If empty or 
2605
2578
                None, get() will return the module itself.
2606
2579
        """
2607
 
        self._check_option_name(key)
2608
2580
        super(OptionRegistry, self).register_lazy(key,
2609
2581
                                                  module_name, member_name)
2610
2582
 
2829
2801
 
2830
2802
Each function takes branch, rev_id as parameters.
2831
2803
'''))
2832
 
option_registry.register_lazy('progress_bar', 'bzrlib.ui.text',
2833
 
                              'opt_progress_bar')
2834
2804
option_registry.register(
2835
2805
    Option('public_branch',
2836
2806
           default=None,
2973
2943
        self.options[name] = value
2974
2944
 
2975
2945
    def remove(self, name):
2976
 
        if name not in self.orig and name in self.options:
 
2946
        if name not in self.orig:
2977
2947
            self.orig[name] = self.get(name, None)
2978
2948
        del self.options[name]
2979
2949
 
3317
3287
        # anyway.
3318
3288
        return 'In-Process Store, no URL'
3319
3289
 
3320
 
 
3321
3290
class TransportIniFileStore(IniFileStore):
3322
3291
    """IniFileStore that loads files from a transport.
3323
3292
 
3413
3382
# on the relevant parts of the API that needs testing -- vila 20110503 (based
3414
3383
# on a poolie's remark)
3415
3384
class GlobalStore(LockableIniFileStore):
3416
 
    """A config store for global options.
3417
 
 
3418
 
    There is a single GlobalStore for a given process.
3419
 
    """
3420
3385
 
3421
3386
    def __init__(self, possible_transports=None):
3422
3387
        t = transport.get_transport_from_path(
3426
3391
 
3427
3392
 
3428
3393
class LocationStore(LockableIniFileStore):
3429
 
    """A config store for options specific to a location.
3430
 
 
3431
 
    There is a single LocationStore for a given process.
3432
 
    """
3433
3394
 
3434
3395
    def __init__(self, possible_transports=None):
3435
3396
        t = transport.get_transport_from_path(
3439
3400
 
3440
3401
 
3441
3402
class BranchStore(TransportIniFileStore):
3442
 
    """A config store for branch options.
3443
 
 
3444
 
    There is a single BranchStore for a given branch.
3445
 
    """
3446
3403
 
3447
3404
    def __init__(self, branch):
3448
3405
        super(BranchStore, self).__init__(branch.control_transport,
3649
3606
            yield self.store, section
3650
3607
 
3651
3608
 
3652
 
# FIXME: _shared_stores should be an attribute of a library state once a
3653
 
# library_state object is always available.
3654
 
_shared_stores = {}
3655
 
_shared_stores_at_exit_installed = False
 
3609
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
 
3610
"""Describes an expandable option reference.
 
3611
 
 
3612
We want to match the most embedded reference first.
 
3613
 
 
3614
I.e. for '{{foo}}' we will get '{foo}',
 
3615
for '{bar{baz}}' we will get '{baz}'
 
3616
"""
 
3617
 
 
3618
def iter_option_refs(string):
 
3619
    # Split isolate refs so every other chunk is a ref
 
3620
    is_ref = False
 
3621
    for chunk  in _option_ref_re.split(string):
 
3622
        yield is_ref, chunk
 
3623
        is_ref = not is_ref
 
3624
 
3656
3625
 
3657
3626
class Stack(object):
3658
3627
    """A stack of configurations where an option can be defined"""
3847
3816
        return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3848
3817
 
3849
3818
    def _get_overrides(self):
3850
 
        # FIXME: Hack around library_state.initialize never called
 
3819
        # Hack around library_state.initialize never called
3851
3820
        if bzrlib.global_state is not None:
3852
3821
            return bzrlib.global_state.cmdline_overrides.get_sections()
3853
3822
        return []
3854
3823
 
3855
 
    def get_shared_store(self, store, state=None):
3856
 
        """Get a known shared store.
3857
 
 
3858
 
        Store urls uniquely identify them and are used to ensure a single copy
3859
 
        is shared across all users.
3860
 
 
3861
 
        :param store: The store known to the caller.
3862
 
 
3863
 
        :param state: The library state where the known stores are kept.
3864
 
 
3865
 
        :returns: The store received if it's not a known one, an already known
3866
 
            otherwise.
3867
 
        """
3868
 
        if state is None:
3869
 
            state = bzrlib.global_state
3870
 
        if state is None:
3871
 
            global _shared_stores_at_exit_installed
3872
 
            stores = _shared_stores
3873
 
            def save_config_changes():
3874
 
                for k, store in stores.iteritems():
3875
 
                    store.save_changes()
3876
 
            if not _shared_stores_at_exit_installed:
3877
 
                # FIXME: Ugly hack waiting for library_state to always be
3878
 
                # available. -- vila 20120731
3879
 
                import atexit
3880
 
                atexit.register(save_config_changes)
3881
 
                _shared_stores_at_exit_installed = True
3882
 
        else:
3883
 
            stores = state.config_stores
3884
 
        url = store.external_url()
3885
 
        try:
3886
 
            return stores[url]
3887
 
        except KeyError:
3888
 
            stores[url] = store
3889
 
            return store
3890
 
 
3891
3824
 
3892
3825
class MemoryStack(Stack):
3893
3826
    """A configuration stack defined from a string.
3943
3876
        self.store.save()
3944
3877
 
3945
3878
 
3946
 
class GlobalStack(Stack):
 
3879
class GlobalStack(_CompatibleStack):
3947
3880
    """Global options only stack.
3948
3881
 
3949
3882
    The following sections are queried:
3957
3890
    """
3958
3891
 
3959
3892
    def __init__(self):
3960
 
        gstore = self.get_shared_store(GlobalStore())
 
3893
        gstore = GlobalStore()
3961
3894
        super(GlobalStack, self).__init__(
3962
3895
            [self._get_overrides,
3963
3896
             NameMatcher(gstore, 'DEFAULT').get_sections],
3964
3897
            gstore, mutable_section_id='DEFAULT')
3965
3898
 
3966
3899
 
3967
 
class LocationStack(Stack):
 
3900
class LocationStack(_CompatibleStack):
3968
3901
    """Per-location options falling back to global options stack.
3969
3902
 
3970
3903
 
3986
3919
        """Make a new stack for a location and global configuration.
3987
3920
 
3988
3921
        :param location: A URL prefix to """
3989
 
        lstore = self.get_shared_store(LocationStore())
 
3922
        lstore = LocationStore()
3990
3923
        if location.startswith('file://'):
3991
3924
            location = urlutils.local_path_from_url(location)
3992
 
        gstore = self.get_shared_store(GlobalStore())
 
3925
        gstore = GlobalStore()
3993
3926
        super(LocationStack, self).__init__(
3994
3927
            [self._get_overrides,
3995
3928
             LocationMatcher(lstore, location).get_sections,
4017
3950
    """
4018
3951
 
4019
3952
    def __init__(self, branch):
4020
 
        lstore = self.get_shared_store(LocationStore())
 
3953
        lstore = LocationStore()
4021
3954
        bstore = branch._get_config_store()
4022
 
        gstore = self.get_shared_store(GlobalStore())
 
3955
        gstore = GlobalStore()
4023
3956
        super(BranchStack, self).__init__(
4024
3957
            [self._get_overrides,
4025
3958
             LocationMatcher(lstore, branch.base).get_sections,
4047
3980
        # unlock saves all the changes.
4048
3981
 
4049
3982
 
4050
 
class RemoteControlStack(Stack):
 
3983
class RemoteControlStack(_CompatibleStack):
4051
3984
    """Remote control-only options stack."""
4052
3985
 
4053
3986
    # FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
4098
4031
class cmd_config(commands.Command):
4099
4032
    __doc__ = """Display, set or remove a configuration option.
4100
4033
 
4101
 
    Display the active value for option NAME.
 
4034
    Display the active value for a given option.
4102
4035
 
4103
4036
    If --all is specified, NAME is interpreted as a regular expression and all
4104
 
    matching options are displayed mentioning their scope and without resolving
4105
 
    option references in the value). The active value that bzr will take into
4106
 
    account is the first one displayed for each option.
4107
 
 
4108
 
    If NAME is not given, --all .* is implied (all options are displayed for the
4109
 
    current scope).
4110
 
 
4111
 
    Setting a value is achieved by using NAME=value without spaces. The value
 
4037
    matching options are displayed mentioning their scope. The active value
 
4038
    that bzr will take into account is the first one displayed for each option.
 
4039
 
 
4040
    If no NAME is given, --all .* is implied.
 
4041
 
 
4042
    Setting a value is achieved by using name=value without spaces. The value
4112
4043
    is set in the most relevant scope and can be checked by displaying the
4113
4044
    option again.
4114
 
 
4115
 
    Removing a value is achieved by using --remove NAME.
4116
4045
    """
4117
4046
 
4118
4047
    takes_args = ['name?']
4139
4068
            remove=False):
4140
4069
        if directory is None:
4141
4070
            directory = '.'
4142
 
        directory = directory_service.directories.dereference(directory)
4143
4071
        directory = urlutils.normalize_url(directory)
4144
4072
        if remove and all:
4145
4073
            raise errors.BzrError(