~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2011-06-22 09:54:01 UTC
  • mfrom: (5991.2.1 trunk)
  • Revision ID: pqm@pqm.ubuntu.com-20110622095401-n1nkzancazl4h0kg
(vila) Slightly simplify whoami tests (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
29
29
create_signatures=always|never|when-required(default)
30
30
gpg_signing_command=name-of-program
31
31
log_format=name-of-format
32
 
validate_signatures_in_log=true|false(default)
33
 
acceptable_keys=pattern1,pattern2
34
 
gpg_signing_key=amy@example.com
35
32
 
36
33
in locations.conf, you specify the url of a branch and options for it.
37
34
Wildcards may be used - * and ? as normal in shell completion. Options
42
39
email= as above
43
40
check_signatures= as above
44
41
create_signatures= as above.
45
 
validate_signatures_in_log=as above
46
 
acceptable_keys=as above
47
42
 
48
43
explanation of options
49
44
----------------------
50
45
editor - this option sets the pop up editor to use during commits.
51
46
email - this option sets the user id bzr will use when committing.
52
 
check_signatures - this option will control whether bzr will require good gpg
 
47
check_signatures - this option controls whether bzr will require good gpg
53
48
                   signatures, ignore them, or check them if they are
54
 
                   present.  Currently it is unused except that check_signatures
55
 
                   turns on create_signatures.
 
49
                   present.
56
50
create_signatures - this option controls whether bzr will always create
57
 
                    gpg signatures or not on commits.  There is an unused
58
 
                    option which in future is expected to work if               
59
 
                    branch settings require signatures.
 
51
                    gpg signatures, never create them, or create them if the
 
52
                    branch is configured to require them.
60
53
log_format - this option sets the default log format.  Possible values are
61
54
             long, short, line, or a plugin can register new formats.
62
 
validate_signatures_in_log - show GPG signature validity in log output
63
 
acceptable_keys - comma separated list of key patterns acceptable for
64
 
                  verify-signatures command
65
55
 
66
56
In bazaar.conf you can also define aliases in the ALIASES sections, example
67
57
 
89
79
    bzrdir,
90
80
    debug,
91
81
    errors,
92
 
    lazy_regex,
93
82
    lockdir,
94
83
    mail_client,
95
84
    mergetools,
438
427
        """See log_format()."""
439
428
        return None
440
429
 
441
 
    def validate_signatures_in_log(self):
442
 
        """Show GPG signature validity in log"""
443
 
        result = self._validate_signatures_in_log()
444
 
        if result == "true":
445
 
            result = True
446
 
        else:
447
 
            result = False
448
 
        return result
449
 
 
450
 
    def _validate_signatures_in_log(self):
451
 
        """See validate_signatures_in_log()."""
452
 
        return None
453
 
 
454
 
    def acceptable_keys(self):
455
 
        """Comma separated list of key patterns acceptable to 
456
 
        verify-signatures command"""
457
 
        result = self._acceptable_keys()
458
 
        return result
459
 
 
460
 
    def _acceptable_keys(self):
461
 
        """See acceptable_keys()."""
462
 
        return None
463
 
 
464
430
    def post_commit(self):
465
431
        """An ordered list of python functions to call.
466
432
 
537
503
            return True
538
504
        return False
539
505
 
540
 
    def gpg_signing_key(self):
541
 
        """GPG user-id to sign commits"""
542
 
        key = self.get_user_option('gpg_signing_key')
543
 
        if key == "default" or key == None:
544
 
            return self.user_email()
545
 
        else:
546
 
            return key
547
 
 
548
506
    def get_alias(self, value):
549
507
        return self._get_alias(value)
550
508
 
872
830
        """See Config.log_format."""
873
831
        return self._get_user_option('log_format')
874
832
 
875
 
    def _validate_signatures_in_log(self):
876
 
        """See Config.validate_signatures_in_log."""
877
 
        return self._get_user_option('validate_signatures_in_log')
878
 
 
879
 
    def _acceptable_keys(self):
880
 
        """See Config.acceptable_keys."""
881
 
        return self._get_user_option('acceptable_keys')
882
 
 
883
833
    def _post_commit(self):
884
834
        """See Config.post_commit."""
885
835
        return self._get_user_option('post_commit')
1460
1410
        """See Config.log_format."""
1461
1411
        return self._get_best_value('_log_format')
1462
1412
 
1463
 
    def _validate_signatures_in_log(self):
1464
 
        """See Config.validate_signatures_in_log."""
1465
 
        return self._get_best_value('_validate_signatures_in_log')
1466
 
 
1467
 
    def _acceptable_keys(self):
1468
 
        """See Config.acceptable_keys."""
1469
 
        return self._get_best_value('_acceptable_keys')
1470
 
 
1471
1413
 
1472
1414
def ensure_config_dir_exists(path=None):
1473
1415
    """Make sure a configuration directory exists.
2274
2216
    value, in which config files it can be stored, etc (TBC).
2275
2217
    """
2276
2218
 
2277
 
    def __init__(self, name, default=None, help=None):
 
2219
    def __init__(self, name, default=None):
2278
2220
        self.name = name
2279
2221
        self.default = default
2280
 
        self.help = help
2281
2222
 
2282
2223
    def get_default(self):
2283
2224
        return self.default
2284
2225
 
2285
2226
 
2286
 
class OptionRegistry(registry.Registry):
2287
 
    """Register config options by their name.
2288
 
 
2289
 
    This overrides ``registry.Registry`` to simplify registration by acquiring
2290
 
    some information from the option object itself.
2291
 
    """
2292
 
 
2293
 
    def register(self, option):
2294
 
        """Register a new option to its name.
2295
 
 
2296
 
        :param option: The option to register. Its name is used as the key.
2297
 
        """
2298
 
        super(OptionRegistry, self).register(option.name, option,
2299
 
                                             help=option.help)
2300
 
 
2301
 
    def register_lazy(self, key, module_name, member_name):
2302
 
        """Register a new option to be loaded on request.
2303
 
 
2304
 
        :param key: This is the key to use to request the option later. Since
2305
 
            the registration is lazy, it should be provided and match the
2306
 
            option name.
2307
 
 
2308
 
        :param module_name: The python path to the module. Such as 'os.path'.
2309
 
 
2310
 
        :param member_name: The member of the module to return.  If empty or
2311
 
                None, get() will return the module itself.
2312
 
        """
2313
 
        super(OptionRegistry, self).register_lazy(key,
2314
 
                                                  module_name, member_name)
2315
 
 
2316
 
    def get_help(self, key=None):
2317
 
        """Get the help text associated with the given key"""
2318
 
        option = self.get(key)
2319
 
        the_help = option.help
2320
 
        if callable(the_help):
2321
 
            return the_help(self, key)
2322
 
        return the_help
2323
 
 
2324
 
 
2325
 
option_registry = OptionRegistry()
2326
 
 
2327
 
 
2328
 
# Registered options in lexicographical order
2329
 
 
2330
 
option_registry.register(
2331
 
    Option('dirstate.fdatasync', default=True,
2332
 
           help='''
2333
 
Flush dirstate changes onto physical disk?
2334
 
 
2335
 
If true (default), working tree metadata changes are flushed through the
2336
 
OS buffers to physical disk.  This is somewhat slower, but means data
2337
 
should not be lost if the machine crashes.  See also repository.fdatasync.
2338
 
'''))
2339
 
option_registry.register(
2340
 
    Option('default_format', default='2a',
2341
 
           help='Format used when creating branches.'))
2342
 
option_registry.register(
2343
 
    Option('editor',
2344
 
           help='The command called to launch an editor to enter a message.'))
2345
 
option_registry.register(
2346
 
    Option('language',
2347
 
           help='Language to translate messages into.'))
2348
 
option_registry.register(
2349
 
    Option('output_encoding',
2350
 
           help= 'Unicode encoding for output'
2351
 
           ' (terminal encoding if not specified).'))
2352
 
option_registry.register(
2353
 
    Option('repository.fdatasync', default=True,
2354
 
           help='''\
2355
 
Flush repository changes onto physical disk?
2356
 
 
2357
 
If true (default), repository changes are flushed through the OS buffers
2358
 
to physical disk.  This is somewhat slower, but means data should not be
2359
 
lost if the machine crashes.  See also dirstate.fdatasync.
2360
 
'''))
 
2227
# Options registry
 
2228
 
 
2229
option_registry = registry.Registry()
 
2230
 
 
2231
 
 
2232
option_registry.register(
 
2233
    'editor', Option('editor'),
 
2234
    help='The command called to launch an editor to enter a message.')
2361
2235
 
2362
2236
 
2363
2237
class Section(object):
2630
2504
class GlobalStore(LockableIniFileStore):
2631
2505
 
2632
2506
    def __init__(self, possible_transports=None):
2633
 
        t = transport.get_transport_from_path(config_dir(),
 
2507
        t = transport.get_transport(config_dir(),
2634
2508
                                    possible_transports=possible_transports)
2635
2509
        super(GlobalStore, self).__init__(t, 'bazaar.conf')
2636
2510
 
2638
2512
class LocationStore(LockableIniFileStore):
2639
2513
 
2640
2514
    def __init__(self, possible_transports=None):
2641
 
        t = transport.get_transport_from_path(config_dir(),
 
2515
        t = transport.get_transport(config_dir(),
2642
2516
                                    possible_transports=possible_transports)
2643
2517
        super(LocationStore, self).__init__(t, 'locations.conf')
2644
2518
 
2889
2763
class LocationStack(_CompatibleStack):
2890
2764
 
2891
2765
    def __init__(self, location):
2892
 
        """Make a new stack for a location and global configuration.
2893
 
        
2894
 
        :param location: A URL prefix to """
2895
2766
        lstore = LocationStore()
2896
2767
        matcher = LocationMatcher(lstore, location)
2897
2768
        gstore = GlobalStore()
3024
2895
            raise errors.NoSuchConfigOption(name)
3025
2896
 
3026
2897
    def _show_matching_options(self, name, directory, scope):
3027
 
        name = lazy_regex.lazy_compile(name)
 
2898
        name = re.compile(name)
3028
2899
        # We want any error in the regexp to be raised *now* so we need to
3029
 
        # avoid the delay introduced by the lazy regexp.  But, we still do
3030
 
        # want the nicer errors raised by lazy_regex.
 
2900
        # avoid the delay introduced by the lazy regexp.
3031
2901
        name._compile_and_collapse()
3032
2902
        cur_conf_id = None
3033
2903
        cur_section = None