← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-09-03 22:30:56 UTC
  • mfrom: (3644.2.13 index_builder_cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20080903223056-b108iytb38xkznci
(jam) Streamline BTreeBuilder.add_node et al to make btree creation
        faster.

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.
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:
200
191
 
201
192
        result = []
202
193
        for tag, value in self.items:
203
 
            if value == u'':
204
 
                result.append(tag + u': \n')
205
 
            elif u'\n' in value:
 
194
            if value == '':
 
195
                result.append(tag + ': \n')
 
196
            elif '\n' in value:
206
197
                # 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')
 
198
                val_lines = value.split('\n')
 
199
                result.append(tag + ': ' + val_lines[0] + '\n')
209
200
                for line in val_lines[1:]:
210
 
                    result.append(u'\t' + line + u'\n')
 
201
                    result.append('\t' + line + '\n')
211
202
            else:
212
 
                result.append(tag + u': ' + value + u'\n')
 
203
                result.append(tag + ': ' + value + '\n')
213
204
        return u''.join(result)
214
205
 
215
206
    def write(self, to_file):
244
235
        for tag, value in self.items:
245
236
            d[tag] = value
246
237
        return d
247
 
 
248
 
 
 
238
         
 
239
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
249
240
def valid_tag(tag):
250
 
    return _valid_tag(tag)
 
241
    return bool(_tag_re.match(tag))
251
242
 
252
243
 
253
244
def read_stanza(line_iter):
254
245
    """Return new Stanza read from list of lines or a file
255
 
 
 
246
    
256
247
    Returns one Stanza that was read, or returns None at end of file.  If a
257
248
    blank line follows the stanza, it is consumed.  It's not an error for
258
249
    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.
 
250
    start of the input this is really an empty stanza and that is returned. 
260
251
 
261
252
    Only the stanza lines and the trailing blank (if any) are consumed
262
253
    from the line_iter.
263
254
 
264
255
    The raw lines must be in utf-8 encoding.
265
256
    """
266
 
    return _read_stanza_utf8(line_iter)
 
257
    unicode_iter = (line.decode('utf-8') for line in line_iter)
 
258
    return read_stanza_unicode(unicode_iter)
267
259
 
268
260
 
269
261
def read_stanza_unicode(unicode_iter):
283
275
    :return: A Stanza object if there are any lines in the file.
284
276
        None otherwise
285
277
    """
286
 
    return _read_stanza_unicode(unicode_iter)
 
278
    stanza = Stanza()
 
279
    tag = None
 
280
    accum_value = None
 
281
    
 
282
    # TODO: jam 20060922 This code should raise real errors rather than
 
283
    #       using 'assert' to process user input, or raising ValueError
 
284
    #       rather than a more specific error.
 
285
 
 
286
    for line in unicode_iter:
 
287
        if line is None or line == '':
 
288
            break       # end of file
 
289
        if line == '\n':
 
290
            break       # end of stanza
 
291
        real_l = line
 
292
        if line[0] == '\t': # continues previous value
 
293
            if tag is None:
 
294
                raise ValueError('invalid continuation line %r' % real_l)
 
295
            accum_value += '\n' + line[1:-1]
 
296
        else: # new tag:value line
 
297
            if tag is not None:
 
298
                stanza.add(tag, accum_value)
 
299
            try:
 
300
                colon_index = line.index(': ')
 
301
            except ValueError:
 
302
                raise ValueError('tag/value separator not found in line %r'
 
303
                                 % real_l)
 
304
            tag = str(line[:colon_index])
 
305
            if not valid_tag(tag):
 
306
                raise ValueError("invalid rio tag %r" % (tag,))
 
307
            accum_value = line[colon_index+2:-1]
 
308
 
 
309
    if tag is not None: # add last tag-value
 
310
        stanza.add(tag, accum_value)
 
311
        return stanza
 
312
    else:     # didn't see any content
 
313
        return None    
287
314
 
288
315
 
289
316
def to_patch_lines(stanza, max_width=72):
372
399
    :return: a Stanza
373
400
    """
374
401
    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
 
       )