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
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)
178
152
class Config(object):
214
188
def _get_signing_policy(self):
215
189
"""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)
341
191
def _get_user_option(self, option_name):
342
192
"""Template method to provide a user option."""
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):
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):
369
200
"""Get a generic option as a boolean - no special process, no default.
371
202
:return None if the option doesn't exist or its value can't be
372
203
interpreted as a boolean. Returns True or False otherwise.
374
s = self.get_user_option(option_name, expand=expand)
205
s = self._get_user_option(option_name)
376
207
# The option doesn't exist
967
773
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)
1026
777
class LocationConfig(LockableConfig):
1027
778
"""A configuration object that gives the policy for a location."""
1057
808
def _get_matching_sections(self):
1058
809
"""Return an ordered list of section names matching this location."""
1059
matches = list(_iter_for_location_by_parts(self._get_parser(),
810
sections = self._get_parser()
811
location_names = self.location.split('/')
812
if self.location.endswith('/'):
813
del location_names[-1]
815
for section in sections:
816
# location is a local path if possible, so we need
817
# to convert 'file://' urls to local paths if necessary.
818
# This also avoids having file:///path be a more exact
819
# match than '/path'.
820
if section.startswith('file://'):
821
section_path = urlutils.local_path_from_url(section)
823
section_path = section
824
section_names = section_path.split('/')
825
if section.endswith('/'):
826
del section_names[-1]
827
names = zip(location_names, section_names)
830
if not fnmatch.fnmatch(name[0], name[1]):
835
# so, for the common prefix they matched.
836
# if section is longer, no match.
837
if len(section_names) > len(location_names):
839
matches.append((len(section_names), section,
840
'/'.join(location_names[len(section_names):])))
1061
841
# put the longest (aka more specific) locations first
1063
key=lambda (section, extra_path, length): (length, section),
1065
for (section, extra_path, length) in matches:
1066
yield section, extra_path
842
matches.sort(reverse=True)
844
for (length, section, extra_path) in matches:
845
sections.append((section, extra_path))
1067
846
# should we stop looking for parent configs here?
1069
848
if self._get_parser()[section].as_bool('ignore_parents'):
1071
850
except KeyError:
1074
854
def _get_sections(self, name=None):
1075
855
"""See IniBasedConfig._get_sections()."""
1343
1123
def config_dir():
1344
1124
"""Return per-user configuration directory.
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
By default this is ~/.bazaar/
1350
1128
TODO: Global option --config-dir to override this.
1352
1130
base = os.environ.get('BZR_HOME', None)
1353
1131
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')
1358
1132
if base is None:
1359
1133
base = win32utils.get_appdata_location_unicode()
1360
1134
if base is None:
1361
1135
base = os.environ.get('HOME', None)
1362
if base is not None:
1363
base = base.decode('mbcs')
1364
1136
if base is None:
1365
1137
raise errors.BzrError('You must have one of BZR_HOME, APPDATA,'
1366
1138
' or HOME set')
1367
1139
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')
1374
1141
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)
1385
1142
base = os.path.expanduser("~")
1386
1143
return osutils.pathjoin(base, ".bazaar")
1433
1190
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)
1516
1193
def parse_username(username):
1517
1194
"""Parse e-mail username and return a (name, address) tuple."""
1518
1195
match = re.match(r'(.*?)\s*<?([\w+.-]+@[\w+.-]+)>?', username)
added
removed
bzrlib/config.py
