sixarm_ruby_ramp 4.1.0 → 4.2.2

data/lib/sixarm_ruby_ramp/enumerable.rb

@@ -1,6 +1,5 @@
 # -*- coding: utf-8 -*-
-
-# Enumberable extensions
+# Enumerable extensions
 
 require 'set'
 module Enumerable
@@ -97,128 +96,6 @@ module Enumerable
     map{|item| yield(item)}.to_h
   end
 
-  ########################################################################
-  #
-  #  map_to_xxx
-  #
-  ########################################################################
-
-  # Map each item => item.id
-  #
-  # @return [Enumerable<Object>] an list of each item.id
-  #
-  # @example
-  #   users = User.find(:all)
-  #   users.map_id => [1,2,3,4,...]
-  #
-  # A typical use is to convert a list of ActiveRecord items to a list of id items.
-  #
-  # This method is a fast way to get the same results as items.map(&:id)
-  #
-  def map_id
-    map{|item| item.id}
-  end
-
-  # Map each item => item.to_a
-  #
-  # @return [Enumberable<Array<Object>>] a list of each item.to_a
-  #
-  # @example
-  #   set1 = Set.new([:a,:b,:c])
-  #   set2 = Set.new([:d,:e,:f])
-  #   set3 = Set.new([:g,:h,:i])
-  #   sets = [set1, set2, set3]
-  #   sets.map_to_a => [[:a, :b, :c], [:d, :e, :f], [:g, :h, :i]]
-  #
-  # A typical use is to convert a list with Set items to a list of Array items,
-  # so you can more easily iterate over the the Array items.
-  #
-  # See http://www.ruby-doc.org/core/classes/Enumerable.html#M003148
-  #
-  def map_to_a
-    map{|item| [item]}
-  end
-
-  # Map each item => item.to_f
-  #
-  # @return [Enumerable<Float>] a list of each item.to_f
-  #
-  # @example
-  #   strings = ["1","2","3"]
-  #   strings.map_to_f => [1.0, 2.0, 3.0]
-  #
-  # A typical use is to convert a list of String items to a list of float items.
-  #
-  # This method is a fast way to get the same results as items.map(&:to_f)
-  #
-  def map_to_f
-    map{|item| item.to_f}
-  end
-
-  # Map each item => item.to_i
-  #
-  # @return [Enumerable<Integer>] a list of each item.to_i
-  #
-  # @example
-  #   strings = ["1","2","3"]
-  #   strings.map_to_i => [1, 2, 3]
-  #
-  # A typical use is to convert a list of String items to a list of integer items.
-  #
-  # This method is a fast way to get the same results as items.map(&:to_i)
-  #
-  def map_to_i
-    map{|item| item.to_i}
-  end
-
-  # Map each item => item.to_s
-  #
-  # @return [Enumerable<String>] a list of each item.to_s
-  #
-  # @example
-  #   numbers = [1, 2, 3]
-  #   numbers.map_to_s => ["1", "2", "3"]
-  #
-  # A typical use is to convert a list of Numeric items to a list of String items.
-  #
-  # This method is a fast way to get the same results as items.map(&:to_s)
-  #
-  def map_to_s
-    map{|item| item.to_s}
-  end
-
-  # Map each item => item.to_sym
-  #
-  # @return [Enumerable<Symbol>] a list of each item.to_sym
-  #
-  # @example
-  #   strings = ["foo", "goo", "hoo"]
-  #   strings.map_to_sym => [:foo, :goo, :hoo]
-  #
-  # A typical use is to convert a list of Object items to a list of Symbol items.
-  #
-  # This method is a fast way to get the same results as items.map(&:to_sym)
-  #
-  def map_to_sym
-    map{|item| item.to_sym}
-  end
-
-  # Map each item and its index => a new output
-  #
-  # @return [Enumerable<Object>] an list of each item transformed by the block
-  # @see Enumerable#map
-  # @see Enumerable#each_with_index
-  #
-  # @example
-  #   strings = ["a", "b", "c"]
-  #   strings.map_with_index{|string,index| "#{string}#{index}"}
-  #    => ["a0, "b1", "c3"]
-  #
-  def map_with_index
-    index=-1
-    map{|item| index+=1; yield(item,index)}
-  end
-
   ########################################################################
   #
   #  select

data/lib/sixarm_ruby_ramp/integer/rbit.rb

@@ -0,0 +1,23 @@
+class Integer
+
+  # Reverse bit.
+  #
+  # Example:
+  #
+  #    0.rbit #=> 0
+  #    1.rbit #=> 128
+  #    2.rbit #=> 64
+  #
+  # The bit count defaults to 8.
+  #
+  # @param count [Integer] the count of bits to reverse
+  #
+  def rbit(count=8)
+    z =  self & 0
+    count.times{|i|
+      z = z * 2 + self[i]
+    }
+    z
+  end
+
+end

data/lib/sixarm_ruby_ramp.rb

@@ -3,6 +3,35 @@
 Please see README
 =end
 
-['array','class','csv','date','enumerable','file','fixnum','hash','integer','io','kernel','math','nil','numeric','object','pairable','process','string','symbol','time','xml','yaml'].map{|x|
+[
+  'array',
+  'array/join',
+  'array/shuffle',
+  'class',
+  'csv',
+  'date',
+  'enumerable',
+  'enumerable/map',
+  'enumerable/nitems',
+  'enumerable/select',
+  'file',
+  'fixnum',
+  'hash',
+  'integer',
+  'integer/rbit',
+  'io',
+  'kernel',
+  'math',
+  'nil',
+  'numeric',
+  'object',
+  'pairable',
+  'process',
+  'string',
+  'symbol',
+  'time',
+  'xml',
+  'yaml'
+].map{|x|
   require File.dirname(__FILE__) + "/sixarm_ruby_ramp/#{x}.rb"
 }

data/test/sixarm_ruby_ramp_test/array/join_test.rb

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp/array/join'
+
+class ArrayJoinTest < Minitest::Test
+
+  A=['a','b','c']
+
+  def test_join_with_no_ops
+    assert_equal('abc',A.join())
+  end
+
+  def test_join_with_1_op_does_infix
+    assert_equal('a*b*c', A.join('*'))
+  end
+
+  def test_join_with_2_ops_does_prefix_suffix
+    assert_equal('[a][b][c]', A.join('[',']'))
+  end
+
+  def test_join_with_3_ops_does_prefix_suffix_infix
+    assert_equal('[a]*[b]*[c]', A.join('[',']','*'))
+  end
+
+  def test_join_with_too_many_ops_raises
+    assert_raises(ArgumentError){ A.join('','','','') }
+  end
+
+  def test_join_prefix_suffix
+    assert_equal('[a][b][c]', A.join_prefix_suffix('[',']'))
+  end
+
+  def test_join_prefix_suffix_infix
+    assert_equal('[a]*[b]*[c]', A.join_prefix_suffix_infix('[',']','*'))
+  end
+
+end

data/test/sixarm_ruby_ramp_test/array/shuffle_test.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp/array/shuffle'
+
+class ArrayTest < Minitest::Test
+
+  def test_shuffle
+    a=[1,2,3,4]
+    5.times {
+      b=a.shuffle
+      assert_equal(a.size,b.size)
+      a.each{|item| assert(b.include?(item)) }
+    }
+  end
+
+  def test_shuffle_bang
+    a=[1,2,3,4]
+    b=a.dup
+    5.times {
+      b.shuffle!
+      assert_equal(a.size,b.size)
+      a.each{|item| assert(b.include?(item)) }
+    }
+  end
+
+end

data/test/sixarm_ruby_ramp_test/array_test.rb

@@ -9,34 +9,6 @@ class ArrayTest < Minitest::Test
   A=['a','b','c','d']
   B=['w','x','y','z']
 
-  def test_join_with_no_ops
-    assert_equal('abcd',A.join())
-  end
-
-  def test_join_with_1_op_does_infix
-    assert_equal('a*b*c*d', A.join('*'))
-  end
-
-  def test_join_with_2_ops_does_prefix_suffix
-    assert_equal('[a][b][c][d]', A.join('[',']'))
-  end
-
-  def test_join_with_3_opes_does_prefix_suffix_infix
-    assert_equal('[a]*[b]*[c]*[d]', A.join('[',']','*'))
-  end
-
-  def test_join_with_too_many_ops_raises
-    assert_raises(ArgumentError){ A.join('','','','') }
-  end
-  
-  def test_join_prefix_suffix
-    assert_equal('[a][b][c][d]', A.join_prefix_suffix('[',']'))
-  end
-
-  def test_join_prefix_suffix_infix
-    assert_equal('[a]*[b]*[c]*[d]', A.join_prefix_suffix_infix('[',']','*'))
-  end
-
   def test_size_with_one_item
     assert_equal(true,[1].size?)
   end
@@ -56,7 +28,7 @@ class ArrayTest < Minitest::Test
   def test_size_with_one_empty
     assert_equal(true,[[]].size?)
   end
-  
+
  def test_rotate
    a=A.dup
    a.rotate!
@@ -157,7 +129,7 @@ class ArrayTest < Minitest::Test
   end
 
   # alias: test_cdr must be idential to test_shifted
-  def test_cdr_with_negative_count    
+  def test_cdr_with_negative_count
     assert_raises(ArgumentError){ [].cdr(-1) }
   end
 
@@ -206,15 +178,15 @@ class ArrayTest < Minitest::Test
     a=['a','b','c']; a.shifted!(4); assert_equal([           ],a)
   end
 
-  def test_shifted_bang_with_negative_count    
+  def test_shifted_bang_with_negative_count
     assert_raises(ArgumentError){ [].shifted!(-1) }
   end
 
-  def test_shifted_bang_with_non_integer_count    
+  def test_shifted_bang_with_non_integer_count
     assert_raises(ArgumentError){ [].shifted!(0.123) }
   end
 
-  def test_shifted_bang_with_non_numeric_count    
+  def test_shifted_bang_with_non_numeric_count
     assert_raises(ArgumentError){ [].shifted!("") }
   end
 
@@ -242,7 +214,7 @@ class ArrayTest < Minitest::Test
   def test_cdr_bang_with_non_numeric_count
     assert_raises(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)
@@ -252,7 +224,7 @@ class ArrayTest < Minitest::Test
     a=['a','b','c']; a.rest!(3); assert_equal([           ],a)
     a=['a','b','c']; a.rest!(4); assert_equal([           ],a)
   end
-    
+
   # alias: test_rest_bang must be identical to test_shifted_bang
   def test_rest_bang_with_negative_count
     assert_raises(ArgumentError){ [].rest!(-1) }
@@ -273,31 +245,12 @@ class ArrayTest < Minitest::Test
     assert_equal('a',a.car)
   end
 
-  def test_shuffle
-    a=[1,2,3,4]
-    5.times {
-      b=a.shuffle
-      assert_equal(a.size,b.size)
-      a.each{|item| assert(b.include?(item)) }
-    }
-  end
-
-  def test_shuffle_bang
-    a=[1,2,3,4]
-    b=a.dup
-    5.times {
-      b.shuffle!
-      assert_equal(a.size,b.size)
-      a.each{|item| assert(b.include?(item)) }
-    }
-  end
-
   def test_to_csv_one_dimensional
     assert_equal("a,b,c,d\n",A.to_csv)
   end
 
   def test_to_csv_with_empty
-    assert_equal("",[].to_csv)    
+    assert_equal("",[].to_csv)
   end
 
   def test_to_csv_multi_dimensional
@@ -311,7 +264,7 @@ class ArrayTest < Minitest::Test
   end
 
   def test_to_tsv_with_empty
-    assert_equal("",[].to_tsv)    
+    assert_equal("",[].to_tsv)
   end
 
   # alias: test_to_tdf must be identical to test_to_tsv
@@ -322,9 +275,7 @@ class ArrayTest < Minitest::Test
 
   # alias: test_to_tdf must be identical to test_to_tsv
   def test_to_tdf_with_empty
-    assert_equal("",[].to_tdf)    
+    assert_equal("",[].to_tdf)
   end
 
 end
-
-

data/test/sixarm_ruby_ramp_test/enumerable/map_test.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp/enumerable/map'
+require 'ostruct'
+
+class EnumerableMapTest < Minitest::Test
+
+  def test_map_id
+    x = [OpenStruct.new(id: 1), OpenStruct.new(id: 2), OpenStruct.new(id: 3)]
+    assert_equal(x.map(&:id), x.map_id)
+  end
+
+  def test_map_to_a
+    x = [{a: :b, c: :d}, {e: :f, g: :h}]
+    assert_equal(x.map(&:to_a), x.map_to_a)
+  end
+
+  def test_map_to_f
+    x = ["1", "2", "3"]
+    assert_equal(x.map(&:to_f) , x.map_to_f)
+  end
+
+  def test_map_to_i
+    x = ["1", "2", "3"]
+    assert_equal(x.map(&:to_i), x.map_to_i)
+  end
+
+  def test_map_to_s
+    x = [1, 2, 3]
+    assert_equal(x.map(&:to_s), x.map_to_s)
+  end
+
+  def test_map_to_sym
+    x = ["a", "b", "c"]
+    assert_equal(x.map(&:to_sym) , x.map_to_sym)
+  end
+
+  def test_map_with_index
+    assert_equal(["a0", "b1", "c2"], ["a", "b", "c"].map_with_index{|x,i| "#{x}#{i}"})
+  end
+
+end

data/test/sixarm_ruby_ramp_test/enumerable/nitems_test.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp/enumerable/nitems'
+
+class EnumerableNItemsTest < Minitest::Test
+
+  ITEMS = ['a','b','c']
+
+  def test_nitems?
+    assert_equal(true,  ITEMS.nitems?(0){|x| x < 'a'})
+    assert_equal(false, ITEMS.nitems?(1){|x| x < 'a'})
+    assert_equal(false, ITEMS.nitems?(2){|x| x < 'a'})
+    assert_equal(false, ITEMS.nitems?(0){|x| x < 'b'})
+    assert_equal(true,  ITEMS.nitems?(1){|x| x < 'b'})
+    assert_equal(false, ITEMS.nitems?(2){|x| x < 'b'})
+    assert_equal(false, ITEMS.nitems?(0){|x| x < 'c'})
+    assert_equal(false, ITEMS.nitems?(1){|x| x < 'c'})
+    assert_equal(true,  ITEMS.nitems?(2){|x| x < 'c'})
+  end
+
+
+  def test_nitems_while
+    assert_equal(0,ITEMS.nitems_while{|x| x < 'a' },'< a')
+    assert_equal(1,ITEMS.nitems_while{|x| x < 'b' },'< b')
+    assert_equal(2,ITEMS.nitems_while{|x| x < 'c' },'< c')
+    assert_equal(3,ITEMS.nitems_while{|x| x < 'd' },'< d')
+    assert_equal(3,ITEMS.nitems_while{|x| x < 'e' },'< e')
+  end
+
+
+  def test_nitems_until
+    assert_equal(0,ITEMS.nitems_until{|x| x == 'a' },'a')
+    assert_equal(1,ITEMS.nitems_until{|x| x == 'b' },'b')
+    assert_equal(2,ITEMS.nitems_until{|x| x == 'c' },'c')
+    assert_equal(3,ITEMS.nitems_until{|x| x == 'd' },'d')
+    assert_equal(3,ITEMS.nitems_until{|x| x == 'e' },'e')
+  end
+
+
+  def test_nitems_with_index
+    assert_equal(0,ITEMS.nitems_with_index{|x,i| i < 0 },'i < 0')
+    assert_equal(1,ITEMS.nitems_with_index{|x,i| i < 1 },'i < 1')
+    assert_equal(2,ITEMS.nitems_with_index{|x,i| i < 2 },'i < 2')
+    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 3 },'i < 3')
+    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 4 },'i < 4')
+  end
+
+end

data/test/sixarm_ruby_ramp_test/enumerable/select_test.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+require 'minitest/autorun'
+require 'sixarm_ruby_ramp/enumerable/select'
+
+class EnumerableSelectTest < Minitest::Test
+
+  ITEMS = ['a','b','c']
+
+  def test_select_while
+    assert_equal([           ], ITEMS.select_while{|x| x < 'a' },'< a')
+    assert_equal(['a'        ], ITEMS.select_while{|x| x < 'b' },'< b')
+    assert_equal(['a','b'    ], ITEMS.select_while{|x| x < 'c' },'< c')
+    assert_equal(['a','b','c'], ITEMS.select_while{|x| x < 'd' },'< d')
+    assert_equal(['a','b','c'], ITEMS.select_while{|x| x < 'e' },'< e')
+  end
+
+  def test_select_until_condition
+    assert_equal([           ], ITEMS.select_until{|x| x == 'a' },'a')
+    assert_equal(['a'        ], ITEMS.select_until{|x| x == 'b' },'b')
+    assert_equal(['a','b'    ], ITEMS.select_until{|x| x == 'c' },'c')
+    assert_equal(['a','b','c'], ITEMS.select_until{|x| x == 'd' },'d')
+    assert_equal(['a','b','c'], ITEMS.select_until{|x| x == 'e' },'e')
+  end
+
+  def test_select_with_index
+    assert_equal([           ], ITEMS.select_with_index{|x,i| i < 0 },'i < 0')
+    assert_equal(['a'        ], ITEMS.select_with_index{|x,i| i < 1 },'i < 1')
+    assert_equal(['a','b'    ], ITEMS.select_with_index{|x,i| i < 2 },'i < 2')
+    assert_equal(['a','b','c'], ITEMS.select_with_index{|x,i| i < 3 },'i < 3')
+    assert_equal(['a','b','c'], ITEMS.select_with_index{|x,i| i < 4 },'i < 4')
+  end
+
+end

data/test/sixarm_ruby_ramp_test/enumerable_test.rb

@@ -7,7 +7,6 @@ require 'set'
 class EnumerableTest < Minitest::Test
 
   ITEMS = ['a','b','c']
-  MAPTEST = [123,"456"] # to test typecasts-- one is numeric and one is string
   RGB = ["red","green","blue"]  # to test case changes
 
 
@@ -47,95 +46,6 @@ class EnumerableTest < Minitest::Test
   end
 
 
-  ########################################################################
-  #
-  #  map
-  #
-  ########################################################################
-
-
-  class Mock #:nodoc: all
-    attr_accessor :id
-
-    def initialize(id)
-      @id=id
-    end
-
-    def to_a
-     [self]
-    end
-
-  end
-
-
-  A = Mock.new('a')
-  B = Mock.new('b')
-  C = Mock.new('c')
-
-
-  def test_map_id
-    assert_equal(['a','b','c'],[A,B,C].map_id)
-  end
-
-  def test_map_to_a
-    assert_equal([[123],["456"]],MAPTEST.to_set.map_to_a)
-  end
-
-  def test_map_to_f
-    assert_equal([123.0,456.0],MAPTEST.map_to_f)
-  end
-
-  def test_map_to_i
-    assert_equal([123,456],MAPTEST.map_to_i)
-  end
-
-  def test_map_to_s
-    assert_equal(["123","456"],MAPTEST.map_to_s)
-  end
-
-  def test_map_to_sym
-    assert_equal([:a,:b,:c],ITEMS.map_to_sym)
-  end
-
-  def test_map_with_index
-    assert_equal(['a0','b1','c2'],ITEMS.map_with_index{|x,i| "#{x}#{i}"})
-  end
-
-
-  ########################################################################
-  #
-  #  select
-  #
-  ########################################################################
-
-
-  def test_select_while
-    assert_equal([           ],ITEMS.select_while{|x| x < 'a' },'< a')
-    assert_equal(['a'        ],ITEMS.select_while{|x| x < 'b' },'< b')
-    assert_equal(['a','b'    ],ITEMS.select_while{|x| x < 'c' },'< c')
-    assert_equal(['a','b','c'],ITEMS.select_while{|x| x < 'd' },'< d')
-    assert_equal(['a','b','c'],ITEMS.select_while{|x| x < 'e' },'< e')
-  end
-
-
-  def test_select_until_condition
-    assert_equal([           ],ITEMS.select_until{|x| x == 'a' },'a')
-    assert_equal(['a'        ],ITEMS.select_until{|x| x == 'b' },'b')
-    assert_equal(['a','b'    ],ITEMS.select_until{|x| x == 'c' },'c')
-    assert_equal(['a','b','c'],ITEMS.select_until{|x| x == 'd' },'d')
-    assert_equal(['a','b','c'],ITEMS.select_until{|x| x == 'e' },'e')
-  end
-
-
-  def test_select_with_index
-    assert_equal([           ],ITEMS.select_with_index{|x,i| i < 0 },'i < 0')
-    assert_equal(['a'        ],ITEMS.select_with_index{|x,i| i < 1 },'i < 1')
-    assert_equal(['a','b'    ],ITEMS.select_with_index{|x,i| i < 2 },'i < 2')
-    assert_equal(['a','b','c'],ITEMS.select_with_index{|x,i| i < 3 },'i < 3')
-    assert_equal(['a','b','c'],ITEMS.select_with_index{|x,i| i < 4 },'i < 4')
-  end
-
-
   ########################################################################
   #
   #  bisect
@@ -164,52 +74,6 @@ class EnumerableTest < Minitest::Test
   end
 
 
-  ########################################################################
-  #
-  #  nitems
-  #
-  ########################################################################
-
-  def test_nitems?
-    assert_equal(true,  ITEMS.nitems?(0){|x| x < 'a'})
-    assert_equal(false, ITEMS.nitems?(1){|x| x < 'a'})
-    assert_equal(false, ITEMS.nitems?(2){|x| x < 'a'})
-    assert_equal(false, ITEMS.nitems?(0){|x| x < 'b'})
-    assert_equal(true,  ITEMS.nitems?(1){|x| x < 'b'})
-    assert_equal(false, ITEMS.nitems?(2){|x| x < 'b'})
-    assert_equal(false, ITEMS.nitems?(0){|x| x < 'c'})
-    assert_equal(false, ITEMS.nitems?(1){|x| x < 'c'})
-    assert_equal(true,  ITEMS.nitems?(2){|x| x < 'c'})
-  end
-
-
-  def test_nitems_while
-    assert_equal(0,ITEMS.nitems_while{|x| x < 'a' },'< a')
-    assert_equal(1,ITEMS.nitems_while{|x| x < 'b' },'< b')
-    assert_equal(2,ITEMS.nitems_while{|x| x < 'c' },'< c')
-    assert_equal(3,ITEMS.nitems_while{|x| x < 'd' },'< d')
-    assert_equal(3,ITEMS.nitems_while{|x| x < 'e' },'< e')
-  end
-
-
-  def test_nitems_until
-    assert_equal(0,ITEMS.nitems_until{|x| x == 'a' },'a')
-    assert_equal(1,ITEMS.nitems_until{|x| x == 'b' },'b')
-    assert_equal(2,ITEMS.nitems_until{|x| x == 'c' },'c')
-    assert_equal(3,ITEMS.nitems_until{|x| x == 'd' },'d')
-    assert_equal(3,ITEMS.nitems_until{|x| x == 'e' },'e')
-  end
-
-
-  def test_nitems_with_index
-    assert_equal(0,ITEMS.nitems_with_index{|x,i| i < 0 },'i < 0')
-    assert_equal(1,ITEMS.nitems_with_index{|x,i| i < 1 },'i < 1')
-    assert_equal(2,ITEMS.nitems_with_index{|x,i| i < 2 },'i < 2')
-    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 3 },'i < 3')
-    assert_equal(3,ITEMS.nitems_with_index{|x,i| i < 4 },'i < 4')
-  end
-
-
   ########################################################################
   #
   #  strings