← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Robert Collins
  • Date: 2005-10-15 11:43:21 UTC
  • mfrom: (1442.1.21)
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051015114321-538f440683c51672
merge in branches.conf support

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/config.py
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
"""Configuration that affects the behaviour of Bazaar."""
 
18
"""Configuration that affects the behaviour of Bazaar.
 
19
 
 
20
Currently this configuration resides in ~/.bazaar/bazaar.conf
 
21
and ~/.bazaar/branches.conf, which is written to by bzr.
 
22
 
 
23
In bazaar.config 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
 
 
30
in branches.conf, you specify the url of a branch and options for it.
 
31
Wildcards may be used - * and ? as normal in shell completion. Options
 
32
set in both bazaar.conf and branches.conf are overriden by the branches.conf
 
33
setting.
 
34
[/home/robertc/source]
 
35
recurse=False|True(default)
 
36
email= as above
 
37
check_signatures= as abive 
 
38
create_signatures= as above.
 
39
 
 
40
explanation of options
 
41
----------------------
 
42
editor - this option sets the pop up editor to use during commits.
 
43
email - this option sets the user id bzr will use when committing.
 
44
check_signatures - this option controls whether bzr will require good gpg
 
45
                   signatures, ignore them, or check them if they are 
 
46
                   present.
 
47
create_signatures - this option controls whether bzr will always create 
 
48
                    gpg signatures, never create them, or create them if the
 
49
                    branch is configured to require them.
 
50
                    NB: This option is planned, but not implemented yet.
 
51
"""
19
52
 
20
53
from ConfigParser import ConfigParser
21
54
import os
 
55
from fnmatch import fnmatch
22
56
import errno
23
57
import re
24
58
 
26
60
import bzrlib.errors as errors
27
61
 
28
62
 
 
63
CHECK_IF_POSSIBLE=0
 
64
CHECK_ALWAYS=1
 
65
CHECK_NEVER=2
 
66
 
 
67
 
29
68
class Config(object):
30
69
    """A configuration policy - what username, editor, gpg needs etc."""
31
70
 
33
72
        """Get the users pop up editor."""
34
73
        raise NotImplementedError
35
74
 
 
75
    def _get_signature_checking(self):
 
76
        """Template method to override signature checking policy."""
 
77
 
36
78
    def __init__(self):
37
79
        super(Config, self).__init__()
38
80
 
76
118
        else:
77
119
            return email
78
120
 
79
 
 
80
 
class GlobalConfig(Config):
81
 
    """The configuration that should be used for a specific location."""
82
 
 
83
 
    def _get_parser(self, filename=None, file=None):
 
121
    def signature_checking(self):
 
122
        """What is the current policy for signature checking?."""
 
123
        policy = self._get_signature_checking()
 
124
        if policy is not None:
 
125
            return policy
 
126
        return CHECK_IF_POSSIBLE
 
127
 
 
128
    def signature_needed(self):
 
129
        """Is a signature needed when committing ?."""
 
130
        policy = self._get_signature_checking()
 
131
        if policy == CHECK_ALWAYS:
 
132
            return True
 
133
        return False
 
134
 
 
135
 
 
136
class IniBasedConfig(Config):
 
137
    """A configuration policy that draws from ini files."""
 
138
 
 
139
    def _get_parser(self, file=None):
 
140
        if self._parser is not None:
 
141
            return self._parser
84
142
        parser = ConfigParser()
85
143
        if file is not None:
86
144
            parser.readfp(file)
87
145
        else:
88
 
            parser.read([filename])
 
146
            parser.read([self._get_filename()])
 
147
        self._parser = parser
89
148
        return parser
90
149
 
91
 
    def _get_config_parser(self, file=None):
92
 
        if self._parser is None:
93
 
            self._parser =  self._get_parser(config_filename(), file)
94
 
        return self._parser
95
 
    
96
 
    def _get_branches_config_parser(self, file=None):
97
 
        if self._branches_parser is None:
98
 
            self._branches_parser = self._get_parser(
99
 
                branches_config_filename(), file)
100
 
        return self._branches_parser
101
 
 
102
 
    def get_editor(self):
103
 
        if self._get_config_parser().has_option('DEFAULT', 'editor'):
104
 
            return self._get_config_parser().get('DEFAULT', 'editor')
105
 
 
106
 
    def _get_user_id(self, branch=None):
107
 
        """Return the full user id from the global config file.
108
 
    
109
 
        e.g. "John Hacker <jhacker@foo.org>"
110
 
        from 
111
 
        [DEFAULT]
112
 
        email=John Hacker <jhacker@foo.org>
113
 
        """
114
 
        if self._get_config_parser().has_option('DEFAULT', 'email'):
115
 
            email = self._get_config_parser().get('DEFAULT', 'email')
116
 
            if email is not None:
117
 
                return email
118
 
    
119
 
    def __init__(self):
120
 
        super(GlobalConfig, self).__init__()
121
 
        self._branches_parser = None
 
150
    def _get_section(self):
 
151
        """Override this to define the section used by the config."""
 
152
        return "DEFAULT"
 
153
 
 
154
    def _get_signature_checking(self):
 
155
        """See Config._get_signature_checking."""
 
156
        section = self._get_section()
 
157
        if section is None:
 
158
            return None
 
159
        if self._get_parser().has_option(section, 'check_signatures'):
 
160
            return self._string_to_signature_policy(
 
161
                self._get_parser().get(section, 'check_signatures'))
 
162
 
 
163
    def _get_user_id(self):
 
164
        """Get the user id from the 'email' key in the current section."""
 
165
        section = self._get_section()
 
166
        if section is not None:
 
167
            if self._get_parser().has_option(section, 'email'):
 
168
                return self._get_parser().get(section, 'email')
 
169
 
 
170
    def __init__(self, get_filename):
 
171
        super(IniBasedConfig, self).__init__()
 
172
        self._get_filename = get_filename
122
173
        self._parser = None
123
174
 
124
 
 
125
 
class LocationConfig(Config):
 
175
    def _string_to_signature_policy(self, signature_string):
 
176
        """Convert a string to a signing policy."""
 
177
        if signature_string.lower() == 'check-available':
 
178
            return CHECK_IF_POSSIBLE
 
179
        if signature_string.lower() == 'ignore':
 
180
            return CHECK_NEVER
 
181
        if signature_string.lower() == 'require':
 
182
            return CHECK_ALWAYS
 
183
        raise errors.BzrError("Invalid signatures policy '%s'"
 
184
                              % signature_string)
 
185
 
 
186
 
 
187
class GlobalConfig(IniBasedConfig):
 
188
    """The configuration that should be used for a specific location."""
 
189
 
 
190
    def get_editor(self):
 
191
        if self._get_parser().has_option(self._get_section(), 'editor'):
 
192
            return self._get_parser().get(self._get_section(), 'editor')
 
193
 
 
194
    def __init__(self):
 
195
        super(GlobalConfig, self).__init__(config_filename)
 
196
 
 
197
 
 
198
class LocationConfig(IniBasedConfig):
126
199
    """A configuration object that gives the policy for a location."""
127
200
 
128
201
    def __init__(self, location):
 
202
        super(LocationConfig, self).__init__(branches_config_filename)
129
203
        self._global_config = None
130
204
        self.location = location
131
205
 
132
 
    def _get_branches_config_parser(self, file=None):
133
 
        return self._get_global_config()._get_branches_config_parser(file)
134
 
 
135
206
    def _get_global_config(self):
136
207
        if self._global_config is None:
137
208
            self._global_config = GlobalConfig()
138
209
        return self._global_config
139
210
 
 
211
    def _get_section(self):
 
212
        """Get the section we should look in for config items.
 
213
 
 
214
        Returns None if none exists. 
 
215
        TODO: perhaps return a NullSection that thunks through to the 
 
216
              global config.
 
217
        """
 
218
        sections = self._get_parser().sections()
 
219
        location_names = self.location.split('/')
 
220
        if self.location.endswith('/'):
 
221
            del location_names[-1]
 
222
        matches=[]
 
223
        for section in sections:
 
224
            section_names = section.split('/')
 
225
            if section.endswith('/'):
 
226
                del section_names[-1]
 
227
            names = zip(location_names, section_names)
 
228
            matched = True
 
229
            for name in names:
 
230
                if not fnmatch(name[0], name[1]):
 
231
                    matched = False
 
232
                    break
 
233
            if not matched:
 
234
                continue
 
235
            # so, for the common prefix they matched.
 
236
            # if section is longer, no match.
 
237
            if len(section_names) > len(location_names):
 
238
                continue
 
239
            # if path is longer, and recurse is not true, no match
 
240
            if len(section_names) < len(location_names):
 
241
                if (self._get_parser().has_option(section, 'recurse')
 
242
                    and not self._get_parser().getboolean(section, 'recurse')):
 
243
                    continue
 
244
            matches.append((len(section_names), section))
 
245
        if not len(matches):
 
246
            return None
 
247
        matches.sort(reverse=True)
 
248
        return matches[0][1]
 
249
 
140
250
    def _get_user_id(self):
 
251
        user_id = super(LocationConfig, self)._get_user_id()
 
252
        if user_id is not None:
 
253
            return user_id
141
254
        return self._get_global_config()._get_user_id()
142
255
 
 
256
    def _get_signature_checking(self):
 
257
        """See Config._get_signature_checking."""
 
258
        check = super(LocationConfig, self)._get_signature_checking()
 
259
        if check is not None:
 
260
            return check
 
261
        return self._get_global_config()._get_signature_checking()
 
262
 
143
263
 
144
264
class BranchConfig(Config):
145
265
    """A configuration object giving the policy for a branch."""
165
285
        
166
286
        return self._get_location_config()._get_user_id()
167
287
 
 
288
    def _get_signature_checking(self):
 
289
        """See Config._get_signature_checking."""
 
290
        return self._get_location_config()._get_signature_checking()
 
291
 
168
292
    def __init__(self, branch):
169
293
        super(BranchConfig, self).__init__()
170
294
        self._location_config = None