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

  • Committer: Robert Collins
  • Date: 2005-10-19 10:11:57 UTC
  • mfrom: (1185.16.78)
  • mto: This revision was merged to the branch mainline in revision 1470.
  • Revision ID: robertc@robertcollins.net-20051019101157-17438d311e746b4f
merge from upstream

Show diffs side-by-side

added added

removed removed

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