/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

  • Committer: John Arbash Meinel
  • Date: 2006-09-13 02:09:37 UTC
  • mto: This revision was merged to the branch mainline in revision 2004.
  • Revision ID: john@arbash-meinel.com-20060913020937-2df2f49f9a28ec43
Update HACKING and docstrings

Show diffs side-by-side

added added

removed removed

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