← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Robert Collins
  • Date: 2009-07-07 04:32:13 UTC
  • mto: This revision was merged to the branch mainline in revision 4524.
  • Revision ID: robertc@robertcollins.net-20090707043213-4hjjhgr40iq7gk2d
More informative assertions in xml serialisation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/rio.py
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
# \subsection{\emph{rio} - simple text metaformat}
18
 
# 
 
18
#
19
19
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
20
 
# 
 
20
#
21
21
# The stored data consists of a series of \emph{stanzas}, each of which contains
22
22
# \emph{fields} identified by an ascii name, with Unicode or string contents.
23
 
# The field tag is constrained to alphanumeric characters.  
 
23
# The field tag is constrained to alphanumeric characters.
24
24
# There may be more than one field in a stanza with the same name.
25
 
# 
 
25
#
26
26
# The format itself does not deal with character encoding issues, though
27
27
# the result will normally be written in Unicode.
28
 
# 
 
28
#
29
29
# The format is intended to be simple enough that there is exactly one character
30
30
# stream representation of an object and vice versa, and that this relation
31
31
# will continue to hold for future versions of bzr.
35
35
from bzrlib.iterablefile import IterableFile
36
36
 
37
37
# XXX: some redundancy is allowing to write stanzas in isolation as well as
38
 
# through a writer object.  
 
38
# through a writer object.
39
39
 
40
40
class RioWriter(object):
41
41
    def __init__(self, to_file):
44
44
 
45
45
    def write_stanza(self, stanza):
46
46
        if self._soft_nl:
47
 
            print >>self._to_file
 
47
            self._to_file.write('\n')
48
48
        stanza.write(self._to_file)
49
49
        self._soft_nl = True
50
50
 
51
51
 
52
52
class RioReader(object):
53
53
    """Read stanzas from a file as a sequence
54
 
    
55
 
    to_file can be anything that can be enumerated as a sequence of 
 
54
 
 
55
    to_file can be anything that can be enumerated as a sequence of
56
56
    lines (with newlines.)
57
57
    """
58
58
    def __init__(self, from_file):
93
93
class Stanza(object):
94
94
    """One stanza for rio.
95
95
 
96
 
    Each stanza contains a set of named fields.  
97
 
    
 
96
    Each stanza contains a set of named fields.
 
97
 
98
98
    Names must be non-empty ascii alphanumeric plus _.  Names can be repeated
99
99
    within a stanza.  Names are case-sensitive.  The ordering of fields is
100
100
    preserved.
116
116
 
117
117
    def add(self, tag, value):
118
118
        """Append a name and value to the stanza."""
119
 
        assert valid_tag(tag), \
120
 
            ("invalid tag %r" % tag)
 
119
        if not valid_tag(tag):
 
120
            raise ValueError("invalid tag %r" % (tag,))
121
121
        if isinstance(value, str):
122
122
            value = unicode(value)
123
123
        elif isinstance(value, unicode):
128
128
            raise TypeError("invalid type for rio value: %r of type %s"
129
129
                            % (value, type(value)))
130
130
        self.items.append((tag, value))
131
 
        
 
131
 
 
132
    @classmethod
 
133
    def from_pairs(cls, pairs):
 
134
        ret = cls()
 
135
        ret.items = pairs
 
136
        return ret
 
137
 
132
138
    def __contains__(self, find_tag):
133
139
        """True if there is any field in this stanza with the given tag."""
134
140
        for tag, value in self.items:
157
163
 
158
164
    def to_lines(self):
159
165
        """Generate sequence of lines for external version of this file.
160
 
        
 
166
 
161
167
        The lines are always utf-8 encoded strings.
162
168
        """
163
169
        if not self.items:
165
171
            return []
166
172
        result = []
167
173
        for tag, value in self.items:
168
 
            assert isinstance(tag, str), type(tag)
169
 
            assert isinstance(value, unicode)
170
174
            if value == '':
171
175
                result.append(tag + ': \n')
172
176
            elif '\n' in value:
193
197
 
194
198
        result = []
195
199
        for tag, value in self.items:
196
 
            if value == '':
197
 
                result.append(tag + ': \n')
198
 
            elif '\n' in value:
 
200
            if value == u'':
 
201
                result.append(tag + u': \n')
 
202
            elif u'\n' in value:
199
203
                # don't want splitlines behaviour on empty lines
200
 
                val_lines = value.split('\n')
201
 
                result.append(tag + ': ' + val_lines[0] + '\n')
 
204
                val_lines = value.split(u'\n')
 
205
                result.append(tag + u': ' + val_lines[0] + u'\n')
202
206
                for line in val_lines[1:]:
203
 
                    result.append('\t' + line + '\n')
 
207
                    result.append(u'\t' + line + u'\n')
204
208
            else:
205
 
                result.append(tag + ': ' + value + '\n')
 
209
                result.append(tag + u': ' + value + u'\n')
206
210
        return u''.join(result)
207
211
 
208
212
    def write(self, to_file):
235
239
        """
236
240
        d = {}
237
241
        for tag, value in self.items:
238
 
            assert tag not in d
239
242
            d[tag] = value
240
243
        return d
241
 
         
242
 
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
 
244
 
 
245
 
243
246
def valid_tag(tag):
244
 
    return bool(_tag_re.match(tag))
 
247
    return _valid_tag(tag)
245
248
 
246
249
 
247
250
def read_stanza(line_iter):
248
251
    """Return new Stanza read from list of lines or a file
249
 
    
 
252
 
250
253
    Returns one Stanza that was read, or returns None at end of file.  If a
251
254
    blank line follows the stanza, it is consumed.  It's not an error for
252
255
    there to be no blank at end of file.  If there is a blank file at the
253
 
    start of the input this is really an empty stanza and that is returned. 
 
256
    start of the input this is really an empty stanza and that is returned.
254
257
 
255
258
    Only the stanza lines and the trailing blank (if any) are consumed
256
259
    from the line_iter.
257
260
 
258
261
    The raw lines must be in utf-8 encoding.
259
262
    """
260
 
    unicode_iter = (line.decode('utf-8') for line in line_iter)
261
 
    return read_stanza_unicode(unicode_iter)
 
263
    return _read_stanza_utf8(line_iter)
262
264
 
263
265
 
264
266
def read_stanza_unicode(unicode_iter):
278
280
    :return: A Stanza object if there are any lines in the file.
279
281
        None otherwise
280
282
    """
281
 
    stanza = Stanza()
282
 
    tag = None
283
 
    accum_value = None
284
 
    
285
 
    # TODO: jam 20060922 This code should raise real errors rather than
286
 
    #       using 'assert' to process user input, or raising ValueError
287
 
    #       rather than a more specific error.
288
 
 
289
 
    for line in unicode_iter:
290
 
        if line is None or line == '':
291
 
            break       # end of file
292
 
        if line == '\n':
293
 
            break       # end of stanza
294
 
        assert line.endswith('\n')
295
 
        real_l = line
296
 
        if line[0] == '\t': # continues previous value
297
 
            if tag is None:
298
 
                raise ValueError('invalid continuation line %r' % real_l)
299
 
            accum_value += '\n' + line[1:-1]
300
 
        else: # new tag:value line
301
 
            if tag is not None:
302
 
                stanza.add(tag, accum_value)
303
 
            try:
304
 
                colon_index = line.index(': ')
305
 
            except ValueError:
306
 
                raise ValueError('tag/value separator not found in line %r'
307
 
                                 % real_l)
308
 
            tag = str(line[:colon_index])
309
 
            assert valid_tag(tag), \
310
 
                    "invalid rio tag %r" % tag
311
 
            accum_value = line[colon_index+2:-1]
312
 
 
313
 
    if tag is not None: # add last tag-value
314
 
        stanza.add(tag, accum_value)
315
 
        return stanza
316
 
    else:     # didn't see any content
317
 
        return None    
 
283
    return _read_stanza_unicode(unicode_iter)
318
284
 
319
285
 
320
286
def to_patch_lines(stanza, max_width=72):
327
293
    :param max_width: The maximum number of characters per physical line.
328
294
    :return: a list of lines
329
295
    """
330
 
    assert max_width > 6
 
296
    if max_width <= 6:
 
297
        raise ValueError(max_width)
331
298
    max_rio_width = max_width - 4
332
299
    lines = []
333
300
    for pline in stanza.to_lines():
373
340
    for line in line_iter:
374
341
        if line.startswith('# '):
375
342
            line = line[2:]
376
 
        else:
377
 
            assert line.startswith('#')
 
343
        elif line.startswith('#'):
378
344
            line = line[1:]
 
345
        else:
 
346
            raise ValueError("bad line %r" % (line,))
379
347
        if last_line is not None and len(line) > 2:
380
348
            line = line[2:]
381
349
        line = re.sub('\r', '', line)
401
369
    :return: a Stanza
402
370
    """
403
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
       )