← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Vincent Ladeuil
  • Date: 2011-12-21 14:25:26 UTC
  • mto: This revision was merged to the branch mainline in revision 6397.
  • Revision ID: v.ladeuil+lp@free.fr-20111221142526-pnwau0xnalimujts
Provides MemoryStack to simplify configuration setup in tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/rio.py
 
1
# Copyright (C) 2005 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
from __future__ import absolute_import
 
18
 
 
19
# \subsection{\emph{rio} - simple text metaformat}
 
20
#
 
21
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
 
22
#
 
23
# The stored data consists of a series of \emph{stanzas}, each of which contains
 
24
# \emph{fields} identified by an ascii name, with Unicode or string contents.
 
25
# The field tag is constrained to alphanumeric characters.
 
26
# There may be more than one field in a stanza with the same name.
 
27
#
 
28
# The format itself does not deal with character encoding issues, though
 
29
# the result will normally be written in Unicode.
 
30
#
 
31
# The format is intended to be simple enough that there is exactly one character
 
32
# stream representation of an object and vice versa, and that this relation
 
33
# will continue to hold for future versions of bzr.
 
34
 
 
35
import re
 
36
 
 
37
from bzrlib import osutils
 
38
from bzrlib.iterablefile import IterableFile
 
39
 
 
40
# XXX: some redundancy is allowing to write stanzas in isolation as well as
 
41
# through a writer object.
 
42
 
 
43
class RioWriter(object):
 
44
    def __init__(self, to_file):
 
45
        self._soft_nl = False
 
46
        self._to_file = to_file
 
47
 
 
48
    def write_stanza(self, stanza):
 
49
        if self._soft_nl:
 
50
            self._to_file.write('\n')
 
51
        stanza.write(self._to_file)
 
52
        self._soft_nl = True
 
53
 
 
54
 
 
55
class RioReader(object):
 
56
    """Read stanzas from a file as a sequence
 
57
 
 
58
    to_file can be anything that can be enumerated as a sequence of
 
59
    lines (with newlines.)
 
60
    """
 
61
    def __init__(self, from_file):
 
62
        self._from_file = from_file
 
63
 
 
64
    def __iter__(self):
 
65
        while True:
 
66
            s = read_stanza(self._from_file)
 
67
            if s is None:
 
68
                break
 
69
            else:
 
70
                yield s
 
71
 
 
72
 
 
73
def rio_file(stanzas, header=None):
 
74
    """Produce a rio IterableFile from an iterable of stanzas"""
 
75
    def str_iter():
 
76
        if header is not None:
 
77
            yield header + '\n'
 
78
        first_stanza = True
 
79
        for s in stanzas:
 
80
            if first_stanza is not True:
 
81
                yield '\n'
 
82
            for line in s.to_lines():
 
83
                yield line
 
84
            first_stanza = False
 
85
    return IterableFile(str_iter())
 
86
 
 
87
 
 
88
def read_stanzas(from_file):
 
89
    while True:
 
90
        s = read_stanza(from_file)
 
91
        if s is None:
 
92
            break
 
93
        else:
 
94
            yield s
 
95
 
 
96
class Stanza(object):
 
97
    """One stanza for rio.
 
98
 
 
99
    Each stanza contains a set of named fields.
 
100
 
 
101
    Names must be non-empty ascii alphanumeric plus _.  Names can be repeated
 
102
    within a stanza.  Names are case-sensitive.  The ordering of fields is
 
103
    preserved.
 
104
 
 
105
    Each field value must be either an int or a string.
 
106
    """
 
107
 
 
108
    __slots__ = ['items']
 
109
 
 
110
    def __init__(self, **kwargs):
 
111
        """Construct a new Stanza.
 
112
 
 
113
        The keyword arguments, if any, are added in sorted order to the stanza.
 
114
        """
 
115
        self.items = []
 
116
        if kwargs:
 
117
            for tag, value in sorted(kwargs.items()):
 
118
                self.add(tag, value)
 
119
 
 
120
    def add(self, tag, value):
 
121
        """Append a name and value to the stanza."""
 
122
        if not valid_tag(tag):
 
123
            raise ValueError("invalid tag %r" % (tag,))
 
124
        if isinstance(value, str):
 
125
            value = unicode(value)
 
126
        elif isinstance(value, unicode):
 
127
            pass
 
128
        ## elif isinstance(value, (int, long)):
 
129
        ##    value = str(value)           # XXX: python2.4 without L-suffix
 
130
        else:
 
131
            raise TypeError("invalid type for rio value: %r of type %s"
 
132
                            % (value, type(value)))
 
133
        self.items.append((tag, value))
 
134
 
 
135
    @classmethod
 
136
    def from_pairs(cls, pairs):
 
137
        ret = cls()
 
138
        ret.items = pairs
 
139
        return ret
 
140
 
 
141
    def __contains__(self, find_tag):
 
142
        """True if there is any field in this stanza with the given tag."""
 
143
        for tag, value in self.items:
 
144
            if tag == find_tag:
 
145
                return True
 
146
        return False
 
147
 
 
148
    def __len__(self):
 
149
        """Return number of pairs in the stanza."""
 
150
        return len(self.items)
 
151
 
 
152
    def __eq__(self, other):
 
153
        if not isinstance(other, Stanza):
 
154
            return False
 
155
        return self.items == other.items
 
156
 
 
157
    def __ne__(self, other):
 
158
        return not self.__eq__(other)
 
159
 
 
160
    def __repr__(self):
 
161
        return "Stanza(%r)" % self.items
 
162
 
 
163
    def iter_pairs(self):
 
164
        """Return iterator of tag, value pairs."""
 
165
        return iter(self.items)
 
166
 
 
167
    def to_lines(self):
 
168
        """Generate sequence of lines for external version of this file.
 
169
 
 
170
        The lines are always utf-8 encoded strings.
 
171
        """
 
172
        if not self.items:
 
173
            # max() complains if sequence is empty
 
174
            return []
 
175
        result = []
 
176
        for tag, value in self.items:
 
177
            if value == '':
 
178
                result.append(tag + ': \n')
 
179
            elif '\n' in value:
 
180
                # don't want splitlines behaviour on empty lines
 
181
                val_lines = value.split('\n')
 
182
                result.append(tag + ': ' + val_lines[0].encode('utf-8') + '\n')
 
183
                for line in val_lines[1:]:
 
184
                    result.append('\t' + line.encode('utf-8') + '\n')
 
185
            else:
 
186
                result.append(tag + ': ' + value.encode('utf-8') + '\n')
 
187
        return result
 
188
 
 
189
    def to_string(self):
 
190
        """Return stanza as a single string"""
 
191
        return ''.join(self.to_lines())
 
192
 
 
193
    def to_unicode(self):
 
194
        """Return stanza as a single Unicode string.
 
195
 
 
196
        This is most useful when adding a Stanza to a parent Stanza
 
197
        """
 
198
        if not self.items:
 
199
            return u''
 
200
 
 
201
        result = []
 
202
        for tag, value in self.items:
 
203
            if value == u'':
 
204
                result.append(tag + u': \n')
 
205
            elif u'\n' in value:
 
206
                # don't want splitlines behaviour on empty lines
 
207
                val_lines = value.split(u'\n')
 
208
                result.append(tag + u': ' + val_lines[0] + u'\n')
 
209
                for line in val_lines[1:]:
 
210
                    result.append(u'\t' + line + u'\n')
 
211
            else:
 
212
                result.append(tag + u': ' + value + u'\n')
 
213
        return u''.join(result)
 
214
 
 
215
    def write(self, to_file):
 
216
        """Write stanza to a file"""
 
217
        to_file.writelines(self.to_lines())
 
218
 
 
219
    def get(self, tag):
 
220
        """Return the value for a field wih given tag.
 
221
 
 
222
        If there is more than one value, only the first is returned.  If the
 
223
        tag is not present, KeyError is raised.
 
224
        """
 
225
        for t, v in self.items:
 
226
            if t == tag:
 
227
                return v
 
228
        else:
 
229
            raise KeyError(tag)
 
230
 
 
231
    __getitem__ = get
 
232
 
 
233
    def get_all(self, tag):
 
234
        r = []
 
235
        for t, v in self.items:
 
236
            if t == tag:
 
237
                r.append(v)
 
238
        return r
 
239
 
 
240
    def as_dict(self):
 
241
        """Return a dict containing the unique values of the stanza.
 
242
        """
 
243
        d = {}
 
244
        for tag, value in self.items:
 
245
            d[tag] = value
 
246
        return d
 
247
 
 
248
 
 
249
def valid_tag(tag):
 
250
    return _valid_tag(tag)
 
251
 
 
252
 
 
253
def read_stanza(line_iter):
 
254
    """Return new Stanza read from list of lines or a file
 
255
 
 
256
    Returns one Stanza that was read, or returns None at end of file.  If a
 
257
    blank line follows the stanza, it is consumed.  It's not an error for
 
258
    there to be no blank at end of file.  If there is a blank file at the
 
259
    start of the input this is really an empty stanza and that is returned.
 
260
 
 
261
    Only the stanza lines and the trailing blank (if any) are consumed
 
262
    from the line_iter.
 
263
 
 
264
    The raw lines must be in utf-8 encoding.
 
265
    """
 
266
    return _read_stanza_utf8(line_iter)
 
267
 
 
268
 
 
269
def read_stanza_unicode(unicode_iter):
 
270
    """Read a Stanza from a list of lines or a file.
 
271
 
 
272
    The lines should already be in unicode form. This returns a single
 
273
    stanza that was read. If there is a blank line at the end of the Stanza,
 
274
    it is consumed. It is not an error for there to be no blank line at
 
275
    the end of the iterable. If there is a blank line at the beginning,
 
276
    this is treated as an empty Stanza and None is returned.
 
277
 
 
278
    Only the stanza lines and the trailing blank (if any) are consumed
 
279
    from the unicode_iter
 
280
 
 
281
    :param unicode_iter: A iterable, yeilding Unicode strings. See read_stanza
 
282
        if you have a utf-8 encoded string.
 
283
    :return: A Stanza object if there are any lines in the file.
 
284
        None otherwise
 
285
    """
 
286
    return _read_stanza_unicode(unicode_iter)
 
287
 
 
288
 
 
289
def to_patch_lines(stanza, max_width=72):
 
290
    """Convert a stanza into RIO-Patch format lines.
 
291
 
 
292
    RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
 
293
    It resists common forms of damage such as newline conversion or the removal
 
294
    of trailing whitespace, yet is also reasonably easy to read.
 
295
 
 
296
    :param max_width: The maximum number of characters per physical line.
 
297
    :return: a list of lines
 
298
    """
 
299
    if max_width <= 6:
 
300
        raise ValueError(max_width)
 
301
    max_rio_width = max_width - 4
 
302
    lines = []
 
303
    for pline in stanza.to_lines():
 
304
        for line in pline.split('\n')[:-1]:
 
305
            line = re.sub('\\\\', '\\\\\\\\', line)
 
306
            while len(line) > 0:
 
307
                partline = line[:max_rio_width]
 
308
                line = line[max_rio_width:]
 
309
                if len(line) > 0 and line[0] != [' ']:
 
310
                    break_index = -1
 
311
                    break_index = partline.rfind(' ', -20)
 
312
                    if break_index < 3:
 
313
                        break_index = partline.rfind('-', -20)
 
314
                        break_index += 1
 
315
                    if break_index < 3:
 
316
                        break_index = partline.rfind('/', -20)
 
317
                    if break_index >= 3:
 
318
                        line = partline[break_index:] + line
 
319
                        partline = partline[:break_index]
 
320
                if len(line) > 0:
 
321
                    line = '  ' + line
 
322
                partline = re.sub('\r', '\\\\r', partline)
 
323
                blank_line = False
 
324
                if len(line) > 0:
 
325
                    partline += '\\'
 
326
                elif re.search(' $', partline):
 
327
                    partline += '\\'
 
328
                    blank_line = True
 
329
                lines.append('# ' + partline + '\n')
 
330
                if blank_line:
 
331
                    lines.append('#   \n')
 
332
    return lines
 
333
 
 
334
 
 
335
def _patch_stanza_iter(line_iter):
 
336
    map = {'\\\\': '\\',
 
337
           '\\r' : '\r',
 
338
           '\\\n': ''}
 
339
    def mapget(match):
 
340
        return map[match.group(0)]
 
341
 
 
342
    last_line = None
 
343
    for line in line_iter:
 
344
        if line.startswith('# '):
 
345
            line = line[2:]
 
346
        elif line.startswith('#'):
 
347
            line = line[1:]
 
348
        else:
 
349
            raise ValueError("bad line %r" % (line,))
 
350
        if last_line is not None and len(line) > 2:
 
351
            line = line[2:]
 
352
        line = re.sub('\r', '', line)
 
353
        line = re.sub('\\\\(.|\n)', mapget, line)
 
354
        if last_line is None:
 
355
            last_line = line
 
356
        else:
 
357
            last_line += line
 
358
        if last_line[-1] == '\n':
 
359
            yield last_line
 
360
            last_line = None
 
361
    if last_line is not None:
 
362
        yield last_line
 
363
 
 
364
 
 
365
def read_patch_stanza(line_iter):
 
366
    """Convert an iterable of RIO-Patch format lines into a Stanza.
 
367
 
 
368
    RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
 
369
    It resists common forms of damage such as newline conversion or the removal
 
370
    of trailing whitespace, yet is also reasonably easy to read.
 
371
 
 
372
    :return: a Stanza
 
373
    """
 
374
    return read_stanza(_patch_stanza_iter(line_iter))
 
375
 
 
376
 
 
377
try:
 
378
    from bzrlib._rio_pyx import (
 
379
        _read_stanza_utf8,
 
380
        _read_stanza_unicode,
 
381
        _valid_tag,
 
382
        )
 
383
except ImportError, e:
 
384
    osutils.failed_to_load_extension(e)
 
385
    from bzrlib._rio_py import (
 
386
       _read_stanza_utf8,
 
387
       _read_stanza_unicode,
 
388
       _valid_tag,
 
389
       )