← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

Merge bzr.dev, update to use new hooks.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#            and others
4
4
#
29
29
create_signatures=always|never|when-required(default)
30
30
gpg_signing_command=name-of-program
31
31
log_format=name-of-format
 
32
validate_signatures_in_log=true|false(default)
 
33
acceptable_keys=pattern1,pattern2
 
34
gpg_signing_key=amy@example.com
32
35
 
33
36
in locations.conf, you specify the url of a branch and options for it.
34
37
Wildcards may be used - * and ? as normal in shell completion. Options
39
42
email= as above
40
43
check_signatures= as above
41
44
create_signatures= as above.
 
45
validate_signatures_in_log=as above
 
46
acceptable_keys=as above
42
47
 
43
48
explanation of options
44
49
----------------------
45
50
editor - this option sets the pop up editor to use during commits.
46
51
email - this option sets the user id bzr will use when committing.
47
 
check_signatures - this option controls whether bzr will require good gpg
 
52
check_signatures - this option will control whether bzr will require good gpg
48
53
                   signatures, ignore them, or check them if they are
49
 
                   present.
 
54
                   present.  Currently it is unused except that check_signatures
 
55
                   turns on create_signatures.
50
56
create_signatures - this option controls whether bzr will always create
51
 
                    gpg signatures, never create them, or create them if the
52
 
                    branch is configured to require them.
 
57
                    gpg signatures or not on commits.  There is an unused
 
58
                    option which in future is expected to work if               
 
59
                    branch settings require signatures.
53
60
log_format - this option sets the default log format.  Possible values are
54
61
             long, short, line, or a plugin can register new formats.
 
62
validate_signatures_in_log - show GPG signature validity in log output
 
63
acceptable_keys - comma separated list of key patterns acceptable for
 
64
                  verify-signatures command
55
65
 
56
66
In bazaar.conf you can also define aliases in the ALIASES sections, example
57
67
 
63
73
"""
64
74
 
65
75
import os
 
76
import string
66
77
import sys
67
78
 
 
79
 
 
80
import bzrlib
68
81
from bzrlib.decorators import needs_write_lock
69
82
from bzrlib.lazy_import import lazy_import
70
83
lazy_import(globals(), """
71
 
import errno
72
 
from fnmatch import fnmatch
 
84
import fnmatch
73
85
import re
74
86
from cStringIO import StringIO
75
87
 
76
 
import bzrlib
77
88
from bzrlib import (
78
89
    atomicfile,
 
90
    controldir,
79
91
    debug,
80
92
    errors,
 
93
    lazy_regex,
 
94
    library_state,
81
95
    lockdir,
82
96
    mail_client,
 
97
    mergetools,
83
98
    osutils,
84
 
    registry,
85
99
    symbol_versioning,
86
100
    trace,
87
101
    transport,
89
103
    urlutils,
90
104
    win32utils,
91
105
    )
 
106
from bzrlib.i18n import gettext
92
107
from bzrlib.util.configobj import configobj
93
108
""")
 
109
from bzrlib import (
 
110
    commands,
 
111
    hooks,
 
112
    lazy_regex,
 
113
    registry,
 
114
    )
 
115
from bzrlib.symbol_versioning import (
 
116
    deprecated_in,
 
117
    deprecated_method,
 
118
    )
94
119
 
95
120
 
96
121
CHECK_IF_POSSIBLE=0
126
151
STORE_BRANCH = 3
127
152
STORE_GLOBAL = 4
128
153
 
129
 
_ConfigObj = None
130
 
def ConfigObj(*args, **kwargs):
131
 
    global _ConfigObj
132
 
    if _ConfigObj is None:
133
 
        class ConfigObj(configobj.ConfigObj):
134
 
 
135
 
            def get_bool(self, section, key):
136
 
                return self[section].as_bool(key)
137
 
 
138
 
            def get_value(self, section, name):
139
 
                # Try [] for the old DEFAULT section.
140
 
                if section == "DEFAULT":
141
 
                    try:
142
 
                        return self[name]
143
 
                    except KeyError:
144
 
                        pass
145
 
                return self[section][name]
146
 
        _ConfigObj = ConfigObj
147
 
    return _ConfigObj(*args, **kwargs)
 
154
 
 
155
class ConfigObj(configobj.ConfigObj):
 
156
 
 
157
    def __init__(self, infile=None, **kwargs):
 
158
        # We define our own interpolation mechanism calling it option expansion
 
159
        super(ConfigObj, self).__init__(infile=infile,
 
160
                                        interpolation=False,
 
161
                                        **kwargs)
 
162
 
 
163
    def get_bool(self, section, key):
 
164
        return self[section].as_bool(key)
 
165
 
 
166
    def get_value(self, section, name):
 
167
        # Try [] for the old DEFAULT section.
 
168
        if section == "DEFAULT":
 
169
            try:
 
170
                return self[name]
 
171
            except KeyError:
 
172
                pass
 
173
        return self[section][name]
 
174
 
 
175
 
 
176
# FIXME: Until we can guarantee that each config file is loaded once and
 
177
# only once for a given bzrlib session, we don't want to re-read the file every
 
178
# time we query for an option so we cache the value (bad ! watch out for tests
 
179
# needing to restore the proper value). -- vila 20110219
 
180
_expand_default_value = None
 
181
def _get_expand_default_value():
 
182
    global _expand_default_value
 
183
    if _expand_default_value is not None:
 
184
        return _expand_default_value
 
185
    conf = GlobalConfig()
 
186
    # Note that we must not use None for the expand value below or we'll run
 
187
    # into infinite recursion. Using False really would be quite silly ;)
 
188
    expand = conf.get_user_option_as_bool('bzr.config.expand', expand=True)
 
189
    if expand is None:
 
190
        # This is an opt-in feature, you *really* need to clearly say you want
 
191
        # to activate it !
 
192
        expand = False
 
193
    _expand_default_value = expand
 
194
    return expand
148
195
 
149
196
 
150
197
class Config(object):
153
200
    def __init__(self):
154
201
        super(Config, self).__init__()
155
202
 
 
203
    def config_id(self):
 
204
        """Returns a unique ID for the config."""
 
205
        raise NotImplementedError(self.config_id)
 
206
 
 
207
    @deprecated_method(deprecated_in((2, 4, 0)))
156
208
    def get_editor(self):
157
209
        """Get the users pop up editor."""
158
210
        raise NotImplementedError
165
217
        return diff.DiffFromTool.from_string(cmd, old_tree, new_tree,
166
218
                                             sys.stdout)
167
219
 
168
 
 
169
220
    def get_mail_client(self):
170
221
        """Get a mail client to use"""
171
222
        selected_client = self.get_user_option('mail_client')
182
233
    def _get_signing_policy(self):
183
234
        """Template method to override signature creation policy."""
184
235
 
 
236
    option_ref_re = None
 
237
 
 
238
    def expand_options(self, string, env=None):
 
239
        """Expand option references in the string in the configuration context.
 
240
 
 
241
        :param string: The string containing option to expand.
 
242
 
 
243
        :param env: An option dict defining additional configuration options or
 
244
            overriding existing ones.
 
245
 
 
246
        :returns: The expanded string.
 
247
        """
 
248
        return self._expand_options_in_string(string, env)
 
249
 
 
250
    def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
 
251
        """Expand options in  a list of strings in the configuration context.
 
252
 
 
253
        :param slist: A list of strings.
 
254
 
 
255
        :param env: An option dict defining additional configuration options or
 
256
            overriding existing ones.
 
257
 
 
258
        :param _ref_stack: Private list containing the options being
 
259
            expanded to detect loops.
 
260
 
 
261
        :returns: The flatten list of expanded strings.
 
262
        """
 
263
        # expand options in each value separately flattening lists
 
264
        result = []
 
265
        for s in slist:
 
266
            value = self._expand_options_in_string(s, env, _ref_stack)
 
267
            if isinstance(value, list):
 
268
                result.extend(value)
 
269
            else:
 
270
                result.append(value)
 
271
        return result
 
272
 
 
273
    def _expand_options_in_string(self, string, env=None, _ref_stack=None):
 
274
        """Expand options in the string in the configuration context.
 
275
 
 
276
        :param string: The string to be expanded.
 
277
 
 
278
        :param env: An option dict defining additional configuration options or
 
279
            overriding existing ones.
 
280
 
 
281
        :param _ref_stack: Private list containing the options being
 
282
            expanded to detect loops.
 
283
 
 
284
        :returns: The expanded string.
 
285
        """
 
286
        if string is None:
 
287
            # Not much to expand there
 
288
            return None
 
289
        if _ref_stack is None:
 
290
            # What references are currently resolved (to detect loops)
 
291
            _ref_stack = []
 
292
        if self.option_ref_re is None:
 
293
            # We want to match the most embedded reference first (i.e. for
 
294
            # '{{foo}}' we will get '{foo}',
 
295
            # for '{bar{baz}}' we will get '{baz}'
 
296
            self.option_ref_re = re.compile('({[^{}]+})')
 
297
        result = string
 
298
        # We need to iterate until no more refs appear ({{foo}} will need two
 
299
        # iterations for example).
 
300
        while True:
 
301
            raw_chunks = self.option_ref_re.split(result)
 
302
            if len(raw_chunks) == 1:
 
303
                # Shorcut the trivial case: no refs
 
304
                return result
 
305
            chunks = []
 
306
            list_value = False
 
307
            # Split will isolate refs so that every other chunk is a ref
 
308
            chunk_is_ref = False
 
309
            for chunk in raw_chunks:
 
310
                if not chunk_is_ref:
 
311
                    if chunk:
 
312
                        # Keep only non-empty strings (or we get bogus empty
 
313
                        # slots when a list value is involved).
 
314
                        chunks.append(chunk)
 
315
                    chunk_is_ref = True
 
316
                else:
 
317
                    name = chunk[1:-1]
 
318
                    if name in _ref_stack:
 
319
                        raise errors.OptionExpansionLoop(string, _ref_stack)
 
320
                    _ref_stack.append(name)
 
321
                    value = self._expand_option(name, env, _ref_stack)
 
322
                    if value is None:
 
323
                        raise errors.ExpandingUnknownOption(name, string)
 
324
                    if isinstance(value, list):
 
325
                        list_value = True
 
326
                        chunks.extend(value)
 
327
                    else:
 
328
                        chunks.append(value)
 
329
                    _ref_stack.pop()
 
330
                    chunk_is_ref = False
 
331
            if list_value:
 
332
                # Once a list appears as the result of an expansion, all
 
333
                # callers will get a list result. This allows a consistent
 
334
                # behavior even when some options in the expansion chain
 
335
                # defined as strings (no comma in their value) but their
 
336
                # expanded value is a list.
 
337
                return self._expand_options_in_list(chunks, env, _ref_stack)
 
338
            else:
 
339
                result = ''.join(chunks)
 
340
        return result
 
341
 
 
342
    def _expand_option(self, name, env, _ref_stack):
 
343
        if env is not None and name in env:
 
344
            # Special case, values provided in env takes precedence over
 
345
            # anything else
 
346
            value = env[name]
 
347
        else:
 
348
            # FIXME: This is a limited implementation, what we really need is a
 
349
            # way to query the bzr config for the value of an option,
 
350
            # respecting the scope rules (That is, once we implement fallback
 
351
            # configs, getting the option value should restart from the top
 
352
            # config, not the current one) -- vila 20101222
 
353
            value = self.get_user_option(name, expand=False)
 
354
            if isinstance(value, list):
 
355
                value = self._expand_options_in_list(value, env, _ref_stack)
 
356
            else:
 
357
                value = self._expand_options_in_string(value, env, _ref_stack)
 
358
        return value
 
359
 
185
360
    def _get_user_option(self, option_name):
186
361
        """Template method to provide a user option."""
187
362
        return None
188
363
 
189
 
    def get_user_option(self, option_name):
190
 
        """Get a generic option - no special process, no default."""
191
 
        return self._get_user_option(option_name)
192
 
 
193
 
    def get_user_option_as_bool(self, option_name):
194
 
        """Get a generic option as a boolean - no special process, no default.
195
 
 
 
364
    def get_user_option(self, option_name, expand=None):
 
365
        """Get a generic option - no special process, no default.
 
366
 
 
367
        :param option_name: The queried option.
 
368
 
 
369
        :param expand: Whether options references should be expanded.
 
370
 
 
371
        :returns: The value of the option.
 
372
        """
 
373
        if expand is None:
 
374
            expand = _get_expand_default_value()
 
375
        value = self._get_user_option(option_name)
 
376
        if expand:
 
377
            if isinstance(value, list):
 
378
                value = self._expand_options_in_list(value)
 
379
            elif isinstance(value, dict):
 
380
                trace.warning('Cannot expand "%s":'
 
381
                              ' Dicts do not support option expansion'
 
382
                              % (option_name,))
 
383
            else:
 
384
                value = self._expand_options_in_string(value)
 
385
        for hook in OldConfigHooks['get']:
 
386
            hook(self, option_name, value)
 
387
        return value
 
388
 
 
389
    def get_user_option_as_bool(self, option_name, expand=None, default=None):
 
390
        """Get a generic option as a boolean.
 
391
 
 
392
        :param expand: Allow expanding references to other config values.
 
393
        :param default: Default value if nothing is configured
196
394
        :return None if the option doesn't exist or its value can't be
197
395
            interpreted as a boolean. Returns True or False otherwise.
198
396
        """
199
 
        s = self._get_user_option(option_name)
 
397
        s = self.get_user_option(option_name, expand=expand)
200
398
        if s is None:
201
399
            # The option doesn't exist
202
 
            return None
 
400
            return default
203
401
        val = ui.bool_from_string(s)
204
402
        if val is None:
205
403
            # The value can't be interpreted as a boolean
207
405
                          s, option_name)
208
406
        return val
209
407
 
210
 
    def get_user_option_as_list(self, option_name):
 
408
    def get_user_option_as_list(self, option_name, expand=None):
211
409
        """Get a generic option as a list - no special process, no default.
212
410
 
213
411
        :return None if the option doesn't exist. Returns the value as a list
214
412
            otherwise.
215
413
        """
216
 
        l = self._get_user_option(option_name)
 
414
        l = self.get_user_option(option_name, expand=expand)
217
415
        if isinstance(l, (str, unicode)):
218
 
            # A single value, most probably the user forgot the final ','
 
416
            # A single value, most probably the user forgot (or didn't care to
 
417
            # add) the final ','
219
418
            l = [l]
220
419
        return l
 
420
        
 
421
    def get_user_option_as_int_from_SI(self,  option_name,  default=None):
 
422
        """Get a generic option from a human readable size in SI units, e.g 10MB
 
423
        
 
424
        Accepted suffixes are K,M,G. It is case-insensitive and may be followed
 
425
        by a trailing b (i.e. Kb, MB). This is intended to be practical and not
 
426
        pedantic.
 
427
        
 
428
        :return Integer, expanded to its base-10 value if a proper SI unit is 
 
429
            found. If the option doesn't exist, or isn't a value in 
 
430
            SI units, return default (which defaults to None)
 
431
        """
 
432
        val = self.get_user_option(option_name)
 
433
        if isinstance(val, list):
 
434
            val = val[0]
 
435
        if val is None:
 
436
            val = default
 
437
        else:
 
438
            p = re.compile("^(\d+)([kmg])*b*$", re.IGNORECASE)
 
439
            try:
 
440
                m = p.match(val)
 
441
                if m is not None:
 
442
                    val = int(m.group(1))
 
443
                    if m.group(2) is not None:
 
444
                        if m.group(2).lower() == 'k':
 
445
                            val *= 10**3
 
446
                        elif m.group(2).lower() == 'm':
 
447
                            val *= 10**6
 
448
                        elif m.group(2).lower() == 'g':
 
449
                            val *= 10**9
 
450
                else:
 
451
                    ui.ui_factory.show_warning(gettext('Invalid config value for "{0}" '
 
452
                                               ' value {1!r} is not an SI unit.').format(
 
453
                                                option_name, val))
 
454
                    val = default
 
455
            except TypeError:
 
456
                val = default
 
457
        return val
 
458
        
221
459
 
222
460
    def gpg_signing_command(self):
223
461
        """What program should be used to sign signatures?"""
241
479
        """See log_format()."""
242
480
        return None
243
481
 
 
482
    def validate_signatures_in_log(self):
 
483
        """Show GPG signature validity in log"""
 
484
        result = self._validate_signatures_in_log()
 
485
        if result == "true":
 
486
            result = True
 
487
        else:
 
488
            result = False
 
489
        return result
 
490
 
 
491
    def _validate_signatures_in_log(self):
 
492
        """See validate_signatures_in_log()."""
 
493
        return None
 
494
 
 
495
    def acceptable_keys(self):
 
496
        """Comma separated list of key patterns acceptable to 
 
497
        verify-signatures command"""
 
498
        result = self._acceptable_keys()
 
499
        return result
 
500
 
 
501
    def _acceptable_keys(self):
 
502
        """See acceptable_keys()."""
 
503
        return None
 
504
 
244
505
    def post_commit(self):
245
506
        """An ordered list of python functions to call.
246
507
 
265
526
        the concrete policy type is checked, and finally
266
527
        $EMAIL is examined.
267
528
        If no username can be found, errors.NoWhoami exception is raised.
268
 
 
269
 
        TODO: Check it's reasonably well-formed.
270
529
        """
271
530
        v = os.environ.get('BZR_EMAIL')
272
531
        if v:
273
532
            return v.decode(osutils.get_user_encoding())
274
 
 
275
533
        v = self._get_user_id()
276
534
        if v:
277
535
            return v
278
 
 
279
536
        v = os.environ.get('EMAIL')
280
537
        if v:
281
538
            return v.decode(osutils.get_user_encoding())
282
 
 
 
539
        name, email = _auto_user_id()
 
540
        if name and email:
 
541
            return '%s <%s>' % (name, email)
 
542
        elif email:
 
543
            return email
283
544
        raise errors.NoWhoami()
284
545
 
285
546
    def ensure_username(self):
309
570
        if policy is None:
310
571
            policy = self._get_signature_checking()
311
572
            if policy is not None:
 
573
                #this warning should go away once check_signatures is
 
574
                #implemented (if not before)
312
575
                trace.warning("Please use create_signatures,"
313
576
                              " not check_signatures to set signing policy.")
314
 
            if policy == CHECK_ALWAYS:
315
 
                return True
316
577
        elif policy == SIGN_ALWAYS:
317
578
            return True
318
579
        return False
319
580
 
 
581
    def gpg_signing_key(self):
 
582
        """GPG user-id to sign commits"""
 
583
        key = self.get_user_option('gpg_signing_key')
 
584
        if key == "default" or key == None:
 
585
            return self.user_email()
 
586
        else:
 
587
            return key
 
588
 
320
589
    def get_alias(self, value):
321
590
        return self._get_alias(value)
322
591
 
351
620
        else:
352
621
            return True
353
622
 
 
623
    def get_merge_tools(self):
 
624
        tools = {}
 
625
        for (oname, value, section, conf_id, parser) in self._get_options():
 
626
            if oname.startswith('bzr.mergetool.'):
 
627
                tool_name = oname[len('bzr.mergetool.'):]
 
628
                tools[tool_name] = self.get_user_option(oname)
 
629
        trace.mutter('loaded merge tools: %r' % tools)
 
630
        return tools
 
631
 
 
632
    def find_merge_tool(self, name):
 
633
        # We fake a defaults mechanism here by checking if the given name can
 
634
        # be found in the known_merge_tools if it's not found in the config.
 
635
        # This should be done through the proposed config defaults mechanism
 
636
        # when it becomes available in the future.
 
637
        command_line = (self.get_user_option('bzr.mergetool.%s' % name,
 
638
                                             expand=False)
 
639
                        or mergetools.known_merge_tools.get(name, None))
 
640
        return command_line
 
641
 
 
642
 
 
643
class _ConfigHooks(hooks.Hooks):
 
644
    """A dict mapping hook names and a list of callables for configs.
 
645
    """
 
646
 
 
647
    def __init__(self):
 
648
        """Create the default hooks.
 
649
 
 
650
        These are all empty initially, because by default nothing should get
 
651
        notified.
 
652
        """
 
653
        super(_ConfigHooks, self).__init__('bzrlib.config', 'ConfigHooks')
 
654
        self.add_hook('load',
 
655
                      'Invoked when a config store is loaded.'
 
656
                      ' The signature is (store).',
 
657
                      (2, 4))
 
658
        self.add_hook('save',
 
659
                      'Invoked when a config store is saved.'
 
660
                      ' The signature is (store).',
 
661
                      (2, 4))
 
662
        # The hooks for config options
 
663
        self.add_hook('get',
 
664
                      'Invoked when a config option is read.'
 
665
                      ' The signature is (stack, name, value).',
 
666
                      (2, 4))
 
667
        self.add_hook('set',
 
668
                      'Invoked when a config option is set.'
 
669
                      ' The signature is (stack, name, value).',
 
670
                      (2, 4))
 
671
        self.add_hook('remove',
 
672
                      'Invoked when a config option is removed.'
 
673
                      ' The signature is (stack, name).',
 
674
                      (2, 4))
 
675
ConfigHooks = _ConfigHooks()
 
676
 
 
677
 
 
678
class _OldConfigHooks(hooks.Hooks):
 
679
    """A dict mapping hook names and a list of callables for configs.
 
680
    """
 
681
 
 
682
    def __init__(self):
 
683
        """Create the default hooks.
 
684
 
 
685
        These are all empty initially, because by default nothing should get
 
686
        notified.
 
687
        """
 
688
        super(_OldConfigHooks, self).__init__('bzrlib.config', 'OldConfigHooks')
 
689
        self.add_hook('load',
 
690
                      'Invoked when a config store is loaded.'
 
691
                      ' The signature is (config).',
 
692
                      (2, 4))
 
693
        self.add_hook('save',
 
694
                      'Invoked when a config store is saved.'
 
695
                      ' The signature is (config).',
 
696
                      (2, 4))
 
697
        # The hooks for config options
 
698
        self.add_hook('get',
 
699
                      'Invoked when a config option is read.'
 
700
                      ' The signature is (config, name, value).',
 
701
                      (2, 4))
 
702
        self.add_hook('set',
 
703
                      'Invoked when a config option is set.'
 
704
                      ' The signature is (config, name, value).',
 
705
                      (2, 4))
 
706
        self.add_hook('remove',
 
707
                      'Invoked when a config option is removed.'
 
708
                      ' The signature is (config, name).',
 
709
                      (2, 4))
 
710
OldConfigHooks = _OldConfigHooks()
 
711
 
354
712
 
355
713
class IniBasedConfig(Config):
356
714
    """A configuration policy that draws from ini files."""
417
775
            self._parser = ConfigObj(co_input, encoding='utf-8')
418
776
        except configobj.ConfigObjError, e:
419
777
            raise errors.ParseConfigError(e.errors, e.config.filename)
 
778
        except UnicodeDecodeError:
 
779
            raise errors.ConfigContentError(self.file_name)
420
780
        # Make sure self.reload() will use the right file name
421
781
        self._parser.filename = self.file_name
 
782
        for hook in OldConfigHooks['load']:
 
783
            hook(self)
422
784
        return self._parser
423
785
 
424
786
    def reload(self):
427
789
            raise AssertionError('We need a file name to reload the config')
428
790
        if self._parser is not None:
429
791
            self._parser.reload()
 
792
        for hook in ConfigHooks['load']:
 
793
            hook(self)
430
794
 
431
795
    def _get_matching_sections(self):
432
796
        """Return an ordered list of (section_name, extra_path) pairs.
444
808
        """Override this to define the section used by the config."""
445
809
        return "DEFAULT"
446
810
 
 
811
    def _get_sections(self, name=None):
 
812
        """Returns an iterator of the sections specified by ``name``.
 
813
 
 
814
        :param name: The section name. If None is supplied, the default
 
815
            configurations are yielded.
 
816
 
 
817
        :return: A tuple (name, section, config_id) for all sections that will
 
818
            be walked by user_get_option() in the 'right' order. The first one
 
819
            is where set_user_option() will update the value.
 
820
        """
 
821
        parser = self._get_parser()
 
822
        if name is not None:
 
823
            yield (name, parser[name], self.config_id())
 
824
        else:
 
825
            # No section name has been given so we fallback to the configobj
 
826
            # itself which holds the variables defined outside of any section.
 
827
            yield (None, parser, self.config_id())
 
828
 
 
829
    def _get_options(self, sections=None):
 
830
        """Return an ordered list of (name, value, section, config_id) tuples.
 
831
 
 
832
        All options are returned with their associated value and the section
 
833
        they appeared in. ``config_id`` is a unique identifier for the
 
834
        configuration file the option is defined in.
 
835
 
 
836
        :param sections: Default to ``_get_matching_sections`` if not
 
837
            specified. This gives a better control to daughter classes about
 
838
            which sections should be searched. This is a list of (name,
 
839
            configobj) tuples.
 
840
        """
 
841
        opts = []
 
842
        if sections is None:
 
843
            parser = self._get_parser()
 
844
            sections = []
 
845
            for (section_name, _) in self._get_matching_sections():
 
846
                try:
 
847
                    section = parser[section_name]
 
848
                except KeyError:
 
849
                    # This could happen for an empty file for which we define a
 
850
                    # DEFAULT section. FIXME: Force callers to provide sections
 
851
                    # instead ? -- vila 20100930
 
852
                    continue
 
853
                sections.append((section_name, section))
 
854
        config_id = self.config_id()
 
855
        for (section_name, section) in sections:
 
856
            for (name, value) in section.iteritems():
 
857
                yield (name, parser._quote(value), section_name,
 
858
                       config_id, parser)
 
859
 
447
860
    def _get_option_policy(self, section, option_name):
448
861
        """Return the policy for the given (section, option_name) pair."""
449
862
        return POLICY_NONE
500
913
        """See Config.log_format."""
501
914
        return self._get_user_option('log_format')
502
915
 
 
916
    def _validate_signatures_in_log(self):
 
917
        """See Config.validate_signatures_in_log."""
 
918
        return self._get_user_option('validate_signatures_in_log')
 
919
 
 
920
    def _acceptable_keys(self):
 
921
        """See Config.acceptable_keys."""
 
922
        return self._get_user_option('acceptable_keys')
 
923
 
503
924
    def _post_commit(self):
504
925
        """See Config.post_commit."""
505
926
        return self._get_user_option('post_commit')
536
957
    def _get_nickname(self):
537
958
        return self.get_user_option('nickname')
538
959
 
 
960
    def remove_user_option(self, option_name, section_name=None):
 
961
        """Remove a user option and save the configuration file.
 
962
 
 
963
        :param option_name: The option to be removed.
 
964
 
 
965
        :param section_name: The section the option is defined in, default to
 
966
            the default section.
 
967
        """
 
968
        self.reload()
 
969
        parser = self._get_parser()
 
970
        if section_name is None:
 
971
            section = parser
 
972
        else:
 
973
            section = parser[section_name]
 
974
        try:
 
975
            del section[option_name]
 
976
        except KeyError:
 
977
            raise errors.NoSuchConfigOption(option_name)
 
978
        self._write_config_file()
 
979
        for hook in OldConfigHooks['remove']:
 
980
            hook(self, option_name)
 
981
 
539
982
    def _write_config_file(self):
540
983
        if self.file_name is None:
541
984
            raise AssertionError('We cannot save, self.file_name is None')
546
989
        atomic_file.commit()
547
990
        atomic_file.close()
548
991
        osutils.copy_ownership_from_path(self.file_name)
 
992
        for hook in OldConfigHooks['save']:
 
993
            hook(self)
549
994
 
550
995
 
551
996
class LockableConfig(IniBasedConfig):
578
1023
    def __init__(self, file_name):
579
1024
        super(LockableConfig, self).__init__(file_name=file_name)
580
1025
        self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
581
 
        self.transport = transport.get_transport(self.dir)
582
 
        self._lock = lockdir.LockDir(self.transport, 'lock')
 
1026
        # FIXME: It doesn't matter that we don't provide possible_transports
 
1027
        # below since this is currently used only for local config files ;
 
1028
        # local transports are not shared. But if/when we start using
 
1029
        # LockableConfig for other kind of transports, we will need to reuse
 
1030
        # whatever connection is already established -- vila 20100929
 
1031
        self.transport = transport.get_transport_from_path(self.dir)
 
1032
        self._lock = lockdir.LockDir(self.transport, self.lock_name)
583
1033
 
584
1034
    def _create_from_string(self, unicode_bytes, save):
585
1035
        super(LockableConfig, self)._create_from_string(unicode_bytes, False)
604
1054
    def break_lock(self):
605
1055
        self._lock.break_lock()
606
1056
 
 
1057
    @needs_write_lock
 
1058
    def remove_user_option(self, option_name, section_name=None):
 
1059
        super(LockableConfig, self).remove_user_option(option_name,
 
1060
                                                       section_name)
 
1061
 
607
1062
    def _write_config_file(self):
608
1063
        if self._lock is None or not self._lock.is_held:
609
1064
            # NB: if the following exception is raised it probably means a
618
1073
    def __init__(self):
619
1074
        super(GlobalConfig, self).__init__(file_name=config_filename())
620
1075
 
 
1076
    def config_id(self):
 
1077
        return 'bazaar'
 
1078
 
621
1079
    @classmethod
622
1080
    def from_string(cls, str_or_unicode, save=False):
623
1081
        """Create a config object from a string.
631
1089
        conf._create_from_string(str_or_unicode, save)
632
1090
        return conf
633
1091
 
 
1092
    @deprecated_method(deprecated_in((2, 4, 0)))
634
1093
    def get_editor(self):
635
1094
        return self._get_user_option('editor')
636
1095
 
665
1124
        self.reload()
666
1125
        self._get_parser().setdefault(section, {})[option] = value
667
1126
        self._write_config_file()
 
1127
        for hook in OldConfigHooks['set']:
 
1128
            hook(self, option, value)
 
1129
 
 
1130
    def _get_sections(self, name=None):
 
1131
        """See IniBasedConfig._get_sections()."""
 
1132
        parser = self._get_parser()
 
1133
        # We don't give access to options defined outside of any section, we
 
1134
        # used the DEFAULT section by... default.
 
1135
        if name in (None, 'DEFAULT'):
 
1136
            # This could happen for an empty file where the DEFAULT section
 
1137
            # doesn't exist yet. So we force DEFAULT when yielding
 
1138
            name = 'DEFAULT'
 
1139
            if 'DEFAULT' not in parser:
 
1140
               parser['DEFAULT']= {}
 
1141
        yield (name, parser[name], self.config_id())
 
1142
 
 
1143
    @needs_write_lock
 
1144
    def remove_user_option(self, option_name, section_name=None):
 
1145
        if section_name is None:
 
1146
            # We need to force the default section.
 
1147
            section_name = 'DEFAULT'
 
1148
        # We need to avoid the LockableConfig implementation or we'll lock
 
1149
        # twice
 
1150
        super(LockableConfig, self).remove_user_option(option_name,
 
1151
                                                       section_name)
 
1152
 
 
1153
def _iter_for_location_by_parts(sections, location):
 
1154
    """Keep only the sessions matching the specified location.
 
1155
 
 
1156
    :param sections: An iterable of section names.
 
1157
 
 
1158
    :param location: An url or a local path to match against.
 
1159
 
 
1160
    :returns: An iterator of (section, extra_path, nb_parts) where nb is the
 
1161
        number of path components in the section name, section is the section
 
1162
        name and extra_path is the difference between location and the section
 
1163
        name.
 
1164
 
 
1165
    ``location`` will always be a local path and never a 'file://' url but the
 
1166
    section names themselves can be in either form.
 
1167
    """
 
1168
    location_parts = location.rstrip('/').split('/')
 
1169
 
 
1170
    for section in sections:
 
1171
        # location is a local path if possible, so we need to convert 'file://'
 
1172
        # urls in section names to local paths if necessary.
 
1173
 
 
1174
        # This also avoids having file:///path be a more exact
 
1175
        # match than '/path'.
 
1176
 
 
1177
        # FIXME: This still raises an issue if a user defines both file:///path
 
1178
        # *and* /path. Should we raise an error in this case -- vila 20110505
 
1179
 
 
1180
        if section.startswith('file://'):
 
1181
            section_path = urlutils.local_path_from_url(section)
 
1182
        else:
 
1183
            section_path = section
 
1184
        section_parts = section_path.rstrip('/').split('/')
 
1185
 
 
1186
        matched = True
 
1187
        if len(section_parts) > len(location_parts):
 
1188
            # More path components in the section, they can't match
 
1189
            matched = False
 
1190
        else:
 
1191
            # Rely on zip truncating in length to the length of the shortest
 
1192
            # argument sequence.
 
1193
            names = zip(location_parts, section_parts)
 
1194
            for name in names:
 
1195
                if not fnmatch.fnmatch(name[0], name[1]):
 
1196
                    matched = False
 
1197
                    break
 
1198
        if not matched:
 
1199
            continue
 
1200
        # build the path difference between the section and the location
 
1201
        extra_path = '/'.join(location_parts[len(section_parts):])
 
1202
        yield section, extra_path, len(section_parts)
668
1203
 
669
1204
 
670
1205
class LocationConfig(LockableConfig):
680
1215
            location = urlutils.local_path_from_url(location)
681
1216
        self.location = location
682
1217
 
 
1218
    def config_id(self):
 
1219
        return 'locations'
 
1220
 
683
1221
    @classmethod
684
1222
    def from_string(cls, str_or_unicode, location, save=False):
685
1223
        """Create a config object from a string.
697
1235
 
698
1236
    def _get_matching_sections(self):
699
1237
        """Return an ordered list of section names matching this location."""
700
 
        sections = self._get_parser()
701
 
        location_names = self.location.split('/')
702
 
        if self.location.endswith('/'):
703
 
            del location_names[-1]
704
 
        matches=[]
705
 
        for section in sections:
706
 
            # location is a local path if possible, so we need
707
 
            # to convert 'file://' urls to local paths if necessary.
708
 
            # This also avoids having file:///path be a more exact
709
 
            # match than '/path'.
710
 
            if section.startswith('file://'):
711
 
                section_path = urlutils.local_path_from_url(section)
712
 
            else:
713
 
                section_path = section
714
 
            section_names = section_path.split('/')
715
 
            if section.endswith('/'):
716
 
                del section_names[-1]
717
 
            names = zip(location_names, section_names)
718
 
            matched = True
719
 
            for name in names:
720
 
                if not fnmatch(name[0], name[1]):
721
 
                    matched = False
722
 
                    break
723
 
            if not matched:
724
 
                continue
725
 
            # so, for the common prefix they matched.
726
 
            # if section is longer, no match.
727
 
            if len(section_names) > len(location_names):
728
 
                continue
729
 
            matches.append((len(section_names), section,
730
 
                            '/'.join(location_names[len(section_names):])))
731
 
        matches.sort(reverse=True)
732
 
        sections = []
733
 
        for (length, section, extra_path) in matches:
734
 
            sections.append((section, extra_path))
 
1238
        matches = list(_iter_for_location_by_parts(self._get_parser(),
 
1239
                                                   self.location))
 
1240
        # put the longest (aka more specific) locations first
 
1241
        matches.sort(
 
1242
            key=lambda (section, extra_path, length): (length, section),
 
1243
            reverse=True)
 
1244
        for (section, extra_path, length) in matches:
 
1245
            yield section, extra_path
735
1246
            # should we stop looking for parent configs here?
736
1247
            try:
737
1248
                if self._get_parser()[section].as_bool('ignore_parents'):
738
1249
                    break
739
1250
            except KeyError:
740
1251
                pass
741
 
        return sections
 
1252
 
 
1253
    def _get_sections(self, name=None):
 
1254
        """See IniBasedConfig._get_sections()."""
 
1255
        # We ignore the name here as the only sections handled are named with
 
1256
        # the location path and we don't expose embedded sections either.
 
1257
        parser = self._get_parser()
 
1258
        for name, extra_path in self._get_matching_sections():
 
1259
            yield (name, parser[name], self.config_id())
742
1260
 
743
1261
    def _get_option_policy(self, section, option_name):
744
1262
        """Return the policy for the given (section, option_name) pair."""
809
1327
        # the allowed values of store match the config policies
810
1328
        self._set_option_policy(location, option, store)
811
1329
        self._write_config_file()
 
1330
        for hook in OldConfigHooks['set']:
 
1331
            hook(self, option, value)
812
1332
 
813
1333
 
814
1334
class BranchConfig(Config):
824
1344
                               self._get_branch_data_config,
825
1345
                               self._get_global_config)
826
1346
 
 
1347
    def config_id(self):
 
1348
        return 'branch'
 
1349
 
827
1350
    def _get_branch_data_config(self):
828
1351
        if self._branch_data_config is None:
829
1352
            self._branch_data_config = TreeConfig(self.branch)
 
1353
            self._branch_data_config.config_id = self.config_id
830
1354
        return self._branch_data_config
831
1355
 
832
1356
    def _get_location_config(self):
872
1396
        e.g. "John Hacker <jhacker@example.com>"
873
1397
        This is looked up in the email controlfile for the branch.
874
1398
        """
875
 
        try:
876
 
            return (self.branch._transport.get_bytes("email")
877
 
                    .decode(osutils.get_user_encoding())
878
 
                    .rstrip("\r\n"))
879
 
        except errors.NoSuchFile, e:
880
 
            pass
881
 
 
882
1399
        return self._get_best_value('_get_user_id')
883
1400
 
884
1401
    def _get_change_editor(self):
900
1417
                return value
901
1418
        return None
902
1419
 
 
1420
    def _get_sections(self, name=None):
 
1421
        """See IniBasedConfig.get_sections()."""
 
1422
        for source in self.option_sources:
 
1423
            for section in source()._get_sections(name):
 
1424
                yield section
 
1425
 
 
1426
    def _get_options(self, sections=None):
 
1427
        opts = []
 
1428
        # First the locations options
 
1429
        for option in self._get_location_config()._get_options():
 
1430
            yield option
 
1431
        # Then the branch options
 
1432
        branch_config = self._get_branch_data_config()
 
1433
        if sections is None:
 
1434
            sections = [('DEFAULT', branch_config._get_parser())]
 
1435
        # FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
 
1436
        # Config itself has no notion of sections :( -- vila 20101001
 
1437
        config_id = self.config_id()
 
1438
        for (section_name, section) in sections:
 
1439
            for (name, value) in section.iteritems():
 
1440
                yield (name, value, section_name,
 
1441
                       config_id, branch_config._get_parser())
 
1442
        # Then the global options
 
1443
        for option in self._get_global_config()._get_options():
 
1444
            yield option
 
1445
 
903
1446
    def set_user_option(self, name, value, store=STORE_BRANCH,
904
1447
        warn_masked=False):
905
1448
        if store == STORE_BRANCH:
923
1466
                        trace.warning('Value "%s" is masked by "%s" from'
924
1467
                                      ' branch.conf', value, mask_value)
925
1468
 
 
1469
    def remove_user_option(self, option_name, section_name=None):
 
1470
        self._get_branch_data_config().remove_option(option_name, section_name)
 
1471
 
926
1472
    def _gpg_signing_command(self):
927
1473
        """See Config.gpg_signing_command."""
928
1474
        return self._get_safe_value('_gpg_signing_command')
948
1494
        """See Config.log_format."""
949
1495
        return self._get_best_value('_log_format')
950
1496
 
 
1497
    def _validate_signatures_in_log(self):
 
1498
        """See Config.validate_signatures_in_log."""
 
1499
        return self._get_best_value('_validate_signatures_in_log')
 
1500
 
 
1501
    def _acceptable_keys(self):
 
1502
        """See Config.acceptable_keys."""
 
1503
        return self._get_best_value('_acceptable_keys')
 
1504
 
951
1505
 
952
1506
def ensure_config_dir_exists(path=None):
953
1507
    """Make sure a configuration directory exists.
962
1516
            parent_dir = os.path.dirname(path)
963
1517
            if not os.path.isdir(parent_dir):
964
1518
                trace.mutter('creating config parent directory: %r', parent_dir)
965
 
            os.mkdir(parent_dir)
 
1519
                os.mkdir(parent_dir)
966
1520
        trace.mutter('creating config directory: %r', path)
967
1521
        os.mkdir(path)
968
1522
        osutils.copy_ownership_from_path(path)
971
1525
def config_dir():
972
1526
    """Return per-user configuration directory.
973
1527
 
974
 
    By default this is ~/.bazaar/
 
1528
    By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
 
1529
    and Linux.  On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
 
1530
    that will be used instead.
975
1531
 
976
1532
    TODO: Global option --config-dir to override this.
977
1533
    """
978
1534
    base = os.environ.get('BZR_HOME', None)
979
1535
    if sys.platform == 'win32':
 
1536
        # environ variables on Windows are in user encoding/mbcs. So decode
 
1537
        # before using one
 
1538
        if base is not None:
 
1539
            base = base.decode('mbcs')
980
1540
        if base is None:
981
1541
            base = win32utils.get_appdata_location_unicode()
982
1542
        if base is None:
983
1543
            base = os.environ.get('HOME', None)
 
1544
            if base is not None:
 
1545
                base = base.decode('mbcs')
984
1546
        if base is None:
985
1547
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
986
1548
                                  ' or HOME set')
987
1549
        return osutils.pathjoin(base, 'bazaar', '2.0')
988
1550
    else:
989
 
        if base is None:
 
1551
        if base is not None:
 
1552
            base = base.decode(osutils._fs_enc)
 
1553
    if sys.platform == 'darwin':
 
1554
        if base is None:
 
1555
            # this takes into account $HOME
 
1556
            base = os.path.expanduser("~")
 
1557
        return osutils.pathjoin(base, '.bazaar')
 
1558
    else:
 
1559
        if base is None:
 
1560
            xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
 
1561
            if xdg_dir is None:
 
1562
                xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
 
1563
            xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
 
1564
            if osutils.isdir(xdg_dir):
 
1565
                trace.mutter(
 
1566
                    "Using configuration in XDG directory %s." % xdg_dir)
 
1567
                return xdg_dir
990
1568
            base = os.path.expanduser("~")
991
1569
        return osutils.pathjoin(base, ".bazaar")
992
1570
 
1038
1616
        return os.path.expanduser('~/.cache')
1039
1617
 
1040
1618
 
 
1619
def _get_default_mail_domain():
 
1620
    """If possible, return the assumed default email domain.
 
1621
 
 
1622
    :returns: string mail domain, or None.
 
1623
    """
 
1624
    if sys.platform == 'win32':
 
1625
        # No implementation yet; patches welcome
 
1626
        return None
 
1627
    try:
 
1628
        f = open('/etc/mailname')
 
1629
    except (IOError, OSError), e:
 
1630
        return None
 
1631
    try:
 
1632
        domain = f.read().strip()
 
1633
        return domain
 
1634
    finally:
 
1635
        f.close()
 
1636
 
 
1637
 
 
1638
def _auto_user_id():
 
1639
    """Calculate automatic user identification.
 
1640
 
 
1641
    :returns: (realname, email), either of which may be None if they can't be
 
1642
    determined.
 
1643
 
 
1644
    Only used when none is set in the environment or the id file.
 
1645
 
 
1646
    This only returns an email address if we can be fairly sure the 
 
1647
    address is reasonable, ie if /etc/mailname is set on unix.
 
1648
 
 
1649
    This doesn't use the FQDN as the default domain because that may be 
 
1650
    slow, and it doesn't use the hostname alone because that's not normally 
 
1651
    a reasonable address.
 
1652
    """
 
1653
    if sys.platform == 'win32':
 
1654
        # No implementation to reliably determine Windows default mail
 
1655
        # address; please add one.
 
1656
        return None, None
 
1657
 
 
1658
    default_mail_domain = _get_default_mail_domain()
 
1659
    if not default_mail_domain:
 
1660
        return None, None
 
1661
 
 
1662
    import pwd
 
1663
    uid = os.getuid()
 
1664
    try:
 
1665
        w = pwd.getpwuid(uid)
 
1666
    except KeyError:
 
1667
        trace.mutter('no passwd entry for uid %d?' % uid)
 
1668
        return None, None
 
1669
 
 
1670
    # we try utf-8 first, because on many variants (like Linux),
 
1671
    # /etc/passwd "should" be in utf-8, and because it's unlikely to give
 
1672
    # false positives.  (many users will have their user encoding set to
 
1673
    # latin-1, which cannot raise UnicodeError.)
 
1674
    try:
 
1675
        gecos = w.pw_gecos.decode('utf-8')
 
1676
        encoding = 'utf-8'
 
1677
    except UnicodeError:
 
1678
        try:
 
1679
            encoding = osutils.get_user_encoding()
 
1680
            gecos = w.pw_gecos.decode(encoding)
 
1681
        except UnicodeError, e:
 
1682
            trace.mutter("cannot decode passwd entry %s" % w)
 
1683
            return None, None
 
1684
    try:
 
1685
        username = w.pw_name.decode(encoding)
 
1686
    except UnicodeError, e:
 
1687
        trace.mutter("cannot decode passwd entry %s" % w)
 
1688
        return None, None
 
1689
 
 
1690
    comma = gecos.find(',')
 
1691
    if comma == -1:
 
1692
        realname = gecos
 
1693
    else:
 
1694
        realname = gecos[:comma]
 
1695
 
 
1696
    return realname, (username + '@' + default_mail_domain)
 
1697
 
 
1698
 
1041
1699
def parse_username(username):
1042
1700
    """Parse e-mail username and return a (name, address) tuple."""
1043
1701
    match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1086
1744
 
1087
1745
    def set_option(self, value, name, section=None):
1088
1746
        """Set a per-branch configuration option"""
 
1747
        # FIXME: We shouldn't need to lock explicitly here but rather rely on
 
1748
        # higher levels providing the right lock -- vila 20101004
1089
1749
        self.branch.lock_write()
1090
1750
        try:
1091
1751
            self._config.set_option(value, name, section)
1092
1752
        finally:
1093
1753
            self.branch.unlock()
1094
1754
 
 
1755
    def remove_option(self, option_name, section_name=None):
 
1756
        # FIXME: We shouldn't need to lock explicitly here but rather rely on
 
1757
        # higher levels providing the right lock -- vila 20101004
 
1758
        self.branch.lock_write()
 
1759
        try:
 
1760
            self._config.remove_option(option_name, section_name)
 
1761
        finally:
 
1762
            self.branch.unlock()
 
1763
 
1095
1764
 
1096
1765
class AuthenticationConfig(object):
1097
1766
    """The authentication configuration file based on a ini file.
1123
1792
            self._config = ConfigObj(self._input, encoding='utf-8')
1124
1793
        except configobj.ConfigObjError, e:
1125
1794
            raise errors.ParseConfigError(e.errors, e.config.filename)
 
1795
        except UnicodeError:
 
1796
            raise errors.ConfigContentError(self._filename)
1126
1797
        return self._config
1127
1798
 
1128
1799
    def _save(self):
1145
1816
        section[option_name] = value
1146
1817
        self._save()
1147
1818
 
1148
 
    def get_credentials(self, scheme, host, port=None, user=None, path=None, 
 
1819
    def get_credentials(self, scheme, host, port=None, user=None, path=None,
1149
1820
                        realm=None):
1150
1821
        """Returns the matching credentials from authentication.conf file.
1151
1822
 
1319
1990
            if ask:
1320
1991
                if prompt is None:
1321
1992
                    # Create a default prompt suitable for most cases
1322
 
                    prompt = scheme.upper() + ' %(host)s username'
 
1993
                    prompt = u'%s' % (scheme.upper(),) + u' %(host)s username'
1323
1994
                # Special handling for optional fields in the prompt
1324
1995
                if port is not None:
1325
1996
                    prompt_host = '%s:%d' % (host, port)
1363
2034
        if password is None:
1364
2035
            if prompt is None:
1365
2036
                # Create a default prompt suitable for most cases
1366
 
                prompt = '%s' % scheme.upper() + ' %(user)s@%(host)s password'
 
2037
                prompt = u'%s' % scheme.upper() + u' %(user)s@%(host)s password'
1367
2038
            # Special handling for optional fields in the prompt
1368
2039
            if port is not None:
1369
2040
                prompt_host = '%s:%d' % (host, port)
1540
2211
    """A Config that reads/writes a config file on a Transport.
1541
2212
 
1542
2213
    It is a low-level object that considers config data to be name/value pairs
1543
 
    that may be associated with a section.  Assigning meaning to the these
1544
 
    values is done at higher levels like TreeConfig.
 
2214
    that may be associated with a section.  Assigning meaning to these values
 
2215
    is done at higher levels like TreeConfig.
1545
2216
    """
1546
2217
 
1547
2218
    def __init__(self, transport, filename):
1564
2235
                section_obj = configobj[section]
1565
2236
            except KeyError:
1566
2237
                return default
1567
 
        return section_obj.get(name, default)
 
2238
        value = section_obj.get(name, default)
 
2239
        for hook in OldConfigHooks['get']:
 
2240
            hook(self, name, value)
 
2241
        return value
1568
2242
 
1569
2243
    def set_option(self, value, name, section=None):
1570
2244
        """Set the value associated with a named option.
1578
2252
            configobj[name] = value
1579
2253
        else:
1580
2254
            configobj.setdefault(section, {})[name] = value
 
2255
        for hook in OldConfigHooks['set']:
 
2256
            hook(self, name, value)
 
2257
        self._set_configobj(configobj)
 
2258
 
 
2259
    def remove_option(self, option_name, section_name=None):
 
2260
        configobj = self._get_configobj()
 
2261
        if section_name is None:
 
2262
            del configobj[option_name]
 
2263
        else:
 
2264
            del configobj[section_name][option_name]
 
2265
        for hook in OldConfigHooks['remove']:
 
2266
            hook(self, option_name)
1581
2267
        self._set_configobj(configobj)
1582
2268
 
1583
2269
    def _get_config_file(self):
1584
2270
        try:
1585
 
            return StringIO(self._transport.get_bytes(self._filename))
 
2271
            f = StringIO(self._transport.get_bytes(self._filename))
 
2272
            for hook in OldConfigHooks['load']:
 
2273
                hook(self)
 
2274
            return f
1586
2275
        except errors.NoSuchFile:
1587
2276
            return StringIO()
 
2277
        except errors.PermissionDenied, e:
 
2278
            trace.warning("Permission denied while trying to open "
 
2279
                "configuration file %s.", urlutils.unescape_for_display(
 
2280
                urlutils.join(self._transport.base, self._filename), "utf-8"))
 
2281
            return StringIO()
 
2282
 
 
2283
    def _external_url(self):
 
2284
        return urlutils.join(self._transport.external_url(), self._filename)
1588
2285
 
1589
2286
    def _get_configobj(self):
1590
2287
        f = self._get_config_file()
1591
2288
        try:
1592
 
            return ConfigObj(f, encoding='utf-8')
 
2289
            try:
 
2290
                conf = ConfigObj(f, encoding='utf-8')
 
2291
            except configobj.ConfigObjError, e:
 
2292
                raise errors.ParseConfigError(e.errors, self._external_url())
 
2293
            except UnicodeDecodeError:
 
2294
                raise errors.ConfigContentError(self._external_url())
1593
2295
        finally:
1594
2296
            f.close()
 
2297
        return conf
1595
2298
 
1596
2299
    def _set_configobj(self, configobj):
1597
2300
        out_file = StringIO()
1598
2301
        configobj.write(out_file)
1599
2302
        out_file.seek(0)
1600
2303
        self._transport.put_file(self._filename, out_file)
 
2304
        for hook in OldConfigHooks['save']:
 
2305
            hook(self)
 
2306
 
 
2307
 
 
2308
class Option(object):
 
2309
    """An option definition.
 
2310
 
 
2311
    The option *values* are stored in config files and found in sections.
 
2312
 
 
2313
    Here we define various properties about the option itself, its default
 
2314
    value, how to convert it from stores, what to do when invalid values are
 
2315
    encoutered, in which config files it can be stored.
 
2316
    """
 
2317
 
 
2318
    def __init__(self, name, default=None, default_from_env=None,
 
2319
                 help=None,
 
2320
                 from_unicode=None, invalid=None):
 
2321
        """Build an option definition.
 
2322
 
 
2323
        :param name: the name used to refer to the option.
 
2324
 
 
2325
        :param default: the default value to use when none exist in the config
 
2326
            stores. This is either a string that ``from_unicode`` will convert
 
2327
            into the proper type, a callable returning a unicode string so that
 
2328
            ``from_unicode`` can be used on the return value, or a python
 
2329
            object that can be stringified (so only the empty list is supported
 
2330
            for example).
 
2331
 
 
2332
        :param default_from_env: A list of environment variables which can
 
2333
           provide a default value. 'default' will be used only if none of the
 
2334
           variables specified here are set in the environment.
 
2335
 
 
2336
        :param help: a doc string to explain the option to the user.
 
2337
 
 
2338
        :param from_unicode: a callable to convert the unicode string
 
2339
            representing the option value in a store. This is not called for
 
2340
            the default value.
 
2341
 
 
2342
        :param invalid: the action to be taken when an invalid value is
 
2343
            encountered in a store. This is called only when from_unicode is
 
2344
            invoked to convert a string and returns None or raise ValueError or
 
2345
            TypeError. Accepted values are: None (ignore invalid values),
 
2346
            'warning' (emit a warning), 'error' (emit an error message and
 
2347
            terminates).
 
2348
        """
 
2349
        if default_from_env is None:
 
2350
            default_from_env = []
 
2351
        self.name = name
 
2352
        # Convert the default value to a unicode string so all values are
 
2353
        # strings internally before conversion (via from_unicode) is attempted.
 
2354
        if default is None:
 
2355
            self.default = None
 
2356
        elif isinstance(default, list):
 
2357
            # Only the empty list is supported
 
2358
            if default:
 
2359
                raise AssertionError(
 
2360
                    'Only empty lists are supported as default values')
 
2361
            self.default = u','
 
2362
        elif isinstance(default, (str, unicode, bool, int, float)):
 
2363
            # Rely on python to convert strings, booleans and integers
 
2364
            self.default = u'%s' % (default,)
 
2365
        elif callable(default):
 
2366
            self.default = default
 
2367
        else:
 
2368
            # other python objects are not expected
 
2369
            raise AssertionError('%r is not supported as a default value'
 
2370
                                 % (default,))
 
2371
        self.default_from_env = default_from_env
 
2372
        self.help = help
 
2373
        self.from_unicode = from_unicode
 
2374
        if invalid and invalid not in ('warning', 'error'):
 
2375
            raise AssertionError("%s not supported for 'invalid'" % (invalid,))
 
2376
        self.invalid = invalid
 
2377
 
 
2378
    def convert_from_unicode(self, unicode_value):
 
2379
        if self.from_unicode is None or unicode_value is None:
 
2380
            # Don't convert or nothing to convert
 
2381
            return unicode_value
 
2382
        try:
 
2383
            converted = self.from_unicode(unicode_value)
 
2384
        except (ValueError, TypeError):
 
2385
            # Invalid values are ignored
 
2386
            converted = None
 
2387
        if converted is None and self.invalid is not None:
 
2388
            # The conversion failed
 
2389
            if self.invalid == 'warning':
 
2390
                trace.warning('Value "%s" is not valid for "%s"',
 
2391
                              unicode_value, self.name)
 
2392
            elif self.invalid == 'error':
 
2393
                raise errors.ConfigOptionValueError(self.name, unicode_value)
 
2394
        return converted
 
2395
 
 
2396
    def get_default(self):
 
2397
        value = None
 
2398
        for var in self.default_from_env:
 
2399
            try:
 
2400
                # If the env variable is defined, its value is the default one
 
2401
                value = os.environ[var]
 
2402
                break
 
2403
            except KeyError:
 
2404
                continue
 
2405
        if value is None:
 
2406
            # Otherwise, fallback to the value defined at registration
 
2407
            if callable(self.default):
 
2408
                value = self.default()
 
2409
                if not isinstance(value, unicode):
 
2410
                    raise AssertionError(
 
2411
                    'Callable default values should be unicode')
 
2412
            else:
 
2413
                value = self.default
 
2414
        return value
 
2415
 
 
2416
    def get_help_text(self, additional_see_also=None, plain=True):
 
2417
        result = self.help
 
2418
        from bzrlib import help_topics
 
2419
        result += help_topics._format_see_also(additional_see_also)
 
2420
        if plain:
 
2421
            result = help_topics.help_as_plain_text(result)
 
2422
        return result
 
2423
 
 
2424
 
 
2425
# Predefined converters to get proper values from store
 
2426
 
 
2427
def bool_from_store(unicode_str):
 
2428
    return ui.bool_from_string(unicode_str)
 
2429
 
 
2430
 
 
2431
def int_from_store(unicode_str):
 
2432
    return int(unicode_str)
 
2433
 
 
2434
 
 
2435
def float_from_store(unicode_str):
 
2436
    return float(unicode_str)
 
2437
 
 
2438
 
 
2439
 
 
2440
# Use a an empty dict to initialize an empty configobj avoiding all
 
2441
# parsing and encoding checks
 
2442
_list_converter_config = configobj.ConfigObj(
 
2443
    {}, encoding='utf-8', list_values=True, interpolation=False)
 
2444
 
 
2445
 
 
2446
def list_from_store(unicode_str):
 
2447
    if not isinstance(unicode_str, basestring):
 
2448
        raise TypeError
 
2449
    # Now inject our string directly as unicode. All callers got their value
 
2450
    # from configobj, so values that need to be quoted are already properly
 
2451
    # quoted.
 
2452
    _list_converter_config.reset()
 
2453
    _list_converter_config._parse([u"list=%s" % (unicode_str,)])
 
2454
    maybe_list = _list_converter_config['list']
 
2455
    # ConfigObj return '' instead of u''. Use 'str' below to catch all cases.
 
2456
    if isinstance(maybe_list, basestring):
 
2457
        if maybe_list:
 
2458
            # A single value, most probably the user forgot (or didn't care to
 
2459
            # add) the final ','
 
2460
            l = [maybe_list]
 
2461
        else:
 
2462
            # The empty string, convert to empty list
 
2463
            l = []
 
2464
    else:
 
2465
        # We rely on ConfigObj providing us with a list already
 
2466
        l = maybe_list
 
2467
    return l
 
2468
 
 
2469
 
 
2470
class OptionRegistry(registry.Registry):
 
2471
    """Register config options by their name.
 
2472
 
 
2473
    This overrides ``registry.Registry`` to simplify registration by acquiring
 
2474
    some information from the option object itself.
 
2475
    """
 
2476
 
 
2477
    def register(self, option):
 
2478
        """Register a new option to its name.
 
2479
 
 
2480
        :param option: The option to register. Its name is used as the key.
 
2481
        """
 
2482
        super(OptionRegistry, self).register(option.name, option,
 
2483
                                             help=option.help)
 
2484
 
 
2485
    def register_lazy(self, key, module_name, member_name):
 
2486
        """Register a new option to be loaded on request.
 
2487
 
 
2488
        :param key: the key to request the option later. Since the registration
 
2489
            is lazy, it should be provided and match the option name.
 
2490
 
 
2491
        :param module_name: the python path to the module. Such as 'os.path'.
 
2492
 
 
2493
        :param member_name: the member of the module to return.  If empty or 
 
2494
                None, get() will return the module itself.
 
2495
        """
 
2496
        super(OptionRegistry, self).register_lazy(key,
 
2497
                                                  module_name, member_name)
 
2498
 
 
2499
    def get_help(self, key=None):
 
2500
        """Get the help text associated with the given key"""
 
2501
        option = self.get(key)
 
2502
        the_help = option.help
 
2503
        if callable(the_help):
 
2504
            return the_help(self, key)
 
2505
        return the_help
 
2506
 
 
2507
 
 
2508
option_registry = OptionRegistry()
 
2509
 
 
2510
 
 
2511
# Registered options in lexicographical order
 
2512
 
 
2513
option_registry.register(
 
2514
    Option('bzr.workingtree.worth_saving_limit', default=10,
 
2515
           from_unicode=int_from_store,  invalid='warning',
 
2516
           help='''\
 
2517
How many changes before saving the dirstate.
 
2518
 
 
2519
-1 means that we will never rewrite the dirstate file for only
 
2520
stat-cache changes. Regardless of this setting, we will always rewrite
 
2521
the dirstate file if a file is added/removed/renamed/etc. This flag only
 
2522
affects the behavior of updating the dirstate file after we notice that
 
2523
a file has been touched.
 
2524
'''))
 
2525
option_registry.register(
 
2526
    Option('dirstate.fdatasync', default=True,
 
2527
           from_unicode=bool_from_store,
 
2528
           help='''\
 
2529
Flush dirstate changes onto physical disk?
 
2530
 
 
2531
If true (default), working tree metadata changes are flushed through the
 
2532
OS buffers to physical disk.  This is somewhat slower, but means data
 
2533
should not be lost if the machine crashes.  See also repository.fdatasync.
 
2534
'''))
 
2535
option_registry.register(
 
2536
    Option('debug_flags', default=[], from_unicode=list_from_store,
 
2537
           help='Debug flags to activate.'))
 
2538
option_registry.register(
 
2539
    Option('default_format', default='2a',
 
2540
           help='Format used when creating branches.'))
 
2541
option_registry.register(
 
2542
    Option('dpush_strict', default=None,
 
2543
           from_unicode=bool_from_store,
 
2544
           help='''\
 
2545
The default value for ``dpush --strict``.
 
2546
 
 
2547
If present, defines the ``--strict`` option default value for checking
 
2548
uncommitted changes before pushing into a different VCS without any
 
2549
custom bzr metadata.
 
2550
'''))
 
2551
option_registry.register(
 
2552
    Option('editor',
 
2553
           help='The command called to launch an editor to enter a message.'))
 
2554
option_registry.register(
 
2555
    Option('ignore_missing_extensions', default=False,
 
2556
           from_unicode=bool_from_store,
 
2557
           help='''\
 
2558
Control the missing extensions warning display.
 
2559
 
 
2560
The warning will not be emitted if set to True.
 
2561
'''))
 
2562
option_registry.register(
 
2563
    Option('language',
 
2564
           help='Language to translate messages into.'))
 
2565
option_registry.register(
 
2566
    Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
 
2567
           help='''\
 
2568
Steal locks that appears to be dead.
 
2569
 
 
2570
If set to True, bzr will check if a lock is supposed to be held by an
 
2571
active process from the same user on the same machine. If the user and
 
2572
machine match, but no process with the given PID is active, then bzr
 
2573
will automatically break the stale lock, and create a new lock for
 
2574
this process.
 
2575
Otherwise, bzr will prompt as normal to break the lock.
 
2576
'''))
 
2577
option_registry.register(
 
2578
    Option('log_format', default='long',
 
2579
           help= '''\
 
2580
Log format to use when displaying revisions.
 
2581
 
 
2582
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
 
2583
may be provided by plugins.
 
2584
'''))
 
2585
option_registry.register(
 
2586
    Option('output_encoding',
 
2587
           help= 'Unicode encoding for output'
 
2588
           ' (terminal encoding if not specified).'))
 
2589
option_registry.register(
 
2590
    Option('push_strict', default=None,
 
2591
           from_unicode=bool_from_store,
 
2592
           help='''\
 
2593
The default value for ``push --strict``.
 
2594
 
 
2595
If present, defines the ``--strict`` option default value for checking
 
2596
uncommitted changes before sending a merge directive.
 
2597
'''))
 
2598
option_registry.register(
 
2599
    Option('repository.fdatasync', default=True,
 
2600
           from_unicode=bool_from_store,
 
2601
           help='''\
 
2602
Flush repository changes onto physical disk?
 
2603
 
 
2604
If true (default), repository changes are flushed through the OS buffers
 
2605
to physical disk.  This is somewhat slower, but means data should not be
 
2606
lost if the machine crashes.  See also dirstate.fdatasync.
 
2607
'''))
 
2608
 
 
2609
option_registry.register(
 
2610
    Option('selftest.timeout',
 
2611
        default='600',
 
2612
        from_unicode=int_from_store,
 
2613
        help='Abort selftest if one test takes longer than this many seconds',
 
2614
        ))
 
2615
 
 
2616
option_registry.register(
 
2617
    Option('send_strict', default=None,
 
2618
           from_unicode=bool_from_store,
 
2619
           help='''\
 
2620
The default value for ``send --strict``.
 
2621
 
 
2622
If present, defines the ``--strict`` option default value for checking
 
2623
uncommitted changes before pushing.
 
2624
'''))
 
2625
 
 
2626
option_registry.register(
 
2627
    Option('serve.client_timeout',
 
2628
           default=300.0, from_unicode=float_from_store,
 
2629
           help="If we wait for a new request from a client for more than"
 
2630
                " X seconds, consider the client idle, and hangup."))
 
2631
 
 
2632
 
 
2633
class Section(object):
 
2634
    """A section defines a dict of option name => value.
 
2635
 
 
2636
    This is merely a read-only dict which can add some knowledge about the
 
2637
    options. It is *not* a python dict object though and doesn't try to mimic
 
2638
    its API.
 
2639
    """
 
2640
 
 
2641
    def __init__(self, section_id, options):
 
2642
        self.id = section_id
 
2643
        # We re-use the dict-like object received
 
2644
        self.options = options
 
2645
 
 
2646
    def get(self, name, default=None, expand=True):
 
2647
        return self.options.get(name, default)
 
2648
 
 
2649
    def iter_option_names(self):
 
2650
        for k in self.options.iterkeys():
 
2651
            yield k
 
2652
 
 
2653
    def __repr__(self):
 
2654
        # Mostly for debugging use
 
2655
        return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
 
2656
 
 
2657
 
 
2658
_NewlyCreatedOption = object()
 
2659
"""Was the option created during the MutableSection lifetime"""
 
2660
 
 
2661
 
 
2662
class MutableSection(Section):
 
2663
    """A section allowing changes and keeping track of the original values."""
 
2664
 
 
2665
    def __init__(self, section_id, options):
 
2666
        super(MutableSection, self).__init__(section_id, options)
 
2667
        self.orig = {}
 
2668
 
 
2669
    def set(self, name, value):
 
2670
        if name not in self.options:
 
2671
            # This is a new option
 
2672
            self.orig[name] = _NewlyCreatedOption
 
2673
        elif name not in self.orig:
 
2674
            self.orig[name] = self.get(name, None)
 
2675
        self.options[name] = value
 
2676
 
 
2677
    def remove(self, name):
 
2678
        if name not in self.orig:
 
2679
            self.orig[name] = self.get(name, None)
 
2680
        del self.options[name]
 
2681
 
 
2682
 
 
2683
class Store(object):
 
2684
    """Abstract interface to persistent storage for configuration options."""
 
2685
 
 
2686
    readonly_section_class = Section
 
2687
    mutable_section_class = MutableSection
 
2688
 
 
2689
    def is_loaded(self):
 
2690
        """Returns True if the Store has been loaded.
 
2691
 
 
2692
        This is used to implement lazy loading and ensure the persistent
 
2693
        storage is queried only when needed.
 
2694
        """
 
2695
        raise NotImplementedError(self.is_loaded)
 
2696
 
 
2697
    def load(self):
 
2698
        """Loads the Store from persistent storage."""
 
2699
        raise NotImplementedError(self.load)
 
2700
 
 
2701
    def _load_from_string(self, bytes):
 
2702
        """Create a store from a string in configobj syntax.
 
2703
 
 
2704
        :param bytes: A string representing the file content.
 
2705
        """
 
2706
        raise NotImplementedError(self._load_from_string)
 
2707
 
 
2708
    def unload(self):
 
2709
        """Unloads the Store.
 
2710
 
 
2711
        This should make is_loaded() return False. This is used when the caller
 
2712
        knows that the persistent storage has changed or may have change since
 
2713
        the last load.
 
2714
        """
 
2715
        raise NotImplementedError(self.unload)
 
2716
 
 
2717
    def save(self):
 
2718
        """Saves the Store to persistent storage."""
 
2719
        raise NotImplementedError(self.save)
 
2720
 
 
2721
    def external_url(self):
 
2722
        raise NotImplementedError(self.external_url)
 
2723
 
 
2724
    def get_sections(self):
 
2725
        """Returns an ordered iterable of existing sections.
 
2726
 
 
2727
        :returns: An iterable of (store, section).
 
2728
        """
 
2729
        raise NotImplementedError(self.get_sections)
 
2730
 
 
2731
    def get_mutable_section(self, section_id=None):
 
2732
        """Returns the specified mutable section.
 
2733
 
 
2734
        :param section_id: The section identifier
 
2735
        """
 
2736
        raise NotImplementedError(self.get_mutable_section)
 
2737
 
 
2738
    def __repr__(self):
 
2739
        # Mostly for debugging use
 
2740
        return "<config.%s(%s)>" % (self.__class__.__name__,
 
2741
                                    self.external_url())
 
2742
 
 
2743
 
 
2744
class CommandLineStore(Store):
 
2745
    "A store to carry command line overrides for the config options."""
 
2746
 
 
2747
    def __init__(self, opts=None):
 
2748
        super(CommandLineStore, self).__init__()
 
2749
        if opts is None:
 
2750
            opts = {}
 
2751
        self.options = {}
 
2752
 
 
2753
    def _reset(self):
 
2754
        # The dict should be cleared but not replaced so it can be shared.
 
2755
        self.options.clear()
 
2756
 
 
2757
    def _from_cmdline(self, overrides):
 
2758
        # Reset before accepting new definitions
 
2759
        self._reset()
 
2760
        for over in overrides:
 
2761
            try:
 
2762
                name, value = over.split('=', 1)
 
2763
            except ValueError:
 
2764
                raise errors.BzrCommandError(
 
2765
                    gettext("Invalid '%s', should be of the form 'name=value'")
 
2766
                    % (over,))
 
2767
            self.options[name] = value
 
2768
 
 
2769
    def external_url(self):
 
2770
        # Not an url but it makes debugging easier and is never needed
 
2771
        # otherwise
 
2772
        return 'cmdline'
 
2773
 
 
2774
    def get_sections(self):
 
2775
        yield self,  self.readonly_section_class('cmdline_overrides',
 
2776
                                                 self.options)
 
2777
 
 
2778
 
 
2779
class IniFileStore(Store):
 
2780
    """A config Store using ConfigObj for storage.
 
2781
 
 
2782
    :ivar transport: The transport object where the config file is located.
 
2783
 
 
2784
    :ivar file_name: The config file basename in the transport directory.
 
2785
 
 
2786
    :ivar _config_obj: Private member to hold the ConfigObj instance used to
 
2787
        serialize/deserialize the config file.
 
2788
    """
 
2789
 
 
2790
    def __init__(self):
 
2791
        """A config Store using ConfigObj for storage.
 
2792
        """
 
2793
        super(IniFileStore, self).__init__()
 
2794
        self._config_obj = None
 
2795
 
 
2796
    def is_loaded(self):
 
2797
        return self._config_obj != None
 
2798
 
 
2799
    def unload(self):
 
2800
        self._config_obj = None
 
2801
 
 
2802
    def _load_content(self):
 
2803
        """Load the config file bytes.
 
2804
 
 
2805
        This should be provided by subclasses
 
2806
 
 
2807
        :return: Byte string
 
2808
        """
 
2809
        raise NotImplementedError(self._load_content)
 
2810
 
 
2811
    def _save_content(self, content):
 
2812
        """Save the config file bytes.
 
2813
 
 
2814
        This should be provided by subclasses
 
2815
 
 
2816
        :param content: Config file bytes to write
 
2817
        """
 
2818
        raise NotImplementedError(self._save_content)
 
2819
 
 
2820
    def load(self):
 
2821
        """Load the store from the associated file."""
 
2822
        if self.is_loaded():
 
2823
            return
 
2824
        content = self._load_content()
 
2825
        self._load_from_string(content)
 
2826
        for hook in ConfigHooks['load']:
 
2827
            hook(self)
 
2828
 
 
2829
    def _load_from_string(self, bytes):
 
2830
        """Create a config store from a string.
 
2831
 
 
2832
        :param bytes: A string representing the file content.
 
2833
        """
 
2834
        if self.is_loaded():
 
2835
            raise AssertionError('Already loaded: %r' % (self._config_obj,))
 
2836
        co_input = StringIO(bytes)
 
2837
        try:
 
2838
            # The config files are always stored utf8-encoded
 
2839
            self._config_obj = ConfigObj(co_input, encoding='utf-8',
 
2840
                                         list_values=False)
 
2841
        except configobj.ConfigObjError, e:
 
2842
            self._config_obj = None
 
2843
            raise errors.ParseConfigError(e.errors, self.external_url())
 
2844
        except UnicodeDecodeError:
 
2845
            raise errors.ConfigContentError(self.external_url())
 
2846
 
 
2847
    def save(self):
 
2848
        if not self.is_loaded():
 
2849
            # Nothing to save
 
2850
            return
 
2851
        out = StringIO()
 
2852
        self._config_obj.write(out)
 
2853
        self._save_content(out.getvalue())
 
2854
        for hook in ConfigHooks['save']:
 
2855
            hook(self)
 
2856
 
 
2857
    def get_sections(self):
 
2858
        """Get the configobj section in the file order.
 
2859
 
 
2860
        :returns: An iterable of (store, section).
 
2861
        """
 
2862
        # We need a loaded store
 
2863
        try:
 
2864
            self.load()
 
2865
        except (errors.NoSuchFile, errors.PermissionDenied):
 
2866
            # If the file can't be read, there is no sections
 
2867
            return
 
2868
        cobj = self._config_obj
 
2869
        if cobj.scalars:
 
2870
            yield self, self.readonly_section_class(None, cobj)
 
2871
        for section_name in cobj.sections:
 
2872
            yield (self,
 
2873
                   self.readonly_section_class(section_name,
 
2874
                                               cobj[section_name]))
 
2875
 
 
2876
    def get_mutable_section(self, section_id=None):
 
2877
        # We need a loaded store
 
2878
        try:
 
2879
            self.load()
 
2880
        except errors.NoSuchFile:
 
2881
            # The file doesn't exist, let's pretend it was empty
 
2882
            self._load_from_string('')
 
2883
        if section_id is None:
 
2884
            section = self._config_obj
 
2885
        else:
 
2886
            section = self._config_obj.setdefault(section_id, {})
 
2887
        return self.mutable_section_class(section_id, section)
 
2888
 
 
2889
 
 
2890
class TransportIniFileStore(IniFileStore):
 
2891
    """IniFileStore that loads files from a transport.
 
2892
    """
 
2893
 
 
2894
    def __init__(self, transport, file_name):
 
2895
        """A Store using a ini file on a Transport
 
2896
 
 
2897
        :param transport: The transport object where the config file is located.
 
2898
        :param file_name: The config file basename in the transport directory.
 
2899
        """
 
2900
        super(TransportIniFileStore, self).__init__()
 
2901
        self.transport = transport
 
2902
        self.file_name = file_name
 
2903
 
 
2904
    def _load_content(self):
 
2905
        try:
 
2906
            return self.transport.get_bytes(self.file_name)
 
2907
        except errors.PermissionDenied:
 
2908
            trace.warning("Permission denied while trying to load "
 
2909
                          "configuration store %s.", self.external_url())
 
2910
            raise
 
2911
 
 
2912
    def _save_content(self, content):
 
2913
        self.transport.put_bytes(self.file_name, content)
 
2914
 
 
2915
    def external_url(self):
 
2916
        # FIXME: external_url should really accepts an optional relpath
 
2917
        # parameter (bug #750169) :-/ -- vila 2011-04-04
 
2918
        # The following will do in the interim but maybe we don't want to
 
2919
        # expose a path here but rather a config ID and its associated
 
2920
        # object </hand wawe>.
 
2921
        return urlutils.join(self.transport.external_url(), self.file_name)
 
2922
 
 
2923
 
 
2924
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
 
2925
# unlockable stores for use with objects that can already ensure the locking
 
2926
# (think branches). If different stores (not based on ConfigObj) are created,
 
2927
# they may face the same issue.
 
2928
 
 
2929
 
 
2930
class LockableIniFileStore(TransportIniFileStore):
 
2931
    """A ConfigObjStore using locks on save to ensure store integrity."""
 
2932
 
 
2933
    def __init__(self, transport, file_name, lock_dir_name=None):
 
2934
        """A config Store using ConfigObj for storage.
 
2935
 
 
2936
        :param transport: The transport object where the config file is located.
 
2937
 
 
2938
        :param file_name: The config file basename in the transport directory.
 
2939
        """
 
2940
        if lock_dir_name is None:
 
2941
            lock_dir_name = 'lock'
 
2942
        self.lock_dir_name = lock_dir_name
 
2943
        super(LockableIniFileStore, self).__init__(transport, file_name)
 
2944
        self._lock = lockdir.LockDir(self.transport, self.lock_dir_name)
 
2945
 
 
2946
    def lock_write(self, token=None):
 
2947
        """Takes a write lock in the directory containing the config file.
 
2948
 
 
2949
        If the directory doesn't exist it is created.
 
2950
        """
 
2951
        # FIXME: This doesn't check the ownership of the created directories as
 
2952
        # ensure_config_dir_exists does. It should if the transport is local
 
2953
        # -- vila 2011-04-06
 
2954
        self.transport.create_prefix()
 
2955
        return self._lock.lock_write(token)
 
2956
 
 
2957
    def unlock(self):
 
2958
        self._lock.unlock()
 
2959
 
 
2960
    def break_lock(self):
 
2961
        self._lock.break_lock()
 
2962
 
 
2963
    @needs_write_lock
 
2964
    def save(self):
 
2965
        # We need to be able to override the undecorated implementation
 
2966
        self.save_without_locking()
 
2967
 
 
2968
    def save_without_locking(self):
 
2969
        super(LockableIniFileStore, self).save()
 
2970
 
 
2971
 
 
2972
# FIXME: global, bazaar, shouldn't that be 'user' instead or even
 
2973
# 'user_defaults' as opposed to 'user_overrides', 'system_defaults'
 
2974
# (/etc/bzr/bazaar.conf) and 'system_overrides' ? -- vila 2011-04-05
 
2975
 
 
2976
# FIXME: Moreover, we shouldn't need classes for these stores either, factory
 
2977
# functions or a registry will make it easier and clearer for tests, focusing
 
2978
# on the relevant parts of the API that needs testing -- vila 20110503 (based
 
2979
# on a poolie's remark)
 
2980
class GlobalStore(LockableIniFileStore):
 
2981
 
 
2982
    def __init__(self, possible_transports=None):
 
2983
        t = transport.get_transport_from_path(
 
2984
            config_dir(), possible_transports=possible_transports)
 
2985
        super(GlobalStore, self).__init__(t, 'bazaar.conf')
 
2986
        self.id = 'bazaar'
 
2987
 
 
2988
 
 
2989
class LocationStore(LockableIniFileStore):
 
2990
 
 
2991
    def __init__(self, possible_transports=None):
 
2992
        t = transport.get_transport_from_path(
 
2993
            config_dir(), possible_transports=possible_transports)
 
2994
        super(LocationStore, self).__init__(t, 'locations.conf')
 
2995
        self.id = 'locations'
 
2996
 
 
2997
 
 
2998
class BranchStore(TransportIniFileStore):
 
2999
 
 
3000
    def __init__(self, branch):
 
3001
        super(BranchStore, self).__init__(branch.control_transport,
 
3002
                                          'branch.conf')
 
3003
        self.branch = branch
 
3004
        self.id = 'branch'
 
3005
 
 
3006
    def lock_write(self, token=None):
 
3007
        return self.branch.lock_write(token)
 
3008
 
 
3009
    def unlock(self):
 
3010
        return self.branch.unlock()
 
3011
 
 
3012
    @needs_write_lock
 
3013
    def save(self):
 
3014
        # We need to be able to override the undecorated implementation
 
3015
        self.save_without_locking()
 
3016
 
 
3017
    def save_without_locking(self):
 
3018
        super(BranchStore, self).save()
 
3019
 
 
3020
 
 
3021
class ControlStore(LockableIniFileStore):
 
3022
 
 
3023
    def __init__(self, bzrdir):
 
3024
        super(ControlStore, self).__init__(bzrdir.transport,
 
3025
                                          'control.conf',
 
3026
                                           lock_dir_name='branch_lock')
 
3027
 
 
3028
 
 
3029
class SectionMatcher(object):
 
3030
    """Select sections into a given Store.
 
3031
 
 
3032
    This is intended to be used to postpone getting an iterable of sections
 
3033
    from a store.
 
3034
    """
 
3035
 
 
3036
    def __init__(self, store):
 
3037
        self.store = store
 
3038
 
 
3039
    def get_sections(self):
 
3040
        # This is where we require loading the store so we can see all defined
 
3041
        # sections.
 
3042
        sections = self.store.get_sections()
 
3043
        # Walk the revisions in the order provided
 
3044
        for store, s in sections:
 
3045
            if self.match(s):
 
3046
                yield store, s
 
3047
 
 
3048
    def match(self, section):
 
3049
        """Does the proposed section match.
 
3050
 
 
3051
        :param section: A Section object.
 
3052
 
 
3053
        :returns: True if the section matches, False otherwise.
 
3054
        """
 
3055
        raise NotImplementedError(self.match)
 
3056
 
 
3057
 
 
3058
class NameMatcher(SectionMatcher):
 
3059
 
 
3060
    def __init__(self, store, section_id):
 
3061
        super(NameMatcher, self).__init__(store)
 
3062
        self.section_id = section_id
 
3063
 
 
3064
    def match(self, section):
 
3065
        return section.id == self.section_id
 
3066
 
 
3067
 
 
3068
class LocationSection(Section):
 
3069
 
 
3070
    def __init__(self, section, length, extra_path):
 
3071
        super(LocationSection, self).__init__(section.id, section.options)
 
3072
        self.length = length
 
3073
        self.extra_path = extra_path
 
3074
        self.locals = {'relpath': extra_path,
 
3075
                       'basename': urlutils.basename(extra_path)}
 
3076
 
 
3077
    def get(self, name, default=None, expand=True):
 
3078
        value = super(LocationSection, self).get(name, default)
 
3079
        if value is not None and expand:
 
3080
            policy_name = self.get(name + ':policy', None)
 
3081
            policy = _policy_value.get(policy_name, POLICY_NONE)
 
3082
            if policy == POLICY_APPENDPATH:
 
3083
                value = urlutils.join(value, self.extra_path)
 
3084
            # expand section local options right now (since POLICY_APPENDPATH
 
3085
            # will never add options references, it's ok to expand after it).
 
3086
            chunks = []
 
3087
            for is_ref, chunk in iter_option_refs(value):
 
3088
                if not is_ref:
 
3089
                    chunks.append(chunk)
 
3090
                else:
 
3091
                    ref = chunk[1:-1]
 
3092
                    if ref in self.locals:
 
3093
                        chunks.append(self.locals[ref])
 
3094
                    else:
 
3095
                        chunks.append(chunk)
 
3096
            value = ''.join(chunks)
 
3097
        return value
 
3098
 
 
3099
 
 
3100
class LocationMatcher(SectionMatcher):
 
3101
 
 
3102
    def __init__(self, store, location):
 
3103
        super(LocationMatcher, self).__init__(store)
 
3104
        if location.startswith('file://'):
 
3105
            location = urlutils.local_path_from_url(location)
 
3106
        self.location = location
 
3107
 
 
3108
    def _get_matching_sections(self):
 
3109
        """Get all sections matching ``location``."""
 
3110
        # We slightly diverge from LocalConfig here by allowing the no-name
 
3111
        # section as the most generic one and the lower priority.
 
3112
        no_name_section = None
 
3113
        all_sections = []
 
3114
        # Filter out the no_name_section so _iter_for_location_by_parts can be
 
3115
        # used (it assumes all sections have a name).
 
3116
        for _, section in self.store.get_sections():
 
3117
            if section.id is None:
 
3118
                no_name_section = section
 
3119
            else:
 
3120
                all_sections.append(section)
 
3121
        # Unfortunately _iter_for_location_by_parts deals with section names so
 
3122
        # we have to resync.
 
3123
        filtered_sections = _iter_for_location_by_parts(
 
3124
            [s.id for s in all_sections], self.location)
 
3125
        iter_all_sections = iter(all_sections)
 
3126
        matching_sections = []
 
3127
        if no_name_section is not None:
 
3128
            matching_sections.append(
 
3129
                LocationSection(no_name_section, 0, self.location))
 
3130
        for section_id, extra_path, length in filtered_sections:
 
3131
            # a section id is unique for a given store so it's safe to take the
 
3132
            # first matching section while iterating. Also, all filtered
 
3133
            # sections are part of 'all_sections' and will always be found
 
3134
            # there.
 
3135
            while True:
 
3136
                section = iter_all_sections.next()
 
3137
                if section_id == section.id:
 
3138
                    matching_sections.append(
 
3139
                        LocationSection(section, length, extra_path))
 
3140
                    break
 
3141
        return matching_sections
 
3142
 
 
3143
    def get_sections(self):
 
3144
        # Override the default implementation as we want to change the order
 
3145
        matching_sections = self._get_matching_sections()
 
3146
        # We want the longest (aka more specific) locations first
 
3147
        sections = sorted(matching_sections,
 
3148
                          key=lambda section: (section.length, section.id),
 
3149
                          reverse=True)
 
3150
        # Sections mentioning 'ignore_parents' restrict the selection
 
3151
        for section in sections:
 
3152
            # FIXME: We really want to use as_bool below -- vila 2011-04-07
 
3153
            ignore = section.get('ignore_parents', None)
 
3154
            if ignore is not None:
 
3155
                ignore = ui.bool_from_string(ignore)
 
3156
            if ignore:
 
3157
                break
 
3158
            # Finally, we have a valid section
 
3159
            yield self.store, section
 
3160
 
 
3161
 
 
3162
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
 
3163
"""Describes an expandable option reference.
 
3164
 
 
3165
We want to match the most embedded reference first.
 
3166
 
 
3167
I.e. for '{{foo}}' we will get '{foo}',
 
3168
for '{bar{baz}}' we will get '{baz}'
 
3169
"""
 
3170
 
 
3171
def iter_option_refs(string):
 
3172
    # Split isolate refs so every other chunk is a ref
 
3173
    is_ref = False
 
3174
    for chunk  in _option_ref_re.split(string):
 
3175
        yield is_ref, chunk
 
3176
        is_ref = not is_ref
 
3177
 
 
3178
 
 
3179
class Stack(object):
 
3180
    """A stack of configurations where an option can be defined"""
 
3181
 
 
3182
    def __init__(self, sections_def, store=None, mutable_section_id=None):
 
3183
        """Creates a stack of sections with an optional store for changes.
 
3184
 
 
3185
        :param sections_def: A list of Section or callables that returns an
 
3186
            iterable of Section. This defines the Sections for the Stack and
 
3187
            can be called repeatedly if needed.
 
3188
 
 
3189
        :param store: The optional Store where modifications will be
 
3190
            recorded. If none is specified, no modifications can be done.
 
3191
 
 
3192
        :param mutable_section_id: The id of the MutableSection where changes
 
3193
            are recorded. This requires the ``store`` parameter to be
 
3194
            specified.
 
3195
        """
 
3196
        self.sections_def = sections_def
 
3197
        self.store = store
 
3198
        self.mutable_section_id = mutable_section_id
 
3199
 
 
3200
    def get(self, name, expand=None):
 
3201
        """Return the *first* option value found in the sections.
 
3202
 
 
3203
        This is where we guarantee that sections coming from Store are loaded
 
3204
        lazily: the loading is delayed until we need to either check that an
 
3205
        option exists or get its value, which in turn may require to discover
 
3206
        in which sections it can be defined. Both of these (section and option
 
3207
        existence) require loading the store (even partially).
 
3208
 
 
3209
        :param name: The queried option.
 
3210
 
 
3211
        :param expand: Whether options references should be expanded.
 
3212
 
 
3213
        :returns: The value of the option.
 
3214
        """
 
3215
        # FIXME: No caching of options nor sections yet -- vila 20110503
 
3216
        if expand is None:
 
3217
            expand = _get_expand_default_value()
 
3218
        value = None
 
3219
        # Ensuring lazy loading is achieved by delaying section matching (which
 
3220
        # implies querying the persistent storage) until it can't be avoided
 
3221
        # anymore by using callables to describe (possibly empty) section
 
3222
        # lists.
 
3223
        for sections in self.sections_def:
 
3224
            for store, section in sections():
 
3225
                value = section.get(name)
 
3226
                if value is not None:
 
3227
                    break
 
3228
            if value is not None:
 
3229
                break
 
3230
        # If the option is registered, it may provide additional info about
 
3231
        # value handling
 
3232
        try:
 
3233
            opt = option_registry.get(name)
 
3234
        except KeyError:
 
3235
            # Not registered
 
3236
            opt = None
 
3237
        def expand_and_convert(val):
 
3238
            # This may need to be called twice if the value is None or ends up
 
3239
            # being None during expansion or conversion.
 
3240
            if val is not None:
 
3241
                if expand:
 
3242
                    if isinstance(val, basestring):
 
3243
                        val = self._expand_options_in_string(val)
 
3244
                    else:
 
3245
                        trace.warning('Cannot expand "%s":'
 
3246
                                      ' %s does not support option expansion'
 
3247
                                      % (name, type(val)))
 
3248
                if opt is not None:
 
3249
                    val = opt.convert_from_unicode(val)
 
3250
            return val
 
3251
        value = expand_and_convert(value)
 
3252
        if opt is not None and value is None:
 
3253
            # If the option is registered, it may provide a default value
 
3254
            value = opt.get_default()
 
3255
            value = expand_and_convert(value)
 
3256
        for hook in ConfigHooks['get']:
 
3257
            hook(self, name, value)
 
3258
        return value
 
3259
 
 
3260
    def expand_options(self, string, env=None):
 
3261
        """Expand option references in the string in the configuration context.
 
3262
 
 
3263
        :param string: The string containing option(s) to expand.
 
3264
 
 
3265
        :param env: An option dict defining additional configuration options or
 
3266
            overriding existing ones.
 
3267
 
 
3268
        :returns: The expanded string.
 
3269
        """
 
3270
        return self._expand_options_in_string(string, env)
 
3271
 
 
3272
    def _expand_options_in_string(self, string, env=None, _refs=None):
 
3273
        """Expand options in the string in the configuration context.
 
3274
 
 
3275
        :param string: The string to be expanded.
 
3276
 
 
3277
        :param env: An option dict defining additional configuration options or
 
3278
            overriding existing ones.
 
3279
 
 
3280
        :param _refs: Private list (FIFO) containing the options being expanded
 
3281
            to detect loops.
 
3282
 
 
3283
        :returns: The expanded string.
 
3284
        """
 
3285
        if string is None:
 
3286
            # Not much to expand there
 
3287
            return None
 
3288
        if _refs is None:
 
3289
            # What references are currently resolved (to detect loops)
 
3290
            _refs = []
 
3291
        result = string
 
3292
        # We need to iterate until no more refs appear ({{foo}} will need two
 
3293
        # iterations for example).
 
3294
        expanded = True
 
3295
        while expanded:
 
3296
            expanded = False
 
3297
            chunks = []
 
3298
            for is_ref, chunk in iter_option_refs(result):
 
3299
                if not is_ref:
 
3300
                    chunks.append(chunk)
 
3301
                else:
 
3302
                    expanded = True
 
3303
                    name = chunk[1:-1]
 
3304
                    if name in _refs:
 
3305
                        raise errors.OptionExpansionLoop(string, _refs)
 
3306
                    _refs.append(name)
 
3307
                    value = self._expand_option(name, env, _refs)
 
3308
                    if value is None:
 
3309
                        raise errors.ExpandingUnknownOption(name, string)
 
3310
                    chunks.append(value)
 
3311
                    _refs.pop()
 
3312
            result = ''.join(chunks)
 
3313
        return result
 
3314
 
 
3315
    def _expand_option(self, name, env, _refs):
 
3316
        if env is not None and name in env:
 
3317
            # Special case, values provided in env takes precedence over
 
3318
            # anything else
 
3319
            value = env[name]
 
3320
        else:
 
3321
            value = self.get(name, expand=False)
 
3322
            value = self._expand_options_in_string(value, env, _refs)
 
3323
        return value
 
3324
 
 
3325
    def _get_mutable_section(self):
 
3326
        """Get the MutableSection for the Stack.
 
3327
 
 
3328
        This is where we guarantee that the mutable section is lazily loaded:
 
3329
        this means we won't load the corresponding store before setting a value
 
3330
        or deleting an option. In practice the store will often be loaded but
 
3331
        this helps catching some programming errors.
 
3332
        """
 
3333
        section = self.store.get_mutable_section(self.mutable_section_id)
 
3334
        return section
 
3335
 
 
3336
    def set(self, name, value):
 
3337
        """Set a new value for the option."""
 
3338
        section = self._get_mutable_section()
 
3339
        section.set(name, value)
 
3340
        for hook in ConfigHooks['set']:
 
3341
            hook(self, name, value)
 
3342
 
 
3343
    def remove(self, name):
 
3344
        """Remove an existing option."""
 
3345
        section = self._get_mutable_section()
 
3346
        section.remove(name)
 
3347
        for hook in ConfigHooks['remove']:
 
3348
            hook(self, name)
 
3349
 
 
3350
    def __repr__(self):
 
3351
        # Mostly for debugging use
 
3352
        return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
 
3353
 
 
3354
    def _get_overrides(self):
 
3355
        # Hack around library_state.initialize never called
 
3356
        if bzrlib.global_state is not None:
 
3357
            return bzrlib.global_state.cmdline_overrides.get_sections()
 
3358
        return []
 
3359
 
 
3360
 
 
3361
class _CompatibleStack(Stack):
 
3362
    """Place holder for compatibility with previous design.
 
3363
 
 
3364
    This is intended to ease the transition from the Config-based design to the
 
3365
    Stack-based design and should not be used nor relied upon by plugins.
 
3366
 
 
3367
    One assumption made here is that the daughter classes will all use Stores
 
3368
    derived from LockableIniFileStore).
 
3369
 
 
3370
    It implements set() and remove () by re-loading the store before applying
 
3371
    the modification and saving it.
 
3372
 
 
3373
    The long term plan being to implement a single write by store to save
 
3374
    all modifications, this class should not be used in the interim.
 
3375
    """
 
3376
 
 
3377
    def set(self, name, value):
 
3378
        # Force a reload
 
3379
        self.store.unload()
 
3380
        super(_CompatibleStack, self).set(name, value)
 
3381
        # Force a write to persistent storage
 
3382
        self.store.save()
 
3383
 
 
3384
    def remove(self, name):
 
3385
        # Force a reload
 
3386
        self.store.unload()
 
3387
        super(_CompatibleStack, self).remove(name)
 
3388
        # Force a write to persistent storage
 
3389
        self.store.save()
 
3390
 
 
3391
 
 
3392
class GlobalStack(_CompatibleStack):
 
3393
    """Global options only stack."""
 
3394
 
 
3395
    def __init__(self):
 
3396
        # Get a GlobalStore
 
3397
        gstore = GlobalStore()
 
3398
        super(GlobalStack, self).__init__(
 
3399
            [self._get_overrides, NameMatcher(gstore, 'DEFAULT').get_sections],
 
3400
            gstore, mutable_section_id='DEFAULT')
 
3401
 
 
3402
 
 
3403
class LocationStack(_CompatibleStack):
 
3404
    """Per-location options falling back to global options stack."""
 
3405
 
 
3406
    def __init__(self, location):
 
3407
        """Make a new stack for a location and global configuration.
 
3408
        
 
3409
        :param location: A URL prefix to """
 
3410
        lstore = LocationStore()
 
3411
        if location.startswith('file://'):
 
3412
            location = urlutils.local_path_from_url(location)
 
3413
        matcher = LocationMatcher(lstore, location)
 
3414
        gstore = GlobalStore()
 
3415
        super(LocationStack, self).__init__(
 
3416
            [self._get_overrides,
 
3417
             matcher.get_sections, NameMatcher(gstore, 'DEFAULT').get_sections],
 
3418
            lstore, mutable_section_id=location)
 
3419
 
 
3420
 
 
3421
class BranchStack(_CompatibleStack):
 
3422
    """Per-location options falling back to branch then global options stack."""
 
3423
 
 
3424
    def __init__(self, branch):
 
3425
        bstore = branch._get_config_store()
 
3426
        lstore = LocationStore()
 
3427
        matcher = LocationMatcher(lstore, branch.base)
 
3428
        gstore = GlobalStore()
 
3429
        super(BranchStack, self).__init__(
 
3430
            [self._get_overrides,
 
3431
             matcher.get_sections, bstore.get_sections,
 
3432
             NameMatcher(gstore, 'DEFAULT').get_sections],
 
3433
            bstore)
 
3434
        self.branch = branch
 
3435
 
 
3436
 
 
3437
class RemoteControlStack(_CompatibleStack):
 
3438
    """Remote control-only options stack."""
 
3439
 
 
3440
    # FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
 
3441
    # with the stack used for remote bzr dirs. RemoteControlStack only uses
 
3442
    # control.conf and is used only for stack options.
 
3443
 
 
3444
    def __init__(self, bzrdir):
 
3445
        cstore = bzrdir._get_config_store()
 
3446
        super(RemoteControlStack, self).__init__(
 
3447
            [cstore.get_sections],
 
3448
            cstore)
 
3449
        self.bzrdir = bzrdir
 
3450
 
 
3451
 
 
3452
class RemoteBranchStack(_CompatibleStack):
 
3453
    """Remote branch-only options stack."""
 
3454
 
 
3455
    # FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
 
3456
    # with the stack used for remote branches. RemoteBranchStack only uses
 
3457
    # branch.conf and is used only for the stack options.
 
3458
 
 
3459
    def __init__(self, branch):
 
3460
        bstore = branch._get_config_store()
 
3461
        super(RemoteBranchStack, self).__init__(
 
3462
            [bstore.get_sections],
 
3463
            bstore)
 
3464
        self.branch = branch
 
3465
 
 
3466
# Use a an empty dict to initialize an empty configobj avoiding all
 
3467
# parsing and encoding checks
 
3468
_quoting_config = configobj.ConfigObj(
 
3469
    {}, encoding='utf-8', interpolation=False)
 
3470
 
 
3471
class cmd_config(commands.Command):
 
3472
    __doc__ = """Display, set or remove a configuration option.
 
3473
 
 
3474
    Display the active value for a given option.
 
3475
 
 
3476
    If --all is specified, NAME is interpreted as a regular expression and all
 
3477
    matching options are displayed mentioning their scope. The active value
 
3478
    that bzr will take into account is the first one displayed for each option.
 
3479
 
 
3480
    If no NAME is given, --all .* is implied.
 
3481
 
 
3482
    Setting a value is achieved by using name=value without spaces. The value
 
3483
    is set in the most relevant scope and can be checked by displaying the
 
3484
    option again.
 
3485
    """
 
3486
 
 
3487
    takes_args = ['name?']
 
3488
 
 
3489
    takes_options = [
 
3490
        'directory',
 
3491
        # FIXME: This should be a registry option so that plugins can register
 
3492
        # their own config files (or not) and will also address
 
3493
        # http://pad.lv/788991 -- vila 20101115
 
3494
        commands.Option('scope', help='Reduce the scope to the specified'
 
3495
                        ' configuration file.',
 
3496
                        type=unicode),
 
3497
        commands.Option('all',
 
3498
            help='Display all the defined values for the matching options.',
 
3499
            ),
 
3500
        commands.Option('remove', help='Remove the option from'
 
3501
                        ' the configuration file.'),
 
3502
        ]
 
3503
 
 
3504
    _see_also = ['configuration']
 
3505
 
 
3506
    @commands.display_command
 
3507
    def run(self, name=None, all=False, directory=None, scope=None,
 
3508
            remove=False):
 
3509
        if directory is None:
 
3510
            directory = '.'
 
3511
        directory = urlutils.normalize_url(directory)
 
3512
        if remove and all:
 
3513
            raise errors.BzrError(
 
3514
                '--all and --remove are mutually exclusive.')
 
3515
        elif remove:
 
3516
            # Delete the option in the given scope
 
3517
            self._remove_config_option(name, directory, scope)
 
3518
        elif name is None:
 
3519
            # Defaults to all options
 
3520
            self._show_matching_options('.*', directory, scope)
 
3521
        else:
 
3522
            try:
 
3523
                name, value = name.split('=', 1)
 
3524
            except ValueError:
 
3525
                # Display the option(s) value(s)
 
3526
                if all:
 
3527
                    self._show_matching_options(name, directory, scope)
 
3528
                else:
 
3529
                    self._show_value(name, directory, scope)
 
3530
            else:
 
3531
                if all:
 
3532
                    raise errors.BzrError(
 
3533
                        'Only one option can be set.')
 
3534
                # Set the option value
 
3535
                self._set_config_option(name, value, directory, scope)
 
3536
 
 
3537
    def _get_stack(self, directory, scope=None):
 
3538
        """Get the configuration stack specified by ``directory`` and ``scope``.
 
3539
 
 
3540
        :param directory: Where the configurations are derived from.
 
3541
 
 
3542
        :param scope: A specific config to start from.
 
3543
        """
 
3544
        # FIXME: scope should allow access to plugin-specific stacks (even
 
3545
        # reduced to the plugin-specific store), related to
 
3546
        # http://pad.lv/788991 -- vila 2011-11-15
 
3547
        if scope is not None:
 
3548
            if scope == 'bazaar':
 
3549
                return GlobalStack()
 
3550
            elif scope == 'locations':
 
3551
                return LocationStack(directory)
 
3552
            elif scope == 'branch':
 
3553
                (_, br, _) = (
 
3554
                    controldir.ControlDir.open_containing_tree_or_branch(
 
3555
                        directory))
 
3556
                return br.get_config_stack()
 
3557
            raise errors.NoSuchConfig(scope)
 
3558
        else:
 
3559
            try:
 
3560
                (_, br, _) = (
 
3561
                    controldir.ControlDir.open_containing_tree_or_branch(
 
3562
                        directory))
 
3563
                return br.get_config_stack()
 
3564
            except errors.NotBranchError:
 
3565
                return LocationStack(directory)
 
3566
 
 
3567
    def _show_value(self, name, directory, scope):
 
3568
        conf = self._get_stack(directory, scope)
 
3569
        value = conf.get(name, expand=True)
 
3570
        if value is not None:
 
3571
            # Quote the value appropriately
 
3572
            value = _quoting_config._quote(value)
 
3573
            self.outf.write('%s\n' % (value,))
 
3574
        else:
 
3575
            raise errors.NoSuchConfigOption(name)
 
3576
 
 
3577
    def _show_matching_options(self, name, directory, scope):
 
3578
        name = lazy_regex.lazy_compile(name)
 
3579
        # We want any error in the regexp to be raised *now* so we need to
 
3580
        # avoid the delay introduced by the lazy regexp.  But, we still do
 
3581
        # want the nicer errors raised by lazy_regex.
 
3582
        name._compile_and_collapse()
 
3583
        cur_store_id = None
 
3584
        cur_section = None
 
3585
        conf = self._get_stack(directory, scope)
 
3586
        for sections in conf.sections_def:
 
3587
            for store, section in sections():
 
3588
                for oname in section.iter_option_names():
 
3589
                    if name.search(oname):
 
3590
                        if cur_store_id != store.id:
 
3591
                            # Explain where the options are defined
 
3592
                            self.outf.write('%s:\n' % (store.id,))
 
3593
                            cur_store_id = store.id
 
3594
                            cur_section = None
 
3595
                        if (section.id not in (None, 'DEFAULT')
 
3596
                            and cur_section != section.id):
 
3597
                            # Display the section if it's not the default (or
 
3598
                            # only) one.
 
3599
                            self.outf.write('  [%s]\n' % (section.id,))
 
3600
                            cur_section = section.id
 
3601
                        value = section.get(oname, expand=False)
 
3602
                        value = _quoting_config._quote(value)
 
3603
                        self.outf.write('  %s = %s\n' % (oname, value))
 
3604
 
 
3605
    def _set_config_option(self, name, value, directory, scope):
 
3606
        conf = self._get_stack(directory, scope)
 
3607
        conf.set(name, value)
 
3608
 
 
3609
    def _remove_config_option(self, name, directory, scope):
 
3610
        if name is None:
 
3611
            raise errors.BzrCommandError(
 
3612
                '--remove expects an option to remove.')
 
3613
        conf = self._get_stack(directory, scope)
 
3614
        try:
 
3615
            conf.remove(name)
 
3616
        except KeyError:
 
3617
            raise errors.NoSuchConfigOption(name)
 
3618
 
 
3619
 
 
3620
# Test registries
 
3621
#
 
3622
# We need adapters that can build a Store or a Stack in a test context. Test
 
3623
# classes, based on TestCaseWithTransport, can use the registry to parametrize
 
3624
# themselves. The builder will receive a test instance and should return a
 
3625
# ready-to-use store or stack.  Plugins that define new store/stacks can also
 
3626
# register themselves here to be tested against the tests defined in
 
3627
# bzrlib.tests.test_config. Note that the builder can be called multiple times
 
3628
# for the same test.
 
3629
 
 
3630
# The registered object should be a callable receiving a test instance
 
3631
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store
 
3632
# object.
 
3633
test_store_builder_registry = registry.Registry()
 
3634
 
 
3635
# The registered object should be a callable receiving a test instance
 
3636
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Stack
 
3637
# object.
 
3638
test_stack_builder_registry = registry.Registry()