tins 0.3.4 → 0.3.5

data/.gitignore

@@ -1,4 +1,5 @@
 .*.sw[pon]
 .rvmrc
 Gemfile.lock
+coverage
 pkg

data/Rakefile

@@ -11,7 +11,7 @@ GemHadar do
   description 'All the stuff that isn\'t good/big enough for a real library.'
   test_dir    'tests'
   test_files.concat Dir["#{test_dir}/*_test.rb"]
-  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.rvmrc'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.rvmrc', 'coverage'
   readme      'README.rdoc'
   development_dependency 'test-unit', '~>2.3'
 

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.3.5

data/lib/tins/null.rb

@@ -28,7 +28,7 @@ module Tins
     end
   end
 
-  NULL = Class.new do
+  NULL = Class.new(Module) do
     include Tins::Null
   end.new.freeze
 end

data/lib/tins/version.rb

@@ -1,6 +1,6 @@
 module Tins
   # Tins version
-  VERSION         = '0.3.4'
+  VERSION         = '0.3.5'
   VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/tins/xt.rb

@@ -23,4 +23,5 @@ module Tins
   require 'tins/xt/string'
   require 'tins/xt/file_binary'
   require 'tins/xt/require_maybe'
+  require 'tins/xt/partial_application'
 end

data/tests/bijection_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  class BijectionTest < Test::Unit::TestCase
+    def test_bijection
+      assert_equal [ [ 1, 2 ], [ 3, 4 ] ], Tins::Bijection[ 1, 2, 3, 4 ].to_a.sort
+      assert_raise(ArgumentError) do
+        Tins::Bijection[1,2,3]
+      end
+      assert_raise(ArgumentError) do
+        Tins::Bijection[1,2,3,2]
+      end
+      assert_raise(ArgumentError) do
+        Tins::Bijection[1,2,1,3]
+      end
+    end
+  end
+end

data/tests/blank_full_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+require 'tins/xt'
+require 'set'
+
+module Tins
+  class BlankFullTest < Test::Unit::TestCase
+
+    def test_blank
+      assert !true.blank?
+      assert false.blank?
+      assert nil.blank?
+      assert [].blank?
+      assert ![23].blank?
+      assert Set[].blank?
+      assert !Set[23].blank?
+      assert({}.blank?)
+      assert !{ :foo => 23 }.blank?
+      assert "".blank?
+      assert "   ".blank?
+      assert !"foo".blank?
+    end
+
+    def test_full
+      assert_equal true, true.full?
+      assert_nil false.full?
+      assert_nil nil.full?
+      assert_nil [].full?
+      assert_equal [ 23 ], [ 23 ].full?
+      assert_nil Set[].full?
+      assert_equal Set[23], Set[23].full?
+      assert_nil({}.full?)
+      assert_equal({ :foo => 23 }, { :foo => 23 }.full?)
+      assert_nil "".full?
+      assert_nil "   ".full?
+      assert_equal "foo", "foo".full?
+      assert_nil "    ".full?(&:size)
+      assert_equal 3, "foo".full?(&:size)
+      assert_nil "    ".full?(&:size)
+      assert_equal 3, "foo".full?(&:size)
+      assert_nil "    ".full?(:size)
+      assert_equal 3, "foo".full?(:size)
+      assert_nil "    ".full?(:size)
+      assert_equal 3, "foo".full?(:size)
+    end
+  end
+end

data/tests/count_by_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class CountByTest < Test::Unit::TestCase
+
+    def test_count_by
+      assert_equal 0, [].count_by { |x| x % 2 == 0 }
+      assert_equal 0, [ 1 ].count_by { |x| x % 2 == 0 }
+      assert_equal 1, [ 1 ].count_by { |x| x % 2 == 1 }
+      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 0 }
+      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 1 }
+      assert_equal 2, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 0 }
+      assert_equal 3, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 1 }
+    end
+  end
+end

data/tests/deep_dup_test.rb

@@ -0,0 +1,20 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class DeepDupTest < Test::Unit::TestCase
+    def test_deep_dup
+      a = [1,2,3]
+      assert_equal    a, a.deep_dup
+      assert_not_same a, a.deep_dup
+    end
+
+    def test_deep_dup_proc
+      f = lambda { |x| 2 * x }
+      g = f.deep_dup
+      assert_equal f[3], g[3]
+      assert_equal f, g
+      assert_same  f, g
+    end
+  end
+end

data/tests/{tins_file_binary_test.rb → file_binary_test.rb}

@@ -1,6 +1,6 @@
 require 'test_helper'
 require 'tempfile'
-require 'tins/xt/file_binary'
+require 'tins/xt'
 
 module Tins
   class TinsFileBinaryTest < Test::Unit::TestCase

data/tests/generator_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  class GeneratorTest < Test::Unit::TestCase
+    def setup
+      @numeric = [ 1, 2, 3 ]
+      @string  = %w[a b c]
+      @chars   = 'abc'
+    end
+
+    def test_generator
+      g = Tins::Generator[@numeric, @string]
+      assert_equal 2, g.size
+      g.add_dimension(@chars, :each_byte)
+      assert_equal 3, g.size
+      assert_equal\
+        [[1, "a", 97],
+        [1, "a", 98],
+        [1, "a", 99],
+        [1, "b", 97],
+        [1, "b", 98],
+        [1, "b", 99],
+        [1, "c", 97],
+        [1, "c", 98],
+        [1, "c", 99],
+        [2, "a", 97],
+        [2, "a", 98],
+        [2, "a", 99],
+        [2, "b", 97],
+        [2, "b", 98],
+        [2, "b", 99],
+        [2, "c", 97],
+        [2, "c", 98],
+        [2, "c", 99],
+        [3, "a", 97],
+        [3, "a", 98],
+        [3, "a", 99],
+        [3, "b", 97],
+        [3, "b", 98],
+        [3, "b", 99],
+        [3, "c", 97],
+        [3, "c", 98],
+        [3, "c", 99]], g.to_a
+    end
+  end
+end

data/tests/hash_symbolize_keys_recursive_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  class HashSymbolizeKeysRecursiveTest < Test::Unit::TestCase
+    require 'tins/xt/hash_symbolize_keys_recursive'
+
+    def test_symbolize
+      hash = {
+        'key' => [
+          {
+            'key' => {
+              'key' => true
+            }
+          }
+        ],
+      }
+      hash2 = hash.symbolize_keys_recursive
+      assert hash2[:key][0][:key][:key]
+      hash.symbolize_keys_recursive!
+      assert hash[:key][0][:key][:key]
+    end
+  end
+end

data/tests/hash_union_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class HashUnionTest < Test::Unit::TestCase
+
+    class HashLike1
+      def to_hash
+        { 'foo' => true }
+      end
+    end
+
+    class HashLike2
+      def to_h
+        { 'foo' => true }
+      end
+    end
+
+    def test_union
+      defaults = { 'foo' => true, 'bar' => false, 'quux' => nil }
+      hash = { 'foo' => false }
+      assert_equal [ ['bar', false], ['foo', false], ['quux', nil] ],
+        (hash | defaults).sort
+      hash |= defaults
+      assert_equal [ ['bar', false], ['foo', false], ['quux', nil] ],
+        hash.sort
+      hash = { 'foo' => false }
+      hash |= {
+        'quux' => true,
+        'baz' => 23,
+      } | defaults
+      assert_equal [ ['bar', false], [ 'baz', 23 ], ['foo', false],
+        ['quux', true] ],
+        hash.sort
+    end
+
+    def test_hash_conversion
+      assert_equal({ 'foo' => true }, { } | HashLike1.new)
+      assert_equal({ 'foo' => true }, { } | HashLike2.new)
+    end
+  end
+end

data/tests/limited_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  class LimitedTest < Test::Unit::TestCase
+    class ::Array
+      include Tins::Shuffle
+    end
+
+    def test_limited
+      count = {}
+      limited = Tins::Limited.new(5)
+      5.times do
+        limited.execute do
+          count[Thread.current] = true
+          sleep
+        end
+      end
+      until count.size >= 5
+        sleep 0.1
+      end
+      assert_equal 5, count.keys.uniq.size
+    end
+  end
+end

data/tests/{tins_memoize_test.rb → memoize_test.rb}

@@ -2,7 +2,7 @@ require 'test_helper'
 require 'tins'
 
 module Tins
-  class TestTinsMemoize < Test::Unit::TestCase
+  class MemoizeTest < Test::Unit::TestCase
     class FooBar
       def foo(*a)
         @@foo ||= 0

data/tests/minimize_test.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  class MinimizeTest < Test::Unit::TestCase
+    class ::Array
+      include Tins::Minimize
+    end
+
+    def test_minimize
+      assert_equal [], [].minimize
+      assert_equal [ 1..1 ], [ 1 ].minimize
+      assert_equal [ 1..2 ], [ 1, 2 ].minimize
+      assert_equal [ 1..1, 7..7 ], [ 1, 7 ].minimize
+      assert_equal [ 1..3, 7..7, 11..14 ],
+        [ 1, 2, 3, 7, 11, 12, 13, 14 ].minimize
+      assert_equal [ 'A'..'C', 'G'..'G', 'K'..'M' ],
+        [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ].minimize
+    end
+
+    def test_minimize!
+      assert_equal [], [].minimize!
+      assert_equal [ 1..1 ], [ 1 ].minimize!
+      assert_equal [ 1..2 ], [ 1, 2 ].minimize!
+      assert_equal [ 1..1, 7..7 ], [ 1, 7 ].minimize!
+      assert_equal [ 1..3, 7..7, 11..14 ],
+        [ 1, 2, 3, 7, 11, 12, 13, 14 ].minimize!
+      assert_equal [ 'A'..'C', 'G'..'G', 'K'..'M' ],
+        [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ].minimize!
+    end
+
+    def test_unminimize
+      assert_equal [], [].unminimize
+      assert_equal [ 1 ], [ 1..1 ].unminimize
+      assert_equal [ 1, 2 ], [ 1..2 ].unminimize
+      assert_equal [ 1, 7 ], [ 1..1, 7..7 ].unminimize
+      assert_equal [ 1, 2, 3, 7, 11, 12, 13, 14 ],
+        [ 1..3, 7..7, 11..14 ].unminimize
+      assert_equal [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ],
+        [ 'A'..'C', 'G'..'G', 'K'..'M' ].unminimize
+    end
+
+    def test_unminimize!
+      assert_equal [], [].unminimize!
+      assert_equal [ 1 ], [ 1..1 ].unminimize!
+      assert_equal [ 1, 2 ], [ 1..2 ].unminimize!
+      assert_equal [ 1, 7 ], [ 1..1, 7..7 ].unminimize!
+      assert_equal [ 1, 2, 3, 7, 11, 12, 13, 14 ],
+        [ 1..3, 7..7, 11..14 ].unminimize!
+      assert_equal [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ],
+        [ 'A'..'C', 'G'..'G', 'K'..'M' ].unminimize!
+    end
+  end
+end

data/tests/module_group_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  class ModuleGroupTest < Test::Unit::TestCase
+    MyClasses = Tins::ModuleGroup[ Array, String, Hash ]
+
+    def test_module_group
+      assert MyClasses === []
+      assert MyClasses === ""
+      assert MyClasses === {}
+      assert !(MyClasses === :nix)
+      case []
+      when MyClasses
+        assert true
+      when Array
+        assert false
+      end
+      case :nix
+      when MyClasses
+        assert false
+      when Array
+        assert false
+      when Symbol
+        assert true
+      end
+    end
+  end
+end

data/tests/named_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require 'tins/xt'
+
+module Tins
+  class NamedTest < Test::Unit::TestCase
+
+    def test_named_simple
+      a = [ 1, 2, 3 ]
+      a.named(:plus1, :map) { |x| x + 1 }
+      assert_equal [ 2, 3, 4 ], a.plus1
+      Array.named(:odd, :select) { |x| x % 2 == 1 }
+      assert_equal [ 3 ], a.plus1.odd
+    end
+
+    if RUBY_VERSION >= '1.9'
+      def foo(x, y, &block)
+        block.call x * y
+      end
+
+      def test_more_complex
+        Object.named(:foo_with_block, :foo) do |z|
+          z ** 2
+        end
+        assert_equal foo(2, 3) { |z| z ** 2 }, foo_with_block(2, 3)
+        Object.named(:foo_23, :foo, 2, 3)
+        assert_equal foo(2, 3) { |z| z ** 2 }, foo_23 { |z| z ** 2 }
+        Object.named(:foo_2, :foo, 2)
+        assert_equal foo(2, 3) { |z| z ** 2 }, foo_2(3) { |z| z ** 2 }
+      end
+    end
+  end
+end

data/tests/null_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+require 'tins'
+
+module Tins
+  class NullTest < Test::Unit::TestCase
+    require 'tins/xt/null'
+
+    def test_null
+      assert_equal NULL, NULL.foo
+      assert_equal NULL, NULL.foo.bar
+      assert_equal 'NULL', NULL.inspect
+      assert_equal '', NULL.to_s
+      assert_equal 1, Null(1)
+      assert_equal NULL, Null(nil)
+      assert_equal NULL, NULL::NULL
+      assert NULL.nil?
+    end
+  end
+end