/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/config.py

[merge] bzr.dev 2255

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
1
 
# Copyright (C) 2005 by Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
2
#   Authors: Robert Collins <robert.collins@canonical.com>
3
3
#
4
4
# This program is free software; you can redistribute it and/or modify
61
61
up=pull
62
62
"""
63
63
 
 
64
import os
 
65
import sys
64
66
 
 
67
from bzrlib.lazy_import import lazy_import
 
68
lazy_import(globals(), """
65
69
import errno
66
70
from fnmatch import fnmatch
67
 
import os
68
71
import re
69
 
import sys
70
72
from StringIO import StringIO
71
73
 
72
74
import bzrlib
73
 
from bzrlib import errors, urlutils
74
 
from bzrlib.osutils import pathjoin
 
75
from bzrlib import (
 
76
    errors,
 
77
    osutils,
 
78
    symbol_versioning,
 
79
    urlutils,
 
80
    )
 
81
import bzrlib.util.configobj.configobj as configobj
 
82
""")
 
83
 
75
84
from bzrlib.trace import mutter, warning
76
 
import bzrlib.util.configobj.configobj as configobj
77
85
 
78
86
 
79
87
CHECK_IF_POSSIBLE=0
86
94
SIGN_NEVER=2
87
95
 
88
96
 
 
97
POLICY_NONE = 0
 
98
POLICY_NORECURSE = 1
 
99
POLICY_APPENDPATH = 2
 
100
 
 
101
_policy_name = {
 
102
    POLICY_NONE: None,
 
103
    POLICY_NORECURSE: 'norecurse',
 
104
    POLICY_APPENDPATH: 'appendpath',
 
105
    }
 
106
_policy_value = {
 
107
    None: POLICY_NONE,
 
108
    'none': POLICY_NONE,
 
109
    'norecurse': POLICY_NORECURSE,
 
110
    'appendpath': POLICY_APPENDPATH,
 
111
    }
 
112
 
 
113
 
 
114
STORE_LOCATION = POLICY_NONE
 
115
STORE_LOCATION_NORECURSE = POLICY_NORECURSE
 
116
STORE_LOCATION_APPENDPATH = POLICY_APPENDPATH
 
117
STORE_BRANCH = 3
 
118
STORE_GLOBAL = 4
 
119
 
 
120
 
89
121
class ConfigObj(configobj.ConfigObj):
90
122
 
91
123
    def get_bool(self, section, key):
255
287
            raise errors.ParseConfigError(e.errors, e.config.filename)
256
288
        return self._parser
257
289
 
 
290
    def _get_matching_sections(self):
 
291
        """Return an ordered list of (section_name, extra_path) pairs.
 
292
 
 
293
        If the section contains inherited configuration, extra_path is
 
294
        a string containing the additional path components.
 
295
        """
 
296
        section = self._get_section()
 
297
        if section is not None:
 
298
            return [(section, '')]
 
299
        else:
 
300
            return []
 
301
 
258
302
    def _get_section(self):
259
303
        """Override this to define the section used by the config."""
260
304
        return "DEFAULT"
261
305
 
 
306
    def _get_option_policy(self, section, option_name):
 
307
        """Return the policy for the given (section, option_name) pair."""
 
308
        return POLICY_NONE
 
309
 
262
310
    def _get_signature_checking(self):
263
311
        """See Config._get_signature_checking."""
264
312
        policy = self._get_user_option('check_signatures')
277
325
 
278
326
    def _get_user_option(self, option_name):
279
327
        """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
 
328
        for (section, extra_path) in self._get_matching_sections():
 
329
            try:
 
330
                value = self._get_parser().get_value(section, option_name)
 
331
            except KeyError:
 
332
                continue
 
333
            policy = self._get_option_policy(section, option_name)
 
334
            if policy == POLICY_NONE:
 
335
                return value
 
336
            elif policy == POLICY_NORECURSE:
 
337
                # norecurse items only apply to the exact path
 
338
                if extra_path:
 
339
                    continue
 
340
                else:
 
341
                    return value
 
342
            elif policy == POLICY_APPENDPATH:
 
343
                if extra_path:
 
344
                    value = urlutils.join(value, extra_path)
 
345
                return value
 
346
            else:
 
347
                raise AssertionError('Unexpected config policy %r' % policy)
 
348
        else:
 
349
            return None
285
350
 
286
351
    def _gpg_signing_command(self):
287
352
        """See Config.gpg_signing_command."""
379
444
            location = urlutils.local_path_from_url(location)
380
445
        self.location = location
381
446
 
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
 
        """
 
447
    def _get_matching_sections(self):
 
448
        """Return an ordered list of section names matching this location."""
389
449
        sections = self._get_parser()
390
450
        location_names = self.location.split('/')
391
451
        if self.location.endswith('/'):
415
475
            # if section is longer, no match.
416
476
            if len(section_names) > len(location_names):
417
477
                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
 
478
            matches.append((len(section_names), section,
 
479
                            '/'.join(location_names[len(section_names):])))
428
480
        matches.sort(reverse=True)
429
 
        return matches[0][1]
430
 
 
431
 
    def set_user_option(self, option, value):
 
481
        sections = []
 
482
        for (length, section, extra_path) in matches:
 
483
            sections.append((section, extra_path))
 
484
            # should we stop looking for parent configs here?
 
485
            try:
 
486
                if self._get_parser()[section].as_bool('ignore_parents'):
 
487
                    break
 
488
            except KeyError:
 
489
                pass
 
490
        return sections
 
491
 
 
492
    def _get_option_policy(self, section, option_name):
 
493
        """Return the policy for the given (section, option_name) pair."""
 
494
        # check for the old 'recurse=False' flag
 
495
        try:
 
496
            recurse = self._get_parser()[section].as_bool('recurse')
 
497
        except KeyError:
 
498
            recurse = True
 
499
        if not recurse:
 
500
            return POLICY_NORECURSE
 
501
 
 
502
        policy_key = option_name + ':policy'
 
503
        try:
 
504
            policy_name = self._get_parser()[section][policy_key]
 
505
        except KeyError:
 
506
            policy_name = None
 
507
 
 
508
        return _policy_value[policy_name]
 
509
 
 
510
    def _set_option_policy(self, section, option_name, option_policy):
 
511
        """Set the policy for the given option name in the given section."""
 
512
        # The old recurse=False option affects all options in the
 
513
        # section.  To handle multiple policies in the section, we
 
514
        # need to convert it to a policy_norecurse key.
 
515
        try:
 
516
            recurse = self._get_parser()[section].as_bool('recurse')
 
517
        except KeyError:
 
518
            pass
 
519
        else:
 
520
            symbol_versioning.warn(
 
521
                'The recurse option is deprecated as of 0.14.  '
 
522
                'The section "%s" has been converted to use policies.'
 
523
                % section,
 
524
                DeprecationWarning)
 
525
            del self._get_parser()[section]['recurse']
 
526
            if not recurse:
 
527
                for key in self._get_parser()[section].keys():
 
528
                    if not key.endswith(':policy'):
 
529
                        self._get_parser()[section][key +
 
530
                                                    ':policy'] = 'norecurse'
 
531
 
 
532
        policy_key = option_name + ':policy'
 
533
        policy_name = _policy_name[option_policy]
 
534
        if policy_name is not None:
 
535
            self._get_parser()[section][policy_key] = policy_name
 
536
        else:
 
537
            if policy_key in self._get_parser()[section]:
 
538
                del self._get_parser()[section][policy_key]
 
539
 
 
540
    def set_user_option(self, option, value, store=STORE_LOCATION):
432
541
        """Save option and its value in the configuration."""
 
542
        assert store in [STORE_LOCATION,
 
543
                         STORE_LOCATION_NORECURSE,
 
544
                         STORE_LOCATION_APPENDPATH], 'bad storage policy'
433
545
        # FIXME: RBC 20051029 This should refresh the parser and also take a
434
546
        # file lock on locations.conf.
435
547
        conf_dir = os.path.dirname(self._get_filename())
443
555
        elif location + '/' in self._get_parser():
444
556
            location = location + '/'
445
557
        self._get_parser()[location][option]=value
 
558
        # the allowed values of store match the config policies
 
559
        self._set_option_policy(location, option, store)
446
560
        self._get_parser().write(file(self._get_filename(), 'wb'))
447
561
 
448
562
 
523
637
                return value
524
638
        return None
525
639
 
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:
 
640
    def set_user_option(self, name, value, store=STORE_BRANCH):
 
641
        if store == STORE_BRANCH:
530
642
            self._get_branch_data_config().set_option(value, name)
531
 
 
 
643
        elif store == STORE_GLOBAL:
 
644
            self._get_global_config().set_user_option(name, value)
 
645
        else:
 
646
            self._get_location_config().set_user_option(name, value, store)
532
647
 
533
648
    def _gpg_signing_command(self):
534
649
        """See Config.gpg_signing_command."""
552
667
        value = self._get_explicit_nickname()
553
668
        if value is not None:
554
669
            return value
555
 
        return self.branch.base.split('/')[-2]
 
670
        return urlutils.unescape(self.branch.base.split('/')[-2])
556
671
 
557
672
    def has_explicit_nickname(self):
558
673
        """Return true if a nickname has been explicitly assigned."""
599
714
            base = os.environ.get('HOME', None)
600
715
        if base is None:
601
716
            raise errors.BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
602
 
        return pathjoin(base, 'bazaar', '2.0')
 
717
        return osutils.pathjoin(base, 'bazaar', '2.0')
603
718
    else:
604
719
        # cygwin, linux, and darwin all have a $HOME directory
605
720
        if base is None:
606
721
            base = os.path.expanduser("~")
607
 
        return pathjoin(base, ".bazaar")
 
722
        return osutils.pathjoin(base, ".bazaar")
608
723
 
609
724
 
610
725
def config_filename():
611
726
    """Return per-user configuration ini file filename."""
612
 
    return pathjoin(config_dir(), 'bazaar.conf')
 
727
    return osutils.pathjoin(config_dir(), 'bazaar.conf')
613
728
 
614
729
 
615
730
def branches_config_filename():
616
731
    """Return per-user configuration ini file filename."""
617
 
    return pathjoin(config_dir(), 'branches.conf')
 
732
    return osutils.pathjoin(config_dir(), 'branches.conf')
618
733
 
619
734
 
620
735
def locations_config_filename():
621
736
    """Return per-user configuration ini file filename."""
622
 
    return pathjoin(config_dir(), 'locations.conf')
 
737
    return osutils.pathjoin(config_dir(), 'locations.conf')
623
738
 
624
739
 
625
740
def user_ignore_config_filename():
626
741
    """Return the user default ignore filename"""
627
 
    return pathjoin(config_dir(), 'ignore')
 
742
    return osutils.pathjoin(config_dir(), 'ignore')
628
743
 
629
744
 
630
745
def _auto_user_id():