← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/rio.py

  • Committer: Martin Pool
  • Date: 2007-04-04 06:17:31 UTC
  • mto: This revision was merged to the branch mainline in revision 2397.
  • Revision ID: mbp@sourcefrog.net-20070404061731-tt2xrzllqhbodn83
Contents of TODO file moved into bug tracker

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