← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Ian Clatworthy
  • Date: 2007-11-30 04:28:32 UTC
  • mto: (3054.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 3055.
  • Revision ID: ian.clatworthy@internode.on.net-20071130042832-6prruj0kzg3fodm8
chapter 2 tweaks

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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
from __future__ import absolute_import
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
16
 
19
17
# \subsection{\emph{rio} - simple text metaformat}
20
 
#
 
18
# 
21
19
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
22
 
#
 
20
# 
23
21
# The stored data consists of a series of \emph{stanzas}, each of which contains
24
22
# \emph{fields} identified by an ascii name, with Unicode or string contents.
25
 
# The field tag is constrained to alphanumeric characters.
 
23
# The field tag is constrained to alphanumeric characters.  
26
24
# There may be more than one field in a stanza with the same name.
27
 
#
 
25
# 
28
26
# The format itself does not deal with character encoding issues, though
29
27
# the result will normally be written in Unicode.
30
 
#
 
28
# 
31
29
# The format is intended to be simple enough that there is exactly one character
32
30
# stream representation of an object and vice versa, and that this relation
33
31
# will continue to hold for future versions of bzr.
34
32
 
35
33
import re
36
34
 
37
 
from bzrlib import osutils
38
35
from bzrlib.iterablefile import IterableFile
39
36
 
40
37
# XXX: some redundancy is allowing to write stanzas in isolation as well as
41
 
# through a writer object.
 
38
# through a writer object.  
42
39
 
43
40
class RioWriter(object):
44
41
    def __init__(self, to_file):
54
51
 
55
52
class RioReader(object):
56
53
    """Read stanzas from a file as a sequence
57
 
 
58
 
    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 
59
56
    lines (with newlines.)
60
57
    """
61
58
    def __init__(self, from_file):
96
93
class Stanza(object):
97
94
    """One stanza for rio.
98
95
 
99
 
    Each stanza contains a set of named fields.
100
 
 
 
96
    Each stanza contains a set of named fields.  
 
97
    
101
98
    Names must be non-empty ascii alphanumeric plus _.  Names can be repeated
102
99
    within a stanza.  Names are case-sensitive.  The ordering of fields is
103
100
    preserved.
119
116
 
120
117
    def add(self, tag, value):
121
118
        """Append a name and value to the stanza."""
122
 
        if not valid_tag(tag):
123
 
            raise ValueError("invalid tag %r" % (tag,))
 
119
        assert valid_tag(tag), \
 
120
            ("invalid tag %r" % tag)
124
121
        if isinstance(value, str):
125
122
            value = unicode(value)
126
123
        elif isinstance(value, unicode):
131
128
            raise TypeError("invalid type for rio value: %r of type %s"
132
129
                            % (value, type(value)))
133
130
        self.items.append((tag, value))
134
 
 
135
 
    @classmethod
136
 
    def from_pairs(cls, pairs):
137
 
        ret = cls()
138
 
        ret.items = pairs
139
 
        return ret
140
 
 
 
131
        
141
132
    def __contains__(self, find_tag):
142
133
        """True if there is any field in this stanza with the given tag."""
143
134
        for tag, value in self.items:
166
157
 
167
158
    def to_lines(self):
168
159
        """Generate sequence of lines for external version of this file.
169
 
 
 
160
        
170
161
        The lines are always utf-8 encoded strings.
171
162
        """
172
163
        if not self.items:
174
165
            return []
175
166
        result = []
176
167
        for tag, value in self.items:
 
168
            assert isinstance(tag, str), type(tag)
 
169
            assert isinstance(value, unicode)
177
170
            if value == '':
178
171
                result.append(tag + ': \n')
179
172
            elif '\n' in value:
200
193
 
201
194
        result = []
202
195
        for tag, value in self.items:
203
 
            if value == u'':
204
 
                result.append(tag + u': \n')
205
 
            elif u'\n' in value:
 
196
            if value == '':
 
197
                result.append(tag + ': \n')
 
198
            elif '\n' in value:
206
199
                # 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')
 
200
                val_lines = value.split('\n')
 
201
                result.append(tag + ': ' + val_lines[0] + '\n')
209
202
                for line in val_lines[1:]:
210
 
                    result.append(u'\t' + line + u'\n')
 
203
                    result.append('\t' + line + '\n')
211
204
            else:
212
 
                result.append(tag + u': ' + value + u'\n')
 
205
                result.append(tag + ': ' + value + '\n')
213
206
        return u''.join(result)
214
207
 
215
208
    def write(self, to_file):
242
235
        """
243
236
        d = {}
244
237
        for tag, value in self.items:
 
238
            assert tag not in d
245
239
            d[tag] = value
246
240
        return d
247
 
 
248
 
 
 
241
         
 
242
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
249
243
def valid_tag(tag):
250
 
    return _valid_tag(tag)
 
244
    return bool(_tag_re.match(tag))
251
245
 
252
246
 
253
247
def read_stanza(line_iter):
254
248
    """Return new Stanza read from list of lines or a file
255
 
 
 
249
    
256
250
    Returns one Stanza that was read, or returns None at end of file.  If a
257
251
    blank line follows the stanza, it is consumed.  It's not an error for
258
252
    there to be no blank at end of file.  If there is a blank file at the
259
 
    start of the input this is really an empty stanza and that is returned.
 
253
    start of the input this is really an empty stanza and that is returned. 
260
254
 
261
255
    Only the stanza lines and the trailing blank (if any) are consumed
262
256
    from the line_iter.
263
257
 
264
258
    The raw lines must be in utf-8 encoding.
265
259
    """
266
 
    return _read_stanza_utf8(line_iter)
 
260
    unicode_iter = (line.decode('utf-8') for line in line_iter)
 
261
    return read_stanza_unicode(unicode_iter)
267
262
 
268
263
 
269
264
def read_stanza_unicode(unicode_iter):
283
278
    :return: A Stanza object if there are any lines in the file.
284
279
        None otherwise
285
280
    """
286
 
    return _read_stanza_unicode(unicode_iter)
 
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    
287
318
 
288
319
 
289
320
def to_patch_lines(stanza, max_width=72):
296
327
    :param max_width: The maximum number of characters per physical line.
297
328
    :return: a list of lines
298
329
    """
299
 
    if max_width <= 6:
300
 
        raise ValueError(max_width)
 
330
    assert max_width > 6
301
331
    max_rio_width = max_width - 4
302
332
    lines = []
303
333
    for pline in stanza.to_lines():
343
373
    for line in line_iter:
344
374
        if line.startswith('# '):
345
375
            line = line[2:]
346
 
        elif line.startswith('#'):
 
376
        else:
 
377
            assert line.startswith('#')
347
378
            line = line[1:]
348
 
        else:
349
 
            raise ValueError("bad line %r" % (line,))
350
379
        if last_line is not None and len(line) > 2:
351
380
            line = line[2:]
352
381
        line = re.sub('\r', '', line)
372
401
    :return: a Stanza
373
402
    """
374
403
    return read_stanza(_patch_stanza_iter(line_iter))
375
 
 
376
 
 
377
 
try:
378
 
    from bzrlib._rio_pyx import (
379
 
        _read_stanza_utf8,
380
 
        _read_stanza_unicode,
381
 
        _valid_tag,
382
 
        )
383
 
except ImportError, e:
384
 
    osutils.failed_to_load_extension(e)
385
 
    from bzrlib._rio_py import (
386
 
       _read_stanza_utf8,
387
 
       _read_stanza_unicode,
388
 
       _valid_tag,
389
 
       )