2318
2271
The option *values* are stored in config files and found in sections.
2320
2273
Here we define various properties about the option itself, its default
2321
value, how to convert it from stores, what to do when invalid values are
2322
encoutered, in which config files it can be stored.
2274
value, in which config files it can be stored, etc (TBC).
2325
def __init__(self, name, default=None, default_from_env=None,
2327
from_unicode=None, invalid=None):
2328
"""Build an option definition.
2330
:param name: the name used to refer to the option.
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 or a python object that can be stringified (so
2335
only the empty list is supported for example).
2337
:param default_from_env: A list of environment variables which can
2338
provide a default value. 'default' will be used only if none of the
2339
variables specified here are set in the environment.
2341
:param help: a doc string to explain the option to the user.
2343
:param from_unicode: a callable to convert the unicode string
2344
representing the option value in a store. This is not called for
2347
:param invalid: the action to be taken when an invalid value is
2348
encountered in a store. This is called only when from_unicode is
2349
invoked to convert a string and returns None or raise ValueError or
2350
TypeError. Accepted values are: None (ignore invalid values),
2351
'warning' (emit a warning), 'error' (emit an error message and
2354
if default_from_env is None:
2355
default_from_env = []
2277
def __init__(self, name, default=None):
2356
2278
self.name = name
2357
# Convert the default value to a unicode string so all values are
2358
# strings internally before conversion (via from_unicode) is attempted.
2361
elif isinstance(default, list):
2362
# Only the empty list is supported
2364
raise AssertionError(
2365
'Only empty lists are supported as default values')
2367
elif isinstance(default, (str, unicode, bool, int, float)):
2368
# Rely on python to convert strings, booleans and integers
2369
self.default = u'%s' % (default,)
2371
# other python objects are not expected
2372
raise AssertionError('%r is not supported as a default value'
2374
self.default_from_env = default_from_env
2376
self.from_unicode = from_unicode
2377
if invalid and invalid not in ('warning', 'error'):
2378
raise AssertionError("%s not supported for 'invalid'" % (invalid,))
2379
self.invalid = invalid
2381
def convert_from_unicode(self, unicode_value):
2382
if self.from_unicode is None or unicode_value is None:
2383
# Don't convert or nothing to convert
2384
return unicode_value
2386
converted = self.from_unicode(unicode_value)
2387
except (ValueError, TypeError):
2388
# Invalid values are ignored
2390
if converted is None and self.invalid is not None:
2391
# The conversion failed
2392
if self.invalid == 'warning':
2393
trace.warning('Value "%s" is not valid for "%s"',
2394
unicode_value, self.name)
2395
elif self.invalid == 'error':
2396
raise errors.ConfigOptionValueError(self.name, unicode_value)
2279
self.default = default
2399
2281
def get_default(self):
2401
for var in self.default_from_env:
2403
# If the env variable is defined, its value is the default one
2404
value = os.environ[var]
2409
# Otherwise, fallback to the value defined at registration
2410
value = self.default
2413
def get_help_text(self, additional_see_also=None, plain=True):
2415
from bzrlib import help_topics
2416
result += help_topics._format_see_also(additional_see_also)
2418
result = help_topics.help_as_plain_text(result)
2422
# Predefined converters to get proper values from store
2424
def bool_from_store(unicode_str):
2425
return ui.bool_from_string(unicode_str)
2428
def int_from_store(unicode_str):
2429
return int(unicode_str)
2432
def float_from_store(unicode_str):
2433
return float(unicode_str)
2437
# Use a an empty dict to initialize an empty configobj avoiding all
2438
# parsing and encoding checks
2439
_list_converter_config = configobj.ConfigObj(
2440
{}, encoding='utf-8', list_values=True, interpolation=False)
2443
def list_from_store(unicode_str):
2444
if not isinstance(unicode_str, basestring):
2446
# Now inject our string directly as unicode. All callers got their value
2447
# from configobj, so values that need to be quoted are already properly
2449
_list_converter_config.reset()
2450
_list_converter_config._parse([u"list=%s" % (unicode_str,)])
2451
maybe_list = _list_converter_config['list']
2452
# ConfigObj return '' instead of u''. Use 'str' below to catch all cases.
2453
if isinstance(maybe_list, basestring):
2455
# A single value, most probably the user forgot (or didn't care to
2456
# add) the final ','
2459
# The empty string, convert to empty list
2462
# We rely on ConfigObj providing us with a list already
2467
class OptionRegistry(registry.Registry):
2468
"""Register config options by their name.
2470
This overrides ``registry.Registry`` to simplify registration by acquiring
2471
some information from the option object itself.
2474
def register(self, option):
2475
"""Register a new option to its name.
2477
:param option: The option to register. Its name is used as the key.
2479
super(OptionRegistry, self).register(option.name, option,
2482
def register_lazy(self, key, module_name, member_name):
2483
"""Register a new option to be loaded on request.
2485
:param key: the key to request the option later. Since the registration
2486
is lazy, it should be provided and match the option name.
2488
:param module_name: the python path to the module. Such as 'os.path'.
2490
:param member_name: the member of the module to return. If empty or
2491
None, get() will return the module itself.
2493
super(OptionRegistry, self).register_lazy(key,
2494
module_name, member_name)
2496
def get_help(self, key=None):
2497
"""Get the help text associated with the given key"""
2498
option = self.get(key)
2499
the_help = option.help
2500
if callable(the_help):
2501
return the_help(self, key)
2505
option_registry = OptionRegistry()
2508
# Registered options in lexicographical order
2510
option_registry.register(
2511
Option('bzr.workingtree.worth_saving_limit', default=10,
2512
from_unicode=int_from_store, invalid='warning',
2514
How many changes before saving the dirstate.
2516
-1 means that we will never rewrite the dirstate file for only
2517
stat-cache changes. Regardless of this setting, we will always rewrite
2518
the dirstate file if a file is added/removed/renamed/etc. This flag only
2519
affects the behavior of updating the dirstate file after we notice that
2520
a file has been touched.
2522
option_registry.register(
2523
Option('dirstate.fdatasync', default=True,
2524
from_unicode=bool_from_store,
2526
Flush dirstate changes onto physical disk?
2528
If true (default), working tree metadata changes are flushed through the
2529
OS buffers to physical disk. This is somewhat slower, but means data
2530
should not be lost if the machine crashes. See also repository.fdatasync.
2532
option_registry.register(
2533
Option('debug_flags', default=[], from_unicode=list_from_store,
2534
help='Debug flags to activate.'))
2535
option_registry.register(
2536
Option('default_format', default='2a',
2537
help='Format used when creating branches.'))
2538
option_registry.register(
2539
Option('dpush_strict', default=None,
2540
from_unicode=bool_from_store,
2542
The default value for ``dpush --strict``.
2544
If present, defines the ``--strict`` option default value for checking
2545
uncommitted changes before pushing into a different VCS without any
2546
custom bzr metadata.
2548
option_registry.register(
2550
help='The command called to launch an editor to enter a message.'))
2551
option_registry.register(
2552
Option('ignore_missing_extensions', default=False,
2553
from_unicode=bool_from_store,
2555
Control the missing extensions warning display.
2557
The warning will not be emitted if set to True.
2559
option_registry.register(
2561
help='Language to translate messages into.'))
2562
option_registry.register(
2563
Option('locks.steal_dead', default=False, from_unicode=bool_from_store,
2565
Steal locks that appears to be dead.
2567
If set to True, bzr will check if a lock is supposed to be held by an
2568
active process from the same user on the same machine. If the user and
2569
machine match, but no process with the given PID is active, then bzr
2570
will automatically break the stale lock, and create a new lock for
2572
Otherwise, bzr will prompt as normal to break the lock.
2574
option_registry.register(
2575
Option('log_format', default='long',
2577
Log format to use when displaying revisions.
2579
Standard log formats are ``long``, ``short`` and ``line``. Additional formats
2580
may be provided by plugins.
2582
option_registry.register(
2583
Option('output_encoding',
2584
help= 'Unicode encoding for output'
2585
' (terminal encoding if not specified).'))
2586
option_registry.register(
2587
Option('push_strict', default=None,
2588
from_unicode=bool_from_store,
2590
The default value for ``push --strict``.
2592
If present, defines the ``--strict`` option default value for checking
2593
uncommitted changes before sending a merge directive.
2595
option_registry.register(
2596
Option('repository.fdatasync', default=True,
2597
from_unicode=bool_from_store,
2599
Flush repository changes onto physical disk?
2601
If true (default), repository changes are flushed through the OS buffers
2602
to physical disk. This is somewhat slower, but means data should not be
2603
lost if the machine crashes. See also dirstate.fdatasync.
2606
option_registry.register(
2607
Option('selftest.timeout',
2609
from_unicode=int_from_store,
2610
help='Abort selftest if one test takes longer than this many seconds',
2613
option_registry.register(
2614
Option('send_strict', default=None,
2615
from_unicode=bool_from_store,
2617
The default value for ``send --strict``.
2619
If present, defines the ``--strict`` option default value for checking
2620
uncommitted changes before pushing.
2623
option_registry.register(
2624
Option('serve.client_timeout',
2625
default=300.0, from_unicode=float_from_store,
2626
help="If we wait for a new request from a client for more than"
2627
" X seconds, consider the client idle, and hangup."))
2287
option_registry = registry.Registry()
2290
option_registry.register(
2291
'editor', Option('editor'),
2292
help='The command called to launch an editor to enter a message.')
2294
option_registry.register(
2295
'dirstate.fdatasync', Option('dirstate.fdatasync', default=True),
2296
help='Flush dirstate changes onto physical disk?')
2298
option_registry.register(
2299
'repository.fdatasync',
2300
Option('repository.fdatasync', default=True),
2301
help='Flush repository changes onto physical disk?')
2630
2304
class Section(object):
2848
2470
out = StringIO()
2849
2471
self._config_obj.write(out)
2850
self._save_content(out.getvalue())
2472
self.transport.put_bytes(self.file_name, out.getvalue())
2851
2473
for hook in ConfigHooks['save']:
2476
def external_url(self):
2477
# FIXME: external_url should really accepts an optional relpath
2478
# parameter (bug #750169) :-/ -- vila 2011-04-04
2479
# The following will do in the interim but maybe we don't want to
2480
# expose a path here but rather a config ID and its associated
2481
# object </hand wawe>.
2482
return urlutils.join(self.transport.external_url(), self.file_name)
2854
2484
def get_sections(self):
2855
2485
"""Get the configobj section in the file order.
2857
:returns: An iterable of (store, section).
2487
:returns: An iterable of (name, dict).
2859
2489
# We need a loaded store
2862
except (errors.NoSuchFile, errors.PermissionDenied):
2863
# If the file can't be read, there is no sections
2492
except errors.NoSuchFile:
2493
# If the file doesn't exist, there is no sections
2865
2495
cobj = self._config_obj
2866
2496
if cobj.scalars:
2867
yield self, self.readonly_section_class(None, cobj)
2497
yield self.readonly_section_class(None, cobj)
2868
2498
for section_name in cobj.sections:
2870
self.readonly_section_class(section_name,
2871
cobj[section_name]))
2499
yield self.readonly_section_class(section_name, cobj[section_name])
2873
def get_mutable_section(self, section_id=None):
2501
def get_mutable_section(self, section_name=None):
2874
2502
# We need a loaded store
2877
2505
except errors.NoSuchFile:
2878
2506
# The file doesn't exist, let's pretend it was empty
2879
2507
self._load_from_string('')
2880
if section_id is None:
2508
if section_name is None:
2881
2509
section = self._config_obj
2883
section = self._config_obj.setdefault(section_id, {})
2884
return self.mutable_section_class(section_id, section)
2887
class TransportIniFileStore(IniFileStore):
2888
"""IniFileStore that loads files from a transport.
2891
def __init__(self, transport, file_name):
2892
"""A Store using a ini file on a Transport
2894
:param transport: The transport object where the config file is located.
2895
:param file_name: The config file basename in the transport directory.
2897
super(TransportIniFileStore, self).__init__()
2898
self.transport = transport
2899
self.file_name = file_name
2901
def _load_content(self):
2903
return self.transport.get_bytes(self.file_name)
2904
except errors.PermissionDenied:
2905
trace.warning("Permission denied while trying to load "
2906
"configuration store %s.", self.external_url())
2909
def _save_content(self, content):
2910
self.transport.put_bytes(self.file_name, content)
2912
def external_url(self):
2913
# FIXME: external_url should really accepts an optional relpath
2914
# parameter (bug #750169) :-/ -- vila 2011-04-04
2915
# The following will do in the interim but maybe we don't want to
2916
# expose a path here but rather a config ID and its associated
2917
# object </hand wawe>.
2918
return urlutils.join(self.transport.external_url(), self.file_name)
2511
section = self._config_obj.setdefault(section_name, {})
2512
return self.mutable_section_class(section_name, section)
2921
2515
# Note that LockableConfigObjStore inherits from ConfigObjStore because we need
3202
2733
option exists or get its value, which in turn may require to discover
3203
2734
in which sections it can be defined. Both of these (section and option
3204
2735
existence) require loading the store (even partially).
3206
:param name: The queried option.
3208
:param expand: Whether options references should be expanded.
3210
:returns: The value of the option.
3212
2737
# FIXME: No caching of options nor sections yet -- vila 20110503
3214
expand = _get_expand_default_value()
3216
2739
# Ensuring lazy loading is achieved by delaying section matching (which
3217
2740
# implies querying the persistent storage) until it can't be avoided
3218
2741
# anymore by using callables to describe (possibly empty) section
3220
for sections in self.sections_def:
3221
for store, section in sections():
2743
for section_or_callable in self.sections_def:
2744
# Each section can expand to multiple ones when a callable is used
2745
if callable(section_or_callable):
2746
sections = section_or_callable()
2748
sections = [section_or_callable]
2749
for section in sections:
3222
2750
value = section.get(name)
3223
2751
if value is not None:
3225
2753
if value is not None:
3227
# If the option is registered, it may provide additional info about
3230
opt = option_registry.get(name)
3234
def expand_and_convert(val):
3235
# This may need to be called twice if the value is None or ends up
3236
# being None during expansion or conversion.
3239
if isinstance(val, basestring):
3240
val = self._expand_options_in_string(val)
3242
trace.warning('Cannot expand "%s":'
3243
' %s does not support option expansion'
3244
% (name, type(val)))
3246
val = opt.convert_from_unicode(val)
3248
value = expand_and_convert(value)
3249
if opt is not None and value is None:
3250
2756
# If the option is registered, it may provide a default value
3251
value = opt.get_default()
3252
value = expand_and_convert(value)
2758
opt = option_registry.get(name)
2763
value = opt.get_default()
3253
2764
for hook in ConfigHooks['get']:
3254
2765
hook(self, name, value)
3257
def expand_options(self, string, env=None):
3258
"""Expand option references in the string in the configuration context.
3260
:param string: The string containing option(s) to expand.
3262
:param env: An option dict defining additional configuration options or
3263
overriding existing ones.
3265
:returns: The expanded string.
3267
return self._expand_options_in_string(string, env)
3269
def _expand_options_in_string(self, string, env=None, _refs=None):
3270
"""Expand options in the string in the configuration context.
3272
:param string: The string to be expanded.
3274
:param env: An option dict defining additional configuration options or
3275
overriding existing ones.
3277
:param _refs: Private list (FIFO) containing the options being expanded
3280
:returns: The expanded string.
3283
# Not much to expand there
3286
# What references are currently resolved (to detect loops)
3289
# We need to iterate until no more refs appear ({{foo}} will need two
3290
# iterations for example).
3295
for is_ref, chunk in iter_option_refs(result):
3297
chunks.append(chunk)
3302
raise errors.OptionExpansionLoop(string, _refs)
3304
value = self._expand_option(name, env, _refs)
3306
raise errors.ExpandingUnknownOption(name, string)
3307
chunks.append(value)
3309
result = ''.join(chunks)
3312
def _expand_option(self, name, env, _refs):
3313
if env is not None and name in env:
3314
# Special case, values provided in env takes precedence over
3318
value = self.get(name, expand=False)
3319
value = self._expand_options_in_string(value, env, _refs)
3322
2768
def _get_mutable_section(self):
3323
2769
"""Get the MutableSection for the Stack.
3325
2771
This is where we guarantee that the mutable section is lazily loaded:
3326
2772
this means we won't load the corresponding store before setting a value
3327
2773
or deleting an option. In practice the store will often be loaded but
3328
this helps catching some programming errors.
2774
this allows helps catching some programming errors.
3330
section = self.store.get_mutable_section(self.mutable_section_id)
2776
section = self.store.get_mutable_section(self.mutable_section_name)
3333
2779
def set(self, name, value):
3378
2818
# Force a write to persistent storage
3379
2819
self.store.save()
3381
def remove(self, name):
3384
super(_CompatibleStack, self).remove(name)
3385
# Force a write to persistent storage
3389
2822
class GlobalStack(_CompatibleStack):
3390
"""Global options only stack."""
3392
2824
def __init__(self):
3393
2825
# Get a GlobalStore
3394
2826
gstore = GlobalStore()
3395
super(GlobalStack, self).__init__(
3396
[self._get_overrides, NameMatcher(gstore, 'DEFAULT').get_sections],
3397
gstore, mutable_section_id='DEFAULT')
2827
super(GlobalStack, self).__init__([gstore.get_sections], gstore)
3400
2830
class LocationStack(_CompatibleStack):
3401
"""Per-location options falling back to global options stack."""
3403
2832
def __init__(self, location):
3404
2833
"""Make a new stack for a location and global configuration.
3406
2835
:param location: A URL prefix to """
3407
2836
lstore = LocationStore()
3408
if location.startswith('file://'):
3409
location = urlutils.local_path_from_url(location)
3410
2837
matcher = LocationMatcher(lstore, location)
3411
2838
gstore = GlobalStore()
3412
2839
super(LocationStack, self).__init__(
3413
[self._get_overrides,
3414
matcher.get_sections, NameMatcher(gstore, 'DEFAULT').get_sections],
3415
lstore, mutable_section_id=location)
2840
[matcher.get_sections, gstore.get_sections], lstore)
3418
2842
class BranchStack(_CompatibleStack):
3419
"""Per-location options falling back to branch then global options stack."""
3421
2844
def __init__(self, branch):
3422
bstore = branch._get_config_store()
2845
bstore = BranchStore(branch)
3423
2846
lstore = LocationStore()
3424
2847
matcher = LocationMatcher(lstore, branch.base)
3425
2848
gstore = GlobalStore()
3426
2849
super(BranchStack, self).__init__(
3427
[self._get_overrides,
3428
matcher.get_sections, bstore.get_sections,
3429
NameMatcher(gstore, 'DEFAULT').get_sections],
3431
self.branch = branch
3434
class RemoteControlStack(_CompatibleStack):
3435
"""Remote control-only options stack."""
3437
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3438
# with the stack used for remote bzr dirs. RemoteControlStack only uses
3439
# control.conf and is used only for stack options.
3441
def __init__(self, bzrdir):
3442
cstore = bzrdir._get_config_store()
3443
super(RemoteControlStack, self).__init__(
3444
[cstore.get_sections],
3446
self.bzrdir = bzrdir
3449
class RemoteBranchStack(_CompatibleStack):
3450
"""Remote branch-only options stack."""
3452
# FIXME 2011-11-22 JRV This should probably be renamed to avoid confusion
3453
# with the stack used for remote branches. RemoteBranchStack only uses
3454
# branch.conf and is used only for the stack options.
3456
def __init__(self, branch):
3457
bstore = branch._get_config_store()
3458
super(RemoteBranchStack, self).__init__(
3459
[bstore.get_sections],
3461
self.branch = branch
3463
# Use a an empty dict to initialize an empty configobj avoiding all
3464
# parsing and encoding checks
3465
_quoting_config = configobj.ConfigObj(
3466
{}, encoding='utf-8', interpolation=False)
2850
[matcher.get_sections, bstore.get_sections, gstore.get_sections],
2852
self.branch = branch
3468
2855
class cmd_config(commands.Command):
3469
2856
__doc__ = """Display, set or remove a configuration option.
3531
2917
# Set the option value
3532
2918
self._set_config_option(name, value, directory, scope)
3534
def _get_stack(self, directory, scope=None):
3535
"""Get the configuration stack specified by ``directory`` and ``scope``.
2920
def _get_configs(self, directory, scope=None):
2921
"""Iterate the configurations specified by ``directory`` and ``scope``.
3537
2923
:param directory: Where the configurations are derived from.
3539
2925
:param scope: A specific config to start from.
3541
# FIXME: scope should allow access to plugin-specific stacks (even
3542
# reduced to the plugin-specific store), related to
3543
# http://pad.lv/788991 -- vila 2011-11-15
3544
2927
if scope is not None:
3545
2928
if scope == 'bazaar':
3546
return GlobalStack()
2929
yield GlobalConfig()
3547
2930
elif scope == 'locations':
3548
return LocationStack(directory)
2931
yield LocationConfig(directory)
3549
2932
elif scope == 'branch':
3551
controldir.ControlDir.open_containing_tree_or_branch(
3553
return br.get_config_stack()
3554
raise errors.NoSuchConfig(scope)
2933
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2935
yield br.get_config()
3558
controldir.ControlDir.open_containing_tree_or_branch(
3560
return br.get_config_stack()
2938
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2940
yield br.get_config()
3561
2941
except errors.NotBranchError:
3562
return LocationStack(directory)
2942
yield LocationConfig(directory)
2943
yield GlobalConfig()
3564
2945
def _show_value(self, name, directory, scope):
3565
conf = self._get_stack(directory, scope)
3566
value = conf.get(name, expand=True)
3567
if value is not None:
3568
# Quote the value appropriately
3569
value = _quoting_config._quote(value)
3570
self.outf.write('%s\n' % (value,))
2947
for c in self._get_configs(directory, scope):
2950
for (oname, value, section, conf_id, parser) in c._get_options():
2952
# Display only the first value and exit
2954
# FIXME: We need to use get_user_option to take policies
2955
# into account and we need to make sure the option exists
2956
# too (hence the two for loops), this needs a better API
2958
value = c.get_user_option(name)
2959
# Quote the value appropriately
2960
value = parser._quote(value)
2961
self.outf.write('%s\n' % (value,))
3572
2965
raise errors.NoSuchConfigOption(name)
3574
2967
def _show_matching_options(self, name, directory, scope):
3577
2970
# avoid the delay introduced by the lazy regexp. But, we still do
3578
2971
# want the nicer errors raised by lazy_regex.
3579
2972
name._compile_and_collapse()
3581
2974
cur_section = None
3582
conf = self._get_stack(directory, scope)
3583
for sections in conf.sections_def:
3584
for store, section in sections():
3585
for oname in section.iter_option_names():
3586
if name.search(oname):
3587
if cur_store_id != store.id:
3588
# Explain where the options are defined
3589
self.outf.write('%s:\n' % (store.id,))
3590
cur_store_id = store.id
3592
if (section.id not in (None, 'DEFAULT')
3593
and cur_section != section.id):
3594
# Display the section if it's not the default (or
3596
self.outf.write(' [%s]\n' % (section.id,))
3597
cur_section = section.id
3598
value = section.get(oname, expand=False)
3599
value = _quoting_config._quote(value)
3600
self.outf.write(' %s = %s\n' % (oname, value))
2975
for c in self._get_configs(directory, scope):
2976
for (oname, value, section, conf_id, parser) in c._get_options():
2977
if name.search(oname):
2978
if cur_conf_id != conf_id:
2979
# Explain where the options are defined
2980
self.outf.write('%s:\n' % (conf_id,))
2981
cur_conf_id = conf_id
2983
if (section not in (None, 'DEFAULT')
2984
and cur_section != section):
2985
# Display the section if it's not the default (or only)
2987
self.outf.write(' [%s]\n' % (section,))
2988
cur_section = section
2989
self.outf.write(' %s = %s\n' % (oname, value))
3602
2991
def _set_config_option(self, name, value, directory, scope):
3603
conf = self._get_stack(directory, scope)
3604
conf.set(name, value)
2992
for conf in self._get_configs(directory, scope):
2993
conf.set_user_option(name, value)
2996
raise errors.NoSuchConfig(scope)
3606
2998
def _remove_config_option(self, name, directory, scope):
3607
2999
if name is None:
3608
3000
raise errors.BzrCommandError(
3609
3001
'--remove expects an option to remove.')
3610
conf = self._get_stack(directory, scope)
3003
for conf in self._get_configs(directory, scope):
3004
for (section_name, section, conf_id) in conf._get_sections():
3005
if scope is not None and conf_id != scope:
3006
# Not the right configuration file
3009
if conf_id != conf.config_id():
3010
conf = self._get_configs(directory, conf_id).next()
3011
# We use the first section in the first config where the
3012
# option is defined to remove it
3013
conf.remove_user_option(name, section_name)
3018
raise errors.NoSuchConfig(scope)
3614
3020
raise errors.NoSuchConfigOption(name)
3617
3022
# Test registries
3619
3024
# We need adapters that can build a Store or a Stack in a test context. Test
added
removed
bzrlib/config.py
