nano 0.8.1

data/test/class/tc_class.rb

@@ -0,0 +1,48 @@
+
+require 'test/unit'
+
+require 'nano/class/descendents'
+require 'nano/class/subclasses'
+require 'nano/class/remove_descendents'
+require 'nano/class/remove_subclasses'
+
+# fixture
+
+class A ; end
+class B < A ; end
+class C < B ; end
+
+# test
+
+class TC_Class < Test::Unit::TestCase
+
+  # descendents
+
+  def test_descendents
+    assert_equal( [C,B], A.descendents )
+  end
+
+  # subclasses (alias of descendents)
+
+  def test_subclasses
+    assert_equal( [C,B], A.subclasses )
+  end
+
+  # remove_descendents
+
+  def test_descendents
+    assert_nothing_raised { B.remove_descendents }
+    # doesn't work despite above; not sure why
+    #assert_equal( [B], A.descendents )
+  end
+
+  # remove_subclasses (alias of remove_descendents)
+  def test_subclasses
+    assert_nothing_raised { A.remove_subclasses }
+    # doesn't work despite above; not why
+    #assert_equal( [], A.subclasses )
+  end
+
+end
+
+nil

data/test/comparable/tc_comparable.rb

@@ -0,0 +1,62 @@
+
+require 'test/unit'
+
+require 'nano/comparable/at_least'
+require 'nano/comparable/at_most'
+require 'nano/comparable/cap'
+require 'nano/comparable/clip'
+require 'nano/comparable/cmp'
+
+class TC_Comparable < Test::Unit::TestCase
+
+  # at_least
+
+  def test_at_least
+    assert_equal( 4, 3.at_least(4) )
+    assert_equal( 4, 4.at_least(4) )
+    assert_equal( 5, 5.at_least(4) )
+  end
+
+  # at_most
+
+  def test_at_most
+    assert_equal( 3, 3.at_most(4) )
+    assert_equal( 4, 4.at_most(4) )
+    assert_equal( 4, 5.at_most(4) )
+  end
+
+  # cap
+
+  def test_cap
+    assert_equal( 3, 3.cap(4) )
+    assert_equal( 4, 4.cap(4) )
+    assert_equal( 4, 5.cap(4) )
+  end
+
+  # clip
+
+  def test_clip
+    assert_equal( 4, 3.clip(4) )
+    assert_equal( 4, 4.clip(4) )
+    assert_equal( 5, 5.clip(4) )
+    assert_equal( 4, 4.clip(3,5) )
+    assert_equal( 3, 3.clip(3,5) )
+    assert_equal( 5, 5.clip(3,5) )
+    assert_equal( 3, 2.clip(3,5) )
+    assert_equal( 5, 6.clip(3,5) )
+    assert_equal( 'd', 'd'.clip('c','e') )
+    assert_equal( 'c', 'c'.clip('c','e') )
+    assert_equal( 'e', 'e'.clip('c','e') )
+    assert_equal( 'c', 'b'.clip('c','e') )
+    assert_equal( 'e', 'f'.clip('c','e') )
+  end
+
+  # cmp
+
+  def test_cmp
+    assert_equal( -1, 3.cmp(4) )
+    assert_equal(  0, 3.cmp(3) )
+    assert_equal(  1, 3.cmp(2) )
+  end
+
+end

data/test/continuation/tc_continuation.rb

@@ -0,0 +1,12 @@
+
+require 'nano/continuation/%3A%3Acreate'
+
+class TCContinuation < Test::Unit::TestCase
+
+  # ::create
+
+  def test_Continuation_create
+    assert_nothing_raised { c, r = Continuation.create }
+  end
+
+end

data/test/date/tc_date.rb

@@ -0,0 +1,54 @@
+
+require 'test/unit'
+
+require 'nano/date/days_in_month'
+require 'nano/date/days_of_month'
+require 'nano/date/stamp'
+require 'nano/date/to_date'
+require 'nano/date/to_s'
+require 'nano/date/to_time'
+
+
+class TC_Date < Test::Unit::TestCase
+
+  def setup
+    @d = Date.civil( 2005, 04, 20 )
+  end
+
+  # days_in_month
+
+  def test_days_in_month
+    assert_equal( 31, Date.new(2004,1,1).days_in_month )
+  end
+
+  # days_of_month
+
+  def test_days_of_month
+    assert_equal( (1..@d.days_in_month).to_a, @d.days_of_month )
+  end
+
+  # stamp
+
+  def test_stamp
+    assert_equal( "2005-04-20", @d.stamp )
+  end
+
+  # to_date
+
+  def test_to_date
+    assert_instance_of( ::Date, @d.to_date )
+  end
+
+  # to_s
+
+  def test_to_s
+    assert_equal( "2005-04-20", @d.to_s )
+  end
+
+  # to_time
+
+  def test_to_time
+    assert_instance_of( ::Time, @d.to_time )
+  end
+
+end

data/test/dir/tc_dir.rb

@@ -0,0 +1,31 @@
+
+require 'test/unit'
+
+require 'nano/dir/%3A%3Als_r'
+require 'nano/dir/%3A%3Arecurse'
+
+class TC_Dir < Test::Unit::TestCase
+
+  # ls_r
+
+  def test_ls_r
+    td = Dir.pwd
+    Dir.chdir File.dirname(__FILE__)
+      r = ["TEST/A", "TEST/A/B", "TEST/A/B/C.txt", "TEST/A/B.txt", "TEST/A.txt"]
+      fs = Dir.ls_r( 'TEST' )
+      assert_equal( r, fs, Dir.pwd  )
+    Dir.chdir td
+  end
+
+  # recurse (alias for ls_r)
+
+  def test_recurse
+    td = Dir.pwd
+    Dir.chdir File.dirname(__FILE__)
+      r = ["TEST/A", "TEST/A/B", "TEST/A/B/C.txt", "TEST/A/B.txt", "TEST/A.txt"]
+      fs = Dir.recurse( 'TEST' )
+      assert_equal( r, fs, Dir.pwd )
+    Dir.chdir td
+  end
+
+end

data/test/enumerable/tc_enumerable.rb

@@ -0,0 +1,370 @@
+
+require 'test/unit'
+
+require 'nano/enumerable/%25'
+require 'nano/enumerable/%2A%2A'
+require 'nano/enumerable/%3A%3Acombinations'
+require 'nano/enumerable/%3A%3Across'
+require 'nano/enumerable/collect_with_counter'
+require 'nano/enumerable/collect_with_index'
+require 'nano/enumerable/commonality'
+require 'nano/enumerable/compact_collect'
+require 'nano/enumerable/compact_map'
+require 'nano/enumerable/cross'
+require 'nano/enumerable/each_by'
+require 'nano/enumerable/each_combination'
+require 'nano/enumerable/each_permutation'
+require 'nano/enumerable/each_slice'
+require 'nano/enumerable/each_unique_pair'
+require 'nano/enumerable/eF'
+require 'nano/enumerable/entropy'
+require 'nano/enumerable/filter_collect'
+require 'nano/enumerable/filter_map'
+require 'nano/enumerable/find_collisions'
+require 'nano/enumerable/frequency'
+require 'nano/enumerable/graph'
+require 'nano/enumerable/ideal_entropy'
+require 'nano/enumerable/map_with_counter'
+require 'nano/enumerable/map_with_index'
+require 'nano/enumerable/none%3F'
+require 'nano/enumerable/occur'
+require 'nano/enumerable/one%3F'
+require 'nano/enumerable/partition_by'
+require 'nano/enumerable/probability'
+require 'nano/enumerable/to_h'
+require 'nano/enumerable/unique_by'
+
+class TC_Enumerable < Test::Unit::TestCase
+
+  # %
+
+  def test_percent_op
+    a = [1,2,3]
+    b = [4,5]
+    assert_equal( [2,4,6], a.% + a )
+  end
+
+  # **
+  def test_cross_op
+    a = [1,2,3] ** [4,5,6]
+    assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
+  end
+
+  # ::combinations
+
+  def test_Enumerable_combinations
+    a = [1,2]
+    b = [3,4]
+    r = Enumerable.combinations(a,b)
+    assert_equal( [[1,3],[1,4],[2,3],[2,4]], r )
+
+    r = [ ["a", "a", "x"],
+          ["a", "a", "y"],
+          ["a", "x", "x"],
+          ["a", "x", "y"],
+          ["b", "a", "x"],
+          ["b", "a", "y"],
+          ["b", "x", "x"],
+          ["b", "x", "y"] ]
+    a = %w|a b|
+    b = %w|a x|
+    c = %w|x y|
+    z = Enumerable.combinations(a, b, c)
+    assert_equal( r, z )
+  end
+
+  # ::cross
+
+  def test_Enumerable_cross
+    i = [[1,2], [3,4]]
+    o = [[1, 3], [1, 4], [2, 3], [2, 4]]
+    assert_equal( o, Enumerable.cross(*i) )
+    i = [[1,2], [4], ["apple", "banana"]]
+    o = [[1, 4, "apple"], [1, 4, "banana"], [2, 4, "apple"], [2, 4, "banana"]]
+    assert_equal( o, Enumerable.cross(*i) )
+  end
+
+  # collect_with_counter
+
+  def test_collect_with_counter
+    a = [1,2,3].collect_with_counter{ |e,i| e*i }
+    assert_equal( [0,2,6], a )
+  end
+
+  # collect_with_index
+
+  def test_collect_with_index
+    a = [1,2,3].collect_with_index{ |e,i| e*i }
+    assert_equal( [0,2,6], a )
+  end
+
+  # commonality
+
+  def test_commonality
+    a = [1,2,2,3,3,3]
+    r = { 2 => [2,2], 3 => [3,3,3] }
+    assert_equal( r, a.commonality )
+    a = [1,2,2,3,3,3]
+    r = {false=>[1, 2, 2], true=>[3, 3, 3]}
+    assert_equal( r, a.commonality { |x| x > 2 } )
+  end
+
+  # compact_collect
+
+  def test_compact_collect
+    a = [1,2,nil,4].compact_collect { |e| e }
+    assert_equal( [1,2,4], a )
+  end
+
+  # compact_map
+
+  def test_compact_map
+    a = [1,2,nil,4].compact_map { |e| e }
+    assert_equal( [1,2,4], a )
+  end
+
+  # cross
+
+  def test_cross
+    a = [1,2,3].cross([4,5,6])
+    assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
+    a = []
+    [1,2,3].cross([4,5,6]) {|elem| a << elem }
+    assert_equal( [[1, 4],[1, 5],[1, 6],[2, 4],[2, 5],[2, 6],[3, 4],[3, 5],[3, 6]], a )
+  end
+
+  # each_by
+
+  def test_each_by
+    x = []
+    [1,2,3,4].each_by(2){ |a,b| x << [a,b] }
+    o = [[1,2],[3,4]]
+    assert_equal( o, x )
+
+    x = []
+    [1,2,3,4,5].each_by(3){ |*a| x << a }
+    o = [[1,2,3],[4,5]]
+    assert_equal( o, x )
+  end
+
+  # each_combination
+
+  def test_each_combination
+    r = []
+    a = [1,2,3,4]
+    a.each_combination(2){ |a,b| r << [a,b] }
+    assert_equal( [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], r )
+  end
+
+  # each_permutation
+
+  def test_each_permutation
+
+  end
+
+  # each_slice
+
+  def test_each_slice
+    x = []
+    [1,2,3,4].each_slice{ |a,b| x << [a,b] }
+    o = [[1,2],[3,4]]
+    assert_equal( o, x )
+
+    x = []
+    [1,2,3,4,5].each_by{ |a,b,c| x << [a,b,c] }
+    o = [[1,2,3],[4,5,nil]]
+    assert_equal( o, x )
+
+    x = []
+    [1,2,3,4].each_slice(2){ |a,b| x << [a,b] }
+    o = [[1,2],[3,4]]
+    assert_equal( o, x )
+
+    x = []
+    [1,2,3,4,5,6,7,8].each_slice(4){ |*a| x << a }
+    o = [[1,2,3,4],[5,6,7,8]]
+    assert_equal( o, x )
+
+    x = []
+    [1,2,3,4,5,6].each_slice(3){ |*a| x << a }
+    o = [[1,2,3],[4,5,6]]
+    assert_equal( o, x )
+
+    a = [1,2,3,4,5,6]
+    r = []
+    a.each_slice(2){ |x,y| r << [x,y] }
+    assert_equal( [[1,2],[3,4],[5,6]], r )
+
+    r = []
+    a.each_slice(3){ |*e| r << e }
+    assert_equal( [[1,2,3],[4,5,6]], r )
+  end
+
+  # each_unique_pair
+
+  def test_each_unique_pair
+    r = []
+    a = [1,2,3,4]
+    a.each_unique_pair{ |a,b| r << [a,b] }
+    assert_equal( [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]], r )
+  end
+
+  # eF
+
+  def test_eF
+    a = [1,2,3]
+    b = [4,5]
+    #assert_equal( [4,5,6], a.every + 3 )
+    assert_equal( [5,7], a.eF + b )
+    assert_equal( [[5,7],[3,4,5]], a.eF.+(b,2) )
+    assert_equal( [[5,7],[4,5,6]], a.eF.+(b,3) )
+  end
+
+  # entropy
+
+  def test_entropy
+    assert_equal( 1.0, %w{ a b }.entropy )
+  end
+
+  # filter_collect
+
+  def test_filter_collect
+    e = [3,4]
+    a = [1,2,3,4].filter_collect { |n|
+      throw(:skip) if n < 3
+      n
+    }
+    assert_equal( e, a )
+  end
+
+  # filter_map
+
+  def test_filter_map
+    e = [3,4]
+    a = [1,2,3,4].filter_map { |n|
+      throw(:skip) if n < 3
+      n
+    }
+    assert_equal( e, a )
+  end
+
+  # find_collisions
+
+  def test_find_collisions
+    a = [1,2,2,3,3,3]
+    assert_equal( [2,3], a.find_collisions )
+    a = [1,2,2,3,3,3]
+    r = {false=>[1, 2, 2], true=>[3, 3, 3]}
+    assert_equal( r, a.find_collisions { |x| x > 2 } )
+  end
+
+  # frequency
+
+  def test_frequency
+    assert_equal( {'a'=>1,'b'=>1}, %w{a b}.frequency )
+    assert_equal( {'tom'=>1,'boy'=>1}, %w{tom boy}.frequency )
+  end
+
+  # graph
+
+  def test_graph
+    numbers  = (1..3)
+    squares  = numbers.graph{ |n| [n, n*n] }
+    assert_equal( {1=>1, 2=>4, 3=>9}, squares )
+    sq_roots = numbers.graph{ |n| [n*n, n] }
+    assert_equal( {1=>1, 4=>2, 9=>3}, sq_roots )
+  end
+
+  # ideal_entropy
+
+  def test_ideal_entropy
+    assert_equal( 1.0, %w{ a b }.ideal_entropy )
+    assert_equal( 2.0, %w{ a a b b }.ideal_entropy )
+  end
+
+  # map_with_counter
+
+  def test_map_with_counter
+    a = [1,2,3].map_with_counter{ |e,i| e*i }
+    assert_equal( [0,2,6], a )
+  end
+
+  # map_with_index
+
+  def test_map_with_index
+    a = [1,2,3].map_with_index{ |e,i| e*i }
+    assert_equal( [0,2,6], a )
+  end
+
+  # none?
+
+  def test_none?
+    a = [nil, nil]
+    assert( a.none? )
+    a = [false, false]
+    assert( a.none? )
+    a = [true, false]
+    assert( ! a.none? )
+    a = [nil, 1]
+    assert( ! a.none? )
+  end
+
+  # occur
+
+  def test_occur
+    arr = [:a,:b,:a]
+    assert_equal( [:b], arr.occur(1) )
+    assert_equal( [:a], arr.occur(2) )
+    assert_equal( [:b], arr.occur(1..1) )
+    assert_equal( [:a], arr.occur{ |n| n % 2 == 0 } )
+  end
+
+  # one?
+
+  def test_one?
+    a = [nil, true]
+    assert( a.one? )
+    a = [true, false]
+    assert( a.one? )
+    a = [true, true]
+    assert( ! a.one? )
+    a = [true, 1]
+    assert( ! a.one? )
+    a = [1, 1]
+    assert( ! a.one? )
+  end
+
+  # partition_by
+
+  def partition_by
+    x = (1..5).partition_by{ |n| n % 3 }
+    o = { 0 => [3], 1 => [1, 4], 2 => [2,5] }
+    assert_equal( o, x )
+    x = ["I had", 1, "dollar and", 50, "cents"].partition_by { |e| e.class }
+    o = { String => ["I had","dollar and","cents"], Fixnum => [1,50] }
+    assert_equal( o, x )
+  end
+
+  # probablity
+
+  def test_probability
+    assert_equal( {'a'=>0.5,'b'=>0.5}, %w{a b}.probability )
+    assert_equal( {'tom'=>0.5,'boy'=>0.5}, %w{tom boy}.probability )
+  end
+
+  # to_h
+
+  def test_to_h
+    a = [:a,:b,:c]
+    assert_equal( { 0=>:a, 1=>:b, 2=>:c }, a.to_h )
+  end
+
+  # unique_by
+
+  def test_uniq_by
+    a = [-5, -4, -3, -2, -1, 0]
+    r = (-5..5).to_a.uniq_by{|i| i*i }
+    assert_equal( a, r )
+  end
+
+end