sixarm_ruby_ramp 4.2.3 → 4.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e7a09b3f5a55209f6e750428efe99e0dd27b39d6
-  data.tar.gz: 7ddd7f2b6fdd77aa42b18ee5cddc54789c521f36
+  metadata.gz: cd28e48ca54cace863d1df36f8db7bfdd6c617af
+  data.tar.gz: 5c2a913207a9b83f7da75c8910c5f44b876017a0
 SHA512:
-  metadata.gz: d98a9cc2f187fa3ebc8e2cbe26b103746dd6b02590f907c526a044dd02c5273715654cc5f256e457abe29edc0024a49da0d758d83926c415d5ba37eb92340e4d
-  data.tar.gz: 77a21d90aa018a1c21b6b7c3a3d29c561bd3c427cf267a64a9c6308e9fc6c238597ced3d59692d703f3036f84a648b06178808ffc0d0a1b7c279f168fa730c51
+  metadata.gz: 21a8671ccf5d9fe673d8f9da26a2370ec2f4d1c8d1720efaea5b167213b65088bf2b353d2566ea5dc387a3432b9262d90907f32c547183856fb0400e57548633
+  data.tar.gz: cdb4647686ddb9417adcffc32c96481033650b5d30a2668ae8609221ad9fbddbf2f27c7949e6e2b09517f91a75305e0c3fe3412c80d613b263a0a42849ad72f1

data/Rakefile

@@ -3,8 +3,9 @@ require "rake"
 require "rake/testtask"
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib' << 'test'
-  t.pattern = 'test/*.rb'
+  t.libs.push("lib", "test")
+  t.pattern = "test/**/*.rb"
 end
 
 task :default => [:test]
+task :default => [:test]

data/lib/sixarm_ruby_ramp/array/join.rb

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 class Array
 
   # Alias join because we're going to override it

data/lib/sixarm_ruby_ramp/enumerable/each.rb

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+module Enumerable
+
+  # Get each element at a given index or indices.
+  #
+  # Example: use an index.
+  #
+  #   ["a", "b", "c", "d", "e"].each_at(1)
+  #   #=> "b"
+  #
+  # Example: use an index that is negative when size is known.
+  #
+  #   ["a", "b", "c", "d", "e"].each_at(-1)
+  #   => "e"
+  #
+  # Example: use a range.
+  #
+  #   ["a", "b", "c", "d", "e"].each_at(1..3)
+  #   => "b", "c", "d"
+  #
+  # Example: use a range that has negatives when size is known.
+  #
+  #   ["a", "b", "c", "d", "e"].each_at(-3..-1)
+  #   => "c", "d", "e"
+  #
+  # Example: use any object that responds to #each or #include?.
+  #
+  #   ["a", "b", "c", "d", "e"].each_at([4, 2, -2])
+  #   => "e", "c", "d"
+  #
+  def each_at(filter)
+    filter, optimize_for_whole_numbers = each_at_normalize_filter(filter)
+
+    # Handle variations.
+    #
+    # Can we call self#at?
+    #
+    #  * Yes: look up a self element by index.
+    #  * No: iterate on self, comparing the loop count to filter target.
+    #
+    # Can we call filter#each?
+    #
+    #  * Yes: iterate on the filter elements.
+    #  * No:  iterate on self, comparing the loop count to filter#include?
+    #
+    # Can we optimize for whole numbers?
+    #
+    #  * Yes: we know that all filter targets are whole numbers.
+    #  * No: we must convert the filter target to an index size each time.
+    #
+    if self.respond_to?(:at) && filter.respond_to?(:each)
+      if optimize_for_whole_numbers
+        # each_at_strategy_with_self_at_and_filter_each_and_whole_numbers(filter)
+        filter.each{|i|
+          yield(at(i))
+        }
+      else
+        # each_at_strategy_with_self_at_and_filter_each(filter)
+        filter.each{|i|
+          yield(at(i >= 0 ? i : i + self.size))
+        }
+      end
+    elsif filter.respond_to?(:include?)
+      # each_at_strategy_with_count(filter)
+      i = 0
+      s = respond_to?(:size) ? size : nil
+      each{|e|
+        yield(e) if (filter.include?(i) || (size && filter.include(i - size)))
+        i += 1
+      }
+    else
+      raise ArgumentError
+    end
+  end
+
+  # Implement #each_at by using a strategy with no optimization.
+  #
+  # When #each_at tests that either self#at is unavailable or filter#each
+  # is unavailable, then #each_at calls this strategy.
+  #
+  # This strategy uses a loop counter and iteration on the self elements,
+  # and each iteration, test whether the counter is in the filter.
+  #
+  # This strategy is the slowest, and for the worst-case need.
+  # This strategy is rarely needed in the wild.
+  #
+  def each_at_strategy_with_optimization_off(filter)
+    i = 0
+    if respond_to?(:size)
+      each{|e|
+        yield(e) if (filter.include?(i) || (size && filter.include?(i - size)))
+        i += 1
+      }
+    else
+      each{|e|
+        yield(e) if (filter.include?(i))
+        i += 1
+      }
+    end
+  end
+
+  # Implement #each_at by using a strategy with some optimization.
+  #
+  # When #each_at tests that both self#at is available and filter#each
+  # is available, yet cannot test that all indexes are whole numbers,
+  # then #each_at calls this strategy.
+  #
+  def each_at_strategy_with_optimization_min(filter)
+    filter.each{|i|
+      yield(at(i >= 0 ? i : i + self.size))
+    }
+  end
+
+  # Implement #each_at by using a strategy with full optimization.
+  #
+  # When #each_at tests that both self#at is available and filter#each
+  # is available, and can test that all indexes are whole numbers,
+  # then #each_at calls this strategy.
+  #
+  def each_at_strategy_with_optimization_max(filter)
+    filter.each{|i|
+      yield(at(i))
+    }
+  end
+
+  # Normalize the filter to make it respond to #each and #include?.
+  #
+  # If we can guarantee the filter is all whole numbers,
+  # then subsequent method calls can optimize the index lookup,
+  # by looking for the whole numbers instead of negative numbers.
+  #
+  def each_at_normalize_filter(filter)
+    case filter
+    when Numeric
+      return [filter.to_i], filter >= 0
+    when Range
+      if filter.first < 0 || filter.last < 0
+        min = filter.first.to_i; min += size if min < 0
+        max = filter.last.to_i; max += size if max < 0
+        max -= 1 if filter.exclude_end?
+        filter = min..max
+      end
+      return filter, true
+    else
+      return filter, false
+    end
+  end
+
+end

data/lib/sixarm_ruby_ramp/integer/rbit.rb

@@ -1,3 +1,5 @@
+# -*- coding: utf-8 -*-
+
 class Integer
 
   # Reverse bit.

data/lib/sixarm_ruby_ramp/integer.rb

@@ -6,21 +6,24 @@ class Integer
 
   # Syntactic sugar to yield n times to a block.
   #
-  # Comparison to Integer#times: 
+  # ## Comparison to Integer#times
+  #
   # Integer#maps is similar to Integer#times except that the output from each
   # call to the block is captured in an array element and that array is
   # returned to the calling code.
   #
-  # @return an array of any results
+  # @return an array of results
   #
   # @example Generate an array of three random numbers
   #   3.maps{rand}
   #   => [0.0248131784304143, 0.814666170190905, 0.15812816258206]
   #
-  
+  # @example Multiply the current index
+  #   3.maps{|i| i * 2}
+  #   => [0, 2, 4]
+  #
   def maps
     return (0...self).map{|item| yield item}
   end
 
-
 end

data/lib/sixarm_ruby_ramp/string.rb

@@ -221,7 +221,7 @@ class String
  # This method defaults to length = self.lorem_length.
  
  def self.lorem(length=self.lorem_length)
-  ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'].choices(length).join
+  ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'].sample(length).join
  end
 
 

data/lib/sixarm_ruby_ramp.rb

@@ -11,6 +11,7 @@ Please see README
   'csv',
   'date',
   'enumerable',
+  'enumerable/each',
   'enumerable/map',
   'enumerable/nitems',
   'enumerable/select',
@@ -30,7 +31,6 @@ Please see README
   '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

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
+require "sixarm_ruby_ramp_test"
 require "sixarm_ruby_ramp/array/join"
 
 class ArrayJoinTest < Minitest::Test

data/test/sixarm_ruby_ramp_test/array/shuffle_test.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
+require "sixarm_ruby_ramp_test"
 require "sixarm_ruby_ramp/array/shuffle"
 
 class ArrayTest < Minitest::Test

data/test/sixarm_ruby_ramp_test/array_test.rb

@@ -1,8 +1,7 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/array"
 require "csv"
-require "sixarm_ruby_ramp"
-
 
 class ArrayTest < Minitest::Test
 

data/test/sixarm_ruby_ramp_test/class_test.rb

@@ -1,11 +1,9 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/class"
 
 class ClassTest < Minitest::Test
 
-  
   METHOD_REGEXP = /^[abc]\W*$/
   def test_publicize_methods
 

data/test/sixarm_ruby_ramp_test/csv_test.rb

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/csv"
 
 class CSVTest < Minitest::Test
 
@@ -42,6 +41,5 @@ class MockRequest
   def env
     @env
   end
-       
+
 end
- 

data/test/sixarm_ruby_ramp_test/date_test.rb

@@ -1,14 +1,13 @@
 # -*- coding: utf-8 -*-
-require "minitest/autorun"
-require "sixarm_ruby_ramp"
-
+require "sixarm_ruby_ramp_test"
+require "sixarm_ruby_ramp/date"
 
 class DateTest < Minitest::Test
 
 
   def test_weekday
     # Start on Monday, January 1, 2007
-    assert( Date.new(2007,1,1).weekday?) 
+    assert( Date.new(2007,1,1).weekday?)
     assert( Date.new(2007,1,2).weekday?)
     assert( Date.new(2007,1,3).weekday?)
     assert( Date.new(2007,1,4).weekday?)
@@ -21,14 +20,14 @@ class DateTest < Minitest::Test
 
   def test_weekend
     # Start on Monday, January 1, 2007
-    assert(!Date.new(2007,1,1).weekend?) 
-    assert(!Date.new(2007,1,2).weekend?) 
-    assert(!Date.new(2007,1,3).weekend?) 
-    assert(!Date.new(2007,1,4).weekend?) 
-    assert(!Date.new(2007,1,5).weekend?) 
-    assert( Date.new(2007,1,6).weekend?) 
-    assert( Date.new(2007,1,7).weekend?) 
-    assert(!Date.new(2007,1,8).weekend?) 
+    assert(!Date.new(2007,1,1).weekend?)
+    assert(!Date.new(2007,1,2).weekend?)
+    assert(!Date.new(2007,1,3).weekend?)
+    assert(!Date.new(2007,1,4).weekend?)
+    assert(!Date.new(2007,1,5).weekend?)
+    assert( Date.new(2007,1,6).weekend?)
+    assert( Date.new(2007,1,7).weekend?)
+    assert(!Date.new(2007,1,8).weekend?)
   end
 
 
@@ -43,8 +42,8 @@ class DateTest < Minitest::Test
 
 
   def test_between
-    d1= Date.parse('2008-01-01')                                                                                  
-    d2= Date.parse('2009-01-01')                                                                                  
+    d1= Date.parse('2008-01-01')
+    d2= Date.parse('2009-01-01')
     d3= Date.between(d1,d2)
     assert(d3>=d1)
     assert(d3<=d2)
@@ -57,4 +56,3 @@ class DateTest < Minitest::Test
 
 
 end
-