1
# Copyright (C) 2005 Canonical Ltd
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.
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.
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
17
from __future__ import absolute_import
19
# \subsection{\emph{rio} - simple text metaformat}
21
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
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.
28
# The format itself does not deal with character encoding issues, though
29
# the result will normally be written in Unicode.
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.
38
from .iterablefile import IterableFile
40
# XXX: some redundancy is allowing to write stanzas in isolation as well as
41
# through a writer object.
44
class RioWriter(object):
46
def __init__(self, to_file):
48
self._to_file = to_file
50
def write_stanza(self, stanza):
52
self._to_file.write(b'\n')
53
stanza.write(self._to_file)
57
class RioReader(object):
58
"""Read stanzas from a file as a sequence
60
to_file can be anything that can be enumerated as a sequence of
61
lines (with newlines.)
64
def __init__(self, from_file):
65
self._from_file = from_file
69
s = read_stanza(self._from_file)
76
def rio_file(stanzas, header=None):
77
"""Produce a rio IterableFile from an iterable of stanzas"""
79
if header is not None:
83
if first_stanza is not True:
85
for line in s.to_lines():
88
return IterableFile(str_iter())
91
def read_stanzas(from_file):
94
s = read_stanza(from_file)
100
def read_stanzas_unicode(from_file):
103
s = read_stanza_unicode(from_file)
109
class Stanza(object):
110
"""One stanza for rio.
112
Each stanza contains a set of named fields.
114
Names must be non-empty ascii alphanumeric plus _. Names can be repeated
115
within a stanza. Names are case-sensitive. The ordering of fields is
118
Each field value must be either an int or a string.
121
__slots__ = ['items']
123
def __init__(self, **kwargs):
124
"""Construct a new Stanza.
126
The keyword arguments, if any, are added in sorted order to the stanza.
130
for tag, value in sorted(kwargs.items()):
133
def add(self, tag, value):
134
"""Append a name and value to the stanza."""
135
if not valid_tag(tag):
136
raise ValueError("invalid tag %r" % (tag,))
137
if isinstance(value, bytes):
138
value = value.decode('ascii')
139
elif isinstance(value, str):
142
raise TypeError("invalid type for rio value: %r of type %s"
143
% (value, type(value)))
144
self.items.append((tag, value))
147
def from_pairs(cls, pairs):
152
def __contains__(self, find_tag):
153
"""True if there is any field in this stanza with the given tag."""
154
for tag, value in self.items:
160
"""Return number of pairs in the stanza."""
161
return len(self.items)
163
def __eq__(self, other):
164
if not isinstance(other, Stanza):
166
return self.items == other.items
168
def __ne__(self, other):
169
return not self.__eq__(other)
172
return "Stanza(%r)" % self.items
174
def iter_pairs(self):
175
"""Return iterator of tag, value pairs."""
176
return iter(self.items)
179
"""Generate sequence of lines for external version of this file.
181
The lines are always utf-8 encoded strings.
184
# max() complains if sequence is empty
187
for text_tag, text_value in self.items:
188
tag = text_tag.encode('ascii')
189
value = text_value.encode('utf-8')
191
result.append(tag + b': \n')
193
# don't want splitlines behaviour on empty lines
194
val_lines = value.split(b'\n')
195
result.append(tag + b': ' + val_lines[0] + b'\n')
196
for line in val_lines[1:]:
197
result.append(b'\t' + line + b'\n')
199
result.append(tag + b': ' + value + b'\n')
203
"""Return stanza as a single string"""
204
return b''.join(self.to_lines())
206
def to_unicode(self):
207
"""Return stanza as a single Unicode string.
209
This is most useful when adding a Stanza to a parent Stanza
215
for tag, value in self.items:
217
result.append(tag + u': \n')
219
# don't want splitlines behaviour on empty lines
220
val_lines = value.split(u'\n')
221
result.append(tag + u': ' + val_lines[0] + u'\n')
222
for line in val_lines[1:]:
223
result.append(u'\t' + line + u'\n')
225
result.append(tag + u': ' + value + u'\n')
226
return u''.join(result)
228
def write(self, to_file):
229
"""Write stanza to a file"""
230
to_file.writelines(self.to_lines())
233
"""Return the value for a field wih given tag.
235
If there is more than one value, only the first is returned. If the
236
tag is not present, KeyError is raised.
238
for t, v in self.items:
246
def get_all(self, tag):
248
for t, v in self.items:
254
"""Return a dict containing the unique values of the stanza.
257
for tag, value in self.items:
263
return _valid_tag(tag)
266
def read_stanza(line_iter):
267
"""Return new Stanza read from list of lines or a file
269
Returns one Stanza that was read, or returns None at end of file. If a
270
blank line follows the stanza, it is consumed. It's not an error for
271
there to be no blank at end of file. If there is a blank file at the
272
start of the input this is really an empty stanza and that is returned.
274
Only the stanza lines and the trailing blank (if any) are consumed
277
The raw lines must be in utf-8 encoding.
279
return _read_stanza_utf8(line_iter)
282
def read_stanza_unicode(unicode_iter):
283
"""Read a Stanza from a list of lines or a file.
285
The lines should already be in unicode form. This returns a single
286
stanza that was read. If there is a blank line at the end of the Stanza,
287
it is consumed. It is not an error for there to be no blank line at
288
the end of the iterable. If there is a blank line at the beginning,
289
this is treated as an empty Stanza and None is returned.
291
Only the stanza lines and the trailing blank (if any) are consumed
292
from the unicode_iter
294
:param unicode_iter: A iterable, yeilding Unicode strings. See read_stanza
295
if you have a utf-8 encoded string.
296
:return: A Stanza object if there are any lines in the file.
299
return _read_stanza_unicode(unicode_iter)
302
def to_patch_lines(stanza, max_width=72):
303
"""Convert a stanza into RIO-Patch format lines.
305
RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
306
It resists common forms of damage such as newline conversion or the removal
307
of trailing whitespace, yet is also reasonably easy to read.
309
:param max_width: The maximum number of characters per physical line.
310
:return: a list of lines
313
raise ValueError(max_width)
314
max_rio_width = max_width - 4
316
for pline in stanza.to_lines():
317
for line in pline.split(b'\n')[:-1]:
318
line = re.sub(b'\\\\', b'\\\\\\\\', line)
320
partline = line[:max_rio_width]
321
line = line[max_rio_width:]
322
if len(line) > 0 and line[:1] != [b' ']:
324
break_index = partline.rfind(b' ', -20)
326
break_index = partline.rfind(b'-', -20)
329
break_index = partline.rfind(b'/', -20)
331
line = partline[break_index:] + line
332
partline = partline[:break_index]
335
partline = re.sub(b'\r', b'\\\\r', partline)
339
elif re.search(b' $', partline):
342
lines.append(b'# ' + partline + b'\n')
344
lines.append(b'# \n')
348
def _patch_stanza_iter(line_iter):
349
map = {b'\\\\': b'\\',
354
return map[match.group(0)]
357
for line in line_iter:
358
if line.startswith(b'# '):
360
elif line.startswith(b'#'):
363
raise ValueError("bad line %r" % (line,))
364
if last_line is not None and len(line) > 2:
366
line = re.sub(b'\r', b'', line)
367
line = re.sub(b'\\\\(.|\n)', mapget, line)
368
if last_line is None:
372
if last_line[-1:] == b'\n':
375
if last_line is not None:
379
def read_patch_stanza(line_iter):
380
"""Convert an iterable of RIO-Patch format lines into a Stanza.
382
RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
383
It resists common forms of damage such as newline conversion or the removal
384
of trailing whitespace, yet is also reasonably easy to read.
388
return read_stanza(_patch_stanza_iter(line_iter))
392
from ._rio_pyx import (
394
_read_stanza_unicode,
397
except ImportError as e:
398
osutils.failed_to_load_extension(e)
399
from ._rio_py import (
401
_read_stanza_unicode,
added
removed
breezy/rio.py
