/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 breezy/rules.py

  • Committer: John Arbash Meinel
  • Date: 2006-04-25 15:05:42 UTC
  • mfrom: (1185.85.85 bzr-encoding)
  • mto: This revision was merged to the branch mainline in revision 1752.
  • Revision ID: john@arbash-meinel.com-20060425150542-c7b518dca9928691
[merge] the old bzr-encoding changes, reparenting them on bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/rules.py
1
 
# Copyright (C) 2008, 2009, 2010 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"""Rule-based definition of preferences for selected files in selected branches
18
 
 
19
 
See ``bzr help rules`` for details.
20
 
"""
21
 
 
22
 
from __future__ import absolute_import
23
 
 
24
 
import configobj
25
 
 
26
 
from . import (
27
 
    bedding,
28
 
    cmdline,
29
 
    errors,
30
 
    globbing,
31
 
    osutils,
32
 
    )
33
 
 
34
 
 
35
 
# Name of the file holding rules in a tree
36
 
RULES_TREE_FILENAME = ".bzrrules"
37
 
 
38
 
# Namespace prefix for per file preferences
39
 
FILE_PREFS_PREFIX = 'name '
40
 
FILE_PREFS_PREFIX_LEN = len(FILE_PREFS_PREFIX)
41
 
 
42
 
# The object providing default rules
43
 
_per_user_searcher = None
44
 
 
45
 
 
46
 
class UnknownRules(errors.BzrError):
47
 
 
48
 
    _fmt = ('Unknown rules detected: %(unknowns_str)s.')
49
 
 
50
 
    def __init__(self, unknowns):
51
 
        errors.BzrError.__init__(self, unknowns_str=", ".join(unknowns))
52
 
 
53
 
 
54
 
class _RulesSearcher(object):
55
 
    """An object that provides rule-based preferences."""
56
 
 
57
 
    def get_items(self, path):
58
 
        """Return the preferences for a path as name,value tuples.
59
 
 
60
 
        :param path: tree relative path
61
 
        :return: () if no rule matched, otherwise a sequence of name,value
62
 
          tuples.
63
 
        """
64
 
        raise NotImplementedError(self.get_items)
65
 
 
66
 
    def get_selected_items(self, path, names):
67
 
        """Return selected preferences for a path as name,value tuples.
68
 
 
69
 
        :param path: tree relative path
70
 
        :param names: the list of preferences to lookup
71
 
        :return: () if no rule matched, otherwise a sequence of name,value
72
 
          tuples. The sequence is the same length as names,
73
 
          tuple order matches the order in names, and
74
 
          undefined preferences are given the value None.
75
 
        """
76
 
        raise NotImplementedError(self.get_selected_items)
77
 
 
78
 
    def get_single_value(self, path, preference_name):
79
 
        """Get a single preference for a single file.
80
 
 
81
 
        :returns: The string preference value, or None.
82
 
        """
83
 
        for key, value in self.get_selected_items(path, [preference_name]):
84
 
            return value
85
 
        return None
86
 
 
87
 
 
88
 
class _IniBasedRulesSearcher(_RulesSearcher):
89
 
 
90
 
    def __init__(self, inifile):
91
 
        """Construct a _RulesSearcher based on an ini file.
92
 
 
93
 
        The content will be decoded as utf-8.
94
 
 
95
 
        :param inifile: the name of the file or a sequence of lines.
96
 
        """
97
 
        self._cfg = configobj.ConfigObj(inifile, encoding='utf-8')
98
 
        sections = self._cfg.keys()
99
 
        patterns = []
100
 
        self.pattern_to_section = {}
101
 
        for s in sections:
102
 
            if s.startswith(FILE_PREFS_PREFIX):
103
 
                file_patterns = cmdline.split(s[FILE_PREFS_PREFIX_LEN:])
104
 
                patterns.extend(file_patterns)
105
 
                for fp in file_patterns:
106
 
                    self.pattern_to_section[fp] = s
107
 
        if len(patterns) < len(sections):
108
 
            unknowns = [s for s in sections
109
 
                        if not s.startswith(FILE_PREFS_PREFIX)]
110
 
            raise UnknownRules(unknowns)
111
 
        elif patterns:
112
 
            self._globster = globbing._OrderedGlobster(patterns)
113
 
        else:
114
 
            self._globster = None
115
 
 
116
 
    def get_items(self, path):
117
 
        """See _RulesSearcher.get_items."""
118
 
        if self._globster is None:
119
 
            return ()
120
 
        pat = self._globster.match(path)
121
 
        if pat is None:
122
 
            return ()
123
 
        else:
124
 
            all = self._cfg[self.pattern_to_section[pat]]
125
 
            return tuple(all.items())
126
 
 
127
 
    def get_selected_items(self, path, names):
128
 
        """See _RulesSearcher.get_selected_items."""
129
 
        if self._globster is None:
130
 
            return ()
131
 
        pat = self._globster.match(path)
132
 
        if pat is None:
133
 
            return ()
134
 
        else:
135
 
            all = self._cfg[self.pattern_to_section[pat]]
136
 
            return tuple((k, all.get(k)) for k in names)
137
 
 
138
 
 
139
 
class _StackedRulesSearcher(_RulesSearcher):
140
 
 
141
 
    def __init__(self, searchers):
142
 
        """Construct a _RulesSearcher based on a stack of other ones.
143
 
 
144
 
        :param searchers: a sequence of searchers.
145
 
        """
146
 
        self.searchers = searchers
147
 
 
148
 
    def get_items(self, path):
149
 
        """See _RulesSearcher.get_items."""
150
 
        for searcher in self.searchers:
151
 
            result = searcher.get_items(path)
152
 
            if result:
153
 
                return result
154
 
        return ()
155
 
 
156
 
    def get_selected_items(self, path, names):
157
 
        """See _RulesSearcher.get_selected_items."""
158
 
        for searcher in self.searchers:
159
 
            result = searcher.get_selected_items(path, names)
160
 
            if result:
161
 
                return result
162
 
        return ()
163
 
 
164
 
 
165
 
def rules_path():
166
 
    """Return the default rules file path."""
167
 
    return osutils.pathjoin(bedding.config_dir(), 'rules')
168
 
 
169
 
 
170
 
def reset_rules():
171
 
    global _per_user_searcher
172
 
    _per_user_searcher = _IniBasedRulesSearcher(rules_path())
173
 
 
174
 
 
175
 
reset_rules()