/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/views.py

  • Committer: Jelmer Vernooij
  • Date: 2017-07-23 15:59:57 UTC
  • mto: This revision was merged to the branch mainline in revision 6740.
  • Revision ID: jelmer@jelmer.uk-20170723155957-rw4kqurf44fqx4x0
Move AlreadyBuilding/NotBuilding errors.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/views.py
 
1
# Copyright (C) 2008 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
"""View management.
 
18
 
 
19
Views are contained within a working tree and normally constructed
 
20
when first accessed.  Clients should do, for example, ...
 
21
 
 
22
  tree.views.lookup_view()
 
23
"""
 
24
 
 
25
from __future__ import absolute_import
 
26
 
 
27
import re
 
28
 
 
29
from . import (
 
30
    errors,
 
31
    osutils,
 
32
    )
 
33
 
 
34
 
 
35
_VIEWS_FORMAT_MARKER_RE = re.compile(r'Bazaar views format (\d+)')
 
36
_VIEWS_FORMAT1_MARKER = "Bazaar views format 1\n"
 
37
 
 
38
 
 
39
class NoSuchView(errors.BzrError):
 
40
    """A view does not exist.
 
41
    """
 
42
 
 
43
    _fmt = u"No such view: %(view_name)s."
 
44
 
 
45
    def __init__(self, view_name):
 
46
        self.view_name = view_name
 
47
 
 
48
 
 
49
class ViewsNotSupported(errors.BzrError):
 
50
    """Views are not supported by a tree format.
 
51
    """
 
52
 
 
53
    _fmt = ("Views are not supported by %(tree)s;"
 
54
            " use 'brz upgrade' to change your tree to a later format.")
 
55
 
 
56
    def __init__(self, tree):
 
57
        self.tree = tree
 
58
 
 
59
 
 
60
class FileOutsideView(errors.BzrError):
 
61
 
 
62
    _fmt = ('Specified file "%(file_name)s" is outside the current view: '
 
63
            '%(view_str)s')
 
64
 
 
65
    def __init__(self, file_name, view_files):
 
66
        self.file_name = file_name
 
67
        self.view_str = ", ".join(view_files)
 
68
 
 
69
 
 
70
class _Views(object):
 
71
    """Base class for View managers."""
 
72
 
 
73
    def supports_views(self):
 
74
        raise NotImplementedError(self.supports_views)
 
75
 
 
76
 
 
77
class PathBasedViews(_Views):
 
78
    """View storage in an unversioned tree control file.
 
79
 
 
80
    Views are stored in terms of paths relative to the tree root.
 
81
 
 
82
    The top line of the control file is a format marker in the format:
 
83
 
 
84
      Bazaar views format X
 
85
 
 
86
    where X is an integer number. After this top line, version 1 format is
 
87
    stored as follows:
 
88
 
 
89
     * optional name-values pairs in the format 'name=value'
 
90
 
 
91
     * optional view definitions, one per line in the format
 
92
 
 
93
       views:
 
94
       name file1 file2 ...
 
95
       name file1 file2 ...
 
96
 
 
97
    where the fields are separated by a nul character (\0). The views file
 
98
    is encoded in utf-8. The only supported keyword in version 1 is
 
99
    'current' which stores the name of the current view, if any.
 
100
    """
 
101
 
 
102
    def __init__(self, tree):
 
103
        self.tree = tree
 
104
        self._loaded = False
 
105
        self._current = None
 
106
        self._views = {}
 
107
 
 
108
    def supports_views(self):
 
109
        return True
 
110
 
 
111
    def get_view_info(self):
 
112
        """Get the current view and dictionary of views.
 
113
 
 
114
        :return: current, views where
 
115
          current = the name of the current view or None if no view is enabled
 
116
          views = a map from view name to list of files/directories
 
117
        """
 
118
        self._load_view_info()
 
119
        return self._current, self._views
 
120
 
 
121
    def set_view_info(self, current, views):
 
122
        """Set the current view and dictionary of views.
 
123
 
 
124
        :param current: the name of the current view or None if no view is
 
125
          enabled
 
126
        :param views: a map from view name to list of files/directories
 
127
        """
 
128
        if current is not None and current not in views:
 
129
            raise NoSuchView(current)
 
130
        self.tree.lock_write()
 
131
        try:
 
132
            self._current = current
 
133
            self._views = views
 
134
            self._save_view_info()
 
135
        finally:
 
136
            self.tree.unlock()
 
137
 
 
138
    def lookup_view(self, view_name=None):
 
139
        """Return the contents of a view.
 
140
 
 
141
        :param view_Name: name of the view or None to lookup the current view
 
142
        :return: the list of files/directories in the requested view
 
143
        """
 
144
        self._load_view_info()
 
145
        try:
 
146
            if view_name is None:
 
147
                if self._current:
 
148
                    view_name = self._current
 
149
                else:
 
150
                    return []
 
151
            return self._views[view_name]
 
152
        except KeyError:
 
153
            raise NoSuchView(view_name)
 
154
 
 
155
    def set_view(self, view_name, view_files, make_current=True):
 
156
        """Add or update a view definition.
 
157
 
 
158
        :param view_name: the name of the view
 
159
        :param view_files: the list of files/directories in the view
 
160
        :param make_current: make this view the current one or not
 
161
        """
 
162
        self.tree.lock_write()
 
163
        try:
 
164
            self._load_view_info()
 
165
            self._views[view_name] = view_files
 
166
            if make_current:
 
167
                self._current = view_name
 
168
            self._save_view_info()
 
169
        finally:
 
170
            self.tree.unlock()
 
171
 
 
172
    def delete_view(self, view_name):
 
173
        """Delete a view definition.
 
174
 
 
175
        If the view deleted is the current one, the current view is reset.
 
176
        """
 
177
        self.tree.lock_write()
 
178
        try:
 
179
            self._load_view_info()
 
180
            try:
 
181
                del self._views[view_name]
 
182
            except KeyError:
 
183
                raise NoSuchView(view_name)
 
184
            if view_name == self._current:
 
185
                self._current = None
 
186
            self._save_view_info()
 
187
        finally:
 
188
            self.tree.unlock()
 
189
 
 
190
    def _save_view_info(self):
 
191
        """Save the current view and all view definitions.
 
192
 
 
193
        Be sure to have initialised self._current and self._views before
 
194
        calling this method.
 
195
        """
 
196
        self.tree.lock_write()
 
197
        try:
 
198
            if self._current is None:
 
199
                keywords = {}
 
200
            else:
 
201
                keywords = {'current': self._current}
 
202
            self.tree._transport.put_bytes('views',
 
203
                self._serialize_view_content(keywords, self._views))
 
204
        finally:
 
205
            self.tree.unlock()
 
206
 
 
207
    def _load_view_info(self):
 
208
        """Load the current view and dictionary of view definitions."""
 
209
        if not self._loaded:
 
210
            self.tree.lock_read()
 
211
            try:
 
212
                try:
 
213
                    view_content = self.tree._transport.get_bytes('views')
 
214
                except errors.NoSuchFile as e:
 
215
                    self._current, self._views = None, {}
 
216
                else:
 
217
                    keywords, self._views = \
 
218
                        self._deserialize_view_content(view_content)
 
219
                    self._current = keywords.get('current')
 
220
            finally:
 
221
                self.tree.unlock()
 
222
            self._loaded = True
 
223
 
 
224
    def _serialize_view_content(self, keywords, view_dict):
 
225
        """Convert view keywords and a view dictionary into a stream."""
 
226
        lines = [_VIEWS_FORMAT1_MARKER]
 
227
        for key in keywords:
 
228
            line = "%s=%s\n" % (key,keywords[key])
 
229
            lines.append(line.encode('utf-8'))
 
230
        if view_dict:
 
231
            lines.append("views:\n".encode('utf-8'))
 
232
            for view in sorted(view_dict):
 
233
                view_data = "%s\0%s\n" % (view, "\0".join(view_dict[view]))
 
234
                lines.append(view_data.encode('utf-8'))
 
235
        return "".join(lines)
 
236
 
 
237
    def _deserialize_view_content(self, view_content):
 
238
        """Convert a stream into view keywords and a dictionary of views."""
 
239
        # as a special case to make initialization easy, an empty definition
 
240
        # maps to no current view and an empty view dictionary
 
241
        if view_content == '':
 
242
            return {}, {}
 
243
        lines = view_content.splitlines()
 
244
        match = _VIEWS_FORMAT_MARKER_RE.match(lines[0])
 
245
        if not match:
 
246
            raise ValueError(
 
247
                "format marker missing from top of views file")
 
248
        elif match.group(1) != '1':
 
249
            raise ValueError(
 
250
                "cannot decode views format %s" % match.group(1))
 
251
        try:
 
252
            keywords = {}
 
253
            views = {}
 
254
            in_views = False
 
255
            for line in lines[1:]:
 
256
                text = line.decode('utf-8')
 
257
                if in_views:
 
258
                    parts = text.split('\0')
 
259
                    view = parts.pop(0)
 
260
                    views[view] = parts
 
261
                elif text == 'views:':
 
262
                    in_views = True
 
263
                    continue
 
264
                elif text.find('=') >= 0:
 
265
                    # must be a name-value pair
 
266
                    keyword, value = text.split('=', 1)
 
267
                    keywords[keyword] = value
 
268
                else:
 
269
                    raise ValueError("failed to deserialize views line %s",
 
270
                        text)
 
271
            return keywords, views
 
272
        except ValueError as e:
 
273
            raise ValueError("failed to deserialize views content %r: %s"
 
274
                % (view_content, e))
 
275
 
 
276
 
 
277
class DisabledViews(_Views):
 
278
    """View storage that refuses to store anything.
 
279
 
 
280
    This is used by older formats that can't store views.
 
281
    """
 
282
 
 
283
    def __init__(self, tree):
 
284
        self.tree = tree
 
285
 
 
286
    def supports_views(self):
 
287
        return False
 
288
 
 
289
    def _not_supported(self, *a, **k):
 
290
        raise ViewsNotSupported(self.tree)
 
291
 
 
292
    get_view_info = _not_supported
 
293
    set_view_info = _not_supported
 
294
    lookup_view = _not_supported
 
295
    set_view = _not_supported
 
296
    delete_view = _not_supported
 
297
 
 
298
 
 
299
def view_display_str(view_files, encoding=None):
 
300
    """Get the display string for a list of view files.
 
301
 
 
302
    :param view_files: the list of file names
 
303
    :param encoding: the encoding to display the files in
 
304
    """
 
305
    if encoding is None:
 
306
        return ", ".join(view_files)
 
307
    else:
 
308
        return ", ".join([v.encode(encoding, 'replace') for v in view_files])
 
309
 
 
310
 
 
311
def check_path_in_view(tree, relpath):
 
312
    """If a working tree has a view enabled, check the path is within it."""
 
313
    if tree.supports_views():
 
314
        view_files = tree.views.lookup_view()
 
315
        if  view_files and not osutils.is_inside_any(view_files, relpath):
 
316
            raise FileOutsideView(relpath, view_files)