nano 0.8.1

data/test/file/TEST1

@@ -0,0 +1 @@
+This is a test

data/test/file/TEST2

@@ -0,0 +1 @@
+tset a si sihT

data/test/file/tc_file.rb

@@ -0,0 +1,41 @@
+
+require 'test/unit'
+
+require 'nano/file/%3A%3Acreate'
+require 'nano/file/%3A%3Aopen_as_string'
+require 'nano/file/%3A%3Asplit_all'
+
+
+class TC_File < Test::Unit::TestCase
+
+  # create
+
+  def test_create
+    f = File.join( File.dirname(__FILE__), 'TEST1' )
+    t = 'This is a test'
+    File.create( f, t )
+    assert( File.exists?( f ) )
+    s = File.read( f )
+    assert_equal( t, s )
+  end
+
+  # open_as_string
+
+  def test_open_as_string
+    f = File.join( File.dirname(__FILE__), 'TEST2' )
+    t = 'This is a test'
+    File.open( f, 'w' ) { |s| s << t }
+    assert( File.exists?( f ) )
+    File.open_as_string(f) { |s| s.reverse! }
+    s = File.read( f )
+    assert_equal( t.reverse, s )
+  end
+
+  # split_all
+
+  def test_split_all
+    fp = "this/is/test"
+    assert_equal( ['this', 'is', 'test'], File.split_all(fp) )
+  end
+
+end

data/test/fileutils/tc_fileutils.rb

@@ -0,0 +1,77 @@
+
+require 'test/unit'
+
+require 'nano/fileutils/head'
+require 'nano/fileutils/slice'
+require 'nano/fileutils/tail'
+
+
+class TC_FileUtils_HeadTail < Test::Unit::TestCase
+
+  def setup
+    @workdir = Dir.getwd
+    @thisdir = File.dirname(__FILE__)
+
+    @tfile = 'test_file.txt'
+
+    @expected_head1 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
+    @expected_head1.push("line6\n","line7\n","line8\n","line9\n","line10\n")
+    @expected_head2 = ["line1\n","line2\n","line3\n","line4\n","line5\n"]
+
+    @expected_tail1 = ["line16\n","line17\n","line18\n","line19\n","line20\n"]
+    @expected_tail1.push("line21\n","line22\n","line23\n","line24\n","line25\n")
+    @expected_tail2 = ["line21\n","line22\n","line23\n","line24\n","line25\n"]
+
+    @expected_body1 = ["line10\n", "line11\n", "line12\n", "line13\n", "line14\n"]
+    @expected_body1.push("line15\n","line16\n", "line17\n", "line18\n", "line19\n","line20\n")
+    @expected_body2 = ["line14\n","line15\n","line16\n","line17\n","line18\n","line19\n","line20\n"]
+    @expected_body3 = ["line5\n","line6\n","line7\n","line8\n","line9\n","line10\n"]
+  end
+
+  def test_method
+    assert_respond_to( FileUtils, :head )
+    assert_respond_to( FileUtils, :tail )
+    assert_respond_to( FileUtils, :slice )
+  end
+
+  # head
+
+  def test_head
+    Dir.chdir @thisdir
+    begin
+    assert_nothing_raised{ FileUtils.head(@tfile) }
+    assert_nothing_raised{ FileUtils.head(@tfile,5) }
+    assert_equal(@expected_head1,FileUtils.head(@tfile))
+    assert_equal(@expected_head2,FileUtils.head(@tfile,5))
+    ensure
+      Dir.chdir @workdir
+    end
+  end
+
+  # slice
+
+  def test_slice
+    Dir.chdir @thisdir
+    begin
+      assert_nothing_raised{ FileUtils.slice(@tfile,5,10) }
+      assert_equal(@expected_body3,FileUtils.slice(@tfile,5,10))
+    ensure
+      Dir.chdir @workdir
+    end
+  end
+
+  # tail
+
+  def test_tail
+    Dir.chdir @thisdir
+    begin
+      assert_nothing_raised{ FileUtils.tail(@tfile) }
+      assert_nothing_raised{ FileUtils.tail(@tfile,5) }
+      assert_equal(@expected_tail1,FileUtils.tail(@tfile))
+      assert_equal(@expected_tail2,FileUtils.tail(@tfile,5))
+    ensure
+      Dir.chdir @workdir
+    end
+  end
+
+end

data/test/fileutils/tc_wc.rb

@@ -0,0 +1,48 @@
+
+require 'test/unit'
+
+require 'nano/fileutils/wc'
+
+
+class TC_FileUtils_WC < Test::Unit::TestCase
+
+  def setup
+    @workdir = Dir.getwd
+    @thisdir = File.dirname(__FILE__)
+
+    @file = 'test_file.txt'
+  end
+
+  def test_method
+    assert_respond_to( FileUtils, :wc )
+  end
+
+  def test_wc
+    Dir.chdir @thisdir
+    begin
+      assert_nothing_raised{ FileUtils.wc(@file) }
+      assert_nothing_raised{ FileUtils.wc(@file,'bytes') }
+      assert_nothing_raised{ FileUtils.wc(@file,'chars') }
+      assert_nothing_raised{ FileUtils.wc(@file,'words') }
+      assert_nothing_raised{ FileUtils.wc(@file,'lines') }
+      assert_raises(RuntimeError){ FileUtils.wc(@file,'bogus') }
+    ensure
+      Dir.chdir @workdir
+    end
+  end
+
+  def test_wc_results
+    Dir.chdir @thisdir
+    begin
+      assert_equal([166,166,25,25],FileUtils.wc(@file))
+      assert_equal(166,FileUtils.wc(@file,'bytes'),"Wrong number of bytes")
+      assert_equal(166,FileUtils.wc(@file,'chars'),"Wrong number of chars")
+      assert_equal(25,FileUtils.wc(@file,'words'),"Wrong number of words")
+      assert_equal(25,FileUtils.wc(@file,'lines'),"Wrong number of lines")
+    ensure
+      Dir.chdir @workdir
+    end
+  end
+
+end
+

data/test/fileutils/tc_whereis.rb

@@ -0,0 +1,36 @@
+
+require 'test/unit'
+
+require 'nano/fileutils/whereis'
+
+
+class TC_FileUtils_Whereis < Test::Unit::TestCase
+
+# Need a universal way to test. But how?
+#    def setup
+#      @workdir = Dir.getwd
+#      @thisdir = File.dirname(__FILE__)
+#
+#      # Change this to suit your system
+#      @expected_locs = ['/usr/local/bin/ruby','/opt/sfw/bin/ruby', '/opt/bin/ruby']
+# 
+#      # MS Windows - change as needed
+#      if File::ALT_SEPARATOR
+#         @expected_locs = ["c:\\ruby\\bin\\ruby.exe"]
+#      end
+#   end
+
+  def test_method
+    assert_respond_to( FileUtils, :whereis )
+  end
+
+#   def test_whereis
+#      Dir.chdir( @thisdir )
+#      assert_nothing_raised{ @locs = FileUtils.whereis("ruby") }
+#      assert_nothing_raised{ FileUtils.whereis("ruby"){ |loc| } }
+#      assert_equal(@expected_locs, @locs, "Not found where expected")
+#      assert_equal(nil,FileUtils.whereis("blahblah"))
+#      Dir.chdir( @workdir )
+#   end
+
+end

data/test/fileutils/tc_which.rb

@@ -0,0 +1,41 @@
+# Largely borrowed from Michael Granger's "FileWhich" RubyGarden wiki.
+
+require 'test/unit'
+require 'rbconfig'
+
+require 'nano/fileutils/which'
+
+
+class TC_FileUtils_Which < Test::Unit::TestCase
+  include Config
+
+  def setup
+    @workdir = Dir.getwd
+    @thisdir = File.dirname(__FILE__)
+
+    @expected_ruby_exe = File.join( CONFIG['bindir'], CONFIG['ruby_install_name'] )
+    if File::ALT_SEPARATOR
+        @expected_ruby_exe.gsub!(/\//,'\\')
+        @expected_ruby_exe += ".exe"
+    end
+  end
+
+  def test_method
+    assert_respond_to( FileUtils, :which )
+  end
+
+  # which
+
+  def test_which
+    Dir.chdir @thisdir
+    begin
+      ruby_exe = nil
+      assert_nothing_raised { ruby_exe = FileUtils.which(CONFIG['ruby_install_name']) }
+      assert_equal(@expected_ruby_exe, ruby_exe)
+      assert_equal(nil, FileUtils.which("blahblah"))
+    ensure
+      Dir.chdir @workdir
+    end
+  end
+
+end

data/test/fileutils/test_file.txt

@@ -0,0 +1,25 @@
+line1
+line2
+line3
+line4
+line5
+line6
+line7
+line8
+line9
+line10
+line11
+line12
+line13
+line14
+line15
+line16
+line17
+line18
+line19
+line20
+line21
+line22
+line23
+line24
+line25

data/test/fileutils/test_file2.txt

@@ -0,0 +1,25 @@
+line1
+line2
+line3
+line4
+line5
+line6
+line7
+line8
+line9
+line10
+line11
+line12
+line13
+line14
+line15
+line16
+line17
+line18
+line19
+line20
+line21
+line22
+line23
+line24
+line25

data/test/float/tc_float.rb

@@ -0,0 +1,64 @@
+
+require 'test/unit'
+
+require 'nano/float/approx?'
+require 'nano/float/round_at'
+require 'nano/float/round_off'
+require 'nano/float/round_to'
+
+
+class TC < Test::Unit::TestCase
+
+  def setup
+    @f0 = [ 0, 10, 15, 105 ]
+    @f1 = [ 10.1, 10.01, 10.9, 10.09, 10.5, 10.05, 10.49 ]
+  end
+
+  # approx?
+
+  def test_approx?
+    f = 10.006
+    assert( f.approx?(10.01) )
+    assert( f.approx?(10,0.1) )
+  end
+
+  # round_at
+
+  def test_round_at_arg1
+    fr = @f0.collect{ |f| f.round_at(1) }
+    assert_equal( [0,10,15,105], fr )
+    fr = @f1.collect { |f| f.round_at(1) }
+    assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
+  end
+
+  def test_round_at_arg2
+    fr = @f0.collect { |f| f.round_at(2) }
+    assert_equal( [0,10,15,105], fr )
+    fr = @f1.collect { |f| f.round_at(2) }
+    assert_equal( [10.1,10.01,10.9,10.09,10.5,10.05,10.49], fr )
+  end
+
+  # round_off
+
+  def test_round_off
+    assert_equal( 1.0, 1.2.round_off )
+    assert_equal( 2.0, 1.8.round_off )
+  end
+
+  # round_to
+
+  def test_round_to_arg1
+    fr = @f0.collect { |f| f.round_to(0.1) }
+    assert_equal( [0,10,15,105], fr )
+    fr = @f1.collect { |f| f.round_to(0.1) }
+    assert_equal( [10.1,10.0,10.9,10.1,10.5,10.1,10.5], fr )
+  end
+
+  def test_round_to_arg10
+    fr = @f0.collect { |f| f.round_to(10) }
+    assert_equal( [0,10,20,110], fr )
+    fr = @f1.collect { |f| f.round_to(10) }
+    assert_equal( [10,10,10,10,10,10,10], fr )
+  end
+
+end

data/test/hash/tc_each.rb

@@ -0,0 +1,25 @@
+
+require 'test/unit'
+
+require 'nano/hash/each'
+
+
+class TC_Hash < Test::Unit::TestCase
+
+  # each
+
+  def test_each
+
+    h = { :a=>1, :b=>2, :c=>3 }
+    a = []
+    h.each { |v| a << v }
+    assert_equal( [1,2,3], a.sort )
+
+    h = { 'a'=>1, 'b'=>2, 'c'=>3 }
+    a = []
+    h.each { |k,v| a << [k,v] }
+    assert_equal( [['a',1],['b',2],['c',3]], a.sort )
+
+  end
+
+end

data/test/hash/tc_hash.rb

@@ -0,0 +1,296 @@
+
+require 'test/unit'
+
+require 'nano/hash/%3A%3Azipnew'
+require 'nano/hash/%3C%3C'
+require 'nano/hash/alias%21'
+require 'nano/hash/assert_has_keys'
+require 'nano/hash/assert_has_only_keys'
+require 'nano/hash/at'
+require 'nano/hash/collate'
+require 'nano/hash/collate%21'
+require 'nano/hash/graph%21'
+require 'nano/hash/has_keys%3F'
+require 'nano/hash/has_only_keys%3F'
+require 'nano/hash/inverse'
+require 'nano/hash/keys_to_s'
+require 'nano/hash/keys_to_s%21'
+require 'nano/hash/keys_to_sym'
+require 'nano/hash/keys_to_sym%21'
+require 'nano/hash/rand_key'
+require 'nano/hash/rand_pair'
+require 'nano/hash/rand_value'
+require 'nano/hash/replace_each'
+require 'nano/hash/shuffle'
+require 'nano/hash/shuffle%21'
+require 'nano/hash/slice'
+require 'nano/hash/swap%21'
+require 'nano/hash/swapkey%21'
+require 'nano/hash/to_h'
+require 'nano/hash/to_ostruct'
+require 'nano/hash/to_ostruct_recurse'
+require 'nano/hash/traverse'
+require 'nano/hash/update_each'
+require 'nano/hash/weave'
+
+
+class TC_Hash < Test::Unit::TestCase
+
+  # ::zipnew
+
+  def test_weave
+    a = [1,2,3]
+    b = [4,5,6]
+    assert_equal( {1=>4,2=>5,3=>6}, Hash.zipnew(a,b) )
+    # and another
+    b = { :a => 1, :b => [1,2,3], :c => { :x => 'X' } }
+    c = { :a => 2, :b => [4,5,6], :c => { :x => 'A', :y => 'B' } }
+    r = { :a => 2, :b => [1,2,3,4,5,6], :c => { :x => 'A', :y => 'B' } }
+    assert_equal( r, b.weave(c) )
+  end
+
+  # <<
+
+  def test_shift_update
+    a = { :a => 1, :b => 2, :c => 3 }
+    b = { :a => 0, :d => 4 }
+    e = { :a => 0, :b => 2, :c => 3, :d => 4 }
+    assert_equal( e, a << b )
+  end
+
+  # alias!
+
+  def test_alias!
+    foo = { 'a'=>1, 'b'=>2 }
+    assert_equal( { 'a'=>1, 'b'=>2, 'c'=>2 }, foo.alias!('c','b') )
+    foo = { 'a'=>1, 'b'=>2 }
+    assert_equal( { :a=>1, 'a'=>1, 'b'=>2 }, foo.alias!(:a,'a') )
+    foo = { :a=>1, :b=>2 }
+    assert_equal( { :a=>1, :b=>2 }, foo.alias!('bar','foo') )
+  end
+
+  # assert_has_keys
+
+  def test_assert_has_keys
+    assert_nothing_raised { { :a=>1,:b=>2,:c=>3 }.assert_has_keys(:a,:b) }
+    assert_raises( ArgumentError ) { { :a=>1,:b=>2,:c=>3 }.assert_has_keys(:d) }
+  end
+
+  # assert_has_only_keys
+
+  def test_assert_has_only_keys
+    assert_nothing_raised {  { :a=>1,:b=>2,:c=>3 }.assert_has_only_keys(:a,:b,:c) }
+    assert_raises( ArgumentError ) { { :a=>1,:b=>2,:c=>3 }.assert_has_only_keys(:a,:b) }
+  end
+
+  # at
+
+  def test_at
+    h = { :a=>1, :b=>2 }
+    assert_equal( 1, h.at(:a) )
+    assert_equal( 2, h.at(:b) )
+  end
+
+  # collate
+
+  def test_collate
+    a = { :a => 1, :b => 2, :c => 3 }
+    e = { :a => 2, :b => 3, :c => 4 }
+    assert_equal( e, a.collate{ |k,v| { k => v+1 } } )
+  end
+
+  # collate!
+
+  def test_collate!
+    a = { :a => 1, :b => 2, :c => 3 }
+    e = { :a => 2, :b => 3, :c => 4 }
+    a.collate!{ |k,v| { k => v+1 } }
+    assert_equal( e, a )
+  end
+
+  # graph!
+
+  def test_graph
+    h  = {:a=>1,:b=>2,:c=>3}
+    h.graph!{ |k,v| [v, v*v] }
+    assert_equal( {1=>1, 2=>4, 3=>9}, h )
+  end
+
+  # has_keys?
+
+  def test_has_keys?
+    assert( { :a=>1,:b=>2,:c=>3 }.has_keys?(:a,:b) )
+    assert( ! { :a=>1,:b=>2,:c=>3 }.has_keys?(:a,:b,:d) )
+  end
+
+  # has_only_keys?
+
+  def test_has_only_keys?
+    assert( { :a=>1,:b=>2,:c=>3 }.has_only_keys?(:a,:b,:c) )
+    assert( ! { :a=>1,:b=>2,:c=>3 }.has_only_keys?(:a,:b) )
+  end
+
+  # keys_to_s
+
+  def test_keys_to_s
+    foo = { :a=>1, :b=>2 }
+    assert_equal( { "a"=>1, "b"=>2 }, foo.keys_to_s )
+    assert_equal( { :a =>1, :b=>2 }, foo  )
+  end
+
+  # keys_to_s!
+
+  def test_keys_to_s!
+    foo = { :a=>1, :b=>2 }
+    assert_equal( { "a"=>1, "b"=>2 }, foo.keys_to_s!  )
+    assert_equal( { "a"=>1, "b"=>2 }, foo )
+  end
+
+  # keys_to_sym
+
+  def test_keys_to_sym
+    foo = { 'a'=>1, 'b'=>2 }
+    assert_equal( { :a=>1, :b=>2 }, foo.keys_to_sym )
+    assert_equal( { "a" =>1, "b"=>2 }, foo )
+  end
+
+  # keys_to_sym!
+
+  def test_keys_to_sym!
+    foo = { 'a'=>1, 'b'=>2 }
+    assert_equal( { :a=>1, :b=>2 }, foo.keys_to_sym! )
+    assert_equal( { :a=>1, :b=>2 }, foo  )
+  end
+
+  # rand_key
+
+  def test_rand_key
+    h = { :a=>1, :b=>2, :c=>3 }
+    10.times { assert( h.keys.include?( h.rand_key ) ) }
+  end
+
+  # rand_value
+
+  def test_rand_value
+    h = { :a=>1, :b=>2, :c=>3 }
+    10.times { assert( h.values.include?( h.rand_value ) ) }
+  end
+
+  # rand_pair
+
+  def test_rand_pair
+    h = { :a=>1, :b=>2, :c=>3 }
+    10.times { k,v = *h.rand_pair; assert_equal( v, h[k] ) }
+  end
+
+  # replace_each
+
+  def test_replace_each
+    a = { :a => 1, :b => 2, :c => 3 }
+    e = { :a => 2, :b => 3, :c => 4 }
+    a.replace_each{ |k,v| { k => v+1 } }
+    assert_equal( e, a )
+  end
+
+  # shuffle
+
+  def test_shuffle
+    h = {:a=>1, :b=>2, :c=>3 }
+    assert_nothing_raised { h.shuffle }
+  end
+
+  # shuffle!
+
+  def test_shuffle!
+    h = {:a=>1, :b=>2, :c=>3 }
+    assert_nothing_raised { h.shuffle! }
+  end
+
+  # slice
+
+  def test_slice
+    h =  {:a=>1, :b=>2, :c=>3 }
+    assert_equal( [1,2], h.slice(:a,:b) )
+  end
+
+  # swap!
+
+  def test_swap!
+    h = { :a=>1, :b=>2 }
+    assert_equal( { :a=>2, :b=>1 }, h.swap!(:a, :b) )
+  end
+
+  # swapkeys!
+
+  def test_swapkeys!
+    foo = { :a=>1, :b=>2 }
+    assert_equal( { 'a'=>1, :b=>2 }, foo.swapkey!('a', :a) )
+    assert_equal( { 'a'=>1, 'b'=>2 }, foo.swapkey!('b', :b) )
+    assert_equal( { 'a'=>1, 'b'=>2 }, foo.swapkey!('foo','bar') )
+  end
+
+  # to_h
+
+  def test_to_h
+    a = { :a => 1, :b => 2, :c => 3 }
+    assert_equal( a, a.to_h )
+  end
+
+  # to_ostruct
+
+  def test_to_ostruct
+    a = { :a => 1, :b => 2, :c => 3 }
+    ao = a.to_ostruct
+    assert_equal( a[:a], ao.a )
+    assert_equal( a[:b], ao.b )
+    assert_equal( a[:c], ao.c )
+  end
+
+  # to_ostruct_recurse
+
+  def test_to_ostruct_recurse
+    a = { :a => 1, :b => 2, :c => { :x => 4 } }
+    ao = a.to_ostruct_recurse
+    assert_equal(  a[:a], ao.a )
+    assert_equal(  a[:b], ao.b )
+    assert_equal(  a[:c][:x], ao.c.x )
+  end
+
+  # traverse
+
+  def test_traverse
+    h = { "A" => "x", "B" => "y" }
+    h2 = h.traverse { |k,v| [k.downcase, v.upcase] }
+    e = { "a" => "X", "b" => "Y" }
+    assert_not_equal( h, h2 )
+    assert_equal( e, h2 )
+  end
+
+  # traverse!
+
+  def test_traverse!
+    h = { "A" => "x", "B" => "y" }
+    h.traverse! { |k,v| [k.downcase, v.upcase] }
+    e = { "a" => "X", "b" => "Y" }
+    assert_equal( e, h )
+  end
+
+  # update_each
+
+  def test_update_each
+    a = { :a => 1, :b => 2, :c => 3 }
+    e = { :a => 2, :b => 3, :c => 4 }
+    a.update_each{ |k,v| { k => v+1 } }
+    assert_equal( e, a )
+  end
+
+  # weave
+
+  def test_weave
+    b = { :a => 1, :b => [1,2,3], :c => { :x => 'X' } }
+    c = { :a => 2, :b => [4,5,6], :c => { :x => 'A', :y => 'B' } }
+    r = { :a => 2, :b => [1,2,3,4,5,6], :c => { :x => 'A', :y => 'B' } }
+    assert_equal( r, b.weave(c) )
+  end
+
+end