tins 0.3.0

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.
Files changed (76) hide show
  1. data/.gitignore +4 -0
  2. data/.travis.yml +7 -0
  3. data/Gemfile +5 -0
  4. data/LICENSE +18 -0
  5. data/README.rdoc +20 -0
  6. data/Rakefile +28 -0
  7. data/TODO +1 -0
  8. data/VERSION +1 -0
  9. data/lib/spruz.rb +1 -0
  10. data/lib/tins.rb +34 -0
  11. data/lib/tins/alias.rb +1 -0
  12. data/lib/tins/attempt.rb +51 -0
  13. data/lib/tins/bijection.rb +46 -0
  14. data/lib/tins/count_by.rb +8 -0
  15. data/lib/tins/deep_dup.rb +11 -0
  16. data/lib/tins/file_binary.rb +85 -0
  17. data/lib/tins/generator.rb +68 -0
  18. data/lib/tins/go.rb +43 -0
  19. data/lib/tins/hash_symbolize_keys_recursive.rb +28 -0
  20. data/lib/tins/hash_union.rb +15 -0
  21. data/lib/tins/limited.rb +38 -0
  22. data/lib/tins/lines_file.rb +123 -0
  23. data/lib/tins/memoize.rb +78 -0
  24. data/lib/tins/minimize.rb +55 -0
  25. data/lib/tins/module_group.rb +13 -0
  26. data/lib/tins/null.rb +26 -0
  27. data/lib/tins/once.rb +25 -0
  28. data/lib/tins/p.rb +23 -0
  29. data/lib/tins/partial_application.rb +31 -0
  30. data/lib/tins/range_plus.rb +9 -0
  31. data/lib/tins/round.rb +51 -0
  32. data/lib/tins/secure_write.rb +25 -0
  33. data/lib/tins/shuffle.rb +17 -0
  34. data/lib/tins/string_camelize.rb +16 -0
  35. data/lib/tins/string_underscore.rb +15 -0
  36. data/lib/tins/string_version.rb +105 -0
  37. data/lib/tins/subhash.rb +42 -0
  38. data/lib/tins/time_dummy.rb +31 -0
  39. data/lib/tins/to_proc.rb +11 -0
  40. data/lib/tins/uniq_by.rb +10 -0
  41. data/lib/tins/version.rb +10 -0
  42. data/lib/tins/write.rb +19 -0
  43. data/lib/tins/xt.rb +25 -0
  44. data/lib/tins/xt/attempt.rb +7 -0
  45. data/lib/tins/xt/blank.rb +67 -0
  46. data/lib/tins/xt/count_by.rb +11 -0
  47. data/lib/tins/xt/deep_dup.rb +7 -0
  48. data/lib/tins/xt/file_binary.rb +7 -0
  49. data/lib/tins/xt/full.rb +33 -0
  50. data/lib/tins/xt/hash_symbolize_keys_recursive.rb +7 -0
  51. data/lib/tins/xt/hash_union.rb +11 -0
  52. data/lib/tins/xt/irb.rb +17 -0
  53. data/lib/tins/xt/named.rb +35 -0
  54. data/lib/tins/xt/null.rb +5 -0
  55. data/lib/tins/xt/p.rb +7 -0
  56. data/lib/tins/xt/partial_application.rb +11 -0
  57. data/lib/tins/xt/range_plus.rb +12 -0
  58. data/lib/tins/xt/round.rb +13 -0
  59. data/lib/tins/xt/secure_write.rb +11 -0
  60. data/lib/tins/xt/shuffle.rb +11 -0
  61. data/lib/tins/xt/string.rb +5 -0
  62. data/lib/tins/xt/string_camelize.rb +6 -0
  63. data/lib/tins/xt/string_underscore.rb +6 -0
  64. data/lib/tins/xt/string_version.rb +7 -0
  65. data/lib/tins/xt/subhash.rb +11 -0
  66. data/lib/tins/xt/symbol_to_proc.rb +7 -0
  67. data/lib/tins/xt/time_dummy.rb +7 -0
  68. data/lib/tins/xt/uniq_by.rb +15 -0
  69. data/lib/tins/xt/write.rb +11 -0
  70. data/tests/tins_file_binary_test.rb +67 -0
  71. data/tests/tins_lines_file_test.rb +84 -0
  72. data/tests/tins_memoize_test.rb +52 -0
  73. data/tests/tins_secure_write_test.rb +44 -0
  74. data/tests/tins_test.rb +629 -0
  75. data/tins.gemspec +35 -0
  76. metadata +212 -0
@@ -0,0 +1,52 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ require 'test/unit'
4
+ require 'tins'
5
+
6
+ module Tins
7
+ class TestTinsMemoize < Test::Unit::TestCase
8
+ class FooBar
9
+ def foo(*a)
10
+ @@foo ||= 0
11
+ @@foo += 1
12
+ end
13
+ memoize_method :foo
14
+
15
+ def bar(*a)
16
+ @@bar ||= 0
17
+ @@bar += 1
18
+ end
19
+ memoize_function :bar
20
+ end
21
+
22
+ def test_foo
23
+ fb1 = FooBar.new
24
+ fb2 = FooBar.new
25
+ assert_equal 1, fb1.foo(1, 2)
26
+ assert_equal 2, fb2.foo(1, 2)
27
+ assert_equal 3, fb1.foo(1, 2, 3)
28
+ assert_equal 4, fb2.foo(1, 2, 3)
29
+ assert_equal 1, fb1.foo(1, 2)
30
+ assert_equal 2, fb2.foo(1, 2)
31
+ FooBar.memoize_cache_clear
32
+ assert_equal 5, fb1.foo(1, 2)
33
+ assert_equal 6, fb2.foo(1, 2)
34
+ assert_equal 5, fb1.foo(1, 2)
35
+ assert_equal 6, fb2.foo(1, 2)
36
+ end
37
+
38
+ def test_bar
39
+ fb1 = FooBar.new
40
+ fb2 = FooBar.new
41
+ assert_equal 1, fb1.bar(1, 2)
42
+ assert_equal 1, fb2.bar(1, 2)
43
+ assert_equal 2, fb1.bar(1, 2, 3)
44
+ assert_equal 2, fb2.bar(1, 2, 3)
45
+ assert_equal 1, fb1.bar(1, 2)
46
+ assert_equal 1, fb2.bar(1, 2)
47
+ FooBar.memoize_cache_clear
48
+ assert_equal 3, fb1.bar(1, 2)
49
+ assert_equal 3, fb2.bar(1, 2)
50
+ end
51
+ end
52
+ end
@@ -0,0 +1,44 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ require 'test/unit'
4
+ require 'tempfile'
5
+ require 'tins'
6
+
7
+ module Tins
8
+ class TinsSecureWriteTest < Test::Unit::TestCase
9
+ module A
10
+ extend SecureWrite
11
+ end
12
+
13
+ def test_secure_write
14
+ assert_equal 4, A.secure_write(fn = File.join(Dir.tmpdir, "A_file.#$$"), 'test')
15
+ assert_equal 4, A.secure_write(fn = File.join(Dir.tmpdir, "A_file.#$$")) { |f| f.write('test') }
16
+ assert_equal 'test', File.read(fn)
17
+ assert_raise(ArgumentError) { A.secure_write }
18
+ end
19
+
20
+ module B
21
+ extend Write
22
+ end
23
+
24
+ module C
25
+ def self.write(*args)
26
+ args
27
+ end
28
+ extend Write
29
+ end
30
+
31
+ class ::IO
32
+ extend Write
33
+ end
34
+
35
+ def test_write
36
+ assert_equal 4, B.write(fn = File.join(Dir.tmpdir, "B_file.#$$"), 'test')
37
+ assert_equal 4, B.write(fn = File.join(Dir.tmpdir, "B_file.#$$")) { |f| f.write('test') }
38
+ assert_equal 4, IO.write(fn = File.join(Dir.tmpdir, "IO_file.#$$"), 'test')
39
+ assert_equal 'test', File.read(fn)
40
+ result = C.write(fn = File.join(Dir.tmpdir, "C_file.#$$"), 'test')
41
+ assert_equal [ fn, 'test' ], result
42
+ end
43
+ end
44
+ end
@@ -0,0 +1,629 @@
1
+ #!/usr/bin/env ruby
2
+
3
+ require 'test/unit'
4
+ require 'tins'
5
+
6
+ module Tins
7
+ class MinimizeTest < Test::Unit::TestCase
8
+ class ::Array
9
+ include Tins::Minimize
10
+ end
11
+
12
+ def test_minimize
13
+ assert_equal [], [].minimize
14
+ assert_equal [ 1..1 ], [ 1 ].minimize
15
+ assert_equal [ 1..2 ], [ 1, 2 ].minimize
16
+ assert_equal [ 1..1, 7..7 ], [ 1, 7 ].minimize
17
+ assert_equal [ 1..3, 7..7, 11..14 ],
18
+ [ 1, 2, 3, 7, 11, 12, 13, 14 ].minimize
19
+ assert_equal [ 'A'..'C', 'G'..'G', 'K'..'M' ],
20
+ [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ].minimize
21
+ end
22
+
23
+ def test_minimize!
24
+ assert_equal [], [].minimize!
25
+ assert_equal [ 1..1 ], [ 1 ].minimize!
26
+ assert_equal [ 1..2 ], [ 1, 2 ].minimize!
27
+ assert_equal [ 1..1, 7..7 ], [ 1, 7 ].minimize!
28
+ assert_equal [ 1..3, 7..7, 11..14 ],
29
+ [ 1, 2, 3, 7, 11, 12, 13, 14 ].minimize!
30
+ assert_equal [ 'A'..'C', 'G'..'G', 'K'..'M' ],
31
+ [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ].minimize!
32
+ end
33
+
34
+ def test_unminimize
35
+ assert_equal [], [].unminimize
36
+ assert_equal [ 1 ], [ 1..1 ].unminimize
37
+ assert_equal [ 1, 2 ], [ 1..2 ].unminimize
38
+ assert_equal [ 1, 7 ], [ 1..1, 7..7 ].unminimize
39
+ assert_equal [ 1, 2, 3, 7, 11, 12, 13, 14 ],
40
+ [ 1..3, 7..7, 11..14 ].unminimize
41
+ assert_equal [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ],
42
+ [ 'A'..'C', 'G'..'G', 'K'..'M' ].unminimize
43
+ end
44
+
45
+ def test_unminimize!
46
+ assert_equal [], [].unminimize!
47
+ assert_equal [ 1 ], [ 1..1 ].unminimize!
48
+ assert_equal [ 1, 2 ], [ 1..2 ].unminimize!
49
+ assert_equal [ 1, 7 ], [ 1..1, 7..7 ].unminimize!
50
+ assert_equal [ 1, 2, 3, 7, 11, 12, 13, 14 ],
51
+ [ 1..3, 7..7, 11..14 ].unminimize!
52
+ assert_equal [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ],
53
+ [ 'A'..'C', 'G'..'G', 'K'..'M' ].unminimize!
54
+ end
55
+ end
56
+
57
+ class PartialApplicationTest < Test::Unit::TestCase
58
+ require 'tins/xt/partial_application'
59
+
60
+ def mul(x, y) x * y end
61
+
62
+ define_method(:dup) { |y| method(:mul).partial(2)[y] }
63
+
64
+ define_method(:trip) { |y| method(:mul).partial(3)[y] }
65
+
66
+
67
+ def test_proc
68
+ mul = lambda { |x, y| x * y }
69
+ klon = mul.partial
70
+ dup = mul.partial(2)
71
+ trip = mul.partial(3)
72
+ assert_equal [ 6, 9, 12 ], [ dup[3], trip[3], mul[4, 3] ]
73
+ assert_equal [ 6, 9, 12 ], [ dup[3], trip[3], klon[4, 3] ]
74
+ assert_raises(ArgumentError) do
75
+ mul.partial(1, 2, 3)
76
+ end
77
+ end
78
+
79
+ def test_method
80
+ assert_equal [ 6, 9, 12 ], [ dup(3), trip(3), mul(4, 3) ]
81
+ end
82
+ end
83
+
84
+ class GeneratorTest < Test::Unit::TestCase
85
+ def setup
86
+ @numeric = [ 1, 2, 3 ]
87
+ @string = %w[a b c]
88
+ @chars = 'abc'
89
+ end
90
+
91
+ def test_generator
92
+ g = Tins::Generator[@numeric, @string]
93
+ assert_equal 2, g.size
94
+ g.add_dimension(@chars, :each_byte)
95
+ assert_equal 3, g.size
96
+ assert_equal\
97
+ [[1, "a", 97],
98
+ [1, "a", 98],
99
+ [1, "a", 99],
100
+ [1, "b", 97],
101
+ [1, "b", 98],
102
+ [1, "b", 99],
103
+ [1, "c", 97],
104
+ [1, "c", 98],
105
+ [1, "c", 99],
106
+ [2, "a", 97],
107
+ [2, "a", 98],
108
+ [2, "a", 99],
109
+ [2, "b", 97],
110
+ [2, "b", 98],
111
+ [2, "b", 99],
112
+ [2, "c", 97],
113
+ [2, "c", 98],
114
+ [2, "c", 99],
115
+ [3, "a", 97],
116
+ [3, "a", 98],
117
+ [3, "a", 99],
118
+ [3, "b", 97],
119
+ [3, "b", 98],
120
+ [3, "b", 99],
121
+ [3, "c", 97],
122
+ [3, "c", 98],
123
+ [3, "c", 99]], g.to_a
124
+ end
125
+ end
126
+
127
+ class RoundTest < Test::Unit::TestCase
128
+ require 'tins/xt/round'
129
+
130
+ def test_standard
131
+ assert_equal(1, 1.round)
132
+ assert_equal(-1, -1.round)
133
+ assert_equal(2, 1.5.round)
134
+ assert_kind_of Integer, 1.5.round
135
+ assert_equal(-1, -1.4.round)
136
+ assert_equal(-2, -1.5.round)
137
+ end
138
+
139
+ def test_inclusion
140
+ assert_equal(10, 12.round(-1))
141
+ assert_kind_of Integer, 12.round(-1)
142
+ assert_equal(-10, -12.round(-1))
143
+ assert_raises(ArgumentError) { 12.round(-2) }
144
+ assert_raises(ArgumentError) { -12.round(-2) }
145
+ assert_in_delta(1.6, 1.55.round(1), 1E-1)
146
+ assert_kind_of Float, 1.55.round(1)
147
+ assert_equal(2, 1.55.round(0))
148
+ assert_in_delta(-1.5, -1.45.round(1), 1E-1)
149
+ assert_equal(-1, -1.45.round(0))
150
+ assert_in_delta(-1.6, -1.55.round(1), 1E-1)
151
+ assert_equal(-2, -1.55.round(0))
152
+ assert_in_delta(-1.55, -1.55.round(999), 1E-2)
153
+ end
154
+ end
155
+
156
+ class ModuleGroupTest < Test::Unit::TestCase
157
+ MyClasses = Tins::ModuleGroup[ Array, String, Hash ]
158
+
159
+ def test_module_group
160
+ assert MyClasses === []
161
+ assert MyClasses === ""
162
+ assert MyClasses === {}
163
+ assert !(MyClasses === :nix)
164
+ case []
165
+ when MyClasses
166
+ assert true
167
+ when Array
168
+ assert false
169
+ end
170
+ case :nix
171
+ when MyClasses
172
+ assert false
173
+ when Array
174
+ assert false
175
+ when Symbol
176
+ assert true
177
+ end
178
+ end
179
+ end
180
+
181
+ class UniqByTest < Test::Unit::TestCase
182
+ require 'tins/xt/uniq_by'
183
+
184
+ class Point < Struct.new :x, :y
185
+ end
186
+
187
+ def test_uniq_by
188
+ assert_equal [ 1, 2, 3 ], [ 1, 2, 2, 3 ].uniq_by.sort
189
+ a = [ 1, 2, 2, 3 ]; a.uniq_by!
190
+ assert_equal [ 1, 2, 3 ], a.sort
191
+ p1 = Point.new 1, 2
192
+ p2 = Point.new 2, 2
193
+ p3 = Point.new 2, 2
194
+ p4 = Point.new 3, 3
195
+ a = [ p1, p2, p3, p4 ]
196
+ a_uniq = a.uniq_by { |p| p.y }
197
+ assert_equal 2, a_uniq.size
198
+ assert a_uniq.include?(p4)
199
+ assert [ p1, p2, p3 ].any? { |p| a_uniq.include? p }
200
+ a.uniq_by! { |p| p.y }
201
+ assert_equal 2, a.size
202
+ assert a.include?(p4)
203
+ assert [ p1, p2, p3 ].any? { |p| a.include? p }
204
+ end
205
+ end
206
+
207
+ class CountByTest < Test::Unit::TestCase
208
+ require 'tins/xt/count_by'
209
+
210
+ def test_count_by
211
+ assert_equal 0, [].count_by { |x| x % 2 == 0 }
212
+ assert_equal 0, [ 1 ].count_by { |x| x % 2 == 0 }
213
+ assert_equal 1, [ 1 ].count_by { |x| x % 2 == 1 }
214
+ assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 0 }
215
+ assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 1 }
216
+ assert_equal 2, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 0 }
217
+ assert_equal 3, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 1 }
218
+ end
219
+ end
220
+
221
+ if Tins::Shuffle === Array
222
+ class ShuffleTest < Test::Unit::TestCase
223
+ require 'tins/xt/shuffle'
224
+
225
+ def setup
226
+ @a = [ 1, 2, 3 ]
227
+ srand 666
228
+ end
229
+
230
+ def test_shuffle
231
+ assert_equal(a = [2, 3, 1], a = @a.shuffle)
232
+ assert_not_same @a, a
233
+ assert_equal(b = [3, 1, 2], b = @a.shuffle)
234
+ assert_not_same a, b
235
+ assert_not_same @a, b
236
+ end
237
+
238
+ def test_shuffle_bang
239
+ assert_equal([2, 3, 1], a = @a.shuffle!)
240
+ assert_same @a, a
241
+ assert_equal([1, 2, 3], b = @a.shuffle!)
242
+ assert_same a, b
243
+ assert_same @a, b
244
+ end
245
+ end
246
+ end
247
+
248
+ class LimitedTest < Test::Unit::TestCase
249
+ class ::Array
250
+ include Tins::Shuffle
251
+ end
252
+
253
+ def test_limited
254
+ count = {}
255
+ limited = Tins::Limited.new(5)
256
+ 5.times do
257
+ limited.execute do
258
+ count[Thread.current] = true
259
+ sleep
260
+ end
261
+ end
262
+ until count.size >= 5
263
+ sleep 0.1
264
+ end
265
+ assert_equal 5, count.keys.uniq.size
266
+ end
267
+ end
268
+
269
+ class MemoizeTest < Test::Unit::TestCase
270
+ class A
271
+ def initialize(var)
272
+ @var = var
273
+ end
274
+
275
+ def foo(n)
276
+ r = n * @var
277
+ @var += 1
278
+ r
279
+ end
280
+ memoize_method :foo
281
+
282
+ def bar(n)
283
+ r = n * @var
284
+ @var += 1
285
+ r
286
+ end
287
+ memoize_function :bar
288
+ end
289
+
290
+ def setup
291
+ @a23 = A.new(23)
292
+ @a42 = A.new(42)
293
+ end
294
+
295
+ def test_memoize_method
296
+ assert Module.__memoize_cache__.empty?
297
+ assert_equal 2 * 23, @a23.foo(2)
298
+ assert_equal 2 * 23, @a23.foo(2)
299
+ assert_equal 3 * 24, @a23.foo(3)
300
+ assert_equal 2 * 42, @a42.foo(2)
301
+ assert_equal 2 * 42, @a42.foo(2)
302
+ assert_equal 3 * 43, @a42.foo(3)
303
+ assert !Module.__memoize_cache__.empty?
304
+ @a23, @a42 = nil, nil
305
+ GC.start
306
+ # XXX test fails atm, assert Module.__memoize_cache__.empty?
307
+ end
308
+
309
+ def test_memoize_function
310
+ assert A.__memoize_cache__.empty?
311
+ assert_equal 2 * 23, @a23.bar(2)
312
+ assert_equal 2 * 23, @a23.bar(2)
313
+ assert_equal 3 * 24, @a23.bar(3)
314
+ assert_equal 2 * 23, @a42.bar(2)
315
+ assert_equal 2 * 23, @a42.bar(2)
316
+ assert_equal 3 * 24, @a42.bar(3)
317
+ assert !A.__memoize_cache__.empty?
318
+ end
319
+ end
320
+
321
+ class HashUnionTest < Test::Unit::TestCase
322
+ require 'tins/xt/hash_union'
323
+
324
+ class HashLike1
325
+ def to_hash
326
+ { 'foo' => true }
327
+ end
328
+ end
329
+
330
+ class HashLike2
331
+ def to_h
332
+ { 'foo' => true }
333
+ end
334
+ end
335
+
336
+ def test_union
337
+ defaults = { 'foo' => true, 'bar' => false, 'quux' => nil }
338
+ hash = { 'foo' => false }
339
+ assert_equal [ ['bar', false], ['foo', false], ['quux', nil] ],
340
+ (hash | defaults).sort
341
+ hash |= defaults
342
+ assert_equal [ ['bar', false], ['foo', false], ['quux', nil] ],
343
+ hash.sort
344
+ hash = { 'foo' => false }
345
+ hash |= {
346
+ 'quux' => true,
347
+ 'baz' => 23,
348
+ } | defaults
349
+ assert_equal [ ['bar', false], [ 'baz', 23 ], ['foo', false],
350
+ ['quux', true] ],
351
+ hash.sort
352
+ end
353
+
354
+ def test_hash_conversion
355
+ assert_equal({ 'foo' => true }, { } | HashLike1.new)
356
+ assert_equal({ 'foo' => true }, { } | HashLike2.new)
357
+ end
358
+ end
359
+
360
+ class HashSymbolizeKeysRecursiveTest < Test::Unit::TestCase
361
+ require 'tins/xt/hash_symbolize_keys_recursive'
362
+
363
+ def test_symbolize
364
+ hash = {
365
+ 'key' => [
366
+ {
367
+ 'key' => {
368
+ 'key' => true
369
+ }
370
+ }
371
+ ],
372
+ }
373
+ hash2 = hash.symbolize_keys_recursive
374
+ assert hash2[:key][0][:key][:key]
375
+ hash.symbolize_keys_recursive!
376
+ assert hash[:key][0][:key][:key]
377
+ end
378
+ end
379
+
380
+ class SubhashTest < Test::Unit::TestCase
381
+ require 'tins/xt/subhash'
382
+
383
+ def test_subhash
384
+ h = { 'foo1' => 1, 'foo2' => 2, 'bar666' => 666 }
385
+ assert_equal [ [ 'bar666', 666 ] ], h.subhash(/\Abar/).to_a
386
+ assert h.subhash(/\Abaz/).empty?
387
+ assert_equal [ [ 'foo1', 1 ], [ 'foo2', 2 ] ], h.subhash(/\Afoo\d/).to_a
388
+ assert_equal [ [ 'foo2', 2 ] ], h.subhash('foo2').to_a
389
+ end
390
+
391
+ def test_subhash_bang
392
+ h = { 'foo1' => 1, 'foo2' => 2, 'bar666' => 666 }
393
+ h.subhash!('foo2')
394
+ assert_equal [ [ 'foo2', 2 ] ], h.to_a
395
+ end
396
+
397
+ def test_subhash_with_block
398
+ h = { 'foo1' => 1, 'foo2' => 2, 'bar666' => 666 }
399
+ assert h.subhash(/\Abaz/) { :foo }.empty?
400
+ assert_equal [ [ 'foo1', 1 ], [ 'foo2', 2 ] ],
401
+ h.subhash(/\Afoo(\d)/) { |_,_,m| Integer(m[1]) }.to_a
402
+ end
403
+ end
404
+
405
+ class NullTest < Test::Unit::TestCase
406
+ require 'tins/xt/null'
407
+
408
+ def test_null
409
+ assert_equal NULL, NULL.foo
410
+ assert_equal NULL, NULL.foo.bar
411
+ assert_equal 'NULL', NULL.inspect
412
+ assert_equal '', NULL.to_s
413
+ end
414
+ end
415
+
416
+ class TimeDummyTest < Test::Unit::TestCase
417
+ require 'tins/xt/time_dummy'
418
+ require 'time'
419
+
420
+ def test_time_dummy
421
+ time = Time.parse('2009-09-09 21:09:09')
422
+ assert_not_equal time, Time.now
423
+ Time.dummy = time
424
+ assert_equal time, Time.now
425
+ Time.dummy = nil
426
+ assert_not_equal time, Time.now
427
+ end
428
+ end
429
+
430
+ class BlankFullTest < Test::Unit::TestCase
431
+ require 'tins/xt/full'
432
+ require 'tins/xt/symbol_to_proc'
433
+ require 'set'
434
+
435
+ def test_blank
436
+ assert !true.blank?
437
+ assert false.blank?
438
+ assert nil.blank?
439
+ assert [].blank?
440
+ assert ![23].blank?
441
+ assert Set[].blank?
442
+ assert !Set[23].blank?
443
+ assert({}.blank?)
444
+ assert !{ :foo => 23 }.blank?
445
+ assert "".blank?
446
+ assert " ".blank?
447
+ assert !"foo".blank?
448
+ end
449
+
450
+ def test_full
451
+ assert_equal true, true.full?
452
+ assert_nil false.full?
453
+ assert_nil nil.full?
454
+ assert_nil [].full?
455
+ assert_equal [ 23 ], [ 23 ].full?
456
+ assert_nil Set[].full?
457
+ assert_equal Set[23], Set[23].full?
458
+ assert_nil({}.full?)
459
+ assert_equal({ :foo => 23 }, { :foo => 23 }.full?)
460
+ assert_nil "".full?
461
+ assert_nil " ".full?
462
+ assert_equal "foo", "foo".full?
463
+ assert_nil " ".full?(&:size)
464
+ assert_equal 3, "foo".full?(&:size)
465
+ assert_nil " ".full?(&:size)
466
+ assert_equal 3, "foo".full?(&:size)
467
+ assert_nil " ".full?(:size)
468
+ assert_equal 3, "foo".full?(:size)
469
+ assert_nil " ".full?(:size)
470
+ assert_equal 3, "foo".full?(:size)
471
+ end
472
+ end
473
+
474
+ class BlankFullTest < Test::Unit::TestCase
475
+ require 'tins/xt/deep_dup'
476
+
477
+ def test_deep_dup
478
+ a = [1,2,3]
479
+ assert_equal a, a.deep_dup
480
+ assert_not_same a, a.deep_dup
481
+ end
482
+
483
+ def test_deep_dup_proc
484
+ f = lambda { |x| 2 * x }
485
+ g = f.deep_dup
486
+ assert_equal f[3], g[3]
487
+ assert_equal f, g
488
+ assert_same f, g
489
+ end
490
+ end
491
+
492
+ class BijectionTest < Test::Unit::TestCase
493
+ def test_bijection
494
+ assert_equal [ [ 1, 2 ], [ 3, 4 ] ], Tins::Bijection[ 1, 2, 3, 4 ].to_a.sort
495
+ assert_raise(ArgumentError) do
496
+ Tins::Bijection[1,2,3]
497
+ end
498
+ assert_raise(ArgumentError) do
499
+ Tins::Bijection[1,2,3,2]
500
+ end
501
+ assert_raise(ArgumentError) do
502
+ Tins::Bijection[1,2,1,3]
503
+ end
504
+ end
505
+ end
506
+
507
+ class TryTest < Test::Unit::TestCase
508
+ require 'tins/xt/attempt'
509
+
510
+ def test_attempt_block_condition
511
+ assert attempt(:attempts => 1, :exception_class => nil) { |c| c == 1 }
512
+ assert attempt(:attempts => 3, :exception_class => nil) { |c| c == 1 }
513
+ assert_equal false, attempt(:attempts => 3, :exception_class => nil) { |c| c == 4 }
514
+ assert_nil attempt(:attempts => 0, :exception_class => nil) { |c| c == 4 }
515
+ assert_raise(Exception) { attempt(:attempts => 3, :exception_class => nil) { raise Exception } }
516
+ end
517
+
518
+ class MyError < StandardError; end
519
+ class MyException < Exception; end
520
+
521
+ def test_attempt_default_exception
522
+ assert attempt(1) { |c| c != 1 and raise MyError }
523
+ assert attempt(3) { |c| c != 1 and raise MyError }
524
+ assert_equal false, attempt(3) { |c| c != 4 and raise MyError }
525
+ assert_nil attempt(0) { |c| c != 4 and raise MyError }
526
+ assert_raise(Exception) { attempt(3) { raise Exception } }
527
+ end
528
+
529
+ def test_attempt_exception
530
+ assert attempt(:attempts => 1, :exception_class => MyException) { |c| c != 1 and raise MyException }
531
+ assert attempt(:attempts => 3, :exception_class => MyException) { |c| c != 1 and raise MyException }
532
+ assert_equal false, attempt(:attempts => 3, :exception_class => MyException) { |c| c != 4 and raise MyException }
533
+ assert_nil attempt(:attempts => 0, :exception_class => MyException) { |c| c != 4 and raise MyException }
534
+ assert_raise(Exception) { attempt(:attempts => 3, :exception_class => MyException) { raise Exception } }
535
+ end
536
+ end
537
+
538
+ class RangePlustTest < Test::Unit::TestCase
539
+ require 'tins/xt/range_plus'
540
+
541
+ def test_range_plus
542
+ assert_equal [], (0...0) + (0...0)
543
+ assert_equal [ 0 ], (0..0) + (0...0)
544
+ assert_equal [ 0, 0 ], (0..0) + (0..0)
545
+ assert_equal((1..5).to_a, (1...3) + (3..5))
546
+ end
547
+ end
548
+
549
+ class NamedTest < Test::Unit::TestCase
550
+ require 'tins/xt/named'
551
+
552
+ def test_named_simple
553
+ a = [ 1, 2, 3 ]
554
+ a.named(:plus1, :map) { |x| x + 1 }
555
+ assert_equal [ 2, 3, 4 ], a.plus1
556
+ Array.named(:odd, :select) { |x| x % 2 == 1 }
557
+ assert_equal [ 3 ], a.plus1.odd
558
+ end
559
+
560
+ if RUBY_VERSION >= '1.9'
561
+ def foo(x, y, &block)
562
+ block.call x * y
563
+ end
564
+
565
+ def test_more_complex
566
+ Object.named(:foo_with_block, :foo) do |z|
567
+ z ** 2
568
+ end
569
+ assert_equal foo(2, 3) { |z| z ** 2 }, foo_with_block(2, 3)
570
+ Object.named(:foo_23, :foo, 2, 3)
571
+ assert_equal foo(2, 3) { |z| z ** 2 }, foo_23 { |z| z ** 2 }
572
+ Object.named(:foo_2, :foo, 2)
573
+ assert_equal foo(2, 3) { |z| z ** 2 }, foo_2(3) { |z| z ** 2 }
574
+ end
575
+ end
576
+ end
577
+
578
+ require 'tins/xt/string'
579
+ class StringCamelizeTest < Test::Unit::TestCase
580
+ def test_camelize
581
+ assert_equal 'FooBar', 'foo_bar'.camelize
582
+ assert_equal 'FooBar', 'foo_bar'.camelize(:upper)
583
+ assert_equal 'FooBar', 'foo_bar'.camelize(true)
584
+ assert_equal 'fooBar', 'foo_bar'.camelize(:lower)
585
+ assert_equal 'fooBar', 'foo_bar'.camelize(false)
586
+ assert_equal 'FooBar', 'foo_bar'.camelcase
587
+ assert_equal 'Foo::Bar', 'foo/bar'.camelize
588
+ assert_equal 'Foo::Bar', 'foo/bar'.camelize(:upper)
589
+ assert_equal 'Foo::Bar', 'foo/bar'.camelize(true)
590
+ assert_equal 'foo::Bar', 'foo/bar'.camelize(:lower)
591
+ assert_equal 'foo::Bar', 'foo/bar'.camelize(false)
592
+ assert_equal 'Foo::Bar', 'foo/bar'.camelcase
593
+ end
594
+ end
595
+
596
+ class StringUnderscoreTest < Test::Unit::TestCase
597
+ def test_underscore
598
+ assert_equal 'foo_bar', 'FooBar'.underscore
599
+ assert_equal 'foo/bar', 'Foo::Bar'.underscore
600
+ end
601
+ end
602
+
603
+ class StringVersionTest < Test::Unit::TestCase
604
+ def test_comparison
605
+ assert_operator '1.2'.version, :<, '1.3'.version
606
+ assert_operator '1.3'.version, :>, '1.2'.version
607
+ assert_operator '1.2'.version, :<=, '1.2'.version
608
+ assert_operator '1.2'.version, :>=, '1.2'.version
609
+ assert_operator '1.2'.version, :==, '1.2'.version
610
+ end
611
+
612
+ def test_change
613
+ s = '1.2'
614
+ s.version.revision = 1
615
+ assert_equal '1.2.0.1', s
616
+ s.version.revision += 1
617
+ assert_equal '1.2.0.2', s
618
+ s.version.succ!
619
+ assert_equal '1.2.0.3', s
620
+ s.version.pred!
621
+ assert_equal '1.2.0.2', s
622
+ assert_raise(ArgumentError) { s.version.build -= 1 }
623
+ s.version.major = 2
624
+ assert_equal '2.2.0.2', s
625
+ s.version.minor = 1
626
+ assert_equal '2.1.0.2', s
627
+ end
628
+ end
629
+ end