~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

Don't encode unicode messages to UTF-8 in mutter() (the stream writer does it).

Use a codec wrapped log file in tests to match the real environment.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
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
16
 
 
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
#
 
3
# Distributed under the GNU General Public Licence v2
 
4
#
17
5
# \subsection{\emph{rio} - simple text metaformat}
18
6
19
7
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
30
18
# stream representation of an object and vice versa, and that this relation
31
19
# will continue to hold for future versions of bzr.
32
20
 
 
21
# In comments, $\min(1,10)$
 
22
 
 
23
min(1,10)
 
24
 
33
25
import re
34
26
 
35
 
from bzrlib.iterablefile import IterableFile
36
 
 
37
27
# XXX: some redundancy is allowing to write stanzas in isolation as well as
38
28
# through a writer object.  
39
29
 
66
56
            else:
67
57
                yield s
68
58
 
69
 
 
70
 
def rio_file(stanzas, header=None):
71
 
    """Produce a rio IterableFile from an iterable of stanzas"""
72
 
    def str_iter():
73
 
        if header is not None:
74
 
            yield header + '\n'
75
 
        first_stanza = True
76
 
        for s in stanzas:
77
 
            if first_stanza is not True:
78
 
                yield '\n'
79
 
            for line in s.to_lines():
80
 
                yield line
81
 
            first_stanza = False
82
 
    return IterableFile(str_iter())
83
 
 
84
 
 
85
59
def read_stanzas(from_file):
86
60
    while True:
87
61
        s = read_stanza(from_file)
118
92
        """Append a name and value to the stanza."""
119
93
        assert valid_tag(tag), \
120
94
            ("invalid tag %r" % tag)
121
 
        if isinstance(value, str):
122
 
            value = unicode(value)
123
 
        elif isinstance(value, unicode):
 
95
        if isinstance(value, (str, unicode)):
124
96
            pass
125
97
        ## elif isinstance(value, (int, long)):
126
98
        ##    value = str(value)           # XXX: python2.4 without L-suffix
127
99
        else:
128
 
            raise TypeError("invalid type for rio value: %r of type %s"
129
 
                            % (value, type(value)))
 
100
            raise ValueError("invalid value %r" % value)
130
101
        self.items.append((tag, value))
131
102
        
132
103
    def __contains__(self, find_tag):
156
127
        return iter(self.items)
157
128
 
158
129
    def to_lines(self):
159
 
        """Generate sequence of lines for external version of this file.
160
 
        
161
 
        The lines are always utf-8 encoded strings.
162
 
        """
 
130
        """Generate sequence of lines for external version of this file."""
163
131
        if not self.items:
164
132
            # max() complains if sequence is empty
165
133
            return []
166
134
        result = []
167
135
        for tag, value in self.items:
168
 
            assert isinstance(tag, str), type(tag)
169
 
            assert isinstance(value, unicode)
 
136
            assert isinstance(value, (str, unicode))
170
137
            if value == '':
171
138
                result.append(tag + ': \n')
172
139
            elif '\n' in value:
173
140
                # don't want splitlines behaviour on empty lines
174
141
                val_lines = value.split('\n')
175
 
                result.append(tag + ': ' + val_lines[0].encode('utf-8') + '\n')
 
142
                result.append(tag + ': ' + val_lines[0] + '\n')
176
143
                for line in val_lines[1:]:
177
 
                    result.append('\t' + line.encode('utf-8') + '\n')
 
144
                    result.append('\t' + line + '\n')
178
145
            else:
179
 
                result.append(tag + ': ' + value.encode('utf-8') + '\n')
 
146
                result.append(tag + ': ' + value + '\n')
180
147
        return result
181
148
 
182
149
    def to_string(self):
183
150
        """Return stanza as a single string"""
184
151
        return ''.join(self.to_lines())
185
152
 
186
 
    def to_unicode(self):
187
 
        """Return stanza as a single Unicode string.
188
 
 
189
 
        This is most useful when adding a Stanza to a parent Stanza
190
 
        """
191
 
        if not self.items:
192
 
            return u''
193
 
 
194
 
        result = []
195
 
        for tag, value in self.items:
196
 
            if value == '':
197
 
                result.append(tag + ': \n')
198
 
            elif '\n' in value:
199
 
                # don't want splitlines behaviour on empty lines
200
 
                val_lines = value.split('\n')
201
 
                result.append(tag + ': ' + val_lines[0] + '\n')
202
 
                for line in val_lines[1:]:
203
 
                    result.append('\t' + line + '\n')
204
 
            else:
205
 
                result.append(tag + ': ' + value + '\n')
206
 
        return u''.join(result)
207
 
 
208
153
    def write(self, to_file):
209
154
        """Write stanza to a file"""
210
155
        to_file.writelines(self.to_lines())
229
174
            if t == tag:
230
175
                r.append(v)
231
176
        return r
232
 
 
233
 
    def as_dict(self):
234
 
        """Return a dict containing the unique values of the stanza.
235
 
        """
236
 
        d = {}
237
 
        for tag, value in self.items:
238
 
            assert tag not in d
239
 
            d[tag] = value
240
 
        return d
241
177
         
242
178
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
243
179
def valid_tag(tag):
254
190
 
255
191
    Only the stanza lines and the trailing blank (if any) are consumed
256
192
    from the line_iter.
257
 
 
258
 
    The raw lines must be in utf-8 encoding.
259
 
    """
260
 
    unicode_iter = (line.decode('utf-8') for line in line_iter)
261
 
    return read_stanza_unicode(unicode_iter)
262
 
 
263
 
 
264
 
def read_stanza_unicode(unicode_iter):
265
 
    """Read a Stanza from a list of lines or a file.
266
 
 
267
 
    The lines should already be in unicode form. This returns a single
268
 
    stanza that was read. If there is a blank line at the end of the Stanza,
269
 
    it is consumed. It is not an error for there to be no blank line at
270
 
    the end of the iterable. If there is a blank line at the beginning,
271
 
    this is treated as an empty Stanza and None is returned.
272
 
 
273
 
    Only the stanza lines and the trailing blank (if any) are consumed
274
 
    from the unicode_iter
275
 
 
276
 
    :param unicode_iter: A iterable, yeilding Unicode strings. See read_stanza
277
 
        if you have a utf-8 encoded string.
278
 
    :return: A Stanza object if there are any lines in the file.
279
 
        None otherwise
280
 
    """
 
193
    """
 
194
    items = []
281
195
    stanza = Stanza()
282
196
    tag = None
283
197
    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 == '':
 
198
    for line in line_iter:
 
199
        if line == None or line == '':
291
200
            break       # end of file
292
201
        if line == '\n':
293
202
            break       # end of stanza
294
 
        assert line.endswith('\n')
 
203
        assert line[-1] == '\n'
295
204
        real_l = line
296
205
        if line[0] == '\t': # continues previous value
297
206
            if tag is None:
303
212
            try:
304
213
                colon_index = line.index(': ')
305
214
            except ValueError:
306
 
                raise ValueError('tag/value separator not found in line %r'
307
 
                                 % real_l)
308
 
            tag = str(line[:colon_index])
 
215
                raise ValueError('tag/value separator not found in line %r' % real_l)
 
216
            tag = line[:colon_index]
309
217
            assert valid_tag(tag), \
310
218
                    "invalid rio tag %r" % tag
311
219
            accum_value = line[colon_index+2:-1]
312
 
 
313
220
    if tag is not None: # add last tag-value
314
221
        stanza.add(tag, accum_value)
315
222
        return stanza
316
223
    else:     # didn't see any content
317
224
        return None    
318
 
 
319
 
 
320
 
def to_patch_lines(stanza, max_width=72):
321
 
    """Convert a stanza into RIO-Patch format lines.
322
 
 
323
 
    RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
324
 
    It resists common forms of damage such as newline conversion or the removal
325
 
    of trailing whitespace, yet is also reasonably easy to read.
326
 
 
327
 
    :param max_width: The maximum number of characters per physical line.
328
 
    :return: a list of lines
329
 
    """
330
 
    assert max_width > 6
331
 
    max_rio_width = max_width - 4
332
 
    lines = []
333
 
    for pline in stanza.to_lines():
334
 
        for line in pline.split('\n')[:-1]:
335
 
            line = re.sub('\\\\', '\\\\\\\\', line)
336
 
            while len(line) > 0:
337
 
                partline = line[:max_rio_width]
338
 
                line = line[max_rio_width:]
339
 
                if len(line) > 0 and line[0] != [' ']:
340
 
                    break_index = -1
341
 
                    break_index = partline.rfind(' ', -20)
342
 
                    if break_index < 3:
343
 
                        break_index = partline.rfind('-', -20)
344
 
                        break_index += 1
345
 
                    if break_index < 3:
346
 
                        break_index = partline.rfind('/', -20)
347
 
                    if break_index >= 3:
348
 
                        line = partline[break_index:] + line
349
 
                        partline = partline[:break_index]
350
 
                if len(line) > 0:
351
 
                    line = '  ' + line
352
 
                partline = re.sub('\r', '\\\\r', partline)
353
 
                blank_line = False
354
 
                if len(line) > 0:
355
 
                    partline += '\\'
356
 
                elif re.search(' $', partline):
357
 
                    partline += '\\'
358
 
                    blank_line = True
359
 
                lines.append('# ' + partline + '\n')
360
 
                if blank_line:
361
 
                    lines.append('#   \n')
362
 
    return lines
363
 
 
364
 
 
365
 
def _patch_stanza_iter(line_iter):
366
 
    map = {'\\\\': '\\',
367
 
           '\\r' : '\r',
368
 
           '\\\n': ''}
369
 
    def mapget(match):
370
 
        return map[match.group(0)]
371
 
 
372
 
    last_line = None
373
 
    for line in line_iter:
374
 
        if line.startswith('# '):
375
 
            line = line[2:]
376
 
        else:
377
 
            assert line.startswith('#')
378
 
            line = line[1:]
379
 
        if last_line is not None and len(line) > 2:
380
 
            line = line[2:]
381
 
        line = re.sub('\r', '', line)
382
 
        line = re.sub('\\\\(.|\n)', mapget, line)
383
 
        if last_line is None:
384
 
            last_line = line
385
 
        else:
386
 
            last_line += line
387
 
        if last_line[-1] == '\n':
388
 
            yield last_line
389
 
            last_line = None
390
 
    if last_line is not None:
391
 
        yield last_line
392
 
 
393
 
 
394
 
def read_patch_stanza(line_iter):
395
 
    """Convert an iterable of RIO-Patch format lines into a Stanza.
396
 
 
397
 
    RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
398
 
    It resists common forms of damage such as newline conversion or the removal
399
 
    of trailing whitespace, yet is also reasonably easy to read.
400
 
 
401
 
    :return: a Stanza
402
 
    """
403
 
    return read_stanza(_patch_stanza_iter(line_iter))