/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/util/bencode.py

  • Committer: Martin Pool
  • Date: 2007-02-15 01:23:29 UTC
  • mfrom: (2284 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2309.
  • Revision ID: mbp@sourcefrog.net-20070215012329-blt2xfhup97r6w8h
merge up from bzr.dev to get metadir changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/util/bencode.py
 
1
# Written by Petru Paler
 
2
# see LICENSE.txt for license information
 
3
 
 
4
def decode_int(x, f):
 
5
    f += 1
 
6
    newf = x.index('e', f)
 
7
    try:
 
8
        n = int(x[f:newf])
 
9
    except (OverflowError, ValueError):
 
10
        n = long(x[f:newf])
 
11
    if x[f] == '-':
 
12
        if x[f + 1] == '0':
 
13
            raise ValueError
 
14
    elif x[f] == '0' and newf != f+1:
 
15
        raise ValueError
 
16
    return (n, newf+1)
 
17
 
 
18
def decode_string(x, f):
 
19
    colon = x.index(':', f)
 
20
    try:
 
21
        n = int(x[f:colon])
 
22
    except (OverflowError, ValueError):
 
23
        n = long(x[f:colon])
 
24
    if x[f] == '0' and colon != f+1:
 
25
        raise ValueError
 
26
    colon += 1
 
27
    return (x[colon:colon+n], colon+n)
 
28
 
 
29
def decode_list(x, f):
 
30
    r, f = [], f+1
 
31
    while x[f] != 'e':
 
32
        v, f = decode_func[x[f]](x, f)
 
33
        r.append(v)
 
34
    return (r, f + 1)
 
35
 
 
36
def decode_dict(x, f):
 
37
    r, f = {}, f+1
 
38
    lastkey = None
 
39
    while x[f] != 'e':
 
40
        k, f = decode_string(x, f)
 
41
        if lastkey >= k:
 
42
            raise ValueError
 
43
        lastkey = k
 
44
        r[k], f = decode_func[x[f]](x, f)
 
45
    return (r, f + 1)
 
46
 
 
47
decode_func = {}
 
48
decode_func['l'] = decode_list
 
49
decode_func['d'] = decode_dict
 
50
decode_func['i'] = decode_int
 
51
decode_func['0'] = decode_string
 
52
decode_func['1'] = decode_string
 
53
decode_func['2'] = decode_string
 
54
decode_func['3'] = decode_string
 
55
decode_func['4'] = decode_string
 
56
decode_func['5'] = decode_string
 
57
decode_func['6'] = decode_string
 
58
decode_func['7'] = decode_string
 
59
decode_func['8'] = decode_string
 
60
decode_func['9'] = decode_string
 
61
 
 
62
def bdecode(x):
 
63
    try:
 
64
        r, l = decode_func[x[0]](x, 0)
 
65
    except (IndexError, KeyError):
 
66
        raise ValueError
 
67
    if l != len(x):
 
68
        raise ValueError
 
69
    return r
 
70
 
 
71
def test_bdecode():
 
72
    try:
 
73
        bdecode('0:0:')
 
74
        assert 0
 
75
    except ValueError:
 
76
        pass
 
77
    try:
 
78
        bdecode('ie')
 
79
        assert 0
 
80
    except ValueError:
 
81
        pass
 
82
    try:
 
83
        bdecode('i341foo382e')
 
84
        assert 0
 
85
    except ValueError:
 
86
        pass
 
87
    assert bdecode('i4e') == 4L
 
88
    assert bdecode('i0e') == 0L
 
89
    assert bdecode('i123456789e') == 123456789L
 
90
    assert bdecode('i-10e') == -10L
 
91
    try:
 
92
        bdecode('i-0e')
 
93
        assert 0
 
94
    except ValueError:
 
95
        pass
 
96
    try:
 
97
        bdecode('i123')
 
98
        assert 0
 
99
    except ValueError:
 
100
        pass
 
101
    try:
 
102
        bdecode('')
 
103
        assert 0
 
104
    except ValueError:
 
105
        pass
 
106
    try:
 
107
        bdecode('i6easd')
 
108
        assert 0
 
109
    except ValueError:
 
110
        pass
 
111
    try:
 
112
        bdecode('35208734823ljdahflajhdf')
 
113
        assert 0
 
114
    except ValueError:
 
115
        pass
 
116
    try:
 
117
        bdecode('2:abfdjslhfld')
 
118
        assert 0
 
119
    except ValueError:
 
120
        pass
 
121
    assert bdecode('0:') == ''
 
122
    assert bdecode('3:abc') == 'abc'
 
123
    assert bdecode('10:1234567890') == '1234567890'
 
124
    try:
 
125
        bdecode('02:xy')
 
126
        assert 0
 
127
    except ValueError:
 
128
        pass
 
129
    try:
 
130
        bdecode('l')
 
131
        assert 0
 
132
    except ValueError:
 
133
        pass
 
134
    assert bdecode('le') == []
 
135
    try:
 
136
        bdecode('leanfdldjfh')
 
137
        assert 0
 
138
    except ValueError:
 
139
        pass
 
140
    assert bdecode('l0:0:0:e') == ['', '', '']
 
141
    try:
 
142
        bdecode('relwjhrlewjh')
 
143
        assert 0
 
144
    except ValueError:
 
145
        pass
 
146
    assert bdecode('li1ei2ei3ee') == [1, 2, 3]
 
147
    assert bdecode('l3:asd2:xye') == ['asd', 'xy']
 
148
    assert bdecode('ll5:Alice3:Bobeli2ei3eee') == [['Alice', 'Bob'], [2, 3]]
 
149
    try:
 
150
        bdecode('d')
 
151
        assert 0
 
152
    except ValueError:
 
153
        pass
 
154
    try:
 
155
        bdecode('defoobar')
 
156
        assert 0
 
157
    except ValueError:
 
158
        pass
 
159
    assert bdecode('de') == {}
 
160
    assert bdecode('d3:agei25e4:eyes4:bluee') == {'age': 25, 'eyes': 'blue'}
 
161
    assert bdecode('d8:spam.mp3d6:author5:Alice6:lengthi100000eee') == {'spam.mp3': {'author': 'Alice', 'length': 100000}}
 
162
    try:
 
163
        bdecode('d3:fooe')
 
164
        assert 0
 
165
    except ValueError:
 
166
        pass
 
167
    try:
 
168
        bdecode('di1e0:e')
 
169
        assert 0
 
170
    except ValueError:
 
171
        pass
 
172
    try:
 
173
        bdecode('d1:b0:1:a0:e')
 
174
        assert 0
 
175
    except ValueError:
 
176
        pass
 
177
    try:
 
178
        bdecode('d1:a0:1:a0:e')
 
179
        assert 0
 
180
    except ValueError:
 
181
        pass
 
182
    try:
 
183
        bdecode('i03e')
 
184
        assert 0
 
185
    except ValueError:
 
186
        pass
 
187
    try:
 
188
        bdecode('l01:ae')
 
189
        assert 0
 
190
    except ValueError:
 
191
        pass
 
192
    try:
 
193
        bdecode('9999:x')
 
194
        assert 0
 
195
    except ValueError:
 
196
        pass
 
197
    try:
 
198
        bdecode('l0:')
 
199
        assert 0
 
200
    except ValueError:
 
201
        pass
 
202
    try:
 
203
        bdecode('d0:0:')
 
204
        assert 0
 
205
    except ValueError:
 
206
        pass
 
207
    try:
 
208
        bdecode('d0:')
 
209
        assert 0
 
210
    except ValueError:
 
211
        pass
 
212
    try:
 
213
        bdecode('00:')
 
214
        assert 0
 
215
    except ValueError:
 
216
        pass
 
217
    try:
 
218
        bdecode('l-3:e')
 
219
        assert 0
 
220
    except ValueError:
 
221
        pass
 
222
    try:
 
223
        bdecode('i-03e')
 
224
        assert 0
 
225
    except ValueError:
 
226
        pass
 
227
    bdecode('d0:i3ee')
 
228
 
 
229
from types import StringType, IntType, LongType, DictType, ListType, TupleType
 
230
 
 
231
class Bencached(object):
 
232
    __slots__ = ['bencoded']
 
233
 
 
234
    def __init__(self, s):
 
235
        self.bencoded = s
 
236
 
 
237
def encode_bencached(x,r):
 
238
    r.append(x.bencoded)
 
239
 
 
240
def encode_int(x, r):
 
241
    r.extend(('i', str(x), 'e'))
 
242
 
 
243
def encode_string(x, r):
 
244
    r.extend((str(len(x)), ':', x))
 
245
 
 
246
def encode_list(x, r):
 
247
    r.append('l')
 
248
    for i in x:
 
249
        encode_func[type(i)](i, r)
 
250
    r.append('e')
 
251
 
 
252
def encode_dict(x,r):
 
253
    r.append('d')
 
254
    ilist = x.items()
 
255
    ilist.sort()
 
256
    for k, v in ilist:
 
257
        r.extend((str(len(k)), ':', k))
 
258
        encode_func[type(v)](v, r)
 
259
    r.append('e')
 
260
 
 
261
encode_func = {}
 
262
encode_func[type(Bencached(0))] = encode_bencached
 
263
encode_func[IntType] = encode_int
 
264
encode_func[LongType] = encode_int
 
265
encode_func[StringType] = encode_string
 
266
encode_func[ListType] = encode_list
 
267
encode_func[TupleType] = encode_list
 
268
encode_func[DictType] = encode_dict
 
269
 
 
270
try:
 
271
    from types import BooleanType
 
272
    encode_func[BooleanType] = encode_int
 
273
except ImportError:
 
274
    pass
 
275
 
 
276
def bencode(x):
 
277
    r = []
 
278
    encode_func[type(x)](x, r)
 
279
    return ''.join(r)
 
280
 
 
281
def test_bencode():
 
282
    assert bencode(4) == 'i4e'
 
283
    assert bencode(0) == 'i0e'
 
284
    assert bencode(-10) == 'i-10e'
 
285
    assert bencode(12345678901234567890L) == 'i12345678901234567890e'
 
286
    assert bencode('') == '0:'
 
287
    assert bencode('abc') == '3:abc'
 
288
    assert bencode('1234567890') == '10:1234567890'
 
289
    assert bencode([]) == 'le'
 
290
    assert bencode([1, 2, 3]) == 'li1ei2ei3ee'
 
291
    assert bencode([['Alice', 'Bob'], [2, 3]]) == 'll5:Alice3:Bobeli2ei3eee'
 
292
    assert bencode({}) == 'de'
 
293
    assert bencode({'age': 25, 'eyes': 'blue'}) == 'd3:agei25e4:eyes4:bluee'
 
294
    assert bencode({'spam.mp3': {'author': 'Alice', 'length': 100000}}) == 'd8:spam.mp3d6:author5:Alice6:lengthi100000eee'
 
295
    assert bencode(Bencached(bencode(3))) == 'i3e'
 
296
    try:
 
297
        bencode({1: 'foo'})
 
298
    except TypeError:
 
299
        return
 
300
    assert 0
 
301
 
 
302
try:
 
303
    import psyco
 
304
    psyco.bind(bdecode)
 
305
    psyco.bind(bencode)
 
306
except ImportError:
 
307
    pass