1
# Copyright (C) 2005 by Canonical Ltd
3
# Distributed under the GNU General Public Licence v2
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
5
19
# \subsection{\emph{rio} - simple text metaformat}
7
21
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
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.
14
28
# The format itself does not deal with character encoding issues, though
15
29
# the result will normally be written in Unicode.
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.
21
# In comments, $\min(1,10)$
37
from bzrlib import osutils
38
from bzrlib.iterablefile import IterableFile
27
40
# XXX: some redundancy is allowing to write stanzas in isolation as well as
28
# through a writer object.
41
# through a writer object.
30
43
class RioWriter(object):
31
44
def __init__(self, to_file):
91
120
def add(self, tag, value):
92
121
"""Append a name and value to the stanza."""
93
assert valid_tag(tag), \
94
("invalid tag %r" % tag)
95
if isinstance(value, (str, unicode)):
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):
97
128
## elif isinstance(value, (int, long)):
98
129
## value = str(value) # XXX: python2.4 without L-suffix
100
raise ValueError("invalid value %r" % value)
131
raise TypeError("invalid type for rio value: %r of type %s"
132
% (value, type(value)))
101
133
self.items.append((tag, value))
136
def from_pairs(cls, pairs):
103
141
def __contains__(self, find_tag):
104
142
"""True if there is any field in this stanza with the given tag."""
105
143
for tag, value in self.items:
127
165
return iter(self.items)
129
167
def to_lines(self):
130
"""Generate sequence of lines for external version of this file."""
168
"""Generate sequence of lines for external version of this file.
170
The lines are always utf-8 encoded strings.
131
172
if not self.items:
132
173
# max() complains if sequence is empty
135
176
for tag, value in self.items:
136
assert isinstance(value, (str, unicode))
138
178
result.append(tag + ': \n')
139
179
elif '\n' in value:
140
180
# don't want splitlines behaviour on empty lines
141
181
val_lines = value.split('\n')
142
result.append(tag + ': ' + val_lines[0] + '\n')
182
result.append(tag + ': ' + val_lines[0].encode('utf-8') + '\n')
143
183
for line in val_lines[1:]:
144
result.append('\t' + line + '\n')
184
result.append('\t' + line.encode('utf-8') + '\n')
146
result.append(tag + ': ' + value + '\n')
186
result.append(tag + ': ' + value.encode('utf-8') + '\n')
149
189
def to_string(self):
150
190
"""Return stanza as a single string"""
151
191
return ''.join(self.to_lines())
193
def to_unicode(self):
194
"""Return stanza as a single Unicode string.
196
This is most useful when adding a Stanza to a parent Stanza
202
for tag, value in self.items:
204
result.append(tag + u': \n')
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')
212
result.append(tag + u': ' + value + u'\n')
213
return u''.join(result)
153
215
def write(self, to_file):
154
216
"""Write stanza to a file"""
155
217
to_file.writelines(self.to_lines())
178
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
241
"""Return a dict containing the unique values of the stanza.
244
for tag, value in self.items:
179
249
def valid_tag(tag):
180
return bool(_tag_re.match(tag))
250
return _valid_tag(tag)
183
253
def read_stanza(line_iter):
184
254
"""Return new Stanza read from list of lines or a file
186
256
Returns one Stanza that was read, or returns None at end of file. If a
187
257
blank line follows the stanza, it is consumed. It's not an error for
188
258
there to be no blank at end of file. If there is a blank file at the
189
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.
191
261
Only the stanza lines and the trailing blank (if any) are consumed
192
262
from the line_iter.
264
The raw lines must be in utf-8 encoding.
266
return _read_stanza_utf8(line_iter)
269
def read_stanza_unicode(unicode_iter):
270
"""Read a Stanza from a list of lines or a file.
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.
278
Only the stanza lines and the trailing blank (if any) are consumed
279
from the unicode_iter
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.
286
return _read_stanza_unicode(unicode_iter)
289
def to_patch_lines(stanza, max_width=72):
290
"""Convert a stanza into RIO-Patch format lines.
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.
296
:param max_width: The maximum number of characters per physical line.
297
:return: a list of lines
300
raise ValueError(max_width)
301
max_rio_width = max_width - 4
303
for pline in stanza.to_lines():
304
for line in pline.split('\n')[:-1]:
305
line = re.sub('\\\\', '\\\\\\\\', line)
307
partline = line[:max_rio_width]
308
line = line[max_rio_width:]
309
if len(line) > 0 and line[0] != [' ']:
311
break_index = partline.rfind(' ', -20)
313
break_index = partline.rfind('-', -20)
316
break_index = partline.rfind('/', -20)
318
line = partline[break_index:] + line
319
partline = partline[:break_index]
322
partline = re.sub('\r', '\\\\r', partline)
326
elif re.search(' $', partline):
329
lines.append('# ' + partline + '\n')
335
def _patch_stanza_iter(line_iter):
340
return map[match.group(0)]
198
343
for line in line_iter:
199
if line == None or line == '':
202
break # end of stanza
203
assert line[-1] == '\n'
205
if line[0] == '\t': # continues previous value
207
raise ValueError('invalid continuation line %r' % real_l)
208
accum_value += '\n' + line[1:-1]
209
else: # new tag:value line
211
stanza.add(tag, accum_value)
213
colon_index = line.index(': ')
215
raise ValueError('tag/value separator not found in line %r' % real_l)
216
tag = line[:colon_index]
217
assert valid_tag(tag), \
218
"invalid rio tag %r" % tag
219
accum_value = line[colon_index+2:-1]
220
if tag is not None: # add last tag-value
221
stanza.add(tag, accum_value)
223
else: # didn't see any content
344
if line.startswith('# '):
346
elif line.startswith('#'):
349
raise ValueError("bad line %r" % (line,))
350
if last_line is not None and len(line) > 2:
352
line = re.sub('\r', '', line)
353
line = re.sub('\\\\(.|\n)', mapget, line)
354
if last_line is None:
358
if last_line[-1] == '\n':
361
if last_line is not None:
365
def read_patch_stanza(line_iter):
366
"""Convert an iterable of RIO-Patch format lines into a Stanza.
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.
374
return read_stanza(_patch_stanza_iter(line_iter))
378
from bzrlib._rio_pyx import (
380
_read_stanza_unicode,
383
except ImportError, e:
384
osutils.failed_to_load_extension(e)
385
from bzrlib._rio_py import (
387
_read_stanza_unicode,
added
removed
bzrlib/rio.py
