webget_ruby_ramp 1.7.3 → 1.7.4

data/lib/webget_ruby_ramp/integer.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # Integer extensions
 
 class Integer
@@ -19,4 +21,26 @@ class Integer
     (0...self).map{|item| yield item}
   end
 
+
+  # Return true if the number is even
+  #
+  # ==Example
+  #   2.even? => true
+  #   3.even? => false
+
+  def even?
+    self % 2 == 0
+  end
+
+
+  # Return true if the number is odd
+  #
+  # ==Example
+  #   2.odd? => false
+  #   3.odd? => true
+
+  def odd?
+    self %2 == 1
+  end
+
 end

data/lib/webget_ruby_ramp/io.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # IO extensions
 
 class IO

data/lib/webget_ruby_ramp/kernel.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 require 'pp'
 require 'stringio'  
 

data/lib/webget_ruby_ramp/math.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # Math extensions
 
 module Math

data/lib/webget_ruby_ramp/nil.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # NilClass provides an instantiatable object
 # suitable for more careful thorough programming.
 

data/lib/webget_ruby_ramp/numeric.rb

@@ -1,8 +1,9 @@
+# -*- encoding: utf-8 -*-
+
 # Numeric extensions
 
 class Numeric
 
-
  # Return 0 if the given flag is any of: nil, false, 0, [], {}
  #
  # ==Example
@@ -11,8 +12,7 @@ class Numeric
  #   
 
  def if(flag)
-   # inline for speed
-   return (flag==nil or flag==false or flag==0 or flag==[] or flag=={}) ? 0 : self
+   if [nil,false,0,[],{}].include?(flag) then 0 else self end
  end
 
 
@@ -23,8 +23,7 @@ class Numeric
  #   3.unless(false) => 3
 
  def unless(flag)
-   # inline for speed
-   return (flag==nil or flag==false or flag==0 or flag==[] or flag=={}) ? self : 0
+   if [nil,false,0,[],{}].include?(flag) then self else 0 end
  end
 
 
@@ -51,7 +50,7 @@ class Numeric
 
  # Return self / 10^6
  def mega
-  self/100000
+  self/1000000
  end
 
  # Return self / 10^3

data/lib/webget_ruby_ramp/object.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # Object extensions
 
 class Object

data/lib/webget_ruby_ramp/process.rb

@@ -1,4 +1,6 @@
-# Process extensions to help debug Ruby programs.
+# -*- encoding: utf-8 -*-
+
+# = Process extensions to help debug Ruby programs.
 #
 # ==Examples
 #

data/lib/webget_ruby_ramp/string.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # String extensions
 
 class String

data/lib/webget_ruby_ramp/symbol.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # Symbol extensions
 
 class Symbol

data/lib/webget_ruby_ramp/time.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 # Time extensions
 
 class Time

data/lib/webget_ruby_ramp/xml.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 require 'rexml/document' 
 
 # XML extensions

data/lib/webget_ruby_ramp/yaml.rb

@@ -1,3 +1,5 @@
+# -*- encoding: utf-8 -*-
+
 require 'yaml'
 
 # YAML extensions

data/test/webget_ruby_ramp/array_test.rb

@@ -4,98 +4,171 @@ require 'webget_ruby_ramp'
 
 class ArrayTest < Test::Unit::TestCase
 
-  def test_join
-    a=['a','b','c']
-    assert_equal('abc',a.join)
-    assert_equal('abc',a.join(''))
-    assert_equal('a*b*c',a.join('*'))
-    assert_equal('[a]*[b]*[c]',a.join('*','[',']'))
-    assert_equal('[a][b][c]',a.join('[',']'))
-    assert_raise(ArgumentError){ a.join('','','','') }
+  A=['a','b','c','d']
+  B=['w','x','y','z']
+  SLICEABLE=['a','b','c','d','e','f','g','h']
+
+  def test_join_with_blank
+    assert_equal('abcd', A.join(''))
+  end
+  
+  def test_join_with_infix
+    assert_equal('a*b*c*d', A.join('*'))
   end
 
-  def test_size
-    assert_equal(false,[].size?)
-    assert_equal(true,[nil].size?)
+  def test_join_with_infix_and_prefix_and_suffix
+    assert_equal('[a]*[b]*[c]*[d]', A.join('*','[',']'))
+  end
+  
+  def test_join_with_prefix_and_suffix
+    assert_equal('[a][b][c][d]', A.join('[',']'))
+  end
+
+  def test_join_with_no_ops
+    assert_equal('abcd',A.join)
+  end
+
+  def test_join_with_too_many_ops
+    assert_raise(ArgumentError){ A.join('','','','') }
+  end
+
+  def test_size_with_one_item
     assert_equal(true,[1].size?)
+  end
+
+  def test_size_with_two_items
     assert_equal(true,[1,2].size?)
+  end
+
+  def test_size_with_empty
+    assert_equal(false,[].size?)
+  end
+
+  def test_size_with_nil
+    assert_equal(true,[nil].size?)
+  end
+
+  def test_size_with_one_empty
     assert_equal(true,[[]].size?)
   end
   
  def test_rotate
-   a=[1,2,3,4]
+   a=A.dup
+   a.rotate!
+   assert_equal(['b','c','d','a'],a)
    a.rotate!
-   assert_equal([2,3,4,1],a)
+   assert_equal(['c','d','a','b'],a)
    a.rotate!
-   assert_equal([3,4,1,2],a)
+   assert_equal(['d','a','b','c'],a)
    a.rotate!
+   assert_equal(['a','b','c','d'],a)
+ end
+
+ def test_rotate_with_empty
    a=[]
    a.rotate!
    assert_equal([],a)
  end
 
  def test_choice
-   a=[1,2,3,4]
    5.times {
-     c=a.choice
-     assert_equal(Fixnum,c.class)
-     assert(a.include?(c))
+     c=A.choice
+     assert_equal(String,c.class)
+     assert(A.include?(c))
    }
  end
 
  def test_choices
-   a=[1,2,3,4]
    5.times {
-     c=a.choices(2)
+     c=A.choices(2)
      assert_equal(2,c.size)
-     assert(a.include?(c[0]))
-     assert(a.include?(c[1]))
-     c=a.choices(3)
+     assert(A.include?(c[0]))
+     assert(A.include?(c[1]))
+     c=A.choices(3)
      assert_equal(3,c.size)
-     assert(a.include?(c[0]))
-     assert(a.include?(c[1]))
-     assert(a.include?(c[2]))
+     assert(A.include?(c[0]))
+     assert(A.include?(c[1]))
+     assert(A.include?(c[2]))
    }
  end
 
  def test_onto
-   foo=[:a,:b,:c]
-   goo=[:x,:y,:z]
-   assert_equal({:a=>:x, :b=>:y, :c=>:z},foo.onto(goo))
-   assert_raise(ArgumentError){ foo.onto([]) }
- end
-
- def test_slices
-   a=[1,2,3,4,5,6,7,8]
-   assert_equal([[1,2],[3,4],[5,6],[7,8]],a.slices(2))
-   assert_equal([[1,2,3,4],[5,6,7,8]], a.slices(4))
-   assert_equal([[1,2,3],[4,5,6],[7,8]],a.slices(3))
-   assert_equal([[1,2,3,4,5],[6,7,8]],a.slices(5))
+   assert_equal({'a'=>'w', 'b'=>'x', 'c'=>'y', 'd'=>'z'},A.onto(B))
+ end
+
+ def test_onto_with_empty
+   assert_raise(ArgumentError){ A.onto([]) }
+ end
+
+ def test_slices_with_balanced_results
+   assert_equal([['a','b'],['c','d'],['e','f'],['g','h']], SLICEABLE.slices(2))
+   assert_equal([['a','b','c','d'],['e','f','g','h']], SLICEABLE.slices(4))
+ end
+
+ def test_slices_with_unbalanced_results
+   assert_equal([['a','b','c'],['d','e','f'],['g','h']], SLICEABLE.slices(3))
+   assert_equal([['a','b','c','d','e'],['f','g','h']], SLICEABLE.slices(5))
+ end
+
+ def test_slices_with_empty
    assert_equal([],[].slices(1))
-   assert_raise(ArgumentError){ a.slices(-1) }
-   assert_raise(ArgumentError){ a.slices("") }
-   assert_raise(ArgumentError){ a.slices(0.123) }
+ end
+ 
+ def test_slices_with_negative_count
+   assert_raise(ArgumentError){ [].slices(-1) }
+ end
+
+ def test_slices_with_non_integer_count
+   assert_raise(ArgumentError){ [].slices(0.123) }
+ end
+
+ def test_slices_with_non_numeric_count
+   assert_raise(ArgumentError){ [].slices("") }
+ end
+
+ def test_divvy_with_one_slice
+   assert_equal([[1,2,3,4,5,6]],[1,2,3,4,5,6].divvy(1))
+ end
+
+ def test_divvy_with_equal_slices
+   assert_equal([[1,2,3],[4,5]],[1,2,3,4,5].divvy(2))
+ end
+
+ def test_divvy_with_remainer_slice
+   assert_equal([[1,2,3],[4,5,6],[7]],[1,2,3,4,5,6,7].divvy(3))
  end
 
- def test_divvy
-   assert_equal([[1,2,3,4,5,6]],[1,2,3,4,5,6].divvy(1),'division into one slice')
-   assert_equal([[1,2,3],[4,5]],[1,2,3,4,5].divvy(2),'division with equal slices')
-   assert_equal([[1,2,3],[4,5,6],[7]],[1,2,3,4,5,6,7].divvy(3),'division with remainer slice')
-   assert_equal([[1,2],[3,4],[5,6]],[1,2,3,4,5,6].divvy(4),'division with small numbers')
+ def test_divvy_with_small_number
+   assert_equal([[1,2],[3,4],[5,6]],[1,2,3,4,5,6].divvy(4))
+ end
+
+ def test_divvy_with_negative_count
    assert_raise(ArgumentError){ [].divvy(-1) }
-   assert_raise(ArgumentError){ [].divvy("") }
+ end
+
+ def test_divvy_with_non_integer_count
    assert_raise(ArgumentError){ [].divvy(0.123) }
  end
 
+ def test_divvy_with_non_numeric_count
+   assert_raise(ArgumentError){ [].divvy("") }
+ end
+
  def test_union
    a=[[1,2,3,4],[2,3,4,5],[3,4,5,6]]
    assert_equal([1,2,3,4,5,6],a.union)
+ end
+
+ def test_union_with_empty
    assert_equal([],[].union)
  end
 
  def test_intersect
    a=[[1,2,3,4],[2,3,4,5],[3,4,5,6]]
    assert_equal([3,4],a.intersect)
+ end
+
+ def test_intersect_with_empty
    assert_equal([],[].intersect)
  end
 
@@ -107,13 +180,21 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal([        'c'],a.shifted(2))
     assert_equal([           ],a.shifted(3))
     assert_equal(nil          ,a.shifted(4))
-    assert_raise(ArgumentError){ a.shifted(-1) }
-    assert_raise(ArgumentError){ a.shifted("") }
-    assert_raise(ArgumentError){ a.shifted(0.123) }
   end
 
-  # test_cdr must be idential to test_shifted
-  # because cdr is an alias for shifted
+  def test_shifted_with_negative_count
+    assert_raise(ArgumentError){ [].shifted(-1) }
+  end
+
+  def test_shifted_with_non_integer_count
+    assert_raise(ArgumentError){ [].shifted(0.123) }
+  end
+
+  def test_shifted_with_non_numeric_count
+    assert_raise(ArgumentError){ [].shifted("") }
+  end
+
+  # alias: test_cdr must be idential to test_shifted
   def test_cdr
     a=['a','b','c']
     assert_equal([    'b','c'],a.cdr)
@@ -122,13 +203,24 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal([        'c'],a.cdr(2))
     assert_equal([           ],a.cdr(3))
     assert_equal(nil          ,a.cdr(4))
-    assert_raise(ArgumentError){ a.cdr(-1) }
-    assert_raise(ArgumentError){ a.cdr("") }
-    assert_raise(ArgumentError){ a.cdr(0.123) }
   end
 
-  # test_rest must be idential to test_shifted
-  # because rest is an alias for shifted
+  # alias: test_cdr must be idential to test_shifted
+  def test_cdr_with_negative_count    
+    assert_raise(ArgumentError){ [].cdr(-1) }
+  end
+
+  # alias: test_cdr must be idential to test_shifted
+  def test_cdr_with_non_integer_count
+    assert_raise(ArgumentError){ [].cdr(0.123) }
+  end
+
+  # alias: test_cdr must be idential to test_shifted
+  def test_cdr_with_non_numeric_count
+    assert_raise(ArgumentError){ [].cdr("") }
+  end
+
+  # alias: test_rest must be idential to test_shifted
   def test_rest
     a=['a','b','c']
     assert_equal([    'b','c'],a.rest)
@@ -137,9 +229,21 @@ class ArrayTest < Test::Unit::TestCase
     assert_equal([        'c'],a.rest(2))
     assert_equal([           ],a.rest(3))
     assert_equal(nil          ,a.rest(4))
-    assert_raise(ArgumentError){ a.rest(-1) }
-    assert_raise(ArgumentError){ a.rest("") }
-    assert_raise(ArgumentError){ a.rest(0.123) }
+  end
+
+  # alias: test_rest must be idential to test_shifted
+  def test_rest_with_negative_count
+    assert_raise(ArgumentError){ [].rest(-1) }
+  end
+
+  # alias: test_rest must be idential to test_shifted
+  def test_rest_with_non_integer_count
+    assert_raise(ArgumentError){ [].rest(0.123) }
+  end
+
+  # alias: test_rest must be idential to test_shifted
+  def test_rest_with_non_numeric_count
+    assert_raise(ArgumentError){ [].rest("") }
   end
 
   def test_shifted_bang
@@ -149,10 +253,18 @@ class ArrayTest < Test::Unit::TestCase
     a=['a','b','c']; a.shifted!(2); assert_equal([        'c'],a)
     a=['a','b','c']; a.shifted!(3); assert_equal([           ],a)
     a=['a','b','c']; a.shifted!(4); assert_equal([           ],a)
-    a=[]
-    assert_raise(ArgumentError){ a.shifted!(-1) }
-    assert_raise(ArgumentError){ a.shifted!("") }
-    assert_raise(ArgumentError){ a.shifted!(0.123) }
+  end
+
+  def test_shifted_bang_with_negative_count    
+    assert_raise(ArgumentError){ [].shifted!(-1) }
+  end
+
+  def test_shifted_bang_with_non_integer_count    
+    assert_raise(ArgumentError){ [].shifted!(0.123) }
+  end
+
+  def test_shifted_bang_with_non_numeric_count    
+    assert_raise(ArgumentError){ [].shifted!("") }
   end
 
   # alias: test_cdr_bang must be identical to test_shifted_bang
@@ -163,13 +275,24 @@ class ArrayTest < Test::Unit::TestCase
     a=['a','b','c']; a.cdr!(2); assert_equal([        'c'],a)
     a=['a','b','c']; a.cdr!(3); assert_equal([           ],a)
     a=['a','b','c']; a.cdr!(4); assert_equal([           ],a)
-    a=[]
-    assert_raise(ArgumentError){ a.cdr!(-1) }
-    assert_raise(ArgumentError){ a.cdr!("") }
-    assert_raise(ArgumentError){ a.cdr!(0.123) }
   end
 
-  # alias: test_rest_band must be identical to test_shifted_bang
+  # alias: test_cdr_bang must be identical to test_shifted_bang
+  def test_cdr_bang_with_negative_count
+    assert_raise(ArgumentError){ [].cdr!(-1) }
+  end
+
+  # alias: test_cdr_bang must be identical to test_shifted_bang
+  def test_cdr_bang_with_non_integer_count
+    assert_raise(ArgumentError){ [].cdr!(0.123) }
+  end
+
+  # alias: test_cdr_bang must be identical to test_shifted_bang
+  def test_cdr_bang_with_non_numeric_count
+    assert_raise(ArgumentError){ [].cdr!("") }
+  end
+  
+  # alias: test_rest_bang must be identical to test_shifted_bang
   def test_rest_bang
     a=['a','b','c']; a.rest!;    assert_equal([    'b','c'],a)
     a=['a','b','c']; a.rest!(0); assert_equal(['a','b','c'],a)
@@ -177,10 +300,21 @@ class ArrayTest < Test::Unit::TestCase
     a=['a','b','c']; a.rest!(2); assert_equal([        'c'],a)
     a=['a','b','c']; a.rest!(3); assert_equal([           ],a)
     a=['a','b','c']; a.rest!(4); assert_equal([           ],a)
-    a=[]
-    assert_raise(ArgumentError){ a.rest!(-1) }
-    assert_raise(ArgumentError){ a.rest!("") }
-    assert_raise(ArgumentError){ a.rest!(0.123) }
+  end
+    
+  # alias: test_rest_bang must be identical to test_shifted_bang
+  def test_rest_bang_with_negative_count
+    assert_raise(ArgumentError){ [].rest!(-1) }
+  end
+
+  # alias: test_rest_bang must be identical to test_shifted_bang
+  def test_rest_bang_with_non_integer_count
+    assert_raise(ArgumentError){ [].rest!(0.123) }
+  end
+
+  # alias: test_rest_bang must be identical to test_shifted_bang
+  def test_rest_bang_with_non_numeric_count
+    assert_raise(ArgumentError){ [].rest!("") }
   end
 
   def test_car
@@ -208,8 +342,10 @@ class ArrayTest < Test::Unit::TestCase
   end
 
   def test_to_csv_one_dimensional
-    a=["a","b","c"]
-    assert_equal("a,b,c\n",a.to_csv)
+    assert_equal("a,b,c,d\n",A.to_csv)
+  end
+
+  def test_to_csv_with_empty
     assert_equal("",[].to_csv)    
   end
 
@@ -221,6 +357,9 @@ class ArrayTest < Test::Unit::TestCase
   def test_to_tsv
     a=[["a", "b"], ["c", "d"], ["e", "f"]]
     assert_equal("a\tb\nc\td\ne\tf\n",a.to_tsv)
+  end
+
+  def test_to_tsv_with_empty
     assert_equal("",[].to_tsv)    
   end
 
@@ -228,6 +367,10 @@ class ArrayTest < Test::Unit::TestCase
   def test_to_tdf
     a=[["a", "b"], ["c", "d"], ["e", "f"]]
     assert_equal("a\tb\nc\td\ne\tf\n",a.to_tdf)
+  end
+
+  # alias: test_to_tdf must be identical to test_to_tsv
+  def test_to_tdf_with_empty
     assert_equal("",[].to_tdf)    
   end