444
@deprecated_method(deprecated_in((2, 5, 0)))
445
def get_user_option_as_int_from_SI(self, option_name, default=None):
446
"""Get a generic option from a human readable size in SI units, e.g 10MB
448
Accepted suffixes are K,M,G. It is case-insensitive and may be followed
449
by a trailing b (i.e. Kb, MB). This is intended to be practical and not
452
:return Integer, expanded to its base-10 value if a proper SI unit is
453
found. If the option doesn't exist, or isn't a value in
454
SI units, return default (which defaults to None)
456
val = self.get_user_option(option_name)
457
if isinstance(val, list):
462
p = re.compile("^(\d+)([kmg])*b*$", re.IGNORECASE)
466
val = int(m.group(1))
467
if m.group(2) is not None:
468
if m.group(2).lower() == 'k':
470
elif m.group(2).lower() == 'm':
472
elif m.group(2).lower() == 'g':
475
ui.ui_factory.show_warning(gettext('Invalid config value for "{0}" '
476
' value {1!r} is not an SI unit.').format(
483
@deprecated_method(deprecated_in((2, 5, 0)))
417
484
def gpg_signing_command(self):
418
485
"""What program should be used to sign signatures?"""
419
486
result = self._gpg_signing_command()
882
948
"""See Config.post_commit."""
883
949
return self._get_user_option('post_commit')
885
def _string_to_signature_policy(self, signature_string):
886
"""Convert a string to a signing policy."""
887
if signature_string.lower() == 'check-available':
888
return CHECK_IF_POSSIBLE
889
if signature_string.lower() == 'ignore':
891
if signature_string.lower() == 'require':
893
raise errors.BzrError("Invalid signatures policy '%s'"
896
def _string_to_signing_policy(self, signature_string):
897
"""Convert a string to a signing policy."""
898
if signature_string.lower() == 'when-required':
899
return SIGN_WHEN_REQUIRED
900
if signature_string.lower() == 'never':
902
if signature_string.lower() == 'always':
904
raise errors.BzrError("Invalid signing policy '%s'"
907
951
def _get_alias(self, value):
909
953
return self._get_parser().get_value("ALIASES",
1496
1535
TODO: Global option --config-dir to override this.
1498
base = os.environ.get('BZR_HOME', None)
1537
base = osutils.path_from_environ('BZR_HOME')
1499
1538
if sys.platform == 'win32':
1500
# environ variables on Windows are in user encoding/mbcs. So decode
1502
if base is not None:
1503
base = base.decode('mbcs')
1505
base = win32utils.get_appdata_location_unicode()
1507
base = os.environ.get('HOME', None)
1508
if base is not None:
1509
base = base.decode('mbcs')
1511
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1540
base = win32utils.get_appdata_location()
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.
1513
1545
return osutils.pathjoin(base, 'bazaar', '2.0')
1515
if base is not None:
1516
base = base.decode(osutils._fs_enc)
1517
if sys.platform == 'darwin':
1519
# this takes into account $HOME
1520
base = os.path.expanduser("~")
1521
return osutils.pathjoin(base, '.bazaar')
1524
xdg_dir = os.environ.get('XDG_CONFIG_HOME', 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')
1525
1550
if xdg_dir is None:
1526
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1551
xdg_dir = osutils.pathjoin(osutils._get_home_dir(), ".config")
1527
1552
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1528
1553
if osutils.isdir(xdg_dir):
1530
1555
"Using configuration in XDG directory %s." % xdg_dir)
1532
base = os.path.expanduser("~")
1533
return osutils.pathjoin(base, ".bazaar")
1557
base = osutils._get_home_dir()
1558
return osutils.pathjoin(base, ".bazaar")
1536
1561
def config_filename():
2274
2319
encoutered, in which config files it can be stored.
2277
def __init__(self, name, default=None, help=None, from_unicode=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):
2279
2325
"""Build an option definition.
2281
2327
:param name: the name used to refer to the option.
2329
:param override_from_env: A list of environment variables which can
2330
provide override any configuration setting.
2283
2332
:param default: the default value to use when none exist in the config
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
2339
:param default_from_env: A list of environment variables which can
2340
provide a default value. 'default' will be used only if none of the
2341
variables specified here are set in the environment.
2286
2343
:param help: a doc string to explain the option to the user.
2295
2352
TypeError. Accepted values are: None (ignore invalid values),
2296
2353
'warning' (emit a warning), 'error' (emit an error message and
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.
2361
if override_from_env is None:
2362
override_from_env = []
2363
if default_from_env is None:
2364
default_from_env = []
2299
2365
self.name = name
2300
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.
2371
elif isinstance(default, list):
2372
# Only the empty list is supported
2374
raise AssertionError(
2375
'Only empty lists are supported as default values')
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
2383
# other python objects are not expected
2384
raise AssertionError('%r is not supported as a default value'
2386
self.default_from_env = default_from_env
2301
2387
self.help = help
2302
2388
self.from_unicode = from_unicode
2389
self.unquote = unquote
2303
2390
if invalid and invalid not in ('warning', 'error'):
2304
2391
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2305
2392
self.invalid = invalid
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
2401
converted = self.from_unicode(unicode_value)
2402
except (ValueError, TypeError):
2403
# Invalid values are ignored
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)
2414
def get_override(self):
2416
for var in self.override_from_env:
2418
# If the env variable is defined, its value takes precedence
2419
value = os.environ[var].decode(osutils.get_user_encoding())
2307
2425
def get_default(self):
2427
for var in self.default_from_env:
2429
# If the env variable is defined, its value is the default one
2430
value = os.environ[var].decode(osutils.get_user_encoding())
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')
2442
value = self.default
2310
2445
def get_help_text(self, additional_see_also=None, plain=True):
2311
2446
result = self.help
2326
2461
return int(unicode_str)
2329
def list_from_store(unicode_str):
2330
# ConfigObj return '' instead of u''. Use 'str' below to catch all cases.
2331
if isinstance(unicode_str, (str, unicode)):
2333
# A single value, most probably the user forgot (or didn't care to
2334
# add) the final ','
2464
_unit_suffixes = dict(K=10**3, M=10**6, G=10**9)
2466
def int_SI_from_store(unicode_str):
2467
"""Convert a human readable size in SI units, e.g 10MB into an integer.
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
2473
:return Integer, expanded to its base-10 value if a proper SI unit is
2474
found, None otherwise.
2476
regexp = "^(\d+)(([" + ''.join(_unit_suffixes) + "])b?)?$"
2477
p = re.compile(regexp, re.IGNORECASE)
2478
m = p.match(unicode_str)
2481
val, _, unit = m.groups()
2485
coeff = _unit_suffixes[unit.upper()]
2487
raise ValueError(gettext('{0} is not an SI unit.').format(unit))
2492
def float_from_store(unicode_str):
2493
return float(unicode_str)
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)
2502
class ListOption(Option):
2504
def __init__(self, name, default=None, default_from_env=None,
2505
help=None, invalid=None):
2506
"""A list Option definition.
2508
This overrides the base class so the conversion from a unicode string
2509
can take quoting into account.
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)
2516
def from_unicode(self, unicode_str):
2517
if not isinstance(unicode_str, basestring):
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
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):
2527
# A single value, most probably the user forgot (or didn't care
2528
# to add) the final ','
2531
# The empty string, convert to empty list
2337
# The empty string, convert to empty list
2340
# We rely on ConfigObj providing us with a list already
2534
# We rely on ConfigObj providing us with a list already
2345
2539
class OptionRegistry(registry.Registry):
2386
2580
# Registered options in lexicographical order
2388
2582
option_registry.register(
2583
Option('append_revisions_only',
2584
default=None, from_unicode=bool_from_store, invalid='warning',
2586
Whether to only append revisions to the mainline.
2588
If this is set to true, then it is not possible to change the
2589
existing mainline of the branch.
2591
option_registry.register(
2592
ListOption('acceptable_keys',
2595
List of GPG key patterns which are acceptable for verification.
2597
option_registry.register(
2598
Option('add.maximum_file_size',
2599
default=u'20MB', from_unicode=int_SI_from_store,
2601
Size above which files should be added manually.
2603
Files below this size are added automatically when using ``bzr add`` without
2606
A negative value means disable the size check.
2608
option_registry.register(
2610
default=None, from_unicode=bool_from_store,
2612
Is the branch bound to ``bound_location``.
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``.
2617
See also: bound_location.
2619
option_registry.register(
2620
Option('bound_location',
2623
The location that commits should go to when acting as a checkout.
2625
This option is normally set by ``bind``.
2629
option_registry.register(
2630
Option('branch.fetch_tags', default=False, from_unicode=bool_from_store,
2632
Whether revisions associated with tags should be fetched.
2634
option_registry.register(
2389
2635
Option('bzr.workingtree.worth_saving_limit', default=10,
2390
2636
from_unicode=int_from_store, invalid='warning',
2398
2644
a file has been touched.
2400
2646
option_registry.register(
2647
Option('check_signatures', default=CHECK_IF_POSSIBLE,
2648
from_unicode=signature_policy_from_unicode,
2650
GPG checking policy.
2652
Possible values: require, ignore, check-available (default)
2654
this option will control whether bzr will require good gpg
2655
signatures, ignore them, or check them if they are
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,
2670
Possible values: always, never, when-required (default)
2672
This option controls whether bzr will always create
2673
gpg signatures or not on commits.
2675
option_registry.register(
2401
2676
Option('dirstate.fdatasync', default=True,
2402
2677
from_unicode=bool_from_store,
2408
2683
should not be lost if the machine crashes. See also repository.fdatasync.
2410
2685
option_registry.register(
2411
Option('debug_flags', default=[], from_unicode=list_from_store,
2686
ListOption('debug_flags', default=[],
2412
2687
help='Debug flags to activate.'))
2413
2688
option_registry.register(
2414
2689
Option('default_format', default='2a',
2415
2690
help='Format used when creating branches.'))
2416
2691
option_registry.register(
2692
Option('dpush_strict', default=None,
2693
from_unicode=bool_from_store,
2695
The default value for ``dpush --strict``.
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.
2701
option_registry.register(
2417
2702
Option('editor',
2418
2703
help='The command called to launch an editor to enter a message.'))
2419
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',
2711
Program to use use for creating signatures.
2713
This should support at least the -u and --clearsign options.
2715
option_registry.register(
2716
Option('gpg_signing_key',
2719
GPG key to use for signing.
2721
This defaults to the first key associated with the users email.
2723
option_registry.register(
2420
2724
Option('ignore_missing_extensions', default=False,
2421
2725
from_unicode=bool_from_store,
2440
2744
Otherwise, bzr will prompt as normal to break the lock.
2442
2746
option_registry.register(
2747
Option('log_format', default='long',
2749
Log format to use when displaying revisions.
2751
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2752
may be provided by plugins.
2754
option_registry.register(
2443
2755
Option('output_encoding',
2444
2756
help= 'Unicode encoding for output'
2445
2757
' (terminal encoding if not specified).'))
2446
2758
option_registry.register(
2447
Option('repository.fdatasync', default=True, from_unicode=bool_from_store,
2759
Option('parent_location',
2762
The location of the default branch for pull or merge.
2764
This option is normally set when creating a branch, the first ``pull`` or by
2765
``pull --remember``.
2767
option_registry.register(
2768
Option('post_commit', default=None,
2770
Post commit functions.
2772
An ordered list of python functions to call, separated by spaces.
2774
Each function takes branch, rev_id as parameters.
2776
option_registry.register(
2777
Option('public_branch',
2780
A publically-accessible version of this branch.
2782
This implies that the branch setting this option is not publically-accessible.
2783
Used and set by ``bzr send``.
2785
option_registry.register(
2786
Option('push_location',
2789
The location of the default branch for push.
2791
This option is normally set by the first ``push`` or ``push --remember``.
2793
option_registry.register(
2794
Option('push_strict', default=None,
2795
from_unicode=bool_from_store,
2797
The default value for ``push --strict``.
2799
If present, defines the ``--strict`` option default value for checking
2800
uncommitted changes before sending a merge directive.
2802
option_registry.register(
2803
Option('repository.fdatasync', default=True,
2804
from_unicode=bool_from_store,
2449
2806
Flush repository changes onto physical disk?
2452
2809
to physical disk. This is somewhat slower, but means data should not be
2453
2810
lost if the machine crashes. See also dirstate.fdatasync.
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',
2821
from_unicode=int_from_store,
2822
help='Abort selftest if one test takes longer than this many seconds',
2825
option_registry.register(
2826
Option('send_strict', default=None,
2827
from_unicode=bool_from_store,
2829
The default value for ``send --strict``.
2831
If present, defines the ``--strict`` option default value for checking
2832
uncommitted changes before sending a bundle.
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',
2843
help="""The location where this branch is stacked on."""))
2844
option_registry.register(
2845
Option('submit_branch',
2848
The branch you intend to submit your current work to.
2850
This is automatically set by ``bzr send`` and ``bzr merge``, and is also used
2851
by the ``submit:`` revision spec.
2853
option_registry.register(
2855
help='''Where submissions from this branch are mailed to.'''))
2857
option_registry.register_lazy('ssl.ca_certs',
2858
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_ca_certs')
2860
option_registry.register_lazy('ssl.cert_reqs',
2861
'bzrlib.transport.http._urllib2_wrappers', 'opt_ssl_cert_reqs')
2457
2865
class Section(object):
2499
2913
self.orig[name] = self.get(name, None)
2500
2914
del self.options[name]
2916
def reset_changes(self):
2919
def apply_changes(self, dirty, store):
2920
"""Apply option value changes.
2922
``self`` has been reloaded from the persistent storage. ``dirty``
2923
contains the changes made since the previous loading.
2925
:param dirty: the mutable section containing the changes.
2927
:param store: the store containing the section
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:
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
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,
2955
# No need to keep track of these changes
2956
self.reset_changes()
2503
2959
class Store(object):
2504
2960
"""Abstract interface to persistent storage for configuration options."""
2535
2995
raise NotImplementedError(self.unload)
2997
def quote(self, value):
2998
"""Quote a configuration option value for storing purposes.
3000
This allows Stacks to present values as they will be stored.
3004
def unquote(self, value):
3005
"""Unquote a configuration option value into unicode.
3007
The received value is quoted as stored.
2537
3011
def save(self):
2538
3012
"""Saves the Store to persistent storage."""
2539
3013
raise NotImplementedError(self.save)
3015
def _need_saving(self):
3016
for s in self.dirty_sections:
3018
# At least one dirty section contains a modification
3022
def apply_changes(self, dirty_sections):
3023
"""Apply changes from dirty sections while checking for coherency.
3025
The Store content is discarded and reloaded from persistent storage to
3026
acquire up-to-date values.
3028
Dirty sections are MutableSection which kept track of the value they
3029
are expected to update.
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.
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 = []
3042
def save_changes(self):
3043
"""Saves the Store to persistent storage if changes occurred.
3045
Apply the changes recorded in the mutable sections to a store content
3046
refreshed from persistent storage.
3048
raise NotImplementedError(self.save_changes)
2541
3050
def external_url(self):
2542
3051
raise NotImplementedError(self.external_url)
2544
3053
def get_sections(self):
2545
3054
"""Returns an ordered iterable of existing sections.
2547
:returns: An iterable of (name, dict).
3056
:returns: An iterable of (store, section).
2549
3058
raise NotImplementedError(self.get_sections)
2551
def get_mutable_section(self, section_name=None):
3060
def get_mutable_section(self, section_id=None):
2552
3061
"""Returns the specified mutable section.
2554
:param section_name: The section identifier
3063
:param section_id: The section identifier
2556
3065
raise NotImplementedError(self.get_mutable_section)
2561
3070
self.external_url())
3073
class CommandLineStore(Store):
3074
"A store to carry command line overrides for the config options."""
3076
def __init__(self, opts=None):
3077
super(CommandLineStore, self).__init__()
3084
# The dict should be cleared but not replaced so it can be shared.
3085
self.options.clear()
3087
def _from_cmdline(self, overrides):
3088
# Reset before accepting new definitions
3090
for over in overrides:
3092
name, value = over.split('=', 1)
3094
raise errors.BzrCommandError(
3095
gettext("Invalid '%s', should be of the form 'name=value'")
3097
self.options[name] = value
3099
def external_url(self):
3100
# Not an url but it makes debugging easier and is never needed
3104
def get_sections(self):
3105
yield self, self.readonly_section_class(None, self.options)
2564
3108
class IniFileStore(Store):
2565
3109
"""A config Store using ConfigObj for storage.
2567
:ivar transport: The transport object where the config file is located.
2569
:ivar file_name: The config file basename in the transport directory.
2571
3111
:ivar _config_obj: Private member to hold the ConfigObj instance used to
2572
3112
serialize/deserialize the config file.
2575
def __init__(self, transport, file_name):
2576
3116
"""A config Store using ConfigObj for storage.
2578
:param transport: The transport object where the config file is located.
2580
:param file_name: The config file basename in the transport directory.
2582
3118
super(IniFileStore, self).__init__()
2583
self.transport = transport
2584
self.file_name = file_name
2585
3119
self._config_obj = None
2587
3121
def is_loaded(self):
2609
3162
co_input = StringIO(bytes)
2611
3164
# The config files are always stored utf8-encoded
2612
self._config_obj = ConfigObj(co_input, encoding='utf-8')
3165
self._config_obj = ConfigObj(co_input, encoding='utf-8',
2613
3167
except configobj.ConfigObjError, e:
2614
3168
self._config_obj = None
2615
3169
raise errors.ParseConfigError(e.errors, self.external_url())
2616
3170
except UnicodeDecodeError:
2617
3171
raise errors.ConfigContentError(self.external_url())
3173
def save_changes(self):
3174
if not self.is_loaded():
3177
if not self._need_saving():
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
2619
3186
def save(self):
2620
3187
if not self.is_loaded():
2621
3188
# Nothing to save
2623
3190
out = StringIO()
2624
3191
self._config_obj.write(out)
2625
self.transport.put_bytes(self.file_name, out.getvalue())
3192
self._save_content(out.getvalue())
2626
3193
for hook in ConfigHooks['save']:
2629
def external_url(self):
2630
# FIXME: external_url should really accepts an optional relpath
2631
# parameter (bug #750169) :-/ -- vila 2011-04-04
2632
# The following will do in the interim but maybe we don't want to
2633
# expose a path here but rather a config ID and its associated
2634
# object </hand wawe>.
2635
return urlutils.join(self.transport.external_url(), self.file_name)
2637
3196
def get_sections(self):
2638
3197
"""Get the configobj section in the file order.
2640
:returns: An iterable of (name, dict).
3199
:returns: An iterable of (store, section).
2642
3201
# We need a loaded store
2645
except errors.NoSuchFile:
2646
# 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
2648
3207
cobj = self._config_obj
2649
3208
if cobj.scalars:
2650
yield self.readonly_section_class(None, cobj)
3209
yield self, self.readonly_section_class(None, cobj)
2651
3210
for section_name in cobj.sections:
2652
yield self.readonly_section_class(section_name, cobj[section_name])
3212
self.readonly_section_class(section_name,
3213
cobj[section_name]))
2654
def get_mutable_section(self, section_name=None):
3215
def get_mutable_section(self, section_id=None):
2655
3216
# We need a loaded store
2658
3219
except errors.NoSuchFile:
2659
3220
# The file doesn't exist, let's pretend it was empty
2660
3221
self._load_from_string('')
2661
if section_name is None:
3222
if section_id is None:
2662
3223
section = self._config_obj
2664
section = self._config_obj.setdefault(section_name, {})
2665
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
3231
def quote(self, value):
3233
# configobj conflates automagical list values and quoting
3234
self._config_obj.list_values = True
3235
return self._config_obj._quote(value)
3237
self._config_obj.list_values = False
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)
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
3251
return 'In-Process Store, no URL'
3253
class TransportIniFileStore(IniFileStore):
3254
"""IniFileStore that loads files from a transport.
3256
:ivar transport: The transport object where the config file is located.
3258
:ivar file_name: The config file basename in the transport directory.
3261
def __init__(self, transport, file_name):
3262
"""A Store using a ini file on a Transport
3264
:param transport: The transport object where the config file is located.
3265
:param file_name: The config file basename in the transport directory.
3267
super(TransportIniFileStore, self).__init__()
3268
self.transport = transport
3269
self.file_name = file_name
3271
def _load_content(self):
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())
3279
def _save_content(self, content):
3280
self.transport.put_bytes(self.file_name, content)
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)
2668
3291
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
2775
3410
sections = self.store.get_sections()
2776
3411
# Walk the revisions in the order provided
3412
for store, s in sections:
2778
3413
if self.match(s):
2781
def match(self, secion):
3416
def match(self, section):
3417
"""Does the proposed section match.
3419
:param section: A Section object.
3421
:returns: True if the section matches, False otherwise.
2782
3423
raise NotImplementedError(self.match)
3426
class NameMatcher(SectionMatcher):
3428
def __init__(self, store, section_id):
3429
super(NameMatcher, self).__init__(store)
3430
self.section_id = section_id
3432
def match(self, section):
3433
return section.id == self.section_id
2785
3436
class LocationSection(Section):
2787
def __init__(self, section, length, extra_path):
3438
def __init__(self, section, extra_path):
2788
3439
super(LocationSection, self).__init__(section.id, section.options)
2789
self.length = length
2790
3440
self.extra_path = extra_path
3441
self.locals = {'relpath': extra_path,
3442
'basename': urlutils.basename(extra_path)}
2792
def get(self, name, default=None):
3444
def get(self, name, default=None, expand=True):
2793
3445
value = super(LocationSection, self).get(name, default)
2794
if value is not None:
3446
if value is not None and expand:
2795
3447
policy_name = self.get(name + ':policy', None)
2796
3448
policy = _policy_value.get(policy_name, POLICY_NONE)
2797
3449
if policy == POLICY_APPENDPATH:
2798
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).
3454
for is_ref, chunk in iter_option_refs(value):
3456
chunks.append(chunk)
3459
if ref in self.locals:
3460
chunks.append(self.locals[ref])
3462
chunks.append(chunk)
3463
value = ''.join(chunks)
3467
class StartingPathMatcher(SectionMatcher):
3468
"""Select sections for a given location respecting the Store order."""
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
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
3484
def get_sections(self):
3485
"""Get all sections matching ``location`` in the store.
3487
The most generic sections are described first in the store, then more
3488
specific ones can be provided for reduced scopes.
3490
The returned section are therefore returned in the reversed order so
3491
the most specific ones can be found first.
3493
location_parts = self.location.rstrip('/').split('/')
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)
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)
2802
3514
class LocationMatcher(SectionMatcher):
2804
3516
def __init__(self, store, location):
2812
3524
# We slightly diverge from LocalConfig here by allowing the no-name
2813
3525
# section as the most generic one and the lower priority.
2814
3526
no_name_section = None
2816
3528
# Filter out the no_name_section so _iter_for_location_by_parts can be
2817
3529
# used (it assumes all sections have a name).
2818
for section in self.store.get_sections():
3530
for _, section in self.store.get_sections():
2819
3531
if section.id is None:
2820
3532
no_name_section = section
2822
sections.append(section)
3534
all_sections.append(section)
2823
3535
# Unfortunately _iter_for_location_by_parts deals with section names so
2824
3536
# we have to resync.
2825
3537
filtered_sections = _iter_for_location_by_parts(
2826
[s.id for s in sections], self.location)
2827
iter_sections = iter(sections)
3538
[s.id for s in all_sections], self.location)
3539
iter_all_sections = iter(all_sections)
2828
3540
matching_sections = []
2829
3541
if no_name_section is not None:
2830
3542
matching_sections.append(
2831
LocationSection(no_name_section, 0, self.location))
3543
(0, LocationSection(no_name_section, self.location)))
2832
3544
for section_id, extra_path, length in filtered_sections:
2833
# a section id is unique for a given store so it's safe to iterate
2835
section = iter_sections.next()
2836
if section_id == section.id:
2837
matching_sections.append(
2838
LocationSection(section, length, extra_path))
3545
# a section id is unique for a given store so it's safe to take the
3546
# first matching section while iterating. Also, all filtered
3547
# sections are part of 'all_sections' and will always be found
3550
section = iter_all_sections.next()
3551
if section_id == section.id:
3552
matching_sections.append(
3553
(length, LocationSection(section, extra_path)))
2839
3555
return matching_sections
2841
3557
def get_sections(self):
2856
3572
# Finally, we have a valid section
3573
yield self.store, section
3576
_option_ref_re = lazy_regex.lazy_compile('({[^{}\n]+})')
3577
"""Describes an expandable option reference.
3579
We want to match the most embedded reference first.
3581
I.e. for '{{foo}}' we will get '{foo}',
3582
for '{bar{baz}}' we will get '{baz}'
3585
def iter_option_refs(string):
3586
# Split isolate refs so every other chunk is a ref
3588
for chunk in _option_ref_re.split(string):
2860
3593
class Stack(object):
2861
3594
"""A stack of configurations where an option can be defined"""
2863
def __init__(self, sections_def, store=None, mutable_section_name=None):
3596
def __init__(self, sections_def, store=None, mutable_section_id=None):
2864
3597
"""Creates a stack of sections with an optional store for changes.
2866
3599
:param sections_def: A list of Section or callables that returns an
2886
3619
option exists or get its value, which in turn may require to discover
2887
3620
in which sections it can be defined. Both of these (section and option
2888
3621
existence) require loading the store (even partially).
3623
:param name: The queried option.
3625
:param expand: Whether options references should be expanded.
3627
:returns: The value of the option.
2890
3629
# FIXME: No caching of options nor sections yet -- vila 20110503
3631
expand = _get_expand_default_value()
2892
# Ensuring lazy loading is achieved by delaying section matching (which
2893
# implies querying the persistent storage) until it can't be avoided
2894
# anymore by using callables to describe (possibly empty) section
2896
for section_or_callable in self.sections_def:
2897
# Each section can expand to multiple ones when a callable is used
2898
if callable(section_or_callable):
2899
sections = section_or_callable()
2901
sections = [section_or_callable]
2902
for section in sections:
2903
value = section.get(name)
2904
if value is not None:
2906
if value is not None:
3633
found_store = None # Where the option value has been found
2908
3634
# If the option is registered, it may provide additional info about
2909
3635
# value handling
2912
3638
except KeyError:
2913
3639
# Not registered
2915
if (opt is not None and opt.from_unicode is not None
2916
and value is not None):
2917
# If a value exists and the option provides a converter, use it
2919
converted = opt.from_unicode(value)
2920
except (ValueError, TypeError):
2921
# Invalid values are ignored
2923
if converted is None and opt.invalid is not None:
2924
# The conversion failed
2925
if opt.invalid == 'warning':
2926
trace.warning('Value "%s" is not valid for "%s"',
2928
elif opt.invalid == 'error':
2929
raise errors.ConfigOptionValueError(name, value)
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.
3647
if isinstance(val, basestring):
3648
val = self._expand_options_in_string(val)
3650
trace.warning('Cannot expand "%s":'
3651
' %s does not support option expansion'
3652
% (name, type(val)))
3654
val = found_store.unquote(val)
3656
val = opt.convert_from_unicode(found_store, val)
3659
# First of all, check if the environment can override the configuration
3661
if opt is not None and opt.override_from_env:
3662
value = opt.get_override()
3663
value = expand_and_convert(value)
2931
3664
if value is None:
2932
# If the option is registered, it may provide a default value
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)
3669
for sections in self.sections_def:
3670
for store, section in sections():
3671
value = section.get(name)
3672
if value is not None:
3675
if value is not None:
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
2934
3680
value = opt.get_default()
3681
value = expand_and_convert(value)
2935
3682
for hook in ConfigHooks['get']:
2936
3683
hook(self, name, value)
3686
def expand_options(self, string, env=None):
3687
"""Expand option references in the string in the configuration context.
3689
:param string: The string containing option(s) to expand.
3691
:param env: An option dict defining additional configuration options or
3692
overriding existing ones.
3694
:returns: The expanded string.
3696
return self._expand_options_in_string(string, env)
3698
def _expand_options_in_string(self, string, env=None, _refs=None):
3699
"""Expand options in the string in the configuration context.
3701
:param string: The string to be expanded.
3703
:param env: An option dict defining additional configuration options or
3704
overriding existing ones.
3706
:param _refs: Private list (FIFO) containing the options being expanded
3709
:returns: The expanded string.
3712
# Not much to expand there
3715
# What references are currently resolved (to detect loops)
3718
# We need to iterate until no more refs appear ({{foo}} will need two
3719
# iterations for example).
3724
for is_ref, chunk in iter_option_refs(result):
3726
chunks.append(chunk)
3731
raise errors.OptionExpansionLoop(string, _refs)
3733
value = self._expand_option(name, env, _refs)
3735
raise errors.ExpandingUnknownOption(name, string)
3736
chunks.append(value)
3738
result = ''.join(chunks)
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
3747
value = self.get(name, expand=False)
3748
value = self._expand_options_in_string(value, env, _refs)
2939
3751
def _get_mutable_section(self):
2940
3752
"""Get the MutableSection for the Stack.
2942
3754
This is where we guarantee that the mutable section is lazily loaded:
2943
3755
this means we won't load the corresponding store before setting a value
2944
3756
or deleting an option. In practice the store will often be loaded but
2945
this allows helps catching some programming errors.
3757
this helps catching some programming errors.
2947
section = self.store.get_mutable_section(self.mutable_section_name)
3760
section = store.get_mutable_section(self.mutable_section_id)
3761
return store, section
2950
3763
def set(self, name, value):
2951
3764
"""Set a new value for the option."""
2952
section = self._get_mutable_section()
2953
section.set(name, value)
3765
store, section = self._get_mutable_section()
3766
section.set(name, store.quote(value))
2954
3767
for hook in ConfigHooks['set']:
2955
3768
hook(self, name, value)
2957
3770
def remove(self, name):
2958
3771
"""Remove an existing option."""
2959
section = self._get_mutable_section()
3772
_, section = self._get_mutable_section()
2960
3773
section.remove(name)
2961
3774
for hook in ConfigHooks['remove']:
2962
3775
hook(self, name)
2965
3778
# Mostly for debugging use
2966
3779
return "<config.%s(%s)>" % (self.__class__.__name__, id(self))
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()
3788
class MemoryStack(Stack):
3789
"""A configuration stack defined from a string.
3791
This is mainly intended for tests and requires no disk resources.
3794
def __init__(self, content=None):
3795
"""Create an in-memory stack from a given content.
3797
It uses a single store based on configobj and support reading and
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
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)
2969
3811
class _CompatibleStack(Stack):
2970
3812
"""Place holder for compatibility with previous design.
2989
3831
# Force a write to persistent storage
2990
3832
self.store.save()
3834
def remove(self, name):
3837
super(_CompatibleStack, self).remove(name)
3838
# Force a write to persistent storage
2993
3842
class GlobalStack(_CompatibleStack):
3843
"""Global options only stack.
3845
The following sections are queried:
3847
* command-line overrides,
3849
* the 'DEFAULT' section in bazaar.conf
3851
This stack will use the ``DEFAULT`` section in bazaar.conf as its
2995
3855
def __init__(self):
2997
3856
gstore = GlobalStore()
2998
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')
3001
3863
class LocationStack(_CompatibleStack):
3864
"""Per-location options falling back to global options stack.
3867
The following sections are queried:
3869
* command-line overrides,
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).
3875
* the 'DEFAULT' section in bazaar.conf
3877
This stack will use the ``location`` section in locations.conf as its
3003
3881
def __init__(self, location):
3004
3882
"""Make a new stack for a location and global configuration.
3006
3884
:param location: A URL prefix to """
3007
3885
lstore = LocationStore()
3008
matcher = LocationMatcher(lstore, location)
3886
if location.startswith('file://'):
3887
location = urlutils.local_path_from_url(location)
3009
3888
gstore = GlobalStore()
3010
3889
super(LocationStack, self).__init__(
3011
[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)
3013
3896
class BranchStack(_CompatibleStack):
3897
"""Per-location options falling back to branch then global options stack.
3899
The following sections are queried:
3901
* command-line overrides,
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),
3907
* the no-name section in branch.conf,
3909
* the ``DEFAULT`` section in ``bazaar.conf``.
3911
This stack will use the no-name section in ``branch.conf`` as its
3015
3915
def __init__(self, branch):
3016
bstore = BranchStore(branch)
3017
3916
lstore = LocationStore()
3018
matcher = LocationMatcher(lstore, branch.base)
3917
bstore = branch._get_config_store()
3019
3918
gstore = GlobalStore()
3020
3919
super(BranchStack, self).__init__(
3021
[matcher.get_sections, bstore.get_sections, gstore.get_sections],
3023
self.branch = branch
3920
[self._get_overrides,
3921
LocationMatcher(lstore, branch.base).get_sections,
3922
NameMatcher(bstore, None).get_sections,
3923
NameMatcher(gstore, 'DEFAULT').get_sections],
3925
self.branch = branch
3928
class RemoteControlStack(_CompatibleStack):
3929
"""Remote control-only options stack."""
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.
3935
def __init__(self, bzrdir):
3936
cstore = bzrdir._get_config_store()
3937
super(RemoteControlStack, self).__init__(
3938
[NameMatcher(cstore, None).get_sections],
3940
self.bzrdir = bzrdir
3943
class BranchOnlyStack(_CompatibleStack):
3944
"""Branch-only options stack."""
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
3950
def __init__(self, branch):
3951
bstore = branch._get_config_store()
3952
super(BranchOnlyStack, self).__init__(
3953
[NameMatcher(bstore, None).get_sections],
3955
self.branch = branch
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)
3026
3963
class cmd_config(commands.Command):
3027
3964
__doc__ = """Display, set or remove a configuration option.
3088
4026
# Set the option value
3089
4027
self._set_config_option(name, value, directory, scope)
3091
def _get_configs(self, directory, scope=None):
3092
"""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``.
3094
4032
:param directory: Where the configurations are derived from.
3096
4034
:param scope: A specific config to start from.
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
3098
4039
if scope is not None:
3099
4040
if scope == 'bazaar':
3100
yield GlobalConfig()
4041
return GlobalStack()
3101
4042
elif scope == 'locations':
3102
yield LocationConfig(directory)
4043
return LocationStack(directory)
3103
4044
elif scope == 'branch':
3104
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
3106
yield br.get_config()
4046
controldir.ControlDir.open_containing_tree_or_branch(
4048
return br.get_config_stack()
4049
raise errors.NoSuchConfig(scope)
3109
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
3111
yield br.get_config()
4053
controldir.ControlDir.open_containing_tree_or_branch(
4055
return br.get_config_stack()
3112
4056
except errors.NotBranchError:
3113
yield LocationConfig(directory)
3114
yield GlobalConfig()
4057
return LocationStack(directory)
3116
4059
def _show_value(self, name, directory, scope):
3118
for c in self._get_configs(directory, scope):
3121
for (oname, value, section, conf_id, parser) in c._get_options():
3123
# Display only the first value and exit
3125
# FIXME: We need to use get_user_option to take policies
3126
# into account and we need to make sure the option exists
3127
# too (hence the two for loops), this needs a better API
3129
value = c.get_user_option(name)
3130
# Quote the value appropriately
3131
value = parser._quote(value)
3132
self.outf.write('%s\n' % (value,))
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,))
3136
4067
raise errors.NoSuchConfigOption(name)
3138
4069
def _show_matching_options(self, name, directory, scope):
3141
4072
# avoid the delay introduced by the lazy regexp. But, we still do
3142
4073
# want the nicer errors raised by lazy_regex.
3143
4074
name._compile_and_collapse()
3145
4076
cur_section = None
3146
for c in self._get_configs(directory, scope):
3147
for (oname, value, section, conf_id, parser) in c._get_options():
3148
if name.search(oname):
3149
if cur_conf_id != conf_id:
3150
# Explain where the options are defined
3151
self.outf.write('%s:\n' % (conf_id,))
3152
cur_conf_id = conf_id
3154
if (section not in (None, 'DEFAULT')
3155
and cur_section != section):
3156
# Display the section if it's not the default (or only)
3158
self.outf.write(' [%s]\n' % (section,))
3159
cur_section = section
3160
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
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
4097
opt = option_registry.get(oname)
4098
value = opt.convert_from_unicode(store, value)
4100
value = store.unquote(value)
4101
value = _quoting_config._quote(value)
4102
self.outf.write(' %s = %s\n' % (oname, value))
3162
4104
def _set_config_option(self, name, value, directory, scope):
3163
for conf in self._get_configs(directory, scope):
3164
conf.set_user_option(name, value)
3167
raise errors.NoSuchConfig(scope)
4105
conf = self._get_stack(directory, scope)
4106
conf.set(name, value)
3169
4108
def _remove_config_option(self, name, directory, scope):
3170
4109
if name is None:
3171
4110
raise errors.BzrCommandError(
3172
4111
'--remove expects an option to remove.')
3174
for conf in self._get_configs(directory, scope):
3175
for (section_name, section, conf_id) in conf._get_sections():
3176
if scope is not None and conf_id != scope:
3177
# Not the right configuration file
3180
if conf_id != conf.config_id():
3181
conf = self._get_configs(directory, conf_id).next()
3182
# We use the first section in the first config where the
3183
# option is defined to remove it
3184
conf.remove_user_option(name, section_name)
3189
raise errors.NoSuchConfig(scope)
4112
conf = self._get_stack(directory, scope)
3191
4116
raise errors.NoSuchConfigOption(name)
3193
4119
# Test registries
3195
4121
# We need adapters that can build a Store or a Stack in a test context. Test
added
removed
bzrlib/config.py
