~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Robert Collins
  • Date: 2005-10-02 22:47:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1397.
  • Revision ID: robertc@robertcollins.net-20051002224701-8a8b20b90de559a6
support ghosts in commits

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 by Canonical Ltd
2
 
#   Authors: Robert Collins <robert.collins@canonical.com>
3
 
#
4
 
# This program is free software; you can redistribute it and/or modify
5
 
# it under the terms of the GNU General Public License as published by
6
 
# the Free Software Foundation; either version 2 of the License, or
7
 
# (at your option) any later version.
8
 
#
9
 
# This program is distributed in the hope that it will be useful,
10
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 
# GNU General Public License for more details.
13
 
#
14
 
# You should have received a copy of the GNU General Public License
15
 
# along with this program; if not, write to the Free Software
16
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 
 
18
 
"""Configuration that affects the behaviour of Bazaar.
19
 
 
20
 
Currently this configuration resides in ~/.bazaar/bazaar.conf
21
 
and ~/.bazaar/locations.conf, which is written to by bzr.
22
 
 
23
 
In bazaar.conf the following options may be set:
24
 
[DEFAULT]
25
 
editor=name-of-program
26
 
email=Your Name <your@email.address>
27
 
check_signatures=require|ignore|check-available(default)
28
 
create_signatures=always|never|when-required(default)
29
 
gpg_signing_command=name-of-program
30
 
log_format=name-of-format
31
 
 
32
 
in locations.conf, you specify the url of a branch and options for it.
33
 
Wildcards may be used - * and ? as normal in shell completion. Options
34
 
set in both bazaar.conf and locations.conf are overridden by the locations.conf
35
 
setting.
36
 
[/home/robertc/source]
37
 
recurse=False|True(default)
38
 
email= as above
39
 
check_signatures= as above 
40
 
create_signatures= as above.
41
 
 
42
 
explanation of options
43
 
----------------------
44
 
editor - this option sets the pop up editor to use during commits.
45
 
email - this option sets the user id bzr will use when committing.
46
 
check_signatures - this option controls whether bzr will require good gpg
47
 
                   signatures, ignore them, or check them if they are 
48
 
                   present.
49
 
create_signatures - this option controls whether bzr will always create 
50
 
                    gpg signatures, never create them, or create them if the
51
 
                    branch is configured to require them.
52
 
log_format - this option sets the default log format.  Possible values are
53
 
             long, short, line, or a plugin can register new formats.
54
 
 
55
 
In bazaar.conf you can also define aliases in the ALIASES sections, example
56
 
 
57
 
[ALIASES]
58
 
lastlog=log --line -r-10..-1
59
 
ll=log --line -r-10..-1
60
 
h=help
61
 
up=pull
62
 
"""
63
 
 
64
 
 
65
 
import errno
66
 
from fnmatch import fnmatch
67
 
import os
68
 
import re
69
 
import sys
70
 
from StringIO import StringIO
71
 
 
72
 
import bzrlib
73
 
from bzrlib import errors, urlutils
74
 
from bzrlib.osutils import pathjoin
75
 
from bzrlib.trace import mutter, warning
76
 
import bzrlib.util.configobj.configobj as configobj
77
 
 
78
 
 
79
 
CHECK_IF_POSSIBLE=0
80
 
CHECK_ALWAYS=1
81
 
CHECK_NEVER=2
82
 
 
83
 
 
84
 
SIGN_WHEN_REQUIRED=0
85
 
SIGN_ALWAYS=1
86
 
SIGN_NEVER=2
87
 
 
88
 
 
89
 
class ConfigObj(configobj.ConfigObj):
90
 
 
91
 
    def get_bool(self, section, key):
92
 
        return self[section].as_bool(key)
93
 
 
94
 
    def get_value(self, section, name):
95
 
        # Try [] for the old DEFAULT section.
96
 
        if section == "DEFAULT":
97
 
            try:
98
 
                return self[name]
99
 
            except KeyError:
100
 
                pass
101
 
        return self[section][name]
102
 
 
103
 
 
104
 
class Config(object):
105
 
    """A configuration policy - what username, editor, gpg needs etc."""
106
 
 
107
 
    def get_editor(self):
108
 
        """Get the users pop up editor."""
109
 
        raise NotImplementedError
110
 
 
111
 
    def _get_signature_checking(self):
112
 
        """Template method to override signature checking policy."""
113
 
 
114
 
    def _get_signing_policy(self):
115
 
        """Template method to override signature creation policy."""
116
 
 
117
 
    def _get_user_option(self, option_name):
118
 
        """Template method to provide a user option."""
119
 
        return None
120
 
 
121
 
    def get_user_option(self, option_name):
122
 
        """Get a generic option - no special process, no default."""
123
 
        return self._get_user_option(option_name)
124
 
 
125
 
    def gpg_signing_command(self):
126
 
        """What program should be used to sign signatures?"""
127
 
        result = self._gpg_signing_command()
128
 
        if result is None:
129
 
            result = "gpg"
130
 
        return result
131
 
 
132
 
    def _gpg_signing_command(self):
133
 
        """See gpg_signing_command()."""
134
 
        return None
135
 
 
136
 
    def log_format(self):
137
 
        """What log format should be used"""
138
 
        result = self._log_format()
139
 
        if result is None:
140
 
            result = "long"
141
 
        return result
142
 
 
143
 
    def _log_format(self):
144
 
        """See log_format()."""
145
 
        return None
146
 
 
147
 
    def __init__(self):
148
 
        super(Config, self).__init__()
149
 
 
150
 
    def post_commit(self):
151
 
        """An ordered list of python functions to call.
152
 
 
153
 
        Each function takes branch, rev_id as parameters.
154
 
        """
155
 
        return self._post_commit()
156
 
 
157
 
    def _post_commit(self):
158
 
        """See Config.post_commit."""
159
 
        return None
160
 
 
161
 
    def user_email(self):
162
 
        """Return just the email component of a username."""
163
 
        return extract_email_address(self.username())
164
 
 
165
 
    def username(self):
166
 
        """Return email-style username.
167
 
    
168
 
        Something similar to 'Martin Pool <mbp@sourcefrog.net>'
169
 
        
170
 
        $BZR_EMAIL can be set to override this (as well as the
171
 
        deprecated $BZREMAIL), then
172
 
        the concrete policy type is checked, and finally
173
 
        $EMAIL is examined.
174
 
        If none is found, a reasonable default is (hopefully)
175
 
        created.
176
 
    
177
 
        TODO: Check it's reasonably well-formed.
178
 
        """
179
 
        v = os.environ.get('BZR_EMAIL')
180
 
        if v:
181
 
            return v.decode(bzrlib.user_encoding)
182
 
        v = os.environ.get('BZREMAIL')
183
 
        if v:
184
 
            warning('BZREMAIL is deprecated in favor of BZR_EMAIL. Please update your configuration.')
185
 
            return v.decode(bzrlib.user_encoding)
186
 
    
187
 
        v = self._get_user_id()
188
 
        if v:
189
 
            return v
190
 
        
191
 
        v = os.environ.get('EMAIL')
192
 
        if v:
193
 
            return v.decode(bzrlib.user_encoding)
194
 
 
195
 
        name, email = _auto_user_id()
196
 
        if name:
197
 
            return '%s <%s>' % (name, email)
198
 
        else:
199
 
            return email
200
 
 
201
 
    def signature_checking(self):
202
 
        """What is the current policy for signature checking?."""
203
 
        policy = self._get_signature_checking()
204
 
        if policy is not None:
205
 
            return policy
206
 
        return CHECK_IF_POSSIBLE
207
 
 
208
 
    def signing_policy(self):
209
 
        """What is the current policy for signature checking?."""
210
 
        policy = self._get_signing_policy()
211
 
        if policy is not None:
212
 
            return policy
213
 
        return SIGN_WHEN_REQUIRED
214
 
 
215
 
    def signature_needed(self):
216
 
        """Is a signature needed when committing ?."""
217
 
        policy = self._get_signing_policy()
218
 
        if policy is None:
219
 
            policy = self._get_signature_checking()
220
 
            if policy is not None:
221
 
                warning("Please use create_signatures, not check_signatures "
222
 
                        "to set signing policy.")
223
 
            if policy == CHECK_ALWAYS:
224
 
                return True
225
 
        elif policy == SIGN_ALWAYS:
226
 
            return True
227
 
        return False
228
 
 
229
 
    def get_alias(self, value):
230
 
        return self._get_alias(value)
231
 
 
232
 
    def _get_alias(self, value):
233
 
        pass
234
 
 
235
 
    def get_nickname(self):
236
 
        return self._get_nickname()
237
 
 
238
 
    def _get_nickname(self):
239
 
        return None
240
 
 
241
 
 
242
 
class IniBasedConfig(Config):
243
 
    """A configuration policy that draws from ini files."""
244
 
 
245
 
    def _get_parser(self, file=None):
246
 
        if self._parser is not None:
247
 
            return self._parser
248
 
        if file is None:
249
 
            input = self._get_filename()
250
 
        else:
251
 
            input = file
252
 
        try:
253
 
            self._parser = ConfigObj(input, encoding='utf-8')
254
 
        except configobj.ConfigObjError, e:
255
 
            raise errors.ParseConfigError(e.errors, e.config.filename)
256
 
        return self._parser
257
 
 
258
 
    def _get_section(self):
259
 
        """Override this to define the section used by the config."""
260
 
        return "DEFAULT"
261
 
 
262
 
    def _get_signature_checking(self):
263
 
        """See Config._get_signature_checking."""
264
 
        policy = self._get_user_option('check_signatures')
265
 
        if policy:
266
 
            return self._string_to_signature_policy(policy)
267
 
 
268
 
    def _get_signing_policy(self):
269
 
        """See Config._get_signing_policy"""
270
 
        policy = self._get_user_option('create_signatures')
271
 
        if policy:
272
 
            return self._string_to_signing_policy(policy)
273
 
 
274
 
    def _get_user_id(self):
275
 
        """Get the user id from the 'email' key in the current section."""
276
 
        return self._get_user_option('email')
277
 
 
278
 
    def _get_user_option(self, option_name):
279
 
        """See Config._get_user_option."""
280
 
        try:
281
 
            return self._get_parser().get_value(self._get_section(),
282
 
                                                option_name)
283
 
        except KeyError:
284
 
            pass
285
 
 
286
 
    def _gpg_signing_command(self):
287
 
        """See Config.gpg_signing_command."""
288
 
        return self._get_user_option('gpg_signing_command')
289
 
 
290
 
    def _log_format(self):
291
 
        """See Config.log_format."""
292
 
        return self._get_user_option('log_format')
293
 
 
294
 
    def __init__(self, get_filename):
295
 
        super(IniBasedConfig, self).__init__()
296
 
        self._get_filename = get_filename
297
 
        self._parser = None
298
 
        
299
 
    def _post_commit(self):
300
 
        """See Config.post_commit."""
301
 
        return self._get_user_option('post_commit')
302
 
 
303
 
    def _string_to_signature_policy(self, signature_string):
304
 
        """Convert a string to a signing policy."""
305
 
        if signature_string.lower() == 'check-available':
306
 
            return CHECK_IF_POSSIBLE
307
 
        if signature_string.lower() == 'ignore':
308
 
            return CHECK_NEVER
309
 
        if signature_string.lower() == 'require':
310
 
            return CHECK_ALWAYS
311
 
        raise errors.BzrError("Invalid signatures policy '%s'"
312
 
                              % signature_string)
313
 
 
314
 
    def _string_to_signing_policy(self, signature_string):
315
 
        """Convert a string to a signing policy."""
316
 
        if signature_string.lower() == 'when-required':
317
 
            return SIGN_WHEN_REQUIRED
318
 
        if signature_string.lower() == 'never':
319
 
            return SIGN_NEVER
320
 
        if signature_string.lower() == 'always':
321
 
            return SIGN_ALWAYS
322
 
        raise errors.BzrError("Invalid signing policy '%s'"
323
 
                              % signature_string)
324
 
 
325
 
    def _get_alias(self, value):
326
 
        try:
327
 
            return self._get_parser().get_value("ALIASES", 
328
 
                                                value)
329
 
        except KeyError:
330
 
            pass
331
 
 
332
 
    def _get_nickname(self):
333
 
        return self.get_user_option('nickname')
334
 
 
335
 
 
336
 
class GlobalConfig(IniBasedConfig):
337
 
    """The configuration that should be used for a specific location."""
338
 
 
339
 
    def get_editor(self):
340
 
        return self._get_user_option('editor')
341
 
 
342
 
    def __init__(self):
343
 
        super(GlobalConfig, self).__init__(config_filename)
344
 
 
345
 
    def set_user_option(self, option, value):
346
 
        """Save option and its value in the configuration."""
347
 
        # FIXME: RBC 20051029 This should refresh the parser and also take a
348
 
        # file lock on bazaar.conf.
349
 
        conf_dir = os.path.dirname(self._get_filename())
350
 
        ensure_config_dir_exists(conf_dir)
351
 
        if 'DEFAULT' not in self._get_parser():
352
 
            self._get_parser()['DEFAULT'] = {}
353
 
        self._get_parser()['DEFAULT'][option] = value
354
 
        f = open(self._get_filename(), 'wb')
355
 
        self._get_parser().write(f)
356
 
        f.close()
357
 
 
358
 
 
359
 
class LocationConfig(IniBasedConfig):
360
 
    """A configuration object that gives the policy for a location."""
361
 
 
362
 
    def __init__(self, location):
363
 
        name_generator = locations_config_filename
364
 
        if (not os.path.exists(name_generator()) and 
365
 
                os.path.exists(branches_config_filename())):
366
 
            if sys.platform == 'win32':
367
 
                warning('Please rename %s to %s' 
368
 
                         % (branches_config_filename(),
369
 
                            locations_config_filename()))
370
 
            else:
371
 
                warning('Please rename ~/.bazaar/branches.conf'
372
 
                        ' to ~/.bazaar/locations.conf')
373
 
            name_generator = branches_config_filename
374
 
        super(LocationConfig, self).__init__(name_generator)
375
 
        # local file locations are looked up by local path, rather than
376
 
        # by file url. This is because the config file is a user
377
 
        # file, and we would rather not expose the user to file urls.
378
 
        if location.startswith('file://'):
379
 
            location = urlutils.local_path_from_url(location)
380
 
        self.location = location
381
 
 
382
 
    def _get_section(self):
383
 
        """Get the section we should look in for config items.
384
 
 
385
 
        Returns None if none exists. 
386
 
        TODO: perhaps return a NullSection that thunks through to the 
387
 
              global config.
388
 
        """
389
 
        sections = self._get_parser()
390
 
        location_names = self.location.split('/')
391
 
        if self.location.endswith('/'):
392
 
            del location_names[-1]
393
 
        matches=[]
394
 
        for section in sections:
395
 
            # location is a local path if possible, so we need
396
 
            # to convert 'file://' urls to local paths if necessary.
397
 
            # This also avoids having file:///path be a more exact
398
 
            # match than '/path'.
399
 
            if section.startswith('file://'):
400
 
                section_path = urlutils.local_path_from_url(section)
401
 
            else:
402
 
                section_path = section
403
 
            section_names = section_path.split('/')
404
 
            if section.endswith('/'):
405
 
                del section_names[-1]
406
 
            names = zip(location_names, section_names)
407
 
            matched = True
408
 
            for name in names:
409
 
                if not fnmatch(name[0], name[1]):
410
 
                    matched = False
411
 
                    break
412
 
            if not matched:
413
 
                continue
414
 
            # so, for the common prefix they matched.
415
 
            # if section is longer, no match.
416
 
            if len(section_names) > len(location_names):
417
 
                continue
418
 
            # if path is longer, and recurse is not true, no match
419
 
            if len(section_names) < len(location_names):
420
 
                try:
421
 
                    if not self._get_parser()[section].as_bool('recurse'):
422
 
                        continue
423
 
                except KeyError:
424
 
                    pass
425
 
            matches.append((len(section_names), section))
426
 
        if not len(matches):
427
 
            return None
428
 
        matches.sort(reverse=True)
429
 
        return matches[0][1]
430
 
 
431
 
    def set_user_option(self, option, value):
432
 
        """Save option and its value in the configuration."""
433
 
        # FIXME: RBC 20051029 This should refresh the parser and also take a
434
 
        # file lock on locations.conf.
435
 
        conf_dir = os.path.dirname(self._get_filename())
436
 
        ensure_config_dir_exists(conf_dir)
437
 
        location = self.location
438
 
        if location.endswith('/'):
439
 
            location = location[:-1]
440
 
        if (not location in self._get_parser() and
441
 
            not location + '/' in self._get_parser()):
442
 
            self._get_parser()[location]={}
443
 
        elif location + '/' in self._get_parser():
444
 
            location = location + '/'
445
 
        self._get_parser()[location][option]=value
446
 
        self._get_parser().write(file(self._get_filename(), 'wb'))
447
 
 
448
 
 
449
 
class BranchConfig(Config):
450
 
    """A configuration object giving the policy for a branch."""
451
 
 
452
 
    def _get_branch_data_config(self):
453
 
        if self._branch_data_config is None:
454
 
            self._branch_data_config = TreeConfig(self.branch)
455
 
        return self._branch_data_config
456
 
 
457
 
    def _get_location_config(self):
458
 
        if self._location_config is None:
459
 
            self._location_config = LocationConfig(self.branch.base)
460
 
        return self._location_config
461
 
 
462
 
    def _get_global_config(self):
463
 
        if self._global_config is None:
464
 
            self._global_config = GlobalConfig()
465
 
        return self._global_config
466
 
 
467
 
    def _get_best_value(self, option_name):
468
 
        """This returns a user option from local, tree or global config.
469
 
 
470
 
        They are tried in that order.  Use get_safe_value if trusted values
471
 
        are necessary.
472
 
        """
473
 
        for source in self.option_sources:
474
 
            value = getattr(source(), option_name)()
475
 
            if value is not None:
476
 
                return value
477
 
        return None
478
 
 
479
 
    def _get_safe_value(self, option_name):
480
 
        """This variant of get_best_value never returns untrusted values.
481
 
        
482
 
        It does not return values from the branch data, because the branch may
483
 
        not be controlled by the user.
484
 
 
485
 
        We may wish to allow locations.conf to control whether branches are
486
 
        trusted in the future.
487
 
        """
488
 
        for source in (self._get_location_config, self._get_global_config):
489
 
            value = getattr(source(), option_name)()
490
 
            if value is not None:
491
 
                return value
492
 
        return None
493
 
 
494
 
    def _get_user_id(self):
495
 
        """Return the full user id for the branch.
496
 
    
497
 
        e.g. "John Hacker <jhacker@foo.org>"
498
 
        This is looked up in the email controlfile for the branch.
499
 
        """
500
 
        try:
501
 
            return (self.branch.control_files.get_utf8("email") 
502
 
                    .read()
503
 
                    .decode(bzrlib.user_encoding)
504
 
                    .rstrip("\r\n"))
505
 
        except errors.NoSuchFile, e:
506
 
            pass
507
 
        
508
 
        return self._get_best_value('_get_user_id')
509
 
 
510
 
    def _get_signature_checking(self):
511
 
        """See Config._get_signature_checking."""
512
 
        return self._get_best_value('_get_signature_checking')
513
 
 
514
 
    def _get_signing_policy(self):
515
 
        """See Config._get_signing_policy."""
516
 
        return self._get_best_value('_get_signing_policy')
517
 
 
518
 
    def _get_user_option(self, option_name):
519
 
        """See Config._get_user_option."""
520
 
        for source in self.option_sources:
521
 
            value = source()._get_user_option(option_name)
522
 
            if value is not None:
523
 
                return value
524
 
        return None
525
 
 
526
 
    def set_user_option(self, name, value, local=False):
527
 
        if local is True:
528
 
            self._get_location_config().set_user_option(name, value)
529
 
        else:
530
 
            self._get_branch_data_config().set_option(value, name)
531
 
 
532
 
 
533
 
    def _gpg_signing_command(self):
534
 
        """See Config.gpg_signing_command."""
535
 
        return self._get_safe_value('_gpg_signing_command')
536
 
        
537
 
    def __init__(self, branch):
538
 
        super(BranchConfig, self).__init__()
539
 
        self._location_config = None
540
 
        self._branch_data_config = None
541
 
        self._global_config = None
542
 
        self.branch = branch
543
 
        self.option_sources = (self._get_location_config, 
544
 
                               self._get_branch_data_config,
545
 
                               self._get_global_config)
546
 
 
547
 
    def _post_commit(self):
548
 
        """See Config.post_commit."""
549
 
        return self._get_safe_value('_post_commit')
550
 
 
551
 
    def _get_nickname(self):
552
 
        value = self._get_explicit_nickname()
553
 
        if value is not None:
554
 
            return value
555
 
        return self.branch.base.split('/')[-2]
556
 
 
557
 
    def has_explicit_nickname(self):
558
 
        """Return true if a nickname has been explicitly assigned."""
559
 
        return self._get_explicit_nickname() is not None
560
 
 
561
 
    def _get_explicit_nickname(self):
562
 
        return self._get_best_value('_get_nickname')
563
 
 
564
 
    def _log_format(self):
565
 
        """See Config.log_format."""
566
 
        return self._get_best_value('_log_format')
567
 
 
568
 
 
569
 
def ensure_config_dir_exists(path=None):
570
 
    """Make sure a configuration directory exists.
571
 
    This makes sure that the directory exists.
572
 
    On windows, since configuration directories are 2 levels deep,
573
 
    it makes sure both the directory and the parent directory exists.
574
 
    """
575
 
    if path is None:
576
 
        path = config_dir()
577
 
    if not os.path.isdir(path):
578
 
        if sys.platform == 'win32':
579
 
            parent_dir = os.path.dirname(path)
580
 
            if not os.path.isdir(parent_dir):
581
 
                mutter('creating config parent directory: %r', parent_dir)
582
 
            os.mkdir(parent_dir)
583
 
        mutter('creating config directory: %r', path)
584
 
        os.mkdir(path)
585
 
 
586
 
 
587
 
def config_dir():
588
 
    """Return per-user configuration directory.
589
 
 
590
 
    By default this is ~/.bazaar/
591
 
    
592
 
    TODO: Global option --config-dir to override this.
593
 
    """
594
 
    base = os.environ.get('BZR_HOME', None)
595
 
    if sys.platform == 'win32':
596
 
        if base is None:
597
 
            base = os.environ.get('APPDATA', None)
598
 
        if base is None:
599
 
            base = os.environ.get('HOME', None)
600
 
        if base is None:
601
 
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
602
 
        return pathjoin(base, 'bazaar', '2.0')
603
 
    else:
604
 
        # cygwin, linux, and darwin all have a $HOME directory
605
 
        if base is None:
606
 
            base = os.path.expanduser("~")
607
 
        return pathjoin(base, ".bazaar")
608
 
 
609
 
 
610
 
def config_filename():
611
 
    """Return per-user configuration ini file filename."""
612
 
    return pathjoin(config_dir(), 'bazaar.conf')
613
 
 
614
 
 
615
 
def branches_config_filename():
616
 
    """Return per-user configuration ini file filename."""
617
 
    return pathjoin(config_dir(), 'branches.conf')
618
 
 
619
 
 
620
 
def locations_config_filename():
621
 
    """Return per-user configuration ini file filename."""
622
 
    return pathjoin(config_dir(), 'locations.conf')
623
 
 
624
 
 
625
 
def user_ignore_config_filename():
626
 
    """Return the user default ignore filename"""
627
 
    return pathjoin(config_dir(), 'ignore')
628
 
 
629
 
 
630
 
def _auto_user_id():
631
 
    """Calculate automatic user identification.
632
 
 
633
 
    Returns (realname, email).
634
 
 
635
 
    Only used when none is set in the environment or the id file.
636
 
 
637
 
    This previously used the FQDN as the default domain, but that can
638
 
    be very slow on machines where DNS is broken.  So now we simply
639
 
    use the hostname.
640
 
    """
641
 
    import socket
642
 
 
643
 
    # XXX: Any good way to get real user name on win32?
644
 
 
645
 
    try:
646
 
        import pwd
647
 
        uid = os.getuid()
648
 
        w = pwd.getpwuid(uid)
649
 
 
650
 
        # we try utf-8 first, because on many variants (like Linux),
651
 
        # /etc/passwd "should" be in utf-8, and because it's unlikely to give
652
 
        # false positives.  (many users will have their user encoding set to
653
 
        # latin-1, which cannot raise UnicodeError.)
654
 
        try:
655
 
            gecos = w.pw_gecos.decode('utf-8')
656
 
            encoding = 'utf-8'
657
 
        except UnicodeError:
658
 
            try:
659
 
                gecos = w.pw_gecos.decode(bzrlib.user_encoding)
660
 
                encoding = bzrlib.user_encoding
661
 
            except UnicodeError:
662
 
                raise errors.BzrCommandError('Unable to determine your name.  '
663
 
                   'Use "bzr whoami" to set it.')
664
 
        try:
665
 
            username = w.pw_name.decode(encoding)
666
 
        except UnicodeError:
667
 
            raise errors.BzrCommandError('Unable to determine your name.  '
668
 
                'Use "bzr whoami" to set it.')
669
 
 
670
 
        comma = gecos.find(',')
671
 
        if comma == -1:
672
 
            realname = gecos
673
 
        else:
674
 
            realname = gecos[:comma]
675
 
        if not realname:
676
 
            realname = username
677
 
 
678
 
    except ImportError:
679
 
        import getpass
680
 
        try:
681
 
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
682
 
        except UnicodeDecodeError:
683
 
            raise errors.BzrError("Can't decode username as %s." % \
684
 
                    bzrlib.user_encoding)
685
 
 
686
 
    return realname, (username + '@' + socket.gethostname())
687
 
 
688
 
 
689
 
def extract_email_address(e):
690
 
    """Return just the address part of an email string.
691
 
    
692
 
    That is just the user@domain part, nothing else. 
693
 
    This part is required to contain only ascii characters.
694
 
    If it can't be extracted, raises an error.
695
 
    
696
 
    >>> extract_email_address('Jane Tester <jane@test.com>')
697
 
    "jane@test.com"
698
 
    """
699
 
    m = re.search(r'[\w+.-]+@[\w+.-]+', e)
700
 
    if not m:
701
 
        raise errors.BzrError("%r doesn't seem to contain "
702
 
                              "a reasonable email address" % e)
703
 
    return m.group(0)
704
 
 
705
 
 
706
 
class TreeConfig(IniBasedConfig):
707
 
    """Branch configuration data associated with its contents, not location"""
708
 
    def __init__(self, branch):
709
 
        self.branch = branch
710
 
 
711
 
    def _get_parser(self, file=None):
712
 
        if file is not None:
713
 
            return IniBasedConfig._get_parser(file)
714
 
        return self._get_config()
715
 
 
716
 
    def _get_config(self):
717
 
        try:
718
 
            obj = ConfigObj(self.branch.control_files.get('branch.conf'), 
719
 
                            encoding='utf-8')
720
 
        except errors.NoSuchFile:
721
 
            obj = ConfigObj(encoding='utf=8')
722
 
        return obj
723
 
 
724
 
    def get_option(self, name, section=None, default=None):
725
 
        self.branch.lock_read()
726
 
        try:
727
 
            obj = self._get_config()
728
 
            try:
729
 
                if section is not None:
730
 
                    obj[section]
731
 
                result = obj[name]
732
 
            except KeyError:
733
 
                result = default
734
 
        finally:
735
 
            self.branch.unlock()
736
 
        return result
737
 
 
738
 
    def set_option(self, value, name, section=None):
739
 
        """Set a per-branch configuration option"""
740
 
        self.branch.lock_write()
741
 
        try:
742
 
            cfg_obj = self._get_config()
743
 
            if section is None:
744
 
                obj = cfg_obj
745
 
            else:
746
 
                try:
747
 
                    obj = cfg_obj[section]
748
 
                except KeyError:
749
 
                    cfg_obj[section] = {}
750
 
                    obj = cfg_obj[section]
751
 
            obj[name] = value
752
 
            out_file = StringIO()
753
 
            cfg_obj.write(out_file)
754
 
            out_file.seek(0)
755
 
            self.branch.control_files.put('branch.conf', out_file)
756
 
        finally:
757
 
            self.branch.unlock()