rbtree 0.2.0 → 0.2.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/ChangeLog +119 -61
- data/LICENSE +1 -1
- data/README +54 -26
- data/extconf.rb +4 -27
- data/rbtree.c +117 -138
- data/test.rb +110 -66
- metadata +45 -35
data/test.rb
CHANGED
@@ -1,16 +1,6 @@
|
|
1
1
|
require "rbtree"
|
2
2
|
require "test/unit.rb"
|
3
3
|
|
4
|
-
module Test
|
5
|
-
module Unit
|
6
|
-
class TestCase
|
7
|
-
unless method_defined?(:assert_raise)
|
8
|
-
alias :assert_raise :assert_raises
|
9
|
-
end
|
10
|
-
end
|
11
|
-
end
|
12
|
-
end
|
13
|
-
|
14
4
|
class RBTreeTest < Test::Unit::TestCase
|
15
5
|
def setup
|
16
6
|
@rbtree = RBTree[*%w(b B d D a A c C)]
|
@@ -22,8 +12,8 @@ class RBTreeTest < Test::Unit::TestCase
|
|
22
12
|
RBTree.new("a")
|
23
13
|
RBTree.new { "a" }
|
24
14
|
}
|
25
|
-
|
26
|
-
|
15
|
+
assert_raises(ArgumentError) { RBTree.new("a") {} }
|
16
|
+
assert_raises(ArgumentError) { RBTree.new("a", "a") }
|
27
17
|
end
|
28
18
|
|
29
19
|
def test_aref
|
@@ -59,14 +49,25 @@ class RBTreeTest < Test::Unit::TestCase
|
|
59
49
|
@rbtree.readjust {|a,b| b <=> a }
|
60
50
|
assert_equal(nil, RBTree[@rbtree].cmp_proc)
|
61
51
|
|
62
|
-
|
52
|
+
assert_raises(ArgumentError) { RBTree["e"] }
|
63
53
|
|
64
54
|
rbtree = RBTree[Hash[*%w(b B d D a A c C)]]
|
65
55
|
assert_equal(4, rbtree.size)
|
66
|
-
assert_equal("A",
|
67
|
-
assert_equal("B",
|
68
|
-
assert_equal("C",
|
69
|
-
assert_equal("D",
|
56
|
+
assert_equal("A", rbtree["a"])
|
57
|
+
assert_equal("B", rbtree["b"])
|
58
|
+
assert_equal("C", rbtree["c"])
|
59
|
+
assert_equal("D", rbtree["d"])
|
60
|
+
|
61
|
+
rbtree = RBTree[[%w(a A), %w(b B), %w(c C), %w(d D)]];
|
62
|
+
assert_equal(4, rbtree.size)
|
63
|
+
assert_equal("A", rbtree["a"])
|
64
|
+
assert_equal("B", rbtree["b"])
|
65
|
+
assert_equal("C", rbtree["c"])
|
66
|
+
assert_equal("D", rbtree["d"])
|
67
|
+
|
68
|
+
rbtree = RBTree[[["a"]]]
|
69
|
+
assert_equal(1, rbtree.size)
|
70
|
+
assert_equal(nil, rbtree["a"])
|
70
71
|
end
|
71
72
|
|
72
73
|
def test_clear
|
@@ -83,10 +84,8 @@ class RBTreeTest < Test::Unit::TestCase
|
|
83
84
|
assert_equal(5, @rbtree.size)
|
84
85
|
assert_equal("E", @rbtree["c"])
|
85
86
|
|
86
|
-
|
87
|
-
|
88
|
-
assert_equal(5, @rbtree.size)
|
89
|
-
end
|
87
|
+
assert_raises(ArgumentError) { @rbtree[100] = 100 }
|
88
|
+
assert_equal(5, @rbtree.size)
|
90
89
|
|
91
90
|
|
92
91
|
key = "f"
|
@@ -134,7 +133,7 @@ class RBTreeTest < Test::Unit::TestCase
|
|
134
133
|
rbtree = RBTree.new("e")
|
135
134
|
assert_equal("e", rbtree.default)
|
136
135
|
assert_equal("e", rbtree.default("f"))
|
137
|
-
|
136
|
+
assert_raises(ArgumentError) { rbtree.default("e", "f") }
|
138
137
|
|
139
138
|
rbtree = RBTree.new {|rbtree, key| @rbtree[key || "c"] }
|
140
139
|
assert_equal("C", rbtree.default(nil))
|
@@ -194,14 +193,14 @@ class RBTreeTest < Test::Unit::TestCase
|
|
194
193
|
assert_equal("C", @rbtree.fetch("c"))
|
195
194
|
assert_equal("D", @rbtree.fetch("d"))
|
196
195
|
|
197
|
-
|
196
|
+
assert_raises(IndexError) { @rbtree.fetch("e") }
|
198
197
|
|
199
198
|
assert_equal("E", @rbtree.fetch("e", "E"))
|
200
199
|
assert_equal("E", @rbtree.fetch("e") { "E" })
|
201
200
|
assert_equal("E", @rbtree.fetch("e", "F") { "E" })
|
202
201
|
|
203
|
-
|
204
|
-
|
202
|
+
assert_raises(ArgumentError) { @rbtree.fetch }
|
203
|
+
assert_raises(ArgumentError) { @rbtree.fetch("e", "E", "E") }
|
205
204
|
end
|
206
205
|
|
207
206
|
def test_index
|
@@ -220,79 +219,99 @@ class RBTreeTest < Test::Unit::TestCase
|
|
220
219
|
@rbtree.each {|key, val| ret << key << val }
|
221
220
|
assert_equal(%w(a A b B c C d D), ret)
|
222
221
|
|
223
|
-
|
222
|
+
assert_raises(TypeError) {
|
224
223
|
@rbtree.each { @rbtree["e"] = "E" }
|
225
224
|
}
|
226
225
|
assert_equal(4, @rbtree.size)
|
227
226
|
|
228
227
|
@rbtree.each {
|
229
228
|
@rbtree.each {}
|
230
|
-
|
229
|
+
assert_raises(TypeError) {
|
231
230
|
@rbtree["e"] = "E"
|
232
231
|
}
|
233
232
|
break
|
234
233
|
}
|
235
234
|
assert_equal(4, @rbtree.size)
|
235
|
+
|
236
|
+
if defined?(Enumerable::Enumerator)
|
237
|
+
enumerator = @rbtree.each
|
238
|
+
assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
|
239
|
+
end
|
236
240
|
end
|
237
|
-
|
241
|
+
|
238
242
|
def test_each_pair
|
239
243
|
ret = []
|
240
244
|
@rbtree.each_pair {|key, val| ret << key << val }
|
241
245
|
assert_equal(%w(a A b B c C d D), ret)
|
242
246
|
|
243
|
-
|
247
|
+
assert_raises(TypeError) {
|
244
248
|
@rbtree.each_pair { @rbtree["e"] = "E" }
|
245
249
|
}
|
246
250
|
assert_equal(4, @rbtree.size)
|
247
251
|
|
248
252
|
@rbtree.each_pair {
|
249
253
|
@rbtree.each_pair {}
|
250
|
-
|
254
|
+
assert_raises(TypeError) {
|
251
255
|
@rbtree["e"] = "E"
|
252
256
|
}
|
253
257
|
break
|
254
258
|
}
|
255
259
|
assert_equal(4, @rbtree.size)
|
260
|
+
|
261
|
+
if defined?(Enumerable::Enumerator)
|
262
|
+
enumerator = @rbtree.each_pair
|
263
|
+
assert_equal(%w(a A b B c C d D), enumerator.map.flatten)
|
264
|
+
end
|
256
265
|
end
|
257
266
|
|
258
267
|
def test_each_key
|
259
268
|
ret = []
|
260
|
-
@rbtree.each_key {|
|
269
|
+
@rbtree.each_key {|key| ret.push(key) }
|
261
270
|
assert_equal(%w(a b c d), ret)
|
262
271
|
|
263
|
-
|
272
|
+
assert_raises(TypeError) {
|
264
273
|
@rbtree.each_key { @rbtree["e"] = "E" }
|
265
274
|
}
|
266
275
|
assert_equal(4, @rbtree.size)
|
267
276
|
|
268
277
|
@rbtree.each_key {
|
269
278
|
@rbtree.each_key {}
|
270
|
-
|
279
|
+
assert_raises(TypeError) {
|
271
280
|
@rbtree["e"] = "E"
|
272
281
|
}
|
273
282
|
break
|
274
283
|
}
|
275
284
|
assert_equal(4, @rbtree.size)
|
285
|
+
|
286
|
+
if defined?(Enumerable::Enumerator)
|
287
|
+
enumerator = @rbtree.each_key
|
288
|
+
assert_equal(%w(a b c d), enumerator.map.flatten)
|
289
|
+
end
|
276
290
|
end
|
277
291
|
|
278
292
|
def test_each_value
|
279
293
|
ret = []
|
280
|
-
@rbtree.each_value {|
|
294
|
+
@rbtree.each_value {|val| ret.push(val) }
|
281
295
|
assert_equal(%w(A B C D), ret)
|
282
296
|
|
283
|
-
|
297
|
+
assert_raises(TypeError) {
|
284
298
|
@rbtree.each_value { @rbtree["e"] = "E" }
|
285
299
|
}
|
286
300
|
assert_equal(4, @rbtree.size)
|
287
301
|
|
288
302
|
@rbtree.each_value {
|
289
303
|
@rbtree.each_value {}
|
290
|
-
|
304
|
+
assert_raises(TypeError) {
|
291
305
|
@rbtree["e"] = "E"
|
292
306
|
}
|
293
307
|
break
|
294
308
|
}
|
295
309
|
assert_equal(4, @rbtree.size)
|
310
|
+
|
311
|
+
if defined?(Enumerable::Enumerator)
|
312
|
+
enumerator = @rbtree.each_value
|
313
|
+
assert_equal(%w(A B C D), enumerator.map.flatten)
|
314
|
+
end
|
296
315
|
end
|
297
316
|
|
298
317
|
def test_shift
|
@@ -341,12 +360,12 @@ class RBTreeTest < Test::Unit::TestCase
|
|
341
360
|
@rbtree.delete_if {|key, val| val == "A" || val == "B" }
|
342
361
|
assert_equal(RBTree[*%w(c C d D)], @rbtree)
|
343
362
|
|
344
|
-
|
363
|
+
assert_raises(ArgumentError) {
|
345
364
|
@rbtree.delete_if {|key, val| key == "c" or raise ArgumentError }
|
346
365
|
}
|
347
366
|
assert_equal(2, @rbtree.size)
|
348
367
|
|
349
|
-
|
368
|
+
assert_raises(TypeError) {
|
350
369
|
@rbtree.delete_if { @rbtree["e"] = "E" }
|
351
370
|
}
|
352
371
|
assert_equal(2, @rbtree.size)
|
@@ -355,12 +374,18 @@ class RBTreeTest < Test::Unit::TestCase
|
|
355
374
|
@rbtree.each {
|
356
375
|
assert_equal(2, @rbtree.size)
|
357
376
|
}
|
358
|
-
|
377
|
+
assert_raises(TypeError) {
|
359
378
|
@rbtree["e"] = "E"
|
360
379
|
}
|
361
380
|
true
|
362
381
|
}
|
363
382
|
assert_equal(0, @rbtree.size)
|
383
|
+
|
384
|
+
if defined?(Enumerable::Enumerator)
|
385
|
+
rbtree = RBTree[*%w(b B d D a A c C)]
|
386
|
+
enumerator = rbtree.delete_if
|
387
|
+
assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
|
388
|
+
end
|
364
389
|
end
|
365
390
|
|
366
391
|
def test_reject_bang
|
@@ -371,8 +396,14 @@ class RBTreeTest < Test::Unit::TestCase
|
|
371
396
|
ret = @rbtree.reject! {|key, val| val == "A" || val == "B" }
|
372
397
|
assert_same(@rbtree, ret)
|
373
398
|
assert_equal(RBTree[*%w(c C d D)], ret)
|
399
|
+
|
400
|
+
if defined?(Enumerable::Enumerator)
|
401
|
+
rbtree = RBTree[*%w(b B d D a A c C)]
|
402
|
+
enumerator = rbtree.reject!
|
403
|
+
assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
|
404
|
+
end
|
374
405
|
end
|
375
|
-
|
406
|
+
|
376
407
|
def test_reject
|
377
408
|
ret = @rbtree.reject { false }
|
378
409
|
assert_equal(nil, ret)
|
@@ -381,12 +412,22 @@ class RBTreeTest < Test::Unit::TestCase
|
|
381
412
|
ret = @rbtree.reject {|key, val| val == "A" || val == "B" }
|
382
413
|
assert_equal(RBTree[*%w(c C d D)], ret)
|
383
414
|
assert_equal(4, @rbtree.size)
|
415
|
+
|
416
|
+
if defined?(Enumerable::Enumerator)
|
417
|
+
enumerator = @rbtree.reject
|
418
|
+
assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B" })
|
419
|
+
end
|
384
420
|
end
|
385
421
|
|
386
422
|
def test_select
|
387
423
|
ret = @rbtree.select {|key, val| val == "A" || val == "B" }
|
388
424
|
assert_equal(%w(a A b B), ret.flatten)
|
389
|
-
|
425
|
+
assert_raises(ArgumentError) { @rbtree.select("c") }
|
426
|
+
|
427
|
+
if defined?(Enumerable::Enumerator)
|
428
|
+
enumerator = @rbtree.select
|
429
|
+
assert_equal([true, true, false, false], enumerator.map {|key, val| val == "A" || val == "B"})
|
430
|
+
end
|
390
431
|
end
|
391
432
|
|
392
433
|
def test_values_at
|
@@ -414,7 +455,7 @@ class RBTreeTest < Test::Unit::TestCase
|
|
414
455
|
}
|
415
456
|
assert_equal(RBTree[*%w(d AB)], @rbtree)
|
416
457
|
|
417
|
-
|
458
|
+
assert_raises(TypeError) { @rbtree.update("e") }
|
418
459
|
end
|
419
460
|
|
420
461
|
def test_merge
|
@@ -538,7 +579,7 @@ class RBTreeTest < Test::Unit::TestCase
|
|
538
579
|
}
|
539
580
|
assert_equal(%w(b c), ret)
|
540
581
|
|
541
|
-
|
582
|
+
assert_raises(TypeError) {
|
542
583
|
@rbtree.bound("a", "d") {
|
543
584
|
@rbtree["e"] = "E"
|
544
585
|
}
|
@@ -547,7 +588,7 @@ class RBTreeTest < Test::Unit::TestCase
|
|
547
588
|
|
548
589
|
@rbtree.bound("b", "c") {
|
549
590
|
@rbtree.bound("b", "c") {}
|
550
|
-
|
591
|
+
assert_raises(TypeError) {
|
551
592
|
@rbtree["e"] = "E"
|
552
593
|
}
|
553
594
|
break
|
@@ -588,15 +629,13 @@ class RBTreeTest < Test::Unit::TestCase
|
|
588
629
|
assert_equal(proc, @rbtree.cmp_proc)
|
589
630
|
|
590
631
|
@rbtree[0] = nil
|
591
|
-
|
592
|
-
|
593
|
-
|
594
|
-
|
595
|
-
|
596
|
-
|
597
|
-
|
598
|
-
assert_raise(ArgumentError) { @rbtree[0] = nil }
|
599
|
-
end
|
632
|
+
assert_raises(ArgumentError) { @rbtree.readjust(nil) }
|
633
|
+
assert_equal(5, @rbtree.size)
|
634
|
+
assert_equal(proc, @rbtree.cmp_proc)
|
635
|
+
|
636
|
+
@rbtree.delete(0)
|
637
|
+
@rbtree.readjust(nil)
|
638
|
+
assert_raises(ArgumentError) { @rbtree[0] = nil }
|
600
639
|
|
601
640
|
|
602
641
|
rbtree = RBTree.new
|
@@ -609,14 +648,12 @@ class RBTreeTest < Test::Unit::TestCase
|
|
609
648
|
rbtree.readjust
|
610
649
|
assert_equal([["e"], ["f"]], rbtree.keys)
|
611
650
|
|
612
|
-
|
613
|
-
|
614
|
-
|
615
|
-
assert_raise(TypeError) { @rbtree.readjust("e") }
|
616
|
-
assert_raise(ArgumentError) {
|
651
|
+
assert_raises(ArgumentError) { @rbtree.readjust { "e" } }
|
652
|
+
assert_raises(TypeError) { @rbtree.readjust("e") }
|
653
|
+
assert_raises(ArgumentError) {
|
617
654
|
@rbtree.readjust(proc) {|a,b| a <=> b }
|
618
655
|
}
|
619
|
-
|
656
|
+
assert_raises(ArgumentError) { @rbtree.readjust(proc, proc) }
|
620
657
|
end
|
621
658
|
|
622
659
|
def test_replace
|
@@ -630,13 +667,18 @@ class RBTreeTest < Test::Unit::TestCase
|
|
630
667
|
assert_equal(rbtree.default, @rbtree.default)
|
631
668
|
assert_equal(rbtree.cmp_proc, @rbtree.cmp_proc)
|
632
669
|
|
633
|
-
|
670
|
+
assert_raises(TypeError) { @rbtree.replace("e") }
|
634
671
|
end
|
635
672
|
|
636
673
|
def test_reverse_each
|
637
674
|
ret = []
|
638
675
|
@rbtree.reverse_each { |key, val| ret.push([key, val]) }
|
639
676
|
assert_equal(%w(d D c C b B a A), ret.flatten)
|
677
|
+
|
678
|
+
if defined?(Enumerable::Enumerator)
|
679
|
+
enumerator = @rbtree.reverse_each
|
680
|
+
assert_equal(%w(d D c C b B a A), enumerator.map.flatten)
|
681
|
+
end
|
640
682
|
end
|
641
683
|
|
642
684
|
def test_marshal
|
@@ -645,11 +687,11 @@ class RBTreeTest < Test::Unit::TestCase
|
|
645
687
|
@rbtree.default = "e"
|
646
688
|
assert_equal(@rbtree, Marshal.load(Marshal.dump(@rbtree)))
|
647
689
|
|
648
|
-
|
690
|
+
assert_raises(TypeError) {
|
649
691
|
Marshal.dump(RBTree.new { "e" })
|
650
692
|
}
|
651
693
|
|
652
|
-
|
694
|
+
assert_raises(TypeError) {
|
653
695
|
@rbtree.readjust {|a, b| a <=> b}
|
654
696
|
Marshal.dump(@rbtree)
|
655
697
|
}
|
@@ -710,7 +752,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
|
|
710
752
|
assert_equal(%w(a A b B b C b D c C), @rbtree.to_a.flatten)
|
711
753
|
|
712
754
|
assert_equal(MultiRBTree[*%w(a A)], MultiRBTree[RBTree[*%w(a A)]])
|
713
|
-
|
755
|
+
assert_raises(TypeError) {
|
714
756
|
RBTree[MultiRBTree[*%w(a A)]]
|
715
757
|
}
|
716
758
|
end
|
@@ -740,7 +782,9 @@ class MultiRBTreeTest < Test::Unit::TestCase
|
|
740
782
|
end
|
741
783
|
|
742
784
|
def test_to_hash
|
743
|
-
|
785
|
+
assert_raises(TypeError) {
|
786
|
+
@rbtree.to_hash
|
787
|
+
}
|
744
788
|
end
|
745
789
|
|
746
790
|
def test_to_rbtree
|
@@ -766,7 +810,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
|
|
766
810
|
def test_replace
|
767
811
|
assert_equal(RBTree[*%w(a A)],
|
768
812
|
MultiRBTree[*%w(a A)].replace(RBTree[*%w(a A)]))
|
769
|
-
|
813
|
+
assert_raises(TypeError) {
|
770
814
|
RBTree[*%w(a A)].replace(MultiRBTree[*%w(a A)])
|
771
815
|
}
|
772
816
|
end
|
@@ -774,7 +818,7 @@ class MultiRBTreeTest < Test::Unit::TestCase
|
|
774
818
|
def test_update
|
775
819
|
assert_equal(MultiRBTree[*%w(a A b B)],
|
776
820
|
MultiRBTree[*%w(a A)].update(RBTree[*%w(b B)]))
|
777
|
-
|
821
|
+
assert_raises(TypeError) {
|
778
822
|
RBTree[*%w(a A)].update(MultiRBTree[*%w(b B)])
|
779
823
|
}
|
780
824
|
end
|
metadata
CHANGED
@@ -1,33 +1,26 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
|
-
rubygems_version: 0.9.4
|
3
|
-
specification_version: 1
|
4
2
|
name: rbtree
|
5
3
|
version: !ruby/object:Gem::Version
|
6
|
-
version: 0.2.
|
7
|
-
date: 2008-02-05 00:00:00 +09:00
|
8
|
-
summary: A sorted associative collection.
|
9
|
-
require_paths:
|
10
|
-
- .
|
11
|
-
email: burningdowntheopera at yahoo dot co dot jp
|
12
|
-
homepage: http://www.geocities.co.jp/SiliconValley-PaloAlto/3388/rbtree/README.html
|
13
|
-
rubyforge_project:
|
14
|
-
description: RBTree is a sorted associative collection using Red-Black Tree as the internal data structure. The elements of RBTree are ordered and the interface is the almost same as Hash, so simply you can consider RBTree sorted Hash.
|
15
|
-
autorequire:
|
16
|
-
default_executable:
|
17
|
-
bindir: bin
|
18
|
-
has_rdoc: true
|
19
|
-
required_ruby_version: !ruby/object:Gem::Version::Requirement
|
20
|
-
requirements:
|
21
|
-
- - ">"
|
22
|
-
- !ruby/object:Gem::Version
|
23
|
-
version: 0.0.0
|
24
|
-
version:
|
4
|
+
version: 0.2.1
|
25
5
|
platform: ruby
|
26
|
-
signing_key:
|
27
|
-
cert_chain:
|
28
|
-
post_install_message:
|
29
6
|
authors:
|
30
7
|
- OZAWA Takuma
|
8
|
+
autorequire:
|
9
|
+
bindir: bin
|
10
|
+
cert_chain: []
|
11
|
+
|
12
|
+
date: 2009-01-27 00:00:00 +09:00
|
13
|
+
default_executable:
|
14
|
+
dependencies: []
|
15
|
+
|
16
|
+
description: RBTree is a sorted associative collection that is implemented with Red-Black Tree. The elements of RBTree are ordered and its interface is the almost same as Hash, so simply you can consider RBTree sorted Hash.
|
17
|
+
email: burningdowntheopera at yahoo dot co dot jp
|
18
|
+
executables: []
|
19
|
+
|
20
|
+
extensions:
|
21
|
+
- extconf.rb
|
22
|
+
extra_rdoc_files:
|
23
|
+
- rbtree.c
|
31
24
|
files:
|
32
25
|
- ChangeLog
|
33
26
|
- LICENSE
|
@@ -39,20 +32,37 @@ files:
|
|
39
32
|
- extconf.rb
|
40
33
|
- rbtree.c
|
41
34
|
- test.rb
|
42
|
-
|
43
|
-
|
35
|
+
has_rdoc: true
|
36
|
+
homepage: http://www.geocities.co.jp/SiliconValley-PaloAlto/3388/rbtree/README.html
|
37
|
+
post_install_message:
|
44
38
|
rdoc_options:
|
39
|
+
- -S
|
40
|
+
- -t
|
41
|
+
- ruby-rbtree
|
45
42
|
- --main
|
46
|
-
-
|
43
|
+
- MultiRBTree
|
47
44
|
- --exclude
|
48
45
|
- .*
|
49
|
-
|
50
|
-
-
|
51
|
-
|
52
|
-
|
53
|
-
|
54
|
-
-
|
46
|
+
require_paths:
|
47
|
+
- .
|
48
|
+
required_ruby_version: !ruby/object:Gem::Requirement
|
49
|
+
requirements:
|
50
|
+
- - ">="
|
51
|
+
- !ruby/object:Gem::Version
|
52
|
+
version: 1.8.0
|
53
|
+
version:
|
54
|
+
required_rubygems_version: !ruby/object:Gem::Requirement
|
55
|
+
requirements:
|
56
|
+
- - ">="
|
57
|
+
- !ruby/object:Gem::Version
|
58
|
+
version: "0"
|
59
|
+
version:
|
55
60
|
requirements: []
|
56
61
|
|
57
|
-
|
58
|
-
|
62
|
+
rubyforge_project: rbtree
|
63
|
+
rubygems_version: 1.3.1
|
64
|
+
signing_key:
|
65
|
+
specification_version: 2
|
66
|
+
summary: A sorted associative collection.
|
67
|
+
test_files:
|
68
|
+
- test.rb
|