126
def ConfigObj(*args, **kwargs):
128
if _ConfigObj is None:
129
class ConfigObj(configobj.ConfigObj):
131
def get_bool(self, section, key):
132
return self[section].as_bool(key)
134
def get_value(self, section, name):
135
# Try [] for the old DEFAULT section.
136
if section == "DEFAULT":
141
return self[section][name]
142
_ConfigObj = ConfigObj
143
return _ConfigObj(*args, **kwargs)
133
class ConfigObj(configobj.ConfigObj):
135
def __init__(self, infile=None, **kwargs):
136
# We define our own interpolation mechanism calling it option expansion
137
super(ConfigObj, self).__init__(infile=infile,
142
def get_bool(self, section, key):
143
return self[section].as_bool(key)
145
def get_value(self, section, name):
146
# Try [] for the old DEFAULT section.
147
if section == "DEFAULT":
152
return self[section][name]
155
# FIXME: Until we can guarantee that each config file is loaded once and and
156
# only once for a given bzrlib session, we don't want to re-read the file every
157
# time we query for an option so we cache the value (bad ! watch out for tests
158
# needing to restore the proper value).This shouldn't be part of 2.4.0 final,
159
# yell at mgz^W vila and the RM if this is still present at that time
161
_expand_default_value = None
162
def _get_expand_default_value():
163
global _expand_default_value
164
if _expand_default_value is not None:
165
return _expand_default_value
166
conf = GlobalConfig()
167
# Note that we must not use None for the expand value below or we'll run
168
# into infinite recursion. Using False really would be quite silly ;)
169
expand = conf.get_user_option_as_bool('bzr.config.expand', expand=True)
171
# This is an opt-in feature, you *really* need to clearly say you want
174
_expand_default_value = expand
146
178
class Config(object):
178
214
def _get_signing_policy(self):
179
215
"""Template method to override signature creation policy."""
219
def expand_options(self, string, env=None):
220
"""Expand option references in the string in the configuration context.
222
:param string: The string containing option to expand.
224
:param env: An option dict defining additional configuration options or
225
overriding existing ones.
227
:returns: The expanded string.
229
return self._expand_options_in_string(string, env)
231
def _expand_options_in_list(self, slist, env=None, _ref_stack=None):
232
"""Expand options in a list of strings in the configuration context.
234
:param slist: A list of strings.
236
:param env: An option dict defining additional configuration options or
237
overriding existing ones.
239
:param _ref_stack: Private list containing the options being
240
expanded to detect loops.
242
:returns: The flatten list of expanded strings.
244
# expand options in each value separately flattening lists
247
value = self._expand_options_in_string(s, env, _ref_stack)
248
if isinstance(value, list):
254
def _expand_options_in_string(self, string, env=None, _ref_stack=None):
255
"""Expand options in the string in the configuration context.
257
:param string: The string to be expanded.
259
:param env: An option dict defining additional configuration options or
260
overriding existing ones.
262
:param _ref_stack: Private list containing the options being
263
expanded to detect loops.
265
:returns: The expanded string.
268
# Not much to expand there
270
if _ref_stack is None:
271
# What references are currently resolved (to detect loops)
273
if self.option_ref_re is None:
274
# We want to match the most embedded reference first (i.e. for
275
# '{{foo}}' we will get '{foo}',
276
# for '{bar{baz}}' we will get '{baz}'
277
self.option_ref_re = re.compile('({[^{}]+})')
279
# We need to iterate until no more refs appear ({{foo}} will need two
280
# iterations for example).
283
raw_chunks = self.option_ref_re.split(result)
285
import pdb; pdb.set_trace()
286
if len(raw_chunks) == 1:
287
# Shorcut the trivial case: no refs
291
# Split will isolate refs so that every other chunk is a ref
293
for chunk in raw_chunks:
296
# Keep only non-empty strings (or we get bogus empty
297
# slots when a list value is involved).
302
if name in _ref_stack:
303
raise errors.OptionExpansionLoop(string, _ref_stack)
304
_ref_stack.append(name)
305
value = self._expand_option(name, env, _ref_stack)
307
raise errors.ExpandingUnknownOption(name, string)
308
if isinstance(value, list):
316
# Once a list appears as the result of an expansion, all
317
# callers will get a list result. This allows a consistent
318
# behavior even when some options in the expansion chain
319
# defined as strings (no comma in their value) but their
320
# expanded value is a list.
321
return self._expand_options_in_list(chunks, env, _ref_stack)
323
result = ''.join(chunks)
326
def _expand_option(self, name, env, _ref_stack):
327
if env is not None and name in env:
328
# Special case, values provided in env takes precedence over
332
# FIXME: This is a limited implementation, what we really need is a
333
# way to query the bzr config for the value of an option,
334
# respecting the scope rules (That is, once we implement fallback
335
# configs, getting the option value should restart from the top
336
# config, not the current one) -- vila 20101222
337
value = self.get_user_option(name, expand=False)
338
if isinstance(value, list):
339
value = self._expand_options_in_list(value, env, _ref_stack)
341
value = self._expand_options_in_string(value, env, _ref_stack)
181
344
def _get_user_option(self, option_name):
182
345
"""Template method to provide a user option."""
185
def get_user_option(self, option_name):
186
"""Get a generic option - no special process, no default."""
187
return self._get_user_option(option_name)
189
def get_user_option_as_bool(self, option_name):
348
def get_user_option(self, option_name, expand=None):
349
"""Get a generic option - no special process, no default.
351
:param option_name: The queried option.
353
:param expand: Whether options references should be expanded.
355
:returns: The value of the option.
358
expand = _get_expand_default_value()
359
value = self._get_user_option(option_name)
361
if isinstance(value, list):
362
value = self._expand_options_in_list(value)
363
elif isinstance(value, dict):
364
trace.warning('Cannot expand "%s":'
365
' Dicts do not support option expansion'
368
value = self._expand_options_in_string(value)
371
def get_user_option_as_bool(self, option_name, expand=None):
190
372
"""Get a generic option as a boolean - no special process, no default.
192
374
:return None if the option doesn't exist or its value can't be
193
375
interpreted as a boolean. Returns True or False otherwise.
195
s = self._get_user_option(option_name)
377
s = self.get_user_option(option_name, expand=expand)
197
379
# The option doesn't exist
533
def get_merge_tools(self):
535
for (oname, value, section, conf_id, parser) in self._get_options():
536
if oname.startswith('bzr.mergetool.'):
537
tool_name = oname[len('bzr.mergetool.'):]
538
tools[tool_name] = value
539
trace.mutter('loaded merge tools: %r' % tools)
542
def find_merge_tool(self, name):
543
# We fake a defaults mechanism here by checking if the given name can
544
# be found in the known_merge_tools if it's not found in the config.
545
# This should be done through the proposed config defaults mechanism
546
# when it becomes available in the future.
547
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
549
or mergetools.known_merge_tools.get(name, None))
350
553
class IniBasedConfig(Config):
351
554
"""A configuration policy that draws from ini files."""
353
def __init__(self, get_filename):
556
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
558
"""Base class for configuration files using an ini-like syntax.
560
:param file_name: The configuration file path.
354
562
super(IniBasedConfig, self).__init__()
355
self._get_filename = get_filename
563
self.file_name = file_name
564
if symbol_versioning.deprecated_passed(get_filename):
565
symbol_versioning.warn(
566
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
567
' Use file_name instead.',
570
if get_filename is not None:
571
self.file_name = get_filename()
573
self.file_name = file_name
356
575
self._parser = None
358
def _get_parser(self, file=None):
578
def from_string(cls, str_or_unicode, file_name=None, save=False):
579
"""Create a config object from a string.
581
:param str_or_unicode: A string representing the file content. This will
584
:param file_name: The configuration file path.
586
:param _save: Whether the file should be saved upon creation.
588
conf = cls(file_name=file_name)
589
conf._create_from_string(str_or_unicode, save)
592
def _create_from_string(self, str_or_unicode, save):
593
self._content = StringIO(str_or_unicode.encode('utf-8'))
594
# Some tests use in-memory configs, some other always need the config
595
# file to exist on disk.
597
self._write_config_file()
599
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
359
600
if self._parser is not None:
360
601
return self._parser
362
input = self._get_filename()
602
if symbol_versioning.deprecated_passed(file):
603
symbol_versioning.warn(
604
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
605
' Use IniBasedConfig(_content=xxx) instead.',
608
if self._content is not None:
609
co_input = self._content
610
elif self.file_name is None:
611
raise AssertionError('We have no content to create the config')
613
co_input = self.file_name
366
self._parser = ConfigObj(input, encoding='utf-8')
615
self._parser = ConfigObj(co_input, encoding='utf-8')
367
616
except configobj.ConfigObjError, e:
368
617
raise errors.ParseConfigError(e.errors, e.config.filename)
618
# Make sure self.reload() will use the right file name
619
self._parser.filename = self.file_name
369
620
return self._parser
623
"""Reload the config file from disk."""
624
if self.file_name is None:
625
raise AssertionError('We need a file name to reload the config')
626
if self._parser is not None:
627
self._parser.reload()
371
629
def _get_matching_sections(self):
372
630
"""Return an ordered list of (section_name, extra_path) pairs.
384
642
"""Override this to define the section used by the config."""
645
def _get_sections(self, name=None):
646
"""Returns an iterator of the sections specified by ``name``.
648
:param name: The section name. If None is supplied, the default
649
configurations are yielded.
651
:return: A tuple (name, section, config_id) for all sections that will
652
be walked by user_get_option() in the 'right' order. The first one
653
is where set_user_option() will update the value.
655
parser = self._get_parser()
657
yield (name, parser[name], self.config_id())
659
# No section name has been given so we fallback to the configobj
660
# itself which holds the variables defined outside of any section.
661
yield (None, parser, self.config_id())
663
def _get_options(self, sections=None):
664
"""Return an ordered list of (name, value, section, config_id) tuples.
666
All options are returned with their associated value and the section
667
they appeared in. ``config_id`` is a unique identifier for the
668
configuration file the option is defined in.
670
:param sections: Default to ``_get_matching_sections`` if not
671
specified. This gives a better control to daughter classes about
672
which sections should be searched. This is a list of (name,
677
parser = self._get_parser()
679
for (section_name, _) in self._get_matching_sections():
681
section = parser[section_name]
683
# This could happen for an empty file for which we define a
684
# DEFAULT section. FIXME: Force callers to provide sections
685
# instead ? -- vila 20100930
687
sections.append((section_name, section))
688
config_id = self.config_id()
689
for (section_name, section) in sections:
690
for (name, value) in section.iteritems():
691
yield (name, parser._quote(value), section_name,
387
694
def _get_option_policy(self, section, option_name):
388
695
"""Return the policy for the given (section, option_name) pair."""
389
696
return POLICY_NONE
476
783
def _get_nickname(self):
477
784
return self.get_user_option('nickname')
480
class GlobalConfig(IniBasedConfig):
786
def remove_user_option(self, option_name, section_name=None):
787
"""Remove a user option and save the configuration file.
789
:param option_name: The option to be removed.
791
:param section_name: The section the option is defined in, default to
795
parser = self._get_parser()
796
if section_name is None:
799
section = parser[section_name]
801
del section[option_name]
803
raise errors.NoSuchConfigOption(option_name)
804
self._write_config_file()
806
def _write_config_file(self):
807
if self.file_name is None:
808
raise AssertionError('We cannot save, self.file_name is None')
809
conf_dir = os.path.dirname(self.file_name)
810
ensure_config_dir_exists(conf_dir)
811
atomic_file = atomicfile.AtomicFile(self.file_name)
812
self._get_parser().write(atomic_file)
815
osutils.copy_ownership_from_path(self.file_name)
818
class LockableConfig(IniBasedConfig):
819
"""A configuration needing explicit locking for access.
821
If several processes try to write the config file, the accesses need to be
824
Daughter classes should decorate all methods that update a config with the
825
``@needs_write_lock`` decorator (they call, directly or indirectly, the
826
``_write_config_file()`` method. These methods (typically ``set_option()``
827
and variants must reload the config file from disk before calling
828
``_write_config_file()``), this can be achieved by calling the
829
``self.reload()`` method. Note that the lock scope should cover both the
830
reading and the writing of the config file which is why the decorator can't
831
be applied to ``_write_config_file()`` only.
833
This should be enough to implement the following logic:
834
- lock for exclusive write access,
835
- reload the config file from disk,
839
This logic guarantees that a writer can update a value without erasing an
840
update made by another writer.
845
def __init__(self, file_name):
846
super(LockableConfig, self).__init__(file_name=file_name)
847
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
848
# FIXME: It doesn't matter that we don't provide possible_transports
849
# below since this is currently used only for local config files ;
850
# local transports are not shared. But if/when we start using
851
# LockableConfig for other kind of transports, we will need to reuse
852
# whatever connection is already established -- vila 20100929
853
self.transport = transport.get_transport(self.dir)
854
self._lock = lockdir.LockDir(self.transport, 'lock')
856
def _create_from_string(self, unicode_bytes, save):
857
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
859
# We need to handle the saving here (as opposed to IniBasedConfig)
862
self._write_config_file()
865
def lock_write(self, token=None):
866
"""Takes a write lock in the directory containing the config file.
868
If the directory doesn't exist it is created.
870
ensure_config_dir_exists(self.dir)
871
return self._lock.lock_write(token)
876
def break_lock(self):
877
self._lock.break_lock()
880
def remove_user_option(self, option_name, section_name=None):
881
super(LockableConfig, self).remove_user_option(option_name,
884
def _write_config_file(self):
885
if self._lock is None or not self._lock.is_held:
886
# NB: if the following exception is raised it probably means a
887
# missing @needs_write_lock decorator on one of the callers.
888
raise errors.ObjectNotLocked(self)
889
super(LockableConfig, self)._write_config_file()
892
class GlobalConfig(LockableConfig):
481
893
"""The configuration that should be used for a specific location."""
896
super(GlobalConfig, self).__init__(file_name=config_filename())
902
def from_string(cls, str_or_unicode, save=False):
903
"""Create a config object from a string.
905
:param str_or_unicode: A string representing the file content. This
906
will be utf-8 encoded.
908
:param save: Whether the file should be saved upon creation.
911
conf._create_from_string(str_or_unicode, save)
483
914
def get_editor(self):
484
915
return self._get_user_option('editor')
487
super(GlobalConfig, self).__init__(config_filename)
489
918
def set_user_option(self, option, value):
490
919
"""Save option and its value in the configuration."""
491
920
self._set_option(option, value, 'DEFAULT')
510
942
self._write_config_file()
512
944
def _set_option(self, option, value, section):
513
# FIXME: RBC 20051029 This should refresh the parser and also take a
514
# file lock on bazaar.conf.
515
conf_dir = os.path.dirname(self._get_filename())
516
ensure_config_dir_exists(conf_dir)
517
946
self._get_parser().setdefault(section, {})[option] = value
518
947
self._write_config_file()
520
def _write_config_file(self):
521
path = self._get_filename()
523
osutils.copy_ownership_from_path(path)
524
self._get_parser().write(f)
528
class LocationConfig(IniBasedConfig):
950
def _get_sections(self, name=None):
951
"""See IniBasedConfig._get_sections()."""
952
parser = self._get_parser()
953
# We don't give access to options defined outside of any section, we
954
# used the DEFAULT section by... default.
955
if name in (None, 'DEFAULT'):
956
# This could happen for an empty file where the DEFAULT section
957
# doesn't exist yet. So we force DEFAULT when yielding
959
if 'DEFAULT' not in parser:
960
parser['DEFAULT']= {}
961
yield (name, parser[name], self.config_id())
964
def remove_user_option(self, option_name, section_name=None):
965
if section_name is None:
966
# We need to force the default section.
967
section_name = 'DEFAULT'
968
# We need to avoid the LockableConfig implementation or we'll lock
970
super(LockableConfig, self).remove_user_option(option_name,
974
class LocationConfig(LockableConfig):
529
975
"""A configuration object that gives the policy for a location."""
531
977
def __init__(self, location):
532
name_generator = locations_config_filename
533
if (not os.path.exists(name_generator()) and
534
os.path.exists(branches_config_filename())):
535
if sys.platform == 'win32':
536
trace.warning('Please rename %s to %s'
537
% (branches_config_filename(),
538
locations_config_filename()))
540
trace.warning('Please rename ~/.bazaar/branches.conf'
541
' to ~/.bazaar/locations.conf')
542
name_generator = branches_config_filename
543
super(LocationConfig, self).__init__(name_generator)
978
super(LocationConfig, self).__init__(
979
file_name=locations_config_filename())
544
980
# local file locations are looked up by local path, rather than
545
981
# by file url. This is because the config file is a user
546
982
# file, and we would rather not expose the user to file urls.
648
1112
STORE_LOCATION_APPENDPATH]:
649
1113
raise ValueError('bad storage policy %r for %r' %
650
1114
(store, option))
651
# FIXME: RBC 20051029 This should refresh the parser and also take a
652
# file lock on locations.conf.
653
conf_dir = os.path.dirname(self._get_filename())
654
ensure_config_dir_exists(conf_dir)
655
1116
location = self.location
656
1117
if location.endswith('/'):
657
1118
location = location[:-1]
658
if (not location in self._get_parser() and
659
not location + '/' in self._get_parser()):
660
self._get_parser()[location]={}
661
elif location + '/' in self._get_parser():
1119
parser = self._get_parser()
1120
if not location in parser and not location + '/' in parser:
1121
parser[location] = {}
1122
elif location + '/' in parser:
662
1123
location = location + '/'
663
self._get_parser()[location][option]=value
1124
parser[location][option]=value
664
1125
# the allowed values of store match the config policies
665
1126
self._set_option_policy(location, option, store)
666
self._get_parser().write(file(self._get_filename(), 'wb'))
1127
self._write_config_file()
669
1130
class BranchConfig(Config):
670
1131
"""A configuration object giving the policy for a branch."""
1133
def __init__(self, branch):
1134
super(BranchConfig, self).__init__()
1135
self._location_config = None
1136
self._branch_data_config = None
1137
self._global_config = None
1138
self.branch = branch
1139
self.option_sources = (self._get_location_config,
1140
self._get_branch_data_config,
1141
self._get_global_config)
1143
def config_id(self):
672
1146
def _get_branch_data_config(self):
673
1147
if self._branch_data_config is None:
674
1148
self._branch_data_config = TreeConfig(self.branch)
1149
self._branch_data_config.config_id = self.config_id
675
1150
return self._branch_data_config
677
1152
def _get_location_config(self):
1223
def _get_sections(self, name=None):
1224
"""See IniBasedConfig.get_sections()."""
1225
for source in self.option_sources:
1226
for section in source()._get_sections(name):
1229
def _get_options(self, sections=None):
1231
# First the locations options
1232
for option in self._get_location_config()._get_options():
1234
# Then the branch options
1235
branch_config = self._get_branch_data_config()
1236
if sections is None:
1237
sections = [('DEFAULT', branch_config._get_parser())]
1238
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1239
# Config itself has no notion of sections :( -- vila 20101001
1240
config_id = self.config_id()
1241
for (section_name, section) in sections:
1242
for (name, value) in section.iteritems():
1243
yield (name, value, section_name,
1244
config_id, branch_config._get_parser())
1245
# Then the global options
1246
for option in self._get_global_config()._get_options():
748
1249
def set_user_option(self, name, value, store=STORE_BRANCH,
749
1250
warn_masked=False):
750
1251
if store == STORE_BRANCH:
826
1320
def config_dir():
827
1321
"""Return per-user configuration directory.
829
By default this is ~/.bazaar/
1323
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1324
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1325
that will be used instead.
831
1327
TODO: Global option --config-dir to override this.
833
1329
base = os.environ.get('BZR_HOME', None)
834
1330
if sys.platform == 'win32':
1331
# environ variables on Windows are in user encoding/mbcs. So decode
1333
if base is not None:
1334
base = base.decode('mbcs')
835
1335
if base is None:
836
1336
base = win32utils.get_appdata_location_unicode()
837
1337
if base is None:
838
1338
base = os.environ.get('HOME', None)
1339
if base is not None:
1340
base = base.decode('mbcs')
839
1341
if base is None:
840
1342
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
842
1344
return osutils.pathjoin(base, 'bazaar', '2.0')
1345
elif sys.platform == 'darwin':
1347
# this takes into account $HOME
1348
base = os.path.expanduser("~")
1349
return osutils.pathjoin(base, '.bazaar')
844
# cygwin, linux, and darwin all have a $HOME directory
845
1351
if base is None:
1353
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1355
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1356
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1357
if osutils.isdir(xdg_dir):
1359
"Using configuration in XDG directory %s." % xdg_dir)
846
1362
base = os.path.expanduser("~")
847
1363
return osutils.pathjoin(base, ".bazaar")
899
1410
return os.path.expanduser('~/.cache')
903
"""Calculate automatic user identification.
905
Returns (realname, email).
907
Only used when none is set in the environment or the id file.
909
This previously used the FQDN as the default domain, but that can
910
be very slow on machines where DNS is broken. So now we simply
915
if sys.platform == 'win32':
916
name = win32utils.get_user_name_unicode()
918
raise errors.BzrError("Cannot autodetect user name.\n"
919
"Please, set your name with command like:\n"
920
'bzr whoami "Your Name <name@domain.com>"')
921
host = win32utils.get_host_name_unicode()
923
host = socket.gethostname()
924
return name, (name + '@' + host)
930
w = pwd.getpwuid(uid)
932
raise errors.BzrCommandError('Unable to determine your name. '
933
'Please use "bzr whoami" to set it.')
935
# we try utf-8 first, because on many variants (like Linux),
936
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
937
# false positives. (many users will have their user encoding set to
938
# latin-1, which cannot raise UnicodeError.)
940
gecos = w.pw_gecos.decode('utf-8')
944
encoding = osutils.get_user_encoding()
945
gecos = w.pw_gecos.decode(encoding)
947
raise errors.BzrCommandError('Unable to determine your name. '
948
'Use "bzr whoami" to set it.')
950
username = w.pw_name.decode(encoding)
952
raise errors.BzrCommandError('Unable to determine your name. '
953
'Use "bzr whoami" to set it.')
955
comma = gecos.find(',')
959
realname = gecos[:comma]
966
user_encoding = osutils.get_user_encoding()
967
realname = username = getpass.getuser().decode(user_encoding)
968
except UnicodeDecodeError:
969
raise errors.BzrError("Can't decode username as %s." % \
972
return realname, (username + '@' + socket.gethostname())
975
1413
def parse_username(username):
976
1414
"""Parse e-mail username and return a (name, address) tuple."""
977
1415
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1517
1978
return StringIO()
1519
1980
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
1981
f = self._get_config_file()
1983
return ConfigObj(f, encoding='utf-8')
1522
1987
def _set_configobj(self, configobj):
1523
1988
out_file = StringIO()
1524
1989
configobj.write(out_file)
1525
1990
out_file.seek(0)
1526
1991
self._transport.put_file(self._filename, out_file)
1994
class cmd_config(commands.Command):
1995
__doc__ = """Display, set or remove a configuration option.
1997
Display the active value for a given option.
1999
If --all is specified, NAME is interpreted as a regular expression and all
2000
matching options are displayed mentioning their scope. The active value
2001
that bzr will take into account is the first one displayed for each option.
2003
If no NAME is given, --all .* is implied.
2005
Setting a value is achieved by using name=value without spaces. The value
2006
is set in the most relevant scope and can be checked by displaying the
2010
takes_args = ['name?']
2014
# FIXME: This should be a registry option so that plugins can register
2015
# their own config files (or not) -- vila 20101002
2016
commands.Option('scope', help='Reduce the scope to the specified'
2017
' configuration file',
2019
commands.Option('all',
2020
help='Display all the defined values for the matching options.',
2022
commands.Option('remove', help='Remove the option from'
2023
' the configuration file'),
2026
@commands.display_command
2027
def run(self, name=None, all=False, directory=None, scope=None,
2029
if directory is None:
2031
directory = urlutils.normalize_url(directory)
2033
raise errors.BzrError(
2034
'--all and --remove are mutually exclusive.')
2036
# Delete the option in the given scope
2037
self._remove_config_option(name, directory, scope)
2039
# Defaults to all options
2040
self._show_matching_options('.*', directory, scope)
2043
name, value = name.split('=', 1)
2045
# Display the option(s) value(s)
2047
self._show_matching_options(name, directory, scope)
2049
self._show_value(name, directory, scope)
2052
raise errors.BzrError(
2053
'Only one option can be set.')
2054
# Set the option value
2055
self._set_config_option(name, value, directory, scope)
2057
def _get_configs(self, directory, scope=None):
2058
"""Iterate the configurations specified by ``directory`` and ``scope``.
2060
:param directory: Where the configurations are derived from.
2062
:param scope: A specific config to start from.
2064
if scope is not None:
2065
if scope == 'bazaar':
2066
yield GlobalConfig()
2067
elif scope == 'locations':
2068
yield LocationConfig(directory)
2069
elif scope == 'branch':
2070
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2072
yield br.get_config()
2075
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2077
yield br.get_config()
2078
except errors.NotBranchError:
2079
yield LocationConfig(directory)
2080
yield GlobalConfig()
2082
def _show_value(self, name, directory, scope):
2084
for c in self._get_configs(directory, scope):
2087
for (oname, value, section, conf_id, parser) in c._get_options():
2089
# Display only the first value and exit
2091
# FIXME: We need to use get_user_option to take policies
2092
# into account and we need to make sure the option exists
2093
# too (hence the two for loops), this needs a better API
2095
value = c.get_user_option(name)
2096
# Quote the value appropriately
2097
value = parser._quote(value)
2098
self.outf.write('%s\n' % (value,))
2102
raise errors.NoSuchConfigOption(name)
2104
def _show_matching_options(self, name, directory, scope):
2105
name = re.compile(name)
2106
# We want any error in the regexp to be raised *now* so we need to
2107
# avoid the delay introduced by the lazy regexp.
2108
name._compile_and_collapse()
2111
for c in self._get_configs(directory, scope):
2112
for (oname, value, section, conf_id, parser) in c._get_options():
2113
if name.search(oname):
2114
if cur_conf_id != conf_id:
2115
# Explain where the options are defined
2116
self.outf.write('%s:\n' % (conf_id,))
2117
cur_conf_id = conf_id
2119
if (section not in (None, 'DEFAULT')
2120
and cur_section != section):
2121
# Display the section if it's not the default (or only)
2123
self.outf.write(' [%s]\n' % (section,))
2124
cur_section = section
2125
self.outf.write(' %s = %s\n' % (oname, value))
2127
def _set_config_option(self, name, value, directory, scope):
2128
for conf in self._get_configs(directory, scope):
2129
conf.set_user_option(name, value)
2132
raise errors.NoSuchConfig(scope)
2134
def _remove_config_option(self, name, directory, scope):
2136
raise errors.BzrCommandError(
2137
'--remove expects an option to remove.')
2139
for conf in self._get_configs(directory, scope):
2140
for (section_name, section, conf_id) in conf._get_sections():
2141
if scope is not None and conf_id != scope:
2142
# Not the right configuration file
2145
if conf_id != conf.config_id():
2146
conf = self._get_configs(directory, conf_id).next()
2147
# We use the first section in the first config where the
2148
# option is defined to remove it
2149
conf.remove_user_option(name, section_name)
2154
raise errors.NoSuchConfig(scope)
2156
raise errors.NoSuchConfigOption(name)
added
removed
bzrlib/config.py
