← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Mark Hammond
  • Date: 2008-08-10 11:16:39 UTC
  • mto: (3606.5.3 1.6)
  • mto: This revision was merged to the branch mainline in revision 3626.
  • Revision ID: mhammond@skippinet.com.au-20080810111639-9upz1wig1s8lvz62
install all files with 'restartreplace uninsrestartdelete' and close
tbzrcache at uninstall time.

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
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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.
32
32
 
33
33
import re
34
34
 
35
 
from bzrlib import osutils
36
35
from bzrlib.iterablefile import IterableFile
37
36
 
38
37
# XXX: some redundancy is allowing to write stanzas in isolation as well as
39
 
# through a writer object.
 
38
# through a writer object.  
40
39
 
41
40
class RioWriter(object):
42
41
    def __init__(self, to_file):
52
51
 
53
52
class RioReader(object):
54
53
    """Read stanzas from a file as a sequence
55
 
 
56
 
    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 
57
56
    lines (with newlines.)
58
57
    """
59
58
    def __init__(self, from_file):
94
93
class Stanza(object):
95
94
    """One stanza for rio.
96
95
 
97
 
    Each stanza contains a set of named fields.
98
 
 
 
96
    Each stanza contains a set of named fields.  
 
97
    
99
98
    Names must be non-empty ascii alphanumeric plus _.  Names can be repeated
100
99
    within a stanza.  Names are case-sensitive.  The ordering of fields is
101
100
    preserved.
129
128
            raise TypeError("invalid type for rio value: %r of type %s"
130
129
                            % (value, type(value)))
131
130
        self.items.append((tag, value))
132
 
 
133
 
    @classmethod
134
 
    def from_pairs(cls, pairs):
135
 
        ret = cls()
136
 
        ret.items = pairs
137
 
        return ret
138
 
 
 
131
        
139
132
    def __contains__(self, find_tag):
140
133
        """True if there is any field in this stanza with the given tag."""
141
134
        for tag, value in self.items:
164
157
 
165
158
    def to_lines(self):
166
159
        """Generate sequence of lines for external version of this file.
167
 
 
 
160
        
168
161
        The lines are always utf-8 encoded strings.
169
162
        """
170
163
        if not self.items:
198
191
 
199
192
        result = []
200
193
        for tag, value in self.items:
201
 
            if value == u'':
202
 
                result.append(tag + u': \n')
203
 
            elif u'\n' in value:
 
194
            if value == '':
 
195
                result.append(tag + ': \n')
 
196
            elif '\n' in value:
204
197
                # don't want splitlines behaviour on empty lines
205
 
                val_lines = value.split(u'\n')
206
 
                result.append(tag + u': ' + val_lines[0] + u'\n')
 
198
                val_lines = value.split('\n')
 
199
                result.append(tag + ': ' + val_lines[0] + '\n')
207
200
                for line in val_lines[1:]:
208
 
                    result.append(u'\t' + line + u'\n')
 
201
                    result.append('\t' + line + '\n')
209
202
            else:
210
 
                result.append(tag + u': ' + value + u'\n')
 
203
                result.append(tag + ': ' + value + '\n')
211
204
        return u''.join(result)
212
205
 
213
206
    def write(self, to_file):
242
235
        for tag, value in self.items:
243
236
            d[tag] = value
244
237
        return d
245
 
 
246
 
 
 
238
         
 
239
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
247
240
def valid_tag(tag):
248
 
    return _valid_tag(tag)
 
241
    return bool(_tag_re.match(tag))
249
242
 
250
243
 
251
244
def read_stanza(line_iter):
252
245
    """Return new Stanza read from list of lines or a file
253
 
 
 
246
    
254
247
    Returns one Stanza that was read, or returns None at end of file.  If a
255
248
    blank line follows the stanza, it is consumed.  It's not an error for
256
249
    there to be no blank at end of file.  If there is a blank file at the
257
 
    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. 
258
251
 
259
252
    Only the stanza lines and the trailing blank (if any) are consumed
260
253
    from the line_iter.
261
254
 
262
255
    The raw lines must be in utf-8 encoding.
263
256
    """
264
 
    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)
265
259
 
266
260
 
267
261
def read_stanza_unicode(unicode_iter):
281
275
    :return: A Stanza object if there are any lines in the file.
282
276
        None otherwise
283
277
    """
284
 
    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    
285
314
 
286
315
 
287
316
def to_patch_lines(stanza, max_width=72):
370
399
    :return: a Stanza
371
400
    """
372
401
    return read_stanza(_patch_stanza_iter(line_iter))
373
 
 
374
 
 
375
 
try:
376
 
    from bzrlib._rio_pyx import (
377
 
        _read_stanza_utf8,
378
 
        _read_stanza_unicode,
379
 
        _valid_tag,
380
 
        )
381
 
except ImportError, e:
382
 
    osutils.failed_to_load_extension(e)
383
 
    from bzrlib._rio_py import (
384
 
       _read_stanza_utf8,
385
 
       _read_stanza_unicode,
386
 
       _valid_tag,
387
 
       )