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).
282
raw_chunks = self.option_ref_re.split(result)
283
if len(raw_chunks) == 1:
284
# Shorcut the trivial case: no refs
288
# Split will isolate refs so that every other chunk is a ref
290
for chunk in raw_chunks:
293
# Keep only non-empty strings (or we get bogus empty
294
# slots when a list value is involved).
299
if name in _ref_stack:
300
raise errors.OptionExpansionLoop(string, _ref_stack)
301
_ref_stack.append(name)
302
value = self._expand_option(name, env, _ref_stack)
304
raise errors.ExpandingUnknownOption(name, string)
305
if isinstance(value, list):
313
# Once a list appears as the result of an expansion, all
314
# callers will get a list result. This allows a consistent
315
# behavior even when some options in the expansion chain
316
# defined as strings (no comma in their value) but their
317
# expanded value is a list.
318
return self._expand_options_in_list(chunks, env, _ref_stack)
320
result = ''.join(chunks)
323
def _expand_option(self, name, env, _ref_stack):
324
if env is not None and name in env:
325
# Special case, values provided in env takes precedence over
329
# FIXME: This is a limited implementation, what we really need is a
330
# way to query the bzr config for the value of an option,
331
# respecting the scope rules (That is, once we implement fallback
332
# configs, getting the option value should restart from the top
333
# config, not the current one) -- vila 20101222
334
value = self.get_user_option(name, expand=False)
335
if isinstance(value, list):
336
value = self._expand_options_in_list(value, env, _ref_stack)
338
value = self._expand_options_in_string(value, env, _ref_stack)
181
341
def _get_user_option(self, option_name):
182
342
"""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):
345
def get_user_option(self, option_name, expand=None):
346
"""Get a generic option - no special process, no default.
348
:param option_name: The queried option.
350
:param expand: Whether options references should be expanded.
352
:returns: The value of the option.
355
expand = _get_expand_default_value()
356
value = self._get_user_option(option_name)
358
if isinstance(value, list):
359
value = self._expand_options_in_list(value)
360
elif isinstance(value, dict):
361
trace.warning('Cannot expand "%s":'
362
' Dicts do not support option expansion'
365
value = self._expand_options_in_string(value)
368
def get_user_option_as_bool(self, option_name, expand=None):
190
369
"""Get a generic option as a boolean - no special process, no default.
192
371
:return None if the option doesn't exist or its value can't be
193
372
interpreted as a boolean. Returns True or False otherwise.
195
s = self._get_user_option(option_name)
374
s = self.get_user_option(option_name, expand=expand)
197
376
# The option doesn't exist
258
438
Something similar to 'Martin Pool <mbp@sourcefrog.net>'
260
$BZR_EMAIL can be set to override this (as well as the
261
deprecated $BZREMAIL), then
440
$BZR_EMAIL can be set to override this, then
262
441
the concrete policy type is checked, and finally
263
442
$EMAIL is examined.
264
If none is found, a reasonable default is (hopefully)
267
TODO: Check it's reasonably well-formed.
443
If no username can be found, errors.NoWhoami exception is raised.
269
445
v = os.environ.get('BZR_EMAIL')
271
447
return v.decode(osutils.get_user_encoding())
273
448
v = self._get_user_id()
277
451
v = os.environ.get('EMAIL')
279
453
return v.decode(osutils.get_user_encoding())
281
454
name, email = _auto_user_id()
283
456
return '%s <%s>' % (name, email)
459
raise errors.NoWhoami()
461
def ensure_username(self):
462
"""Raise errors.NoWhoami if username is not set.
464
This method relies on the username() function raising the error.
287
468
def signature_checking(self):
288
469
"""What is the current policy for signature checking?."""
530
def get_merge_tools(self):
532
for (oname, value, section, conf_id, parser) in self._get_options():
533
if oname.startswith('bzr.mergetool.'):
534
tool_name = oname[len('bzr.mergetool.'):]
535
tools[tool_name] = value
536
trace.mutter('loaded merge tools: %r' % tools)
539
def find_merge_tool(self, name):
540
# We fake a defaults mechanism here by checking if the given name can
541
# be found in the known_merge_tools if it's not found in the config.
542
# This should be done through the proposed config defaults mechanism
543
# when it becomes available in the future.
544
command_line = (self.get_user_option('bzr.mergetool.%s' % name,
546
or mergetools.known_merge_tools.get(name, None))
350
550
class IniBasedConfig(Config):
351
551
"""A configuration policy that draws from ini files."""
353
def __init__(self, get_filename):
553
def __init__(self, get_filename=symbol_versioning.DEPRECATED_PARAMETER,
555
"""Base class for configuration files using an ini-like syntax.
557
:param file_name: The configuration file path.
354
559
super(IniBasedConfig, self).__init__()
355
self._get_filename = get_filename
560
self.file_name = file_name
561
if symbol_versioning.deprecated_passed(get_filename):
562
symbol_versioning.warn(
563
'IniBasedConfig.__init__(get_filename) was deprecated in 2.3.'
564
' Use file_name instead.',
567
if get_filename is not None:
568
self.file_name = get_filename()
570
self.file_name = file_name
356
572
self._parser = None
358
def _get_parser(self, file=None):
575
def from_string(cls, str_or_unicode, file_name=None, save=False):
576
"""Create a config object from a string.
578
:param str_or_unicode: A string representing the file content. This will
581
:param file_name: The configuration file path.
583
:param _save: Whether the file should be saved upon creation.
585
conf = cls(file_name=file_name)
586
conf._create_from_string(str_or_unicode, save)
589
def _create_from_string(self, str_or_unicode, save):
590
self._content = StringIO(str_or_unicode.encode('utf-8'))
591
# Some tests use in-memory configs, some other always need the config
592
# file to exist on disk.
594
self._write_config_file()
596
def _get_parser(self, file=symbol_versioning.DEPRECATED_PARAMETER):
359
597
if self._parser is not None:
360
598
return self._parser
362
input = self._get_filename()
599
if symbol_versioning.deprecated_passed(file):
600
symbol_versioning.warn(
601
'IniBasedConfig._get_parser(file=xxx) was deprecated in 2.3.'
602
' Use IniBasedConfig(_content=xxx) instead.',
605
if self._content is not None:
606
co_input = self._content
607
elif self.file_name is None:
608
raise AssertionError('We have no content to create the config')
610
co_input = self.file_name
366
self._parser = ConfigObj(input, encoding='utf-8')
612
self._parser = ConfigObj(co_input, encoding='utf-8')
367
613
except configobj.ConfigObjError, e:
368
614
raise errors.ParseConfigError(e.errors, e.config.filename)
615
# Make sure self.reload() will use the right file name
616
self._parser.filename = self.file_name
369
617
return self._parser
620
"""Reload the config file from disk."""
621
if self.file_name is None:
622
raise AssertionError('We need a file name to reload the config')
623
if self._parser is not None:
624
self._parser.reload()
371
626
def _get_matching_sections(self):
372
627
"""Return an ordered list of (section_name, extra_path) pairs.
384
639
"""Override this to define the section used by the config."""
642
def _get_sections(self, name=None):
643
"""Returns an iterator of the sections specified by ``name``.
645
:param name: The section name. If None is supplied, the default
646
configurations are yielded.
648
:return: A tuple (name, section, config_id) for all sections that will
649
be walked by user_get_option() in the 'right' order. The first one
650
is where set_user_option() will update the value.
652
parser = self._get_parser()
654
yield (name, parser[name], self.config_id())
656
# No section name has been given so we fallback to the configobj
657
# itself which holds the variables defined outside of any section.
658
yield (None, parser, self.config_id())
660
def _get_options(self, sections=None):
661
"""Return an ordered list of (name, value, section, config_id) tuples.
663
All options are returned with their associated value and the section
664
they appeared in. ``config_id`` is a unique identifier for the
665
configuration file the option is defined in.
667
:param sections: Default to ``_get_matching_sections`` if not
668
specified. This gives a better control to daughter classes about
669
which sections should be searched. This is a list of (name,
674
parser = self._get_parser()
676
for (section_name, _) in self._get_matching_sections():
678
section = parser[section_name]
680
# This could happen for an empty file for which we define a
681
# DEFAULT section. FIXME: Force callers to provide sections
682
# instead ? -- vila 20100930
684
sections.append((section_name, section))
685
config_id = self.config_id()
686
for (section_name, section) in sections:
687
for (name, value) in section.iteritems():
688
yield (name, parser._quote(value), section_name,
387
691
def _get_option_policy(self, section, option_name):
388
692
"""Return the policy for the given (section, option_name) pair."""
389
693
return POLICY_NONE
476
780
def _get_nickname(self):
477
781
return self.get_user_option('nickname')
480
class GlobalConfig(IniBasedConfig):
783
def remove_user_option(self, option_name, section_name=None):
784
"""Remove a user option and save the configuration file.
786
:param option_name: The option to be removed.
788
:param section_name: The section the option is defined in, default to
792
parser = self._get_parser()
793
if section_name is None:
796
section = parser[section_name]
798
del section[option_name]
800
raise errors.NoSuchConfigOption(option_name)
801
self._write_config_file()
803
def _write_config_file(self):
804
if self.file_name is None:
805
raise AssertionError('We cannot save, self.file_name is None')
806
conf_dir = os.path.dirname(self.file_name)
807
ensure_config_dir_exists(conf_dir)
808
atomic_file = atomicfile.AtomicFile(self.file_name)
809
self._get_parser().write(atomic_file)
812
osutils.copy_ownership_from_path(self.file_name)
815
class LockableConfig(IniBasedConfig):
816
"""A configuration needing explicit locking for access.
818
If several processes try to write the config file, the accesses need to be
821
Daughter classes should decorate all methods that update a config with the
822
``@needs_write_lock`` decorator (they call, directly or indirectly, the
823
``_write_config_file()`` method. These methods (typically ``set_option()``
824
and variants must reload the config file from disk before calling
825
``_write_config_file()``), this can be achieved by calling the
826
``self.reload()`` method. Note that the lock scope should cover both the
827
reading and the writing of the config file which is why the decorator can't
828
be applied to ``_write_config_file()`` only.
830
This should be enough to implement the following logic:
831
- lock for exclusive write access,
832
- reload the config file from disk,
836
This logic guarantees that a writer can update a value without erasing an
837
update made by another writer.
842
def __init__(self, file_name):
843
super(LockableConfig, self).__init__(file_name=file_name)
844
self.dir = osutils.dirname(osutils.safe_unicode(self.file_name))
845
# FIXME: It doesn't matter that we don't provide possible_transports
846
# below since this is currently used only for local config files ;
847
# local transports are not shared. But if/when we start using
848
# LockableConfig for other kind of transports, we will need to reuse
849
# whatever connection is already established -- vila 20100929
850
self.transport = transport.get_transport(self.dir)
851
self._lock = lockdir.LockDir(self.transport, 'lock')
853
def _create_from_string(self, unicode_bytes, save):
854
super(LockableConfig, self)._create_from_string(unicode_bytes, False)
856
# We need to handle the saving here (as opposed to IniBasedConfig)
859
self._write_config_file()
862
def lock_write(self, token=None):
863
"""Takes a write lock in the directory containing the config file.
865
If the directory doesn't exist it is created.
867
ensure_config_dir_exists(self.dir)
868
return self._lock.lock_write(token)
873
def break_lock(self):
874
self._lock.break_lock()
877
def remove_user_option(self, option_name, section_name=None):
878
super(LockableConfig, self).remove_user_option(option_name,
881
def _write_config_file(self):
882
if self._lock is None or not self._lock.is_held:
883
# NB: if the following exception is raised it probably means a
884
# missing @needs_write_lock decorator on one of the callers.
885
raise errors.ObjectNotLocked(self)
886
super(LockableConfig, self)._write_config_file()
889
class GlobalConfig(LockableConfig):
481
890
"""The configuration that should be used for a specific location."""
893
super(GlobalConfig, self).__init__(file_name=config_filename())
899
def from_string(cls, str_or_unicode, save=False):
900
"""Create a config object from a string.
902
:param str_or_unicode: A string representing the file content. This
903
will be utf-8 encoded.
905
:param save: Whether the file should be saved upon creation.
908
conf._create_from_string(str_or_unicode, save)
483
911
def get_editor(self):
484
912
return self._get_user_option('editor')
487
super(GlobalConfig, self).__init__(config_filename)
489
915
def set_user_option(self, option, value):
490
916
"""Save option and its value in the configuration."""
491
917
self._set_option(option, value, 'DEFAULT')
510
939
self._write_config_file()
512
941
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
943
self._get_parser().setdefault(section, {})[option] = value
518
944
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):
947
def _get_sections(self, name=None):
948
"""See IniBasedConfig._get_sections()."""
949
parser = self._get_parser()
950
# We don't give access to options defined outside of any section, we
951
# used the DEFAULT section by... default.
952
if name in (None, 'DEFAULT'):
953
# This could happen for an empty file where the DEFAULT section
954
# doesn't exist yet. So we force DEFAULT when yielding
956
if 'DEFAULT' not in parser:
957
parser['DEFAULT']= {}
958
yield (name, parser[name], self.config_id())
961
def remove_user_option(self, option_name, section_name=None):
962
if section_name is None:
963
# We need to force the default section.
964
section_name = 'DEFAULT'
965
# We need to avoid the LockableConfig implementation or we'll lock
967
super(LockableConfig, self).remove_user_option(option_name,
971
class LocationConfig(LockableConfig):
529
972
"""A configuration object that gives the policy for a location."""
531
974
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)
975
super(LocationConfig, self).__init__(
976
file_name=locations_config_filename())
544
977
# local file locations are looked up by local path, rather than
545
978
# by file url. This is because the config file is a user
546
979
# file, and we would rather not expose the user to file urls.
648
1109
STORE_LOCATION_APPENDPATH]:
649
1110
raise ValueError('bad storage policy %r for %r' %
650
1111
(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
1113
location = self.location
656
1114
if location.endswith('/'):
657
1115
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():
1116
parser = self._get_parser()
1117
if not location in parser and not location + '/' in parser:
1118
parser[location] = {}
1119
elif location + '/' in parser:
662
1120
location = location + '/'
663
self._get_parser()[location][option]=value
1121
parser[location][option]=value
664
1122
# the allowed values of store match the config policies
665
1123
self._set_option_policy(location, option, store)
666
self._get_parser().write(file(self._get_filename(), 'wb'))
1124
self._write_config_file()
669
1127
class BranchConfig(Config):
670
1128
"""A configuration object giving the policy for a branch."""
1130
def __init__(self, branch):
1131
super(BranchConfig, self).__init__()
1132
self._location_config = None
1133
self._branch_data_config = None
1134
self._global_config = None
1135
self.branch = branch
1136
self.option_sources = (self._get_location_config,
1137
self._get_branch_data_config,
1138
self._get_global_config)
1140
def config_id(self):
672
1143
def _get_branch_data_config(self):
673
1144
if self._branch_data_config is None:
674
1145
self._branch_data_config = TreeConfig(self.branch)
1146
self._branch_data_config.config_id = self.config_id
675
1147
return self._branch_data_config
677
1149
def _get_location_config(self):
1220
def _get_sections(self, name=None):
1221
"""See IniBasedConfig.get_sections()."""
1222
for source in self.option_sources:
1223
for section in source()._get_sections(name):
1226
def _get_options(self, sections=None):
1228
# First the locations options
1229
for option in self._get_location_config()._get_options():
1231
# Then the branch options
1232
branch_config = self._get_branch_data_config()
1233
if sections is None:
1234
sections = [('DEFAULT', branch_config._get_parser())]
1235
# FIXME: We shouldn't have to duplicate the code in IniBasedConfig but
1236
# Config itself has no notion of sections :( -- vila 20101001
1237
config_id = self.config_id()
1238
for (section_name, section) in sections:
1239
for (name, value) in section.iteritems():
1240
yield (name, value, section_name,
1241
config_id, branch_config._get_parser())
1242
# Then the global options
1243
for option in self._get_global_config()._get_options():
748
1246
def set_user_option(self, name, value, store=STORE_BRANCH,
749
1247
warn_masked=False):
750
1248
if store == STORE_BRANCH:
826
1317
def config_dir():
827
1318
"""Return per-user configuration directory.
829
By default this is ~/.bazaar/
1320
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1321
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1322
that will be used instead.
831
1324
TODO: Global option --config-dir to override this.
833
1326
base = os.environ.get('BZR_HOME', None)
834
1327
if sys.platform == 'win32':
1328
# environ variables on Windows are in user encoding/mbcs. So decode
1330
if base is not None:
1331
base = base.decode('mbcs')
835
1332
if base is None:
836
1333
base = win32utils.get_appdata_location_unicode()
837
1334
if base is None:
838
1335
base = os.environ.get('HOME', None)
1336
if base is not None:
1337
base = base.decode('mbcs')
839
1338
if base is None:
840
1339
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
842
1341
return osutils.pathjoin(base, 'bazaar', '2.0')
1342
elif sys.platform == 'darwin':
1344
# this takes into account $HOME
1345
base = os.path.expanduser("~")
1346
return osutils.pathjoin(base, '.bazaar')
844
# cygwin, linux, and darwin all have a $HOME directory
845
1348
if base is None:
1350
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1352
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1353
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1354
if osutils.isdir(xdg_dir):
1356
"Using configuration in XDG directory %s." % xdg_dir)
846
1359
base = os.path.expanduser("~")
847
1360
return osutils.pathjoin(base, ".bazaar")
899
1407
return os.path.expanduser('~/.cache')
1410
def _get_default_mail_domain():
1411
"""If possible, return the assumed default email domain.
1413
:returns: string mail domain, or None.
1415
if sys.platform == 'win32':
1416
# No implementation yet; patches welcome
1419
f = open('/etc/mailname')
1420
except (IOError, OSError), e:
1423
domain = f.read().strip()
902
1429
def _auto_user_id():
903
1430
"""Calculate automatic user identification.
905
Returns (realname, email).
1432
:returns: (realname, email), either of which may be None if they can't be
907
1435
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
1437
This only returns an email address if we can be fairly sure the
1438
address is reasonable, ie if /etc/mailname is set on unix.
1440
This doesn't use the FQDN as the default domain because that may be
1441
slow, and it doesn't use the hostname alone because that's not normally
1442
a reasonable address.
915
1444
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())
1445
# No implementation to reliably determine Windows default mail
1446
# address; please add one.
1449
default_mail_domain = _get_default_mail_domain()
1450
if not default_mail_domain:
1456
w = pwd.getpwuid(uid)
1458
mutter('no passwd entry for uid %d?' % uid)
1461
# we try utf-8 first, because on many variants (like Linux),
1462
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1463
# false positives. (many users will have their user encoding set to
1464
# latin-1, which cannot raise UnicodeError.)
1466
gecos = w.pw_gecos.decode('utf-8')
1468
except UnicodeError:
1470
encoding = osutils.get_user_encoding()
1471
gecos = w.pw_gecos.decode(encoding)
1472
except UnicodeError, e:
1473
mutter("cannot decode passwd entry %s" % w)
1476
username = w.pw_name.decode(encoding)
1477
except UnicodeError, e:
1478
mutter("cannot decode passwd entry %s" % w)
1481
comma = gecos.find(',')
1485
realname = gecos[:comma]
1487
return realname, (username + '@' + default_mail_domain)
975
1490
def parse_username(username):
1517
2055
return StringIO()
1519
2057
def _get_configobj(self):
1520
return ConfigObj(self._get_config_file(), encoding='utf-8')
2058
f = self._get_config_file()
2060
return ConfigObj(f, encoding='utf-8')
1522
2064
def _set_configobj(self, configobj):
1523
2065
out_file = StringIO()
1524
2066
configobj.write(out_file)
1525
2067
out_file.seek(0)
1526
2068
self._transport.put_file(self._filename, out_file)
2071
class cmd_config(commands.Command):
2072
__doc__ = """Display, set or remove a configuration option.
2074
Display the active value for a given option.
2076
If --all is specified, NAME is interpreted as a regular expression and all
2077
matching options are displayed mentioning their scope. The active value
2078
that bzr will take into account is the first one displayed for each option.
2080
If no NAME is given, --all .* is implied.
2082
Setting a value is achieved by using name=value without spaces. The value
2083
is set in the most relevant scope and can be checked by displaying the
2087
takes_args = ['name?']
2091
# FIXME: This should be a registry option so that plugins can register
2092
# their own config files (or not) -- vila 20101002
2093
commands.Option('scope', help='Reduce the scope to the specified'
2094
' configuration file',
2096
commands.Option('all',
2097
help='Display all the defined values for the matching options.',
2099
commands.Option('remove', help='Remove the option from'
2100
' the configuration file'),
2103
@commands.display_command
2104
def run(self, name=None, all=False, directory=None, scope=None,
2106
if directory is None:
2108
directory = urlutils.normalize_url(directory)
2110
raise errors.BzrError(
2111
'--all and --remove are mutually exclusive.')
2113
# Delete the option in the given scope
2114
self._remove_config_option(name, directory, scope)
2116
# Defaults to all options
2117
self._show_matching_options('.*', directory, scope)
2120
name, value = name.split('=', 1)
2122
# Display the option(s) value(s)
2124
self._show_matching_options(name, directory, scope)
2126
self._show_value(name, directory, scope)
2129
raise errors.BzrError(
2130
'Only one option can be set.')
2131
# Set the option value
2132
self._set_config_option(name, value, directory, scope)
2134
def _get_configs(self, directory, scope=None):
2135
"""Iterate the configurations specified by ``directory`` and ``scope``.
2137
:param directory: Where the configurations are derived from.
2139
:param scope: A specific config to start from.
2141
if scope is not None:
2142
if scope == 'bazaar':
2143
yield GlobalConfig()
2144
elif scope == 'locations':
2145
yield LocationConfig(directory)
2146
elif scope == 'branch':
2147
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2149
yield br.get_config()
2152
(_, br, _) = bzrdir.BzrDir.open_containing_tree_or_branch(
2154
yield br.get_config()
2155
except errors.NotBranchError:
2156
yield LocationConfig(directory)
2157
yield GlobalConfig()
2159
def _show_value(self, name, directory, scope):
2161
for c in self._get_configs(directory, scope):
2164
for (oname, value, section, conf_id, parser) in c._get_options():
2166
# Display only the first value and exit
2168
# FIXME: We need to use get_user_option to take policies
2169
# into account and we need to make sure the option exists
2170
# too (hence the two for loops), this needs a better API
2172
value = c.get_user_option(name)
2173
# Quote the value appropriately
2174
value = parser._quote(value)
2175
self.outf.write('%s\n' % (value,))
2179
raise errors.NoSuchConfigOption(name)
2181
def _show_matching_options(self, name, directory, scope):
2182
name = re.compile(name)
2183
# We want any error in the regexp to be raised *now* so we need to
2184
# avoid the delay introduced by the lazy regexp.
2185
name._compile_and_collapse()
2188
for c in self._get_configs(directory, scope):
2189
for (oname, value, section, conf_id, parser) in c._get_options():
2190
if name.search(oname):
2191
if cur_conf_id != conf_id:
2192
# Explain where the options are defined
2193
self.outf.write('%s:\n' % (conf_id,))
2194
cur_conf_id = conf_id
2196
if (section not in (None, 'DEFAULT')
2197
and cur_section != section):
2198
# Display the section if it's not the default (or only)
2200
self.outf.write(' [%s]\n' % (section,))
2201
cur_section = section
2202
self.outf.write(' %s = %s\n' % (oname, value))
2204
def _set_config_option(self, name, value, directory, scope):
2205
for conf in self._get_configs(directory, scope):
2206
conf.set_user_option(name, value)
2209
raise errors.NoSuchConfig(scope)
2211
def _remove_config_option(self, name, directory, scope):
2213
raise errors.BzrCommandError(
2214
'--remove expects an option to remove.')
2216
for conf in self._get_configs(directory, scope):
2217
for (section_name, section, conf_id) in conf._get_sections():
2218
if scope is not None and conf_id != scope:
2219
# Not the right configuration file
2222
if conf_id != conf.config_id():
2223
conf = self._get_configs(directory, conf_id).next()
2224
# We use the first section in the first config where the
2225
# option is defined to remove it
2226
conf.remove_user_option(name, section_name)
2231
raise errors.NoSuchConfig(scope)
2233
raise errors.NoSuchConfigOption(name)
added
removed
bzrlib/config.py
