nano 0.8.1

data/test/hash/tc_slice-op.rb

@@ -0,0 +1,98 @@
+
+require 'test/unit'
+
+require 'nano/hash/%5B%5D'
+require 'nano/hash/%5B%5D%3D'
+
+class TC_HashSlice < Test::Unit::TestCase
+
+  @hash = nil
+  AryKey = %w{an array as a key}
+  AryVal = %w{an array as a value}
+
+  def setup
+    @hash = {
+      "this" => "is",
+      "a" => "test",
+      "hash" => "with",
+      "some" => "values",
+      "for" => "testing",
+      AryKey => 'aryKey',
+      'aryVal' => AryVal
+    }
+  end
+
+  # Testing teardown method
+  def teardown
+    @hash = nil
+  end
+
+  # Make sure we haven't screwed up regular element reference
+  def test_get_regular
+      assert_equal('is', @hash['this'])
+      assert_equal('aryKey', @hash[ AryKey ])
+      assert_equal(AryVal, @hash[ 'aryVal' ])
+      assert_nil(@hash['nonExistant'])
+  end
+
+  # Test slice reference
+  def test_get_2args
+    res = @hash['this','a']
+    assert_instance_of( Array, res )
+    assert_equal( ['is','test'], res )
+
+    assert_equal(['aryKey','with'], @hash[ AryKey, 'hash' ])
+
+    assert_equal([AryVal,'testing'], @hash[ 'aryVal', 'for' ])
+
+    assert_equal(['aryKey',AryVal], @hash[ AryKey, 'aryVal' ])
+
+    res = @hash['nonExistant', 'anotherNonExistant']
+    assert_nil(res[0])
+    assert_nil(res[1])
+
+    @hash.default = 'default'
+    res = @hash['nonExistant', 'anotherNonExistant']
+    assert_equal( 'default', res[0] )
+    assert_equal( 'default', res[1] )
+  end
+
+  # Test fetching slices with duplicate keys
+  def test_get_duplicate_args
+    assert_equal(['is','is'], @hash['this','this'])
+    assert_equal(['aryKey','aryKey'], @hash[ AryKey, AryKey ])
+    assert_equal([AryVal,AryVal], @hash[ 'aryVal', 'aryVal' ])
+    assert_equal(['aryKey',AryVal,'aryKey','aryKey'], @hash[ AryKey, 'aryVal', AryKey, AryKey ])
+  end
+
+  # Test to make sure we haven't mucked up regular element assign
+  def test_set_regular
+    # Single string key assign
+    @hash['this'] = 'something else'
+    assert_equal( 'something else', @hash['this'] )
+
+    # Single array key assign
+    @hash[AryKey] = 'something else'
+    assert_equal( 'something else', @hash[AryKey] )
+
+    # Make sure range-assign behaviour is unchanged
+    rng = 1..5
+    @hash[ rng ] = 1..5
+    assert_instance_of( Range, @hash[rng] )
+    assert_equal( 1..5, @hash[1..5] )
+  end
+
+  # Test slice-assign
+  def test_set_2args
+    # Test slice-assign with string keys
+    assert_nothing_raised {@hash['this','a'] = 'other', 'stuff'}
+    assert_equal( 'other', @hash['this'] )
+    assert_equal( 'stuff', @hash['a'] )
+
+    # Test slice-assign with array keys and a string and array value
+    assert_nothing_raised {@hash[AryKey, %w{some other array}] = 'another', %w{set of values}}
+    assert_equal( 'another', @hash[AryKey] )
+    assert_equal( %w{set of values}, @hash[%w{some other array}] )
+  end
+
+end

data/test/integer/tc_integer.rb

@@ -0,0 +1,77 @@
+
+require 'test/unit'
+
+require 'nano/integer/even%3F'
+require 'nano/integer/fact'
+require 'nano/integer/factorial'
+require 'nano/integer/multiple%3F'
+require 'nano/integer/odd%3F'
+require 'nano/integer/times_collect'
+require 'nano/integer/times_map'
+
+class TCInteger < Test::Unit::TestCase
+
+  # even?
+
+  def test_even?
+    assert(   0.even? )
+    assert( ! 1.even? )
+    assert(   2.even? )
+    assert( ! 3.even? )
+  end
+
+  # factorial
+
+  def test_factorial
+    assert_equal( 1, 0.factorial )
+    assert_equal( 1, 1.factorial )
+    assert_equal( 2, 2.factorial )
+    assert_equal( 6, 3.factorial )
+    assert_equal( 24, 4.factorial )
+  end
+
+  # fact (alias for factorial)
+
+  def test_fact
+    assert_equal( 1, 0.fact )
+    assert_equal( 1, 1.fact )
+    assert_equal( 2, 2.fact )
+    assert_equal( 6, 3.fact )
+    assert_equal( 24, 4.fact )
+  end
+
+  # multiple?
+
+  def test_multiple?
+    assert( ! 1.multiple?(2) )
+    assert(   2.multiple?(2) )
+    assert( ! 5.multiple?(3) )
+    assert(   6.multiple?(3) )
+  end
+
+  # odd?
+
+  def test_odd?
+    assert( ! 0.odd? )
+    assert(   1.odd? )
+    assert( ! 2.odd? )
+    assert(   3.odd? )
+  end
+
+  # times_collect
+
+  def test_times_collect
+    a = 4
+    b = a.times_collect{ |i| i*2 }
+    assert_equal( [0,2,4,6], b )
+  end
+
+  # times_map
+
+  def test_times_map
+    a = 4
+    b = a.times_map{ |i| i*2 }
+    assert_equal( [0,2,4,6], b )
+  end
+
+end

data/test/kernel/TEST/test.rb

@@ -0,0 +1,4 @@
+# This file is just here to test require_local.
+# Nothing doing! :)
+
+TEST_CHECK = true

data/test/kernel/tc_kernel.rb

@@ -0,0 +1,165 @@
+
+require 'test/unit'
+
+require 'nano/kernel/autoreload'
+require 'nano/kernel/autoreload_glob'
+require 'nano/kernel/bug%21'
+require 'nano/kernel/called'
+require 'nano/kernel/call_stack'
+require 'nano/kernel/demo'
+require 'nano/kernel/fn'
+require 'nano/kernel/get_by_id'
+require 'nano/kernel/here'
+require 'nano/kernel/maybe'
+require 'nano/kernel/method_name'
+require 'nano/kernel/require_all'
+require 'nano/kernel/require_esc'
+require 'nano/kernel/require_local'
+require 'nano/kernel/require_nano'
+require 'nano/kernel/__require__'
+require 'nano/kernel/resc'
+require 'nano/kernel/returning'
+require 'nano/kernel/silence_warnings'
+require 'nano/kernel/silently'
+require 'nano/kernel/warn_with_line'
+
+
+class TC_Kernel < Test::Unit::TestCase
+
+  # autoreload
+
+  # autoreload_glob
+
+  # bug!
+
+  def test_bug!
+    assert_raises(ScriptBug){ bug! "error test" }
+  end
+
+  # called
+
+  def test_called
+    assert_equal( :test_called, called )    
+  end
+
+  # call_stack
+
+  def test_call_stack
+    assert_nothing_raised{ call_stack }
+  end
+
+  # demo
+
+  def test_demo
+    demo(i=''){%{ a = [1,2,3] }}
+    o = " a = [1,2,3]             #=>  [1, 2, 3]\n"
+    assert_equal( o, i )
+  end
+
+  # fn
+
+  def test_fn
+    assert_instance_of(Proc, fn{ |x| x + 1 } )
+  end
+
+  # get_by_id
+
+  def test_get_by_id
+    a = "Test"
+    i = a.object_id
+    assert_equal( a, get_by_id(i) )
+  end
+
+  # here
+
+  def test_here
+    assert_instance_of( Binding, here )
+  end
+
+  # maybe
+
+  def test_maybe
+    assert_nothing_raised { maybe }
+  end
+
+  # method_name
+
+  def test_method_name
+    # For some reason this was returning a string
+    # even when aliased to #called. Why?
+    # Well, I couldn't seem to fix it, so I just
+    # accepted it as fact and made +method_name+ 
+    # purposefully work that way.
+    assert_equal( "test_method_name", method_name )
+  end
+
+  # require_all
+
+  def test_require_all
+# TODO how? assert_nothing_raised { require_all 'nano//*' }
+  end
+
+  # require_local
+
+  def test_require_local
+    assert_nothing_raised { require_local 'TEST/test' }
+    assert( TEST_CHECK )
+  end
+
+  # require_esc
+
+  def test_require_esc
+    assert_nothing_raised { require_esc 'nano/string/blank?' }
+    assert( "".respond_to?( :blank? ) )
+  end
+
+  # require_nano
+
+  def test_require_nano
+    assert_nothing_raised { require_nano 'string/margin' }
+    assert( "".respond_to?( :margin ) )
+  end
+
+  # __require__
+
+  def test___require__
+    assert_nothing_raised { __require__ 'nano/string/to_re' }
+    assert( "".respond_to?( :to_re ) )
+  end
+
+  # resc
+
+  def test_resc
+    assert_equal( Regexp.escape("'jfiw0[]4"), resc("'jfiw0[]4") )
+    assert_equal( Regexp.escape("/////"), resc("/////") )
+  end
+
+  # returning
+
+  def test_returning
+    foo = returning( values = []) do
+      values << 'bar'
+      values << 'baz'
+    end
+    assert_equal( ['bar', 'baz'], foo )
+  end
+
+  # silently
+
+  def test_silently
+# TODO
+  end
+
+  # silence_warnings
+
+  def test_silence_warnings
+# TODO
+  end
+
+  # warn_with_line
+
+  def test_warn_with_line
+# TODO
+  end
+
+end

data/test/matchdata/tc_matchdata.rb

@@ -0,0 +1,62 @@
+
+require 'test/unit'
+
+require 'nano/matchdata/match'
+require 'nano/matchdata/matchtree'
+require 'nano/matchdata/matchset'
+
+
+class TC_MatchData < Test::Unit::TestCase
+
+  # match
+
+  def test_match
+    md = /X(a)(b)(c)X/.match("YXabcXY")
+    assert_equal( "XabcX", md.match )
+  end
+
+  # matchtree
+
+  def test_matchtree
+    md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
+    assert_equal( [["bb"], ["cc", ["dd"]], ["ee"]] , md.matchtree )
+  end
+
+  # matchset
+
+  def test_matchset
+    md = /(bb)(cc(dd))(ee)/.match "XXaabbccddeeffXX"
+    assert_equal( ["XXaa", [["bb"], ["cc", ["dd"]], ["ee"]], "ffXX"] , md.matchset )
+  end
+
+#   # match_from
+#
+#   def test_pre_match_from
+#     md = /X(a)(b)(c)X/.match("YXabcXY")
+#     assert_equal( md.pre_match, md.pre_match_from )
+#     assert_equal( md.pre_match, md.pre_match_from(0) )
+#     assert_equal( "Y", md.pre_match_from )
+#     assert_equal( "Y", md.pre_match_from(0) )
+#     assert_equal( "YX", md.pre_match_from(1) )
+#     assert_equal( "YXa", md.pre_match_from(2) )
+#     assert_equal( "YXab", md.pre_match_from(3) )
+#     assert_equal( "YXab", md.pre_match_from(-1) )
+#     assert_equal( "YXa", md.pre_match_from(-2) )
+#     assert_equal( "YX", md.pre_match_from(-3) )
+#   end
+#
+#   def test_post_match_from
+#     md = /X(a)(b)(c)X/.match("YXabcXY")
+#     assert_equal( md.post_match, md.post_match_from )
+#     assert_equal( md.post_match, md.post_match_from(0) )
+#     assert_equal( "Y", md.post_match_from )
+#     assert_equal( "Y", md.post_match_from(0) )
+#     assert_equal( "bcXY", md.post_match_from(1) )
+#     assert_equal( "cXY", md.post_match_from(2) )
+#     assert_equal( "XY", md.post_match_from(3) )
+#     assert_equal( "XY", md.post_match_from(-1) )
+#     assert_equal( "cXY", md.post_match_from(-2) )
+#     assert_equal( "bcXY", md.post_match_from(-3) )
+#   end
+
+end

data/test/module/tc_abstract.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'nano/module/abstract'
+
+# fixture
+
+class Aq
+  abstract :q
+end
+
+class TC_Module < Test::Unit::TestCase
+
+  # abstract
+
+  def test01
+    ac = Aq.new
+    assert_raises( TypeError ) { ac.q }
+  end
+
+  def test02
+    ac = Class.new { abstract :q }.new
+    assert_raises( TypeError ) { ac.q }
+  end
+
+end

data/test/module/tc_cloning.rb

@@ -0,0 +1,44 @@
+
+require 'test/unit'
+
+require 'nano/module/clone_renaming'
+require 'nano/module/clone_removing'
+require 'nano/module/clone_using'
+
+module M
+  def f; 1; end
+  def g; 2; end
+end
+
+class TC_Removing < Test::Unit::TestCase
+  include M.clone_removing( :g )
+  def test01
+    assert( ! defined?(g) )
+  end
+  def test02
+    assert( defined?(f) )
+  end
+end
+
+class TC_Renaming < Test::Unit::TestCase
+  include M.clone_renaming( :q => :g )
+  def test01
+    assert( ! defined?(g) )
+  end
+  def test02
+    assert( defined?(f) )
+  end
+  def test03
+    assert( defined?(q) )
+  end
+end
+
+class TC_Using < Test::Unit::TestCase
+  include M.clone_using( :f )
+  def test01
+    assert( ! defined?(g) )
+  end
+  def test02
+    assert( defined?(f) )
+  end
+end