← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Jelmer Vernooij
  • Date: 2012-02-20 12:19:29 UTC
  • mfrom: (6437.23.11 2.5)
  • mto: (6581.1.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 6582.
  • Revision ID: jelmer@samba.org-20120220121929-7ni2psvjoatm1yp4
Merge bzr/2.5.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
1
 
# Copyright (C) 2005-2011 Canonical Ltd
 
1
# Copyright (C) 2005-2012 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#            and others
4
4
#
72
72
up=pull
73
73
"""
74
74
 
 
75
from __future__ import absolute_import
 
76
from cStringIO import StringIO
75
77
import os
76
 
import string
77
78
import sys
78
 
import re
79
 
 
80
 
 
 
79
 
 
80
import bzrlib
81
81
from bzrlib.decorators import needs_write_lock
82
82
from bzrlib.lazy_import import lazy_import
83
83
lazy_import(globals(), """
84
84
import fnmatch
85
85
import re
86
 
from cStringIO import StringIO
87
86
 
88
87
from bzrlib import (
89
88
    atomicfile,
90
 
    bzrdir,
 
89
    controldir,
91
90
    debug,
92
91
    errors,
93
92
    lazy_regex,
 
93
    library_state,
94
94
    lockdir,
95
95
    mail_client,
96
96
    mergetools,
102
102
    urlutils,
103
103
    win32utils,
104
104
    )
 
105
from bzrlib.i18n import gettext
105
106
from bzrlib.util.configobj import configobj
106
107
""")
107
108
from bzrlib import (
108
109
    commands,
109
110
    hooks,
 
111
    lazy_regex,
110
112
    registry,
111
113
    )
112
114
from bzrlib.symbol_versioning import (
149
151
STORE_GLOBAL = 4
150
152
 
151
153
 
 
154
def signature_policy_from_unicode(signature_string):
 
155
    """Convert a string to a signing policy."""
 
156
    if signature_string.lower() == 'check-available':
 
157
        return CHECK_IF_POSSIBLE
 
158
    if signature_string.lower() == 'ignore':
 
159
        return CHECK_NEVER
 
160
    if signature_string.lower() == 'require':
 
161
        return CHECK_ALWAYS
 
162
    raise ValueError("Invalid signatures policy '%s'"
 
163
                     % signature_string)
 
164
 
 
165
 
 
166
def signing_policy_from_unicode(signature_string):
 
167
    """Convert a string to a signing policy."""
 
168
    if signature_string.lower() == 'when-required':
 
169
        return SIGN_WHEN_REQUIRED
 
170
    if signature_string.lower() == 'never':
 
171
        return SIGN_NEVER
 
172
    if signature_string.lower() == 'always':
 
173
        return SIGN_ALWAYS
 
174
    raise ValueError("Invalid signing policy '%s'"
 
175
                     % signature_string)
 
176
 
 
177
 
152
178
class ConfigObj(configobj.ConfigObj):
153
179
 
154
180
    def __init__(self, infile=None, **kwargs):
414
440
            # add) the final ','
415
441
            l = [l]
416
442
        return l
417
 
        
418
 
    def get_user_option_as_int_from_SI(self,  option_name,  default=None):
 
443
 
 
444
    @deprecated_method(deprecated_in((2, 5, 0)))
 
445
    def get_user_option_as_int_from_SI(self, option_name, default=None):
419
446
        """Get a generic option from a human readable size in SI units, e.g 10MB
420
 
        
 
447
 
421
448
        Accepted suffixes are K,M,G. It is case-insensitive and may be followed
422
449
        by a trailing b (i.e. Kb, MB). This is intended to be practical and not
423
450
        pedantic.
424
 
        
 
451
 
425
452
        :return Integer, expanded to its base-10 value if a proper SI unit is 
426
453
            found. If the option doesn't exist, or isn't a value in 
427
454
            SI units, return default (which defaults to None)
445
472
                        elif m.group(2).lower() == 'g':
446
473
                            val *= 10**9
447
474
                else:
448
 
                    ui.ui_factory.show_warning('Invalid config value for "%s" '
449
 
                                               ' value %r is not an SI unit.'
450
 
                                                % (option_name, val))
 
475
                    ui.ui_factory.show_warning(gettext('Invalid config value for "{0}" '
 
476
                                               ' value {1!r} is not an SI unit.').format(
 
477
                                                option_name, val))
451
478
                    val = default
452
479
            except TypeError:
453
480
                val = default
454
481
        return val
455
 
        
456
482
 
 
483
    @deprecated_method(deprecated_in((2, 5, 0)))
457
484
    def gpg_signing_command(self):
458
485
        """What program should be used to sign signatures?"""
459
486
        result = self._gpg_signing_command()
465
492
        """See gpg_signing_command()."""
466
493
        return None
467
494
 
 
495
    @deprecated_method(deprecated_in((2, 5, 0)))
468
496
    def log_format(self):
469
497
        """What log format should be used"""
470
498
        result = self._log_format()
489
517
        """See validate_signatures_in_log()."""
490
518
        return None
491
519
 
 
520
    @deprecated_method(deprecated_in((2, 5, 0)))
492
521
    def acceptable_keys(self):
493
522
        """Comma separated list of key patterns acceptable to 
494
523
        verify-signatures command"""
499
528
        """See acceptable_keys()."""
500
529
        return None
501
530
 
 
531
    @deprecated_method(deprecated_in((2, 5, 0)))
502
532
    def post_commit(self):
503
533
        """An ordered list of python functions to call.
504
534
 
530
560
        v = self._get_user_id()
531
561
        if v:
532
562
            return v
533
 
        v = os.environ.get('EMAIL')
534
 
        if v:
535
 
            return v.decode(osutils.get_user_encoding())
536
 
        name, email = _auto_user_id()
537
 
        if name and email:
538
 
            return '%s <%s>' % (name, email)
539
 
        elif email:
540
 
            return email
541
 
        raise errors.NoWhoami()
 
563
        return default_email()
542
564
 
543
565
    def ensure_username(self):
544
566
        """Raise errors.NoWhoami if username is not set.
547
569
        """
548
570
        self.username()
549
571
 
 
572
    @deprecated_method(deprecated_in((2, 5, 0)))
550
573
    def signature_checking(self):
551
574
        """What is the current policy for signature checking?."""
552
575
        policy = self._get_signature_checking()
554
577
            return policy
555
578
        return CHECK_IF_POSSIBLE
556
579
 
 
580
    @deprecated_method(deprecated_in((2, 5, 0)))
557
581
    def signing_policy(self):
558
582
        """What is the current policy for signature checking?."""
559
583
        policy = self._get_signing_policy()
561
585
            return policy
562
586
        return SIGN_WHEN_REQUIRED
563
587
 
 
588
    @deprecated_method(deprecated_in((2, 5, 0)))
564
589
    def signature_needed(self):
565
590
        """Is a signature needed when committing ?."""
566
591
        policy = self._get_signing_policy()
575
600
            return True
576
601
        return False
577
602
 
 
603
    @deprecated_method(deprecated_in((2, 5, 0)))
578
604
    def gpg_signing_key(self):
579
605
        """GPG user-id to sign commits"""
580
606
        key = self.get_user_option('gpg_signing_key')
622
648
        for (oname, value, section, conf_id, parser) in self._get_options():
623
649
            if oname.startswith('bzr.mergetool.'):
624
650
                tool_name = oname[len('bzr.mergetool.'):]
625
 
                tools[tool_name] = value
 
651
                tools[tool_name] = self.get_user_option(oname)
626
652
        trace.mutter('loaded merge tools: %r' % tools)
627
653
        return tools
628
654
 
865
891
        """See Config._get_signature_checking."""
866
892
        policy = self._get_user_option('check_signatures')
867
893
        if policy:
868
 
            return self._string_to_signature_policy(policy)
 
894
            return signature_policy_from_unicode(policy)
869
895
 
870
896
    def _get_signing_policy(self):
871
897
        """See Config._get_signing_policy"""
872
898
        policy = self._get_user_option('create_signatures')
873
899
        if policy:
874
 
            return self._string_to_signing_policy(policy)
 
900
            return signing_policy_from_unicode(policy)
875
901
 
876
902
    def _get_user_id(self):
877
903
        """Get the user id from the 'email' key in the current section."""
922
948
        """See Config.post_commit."""
923
949
        return self._get_user_option('post_commit')
924
950
 
925
 
    def _string_to_signature_policy(self, signature_string):
926
 
        """Convert a string to a signing policy."""
927
 
        if signature_string.lower() == 'check-available':
928
 
            return CHECK_IF_POSSIBLE
929
 
        if signature_string.lower() == 'ignore':
930
 
            return CHECK_NEVER
931
 
        if signature_string.lower() == 'require':
932
 
            return CHECK_ALWAYS
933
 
        raise errors.BzrError("Invalid signatures policy '%s'"
934
 
                              % signature_string)
935
 
 
936
 
    def _string_to_signing_policy(self, signature_string):
937
 
        """Convert a string to a signing policy."""
938
 
        if signature_string.lower() == 'when-required':
939
 
            return SIGN_WHEN_REQUIRED
940
 
        if signature_string.lower() == 'never':
941
 
            return SIGN_NEVER
942
 
        if signature_string.lower() == 'always':
943
 
            return SIGN_ALWAYS
944
 
        raise errors.BzrError("Invalid signing policy '%s'"
945
 
                              % signature_string)
946
 
 
947
951
    def _get_alias(self, value):
948
952
        try:
949
953
            return self._get_parser().get_value("ALIASES",
1393
1397
        e.g. "John Hacker <jhacker@example.com>"
1394
1398
        This is looked up in the email controlfile for the branch.
1395
1399
        """
1396
 
        try:
1397
 
            return (self.branch._transport.get_bytes("email")
1398
 
                    .decode(osutils.get_user_encoding())
1399
 
                    .rstrip("\r\n"))
1400
 
        except errors.NoSuchFile, e:
1401
 
            pass
1402
 
 
1403
1400
        return self._get_best_value('_get_user_id')
1404
1401
 
1405
1402
    def _get_change_editor(self):
1485
1482
        value = self._get_explicit_nickname()
1486
1483
        if value is not None:
1487
1484
            return value
 
1485
        if self.branch.name:
 
1486
            return self.branch.name
1488
1487
        return urlutils.unescape(self.branch.base.split('/')[-2])
1489
1488
 
1490
1489
    def has_explicit_nickname(self):
1527
1526
 
1528
1527
 
1529
1528
def config_dir():
1530
 
    """Return per-user configuration directory.
 
1529
    """Return per-user configuration directory as unicode string
1531
1530
 
1532
1531
    By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1533
1532
    and Linux.  On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1535
1534
 
1536
1535
    TODO: Global option --config-dir to override this.
1537
1536
    """
1538
 
    base = os.environ.get('BZR_HOME', None)
 
1537
    base = osutils.path_from_environ('BZR_HOME')
1539
1538
    if sys.platform == 'win32':
1540
 
        # environ variables on Windows are in user encoding/mbcs. So decode
1541
 
        # before using one
1542
 
        if base is not None:
1543
 
            base = base.decode('mbcs')
1544
 
        if base is None:
1545
 
            base = win32utils.get_appdata_location_unicode()
1546
 
        if base is None:
1547
 
            base = os.environ.get('HOME', None)
1548
 
            if base is not None:
1549
 
                base = base.decode('mbcs')
1550
 
        if base is None:
1551
 
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1552
 
                                  ' or HOME set')
 
1539
        if base is None:
 
1540
            base = win32utils.get_appdata_location()
 
1541
        if base is None:
 
1542
            base = win32utils.get_home_location()
 
1543
        # GZ 2012-02-01: Really the two level subdirs only make sense inside
 
1544
        #                APPDATA, but hard to move. See bug 348640 for more.
1553
1545
        return osutils.pathjoin(base, 'bazaar', '2.0')
1554
 
    else:
1555
 
        if base is not None:
1556
 
            base = base.decode(osutils._fs_enc)
1557
 
    if sys.platform == 'darwin':
1558
 
        if base is None:
1559
 
            # this takes into account $HOME
1560
 
            base = os.path.expanduser("~")
1561
 
        return osutils.pathjoin(base, '.bazaar')
1562
 
    else:
1563
 
        if base is None:
1564
 
            xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
 
1546
    if base is None:
 
1547
        # GZ 2012-02-01: What should OSX use instead of XDG if anything?
 
1548
        if sys.platform != 'darwin':
 
1549
            xdg_dir = osutils.path_from_environ('XDG_CONFIG_HOME')
1565
1550
            if xdg_dir is None:
1566
 
                xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
 
1551
                xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1567
1552
            xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1568
1553
            if osutils.isdir(xdg_dir):
1569
1554
                trace.mutter(
1570
1555
                    "Using configuration in XDG directory %s." % xdg_dir)
1571
1556
                return xdg_dir
1572
 
            base = os.path.expanduser("~")
1573
 
        return osutils.pathjoin(base, ".bazaar")
 
1557
        base = osutils._get_home_dir()
 
1558
    return osutils.pathjoin(base, ".bazaar")
1574
1559
 
1575
1560
 
1576
1561
def config_filename():
1639
1624
        f.close()
1640
1625
 
1641
1626
 
 
1627
def default_email():
 
1628
    v = os.environ.get('BZR_EMAIL')
 
1629
    if v:
 
1630
        return v.decode(osutils.get_user_encoding())
 
1631
    v = os.environ.get('EMAIL')
 
1632
    if v:
 
1633
        return v.decode(osutils.get_user_encoding())
 
1634
    name, email = _auto_user_id()
 
1635
    if name and email:
 
1636
        return u'%s <%s>' % (name, email)
 
1637
    elif email:
 
1638
        return email
 
1639
    raise errors.NoWhoami()
 
1640
 
 
1641
 
1642
1642
def _auto_user_id():
1643
1643
    """Calculate automatic user identification.
1644
1644
 
1833
1833
        :param user: login (optional)
1834
1834
 
1835
1835
        :param path: the absolute path on the server (optional)
1836
 
        
 
1836
 
1837
1837
        :param realm: the http authentication realm (optional)
1838
1838
 
1839
1839
        :return: A dict containing the matching credentials or None.
2278
2278
            return f
2279
2279
        except errors.NoSuchFile:
2280
2280
            return StringIO()
 
2281
        except errors.PermissionDenied, e:
 
2282
            trace.warning("Permission denied while trying to open "
 
2283
                "configuration file %s.", urlutils.unescape_for_display(
 
2284
                urlutils.join(self._transport.base, self._filename), "utf-8"))
 
2285
            return StringIO()
2281
2286
 
2282
2287
    def _external_url(self):
2283
2288
        return urlutils.join(self._transport.external_url(), self._filename)
2314
2319
    encoutered, in which config files it can be stored.
2315
2320
    """
2316
2321
 
2317
 
    def __init__(self, name, default=None, default_from_env=None,
2318
 
                 help=None,
2319
 
                 from_unicode=None, invalid=None):
 
2322
    def __init__(self, name, override_from_env=None,
 
2323
                 default=None, default_from_env=None,
 
2324
                 help=None, from_unicode=None, invalid=None, unquote=True):
2320
2325
        """Build an option definition.
2321
2326
 
2322
2327
        :param name: the name used to refer to the option.
2323
2328
 
 
2329
        :param override_from_env: A list of environment variables which can
 
2330
           provide override any configuration setting.
 
2331
 
2324
2332
        :param default: the default value to use when none exist in the config
2325
 
            stores.
 
2333
            stores. This is either a string that ``from_unicode`` will convert
 
2334
            into the proper type, a callable returning a unicode string so that
 
2335
            ``from_unicode`` can be used on the return value, or a python
 
2336
            object that can be stringified (so only the empty list is supported
 
2337
            for example).
2326
2338
 
2327
2339
        :param default_from_env: A list of environment variables which can
2328
2340
           provide a default value. 'default' will be used only if none of the
2340
2352
            TypeError. Accepted values are: None (ignore invalid values),
2341
2353
            'warning' (emit a warning), 'error' (emit an error message and
2342
2354
            terminates).
 
2355
 
 
2356
        :param unquote: should the unicode value be unquoted before conversion.
 
2357
           This should be used only when the store providing the values cannot
 
2358
           safely unquote them (see http://pad.lv/906897). It is provided so
 
2359
           daughter classes can handle the quoting themselves.
2343
2360
        """
 
2361
        if override_from_env is None:
 
2362
            override_from_env = []
2344
2363
        if default_from_env is None:
2345
2364
            default_from_env = []
2346
2365
        self.name = name
2347
 
        self.default = default
 
2366
        self.override_from_env = override_from_env
 
2367
        # Convert the default value to a unicode string so all values are
 
2368
        # strings internally before conversion (via from_unicode) is attempted.
 
2369
        if default is None:
 
2370
            self.default = None
 
2371
        elif isinstance(default, list):
 
2372
            # Only the empty list is supported
 
2373
            if default:
 
2374
                raise AssertionError(
 
2375
                    'Only empty lists are supported as default values')
 
2376
            self.default = u','
 
2377
        elif isinstance(default, (str, unicode, bool, int, float)):
 
2378
            # Rely on python to convert strings, booleans and integers
 
2379
            self.default = u'%s' % (default,)
 
2380
        elif callable(default):
 
2381
            self.default = default
 
2382
        else:
 
2383
            # other python objects are not expected
 
2384
            raise AssertionError('%r is not supported as a default value'
 
2385
                                 % (default,))
2348
2386
        self.default_from_env = default_from_env
2349
2387
        self.help = help
2350
2388
        self.from_unicode = from_unicode
 
2389
        self.unquote = unquote
2351
2390
        if invalid and invalid not in ('warning', 'error'):
2352
2391
            raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2353
2392
        self.invalid = invalid
2354
2393
 
 
2394
    def convert_from_unicode(self, store, unicode_value):
 
2395
        if self.unquote and store is not None and unicode_value is not None:
 
2396
            unicode_value = store.unquote(unicode_value)
 
2397
        if self.from_unicode is None or unicode_value is None:
 
2398
            # Don't convert or nothing to convert
 
2399
            return unicode_value
 
2400
        try:
 
2401
            converted = self.from_unicode(unicode_value)
 
2402
        except (ValueError, TypeError):
 
2403
            # Invalid values are ignored
 
2404
            converted = None
 
2405
        if converted is None and self.invalid is not None:
 
2406
            # The conversion failed
 
2407
            if self.invalid == 'warning':
 
2408
                trace.warning('Value "%s" is not valid for "%s"',
 
2409
                              unicode_value, self.name)
 
2410
            elif self.invalid == 'error':
 
2411
                raise errors.ConfigOptionValueError(self.name, unicode_value)
 
2412
        return converted
 
2413
 
 
2414
    def get_override(self):
 
2415
        value = None
 
2416
        for var in self.override_from_env:
 
2417
            try:
 
2418
                # If the env variable is defined, its value takes precedence
 
2419
                value = os.environ[var].decode(osutils.get_user_encoding())
 
2420
                break
 
2421
            except KeyError:
 
2422
                continue
 
2423
        return value
 
2424
 
2355
2425
    def get_default(self):
 
2426
        value = None
2356
2427
        for var in self.default_from_env:
2357
2428
            try:
2358
 
                return os.environ[var]
 
2429
                # If the env variable is defined, its value is the default one
 
2430
                value = os.environ[var].decode(osutils.get_user_encoding())
 
2431
                break
2359
2432
            except KeyError:
2360
2433
                continue
2361
 
        return self.default
 
2434
        if value is None:
 
2435
            # Otherwise, fallback to the value defined at registration
 
2436
            if callable(self.default):
 
2437
                value = self.default()
 
2438
                if not isinstance(value, unicode):
 
2439
                    raise AssertionError(
 
2440
                    'Callable default values should be unicode')
 
2441
            else:
 
2442
                value = self.default
 
2443
        return value
2362
2444
 
2363
2445
    def get_help_text(self, additional_see_also=None, plain=True):
2364
2446
        result = self.help
2379
2461
    return int(unicode_str)
2380
2462
 
2381
2463
 
2382
 
def list_from_store(unicode_str):
2383
 
    # ConfigObj return '' instead of u''. Use 'str' below to catch all cases.
2384
 
    if isinstance(unicode_str, (str, unicode)):
2385
 
        if unicode_str:
2386
 
            # A single value, most probably the user forgot (or didn't care to
2387
 
            # add) the final ','
2388
 
            l = [unicode_str]
 
2464
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
 
2465
 
 
2466
def int_SI_from_store(unicode_str):
 
2467
    """Convert a human readable size in SI units, e.g 10MB into an integer.
 
2468
 
 
2469
    Accepted suffixes are K,M,G. It is case-insensitive and may be followed
 
2470
    by a trailing b (i.e. Kb, MB). This is intended to be practical and not
 
2471
    pedantic.
 
2472
 
 
2473
    :return Integer, expanded to its base-10 value if a proper SI unit is 
 
2474
        found, None otherwise.
 
2475
    """
 
2476
    regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
 
2477
    p = re.compile(regexp, re.IGNORECASE)
 
2478
    m = p.match(unicode_str)
 
2479
    val = None
 
2480
    if m is not None:
 
2481
        val, _, unit = m.groups()
 
2482
        val = int(val)
 
2483
        if unit:
 
2484
            try:
 
2485
                coeff = _unit_suffixes[unit.upper()]
 
2486
            except KeyError:
 
2487
                raise ValueError(gettext('{0} is not an SI unit.').format(unit))
 
2488
            val *= coeff
 
2489
    return val
 
2490
 
 
2491
 
 
2492
def float_from_store(unicode_str):
 
2493
    return float(unicode_str)
 
2494
 
 
2495
 
 
2496
# Use a an empty dict to initialize an empty configobj avoiding all
 
2497
# parsing and encoding checks
 
2498
_list_converter_config = configobj.ConfigObj(
 
2499
    {}, encoding='utf-8', list_values=True, interpolation=False)
 
2500
 
 
2501
 
 
2502
class ListOption(Option):
 
2503
 
 
2504
    def __init__(self, name, default=None, default_from_env=None,
 
2505
                 help=None, invalid=None):
 
2506
        """A list Option definition.
 
2507
 
 
2508
        This overrides the base class so the conversion from a unicode string
 
2509
        can take quoting into account.
 
2510
        """
 
2511
        super(ListOption, self).__init__(
 
2512
            name, default=default, default_from_env=default_from_env,
 
2513
            from_unicode=self.from_unicode, help=help,
 
2514
            invalid=invalid, unquote=False)
 
2515
 
 
2516
    def from_unicode(self, unicode_str):
 
2517
        if not isinstance(unicode_str, basestring):
 
2518
            raise TypeError
 
2519
        # Now inject our string directly as unicode. All callers got their
 
2520
        # value from configobj, so values that need to be quoted are already
 
2521
        # properly quoted.
 
2522
        _list_converter_config.reset()
 
2523
        _list_converter_config._parse([u"list=%s" % (unicode_str,)])
 
2524
        maybe_list = _list_converter_config['list']
 
2525
        if isinstance(maybe_list, basestring):
 
2526
            if maybe_list:
 
2527
                # A single value, most probably the user forgot (or didn't care
 
2528
                # to add) the final ','
 
2529
                l = [maybe_list]
 
2530
            else:
 
2531
                # The empty string, convert to empty list
 
2532
                l = []
2389
2533
        else:
2390
 
            # The empty string, convert to empty list
2391
 
            l = []
2392
 
    else:
2393
 
        # We rely on ConfigObj providing us with a list already
2394
 
        l = unicode_str
2395
 
    return l
 
2534
            # We rely on ConfigObj providing us with a list already
 
2535
            l = maybe_list
 
2536
        return l
2396
2537
 
2397
2538
 
2398
2539
class OptionRegistry(registry.Registry):
2439
2580
# Registered options in lexicographical order
2440
2581
 
2441
2582
option_registry.register(
 
2583
    Option('append_revisions_only',
 
2584
           default=None, from_unicode=bool_from_store, invalid='warning',
 
2585
           help='''\
 
2586
Whether to only append revisions to the mainline.
 
2587
 
 
2588
If this is set to true, then it is not possible to change the
 
2589
existing mainline of the branch.
 
2590
'''))
 
2591
option_registry.register(
 
2592
    ListOption('acceptable_keys',
 
2593
           default=None,
 
2594
           help="""\
 
2595
List of GPG key patterns which are acceptable for verification.
 
2596
"""))
 
2597
option_registry.register(
 
2598
    Option('add.maximum_file_size',
 
2599
           default=u'20MB', from_unicode=int_SI_from_store,
 
2600
           help="""\
 
2601
Size above which files should be added manually.
 
2602
 
 
2603
Files below this size are added automatically when using ``bzr add`` without
 
2604
arguments.
 
2605
 
 
2606
A negative value means disable the size check.
 
2607
"""))
 
2608
option_registry.register(
 
2609
    Option('bound',
 
2610
           default=None, from_unicode=bool_from_store,
 
2611
           help="""\
 
2612
Is the branch bound to ``bound_location``.
 
2613
 
 
2614
If set to "True", the branch should act as a checkout, and push each commit to
 
2615
the bound_location.  This option is normally set by ``bind``/``unbind``.
 
2616
 
 
2617
See also: bound_location.
 
2618
"""))
 
2619
option_registry.register(
 
2620
    Option('bound_location',
 
2621
           default=None,
 
2622
           help="""\
 
2623
The location that commits should go to when acting as a checkout.
 
2624
 
 
2625
This option is normally set by ``bind``.
 
2626
 
 
2627
See also: bound.
 
2628
"""))
 
2629
option_registry.register(
 
2630
    Option('branch.fetch_tags', default=False,  from_unicode=bool_from_store,
 
2631
           help="""\
 
2632
Whether revisions associated with tags should be fetched.
 
2633
"""))
 
2634
option_registry.register(
2442
2635
    Option('bzr.workingtree.worth_saving_limit', default=10,
2443
2636
           from_unicode=int_from_store,  invalid='warning',
2444
2637
           help='''\
2451
2644
a file has been touched.
2452
2645
'''))
2453
2646
option_registry.register(
 
2647
    Option('check_signatures', default=CHECK_IF_POSSIBLE,
 
2648
           from_unicode=signature_policy_from_unicode,
 
2649
           help='''\
 
2650
GPG checking policy.
 
2651
 
 
2652
Possible values: require, ignore, check-available (default)
 
2653
 
 
2654
this option will control whether bzr will require good gpg
 
2655
signatures, ignore them, or check them if they are
 
2656
present.
 
2657
'''))
 
2658
option_registry.register(
 
2659
    Option('child_submit_format',
 
2660
           help='''The preferred format of submissions to this branch.'''))
 
2661
option_registry.register(
 
2662
    Option('child_submit_to',
 
2663
           help='''Where submissions to this branch are mailed to.'''))
 
2664
option_registry.register(
 
2665
    Option('create_signatures', default=SIGN_WHEN_REQUIRED,
 
2666
           from_unicode=signing_policy_from_unicode,
 
2667
           help='''\
 
2668
GPG Signing policy.
 
2669
 
 
2670
Possible values: always, never, when-required (default)
 
2671
 
 
2672
This option controls whether bzr will always create
 
2673
gpg signatures or not on commits.
 
2674
'''))
 
2675
option_registry.register(
2454
2676
    Option('dirstate.fdatasync', default=True,
2455
2677
           from_unicode=bool_from_store,
2456
2678
           help='''\
2461
2683
should not be lost if the machine crashes.  See also repository.fdatasync.
2462
2684
'''))
2463
2685
option_registry.register(
2464
 
    Option('debug_flags', default=[], from_unicode=list_from_store,
 
2686
    ListOption('debug_flags', default=[],
2465
2687
           help='Debug flags to activate.'))
2466
2688
option_registry.register(
2467
2689
    Option('default_format', default='2a',
2468
2690
           help='Format used when creating branches.'))
2469
2691
option_registry.register(
 
2692
    Option('dpush_strict', default=None,
 
2693
           from_unicode=bool_from_store,
 
2694
           help='''\
 
2695
The default value for ``dpush --strict``.
 
2696
 
 
2697
If present, defines the ``--strict`` option default value for checking
 
2698
uncommitted changes before pushing into a different VCS without any
 
2699
custom bzr metadata.
 
2700
'''))
 
2701
option_registry.register(
2470
2702
    Option('editor',
2471
2703
           help='The command called to launch an editor to enter a message.'))
2472
2704
option_registry.register(
 
2705
    Option('email', override_from_env=['BZR_EMAIL'], default=default_email,
 
2706
           help='The users identity'))
 
2707
option_registry.register(
 
2708
    Option('gpg_signing_command',
 
2709
           default='gpg',
 
2710
           help="""\
 
2711
Program to use use for creating signatures.
 
2712
 
 
2713
This should support at least the -u and --clearsign options.
 
2714
"""))
 
2715
option_registry.register(
 
2716
    Option('gpg_signing_key',
 
2717
           default=None,
 
2718
           help="""\
 
2719
GPG key to use for signing.
 
2720
 
 
2721
This defaults to the first key associated with the users email.
 
2722
"""))
 
2723
option_registry.register(
2473
2724
    Option('ignore_missing_extensions', default=False,
2474
2725
           from_unicode=bool_from_store,
2475
2726
           help='''\
2493
2744
Otherwise, bzr will prompt as normal to break the lock.
2494
2745
'''))
2495
2746
option_registry.register(
 
2747
    Option('log_format', default='long',
 
2748
           help= '''\
 
2749
Log format to use when displaying revisions.
 
2750
 
 
2751
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
 
2752
may be provided by plugins.
 
2753
'''))
 
2754
option_registry.register(
2496
2755
    Option('output_encoding',
2497
2756
           help= 'Unicode encoding for output'
2498
2757
           ' (terminal encoding if not specified).'))
2499
2758
option_registry.register(
2500
 
    Option('repository.fdatasync', default=True, from_unicode=bool_from_store,
 
2759
    Option('parent_location',
 
2760
           default=None,
 
2761
           help="""\
 
2762
The location of the default branch for pull or merge.
 
2763
 
 
2764
This option is normally set when creating a branch, the first ``pull`` or by
 
2765
``pull --remember``.
 
2766
"""))
 
2767
option_registry.register(
 
2768
    Option('post_commit', default=None,
 
2769
           help='''\
 
2770
Post commit functions.
 
2771
 
 
2772
An ordered list of python functions to call, separated by spaces.
 
2773
 
 
2774
Each function takes branch, rev_id as parameters.
 
2775
'''))
 
2776
option_registry.register(
 
2777
    Option('public_branch',
 
2778
           default=None,
 
2779
           help="""\
 
2780
A publically-accessible version of this branch.
 
2781
 
 
2782
This implies that the branch setting this option is not publically-accessible.
 
2783
Used and set by ``bzr send``.
 
2784
"""))
 
2785
option_registry.register(
 
2786
    Option('push_location',
 
2787
           default=None,
 
2788
           help="""\
 
2789
The location of the default branch for push.
 
2790
 
 
2791
This option is normally set by the first ``push`` or ``push --remember``.
 
2792
"""))
 
2793
option_registry.register(
 
2794
    Option('push_strict', default=None,
 
2795
           from_unicode=bool_from_store,
 
2796
           help='''\
 
2797
The default value for ``push --strict``.
 
2798
 
 
2799
If present, defines the ``--strict`` option default value for checking
 
2800
uncommitted changes before sending a merge directive.
 
2801
'''))
 
2802
option_registry.register(
 
2803
    Option('repository.fdatasync', default=True,
 
2804
           from_unicode=bool_from_store,
2501
2805
           help='''\
2502
2806
Flush repository changes onto physical disk?
2503
2807
 
2505
2809
to physical disk.  This is somewhat slower, but means data should not be
2506
2810
lost if the machine crashes.  See also dirstate.fdatasync.
2507
2811
'''))
 
2812
option_registry.register_lazy('smtp_server',
 
2813
    'bzrlib.smtp_connection', 'smtp_server')
 
2814
option_registry.register_lazy('smtp_password',
 
2815
    'bzrlib.smtp_connection', 'smtp_password')
 
2816
option_registry.register_lazy('smtp_username',
 
2817
    'bzrlib.smtp_connection', 'smtp_username')
 
2818
option_registry.register(
 
2819
    Option('selftest.timeout',
 
2820
        default='600',
 
2821
        from_unicode=int_from_store,
 
2822
        help='Abort selftest if one test takes longer than this many seconds',
 
2823
        ))
 
2824
 
 
2825
option_registry.register(
 
2826
    Option('send_strict', default=None,
 
2827
           from_unicode=bool_from_store,
 
2828
           help='''\
 
2829
The default value for ``send --strict``.
 
2830
 
 
2831
If present, defines the ``--strict`` option default value for checking
 
2832
uncommitted changes before sending a bundle.
 
2833
'''))
 
2834
 
 
2835
option_registry.register(
 
2836
    Option('serve.client_timeout',
 
2837
           default=300.0, from_unicode=float_from_store,
 
2838
           help="If we wait for a new request from a client for more than"
 
2839
                " X seconds, consider the client idle, and hangup."))
 
2840
option_registry.register(
 
2841
    Option('stacked_on_location',
 
2842
           default=None,
 
2843
           help="""The location where this branch is stacked on."""))
 
2844
option_registry.register(
 
2845
    Option('submit_branch',
 
2846
           default=None,
 
2847
           help="""\
 
2848
The branch you intend to submit your current work to.
 
2849
 
 
2850
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
 
2851
by the ``submit:`` revision spec.
 
2852
"""))
 
2853
option_registry.register(
 
2854
    Option('submit_to',
 
2855
           help='''Where submissions from this branch are mailed to.'''))
 
2856
 
 
2857
option_registry.register_lazy('ssl.ca_certs',
 
2858
    'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
 
2859
 
 
2860
option_registry.register_lazy('ssl.cert_reqs',
 
2861
    'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
 
2862
 
2508
2863
 
2509
2864
 
2510
2865
class Section(object):
2520
2875
        # We re-use the dict-like object received
2521
2876
        self.options = options
2522
2877
 
2523
 
    def get(self, name, default=None):
 
2878
    def get(self, name, default=None, expand=True):
2524
2879
        return self.options.get(name, default)
2525
2880
 
 
2881
    def iter_option_names(self):
 
2882
        for k in self.options.iterkeys():
 
2883
            yield k
 
2884
 
2526
2885
    def __repr__(self):
2527
2886
        # Mostly for debugging use
2528
2887
        return "<config.%s id=%s>" % (self.__class__.__name__, self.id)
2530
2889
 
2531
2890
_NewlyCreatedOption = object()
2532
2891
"""Was the option created during the MutableSection lifetime"""
 
2892
_DeletedOption = object()
 
2893
"""Was the option deleted during the MutableSection lifetime"""
2533
2894
 
2534
2895
 
2535
2896
class MutableSection(Section):
2537
2898
 
2538
2899
    def __init__(self, section_id, options):
2539
2900
        super(MutableSection, self).__init__(section_id, options)
2540
 
        self.orig = {}
 
2901
        self.reset_changes()
2541
2902
 
2542
2903
    def set(self, name, value):
2543
2904
        if name not in self.options:
2552
2913
            self.orig[name] = self.get(name, None)
2553
2914
        del self.options[name]
2554
2915
 
 
2916
    def reset_changes(self):
 
2917
        self.orig = {}
 
2918
 
 
2919
    def apply_changes(self, dirty, store):
 
2920
        """Apply option value changes.
 
2921
 
 
2922
        ``self`` has been reloaded from the persistent storage. ``dirty``
 
2923
        contains the changes made since the previous loading.
 
2924
 
 
2925
        :param dirty: the mutable section containing the changes.
 
2926
 
 
2927
        :param store: the store containing the section
 
2928
        """
 
2929
        for k, expected in dirty.orig.iteritems():
 
2930
            actual = dirty.get(k, _DeletedOption)
 
2931
            reloaded = self.get(k, _NewlyCreatedOption)
 
2932
            if actual is _DeletedOption:
 
2933
                if k in self.options:
 
2934
                    self.remove(k)
 
2935
            else:
 
2936
                self.set(k, actual)
 
2937
            # Report concurrent updates in an ad-hoc way. This should only
 
2938
            # occurs when different processes try to update the same option
 
2939
            # which is not supported (as in: the config framework is not meant
 
2940
            # to be used a sharing mechanism).
 
2941
            if expected != reloaded:
 
2942
                if actual is _DeletedOption:
 
2943
                    actual = '<DELETED>'
 
2944
                if reloaded is _NewlyCreatedOption:
 
2945
                    reloaded = '<CREATED>'
 
2946
                if expected is _NewlyCreatedOption:
 
2947
                    expected = '<CREATED>'
 
2948
                # Someone changed the value since we get it from the persistent
 
2949
                # storage.
 
2950
                trace.warning(gettext(
 
2951
                        "Option {0} in section {1} of {2} was changed"
 
2952
                        " from {3} to {4}. The {5} value will be saved.".format(
 
2953
                            k, self.id, store.external_url(), expected,
 
2954
                            reloaded, actual)))
 
2955
        # No need to keep track of these changes
 
2956
        self.reset_changes()
 
2957
 
2555
2958
 
2556
2959
class Store(object):
2557
2960
    """Abstract interface to persistent storage for configuration options."""
2559
2962
    readonly_section_class = Section
2560
2963
    mutable_section_class = MutableSection
2561
2964
 
 
2965
    def __init__(self):
 
2966
        # Which sections need to be saved
 
2967
        self.dirty_sections = []
 
2968
 
2562
2969
    def is_loaded(self):
2563
2970
        """Returns True if the Store has been loaded.
2564
2971
 
2587
2994
        """
2588
2995
        raise NotImplementedError(self.unload)
2589
2996
 
 
2997
    def quote(self, value):
 
2998
        """Quote a configuration option value for storing purposes.
 
2999
 
 
3000
        This allows Stacks to present values as they will be stored.
 
3001
        """
 
3002
        return value
 
3003
 
 
3004
    def unquote(self, value):
 
3005
        """Unquote a configuration option value into unicode.
 
3006
 
 
3007
        The received value is quoted as stored.
 
3008
        """
 
3009
        return value
 
3010
 
2590
3011
    def save(self):
2591
3012
        """Saves the Store to persistent storage."""
2592
3013
        raise NotImplementedError(self.save)
2593
3014
 
 
3015
    def _need_saving(self):
 
3016
        for s in self.dirty_sections:
 
3017
            if s.orig:
 
3018
                # At least one dirty section contains a modification
 
3019
                return True
 
3020
        return False
 
3021
 
 
3022
    def apply_changes(self, dirty_sections):
 
3023
        """Apply changes from dirty sections while checking for coherency.
 
3024
 
 
3025
        The Store content is discarded and reloaded from persistent storage to
 
3026
        acquire up-to-date values.
 
3027
 
 
3028
        Dirty sections are MutableSection which kept track of the value they
 
3029
        are expected to update.
 
3030
        """
 
3031
        # We need an up-to-date version from the persistent storage, unload the
 
3032
        # store. The reload will occur when needed (triggered by the first
 
3033
        # get_mutable_section() call below.
 
3034
        self.unload()
 
3035
        # Apply the changes from the preserved dirty sections
 
3036
        for dirty in dirty_sections:
 
3037
            clean = self.get_mutable_section(dirty.id)
 
3038
            clean.apply_changes(dirty, self)
 
3039
        # Everything is clean now
 
3040
        self.dirty_sections = []
 
3041
 
 
3042
    def save_changes(self):
 
3043
        """Saves the Store to persistent storage if changes occurred.
 
3044
 
 
3045
        Apply the changes recorded in the mutable sections to a store content
 
3046
        refreshed from persistent storage.
 
3047
        """
 
3048
        raise NotImplementedError(self.save_changes)
 
3049
 
2594
3050
    def external_url(self):
2595
3051
        raise NotImplementedError(self.external_url)
2596
3052
 
2597
3053
    def get_sections(self):
2598
3054
        """Returns an ordered iterable of existing sections.
2599
3055
 
2600
 
        :returns: An iterable of (name, dict).
 
3056
        :returns: An iterable of (store, section).
2601
3057
        """
2602
3058
        raise NotImplementedError(self.get_sections)
2603
3059
 
2604
 
    def get_mutable_section(self, section_name=None):
 
3060
    def get_mutable_section(self, section_id=None):
2605
3061
        """Returns the specified mutable section.
2606
3062
 
2607
 
        :param section_name: The section identifier
 
3063
        :param section_id: The section identifier
2608
3064
        """
2609
3065
        raise NotImplementedError(self.get_mutable_section)
2610
3066
 
2614
3070
                                    self.external_url())
2615
3071
 
2616
3072
 
 
3073
class CommandLineStore(Store):
 
3074
    "A store to carry command line overrides for the config options."""
 
3075
 
 
3076
    def __init__(self, opts=None):
 
3077
        super(CommandLineStore, self).__init__()
 
3078
        if opts is None:
 
3079
            opts = {}
 
3080
        self.options = {}
 
3081
        self.id = 'cmdline'
 
3082
 
 
3083
    def _reset(self):
 
3084
        # The dict should be cleared but not replaced so it can be shared.
 
3085
        self.options.clear()
 
3086
 
 
3087
    def _from_cmdline(self, overrides):
 
3088
        # Reset before accepting new definitions
 
3089
        self._reset()
 
3090
        for over in overrides:
 
3091
            try:
 
3092
                name, value = over.split('=', 1)
 
3093
            except ValueError:
 
3094
                raise errors.BzrCommandError(
 
3095
                    gettext("Invalid '%s', should be of the form 'name=value'")
 
3096
                    % (over,))
 
3097
            self.options[name] = value
 
3098
 
 
3099
    def external_url(self):
 
3100
        # Not an url but it makes debugging easier and is never needed
 
3101
        # otherwise
 
3102
        return 'cmdline'
 
3103
 
 
3104
    def get_sections(self):
 
3105
        yield self,  self.readonly_section_class(None, self.options)
 
3106
 
 
3107
 
2617
3108
class IniFileStore(Store):
2618
3109
    """A config Store using ConfigObj for storage.
2619
3110
 
2620
 
    :ivar transport: The transport object where the config file is located.
2621
 
 
2622
 
    :ivar file_name: The config file basename in the transport directory.
2623
 
 
2624
3111
    :ivar _config_obj: Private member to hold the ConfigObj instance used to
2625
3112
        serialize/deserialize the config file.
2626
3113
    """
2627
3114
 
2628
 
    def __init__(self, transport, file_name):
 
3115
    def __init__(self):
2629
3116
        """A config Store using ConfigObj for storage.
2630
 
 
2631
 
        :param transport: The transport object where the config file is located.
2632
 
 
2633
 
        :param file_name: The config file basename in the transport directory.
2634
3117
        """
2635
3118
        super(IniFileStore, self).__init__()
2636
 
        self.transport = transport
2637
 
        self.file_name = file_name
2638
3119
        self._config_obj = None
2639
3120
 
2640
3121
    def is_loaded(self):
2642
3123
 
2643
3124
    def unload(self):
2644
3125
        self._config_obj = None
 
3126
        self.dirty_sections = []
 
3127
 
 
3128
    def _load_content(self):
 
3129
        """Load the config file bytes.
 
3130
 
 
3131
        This should be provided by subclasses
 
3132
 
 
3133
        :return: Byte string
 
3134
        """
 
3135
        raise NotImplementedError(self._load_content)
 
3136
 
 
3137
    def _save_content(self, content):
 
3138
        """Save the config file bytes.
 
3139
 
 
3140
        This should be provided by subclasses
 
3141
 
 
3142
        :param content: Config file bytes to write
 
3143
        """
 
3144
        raise NotImplementedError(self._save_content)
2645
3145
 
2646
3146
    def load(self):
2647
3147
        """Load the store from the associated file."""
2648
3148
        if self.is_loaded():
2649
3149
            return
2650
 
        content = self.transport.get_bytes(self.file_name)
 
3150
        content = self._load_content()
2651
3151
        self._load_from_string(content)
2652
3152
        for hook in ConfigHooks['load']:
2653
3153
            hook(self)
2662
3162
        co_input = StringIO(bytes)
2663
3163
        try:
2664
3164
            # The config files are always stored utf8-encoded
2665
 
            self._config_obj = ConfigObj(co_input, encoding='utf-8')
 
3165
            self._config_obj = ConfigObj(co_input, encoding='utf-8',
 
3166
                                         list_values=False)
2666
3167
        except configobj.ConfigObjError, e:
2667
3168
            self._config_obj = None
2668
3169
            raise errors.ParseConfigError(e.errors, self.external_url())
2669
3170
        except UnicodeDecodeError:
2670
3171
            raise errors.ConfigContentError(self.external_url())
2671
3172
 
 
3173
    def save_changes(self):
 
3174
        if not self.is_loaded():
 
3175
            # Nothing to save
 
3176
            return
 
3177
        if not self._need_saving():
 
3178
            return
 
3179
        # Preserve the current version
 
3180
        current = self._config_obj
 
3181
        dirty_sections = list(self.dirty_sections)
 
3182
        self.apply_changes(dirty_sections)
 
3183
        # Save to the persistent storage
 
3184
        self.save()
 
3185
 
2672
3186
    def save(self):
2673
3187
        if not self.is_loaded():
2674
3188
            # Nothing to save
2675
3189
            return
2676
3190
        out = StringIO()
2677
3191
        self._config_obj.write(out)
2678
 
        self.transport.put_bytes(self.file_name, out.getvalue())
 
3192
        self._save_content(out.getvalue())
2679
3193
        for hook in ConfigHooks['save']:
2680
3194
            hook(self)
2681
3195
 
2682
 
    def external_url(self):
2683
 
        # FIXME: external_url should really accepts an optional relpath
2684
 
        # parameter (bug #750169) :-/ -- vila 2011-04-04
2685
 
        # The following will do in the interim but maybe we don't want to
2686
 
        # expose a path here but rather a config ID and its associated
2687
 
        # object </hand wawe>.
2688
 
        return urlutils.join(self.transport.external_url(), self.file_name)
2689
 
 
2690
3196
    def get_sections(self):
2691
3197
        """Get the configobj section in the file order.
2692
3198
 
2693
 
        :returns: An iterable of (name, dict).
 
3199
        :returns: An iterable of (store, section).
2694
3200
        """
2695
3201
        # We need a loaded store
2696
3202
        try:
2697
3203
            self.load()
2698
 
        except errors.NoSuchFile:
2699
 
            # If the file doesn't exist, there is no sections
 
3204
        except (errors.NoSuchFile, errors.PermissionDenied):
 
3205
            # If the file can't be read, there is no sections
2700
3206
            return
2701
3207
        cobj = self._config_obj
2702
3208
        if cobj.scalars:
2703
 
            yield self.readonly_section_class(None, cobj)
 
3209
            yield self, self.readonly_section_class(None, cobj)
2704
3210
        for section_name in cobj.sections:
2705
 
            yield self.readonly_section_class(section_name, cobj[section_name])
 
3211
            yield (self,
 
3212
                   self.readonly_section_class(section_name,
 
3213
                                               cobj[section_name]))
2706
3214
 
2707
 
    def get_mutable_section(self, section_name=None):
 
3215
    def get_mutable_section(self, section_id=None):
2708
3216
        # We need a loaded store
2709
3217
        try:
2710
3218
            self.load()
2711
3219
        except errors.NoSuchFile:
2712
3220
            # The file doesn't exist, let's pretend it was empty
2713
3221
            self._load_from_string('')
2714
 
        if section_name is None:
 
3222
        if section_id is None:
2715
3223
            section = self._config_obj
2716
3224
        else:
2717
 
            section = self._config_obj.setdefault(section_name, {})
2718
 
        return self.mutable_section_class(section_name, section)
 
3225
            section = self._config_obj.setdefault(section_id, {})
 
3226
        mutable_section = self.mutable_section_class(section_id, section)
 
3227
        # All mutable sections can become dirty
 
3228
        self.dirty_sections.append(mutable_section)
 
3229
        return mutable_section
 
3230
 
 
3231
    def quote(self, value):
 
3232
        try:
 
3233
            # configobj conflates automagical list values and quoting
 
3234
            self._config_obj.list_values = True
 
3235
            return self._config_obj._quote(value)
 
3236
        finally:
 
3237
            self._config_obj.list_values = False
 
3238
 
 
3239
    def unquote(self, value):
 
3240
        if value and isinstance(value, basestring):
 
3241
            # _unquote doesn't handle None nor empty strings nor anything that
 
3242
            # is not a string, really.
 
3243
            value = self._config_obj._unquote(value)
 
3244
        return value
 
3245
 
 
3246
    def external_url(self):
 
3247
        # Since an IniFileStore can be used without a file (at least in tests),
 
3248
        # it's better to provide something than raising a NotImplementedError.
 
3249
        # All daughter classes are supposed to provide an implementation
 
3250
        # anyway.
 
3251
        return 'In-Process Store, no URL'
 
3252
 
 
3253
class TransportIniFileStore(IniFileStore):
 
3254
    """IniFileStore that loads files from a transport.
 
3255
 
 
3256
    :ivar transport: The transport object where the config file is located.
 
3257
 
 
3258
    :ivar file_name: The config file basename in the transport directory.
 
3259
    """
 
3260
 
 
3261
    def __init__(self, transport, file_name):
 
3262
        """A Store using a ini file on a Transport
 
3263
 
 
3264
        :param transport: The transport object where the config file is located.
 
3265
        :param file_name: The config file basename in the transport directory.
 
3266
        """
 
3267
        super(TransportIniFileStore, self).__init__()
 
3268
        self.transport = transport
 
3269
        self.file_name = file_name
 
3270
 
 
3271
    def _load_content(self):
 
3272
        try:
 
3273
            return self.transport.get_bytes(self.file_name)
 
3274
        except errors.PermissionDenied:
 
3275
            trace.warning("Permission denied while trying to load "
 
3276
                          "configuration store %s.", self.external_url())
 
3277
            raise
 
3278
 
 
3279
    def _save_content(self, content):
 
3280
        self.transport.put_bytes(self.file_name, content)
 
3281
 
 
3282
    def external_url(self):
 
3283
        # FIXME: external_url should really accepts an optional relpath
 
3284
        # parameter (bug #750169) :-/ -- vila 2011-04-04
 
3285
        # The following will do in the interim but maybe we don't want to
 
3286
        # expose a path here but rather a config ID and its associated
 
3287
        # object </hand wawe>.
 
3288
        return urlutils.join(self.transport.external_url(), self.file_name)
2719
3289
 
2720
3290
 
2721
3291
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
2724
3294
# they may face the same issue.
2725
3295
 
2726
3296
 
2727
 
class LockableIniFileStore(IniFileStore):
 
3297
class LockableIniFileStore(TransportIniFileStore):
2728
3298
    """A ConfigObjStore using locks on save to ensure store integrity."""
2729
3299
 
2730
3300
    def __init__(self, transport, file_name, lock_dir_name=None):
2780
3350
        t = transport.get_transport_from_path(
2781
3351
            config_dir(), possible_transports=possible_transports)
2782
3352
        super(GlobalStore, self).__init__(t, 'bazaar.conf')
 
3353
        self.id = 'bazaar'
2783
3354
 
2784
3355
 
2785
3356
class LocationStore(LockableIniFileStore):
2788
3359
        t = transport.get_transport_from_path(
2789
3360
            config_dir(), possible_transports=possible_transports)
2790
3361
        super(LocationStore, self).__init__(t, 'locations.conf')
2791
 
 
2792
 
 
2793
 
class BranchStore(IniFileStore):
 
3362
        self.id = 'locations'
 
3363
 
 
3364
 
 
3365
class BranchStore(TransportIniFileStore):
2794
3366
 
2795
3367
    def __init__(self, branch):
2796
3368
        super(BranchStore, self).__init__(branch.control_transport,
2797
3369
                                          'branch.conf')
2798
3370
        self.branch = branch
 
3371
        self.id = 'branch'
2799
3372
 
2800
3373
    def lock_write(self, token=None):
2801
3374
        return self.branch.lock_write(token)
2818
3391
        super(ControlStore, self).__init__(bzrdir.transport,
2819
3392
                                          'control.conf',
2820
3393
                                           lock_dir_name='branch_lock')
 
3394
        self.id = 'control'
2821
3395
 
2822
3396
 
2823
3397
class SectionMatcher(object):
2824
3398
    """Select sections into a given Store.
2825
3399
 
2826
 
    This intended to be used to postpone getting an iterable of sections from a
2827
 
    store.
 
3400
    This is intended to be used to postpone getting an iterable of sections
 
3401
    from a store.
2828
3402
    """
2829
3403
 
2830
3404
    def __init__(self, store):
2835
3409
        # sections.
2836
3410
        sections = self.store.get_sections()
2837
3411
        # Walk the revisions in the order provided
2838
 
        for s in sections:
 
3412
        for store, s in sections:
2839
3413
            if self.match(s):
2840
 
                yield s
2841
 
 
2842
 
    def match(self, secion):
 
3414
                yield store, s
 
3415
 
 
3416
    def match(self, section):
 
3417
        """Does the proposed section match.
 
3418
 
 
3419
        :param section: A Section object.
 
3420
 
 
3421
        :returns: True if the section matches, False otherwise.
 
3422
        """
2843
3423
        raise NotImplementedError(self.match)
2844
3424
 
2845
3425
 
 
3426
class NameMatcher(SectionMatcher):
 
3427
 
 
3428
    def __init__(self, store, section_id):
 
3429
        super(NameMatcher, self).__init__(store)
 
3430
        self.section_id = section_id
 
3431
 
 
3432
    def match(self, section):
 
3433
        return section.id == self.section_id
 
3434
 
 
3435
 
2846
3436
class LocationSection(Section):
2847
3437
 
2848
 
    def __init__(self, section, length, extra_path):
 
3438
    def __init__(self, section, extra_path):
2849
3439
        super(LocationSection, self).__init__(section.id, section.options)
2850
 
        self.length = length
2851
3440
        self.extra_path = extra_path
 
3441
        self.locals = {'relpath': extra_path,
 
3442
                       'basename': urlutils.basename(extra_path)}
2852
3443
 
2853
 
    def get(self, name, default=None):
 
3444
    def get(self, name, default=None, expand=True):
2854
3445
        value = super(LocationSection, self).get(name, default)
2855
 
        if value is not None:
 
3446
        if value is not None and expand:
2856
3447
            policy_name = self.get(name + ':policy', None)
2857
3448
            policy = _policy_value.get(policy_name, POLICY_NONE)
2858
3449
            if policy == POLICY_APPENDPATH:
2859
3450
                value = urlutils.join(value, self.extra_path)
 
3451
            # expand section local options right now (since POLICY_APPENDPATH
 
3452
            # will never add options references, it's ok to expand after it).
 
3453
            chunks = []
 
3454
            for is_ref, chunk in iter_option_refs(value):
 
3455
                if not is_ref:
 
3456
                    chunks.append(chunk)
 
3457
                else:
 
3458
                    ref = chunk[1:-1]
 
3459
                    if ref in self.locals:
 
3460
                        chunks.append(self.locals[ref])
 
3461
                    else:
 
3462
                        chunks.append(chunk)
 
3463
            value = ''.join(chunks)
2860
3464
        return value
2861
3465
 
2862
3466
 
 
3467
class StartingPathMatcher(SectionMatcher):
 
3468
    """Select sections for a given location respecting the Store order."""
 
3469
 
 
3470
    # FIXME: Both local paths and urls can be used for section names as well as
 
3471
    # ``location`` to stay consistent with ``LocationMatcher`` which itself
 
3472
    # inherited the fuzziness from the previous ``LocationConfig``
 
3473
    # implementation. We probably need to revisit which encoding is allowed for
 
3474
    # both ``location`` and section names and how we normalize
 
3475
    # them. http://pad.lv/85479, http://pad.lv/437009 and http://359320 are
 
3476
    # related too. -- vila 2012-01-04
 
3477
 
 
3478
    def __init__(self, store, location):
 
3479
        super(StartingPathMatcher, self).__init__(store)
 
3480
        if location.startswith('file://'):
 
3481
            location = urlutils.local_path_from_url(location)
 
3482
        self.location = location
 
3483
 
 
3484
    def get_sections(self):
 
3485
        """Get all sections matching ``location`` in the store.
 
3486
 
 
3487
        The most generic sections are described first in the store, then more
 
3488
        specific ones can be provided for reduced scopes.
 
3489
 
 
3490
        The returned section are therefore returned in the reversed order so
 
3491
        the most specific ones can be found first.
 
3492
        """
 
3493
        location_parts = self.location.rstrip('/').split('/')
 
3494
        store = self.store
 
3495
        sections = []
 
3496
        # Later sections are more specific, they should be returned first
 
3497
        for _, section in reversed(list(store.get_sections())):
 
3498
            if section.id is None:
 
3499
                # The no-name section is always included if present
 
3500
                yield store, LocationSection(section, self.location)
 
3501
                continue
 
3502
            section_path = section.id
 
3503
            if section_path.startswith('file://'):
 
3504
                # the location is already a local path or URL, convert the
 
3505
                # section id to the same format
 
3506
                section_path = urlutils.local_path_from_url(section_path)
 
3507
            if (self.location.startswith(section_path)
 
3508
                or fnmatch.fnmatch(self.location, section_path)):
 
3509
                section_parts = section_path.rstrip('/').split('/')
 
3510
                extra_path = '/'.join(location_parts[len(section_parts):])
 
3511
                yield store, LocationSection(section, extra_path)
 
3512
 
 
3513
 
2863
3514
class LocationMatcher(SectionMatcher):
2864
3515
 
2865
3516
    def __init__(self, store, location):
2876
3527
        all_sections = []
2877
3528
        # Filter out the no_name_section so _iter_for_location_by_parts can be
2878
3529
        # used (it assumes all sections have a name).
2879
 
        for section in self.store.get_sections():
 
3530
        for _, section in self.store.get_sections():
2880
3531
            if section.id is None:
2881
3532
                no_name_section = section
2882
3533
            else:
2889
3540
        matching_sections = []
2890
3541
        if no_name_section is not None:
2891
3542
            matching_sections.append(
2892
 
                LocationSection(no_name_section, 0, self.location))
 
3543
                (0, LocationSection(no_name_section, self.location)))
2893
3544
        for section_id, extra_path, length in filtered_sections:
2894
3545
            # a section id is unique for a given store so it's safe to take the
2895
3546
            # first matching section while iterating. Also, all filtered
2899
3550
                section = iter_all_sections.next()
2900
3551
                if section_id == section.id:
2901
3552
                    matching_sections.append(
2902
 
                        LocationSection(section, length, extra_path))
 
3553
                        (length, LocationSection(section, extra_path)))
2903
3554
                    break
2904
3555
        return matching_sections
2905
3556
 
2908
3559
        matching_sections = self._get_matching_sections()
2909
3560
        # We want the longest (aka more specific) locations first
2910
3561
        sections = sorted(matching_sections,
2911
 
                          key=lambda section: (section.length, section.id),
 
3562
                          key=lambda (length, section): (length, section.id),
2912
3563
                          reverse=True)
2913
3564
        # Sections mentioning 'ignore_parents' restrict the selection
2914
 
        for section in sections:
 
3565
        for _, section in sections:
2915
3566
            # FIXME: We really want to use as_bool below -- vila 2011-04-07
2916
3567
            ignore = section.get('ignore_parents', None)
2917
3568
            if ignore is not None:
2919
3570
            if ignore:
2920
3571
                break
2921
3572
            # Finally, we have a valid section
2922
 
            yield section
 
3573
            yield self.store, section
 
3574
 
 
3575
 
 
3576
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
 
3577
"""Describes an expandable option reference.
 
3578
 
 
3579
We want to match the most embedded reference first.
 
3580
 
 
3581
I.e. for '{{foo}}' we will get '{foo}',
 
3582
for '{bar{baz}}' we will get '{baz}'
 
3583
"""
 
3584
 
 
3585
def iter_option_refs(string):
 
3586
    # Split isolate refs so every other chunk is a ref
 
3587
    is_ref = False
 
3588
    for chunk  in _option_ref_re.split(string):
 
3589
        yield is_ref, chunk
 
3590
        is_ref = not is_ref
2923
3591
 
2924
3592
 
2925
3593
class Stack(object):
2926
3594
    """A stack of configurations where an option can be defined"""
2927
3595
 
2928
 
    def __init__(self, sections_def, store=None, mutable_section_name=None):
 
3596
    def __init__(self, sections_def, store=None, mutable_section_id=None):
2929
3597
        """Creates a stack of sections with an optional store for changes.
2930
3598
 
2931
3599
        :param sections_def: A list of Section or callables that returns an
2935
3603
        :param store: The optional Store where modifications will be
2936
3604
            recorded. If none is specified, no modifications can be done.
2937
3605
 
2938
 
        :param mutable_section_name: The name of the MutableSection where
2939
 
            changes are recorded. This requires the ``store`` parameter to be
 
3606
        :param mutable_section_id: The id of the MutableSection where changes
 
3607
            are recorded. This requires the ``store`` parameter to be
2940
3608
            specified.
2941
3609
        """
2942
3610
        self.sections_def = sections_def
2943
3611
        self.store = store
2944
 
        self.mutable_section_name = mutable_section_name
 
3612
        self.mutable_section_id = mutable_section_id
2945
3613
 
2946
 
    def get(self, name):
 
3614
    def get(self, name, expand=None):
2947
3615
        """Return the *first* option value found in the sections.
2948
3616
 
2949
3617
        This is where we guarantee that sections coming from Store are loaded
2951
3619
        option exists or get its value, which in turn may require to discover
2952
3620
        in which sections it can be defined. Both of these (section and option
2953
3621
        existence) require loading the store (even partially).
 
3622
 
 
3623
        :param name: The queried option.
 
3624
 
 
3625
        :param expand: Whether options references should be expanded.
 
3626
 
 
3627
        :returns: The value of the option.
2954
3628
        """
2955
3629
        # FIXME: No caching of options nor sections yet -- vila 20110503
 
3630
        if expand is None:
 
3631
            expand = _get_expand_default_value()
2956
3632
        value = None
2957
 
        # Ensuring lazy loading is achieved by delaying section matching (which
2958
 
        # implies querying the persistent storage) until it can't be avoided
2959
 
        # anymore by using callables to describe (possibly empty) section
2960
 
        # lists.
2961
 
        for section_or_callable in self.sections_def:
2962
 
            # Each section can expand to multiple ones when a callable is used
2963
 
            if callable(section_or_callable):
2964
 
                sections = section_or_callable()
2965
 
            else:
2966
 
                sections = [section_or_callable]
2967
 
            for section in sections:
2968
 
                value = section.get(name)
2969
 
                if value is not None:
2970
 
                    break
2971
 
            if value is not None:
2972
 
                break
 
3633
        found_store = None # Where the option value has been found
2973
3634
        # If the option is registered, it may provide additional info about
2974
3635
        # value handling
2975
3636
        try:
2977
3638
        except KeyError:
2978
3639
            # Not registered
2979
3640
            opt = None
2980
 
        if (opt is not None and opt.from_unicode is not None
2981
 
            and value is not None):
2982
 
            # If a value exists and the option provides a converter, use it
2983
 
            try:
2984
 
                converted = opt.from_unicode(value)
2985
 
            except (ValueError, TypeError):
2986
 
                # Invalid values are ignored
2987
 
                converted = None
2988
 
            if converted is None and opt.invalid is not None:
2989
 
                # The conversion failed
2990
 
                if opt.invalid == 'warning':
2991
 
                    trace.warning('Value "%s" is not valid for "%s"',
2992
 
                                  value, name)
2993
 
                elif opt.invalid == 'error':
2994
 
                    raise errors.ConfigOptionValueError(name, value)
2995
 
            value = converted
 
3641
 
 
3642
        def expand_and_convert(val):
 
3643
            # This may need to be called in different contexts if the value is
 
3644
            # None or ends up being None during expansion or conversion.
 
3645
            if val is not None:
 
3646
                if expand:
 
3647
                    if isinstance(val, basestring):
 
3648
                        val = self._expand_options_in_string(val)
 
3649
                    else:
 
3650
                        trace.warning('Cannot expand "%s":'
 
3651
                                      ' %s does not support option expansion'
 
3652
                                      % (name, type(val)))
 
3653
                if opt is None:
 
3654
                    val = found_store.unquote(val)
 
3655
                else:
 
3656
                    val = opt.convert_from_unicode(found_store, val)
 
3657
            return val
 
3658
 
 
3659
        # First of all, check if the environment can override the configuration
 
3660
        # value
 
3661
        if opt is not None and opt.override_from_env:
 
3662
            value = opt.get_override()
 
3663
            value = expand_and_convert(value)
2996
3664
        if value is None:
2997
 
            # If the option is registered, it may provide a default value
2998
 
            if opt is not None:
 
3665
            # Ensuring lazy loading is achieved by delaying section matching
 
3666
            # (which implies querying the persistent storage) until it can't be
 
3667
            # avoided anymore by using callables to describe (possibly empty)
 
3668
            # section lists.
 
3669
            for sections in self.sections_def:
 
3670
                for store, section in sections():
 
3671
                    value = section.get(name)
 
3672
                    if value is not None:
 
3673
                        found_store = store
 
3674
                        break
 
3675
                if value is not None:
 
3676
                    break
 
3677
            value = expand_and_convert(value)
 
3678
            if opt is not None and value is None:
 
3679
                # If the option is registered, it may provide a default value
2999
3680
                value = opt.get_default()
 
3681
                value = expand_and_convert(value)
3000
3682
        for hook in ConfigHooks['get']:
3001
3683
            hook(self, name, value)
3002
3684
        return value
3003
3685
 
 
3686
    def expand_options(self, string, env=None):
 
3687
        """Expand option references in the string in the configuration context.
 
3688
 
 
3689
        :param string: The string containing option(s) to expand.
 
3690
 
 
3691
        :param env: An option dict defining additional configuration options or
 
3692
            overriding existing ones.
 
3693
 
 
3694
        :returns: The expanded string.
 
3695
        """
 
3696
        return self._expand_options_in_string(string, env)
 
3697
 
 
3698
    def _expand_options_in_string(self, string, env=None, _refs=None):
 
3699
        """Expand options in the string in the configuration context.
 
3700
 
 
3701
        :param string: The string to be expanded.
 
3702
 
 
3703
        :param env: An option dict defining additional configuration options or
 
3704
            overriding existing ones.
 
3705
 
 
3706
        :param _refs: Private list (FIFO) containing the options being expanded
 
3707
            to detect loops.
 
3708
 
 
3709
        :returns: The expanded string.
 
3710
        """
 
3711
        if string is None:
 
3712
            # Not much to expand there
 
3713
            return None
 
3714
        if _refs is None:
 
3715
            # What references are currently resolved (to detect loops)
 
3716
            _refs = []
 
3717
        result = string
 
3718
        # We need to iterate until no more refs appear ({{foo}} will need two
 
3719
        # iterations for example).
 
3720
        expanded = True
 
3721
        while expanded:
 
3722
            expanded = False
 
3723
            chunks = []
 
3724
            for is_ref, chunk in iter_option_refs(result):
 
3725
                if not is_ref:
 
3726
                    chunks.append(chunk)
 
3727
                else:
 
3728
                    expanded = True
 
3729
                    name = chunk[1:-1]
 
3730
                    if name in _refs:
 
3731
                        raise errors.OptionExpansionLoop(string, _refs)
 
3732
                    _refs.append(name)
 
3733
                    value = self._expand_option(name, env, _refs)
 
3734
                    if value is None:
 
3735
                        raise errors.ExpandingUnknownOption(name, string)
 
3736
                    chunks.append(value)
 
3737
                    _refs.pop()
 
3738
            result = ''.join(chunks)
 
3739
        return result
 
3740
 
 
3741
    def _expand_option(self, name, env, _refs):
 
3742
        if env is not None and name in env:
 
3743
            # Special case, values provided in env takes precedence over
 
3744
            # anything else
 
3745
            value = env[name]
 
3746
        else:
 
3747
            value = self.get(name, expand=False)
 
3748
            value = self._expand_options_in_string(value, env, _refs)
 
3749
        return value
 
3750
 
3004
3751
    def _get_mutable_section(self):
3005
3752
        """Get the MutableSection for the Stack.
3006
3753
 
3007
3754
        This is where we guarantee that the mutable section is lazily loaded:
3008
3755
        this means we won't load the corresponding store before setting a value
3009
3756
        or deleting an option. In practice the store will often be loaded but
3010
 
        this allows helps catching some programming errors.
 
3757
        this helps catching some programming errors.
3011
3758
        """
3012
 
        section = self.store.get_mutable_section(self.mutable_section_name)
3013
 
        return section
 
3759
        store = self.store
 
3760
        section = store.get_mutable_section(self.mutable_section_id)
 
3761
        return store, section
3014
3762
 
3015
3763
    def set(self, name, value):
3016
3764
        """Set a new value for the option."""
3017
 
        section = self._get_mutable_section()
3018
 
        section.set(name, value)
 
3765
        store, section = self._get_mutable_section()
 
3766
        section.set(name, store.quote(value))
3019
3767
        for hook in ConfigHooks['set']:
3020
3768
            hook(self, name, value)
3021
3769
 
3022
3770
    def remove(self, name):
3023
3771
        """Remove an existing option."""
3024
 
        section = self._get_mutable_section()
 
3772
        _, section = self._get_mutable_section()
3025
3773
        section.remove(name)
3026
3774
        for hook in ConfigHooks['remove']:
3027
3775
            hook(self, name)
3030
3778
        # Mostly for debugging use
3031
3779
        return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
3032
3780
 
 
3781
    def _get_overrides(self):
 
3782
        # Hack around library_state.initialize never called
 
3783
        if bzrlib.global_state is not None:
 
3784
            return bzrlib.global_state.cmdline_overrides.get_sections()
 
3785
        return []
 
3786
 
 
3787
 
 
3788
class MemoryStack(Stack):
 
3789
    """A configuration stack defined from a string.
 
3790
 
 
3791
    This is mainly intended for tests and requires no disk resources.
 
3792
    """
 
3793
 
 
3794
    def __init__(self, content=None):
 
3795
        """Create an in-memory stack from a given content.
 
3796
 
 
3797
        It uses a single store based on configobj and support reading and
 
3798
        writing options.
 
3799
 
 
3800
        :param content: The initial content of the store. If None, the store is
 
3801
            not loaded and ``_load_from_string`` can and should be used if
 
3802
            needed.
 
3803
        """
 
3804
        store = IniFileStore()
 
3805
        if content is not None:
 
3806
            store._load_from_string(content)
 
3807
        super(MemoryStack, self).__init__(
 
3808
            [store.get_sections], store)
 
3809
 
3033
3810
 
3034
3811
class _CompatibleStack(Stack):
3035
3812
    """Place holder for compatibility with previous design.
3040
3817
    One assumption made here is that the daughter classes will all use Stores
3041
3818
    derived from LockableIniFileStore).
3042
3819
 
3043
 
    It implements set() by re-loading the store before applying the
3044
 
    modification and saving it.
 
3820
    It implements set() and remove () by re-loading the store before applying
 
3821
    the modification and saving it.
3045
3822
 
3046
3823
    The long term plan being to implement a single write by store to save
3047
3824
    all modifications, this class should not be used in the interim.
3054
3831
        # Force a write to persistent storage
3055
3832
        self.store.save()
3056
3833
 
 
3834
    def remove(self, name):
 
3835
        # Force a reload
 
3836
        self.store.unload()
 
3837
        super(_CompatibleStack, self).remove(name)
 
3838
        # Force a write to persistent storage
 
3839
        self.store.save()
 
3840
 
3057
3841
 
3058
3842
class GlobalStack(_CompatibleStack):
3059
 
    """Global options only stack."""
 
3843
    """Global options only stack.
 
3844
 
 
3845
    The following sections are queried:
 
3846
 
 
3847
    * command-line overrides,
 
3848
 
 
3849
    * the 'DEFAULT' section in bazaar.conf
 
3850
 
 
3851
    This stack will use the ``DEFAULT`` section in bazaar.conf as its
 
3852
    MutableSection.
 
3853
    """
3060
3854
 
3061
3855
    def __init__(self):
3062
 
        # Get a GlobalStore
3063
3856
        gstore = GlobalStore()
3064
 
        super(GlobalStack, self).__init__([gstore.get_sections], gstore)
 
3857
        super(GlobalStack, self).__init__(
 
3858
            [self._get_overrides,
 
3859
             NameMatcher(gstore, 'DEFAULT').get_sections],
 
3860
            gstore, mutable_section_id='DEFAULT')
3065
3861
 
3066
3862
 
3067
3863
class LocationStack(_CompatibleStack):
3068
 
    """Per-location options falling back to global options stack."""
 
3864
    """Per-location options falling back to global options stack.
 
3865
 
 
3866
 
 
3867
    The following sections are queried:
 
3868
 
 
3869
    * command-line overrides,
 
3870
 
 
3871
    * the sections matching ``location`` in ``locations.conf``, the order being
 
3872
      defined by the number of path components in the section glob, higher
 
3873
      numbers first (from most specific section to most generic).
 
3874
 
 
3875
    * the 'DEFAULT' section in bazaar.conf
 
3876
 
 
3877
    This stack will use the ``location`` section in locations.conf as its
 
3878
    MutableSection.
 
3879
    """
3069
3880
 
3070
3881
    def __init__(self, location):
3071
3882
        """Make a new stack for a location and global configuration.
3072
 
        
 
3883
 
3073
3884
        :param location: A URL prefix to """
3074
3885
        lstore = LocationStore()
3075
 
        matcher = LocationMatcher(lstore, location)
 
3886
        if location.startswith('file://'):
 
3887
            location = urlutils.local_path_from_url(location)
3076
3888
        gstore = GlobalStore()
3077
3889
        super(LocationStack, self).__init__(
3078
 
            [matcher.get_sections, gstore.get_sections], lstore)
 
3890
            [self._get_overrides,
 
3891
             LocationMatcher(lstore, location).get_sections,
 
3892
             NameMatcher(gstore, 'DEFAULT').get_sections],
 
3893
            lstore, mutable_section_id=location)
3079
3894
 
3080
3895
 
3081
3896
class BranchStack(_CompatibleStack):
3082
 
    """Per-location options falling back to branch then global options stack."""
 
3897
    """Per-location options falling back to branch then global options stack.
 
3898
 
 
3899
    The following sections are queried:
 
3900
 
 
3901
    * command-line overrides,
 
3902
 
 
3903
    * the sections matching ``location`` in ``locations.conf``, the order being
 
3904
      defined by the number of path components in the section glob, higher
 
3905
      numbers first (from most specific section to most generic),
 
3906
 
 
3907
    * the no-name section in branch.conf,
 
3908
 
 
3909
    * the ``DEFAULT`` section in ``bazaar.conf``.
 
3910
 
 
3911
    This stack will use the no-name section in ``branch.conf`` as its
 
3912
    MutableSection.
 
3913
    """
3083
3914
 
3084
3915
    def __init__(self, branch):
3085
 
        bstore = BranchStore(branch)
3086
3916
        lstore = LocationStore()
3087
 
        matcher = LocationMatcher(lstore, branch.base)
 
3917
        bstore = branch._get_config_store()
3088
3918
        gstore = GlobalStore()
3089
3919
        super(BranchStack, self).__init__(
3090
 
            [matcher.get_sections, bstore.get_sections, gstore.get_sections],
 
3920
            [self._get_overrides,
 
3921
             LocationMatcher(lstore, branch.base).get_sections,
 
3922
             NameMatcher(bstore, None).get_sections,
 
3923
             NameMatcher(gstore, 'DEFAULT').get_sections],
3091
3924
            bstore)
3092
3925
        self.branch = branch
3093
3926
 
3095
3928
class RemoteControlStack(_CompatibleStack):
3096
3929
    """Remote control-only options stack."""
3097
3930
 
 
3931
    # FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
 
3932
    # with the stack used for remote bzr dirs. RemoteControlStack only uses
 
3933
    # control.conf and is used only for stack options.
 
3934
 
3098
3935
    def __init__(self, bzrdir):
3099
 
        cstore = ControlStore(bzrdir)
 
3936
        cstore = bzrdir._get_config_store()
3100
3937
        super(RemoteControlStack, self).__init__(
3101
 
            [cstore.get_sections],
 
3938
            [NameMatcher(cstore, None).get_sections],
3102
3939
            cstore)
3103
3940
        self.bzrdir = bzrdir
3104
3941
 
3105
3942
 
3106
 
class RemoteBranchStack(_CompatibleStack):
3107
 
    """Remote branch-only options stack."""
 
3943
class BranchOnlyStack(_CompatibleStack):
 
3944
    """Branch-only options stack."""
 
3945
 
 
3946
    # FIXME: _BranchOnlyStack only uses branch.conf and is used only for the
 
3947
    # stacked_on_location options waiting for http://pad.lv/832042 to be fixed.
 
3948
    # -- vila 2011-12-16
3108
3949
 
3109
3950
    def __init__(self, branch):
3110
 
        bstore = BranchStore(branch)
3111
 
        super(RemoteBranchStack, self).__init__(
3112
 
            [bstore.get_sections],
 
3951
        bstore = branch._get_config_store()
 
3952
        super(BranchOnlyStack, self).__init__(
 
3953
            [NameMatcher(bstore, None).get_sections],
3113
3954
            bstore)
3114
3955
        self.branch = branch
3115
3956
 
3116
3957
 
 
3958
# Use a an empty dict to initialize an empty configobj avoiding all
 
3959
# parsing and encoding checks
 
3960
_quoting_config = configobj.ConfigObj(
 
3961
    {}, encoding='utf-8', interpolation=False, list_values=True)
 
3962
 
3117
3963
class cmd_config(commands.Command):
3118
3964
    __doc__ = """Display, set or remove a configuration option.
3119
3965
 
3135
3981
    takes_options = [
3136
3982
        'directory',
3137
3983
        # FIXME: This should be a registry option so that plugins can register
3138
 
        # their own config files (or not) -- vila 20101002
 
3984
        # their own config files (or not) and will also address
 
3985
        # http://pad.lv/788991 -- vila 20101115
3139
3986
        commands.Option('scope', help='Reduce the scope to the specified'
3140
 
                        ' configuration file',
 
3987
                        ' configuration file.',
3141
3988
                        type=unicode),
3142
3989
        commands.Option('all',
3143
3990
            help='Display all the defined values for the matching options.',
3144
3991
            ),
3145
3992
        commands.Option('remove', help='Remove the option from'
3146
 
                        ' the configuration file'),
 
3993
                        ' the configuration file.'),
3147
3994
        ]
3148
3995
 
3149
3996
    _see_also = ['configuration']
3179
4026
                # Set the option value
3180
4027
                self._set_config_option(name, value, directory, scope)
3181
4028
 
3182
 
    def _get_configs(self, directory, scope=None):
3183
 
        """Iterate the configurations specified by ``directory`` and ``scope``.
 
4029
    def _get_stack(self, directory, scope=None):
 
4030
        """Get the configuration stack specified by ``directory`` and ``scope``.
3184
4031
 
3185
4032
        :param directory: Where the configurations are derived from.
3186
4033
 
3187
4034
        :param scope: A specific config to start from.
3188
4035
        """
 
4036
        # FIXME: scope should allow access to plugin-specific stacks (even
 
4037
        # reduced to the plugin-specific store), related to
 
4038
        # http://pad.lv/788991 -- vila 2011-11-15
3189
4039
        if scope is not None:
3190
4040
            if scope == 'bazaar':
3191
 
                yield GlobalConfig()
 
4041
                return GlobalStack()
3192
4042
            elif scope == 'locations':
3193
 
                yield LocationConfig(directory)
 
4043
                return LocationStack(directory)
3194
4044
            elif scope == 'branch':
3195
 
                (_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
3196
 
                    directory)
3197
 
                yield br.get_config()
 
4045
                (_, br, _) = (
 
4046
                    controldir.ControlDir.open_containing_tree_or_branch(
 
4047
                        directory))
 
4048
                return br.get_config_stack()
 
4049
            raise errors.NoSuchConfig(scope)
3198
4050
        else:
3199
4051
            try:
3200
 
                (_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
3201
 
                    directory)
3202
 
                yield br.get_config()
 
4052
                (_, br, _) = (
 
4053
                    controldir.ControlDir.open_containing_tree_or_branch(
 
4054
                        directory))
 
4055
                return br.get_config_stack()
3203
4056
            except errors.NotBranchError:
3204
 
                yield LocationConfig(directory)
3205
 
                yield GlobalConfig()
 
4057
                return LocationStack(directory)
3206
4058
 
3207
4059
    def _show_value(self, name, directory, scope):
3208
 
        displayed = False
3209
 
        for c in self._get_configs(directory, scope):
3210
 
            if displayed:
3211
 
                break
3212
 
            for (oname, value, section, conf_id, parser) in c._get_options():
3213
 
                if name == oname:
3214
 
                    # Display only the first value and exit
3215
 
 
3216
 
                    # FIXME: We need to use get_user_option to take policies
3217
 
                    # into account and we need to make sure the option exists
3218
 
                    # too (hence the two for loops), this needs a better API
3219
 
                    # -- vila 20101117
3220
 
                    value = c.get_user_option(name)
3221
 
                    # Quote the value appropriately
3222
 
                    value = parser._quote(value)
3223
 
                    self.outf.write('%s\n' % (value,))
3224
 
                    displayed = True
3225
 
                    break
3226
 
        if not displayed:
 
4060
        conf = self._get_stack(directory, scope)
 
4061
        value = conf.get(name, expand=True)
 
4062
        if value is not None:
 
4063
            # Quote the value appropriately
 
4064
            value = _quoting_config._quote(value)
 
4065
            self.outf.write('%s\n' % (value,))
 
4066
        else:
3227
4067
            raise errors.NoSuchConfigOption(name)
3228
4068
 
3229
4069
    def _show_matching_options(self, name, directory, scope):
3232
4072
        # avoid the delay introduced by the lazy regexp.  But, we still do
3233
4073
        # want the nicer errors raised by lazy_regex.
3234
4074
        name._compile_and_collapse()
3235
 
        cur_conf_id = None
 
4075
        cur_store_id = None
3236
4076
        cur_section = None
3237
 
        for c in self._get_configs(directory, scope):
3238
 
            for (oname, value, section, conf_id, parser) in c._get_options():
3239
 
                if name.search(oname):
3240
 
                    if cur_conf_id != conf_id:
3241
 
                        # Explain where the options are defined
3242
 
                        self.outf.write('%s:\n' % (conf_id,))
3243
 
                        cur_conf_id = conf_id
3244
 
                        cur_section = None
3245
 
                    if (section not in (None, 'DEFAULT')
3246
 
                        and cur_section != section):
3247
 
                        # Display the section if it's not the default (or only)
3248
 
                        # one.
3249
 
                        self.outf.write('  [%s]\n' % (section,))
3250
 
                        cur_section = section
3251
 
                    self.outf.write('  %s = %s\n' % (oname, value))
 
4077
        conf = self._get_stack(directory, scope)
 
4078
        for sections in conf.sections_def:
 
4079
            for store, section in sections():
 
4080
                for oname in section.iter_option_names():
 
4081
                    if name.search(oname):
 
4082
                        if cur_store_id != store.id:
 
4083
                            # Explain where the options are defined
 
4084
                            self.outf.write('%s:\n' % (store.id,))
 
4085
                            cur_store_id = store.id
 
4086
                            cur_section = None
 
4087
                        if (section.id is not None
 
4088
                            and cur_section != section.id):
 
4089
                            # Display the section id as it appears in the store
 
4090
                            # (None doesn't appear by definition)
 
4091
                            self.outf.write('  [%s]\n' % (section.id,))
 
4092
                            cur_section = section.id
 
4093
                        value = section.get(oname, expand=False)
 
4094
                        # Since we don't use the stack, we need to restore a
 
4095
                        # proper quoting.
 
4096
                        try:
 
4097
                            opt = option_registry.get(oname)
 
4098
                            value = opt.convert_from_unicode(store, value)
 
4099
                        except KeyError:
 
4100
                            value = store.unquote(value)
 
4101
                        value = _quoting_config._quote(value)
 
4102
                        self.outf.write('  %s = %s\n' % (oname, value))
3252
4103
 
3253
4104
    def _set_config_option(self, name, value, directory, scope):
3254
 
        for conf in self._get_configs(directory, scope):
3255
 
            conf.set_user_option(name, value)
3256
 
            break
3257
 
        else:
3258
 
            raise errors.NoSuchConfig(scope)
 
4105
        conf = self._get_stack(directory, scope)
 
4106
        conf.set(name, value)
3259
4107
 
3260
4108
    def _remove_config_option(self, name, directory, scope):
3261
4109
        if name is None:
3262
4110
            raise errors.BzrCommandError(
3263
4111
                '--remove expects an option to remove.')
3264
 
        removed = False
3265
 
        for conf in self._get_configs(directory, scope):
3266
 
            for (section_name, section, conf_id) in conf._get_sections():
3267
 
                if scope is not None and conf_id != scope:
3268
 
                    # Not the right configuration file
3269
 
                    continue
3270
 
                if name in section:
3271
 
                    if conf_id != conf.config_id():
3272
 
                        conf = self._get_configs(directory, conf_id).next()
3273
 
                    # We use the first section in the first config where the
3274
 
                    # option is defined to remove it
3275
 
                    conf.remove_user_option(name, section_name)
3276
 
                    removed = True
3277
 
                    break
3278
 
            break
3279
 
        else:
3280
 
            raise errors.NoSuchConfig(scope)
3281
 
        if not removed:
 
4112
        conf = self._get_stack(directory, scope)
 
4113
        try:
 
4114
            conf.remove(name)
 
4115
        except KeyError:
3282
4116
            raise errors.NoSuchConfigOption(name)
3283
4117
 
 
4118
 
3284
4119
# Test registries
3285
4120
#
3286
4121
# We need adapters that can build a Store or a Stack in a test context. Test
3289
4124
# ready-to-use store or stack.  Plugins that define new store/stacks can also
3290
4125
# register themselves here to be tested against the tests defined in
3291
4126
# bzrlib.tests.test_config. Note that the builder can be called multiple times
3292
 
# for the same tests.
 
4127
# for the same test.
3293
4128
 
3294
4129
# The registered object should be a callable receiving a test instance
3295
4130
# parameter (inheriting from tests.TestCaseWithTransport) and returning a Store