← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

(vila) Fix test failures blocking package builds. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/rio.py
1
 
# Copyright (C) 2005 by Canonical Ltd
2
 
#
3
 
# Distributed under the GNU General Public Licence v2
 
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
4
18
 
5
19
# \subsection{\emph{rio} - simple text metaformat}
6
 
# 
 
20
#
7
21
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
8
 
# 
 
22
#
9
23
# The stored data consists of a series of \emph{stanzas}, each of which contains
10
24
# \emph{fields} identified by an ascii name, with Unicode or string contents.
11
 
# The field tag is constrained to alphanumeric characters.  
 
25
# The field tag is constrained to alphanumeric characters.
12
26
# There may be more than one field in a stanza with the same name.
13
 
# 
 
27
#
14
28
# The format itself does not deal with character encoding issues, though
15
29
# the result will normally be written in Unicode.
16
 
# 
 
30
#
17
31
# The format is intended to be simple enough that there is exactly one character
18
32
# stream representation of an object and vice versa, and that this relation
19
33
# will continue to hold for future versions of bzr.
20
34
 
21
35
import re
22
36
 
 
37
from bzrlib import osutils
23
38
from bzrlib.iterablefile import IterableFile
24
39
 
25
40
# XXX: some redundancy is allowing to write stanzas in isolation as well as
26
 
# through a writer object.  
 
41
# through a writer object.
27
42
 
28
43
class RioWriter(object):
29
44
    def __init__(self, to_file):
32
47
 
33
48
    def write_stanza(self, stanza):
34
49
        if self._soft_nl:
35
 
            print >>self._to_file
 
50
            self._to_file.write('\n')
36
51
        stanza.write(self._to_file)
37
52
        self._soft_nl = True
38
53
 
39
54
 
40
55
class RioReader(object):
41
56
    """Read stanzas from a file as a sequence
42
 
    
43
 
    to_file can be anything that can be enumerated as a sequence of 
 
57
 
 
58
    to_file can be anything that can be enumerated as a sequence of
44
59
    lines (with newlines.)
45
60
    """
46
61
    def __init__(self, from_file):
81
96
class Stanza(object):
82
97
    """One stanza for rio.
83
98
 
84
 
    Each stanza contains a set of named fields.  
85
 
    
 
99
    Each stanza contains a set of named fields.
 
100
 
86
101
    Names must be non-empty ascii alphanumeric plus _.  Names can be repeated
87
102
    within a stanza.  Names are case-sensitive.  The ordering of fields is
88
103
    preserved.
104
119
 
105
120
    def add(self, tag, value):
106
121
        """Append a name and value to the stanza."""
107
 
        assert valid_tag(tag), \
108
 
            ("invalid tag %r" % tag)
 
122
        if not valid_tag(tag):
 
123
            raise ValueError("invalid tag %r" % (tag,))
109
124
        if isinstance(value, str):
110
125
            value = unicode(value)
111
126
        elif isinstance(value, unicode):
116
131
            raise TypeError("invalid type for rio value: %r of type %s"
117
132
                            % (value, type(value)))
118
133
        self.items.append((tag, value))
119
 
        
 
134
 
 
135
    @classmethod
 
136
    def from_pairs(cls, pairs):
 
137
        ret = cls()
 
138
        ret.items = pairs
 
139
        return ret
 
140
 
120
141
    def __contains__(self, find_tag):
121
142
        """True if there is any field in this stanza with the given tag."""
122
143
        for tag, value in self.items:
145
166
 
146
167
    def to_lines(self):
147
168
        """Generate sequence of lines for external version of this file.
148
 
        
 
169
 
149
170
        The lines are always utf-8 encoded strings.
150
171
        """
151
172
        if not self.items:
153
174
            return []
154
175
        result = []
155
176
        for tag, value in self.items:
156
 
            assert isinstance(tag, str), type(tag)
157
 
            assert isinstance(value, unicode)
158
177
            if value == '':
159
178
                result.append(tag + ': \n')
160
179
            elif '\n' in value:
181
200
 
182
201
        result = []
183
202
        for tag, value in self.items:
184
 
            if value == '':
185
 
                result.append(tag + ': \n')
186
 
            elif '\n' in value:
 
203
            if value == u'':
 
204
                result.append(tag + u': \n')
 
205
            elif u'\n' in value:
187
206
                # don't want splitlines behaviour on empty lines
188
 
                val_lines = value.split('\n')
189
 
                result.append(tag + ': ' + val_lines[0] + '\n')
 
207
                val_lines = value.split(u'\n')
 
208
                result.append(tag + u': ' + val_lines[0] + u'\n')
190
209
                for line in val_lines[1:]:
191
 
                    result.append('\t' + line + '\n')
 
210
                    result.append(u'\t' + line + u'\n')
192
211
            else:
193
 
                result.append(tag + ': ' + value + '\n')
 
212
                result.append(tag + u': ' + value + u'\n')
194
213
        return u''.join(result)
195
214
 
196
215
    def write(self, to_file):
223
242
        """
224
243
        d = {}
225
244
        for tag, value in self.items:
226
 
            assert tag not in d
227
245
            d[tag] = value
228
246
        return d
229
 
         
230
 
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
 
247
 
 
248
 
231
249
def valid_tag(tag):
232
 
    return bool(_tag_re.match(tag))
 
250
    return _valid_tag(tag)
233
251
 
234
252
 
235
253
def read_stanza(line_iter):
236
254
    """Return new Stanza read from list of lines or a file
237
 
    
 
255
 
238
256
    Returns one Stanza that was read, or returns None at end of file.  If a
239
257
    blank line follows the stanza, it is consumed.  It's not an error for
240
258
    there to be no blank at end of file.  If there is a blank file at the
241
 
    start of the input this is really an empty stanza and that is returned. 
 
259
    start of the input this is really an empty stanza and that is returned.
242
260
 
243
261
    Only the stanza lines and the trailing blank (if any) are consumed
244
262
    from the line_iter.
245
263
 
246
264
    The raw lines must be in utf-8 encoding.
247
265
    """
248
 
    unicode_iter = (line.decode('utf-8') for line in line_iter)
249
 
    return read_stanza_unicode(unicode_iter)
 
266
    return _read_stanza_utf8(line_iter)
250
267
 
251
268
 
252
269
def read_stanza_unicode(unicode_iter):
266
283
    :return: A Stanza object if there are any lines in the file.
267
284
        None otherwise
268
285
    """
269
 
    stanza = Stanza()
270
 
    tag = None
271
 
    accum_value = None
272
 
    
273
 
    # TODO: jam 20060922 This code should raise real errors rather than
274
 
    #       using 'assert' to process user input, or raising ValueError
275
 
    #       rather than a more specific error.
276
 
 
277
 
    for line in unicode_iter:
278
 
        if line is None or line == '':
279
 
            break       # end of file
280
 
        if line == '\n':
281
 
            break       # end of stanza
282
 
        assert line.endswith('\n')
283
 
        real_l = line
284
 
        if line[0] == '\t': # continues previous value
285
 
            if tag is None:
286
 
                raise ValueError('invalid continuation line %r' % real_l)
287
 
            accum_value += '\n' + line[1:-1]
288
 
        else: # new tag:value line
289
 
            if tag is not None:
290
 
                stanza.add(tag, accum_value)
291
 
            try:
292
 
                colon_index = line.index(': ')
293
 
            except ValueError:
294
 
                raise ValueError('tag/value separator not found in line %r'
295
 
                                 % real_l)
296
 
            tag = str(line[:colon_index])
297
 
            assert valid_tag(tag), \
298
 
                    "invalid rio tag %r" % tag
299
 
            accum_value = line[colon_index+2:-1]
300
 
 
301
 
    if tag is not None: # add last tag-value
302
 
        stanza.add(tag, accum_value)
303
 
        return stanza
304
 
    else:     # didn't see any content
305
 
        return None    
 
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
       )