132
def ConfigObj(*args, **kwargs):
134
if _ConfigObj is None:
135
class ConfigObj(configobj.ConfigObj):
137
def get_bool(self, section, key):
138
return self[section].as_bool(key)
140
def get_value(self, section, name):
141
# Try [] for the old DEFAULT section.
142
if section == "DEFAULT":
147
return self[section][name]
148
_ConfigObj = ConfigObj
149
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
152
178
class Config(object):
188
214
def _get_signing_policy(self):
189
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)
191
341
def _get_user_option(self, option_name):
192
342
"""Template method to provide a user option."""
195
def get_user_option(self, option_name):
196
"""Get a generic option - no special process, no default."""
197
return self._get_user_option(option_name)
199
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):
200
369
"""Get a generic option as a boolean - no special process, no default.
202
371
:return None if the option doesn't exist or its value can't be
203
372
interpreted as a boolean. Returns True or False otherwise.
205
s = self._get_user_option(option_name)
374
s = self.get_user_option(option_name, expand=expand)
207
376
# The option doesn't exist
772
967
super(LockableConfig, self).remove_user_option(option_name,
970
def _iter_for_location_by_parts(sections, location):
971
"""Keep only the sessions matching the specified location.
973
:param sections: An iterable of section names.
975
:param location: An url or a local path to match against.
977
:returns: An iterator of (section, extra_path, nb_parts) where nb is the
978
number of path components in the section name, section is the section
979
name and extra_path is the difference between location and the section
982
location_parts = location.rstrip('/').split('/')
984
for section in sections:
985
# location is a local path if possible, so we need
986
# to convert 'file://' urls to local paths if necessary.
988
# FIXME: I don't think the above comment is still up to date,
989
# LocationConfig is always instantiated with an url -- vila 2011-04-07
991
# This also avoids having file:///path be a more exact
992
# match than '/path'.
994
# FIXME: Not sure about the above either, but since the path components
995
# are compared in sync, adding two empty components (//) is likely to
996
# trick the comparison and also trick the check on the number of
997
# components, so we *should* take only the relevant part of the url. On
998
# the other hand, this means 'file://' urls *can't* be used in sections
999
# so more work is probably needed -- vila 2011-04-07
1001
if section.startswith('file://'):
1002
section_path = urlutils.local_path_from_url(section)
1004
section_path = section
1005
section_parts = section_path.rstrip('/').split('/')
1008
if len(section_parts) > len(location_parts):
1009
# More path components in the section, they can't match
1012
# Rely on zip truncating in length to the length of the shortest
1013
# argument sequence.
1014
names = zip(location_parts, section_parts)
1016
if not fnmatch.fnmatch(name[0], name[1]):
1021
# build the path difference between the section and the location
1022
extra_path = '/'.join(location_parts[len(section_parts):])
1023
yield section, extra_path, len(section_parts)
776
1026
class LocationConfig(LockableConfig):
777
1027
"""A configuration object that gives the policy for a location."""
807
1057
def _get_matching_sections(self):
808
1058
"""Return an ordered list of section names matching this location."""
809
sections = self._get_parser()
810
location_names = self.location.split('/')
811
if self.location.endswith('/'):
812
del location_names[-1]
814
for section in sections:
815
# location is a local path if possible, so we need
816
# to convert 'file://' urls to local paths if necessary.
817
# This also avoids having file:///path be a more exact
818
# match than '/path'.
819
if section.startswith('file://'):
820
section_path = urlutils.local_path_from_url(section)
822
section_path = section
823
section_names = section_path.split('/')
824
if section.endswith('/'):
825
del section_names[-1]
826
names = zip(location_names, section_names)
829
if not fnmatch.fnmatch(name[0], name[1]):
834
# so, for the common prefix they matched.
835
# if section is longer, no match.
836
if len(section_names) > len(location_names):
838
matches.append((len(section_names), section,
839
'/'.join(location_names[len(section_names):])))
1059
matches = list(_iter_for_location_by_parts(self._get_parser(),
840
1061
# put the longest (aka more specific) locations first
841
matches.sort(reverse=True)
843
for (length, section, extra_path) in matches:
844
sections.append((section, extra_path))
1063
key=lambda (section, extra_path, length): (length, section),
1065
for (section, extra_path, length) in matches:
1066
yield section, extra_path
845
1067
# should we stop looking for parent configs here?
847
1069
if self._get_parser()[section].as_bool('ignore_parents'):
849
1071
except KeyError:
853
1074
def _get_sections(self, name=None):
854
1075
"""See IniBasedConfig._get_sections()."""
1121
1343
def config_dir():
1122
1344
"""Return per-user configuration directory.
1124
By default this is ~/.bazaar/
1346
By default this is %APPDATA%/bazaar/2.0 on Windows, ~/.bazaar on Mac OS X
1347
and Linux. On Linux, if there is a $XDG_CONFIG_HOME/bazaar directory,
1348
that will be used instead.
1126
1350
TODO: Global option --config-dir to override this.
1128
1352
base = os.environ.get('BZR_HOME', None)
1129
1353
if sys.platform == 'win32':
1354
# environ variables on Windows are in user encoding/mbcs. So decode
1356
if base is not None:
1357
base = base.decode('mbcs')
1130
1358
if base is None:
1131
1359
base = win32utils.get_appdata_location_unicode()
1132
1360
if base is None:
1133
1361
base = os.environ.get('HOME', None)
1362
if base is not None:
1363
base = base.decode('mbcs')
1134
1364
if base is None:
1135
1365
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1136
1366
' or HOME set')
1137
1367
return osutils.pathjoin(base, 'bazaar', '2.0')
1368
elif sys.platform == 'darwin':
1370
# this takes into account $HOME
1371
base = os.path.expanduser("~")
1372
return osutils.pathjoin(base, '.bazaar')
1139
1374
if base is None:
1376
xdg_dir = os.environ.get('XDG_CONFIG_HOME', None)
1378
xdg_dir = osutils.pathjoin(os.path.expanduser("~"), ".config")
1379
xdg_dir = osutils.pathjoin(xdg_dir, 'bazaar')
1380
if osutils.isdir(xdg_dir):
1382
"Using configuration in XDG directory %s." % xdg_dir)
1140
1385
base = os.path.expanduser("~")
1141
1386
return osutils.pathjoin(base, ".bazaar")
1188
1433
return os.path.expanduser('~/.cache')
1436
def _get_default_mail_domain():
1437
"""If possible, return the assumed default email domain.
1439
:returns: string mail domain, or None.
1441
if sys.platform == 'win32':
1442
# No implementation yet; patches welcome
1445
f = open('/etc/mailname')
1446
except (IOError, OSError), e:
1449
domain = f.read().strip()
1455
def _auto_user_id():
1456
"""Calculate automatic user identification.
1458
:returns: (realname, email), either of which may be None if they can't be
1461
Only used when none is set in the environment or the id file.
1463
This only returns an email address if we can be fairly sure the
1464
address is reasonable, ie if /etc/mailname is set on unix.
1466
This doesn't use the FQDN as the default domain because that may be
1467
slow, and it doesn't use the hostname alone because that's not normally
1468
a reasonable address.
1470
if sys.platform == 'win32':
1471
# No implementation to reliably determine Windows default mail
1472
# address; please add one.
1475
default_mail_domain = _get_default_mail_domain()
1476
if not default_mail_domain:
1482
w = pwd.getpwuid(uid)
1484
mutter('no passwd entry for uid %d?' % uid)
1487
# we try utf-8 first, because on many variants (like Linux),
1488
# /etc/passwd "should" be in utf-8, and because it's unlikely to give
1489
# false positives. (many users will have their user encoding set to
1490
# latin-1, which cannot raise UnicodeError.)
1492
gecos = w.pw_gecos.decode('utf-8')
1494
except UnicodeError:
1496
encoding = osutils.get_user_encoding()
1497
gecos = w.pw_gecos.decode(encoding)
1498
except UnicodeError, e:
1499
mutter("cannot decode passwd entry %s" % w)
1502
username = w.pw_name.decode(encoding)
1503
except UnicodeError, e:
1504
mutter("cannot decode passwd entry %s" % w)
1507
comma = gecos.find(',')
1511
realname = gecos[:comma]
1513
return realname, (username + '@' + default_mail_domain)
1191
1516
def parse_username(username):
1192
1517
"""Parse e-mail username and return a (name, address) tuple."""
1193
1518
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
1791
2119
commands.Option('scope', help='Reduce the scope to the specified'
1792
2120
' configuration file',
2122
commands.Option('all',
2123
help='Display all the defined values for the matching options.',
1794
2125
commands.Option('remove', help='Remove the option from'
1795
2126
' the configuration file'),
1798
2129
@commands.display_command
1799
def run(self, matching=None, directory=None, scope=None, remove=False):
2130
def run(self, name=None, all=False, directory=None, scope=None,
1800
2132
if directory is None:
1801
2133
directory = '.'
1802
2134
directory = urlutils.normalize_url(directory)
1803
if matching is None:
1804
self._show_config('*', directory)
2136
raise errors.BzrError(
2137
'--all and --remove are mutually exclusive.')
2139
# Delete the option in the given scope
2140
self._remove_config_option(name, directory, scope)
2142
# Defaults to all options
2143
self._show_matching_options('.*', directory, scope)
1807
self._remove_config_option(matching, directory, scope)
2146
name, value = name.split('=', 1)
2148
# Display the option(s) value(s)
2150
self._show_matching_options(name, directory, scope)
2152
self._show_value(name, directory, scope)
1809
pos = matching.find('=')
1811
self._show_config(matching, directory)
1813
self._set_config_option(matching[:pos], matching[pos+1:],
2155
raise errors.BzrError(
2156
'Only one option can be set.')
2157
# Set the option value
2158
self._set_config_option(name, value, directory, scope)
1816
2160
def _get_configs(self, directory, scope=None):
1817
2161
"""Iterate the configurations specified by ``directory`` and ``scope``.
1838
2182
yield LocationConfig(directory)
1839
2183
yield GlobalConfig()
1841
def _show_config(self, matching, directory):
1842
# Turn the glob into a regexp
1843
matching_re = re.compile(fnmatch.translate(matching))
2185
def _show_value(self, name, directory, scope):
2187
for c in self._get_configs(directory, scope):
2190
for (oname, value, section, conf_id, parser) in c._get_options():
2192
# Display only the first value and exit
2194
# FIXME: We need to use get_user_option to take policies
2195
# into account and we need to make sure the option exists
2196
# too (hence the two for loops), this needs a better API
2198
value = c.get_user_option(name)
2199
# Quote the value appropriately
2200
value = parser._quote(value)
2201
self.outf.write('%s\n' % (value,))
2205
raise errors.NoSuchConfigOption(name)
2207
def _show_matching_options(self, name, directory, scope):
2208
name = re.compile(name)
2209
# We want any error in the regexp to be raised *now* so we need to
2210
# avoid the delay introduced by the lazy regexp.
2211
name._compile_and_collapse()
1844
2212
cur_conf_id = None
1845
for c in self._get_configs(directory):
1846
for (name, value, section, conf_id) in c._get_options():
1847
if matching_re.search(name):
2214
for c in self._get_configs(directory, scope):
2215
for (oname, value, section, conf_id, parser) in c._get_options():
2216
if name.search(oname):
1848
2217
if cur_conf_id != conf_id:
2218
# Explain where the options are defined
1849
2219
self.outf.write('%s:\n' % (conf_id,))
1850
2220
cur_conf_id = conf_id
1851
self.outf.write(' %s = %s\n' % (name, value))
2222
if (section not in (None, 'DEFAULT')
2223
and cur_section != section):
2224
# Display the section if it's not the default (or only)
2226
self.outf.write(' [%s]\n' % (section,))
2227
cur_section = section
2228
self.outf.write(' %s = %s\n' % (oname, value))
1853
2230
def _set_config_option(self, name, value, directory, scope):
1854
2231
for conf in self._get_configs(directory, scope):
added
removed
bzrlib/config.py
