~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/config.py

  • Committer: Robert Collins
  • Date: 2005-10-17 11:56:54 UTC
  • mfrom: (1185.16.59)
  • Revision ID: robertc@robertcollins.net-20051017115654-662239e1587524a8
mergeĀ fromĀ martin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
Currently this configuration resides in ~/.bazaar/bazaar.conf
21
21
and ~/.bazaar/branches.conf, which is written to by bzr.
22
22
 
23
 
In bazaar.conf the following options may be set:
 
23
In bazaar.config the following options may be set:
24
24
[DEFAULT]
25
25
editor=name-of-program
26
26
email=Your Name <your@email.address>
51
51
                    NB: This option is planned, but not implemented yet.
52
52
"""
53
53
 
54
 
 
55
 
import errno
 
54
from ConfigParser import ConfigParser
56
55
import os
57
 
import sys
58
56
from fnmatch import fnmatch
 
57
import errno
59
58
import re
60
59
 
61
60
import bzrlib
62
61
import bzrlib.errors as errors
63
 
import bzrlib.util.configobj.configobj as configobj
64
 
from StringIO import StringIO
 
62
 
65
63
 
66
64
CHECK_IF_POSSIBLE=0
67
65
CHECK_ALWAYS=1
68
66
CHECK_NEVER=2
69
67
 
70
68
 
71
 
class ConfigObj(configobj.ConfigObj):
72
 
 
73
 
    def get_bool(self, section, key):
74
 
        val = self[section][key].lower()
75
 
        if val in ('1', 'yes', 'true', 'on'):
76
 
            return True
77
 
        elif val in ('0', 'no', 'false', 'off'):
78
 
            return False
79
 
        else:
80
 
            raise ValueError("Value %r is not boolean" % val)
81
 
 
82
 
    def get_value(self, section, name):
83
 
        # Try [] for the old DEFAULT section.
84
 
        if section == "DEFAULT":
85
 
            try:
86
 
                return self[name]
87
 
            except KeyError:
88
 
                pass
89
 
        return self[section][name]
90
 
 
91
 
 
92
69
class Config(object):
93
70
    """A configuration policy - what username, editor, gpg needs etc."""
94
71
 
99
76
    def _get_signature_checking(self):
100
77
        """Template method to override signature checking policy."""
101
78
 
102
 
    def _get_user_option(self, option_name):
103
 
        """Template method to provide a user option."""
104
 
        return None
105
 
 
106
 
    def get_user_option(self, option_name):
107
 
        """Get a generic option - no special process, no default."""
108
 
        return self._get_user_option(option_name)
109
 
 
110
79
    def gpg_signing_command(self):
111
80
        """What program should be used to sign signatures?"""
112
81
        result = self._gpg_signing_command()
121
90
    def __init__(self):
122
91
        super(Config, self).__init__()
123
92
 
124
 
    def post_commit(self):
125
 
        """An ordered list of python functions to call.
126
 
 
127
 
        Each function takes branch, rev_id as parameters.
128
 
        """
129
 
        return self._post_commit()
130
 
 
131
 
    def _post_commit(self):
132
 
        """See Config.post_commit."""
133
 
        return None
134
 
 
135
93
    def user_email(self):
136
94
        """Return just the email component of a username."""
137
 
        return extract_email_address(self.username())
 
95
        e = self.username()
 
96
        m = re.search(r'[\w+.-]+@[\w+.-]+', e)
 
97
        if not m:
 
98
            raise BzrError("%r doesn't seem to contain "
 
99
                           "a reasonable email address" % e)
 
100
        return m.group(0)
138
101
 
139
102
    def username(self):
140
103
        """Return email-style username.
143
106
        
144
107
        $BZREMAIL can be set to override this, then
145
108
        the concrete policy type is checked, and finally
146
 
        $EMAIL is examined.
147
 
        If none is found, a reasonable default is (hopefully)
 
109
        $EMAIL is examinged.
 
110
        but if none is found, a reasonable default is (hopefully)
148
111
        created.
149
112
    
150
113
        TODO: Check it's reasonably well-formed.
188
151
    def _get_parser(self, file=None):
189
152
        if self._parser is not None:
190
153
            return self._parser
191
 
        if file is None:
192
 
            input = self._get_filename()
 
154
        parser = ConfigParser()
 
155
        if file is not None:
 
156
            parser.readfp(file)
193
157
        else:
194
 
            input = file
195
 
        try:
196
 
            self._parser = ConfigObj(input)
197
 
        except configobj.ConfigObjError, e:
198
 
            raise errors.ParseConfigError(e.errors, e.config.filename)
199
 
        return self._parser
 
158
            parser.read([self._get_filename()])
 
159
        self._parser = parser
 
160
        return parser
200
161
 
201
162
    def _get_section(self):
202
163
        """Override this to define the section used by the config."""
204
165
 
205
166
    def _get_signature_checking(self):
206
167
        """See Config._get_signature_checking."""
207
 
        policy = self._get_user_option('check_signatures')
208
 
        if policy:
209
 
            return self._string_to_signature_policy(policy)
 
168
        section = self._get_section()
 
169
        if section is None:
 
170
            return None
 
171
        if self._get_parser().has_option(section, 'check_signatures'):
 
172
            return self._string_to_signature_policy(
 
173
                self._get_parser().get(section, 'check_signatures'))
210
174
 
211
175
    def _get_user_id(self):
212
176
        """Get the user id from the 'email' key in the current section."""
213
 
        return self._get_user_option('email')
214
 
 
215
 
    def _get_user_option(self, option_name):
216
 
        """See Config._get_user_option."""
217
 
        try:
218
 
            return self._get_parser().get_value(self._get_section(),
219
 
                                                option_name)
220
 
        except KeyError:
221
 
            pass
 
177
        section = self._get_section()
 
178
        if section is not None:
 
179
            if self._get_parser().has_option(section, 'email'):
 
180
                return self._get_parser().get(section, 'email')
222
181
 
223
182
    def _gpg_signing_command(self):
224
183
        """See Config.gpg_signing_command."""
225
 
        return self._get_user_option('gpg_signing_command')
 
184
        section = self._get_section()
 
185
        if section is not None:
 
186
            if self._get_parser().has_option(section, 'gpg_signing_command'):
 
187
                return self._get_parser().get(section, 'gpg_signing_command')
226
188
 
227
189
    def __init__(self, get_filename):
228
190
        super(IniBasedConfig, self).__init__()
229
191
        self._get_filename = get_filename
230
192
        self._parser = None
231
 
        
232
 
    def _post_commit(self):
233
 
        """See Config.post_commit."""
234
 
        return self._get_user_option('post_commit')
235
193
 
236
194
    def _string_to_signature_policy(self, signature_string):
237
195
        """Convert a string to a signing policy."""
249
207
    """The configuration that should be used for a specific location."""
250
208
 
251
209
    def get_editor(self):
252
 
        return self._get_user_option('editor')
 
210
        if self._get_parser().has_option(self._get_section(), 'editor'):
 
211
            return self._get_parser().get(self._get_section(), 'editor')
253
212
 
254
213
    def __init__(self):
255
214
        super(GlobalConfig, self).__init__(config_filename)
275
234
        TODO: perhaps return a NullSection that thunks through to the 
276
235
              global config.
277
236
        """
278
 
        sections = self._get_parser()
 
237
        sections = self._get_parser().sections()
279
238
        location_names = self.location.split('/')
280
239
        if self.location.endswith('/'):
281
240
            del location_names[-1]
298
257
                continue
299
258
            # if path is longer, and recurse is not true, no match
300
259
            if len(section_names) < len(location_names):
301
 
                try:
302
 
                    if not self._get_parser().get_bool(section, 'recurse'):
303
 
                        continue
304
 
                except KeyError:
305
 
                    pass
 
260
                if (self._get_parser().has_option(section, 'recurse')
 
261
                    and not self._get_parser().getboolean(section, 'recurse')):
 
262
                    continue
306
263
            matches.append((len(section_names), section))
307
264
        if not len(matches):
308
265
            return None
322
279
            return user_id
323
280
        return self._get_global_config()._get_user_id()
324
281
 
325
 
    def _get_user_option(self, option_name):
326
 
        """See Config._get_user_option."""
327
 
        option_value = super(LocationConfig, 
328
 
                             self)._get_user_option(option_name)
329
 
        if option_value is not None:
330
 
            return option_value
331
 
        return self._get_global_config()._get_user_option(option_name)
332
 
 
333
282
    def _get_signature_checking(self):
334
283
        """See Config._get_signature_checking."""
335
284
        check = super(LocationConfig, self)._get_signature_checking()
337
286
            return check
338
287
        return self._get_global_config()._get_signature_checking()
339
288
 
340
 
    def _post_commit(self):
341
 
        """See Config.post_commit."""
342
 
        hook = self._get_user_option('post_commit')
343
 
        if hook is not None:
344
 
            return hook
345
 
        return self._get_global_config()._post_commit()
346
 
 
347
 
    def set_user_option(self, option, value):
348
 
        """Save option and its value in the configuration."""
349
 
        # FIXME: RBC 20051029 This should refresh the parser and also take a
350
 
        # file lock on branches.conf.
351
 
        if not os.path.isdir(os.path.dirname(self._get_filename())):
352
 
            os.mkdir(os.path.dirname(self._get_filename()))
353
 
        location = self.location
354
 
        if location.endswith('/'):
355
 
            location = location[:-1]
356
 
        if (not location in self._get_parser() and
357
 
            not location + '/' in self._get_parser()):
358
 
            self._get_parser()[location]={}
359
 
        elif location + '/' in self._get_parser():
360
 
            location = location + '/'
361
 
        self._get_parser()[location][option]=value
362
 
        self._get_parser().write()
363
 
 
364
289
 
365
290
class BranchConfig(Config):
366
291
    """A configuration object giving the policy for a branch."""
390
315
        """See Config._get_signature_checking."""
391
316
        return self._get_location_config()._get_signature_checking()
392
317
 
393
 
    def _get_user_option(self, option_name):
394
 
        """See Config._get_user_option."""
395
 
        return self._get_location_config()._get_user_option(option_name)
396
 
 
397
318
    def _gpg_signing_command(self):
398
319
        """See Config.gpg_signing_command."""
399
320
        return self._get_location_config()._gpg_signing_command()
403
324
        self._location_config = None
404
325
        self.branch = branch
405
326
 
406
 
    def _post_commit(self):
407
 
        """See Config.post_commit."""
408
 
        return self._get_location_config()._post_commit()
409
 
 
410
327
 
411
328
def config_dir():
412
329
    """Return per-user configuration directory.
415
332
    
416
333
    TODO: Global option --config-dir to override this.
417
334
    """
418
 
    base = os.environ.get('BZR_HOME', None)
419
 
    if sys.platform == 'win32':
420
 
        if base is None:
421
 
            base = os.environ.get('APPDATA', None)
422
 
        if base is None:
423
 
            base = os.environ.get('HOME', None)
424
 
        if base is None:
425
 
            raise BzrError('You must have one of BZR_HOME, APPDATA, or HOME set')
426
 
        return os.path.join(base, 'bazaar', '2.0')
427
 
    else:
428
 
        # cygwin, linux, and darwin all have a $HOME directory
429
 
        if base is None:
430
 
            base = os.path.expanduser("~")
431
 
        return os.path.join(base, ".bazaar")
 
335
    return os.path.join(os.path.expanduser("~"), ".bazaar")
432
336
 
433
337
 
434
338
def config_filename():
489
393
    """
490
394
    m = re.search(r'[\w+.-]+@[\w+.-]+', e)
491
395
    if not m:
492
 
        raise errors.BzrError("%r doesn't seem to contain "
493
 
                              "a reasonable email address" % e)
 
396
        raise BzrError("%r doesn't seem to contain "
 
397
                       "a reasonable email address" % e)
494
398
    return m.group(0)
495
 
 
496
 
class TreeConfig(object):
497
 
    """Branch configuration data associated with its contents, not location"""
498
 
    def __init__(self, branch):
499
 
        self.branch = branch
500
 
 
501
 
    def _get_config(self):
502
 
        try:
503
 
            obj = ConfigObj(self.branch.controlfile('branch.conf',
504
 
                                                    'rb').readlines())
505
 
            obj.decode('UTF-8')
506
 
        except errors.NoSuchFile:
507
 
            obj = ConfigObj()
508
 
        return obj
509
 
 
510
 
    def get_option(self, name, section=None, default=None):
511
 
        self.branch.lock_read()
512
 
        try:
513
 
            obj = self._get_config()
514
 
            try:
515
 
                if section is not None:
516
 
                    obj[section]
517
 
                result = obj[name]
518
 
            except KeyError:
519
 
                result = default
520
 
        finally:
521
 
            self.branch.unlock()
522
 
        return result
523
 
 
524
 
    def set_option(self, value, name, section=None):
525
 
        """Set a per-branch configuration option"""
526
 
        self.branch.lock_write()
527
 
        try:
528
 
            cfg_obj = self._get_config()
529
 
            if section is None:
530
 
                obj = cfg_obj
531
 
            else:
532
 
                try:
533
 
                    obj = cfg_obj[section]
534
 
                except KeyError:
535
 
                    cfg_obj[section] = {}
536
 
                    obj = cfg_obj[section]
537
 
            obj[name] = value
538
 
            cfg_obj.encode('UTF-8')
539
 
            out_file = StringIO(''.join([l+'\n' for l in cfg_obj.write()]))
540
 
            out_file.seek(0)
541
 
            self.branch.put_controlfile('branch.conf', out_file, encode=False)
542
 
        finally:
543
 
            self.branch.unlock()