← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: John Arbash Meinel
  • Date: 2006-10-10 06:26:39 UTC
  • mto: This revision was merged to the branch mainline in revision 2070.
  • Revision ID: john@arbash-meinel.com-20061010062639-6d527d0f9a3401d8
Catch an exception while opening /dev/urandom rather than using os.path.exists()

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/rio.py
1
1
# Copyright (C) 2005 by Canonical Ltd
2
2
#
3
3
# Distributed under the GNU General Public Licence v2
4
 
#
 
4
 
5
5
# \subsection{\emph{rio} - simple text metaformat}
6
6
# 
7
7
# \emph{r} stands for `restricted', `reproducible', or `rfc822-like'.
18
18
# stream representation of an object and vice versa, and that this relation
19
19
# will continue to hold for future versions of bzr.
20
20
 
21
 
# In comments, $\min(1,10)$
22
 
 
23
 
min(1,10)
24
 
 
25
21
import re
26
22
 
 
23
from bzrlib.iterablefile import IterableFile
 
24
 
27
25
# XXX: some redundancy is allowing to write stanzas in isolation as well as
28
26
# through a writer object.  
29
27
 
56
54
            else:
57
55
                yield s
58
56
 
 
57
 
 
58
def rio_file(stanzas, header=None):
 
59
    """Produce a rio IterableFile from an iterable of stanzas"""
 
60
    def str_iter():
 
61
        if header is not None:
 
62
            yield header + '\n'
 
63
        first_stanza = True
 
64
        for s in stanzas:
 
65
            if first_stanza is not True:
 
66
                yield '\n'
 
67
            for line in s.to_lines():
 
68
                yield line
 
69
            first_stanza = False
 
70
    return IterableFile(str_iter())
 
71
 
 
72
 
59
73
def read_stanzas(from_file):
60
74
    while True:
61
75
        s = read_stanza(from_file)
92
106
        """Append a name and value to the stanza."""
93
107
        assert valid_tag(tag), \
94
108
            ("invalid tag %r" % tag)
95
 
        if isinstance(value, (str, unicode)):
 
109
        if isinstance(value, str):
 
110
            value = unicode(value)
 
111
        elif isinstance(value, unicode):
96
112
            pass
97
113
        ## elif isinstance(value, (int, long)):
98
114
        ##    value = str(value)           # XXX: python2.4 without L-suffix
99
115
        else:
100
 
            raise ValueError("invalid value %r" % value)
 
116
            raise TypeError("invalid type for rio value: %r of type %s"
 
117
                            % (value, type(value)))
101
118
        self.items.append((tag, value))
102
119
        
103
120
    def __contains__(self, find_tag):
127
144
        return iter(self.items)
128
145
 
129
146
    def to_lines(self):
130
 
        """Generate sequence of lines for external version of this file."""
 
147
        """Generate sequence of lines for external version of this file.
 
148
        
 
149
        The lines are always utf-8 encoded strings.
 
150
        """
131
151
        if not self.items:
132
152
            # max() complains if sequence is empty
133
153
            return []
134
154
        result = []
135
155
        for tag, value in self.items:
136
 
            assert isinstance(value, (str, unicode))
 
156
            assert isinstance(tag, str), type(tag)
 
157
            assert isinstance(value, unicode)
137
158
            if value == '':
138
159
                result.append(tag + ': \n')
139
160
            elif '\n' in value:
140
161
                # don't want splitlines behaviour on empty lines
141
162
                val_lines = value.split('\n')
142
 
                result.append(tag + ': ' + val_lines[0] + '\n')
 
163
                result.append(tag + ': ' + val_lines[0].encode('utf-8') + '\n')
143
164
                for line in val_lines[1:]:
144
 
                    result.append('\t' + line + '\n')
 
165
                    result.append('\t' + line.encode('utf-8') + '\n')
145
166
            else:
146
 
                result.append(tag + ': ' + value + '\n')
 
167
                result.append(tag + ': ' + value.encode('utf-8') + '\n')
147
168
        return result
148
169
 
149
170
    def to_string(self):
150
171
        """Return stanza as a single string"""
151
172
        return ''.join(self.to_lines())
152
173
 
 
174
    def to_unicode(self):
 
175
        """Return stanza as a single Unicode string.
 
176
 
 
177
        This is most useful when adding a Stanza to a parent Stanza
 
178
        """
 
179
        if not self.items:
 
180
            return u''
 
181
 
 
182
        result = []
 
183
        for tag, value in self.items:
 
184
            if value == '':
 
185
                result.append(tag + ': \n')
 
186
            elif '\n' in value:
 
187
                # don't want splitlines behaviour on empty lines
 
188
                val_lines = value.split('\n')
 
189
                result.append(tag + ': ' + val_lines[0] + '\n')
 
190
                for line in val_lines[1:]:
 
191
                    result.append('\t' + line + '\n')
 
192
            else:
 
193
                result.append(tag + ': ' + value + '\n')
 
194
        return u''.join(result)
 
195
 
153
196
    def write(self, to_file):
154
197
        """Write stanza to a file"""
155
198
        to_file.writelines(self.to_lines())
174
217
            if t == tag:
175
218
                r.append(v)
176
219
        return r
 
220
 
 
221
    def as_dict(self):
 
222
        """Return a dict containing the unique values of the stanza.
 
223
        """
 
224
        d = {}
 
225
        for tag, value in self.items:
 
226
            assert tag not in d
 
227
            d[tag] = value
 
228
        return d
177
229
         
178
230
_tag_re = re.compile(r'^[-a-zA-Z0-9_]+$')
179
231
def valid_tag(tag):
190
242
 
191
243
    Only the stanza lines and the trailing blank (if any) are consumed
192
244
    from the line_iter.
193
 
    """
194
 
    items = []
 
245
 
 
246
    The raw lines must be in utf-8 encoding.
 
247
    """
 
248
    unicode_iter = (line.decode('utf-8') for line in line_iter)
 
249
    return read_stanza_unicode(unicode_iter)
 
250
 
 
251
 
 
252
def read_stanza_unicode(unicode_iter):
 
253
    """Read a Stanza from a list of lines or a file.
 
254
 
 
255
    The lines should already be in unicode form. This returns a single
 
256
    stanza that was read. If there is a blank line at the end of the Stanza,
 
257
    it is consumed. It is not an error for there to be no blank line at
 
258
    the end of the iterable. If there is a blank line at the beginning,
 
259
    this is treated as an empty Stanza and None is returned.
 
260
 
 
261
    Only the stanza lines and the trailing blank (if any) are consumed
 
262
    from the unicode_iter
 
263
 
 
264
    :param unicode_iter: A iterable, yeilding Unicode strings. See read_stanza
 
265
        if you have a utf-8 encoded string.
 
266
    :return: A Stanza object if there are any lines in the file.
 
267
        None otherwise
 
268
    """
195
269
    stanza = Stanza()
196
270
    tag = None
197
271
    accum_value = None
198
 
    for line in line_iter:
199
 
        if line == None or line == '':
 
272
    
 
273
    # TODO: jam 20060922 This code should raise real errors rather than
 
274
    #       using 'assert' to process user input, or raising ValueError
 
275
    #       rather than a more specific error.
 
276
 
 
277
    for line in unicode_iter:
 
278
        if line is None or line == '':
200
279
            break       # end of file
201
280
        if line == '\n':
202
281
            break       # end of stanza
203
 
        assert line[-1] == '\n'
 
282
        assert line.endswith('\n')
204
283
        real_l = line
205
284
        if line[0] == '\t': # continues previous value
206
285
            if tag is None:
212
291
            try:
213
292
                colon_index = line.index(': ')
214
293
            except ValueError:
215
 
                raise ValueError('tag/value separator not found in line %r' % real_l)
216
 
            tag = line[:colon_index]
 
294
                raise ValueError('tag/value separator not found in line %r'
 
295
                                 % real_l)
 
296
            tag = str(line[:colon_index])
217
297
            assert valid_tag(tag), \
218
298
                    "invalid rio tag %r" % tag
219
299
            accum_value = line[colon_index+2:-1]
 
300
 
220
301
    if tag is not None: # add last tag-value
221
302
        stanza.add(tag, accum_value)
222
303
        return stanza