← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rules.py

  • Committer: Martin Packman
  • Date: 2011-11-17 13:45:49 UTC
  • mto: This revision was merged to the branch mainline in revision 6271.
  • Revision ID: martin.packman@canonical.com-20111117134549-080e1fhtrzoicexg
https://launchpad.net/bugs/891582
Only assert FileExists path in test_transform directory clash tests to avoid stringification fallout

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/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 bzrlib import (
 
23
    config,
 
24
    cmdline,
 
25
    errors,
 
26
    globbing,
 
27
    osutils,
 
28
    )
 
29
from bzrlib.util.configobj import configobj
 
30
 
 
31
 
 
32
# Name of the file holding rules in a tree
 
33
RULES_TREE_FILENAME = ".bzrrules"
 
34
 
 
35
# Namespace prefix for per file preferences
 
36
FILE_PREFS_PREFIX = 'name '
 
37
FILE_PREFS_PREFIX_LEN = len(FILE_PREFS_PREFIX)
 
38
 
 
39
# The object providing default rules
 
40
_per_user_searcher = None
 
41
 
 
42
 
 
43
class _RulesSearcher(object):
 
44
    """An object that provides rule-based preferences."""
 
45
 
 
46
    def get_items(self, path):
 
47
        """Return the preferences for a path as name,value tuples.
 
48
 
 
49
        :param path: tree relative path
 
50
        :return: () if no rule matched, otherwise a sequence of name,value
 
51
          tuples.
 
52
        """
 
53
        raise NotImplementedError(self.get_items)
 
54
 
 
55
    def get_selected_items(self, path, names):
 
56
        """Return selected preferences for a path as name,value tuples.
 
57
 
 
58
        :param path: tree relative path
 
59
        :param names: the list of preferences to lookup
 
60
        :return: () if no rule matched, otherwise a sequence of name,value
 
61
          tuples. The sequence is the same length as names,
 
62
          tuple order matches the order in names, and
 
63
          undefined preferences are given the value None.
 
64
        """
 
65
        raise NotImplementedError(self.get_selected_items)
 
66
 
 
67
    def get_single_value(self, path, preference_name):
 
68
        """Get a single preference for a single file.
 
69
        
 
70
        :returns: The string preference value, or None.
 
71
        """
 
72
        for key, value in self.get_selected_items(path, [preference_name]):
 
73
            return value
 
74
        return None
 
75
 
 
76
 
 
77
class _IniBasedRulesSearcher(_RulesSearcher):
 
78
 
 
79
    def __init__(self, inifile):
 
80
        """Construct a _RulesSearcher based on an ini file.
 
81
 
 
82
        The content will be decoded as utf-8.
 
83
 
 
84
        :param inifile: the name of the file or a sequence of lines.
 
85
        """
 
86
        self._cfg = configobj.ConfigObj(inifile, encoding='utf-8')
 
87
        sections = self._cfg.keys()
 
88
        patterns = []
 
89
        self.pattern_to_section = {}
 
90
        for s in sections:
 
91
            if s.startswith(FILE_PREFS_PREFIX):
 
92
                file_patterns = cmdline.split(s[FILE_PREFS_PREFIX_LEN:])
 
93
                patterns.extend(file_patterns)
 
94
                for fp in file_patterns:
 
95
                    self.pattern_to_section[fp] = s
 
96
        if len(patterns) < len(sections):
 
97
            unknowns = [s for s in sections
 
98
                if not s.startswith(FILE_PREFS_PREFIX)]
 
99
            raise errors.UnknownRules(unknowns)
 
100
        elif patterns:
 
101
            self._globster = globbing._OrderedGlobster(patterns)
 
102
        else:
 
103
            self._globster = None
 
104
 
 
105
    def get_items(self, path):
 
106
        """See _RulesSearcher.get_items."""
 
107
        if self._globster is None:
 
108
            return ()
 
109
        pat = self._globster.match(path)
 
110
        if pat is None:
 
111
            return ()
 
112
        else:
 
113
            all = self._cfg[self.pattern_to_section[pat]]
 
114
            return tuple(all.items())
 
115
 
 
116
    def get_selected_items(self, path, names):
 
117
        """See _RulesSearcher.get_selected_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((k, all.get(k)) for k in names)
 
126
 
 
127
 
 
128
class _StackedRulesSearcher(_RulesSearcher):
 
129
 
 
130
    def __init__(self, searchers):
 
131
        """Construct a _RulesSearcher based on a stack of other ones.
 
132
 
 
133
        :param searchers: a sequence of searchers.
 
134
        """
 
135
        self.searchers = searchers
 
136
 
 
137
    def get_items(self, path):
 
138
        """See _RulesSearcher.get_items."""
 
139
        for searcher in self.searchers:
 
140
            result = searcher.get_items(path)
 
141
            if result:
 
142
                return result
 
143
        return ()
 
144
 
 
145
    def get_selected_items(self, path, names):
 
146
        """See _RulesSearcher.get_selected_items."""
 
147
        for searcher in self.searchers:
 
148
            result = searcher.get_selected_items(path, names)
 
149
            if result:
 
150
                return result
 
151
        return ()
 
152
 
 
153
 
 
154
def rules_filename():
 
155
    """Return the default rules filename."""
 
156
    return osutils.pathjoin(config.config_dir(), 'rules')
 
157
 
 
158
 
 
159
def reset_rules():
 
160
    global _per_user_searcher
 
161
    _per_user_searcher = _IniBasedRulesSearcher(rules_filename())
 
162
 
 
163
reset_rules()