← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Aaron Bentley
  • Date: 2006-06-21 14:30:57 UTC
  • mfrom: (1801.1.1 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1803.
  • Revision ID: abentley@panoramicfeedback.com-20060621143057-776e4b8d707e430e
Install benchmarks. (Jelmer Vernooij)

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