← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Patch Queue Manager
  • Date: 2016-04-21 04:10:52 UTC
  • mfrom: (6616.1.1 fix-en-user-guide)
  • Revision ID: pqm@pqm.ubuntu.com-20160421041052-clcye7ns1qcl2n7w
(richard-wilbur) Ensure build of English use guide always uses English text
 even when user's locale specifies a different language. (Jelmer Vernooij)

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
 
 
17
from __future__ import absolute_import
16
18
 
17
19
# \subsection{\emph{rio} - simple text metaformat}
18
 
# 
 
20
#
19
21
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
20
 
# 
 
22
#
21
23
# The stored data consists of a series of \emph{stanzas}, each of which contains
22
24
# \emph{fields} identified by an ascii name, with Unicode or string contents.
23
 
# The field tag is constrained to alphanumeric characters.  
 
25
# The field tag is constrained to alphanumeric characters.
24
26
# There may be more than one field in a stanza with the same name.
25
 
# 
 
27
#
26
28
# The format itself does not deal with character encoding issues, though
27
29
# the result will normally be written in Unicode.
28
 
# 
 
30
#
29
31
# The format is intended to be simple enough that there is exactly one character
30
32
# stream representation of an object and vice versa, and that this relation
31
33
# will continue to hold for future versions of bzr.
32
34
 
33
35
import re
34
36
 
 
37
from bzrlib import osutils
35
38
from bzrlib.iterablefile import IterableFile
36
39
 
37
40
# XXX: some redundancy is allowing to write stanzas in isolation as well as
38
 
# through a writer object.  
 
41
# through a writer object.
39
42
 
40
43
class RioWriter(object):
41
44
    def __init__(self, to_file):
51
54
 
52
55
class RioReader(object):
53
56
    """Read stanzas from a file as a sequence
54
 
    
55
 
    to_file can be anything that can be enumerated as a sequence of 
 
57
 
 
58
    to_file can be anything that can be enumerated as a sequence of
56
59
    lines (with newlines.)
57
60
    """
58
61
    def __init__(self, from_file):
93
96
class Stanza(object):
94
97
    """One stanza for rio.
95
98
 
96
 
    Each stanza contains a set of named fields.  
97
 
    
 
99
    Each stanza contains a set of named fields.
 
100
 
98
101
    Names must be non-empty ascii alphanumeric plus _.  Names can be repeated
99
102
    within a stanza.  Names are case-sensitive.  The ordering of fields is
100
103
    preserved.
128
131
            raise TypeError("invalid type for rio value: %r of type %s"
129
132
                            % (value, type(value)))
130
133
        self.items.append((tag, value))
131
 
        
 
134
 
 
135
    @classmethod
 
136
    def from_pairs(cls, pairs):
 
137
        ret = cls()
 
138
        ret.items = pairs
 
139
        return ret
 
140
 
132
141
    def __contains__(self, find_tag):
133
142
        """True if there is any field in this stanza with the given tag."""
134
143
        for tag, value in self.items:
157
166
 
158
167
    def to_lines(self):
159
168
        """Generate sequence of lines for external version of this file.
160
 
        
 
169
 
161
170
        The lines are always utf-8 encoded strings.
162
171
        """
163
172
        if not self.items:
191
200
 
192
201
        result = []
193
202
        for tag, value in self.items:
194
 
            if value == '':
195
 
                result.append(tag + ': \n')
196
 
            elif '\n' in value:
 
203
            if value == u'':
 
204
                result.append(tag + u': \n')
 
205
            elif u'\n' in value:
197
206
                # don't want splitlines behaviour on empty lines
198
 
                val_lines = value.split('\n')
199
 
                result.append(tag + ': ' + val_lines[0] + '\n')
 
207
                val_lines = value.split(u'\n')
 
208
                result.append(tag + u': ' + val_lines[0] + u'\n')
200
209
                for line in val_lines[1:]:
201
 
                    result.append('\t' + line + '\n')
 
210
                    result.append(u'\t' + line + u'\n')
202
211
            else:
203
 
                result.append(tag + ': ' + value + '\n')
 
212
                result.append(tag + u': ' + value + u'\n')
204
213
        return u''.join(result)
205
214
 
206
215
    def write(self, to_file):
235
244
        for tag, value in self.items:
236
245
            d[tag] = value
237
246
        return d
238
 
         
239
 
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
 
247
 
 
248
 
240
249
def valid_tag(tag):
241
 
    return bool(_tag_re.match(tag))
 
250
    return _valid_tag(tag)
242
251
 
243
252
 
244
253
def read_stanza(line_iter):
245
254
    """Return new Stanza read from list of lines or a file
246
 
    
 
255
 
247
256
    Returns one Stanza that was read, or returns None at end of file.  If a
248
257
    blank line follows the stanza, it is consumed.  It's not an error for
249
258
    there to be no blank at end of file.  If there is a blank file at the
250
 
    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.
251
260
 
252
261
    Only the stanza lines and the trailing blank (if any) are consumed
253
262
    from the line_iter.
254
263
 
255
264
    The raw lines must be in utf-8 encoding.
256
265
    """
257
 
    unicode_iter = (line.decode('utf-8') for line in line_iter)
258
 
    return read_stanza_unicode(unicode_iter)
 
266
    return _read_stanza_utf8(line_iter)
259
267
 
260
268
 
261
269
def read_stanza_unicode(unicode_iter):
275
283
    :return: A Stanza object if there are any lines in the file.
276
284
        None otherwise
277
285
    """
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    
 
286
    return _read_stanza_unicode(unicode_iter)
314
287
 
315
288
 
316
289
def to_patch_lines(stanza, max_width=72):
399
372
    :return: a Stanza
400
373
    """
401
374
    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
       )