← 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: 2009-04-09 20:23:07 UTC
  • mfrom: (4265.1.4 bbc-merge)
  • Revision ID: pqm@pqm.ubuntu.com-20090409202307-n0depb16qepoe21o
(jam) Change _fetch_uses_deltas = False for CHK repos until we can
        write a better fix.

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
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
 
            print >>self._to_file
 
47
            self._to_file.write('\n')
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
 
        assert valid_tag(tag), \
120
 
            ("invalid tag %r" % tag)
 
119
        if not valid_tag(tag):
 
120
            raise ValueError("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
 
        
 
131
 
132
132
    def __contains__(self, find_tag):
133
133
        """True if there is any field in this stanza with the given tag."""
134
134
        for tag, value in self.items:
157
157
 
158
158
    def to_lines(self):
159
159
        """Generate sequence of lines for external version of this file.
160
 
        
 
160
 
161
161
        The lines are always utf-8 encoded strings.
162
162
        """
163
163
        if not self.items:
165
165
            return []
166
166
        result = []
167
167
        for tag, value in self.items:
168
 
            assert isinstance(tag, str), type(tag)
169
 
            assert isinstance(value, unicode)
170
168
            if value == '':
171
169
                result.append(tag + ': \n')
172
170
            elif '\n' in value:
235
233
        """
236
234
        d = {}
237
235
        for tag, value in self.items:
238
 
            assert tag not in d
239
236
            d[tag] = value
240
237
        return d
241
 
         
 
238
 
242
239
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
243
240
def valid_tag(tag):
244
241
    return bool(_tag_re.match(tag))
246
243
 
247
244
def read_stanza(line_iter):
248
245
    """Return new Stanza read from list of lines or a file
249
 
    
 
246
 
250
247
    Returns one Stanza that was read, or returns None at end of file.  If a
251
248
    blank line follows the stanza, it is consumed.  It's not an error for
252
249
    there to be no blank at end of file.  If there is a blank file at the
253
 
    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.
254
251
 
255
252
    Only the stanza lines and the trailing blank (if any) are consumed
256
253
    from the line_iter.
281
278
    stanza = Stanza()
282
279
    tag = None
283
280
    accum_value = None
284
 
    
 
281
 
285
282
    # TODO: jam 20060922 This code should raise real errors rather than
286
283
    #       using 'assert' to process user input, or raising ValueError
287
284
    #       rather than a more specific error.
291
288
            break       # end of file
292
289
        if line == '\n':
293
290
            break       # end of stanza
294
 
        assert line.endswith('\n')
295
291
        real_l = line
296
292
        if line[0] == '\t': # continues previous value
297
293
            if tag is None:
306
302
                raise ValueError('tag/value separator not found in line %r'
307
303
                                 % real_l)
308
304
            tag = str(line[:colon_index])
309
 
            assert valid_tag(tag), \
310
 
                    "invalid rio tag %r" % tag
 
305
            if not valid_tag(tag):
 
306
                raise ValueError("invalid rio tag %r" % (tag,))
311
307
            accum_value = line[colon_index+2:-1]
312
308
 
313
309
    if tag is not None: # add last tag-value
314
310
        stanza.add(tag, accum_value)
315
311
        return stanza
316
312
    else:     # didn't see any content
317
 
        return None    
 
313
        return None
318
314
 
319
315
 
320
316
def to_patch_lines(stanza, max_width=72):
327
323
    :param max_width: The maximum number of characters per physical line.
328
324
    :return: a list of lines
329
325
    """
330
 
    assert max_width > 6
 
326
    if max_width <= 6:
 
327
        raise ValueError(max_width)
331
328
    max_rio_width = max_width - 4
332
329
    lines = []
333
330
    for pline in stanza.to_lines():
373
370
    for line in line_iter:
374
371
        if line.startswith('# '):
375
372
            line = line[2:]
376
 
        else:
377
 
            assert line.startswith('#')
 
373
        elif line.startswith('#'):
378
374
            line = line[1:]
 
375
        else:
 
376
            raise ValueError("bad line %r" % (line,))
379
377
        if last_line is not None and len(line) > 2:
380
378
            line = line[2:]
381
379
        line = re.sub('\r', '', line)