/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: Jelmer Vernooij
  • Date: 2020-02-07 02:14:30 UTC
  • mto: This revision was merged to the branch mainline in revision 7492.
  • Revision ID: jelmer@jelmer.uk-20200207021430-m49iq3x4x8xlib6x
Drop python2 support.

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()