← 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: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

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.
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
 
            self._to_file.write('\n')
 
47
            print >>self._to_file
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
 
        if not valid_tag(tag):
120
 
            raise ValueError("invalid tag %r" % (tag,))
 
119
        assert valid_tag(tag), \
 
120
            ("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
 
 
132
 
    @classmethod
133
 
    def from_pairs(cls, pairs):
134
 
        ret = cls()
135
 
        ret.items = pairs
136
 
        return ret
137
 
 
 
131
        
138
132
    def __contains__(self, find_tag):
139
133
        """True if there is any field in this stanza with the given tag."""
140
134
        for tag, value in self.items:
163
157
 
164
158
    def to_lines(self):
165
159
        """Generate sequence of lines for external version of this file.
166
 
 
 
160
        
167
161
        The lines are always utf-8 encoded strings.
168
162
        """
169
163
        if not self.items:
171
165
            return []
172
166
        result = []
173
167
        for tag, value in self.items:
 
168
            assert isinstance(tag, str), type(tag)
 
169
            assert isinstance(value, unicode)
174
170
            if value == '':
175
171
                result.append(tag + ': \n')
176
172
            elif '\n' in value:
197
193
 
198
194
        result = []
199
195
        for tag, value in self.items:
200
 
            if value == u'':
201
 
                result.append(tag + u': \n')
202
 
            elif u'\n' in value:
 
196
            if value == '':
 
197
                result.append(tag + ': \n')
 
198
            elif '\n' in value:
203
199
                # don't want splitlines behaviour on empty lines
204
 
                val_lines = value.split(u'\n')
205
 
                result.append(tag + u': ' + val_lines[0] + u'\n')
 
200
                val_lines = value.split('\n')
 
201
                result.append(tag + ': ' + val_lines[0] + '\n')
206
202
                for line in val_lines[1:]:
207
 
                    result.append(u'\t' + line + u'\n')
 
203
                    result.append('\t' + line + '\n')
208
204
            else:
209
 
                result.append(tag + u': ' + value + u'\n')
 
205
                result.append(tag + ': ' + value + '\n')
210
206
        return u''.join(result)
211
207
 
212
208
    def write(self, to_file):
239
235
        """
240
236
        d = {}
241
237
        for tag, value in self.items:
 
238
            assert tag not in d
242
239
            d[tag] = value
243
240
        return d
244
 
 
245
 
 
 
241
         
 
242
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
246
243
def valid_tag(tag):
247
 
    return _valid_tag(tag)
 
244
    return bool(_tag_re.match(tag))
248
245
 
249
246
 
250
247
def read_stanza(line_iter):
251
248
    """Return new Stanza read from list of lines or a file
252
 
 
 
249
    
253
250
    Returns one Stanza that was read, or returns None at end of file.  If a
254
251
    blank line follows the stanza, it is consumed.  It's not an error for
255
252
    there to be no blank at end of file.  If there is a blank file at the
256
 
    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. 
257
254
 
258
255
    Only the stanza lines and the trailing blank (if any) are consumed
259
256
    from the line_iter.
260
257
 
261
258
    The raw lines must be in utf-8 encoding.
262
259
    """
263
 
    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)
264
262
 
265
263
 
266
264
def read_stanza_unicode(unicode_iter):
280
278
    :return: A Stanza object if there are any lines in the file.
281
279
        None otherwise
282
280
    """
283
 
    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    
284
318
 
285
319
 
286
320
def to_patch_lines(stanza, max_width=72):
293
327
    :param max_width: The maximum number of characters per physical line.
294
328
    :return: a list of lines
295
329
    """
296
 
    if max_width <= 6:
297
 
        raise ValueError(max_width)
 
330
    assert max_width > 6
298
331
    max_rio_width = max_width - 4
299
332
    lines = []
300
333
    for pline in stanza.to_lines():
340
373
    for line in line_iter:
341
374
        if line.startswith('# '):
342
375
            line = line[2:]
343
 
        elif line.startswith('#'):
 
376
        else:
 
377
            assert line.startswith('#')
344
378
            line = line[1:]
345
 
        else:
346
 
            raise ValueError("bad line %r" % (line,))
347
379
        if last_line is not None and len(line) > 2:
348
380
            line = line[2:]
349
381
        line = re.sub('\r', '', line)
369
401
    :return: a Stanza
370
402
    """
371
403
    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
 
       )