← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

Added more docs

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
27
27
check_signatures=require|ignore|check-available(default)
28
28
create_signatures=always|never|when-required(default)
29
29
gpg_signing_command=name-of-program
30
 
log_format=name-of-format
31
30
 
32
31
in branches.conf, you specify the url of a branch and options for it.
33
32
Wildcards may be used - * and ? as normal in shell completion. Options
50
49
                    gpg signatures, never create them, or create them if the
51
50
                    branch is configured to require them.
52
51
                    NB: This option is planned, but not implemented yet.
53
 
log_format - This options set the default log format.  Options are long, 
54
 
             short, line, or a plugin can register new formats
55
 
 
56
 
In bazaar.conf you can also define aliases in the ALIASES sections, example
57
 
 
58
 
[ALIASES]
59
 
lastlog=log --line -r-10..-1
60
 
ll=log --line -r-10..-1
61
 
h=help
62
 
up=pull
63
52
"""
64
53
 
65
54
 
84
73
class ConfigObj(configobj.ConfigObj):
85
74
 
86
75
    def get_bool(self, section, key):
87
 
        return self[section].as_bool(key)
 
76
        val = self[section][key].lower()
 
77
        if val in ('1', 'yes', 'true', 'on'):
 
78
            return True
 
79
        elif val in ('0', 'no', 'false', 'off'):
 
80
            return False
 
81
        else:
 
82
            raise ValueError("Value %r is not boolean" % val)
88
83
 
89
84
    def get_value(self, section, name):
90
85
        # Try [] for the old DEFAULT section.
125
120
        """See gpg_signing_command()."""
126
121
        return None
127
122
 
128
 
    def log_format(self):
129
 
        """What log format should be used"""
130
 
        result = self._log_format()
131
 
        if result is None:
132
 
            result = "long"
133
 
        return result
134
 
 
135
 
    def _log_format(self):
136
 
        """See log_format()."""
137
 
        return None
138
 
 
139
123
    def __init__(self):
140
124
        super(Config, self).__init__()
141
125
 
199
183
            return True
200
184
        return False
201
185
 
202
 
    def get_alias(self, value):
203
 
        return self._get_alias(value)
204
 
 
205
 
    def _get_alias(self, value):
206
 
        pass
207
 
 
208
186
 
209
187
class IniBasedConfig(Config):
210
188
    """A configuration policy that draws from ini files."""
217
195
        else:
218
196
            input = file
219
197
        try:
220
 
            self._parser = ConfigObj(input, encoding='utf-8')
 
198
            self._parser = ConfigObj(input)
221
199
        except configobj.ConfigObjError, e:
222
200
            raise errors.ParseConfigError(e.errors, e.config.filename)
223
201
        return self._parser
248
226
        """See Config.gpg_signing_command."""
249
227
        return self._get_user_option('gpg_signing_command')
250
228
 
251
 
    def _log_format(self):
252
 
        """See Config.log_format."""
253
 
        return self._get_user_option('log_format')
254
 
 
255
229
    def __init__(self, get_filename):
256
230
        super(IniBasedConfig, self).__init__()
257
231
        self._get_filename = get_filename
272
246
        raise errors.BzrError("Invalid signatures policy '%s'"
273
247
                              % signature_string)
274
248
 
275
 
    def _get_alias(self, value):
276
 
        try:
277
 
            return self._get_parser().get_value("ALIASES", 
278
 
                                                value)
279
 
        except KeyError:
280
 
            pass
281
 
 
282
249
 
283
250
class GlobalConfig(IniBasedConfig):
284
251
    """The configuration that should be used for a specific location."""
334
301
            # if path is longer, and recurse is not true, no match
335
302
            if len(section_names) < len(location_names):
336
303
                try:
337
 
                    if not self._get_parser()[section].as_bool('recurse'):
 
304
                    if not self._get_parser().get_bool(section, 'recurse'):
338
305
                        continue
339
306
                except KeyError:
340
307
                    pass
351
318
            return command
352
319
        return self._get_global_config()._gpg_signing_command()
353
320
 
354
 
    def _log_format(self):
355
 
        """See Config.log_format."""
356
 
        command = super(LocationConfig, self)._log_format()
357
 
        if command is not None:
358
 
            return command
359
 
        return self._get_global_config()._log_format()
360
 
 
361
321
    def _get_user_id(self):
362
322
        user_id = super(LocationConfig, self)._get_user_id()
363
323
        if user_id is not None:
401
361
        elif location + '/' in self._get_parser():
402
362
            location = location + '/'
403
363
        self._get_parser()[location][option]=value
404
 
        self._get_parser().write(file(self._get_filename(), 'wb'))
 
364
        self._get_parser().write()
405
365
 
406
366
 
407
367
class BranchConfig(Config):
449
409
        """See Config.post_commit."""
450
410
        return self._get_location_config()._post_commit()
451
411
 
452
 
    def _log_format(self):
453
 
        """See Config.log_format."""
454
 
        return self._get_location_config()._log_format()
455
 
 
456
412
 
457
413
def ensure_config_dir_exists(path=None):
458
414
    """Make sure a configuration directory exists.
524
480
        import pwd
525
481
        uid = os.getuid()
526
482
        w = pwd.getpwuid(uid)
527
 
 
528
 
        try:
529
 
            gecos = w.pw_gecos.decode(bzrlib.user_encoding)
530
 
            username = w.pw_name.decode(bzrlib.user_encoding)
531
 
        except UnicodeDecodeError:
532
 
            # We're using pwd, therefore we're on Unix, so /etc/passwd is ok.
533
 
            raise errors.BzrError("Can't decode username in " \
534
 
                    "/etc/passwd as %s." % bzrlib.user_encoding)
535
 
 
 
483
        gecos = w.pw_gecos.decode(bzrlib.user_encoding)
 
484
        username = w.pw_name.decode(bzrlib.user_encoding)
536
485
        comma = gecos.find(',')
537
486
        if comma == -1:
538
487
            realname = gecos
543
492
 
544
493
    except ImportError:
545
494
        import getpass
546
 
        try:
547
 
            realname = username = getpass.getuser().decode(bzrlib.user_encoding)
548
 
        except UnicodeDecodeError:
549
 
            raise errors.BzrError("Can't decode username as %s." % \
550
 
                    bzrlib.user_encoding)
 
495
        realname = username = getpass.getuser().decode(bzrlib.user_encoding)
551
496
 
552
497
    return realname, (username + '@' + socket.gethostname())
553
498
 
575
520
 
576
521
    def _get_config(self):
577
522
        try:
578
 
            obj = ConfigObj(self.branch.control_files.get('branch.conf'), 
579
 
                            encoding='utf-8')
 
523
            obj = ConfigObj(self.branch.control_files.get('branch.conf'
 
524
                        ).readlines())
 
525
            obj.decode('UTF-8')
580
526
        except errors.NoSuchFile:
581
 
            obj = ConfigObj(encoding='utf=8')
 
527
            obj = ConfigObj()
582
528
        return obj
583
529
 
584
530
    def get_option(self, name, section=None, default=None):
609
555
                    cfg_obj[section] = {}
610
556
                    obj = cfg_obj[section]
611
557
            obj[name] = value
612
 
            out_file = StringIO()
613
 
            cfg_obj.write(out_file)
 
558
            cfg_obj.encode('UTF-8')
 
559
            out_file = StringIO(''.join([l+'\n' for l in cfg_obj.write()]))
614
560
            out_file.seek(0)
615
561
            self.branch.control_files.put('branch.conf', out_file)
616
562
        finally: