nano 0.8.1

data/test/string/tc_shift.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'nano/string/shift'
+
+class TC_String_shift < Test::Unit::TestCase
+
+  def setup
+    @a =  "012345"
+  end
+
+  def test01
+    assert_raises( ArgumentError ) { @a.shift(1) }
+  end
+
+  def test02
+    assert_equal( "12345", @a.shift )
+    assert_equal( "2345", @a.shift )
+    assert_equal( "345", @a.shift )
+    assert_equal( "45", @a.shift )
+    assert_equal( "5", @a.shift )
+    assert_equal( "", @a.shift )
+    assert_equal( "", @a.shift )
+  end
+
+end

data/test/string/tc_slap.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'nano/string/slap'
+
+class TC_String_slap < Test::Unit::TestCase
+
+  def setup
+    @a =  ""
+  end
+
+  def test01
+    #assert_raises( ArgumentError ) { @a.slap }
+    assert_raises( ArgumentError ) { @a.slap(1,2) }
+  end
+
+  def test02
+    assert_equal( "0", @a.slap("0") )
+    assert_equal( "10", @a.slap("1") )
+    assert_equal( "210", @a.slap("2") )
+    assert_equal( "3210", @a.slap("3") )
+    assert_equal( "43210", @a.slap("4") )
+    assert_equal( "543210", @a.slap("5") )
+  end
+
+end

data/test/string/tc_soundex.rb

@@ -0,0 +1,24 @@
+
+###### #####   #### ######
+  ##   ##     ##      ##
+  ##   ####     ##    ##
+  ##   ##        ##   ##
+  ##   #####  ####    ##
+
+require 'test/unit'
+require 'nano/string/soundex'
+
+class TC_Soundex < Test::Unit::TestCase
+
+  TESTVEC = "Euler Ellery Gauss Ghosh Hilbert Heilbronn Knuth Kant Lloyd Ladd Lukasiewicz Lissajous".split(" ")
+  RESVEC  = "E460 E460 G200 G200 H416 H416 K530 K530 L300 L300 L222 L222".split(" ")
+
+  def test_soundex
+    TESTVEC.each_with_index {|str,i| 
+      res = str.soundex
+      #print "#{str.ljust(11)} => #{res} ... "
+      assert_equal( RESVEC[i], res )
+    }
+  end
+
+end

data/test/string/tc_string.rb

@@ -0,0 +1,705 @@
+
+require 'test/unit'
+
+require 'nano/string/%3A%3Apatterns'
+require 'nano/string/%3A%3Arand_letter'
+require 'nano/string/align_center'
+require 'nano/string/align_left'
+require 'nano/string/align_right'
+require 'nano/string/at_rand'
+require 'nano/string/at_rand%21'
+require 'nano/string/blank%3F'
+require 'nano/string/bracket%21'
+require 'nano/string/bracket'
+require 'nano/string/bytes'
+require 'nano/string/camelcase'
+require 'nano/string/camelize'
+require 'nano/string/capitalized%3F'
+require 'nano/string/chars'
+require 'nano/string/cmp'
+require 'nano/string/downcase%3F'
+require 'nano/string/dresner%21'
+require 'nano/string/dresner'
+require 'nano/string/each_char'
+require 'nano/string/each_word'
+require 'nano/string/first%21'
+require 'nano/string/first%3D'
+require 'nano/string/first'
+require 'nano/string/fold'
+require 'nano/string/frequency'
+require 'nano/string/humanize'
+require 'nano/string/indent'
+require 'nano/string/index_all'
+require 'nano/string/last%21'
+require 'nano/string/last%3D'
+require 'nano/string/last'
+require 'nano/string/lines'
+require 'nano/string/line_wrap'
+require 'nano/string/lowercase%3F'
+#require 'nano/string/margin' [see tc_margin.rb]
+require 'nano/string/mscan'
+require 'nano/string/natcmp'
+require 'nano/string/nchar'
+#require 'nano/string/occur' [implement?]
+require 'nano/string/plural'
+require 'nano/string/probability'
+require 'nano/string/rand_byte%21'
+require 'nano/string/rand_byte'
+require 'nano/string/rand_index'
+require 'nano/string/range_all'
+require 'nano/string/range_of_line'
+require 'nano/string/range'
+require 'nano/string/shatter'
+require 'nano/string/shuffle'
+require 'nano/string/similarity'
+require 'nano/string/singular'
+require 'nano/string/soundex'
+require 'nano/string/succ'
+require 'nano/string/tab'
+require 'nano/string/tabto'
+# require 'nano/string/to_a'  [see tc_to_a.rb]
+require 'nano/string/to_arr'
+require 'nano/string/to_b'
+require 'nano/string/to_const'
+require 'nano/string/to_date'
+require 'nano/string/to_proc'
+require 'nano/string/to_re'
+require 'nano/string/to_time'
+require 'nano/string/underscore'
+require 'nano/string/unix_crypt%21'
+require 'nano/string/unix_crypt'
+require 'nano/string/unpack'
+require 'nano/string/upcase%3F'
+require 'nano/string/uppercase%3F'
+require 'nano/string/whitespace%3F'
+require 'nano/string/word_filter'
+require 'nano/string/words'
+require 'nano/string/word_wrap%21'
+require 'nano/string/word_wrap'
+
+
+class TC_String < Test::Unit::TestCase
+
+  # ::patterns
+
+  def test_String_rand_letter
+    assert_equal( //, String.patterns(//) )
+    assert_equal( //, String.patterns(:chars) )
+    assert_equal( /\ /, String.patterns(' ') )
+  end
+
+  # ::rand_letter
+
+  def test_String_rand_letter
+    100.times { |i| assert( /[a-zA-z]/ =~ String.rand_letter ) }
+  end
+
+  # align_center
+
+  def test_align_center
+    assert_equal( "   xxx   ", "xxx".align_center(9) )
+  end
+
+  # align_left
+
+  def test_align_left
+    assert_equal( "xxx      ", "xxx".align_left(9) )
+  end
+
+  # align_left
+
+  def test_align_right
+    assert_equal( "      xxx", "xxx".align_right(9) )
+  end
+
+  # at_rand
+
+  def test_at_rand
+    a = '12345'
+    20.times{ assert_nothing_raised{ a.at_rand } }
+    20.times{ assert( a.include?( a.at_rand ) ) }
+  end
+
+  # at_rand!
+
+  def test_at_rand!
+    x = 'ab'
+    r = x.at_rand!
+    assert( r == 'a' || r == 'b' )
+    assert( x == 'a' || x == 'b' )
+  end
+
+  # blank?
+
+  def test_blank?
+    assert( ! "xyz".blank? )
+    assert( "     ".blank? )
+  end
+
+  # bracket
+
+  def test_bracket
+    assert_equal( '#X#', 'X'.bracket('#') )
+    assert_equal( 'xX!', 'X'.bracket('x','!') )
+    assert_equal( '{X}', 'X'.bracket('{','}') )
+    assert_equal( '<X>', 'X'.bracket('<') )
+    assert_equal( '(X)', 'X'.bracket('(') )
+    assert_equal( '[X]', 'X'.bracket('[') )
+    assert_equal( '{X}', 'X'.bracket('{') )
+  end
+
+  # bracket!
+
+  def test_braket!
+    a = 'X' ; a.bracket!('#')
+    assert_equal( '#X#', a )
+    a = 'X' ; a.bracket!('x','!')
+    assert_equal( 'xX!', a )
+    a = 'X' ; a.bracket!('{','}')
+    assert_equal( '{X}', a )
+    a = 'X' ; a.bracket!('<')
+    assert_equal( '<X>', a )
+    a = 'X' ; a.bracket!('(')
+    assert_equal( '(X)', a )
+    a = 'X' ; a.bracket!('[')
+    assert_equal( '[X]', a )
+    a = 'X' ; a.bracket!('{')
+    assert_equal( '{X}', a )
+  end
+
+  # camelcase
+
+  def test_camelcase
+    assert_equal( "abcXyz", "abc_xyz".camelcase )
+    assert_equal( "abcXyz", "abc xyz".camelcase )
+    assert_equal( "abcXyz", "abc  xyz".camelcase )
+    assert_equal( "abcXyz", "abc\txyz".camelcase )
+    assert_equal( "abcXyz", "abc\nxyz".camelcase )
+    assert_equal( "abcXyz", "abc____xyz".camelcase )
+  end
+
+  def test_camelcase_true
+    assert_equal( "AbcXyz", "abc_xyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc xyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc  xyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc\txyz".camelcase(true) )
+    assert_equal( "AbcXyz", "abc\nxyz".camelcase(true) )
+  end
+
+  # camelize
+
+  def test_camelize
+    assert_equal( 'ThisIsIt', 'this_is_it'.camelize )
+  end
+
+  # capitalized?
+
+  def test_capitalized?
+    assert( 'Abc'.capitalized? )
+  end
+
+  # chars
+
+  def test_chars
+    assert_equal( ["a","b","c"], "abc".chars )
+    assert_equal( ["a","b","\n","c"], "ab\nc".chars )
+  end
+
+  # cmp
+
+  def test_cmp
+    assert_equal( 0, "abc".cmp("abc") )
+    assert_equal( -1, "abc".cmp("abcd") )
+    assert_equal( 1, "abcd".cmp("abc") )
+    assert_equal( -1, "abc".cmp("bcd") )
+    assert_equal( 1, "bcd".cmp("abc") )
+  end
+
+  # downcase?
+
+  def test_downcase?
+    assert( 'abc'.downcase? )
+  end
+
+  # dresner
+
+  def test_dresner
+    # assert_still_legible ;-)
+    assert_nothing_raised { "How are you today?".dresner }
+  end
+
+  # dresner!
+
+  def test_dresner
+    # assert_still_legible ;-)
+    assert_nothing_raised { "How are you today?".dresner! }
+  end
+
+  # each_char
+
+  def test_each_char
+    a = []
+    i = "this"
+    i.each_char{ |w| a << w }
+    assert_equal( ['t', 'h', 'i', 's'], a )
+  end
+
+  # each_word
+
+  def test_each_word
+    a = []
+    i = "this is a test"
+    i.each_word{ |w| a << w }
+    assert_equal( ['this', 'is', 'a', 'test'], a )
+  end
+
+  # first
+
+  def test_first
+    assert_equal( "a", "abcxyz".first )
+    assert_equal( "ax", "ax by cz".first(' ') )
+    assert_equal( "a", "a\nb\nc".first("\n") )
+  end
+
+  # first=
+
+  def test_first_eq
+    s = "abc"
+    s.first = "123"
+    assert_equal( "123abc", s )
+    s = "a\nbc"
+    s.first = "123"
+    assert_equal( "123a\nbc", s )
+  end
+
+  # first!
+
+  def test_first!
+    s = "a\nbc"
+    s.first!("\n")
+    assert_equal( "bc", s )
+  end
+
+  # fold
+
+  def test_fold
+    s = "This is\na test.\n\nIt clumps\nlines of text."
+    o = "This is a test.\n\nIt clumps lines of text."
+    assert_equal( o, s.fold )
+  end
+
+  # frequency
+
+  def test_frequency
+    assert_equal( {'a'=>1,'b'=>1}, "ab".frequency )
+    assert_equal( {'tom'=>1,'boy'=>1}, "tom boy".frequency(:word) )
+    assert_equal( {'tom'=>1,'boy'=>1}, "tom\nboy".frequency(:line) )
+  end
+
+  # humanize
+
+  def test_humanize
+    assert_equal( 'This is it', 'this_is_it'.humanize )
+  end
+
+  # indent
+
+  def test_indent
+    a = "xyz".indent(4)
+    assert_equal( '    ', a[0..3] )
+  # TODO need to expand on this
+  end
+
+  # index_all
+
+  def test_index_all
+    assert_equal( [0,4,8], "a123a567a9".index_all(/a/) )
+  end
+
+  # last
+
+  def test_last
+    assert_equal( "z", "abcxyz".last )
+    assert_equal( "cz", "ax by cz".last(' ') )
+    assert_equal( "c", "a\nb\nc".last("\n") )
+  end
+
+  # last=
+
+  def test_last_eq
+    s = "abc"
+    s.last = "123"
+    assert_equal( "abc123", s )
+    s = "a\nbc"
+    s.last = "123"
+    assert_equal( "a\nbc123", s )
+  end
+
+  # last!
+
+  def test_last!
+    s = "abc"
+    s.last!
+    assert_equal( "ab", s )
+    s = "a b c"
+    s.last!(' ')
+    assert_equal( "a b", s )
+  end
+
+  # lines
+
+  def test_lines
+    assert_equal( ['a','b','c'], "a\nb\nc".lines )
+  end
+
+  # line_wrap
+
+  def test_line_wrap
+    assert_equal "abc\n123\n", "abc123".line_wrap(3)
+    assert_equal "abcd\n123\n", "abcd123".line_wrap(4)
+  end
+
+  # lowercase?
+
+  def test_lowercase?
+    assert( 'abc'.lowercase? )
+  end
+
+  # margin
+
+    # [see tc_margin.rb]
+
+  # mscan
+
+  def test_mscan
+    r = 'abc,def,gh'.mscan(/[,]/)
+    assert( r.all?{ |md| MatchData === md } )
+    assert_equal( 2, r.to_a.length )
+    assert_equal( ',', r[0][0] )
+    assert_equal( ',', r[1][0] )
+  end
+
+  # natcmp
+
+  def test_natcmp
+    assert( -1, "my_prog_v1.1.0".natcmp("my_prog_v1.2.0") )
+    assert( -1, "my_prog_v1.2.0".natcmp("my_prog_v1.10.0") )
+    assert( 1, "my_prog_v1.2.0".natcmp("my_prog_v1.1.0") )
+    assert( 1, "my_prog_v1.10.0".natcmp("my_prog_v1.2.0") )
+    assert( 0, "my_prog_v1.0.0".natcmp("my_prog_v1.0.0") )
+  end
+
+  # nchar
+
+  def test_nchar
+    assert_equal( "abc", "abcxyz".nchar(3) )
+    assert_equal( "xyz", "abcxyz".nchar(-3) )
+    assert_equal( "HIxyz", "abcxyz".nchar(3, 'HI') )
+    assert_equal( "abcHI", "abcxyz".nchar(-3, 'HI') )
+  end
+
+  # occur
+
+  # def test_occur
+  #   assert_equal( ['a'], "abb".occur(1) )
+  #   assert_equal( ['tom'], "tom boy tom".occur(:word, 1) )
+  #   assert_equal( ['boy'], "tom\nboy\nboy".occur(:line, 2) )
+  # end
+  #
+  # def test_occur_within
+  #   assert_equal( ['a'], "abb".occur_within(1..1) )
+  #   assert_equal( ['tom'], "tom boy tom".occur_within(:word, 1..1) )
+  #   assert_equal( ['boy'], "tom\nboy\nboy".occur_within(:line, 2..2) )
+  # end
+
+  # plural
+
+  def test_plural
+    assert_equal( "friends", "friend".plural )
+    assert_equal( "men", "man".plural )
+  end
+
+  # probability
+
+  def test_probability
+    assert_equal( {'a'=>0.5,'b'=>0.5}, "ab".probability )
+    assert_equal( {'tom'=>0.5,'boy'=>0.5}, "tom boy".probability(:word) )
+    assert_equal( {'tom'=>0.5,'boy'=>0.5}, "tom\nboy".probability(:line) )
+  end
+
+  # rand_byte
+
+  def test_rand_byte
+    s = 'ab'
+    r = s.rand_byte
+    assert( r == 97 || r == 98 )
+  end
+
+  # rand_byte!
+
+  def test_rand_byte
+    s = 'ab'
+    r = s.rand_byte
+    assert( r == 97 || r == 98 )
+    assert( s = 'a' || s = 'b' )
+  end
+
+  # rand_index
+
+  def test_rand_index
+    10.times { assert( (0..2).include?( 'abc'.rand_index ) ) }
+  end
+
+  # range
+
+  def test_range
+    assert_equal( (1..3), "a123a567a9".range(/123/) )
+    assert_equal( (0..0), "a123a567a9".range(/a/) )
+  end
+
+  # range_all
+
+  def test_range_all
+    assert_equal( [ (1..3), (5..7) ], "a123a123a9".range_all(/123/) )
+    assert_equal( [ (0..0), (4..4), (8..8) ], "a123a567a9".range_all(/a/) )
+  end
+
+  # range_of_line
+
+  def test_range_of_line
+    a = "0123\n456\n78"
+    ltcm = a.range_of_line
+    assert_equal( [0..4, 5..8, 9..10], ltcm )
+  end
+
+  # shatter
+
+  def test_shatter
+    s = "<p>This<b>is</b>a test.</p>"
+    sh = s.shatter( /<.*?>/ )
+    e = ["<p>", "This", "<b>", "is", "</b>", "a test.", "</p>"]
+    assert_equal(e, sh)
+  end
+
+  # shuffle
+
+  def test_shuffle
+    assert_nothing_raised { "abc 123".shuffle }
+    #assert_nothing_raised { "abc 123".shuffle! }
+  end
+
+  # similarity
+
+  def test_similarity
+    assert_nothing_raised { "Hello World!".similarity( "helo wrld" ) }
+  end
+
+  # singular
+
+  def test_singular
+    assert_equal( "friend", "friends".singular )
+    assert_equal( "man", "men".singular )    
+  end
+
+  # soundex (need to verify function)
+
+  def test_soundex
+    assert_equal("Ruby".soundex, "R100")
+  end
+
+  # succ
+
+  def test_succ
+    assert_equal( "b", "a".succ )
+    assert_equal( "b", "a".succ(1) )
+    assert_equal( "c", "a".succ(2) )
+    assert_equal( "d", "a".succ(3) )
+  end
+
+  # tab
+
+  def test_tab
+    a = "xyz".tab(4)
+    assert_equal( '    ', a[0..3] )
+  # TODO need to expand on this
+  end
+
+  # tabto
+
+  def test_tabto
+    a = "xyz".tabto(4)
+    assert_equal( '    ', a[0..3] )
+  # TODO need to expand on this
+  end
+
+  # to_arr
+
+  def test_to_arr
+    assert_equal( ['a','b','c'], 'abc'.to_arr )
+  end
+
+  # to_b
+
+  def test_to_b
+    assert( 'true'.to_b )
+    assert( 'True'.to_b )
+    assert( 'yes'.to_b )
+    assert( 'YES'.to_b )
+    assert( 'on'.to_b )
+    assert( 'ON'.to_b )
+    assert( 't'.to_b )
+    assert( '1'.to_b )
+    assert( 'y'.to_b )
+    assert( 'Y'.to_b )
+    assert( '=='.to_b )
+    assert( ! 'nil'.to_b )
+    assert( ! 'false'.to_b )
+    assert( ! 'blahblahtrueblah'.to_b )
+    assert_equal( nil, 'nil'.to_b )
+    assert_equal( nil, 'null'.to_b )
+  end
+
+  # to_const
+
+  TestConst = 4
+  def test_to_const
+    assert_equal( 4, "TC_String::TestConst".to_const )
+  end
+
+  # to_date
+
+  def test_to_date
+    s = "2005-10-31"
+    d = s.to_date
+    assert_equal( 31, d.day )
+    assert_equal( 10, d.month )
+    assert_equal( 2005, d.year )
+  end
+
+  # to_proc
+
+  def test_to_proc
+    assert_nothing_raised { @add = '|x,y| x + y'.to_proc }
+    assert_equal(4, @add.call(2,2))    
+    @t = 3
+    @multi = '|y| @t * y'.to_proc(self)
+    assert_equal(6, @multi.call(2))
+    x = 4
+    @div = '|y| x / y'.to_proc(binding)
+    assert_equal(2, @div.call(2))
+  end
+
+  # to_re
+
+  def test_to_re
+    assert_equal( /abc/, "abc".to_re )
+    assert_equal( /a\+bc/, "a+bc".to_re )
+    assert_equal( /a+bc/, "a+bc".to_re(false) )
+  end
+
+  # to_time
+
+  def test_to_time
+    s = "2:31:15 PM"
+    t = s.to_time
+    assert_equal( 14, t.hour )
+    assert_equal( 31, t.min )
+    assert_equal( 15, t.sec )
+  end
+
+
+  # unix_crypt
+
+  def test_unix_crypt
+    assert_nothing_raised { "abc 123".unix_crypt }
+  end
+
+  # unix_crypt!
+
+  def test_unix_crypt!
+    assert_nothing_raised { "abc 123".unix_crypt! }
+  end
+
+  # unpack
+
+  def test_unpack
+    str, fmt = "abc\0", "Z*"
+    assert_equal "abc", str.unpack(fmt).first
+    assert_equal "abc", str.unpack(fmt, 0).first
+    assert_equal "bc", str.unpack(fmt, 1).first
+    assert_equal "bc", str.unpack(fmt, -3).first
+    assert_equal "c", str.unpack(fmt, 2).first
+    assert_equal "c", str.unpack(fmt, -2).first
+    assert_equal "", str.unpack(fmt, 3).first
+    assert_equal "", str.unpack(fmt, -1).first
+  end
+
+  # upcase?
+
+  def test_upcase?
+    assert( 'ABC'.upcase? )
+  end
+
+  # uppercase?
+
+  def test_uppercase?
+    assert( 'ABC'.uppercase? )
+  end
+
+  # whitespace?
+
+  def test_whitespace?
+    assert( ! "xyz".whitespace? )
+    assert( "     ".whitespace? )
+  end
+
+  # word_filter
+
+  def test_word_filter
+    s = "this is a test"
+    n = s.word_filter{ |w| "#{w}1" }
+    assert_equal( 'this1 is1 a1 test1', n )
+  end
+
+  # word_filter!
+
+  def test_word_filter!
+    s = "this is a test"
+    s.word_filter!{ |w| "#{w}1" }
+    assert_equal( 'this1 is1 a1 test1', s )
+  end
+
+  # word_wrap
+
+  def test_word_wrap
+    assert_equal "abcde\n12345\nxyzwu", "abcde 12345 xyzwu".word_wrap(5)
+    assert_equal "abcd\n1234\nxyzw", "abcd 1234 xyzw".word_wrap(4)
+    assert_equal "abc\n123", "abc 123".word_wrap(4)
+    assert_equal "abc\n 123", "abc  123".word_wrap(4)
+    assert_equal "abc\n    123", "abc     123".word_wrap(4)
+  end
+
+  # word_wrap!
+
+  def test_word_wrap!
+    w = "abcde 12345 xyzwu" ; w.word_wrap!(5)
+    assert_equal("abcde\n12345\nxyzwu", w)
+    w = "abcd 1234 xyzw" ; w.word_wrap!(4)
+    assert_equal("abcd\n1234\nxyzw", w)
+    w = "abc 123" ; w.word_wrap!(4)
+    assert_equal "abc\n123", w
+    w = "abc  123" ; w.word_wrap!(4)
+    assert_equal("abc\n 123", w)
+    w = "abc     123" ; w.word_wrap!(4)
+    assert_equal("abc\n    123", w)
+  end
+
+#   def test_word_wrap
+#     assert_equal "abcde-\n12345-\nxyzwu\n", "abcde12345xyzwu".word_wrap(6,2)
+#     assert_equal "abcd-\n1234-\nxyzw\n", "abcd1234xyzw".word_wrap(5,2)
+#     assert_equal "abc \n123\n", "abc 123".word_wrap(4,2)
+#     assert_equal "abc \n123\n", "abc  123".word_wrap(4,2)
+#     assert_equal "abc \n123\n", "abc     123".word_wrap(4,2)
+#   end
+
+end