← 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: 2006-06-16 14:33:42 UTC
  • mfrom: (1770.2.1 config)
  • Revision ID: pqm@pqm.ubuntu.com-20060616143342-8f7f4a4f77c1e4c8
Use create_signature for signing policy, deprecate check_signatures for this

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/rio.py
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
 
1
# Copyright (C) 2005 by Canonical Ltd
 
2
#
 
3
# Distributed under the GNU General Public Licence v2
16
4
 
17
5
# \subsection{\emph{rio} - simple text metaformat}
18
6
# 
44
32
 
45
33
    def write_stanza(self, stanza):
46
34
        if self._soft_nl:
47
 
            self._to_file.write('\n')
 
35
            print >>self._to_file
48
36
        stanza.write(self._to_file)
49
37
        self._soft_nl = True
50
38
 
116
104
 
117
105
    def add(self, tag, value):
118
106
        """Append a name and value to the stanza."""
119
 
        if not valid_tag(tag):
120
 
            raise ValueError("invalid tag %r" % (tag,))
 
107
        assert valid_tag(tag), \
 
108
            ("invalid tag %r" % tag)
121
109
        if isinstance(value, str):
122
110
            value = unicode(value)
123
111
        elif isinstance(value, unicode):
165
153
            return []
166
154
        result = []
167
155
        for tag, value in self.items:
 
156
            assert isinstance(tag, str), type(tag)
 
157
            assert isinstance(value, unicode)
168
158
            if value == '':
169
159
                result.append(tag + ': \n')
170
160
            elif '\n' in value:
181
171
        """Return stanza as a single string"""
182
172
        return ''.join(self.to_lines())
183
173
 
184
 
    def to_unicode(self):
185
 
        """Return stanza as a single Unicode string.
186
 
 
187
 
        This is most useful when adding a Stanza to a parent Stanza
188
 
        """
189
 
        if not self.items:
190
 
            return u''
191
 
 
192
 
        result = []
193
 
        for tag, value in self.items:
194
 
            if value == '':
195
 
                result.append(tag + ': \n')
196
 
            elif '\n' in value:
197
 
                # don't want splitlines behaviour on empty lines
198
 
                val_lines = value.split('\n')
199
 
                result.append(tag + ': ' + val_lines[0] + '\n')
200
 
                for line in val_lines[1:]:
201
 
                    result.append('\t' + line + '\n')
202
 
            else:
203
 
                result.append(tag + ': ' + value + '\n')
204
 
        return u''.join(result)
205
 
 
206
174
    def write(self, to_file):
207
175
        """Write stanza to a file"""
208
176
        to_file.writelines(self.to_lines())
233
201
        """
234
202
        d = {}
235
203
        for tag, value in self.items:
 
204
            assert tag not in d
236
205
            d[tag] = value
237
206
        return d
238
207
         
254
223
 
255
224
    The raw lines must be in utf-8 encoding.
256
225
    """
257
 
    unicode_iter = (line.decode('utf-8') for line in line_iter)
258
 
    return read_stanza_unicode(unicode_iter)
259
 
 
260
 
 
261
 
def read_stanza_unicode(unicode_iter):
262
 
    """Read a Stanza from a list of lines or a file.
263
 
 
264
 
    The lines should already be in unicode form. This returns a single
265
 
    stanza that was read. If there is a blank line at the end of the Stanza,
266
 
    it is consumed. It is not an error for there to be no blank line at
267
 
    the end of the iterable. If there is a blank line at the beginning,
268
 
    this is treated as an empty Stanza and None is returned.
269
 
 
270
 
    Only the stanza lines and the trailing blank (if any) are consumed
271
 
    from the unicode_iter
272
 
 
273
 
    :param unicode_iter: A iterable, yeilding Unicode strings. See read_stanza
274
 
        if you have a utf-8 encoded string.
275
 
    :return: A Stanza object if there are any lines in the file.
276
 
        None otherwise
277
 
    """
 
226
    items = []
278
227
    stanza = Stanza()
279
228
    tag = None
280
229
    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 == '':
 
230
    for line in line_iter:
 
231
        if line == None or line == '':
288
232
            break       # end of file
289
233
        if line == '\n':
290
234
            break       # end of stanza
 
235
        line = line.decode('utf-8')
 
236
        assert line[-1] == '\n'
291
237
        real_l = line
292
238
        if line[0] == '\t': # continues previous value
293
239
            if tag is None:
299
245
            try:
300
246
                colon_index = line.index(': ')
301
247
            except ValueError:
302
 
                raise ValueError('tag/value separator not found in line %r'
303
 
                                 % real_l)
 
248
                raise ValueError('tag/value separator not found in line %r' % real_l)
304
249
            tag = str(line[:colon_index])
305
 
            if not valid_tag(tag):
306
 
                raise ValueError("invalid rio tag %r" % (tag,))
 
250
            assert valid_tag(tag), \
 
251
                    "invalid rio tag %r" % tag
307
252
            accum_value = line[colon_index+2:-1]
308
 
 
309
253
    if tag is not None: # add last tag-value
310
254
        stanza.add(tag, accum_value)
311
255
        return stanza
312
256
    else:     # didn't see any content
313
257
        return None    
314
 
 
315
 
 
316
 
def to_patch_lines(stanza, max_width=72):
317
 
    """Convert a stanza into RIO-Patch format lines.
318
 
 
319
 
    RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
320
 
    It resists common forms of damage such as newline conversion or the removal
321
 
    of trailing whitespace, yet is also reasonably easy to read.
322
 
 
323
 
    :param max_width: The maximum number of characters per physical line.
324
 
    :return: a list of lines
325
 
    """
326
 
    if max_width <= 6:
327
 
        raise ValueError(max_width)
328
 
    max_rio_width = max_width - 4
329
 
    lines = []
330
 
    for pline in stanza.to_lines():
331
 
        for line in pline.split('\n')[:-1]:
332
 
            line = re.sub('\\\\', '\\\\\\\\', line)
333
 
            while len(line) > 0:
334
 
                partline = line[:max_rio_width]
335
 
                line = line[max_rio_width:]
336
 
                if len(line) > 0 and line[0] != [' ']:
337
 
                    break_index = -1
338
 
                    break_index = partline.rfind(' ', -20)
339
 
                    if break_index < 3:
340
 
                        break_index = partline.rfind('-', -20)
341
 
                        break_index += 1
342
 
                    if break_index < 3:
343
 
                        break_index = partline.rfind('/', -20)
344
 
                    if break_index >= 3:
345
 
                        line = partline[break_index:] + line
346
 
                        partline = partline[:break_index]
347
 
                if len(line) > 0:
348
 
                    line = '  ' + line
349
 
                partline = re.sub('\r', '\\\\r', partline)
350
 
                blank_line = False
351
 
                if len(line) > 0:
352
 
                    partline += '\\'
353
 
                elif re.search(' $', partline):
354
 
                    partline += '\\'
355
 
                    blank_line = True
356
 
                lines.append('# ' + partline + '\n')
357
 
                if blank_line:
358
 
                    lines.append('#   \n')
359
 
    return lines
360
 
 
361
 
 
362
 
def _patch_stanza_iter(line_iter):
363
 
    map = {'\\\\': '\\',
364
 
           '\\r' : '\r',
365
 
           '\\\n': ''}
366
 
    def mapget(match):
367
 
        return map[match.group(0)]
368
 
 
369
 
    last_line = None
370
 
    for line in line_iter:
371
 
        if line.startswith('# '):
372
 
            line = line[2:]
373
 
        elif line.startswith('#'):
374
 
            line = line[1:]
375
 
        else:
376
 
            raise ValueError("bad line %r" % (line,))
377
 
        if last_line is not None and len(line) > 2:
378
 
            line = line[2:]
379
 
        line = re.sub('\r', '', line)
380
 
        line = re.sub('\\\\(.|\n)', mapget, line)
381
 
        if last_line is None:
382
 
            last_line = line
383
 
        else:
384
 
            last_line += line
385
 
        if last_line[-1] == '\n':
386
 
            yield last_line
387
 
            last_line = None
388
 
    if last_line is not None:
389
 
        yield last_line
390
 
 
391
 
 
392
 
def read_patch_stanza(line_iter):
393
 
    """Convert an iterable of RIO-Patch format lines into a Stanza.
394
 
 
395
 
    RIO-Patch is a RIO variant designed to be e-mailed as part of a patch.
396
 
    It resists common forms of damage such as newline conversion or the removal
397
 
    of trailing whitespace, yet is also reasonably easy to read.
398
 
 
399
 
    :return: a Stanza
400
 
    """
401
 
    return read_stanza(_patch_stanza_iter(line_iter))