sixarm_ruby_ramp 4.1.0 → 4.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a60c19644a07626f66aae272432fb95dc384d5f3
-  data.tar.gz: 289def436e9f4683c32d22baad4e42567aa69dbf
+  metadata.gz: a821169d3c371f60d7d48f2084ee1b6cceceecd9
+  data.tar.gz: 96510d04fe9d8bb4d695c3e101cab563653310c6
 SHA512:
-  metadata.gz: 3ba91da4fcfc8e1bfba53b6375623f2e9849c0f97f0629da4cecc6d29e7b96d38594709d82b117593566d8125cf61ab725dbb22f2949cd7880f5de1c3713e3cb
-  data.tar.gz: b8af5a9742251db4518c10fec767c61ee9e9ec1910e3e203aa9615b6a0c146efdfb18aa79d0793925a43ba4cc5b796b16cdbc87871465e2b7e5363fe1710e66d
+  metadata.gz: a5ece89814f03fd98c3c2f1d87d682828a90ba79e48d7a4122be16bc2af3ee208ab36f2de4c0ef3d247c8c65af482b46a3710a6a980cf80bf66eb037de170209
+  data.tar.gz: 601811bc53253b62be8c3c8ef88f653f78c72c9bc6101954c7109a3bc91369141fa543de13910fc3ead9981b8145c408442c7f83b430d4e59ef6ea28e0582352

data/README.md

@@ -28,7 +28,7 @@ Install:
 
 Bundler:
 
-    gem "sixarm_ruby_ramp", ">=4.1.0", "<5"
+    gem "sixarm_ruby_ramp", ">=4.2.2", "<5"
 
 Require:
 
@@ -54,7 +54,6 @@ To install with high security:
 * choice, choices: one or more random elements from an array
 * cross: return the cross pairings of an array with another array
 * divvy: divides an array, like a pie, into a specified number of slices (deprecated - see method rdoc)
-* join, join_prefix_suffix, join_prefix_suffix_infix: like Array#join with improvements
 * onto: return a hash that maps an array's keys on to another array's values
 * rotate: moves the first element of an array to the end
 * rest: return the rest of the items of the array (aka cdr, aka shifted)
@@ -67,6 +66,13 @@ To install with high security:
 * union: builds an array containing each of the unique elements of sub-arrays ([[1,2,3,4],[2,3,4,5],[3,4,5,6]].union => [1,2,3,4,5,6])
 
 
+### Array join
+
+* join: enhances #join with optional prefix, suffix, and infix.
+* join_prefix_suffix: join with a prefix and suffix.
+* join_prefix_suffix_infix: join with a prefix, suffix, and infix.
+
+
 ## Class
 
 * publicize_methods: make all methods public for a block, e.g. to unit test private methods
@@ -93,13 +99,28 @@ To install with high security:
 * join: forwards to self.to_a.join
 * to_h: convert the object to a hash by mapping each item to a key=>value pair.
 * to_h_merge: convert the object to a hash by mapping each item to a key=>value pair, merging any duplicate keys.
+* power_set: return an array with all subsets of the enum's elements
+
+
+### Enumerable map
+
 * map_id: return the id of an Enumerable object; *requires* that the object respond to an 'id' message
 * map_to_a, map_to_f, map_to_i, map_to_s, map_to_sym: convert each object to a specific type by calling its respective method to_a, to_i, to_f, to_s, to_sym
 * map_with_index: for each item, yield to a block with the item and its incrementing index
-* nitems_until, select_until: return the number of, or an array containing, the leading elements for which block is false or nil.
-* nitems_while, select_while: return the number of items, or an array containing the leading elements, for which block is not false or nil.
-* nitems_with_index, select_with_index: calls block with two arguments, the item and its index, for each item in enum. Return the number of, or an array containing, the leading elements for which block is not false or nil.
-* power_set: return an array with all subsets of the enum's elements
+
+
+### Enumerable nitems
+
+* nitems_while: the number of leading elements for which block is truthy.
+* nitems_until: the number of leading elements for which block is falsey.
+* nitems_with_index: the number of leading elements for which block with index is truthy.
+
+
+### Enumerable select
+
+* select_while: return an array of the leading elements for which block is truthy.
+* select_until: return an array of the leading elements for which block is falsey.
+* select_with_index: return an array of the leading elements for which block with index is truthy.
 
 
 ## File
@@ -131,6 +152,7 @@ To install with high security:
 
 ## Integer
 
+* rbit: reverse bit
 * maps: syntactic sugar to yield n times to a block, returning an array of any results
 * odd?: is the number odd?
 
@@ -229,6 +251,8 @@ Extensions that help debug Ruby programs.
 
 ## Changes
 
+* 2015-03-14 4.2.1 Conditionally load `Array#shuffle*`
+* 2015-03-14 4.2.0 Add `Integer#rbit`
 * 2015-01-13 4.1.0 Fix Enumerable `to_h` and add `to_h_merge`
 * 2015-01-13 4.0.1 Fix for Process.ps keys
 * 2014-12-17 4.0.0 Add `Pairable` methods; change semantics of `Hash#map_pair`; change `to_h` for Ruby 2.2.0

data/VERSION

@@ -1 +1 @@
-4.1.0
+4.2.2

data/lib/sixarm_ruby_ramp/array/join.rb

@@ -0,0 +1,67 @@
+class Array
+
+  # Alias join because we're going to override it
+  alias :ruby_join :join
+
+  # Concatenate the items into a string by join.
+  #
+  # @return [String] concatenated string
+  #
+  # @example Join with infix
+  #   list=['a','b','c']
+  #   list.join("*") => "a*b*c"
+  #
+  # @example Join with prefix and suffix
+  #   list=['a','b','c']
+  #   list.join("[","]") => "[a][b][c]"
+  #
+  # @example Join with prefix, suffix, and infix
+  #   list=['a','b','c']
+  #   list.join("*","[","]") => "[a]*[b]*[c]"
+  #
+  def join(*fixes)
+    if fixes.is_a?(String) then return self.ruby_join(fixes) end
+    return case fixes.size
+    when 0
+      ruby_join
+    when 1
+      ruby_join(fixes[0].to_s)
+    when 2
+      join_prefix_suffix(*fixes)
+    when 3
+      join_prefix_suffix_infix(*fixes)
+    else
+      raise ArgumentError, "join() takes 0-3 arguments; you gave #{fixes.size}]"
+    end
+  end
+
+  # Concatenate the items by joining using a prefix string and suffix string.
+  #
+  # @return [String] concatenated string
+  #
+  # @example
+  #   list=['a','b','c']
+  #   list.join("[","]") => "[a][b][c]"
+  #
+  def join_prefix_suffix(prefix, suffix)
+    prefix = prefix.to_s
+    suffix = suffix.to_s
+    return self.map{|item| prefix + item.to_s + suffix}.ruby_join()
+  end
+
+  # Concatenate the items by joining using a prefix string, suffix string, and infix string.
+  #
+  # @return [String] concatenated string
+  #
+  # @example
+  #   list=['a','b','c']
+  #   list.join("*","[","]") => "[a]*[b]*[c]"
+  #
+  def join_prefix_suffix_infix(prefix, suffix, infix)
+    prefix = prefix.to_s
+    suffix = suffix.to_s
+    infix = infix.to_s
+    return self.map{|item| prefix + item.to_s + suffix}.ruby_join(infix)
+  end
+
+end

data/lib/sixarm_ruby_ramp/array/shuffle.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+class Array
+
+  unless method_defined? :shuffle
+
+    # Randomly arrange the array items.
+    #
+    # @return [Array] a new array with the items shuffled.
+    #
+    # This implementation is optimized for speed, not for memory use.
+    # See http://codeidol.com/other/rubyckbk/Arrays/Shuffling-an-Array/
+    #
+    # @example
+    #   list=
+    #   list=['a','b','c']
+    #   list.shuffle!
+    #   list => ['c','a','b']
+
+    def shuffle
+      dup.shuffle!
+    end
+
+  end
+
+  unless method_defined? :shuffle!
+
+    # Randomly arrange the array items.
+    #
+    # @return [Array] the array, with its items shuffled.
+    #
+    # This implementation is optimized for speed, not for memory use.
+    # See http://codeidol.com/other/rubyckbk/Arrays/Shuffling-an-Array/
+    #
+    # @example
+    #   list=
+    #   list=['a','b','c']
+    #   list.shuffle!
+    #   list => ['c','a','b']
+
+    def shuffle!
+      each_index do |i|
+        j = rand(length-i) + i
+        self[j], self[i] = self[i], self[j]
+      end
+    end
+  end
+
+end

data/lib/sixarm_ruby_ramp/array.rb

@@ -1,78 +1,8 @@
 # -*- coding: utf-8 -*-
-
 require 'csv'
- 
-# Array extensions
 
 class Array
 
-
-  # Alias join because we're going to override it
-
-  alias :ruby_join :join
-
-
-  # Concatenate the items into a string by join.
-  #
-  # @return [String] concatenated string
-  #
-  # @example Join with infix
-  #   list=['a','b','c']
-  #   list.join("*") => "a*b*c"
-  #
-  # @example Join with prefix and suffix
-  #   list=['a','b','c']
-  #   list.join("[","]") => "[a][b][c]"
-  #
-  # @example Join with prefix, suffix, and infix
-  #   list=['a','b','c']
-  #   list.join("*","[","]") => "[a]*[b]*[c]"
-  #
-  def join(*fixes)
-    if fixes.is_a?(String) then return self.ruby_join(fixes) end
-    return case fixes.size
-    when 0
-      ruby_join
-    when 1
-      ruby_join(fixes[0].to_s)
-    when 2
-      join_prefix_suffix(*fixes)
-    when 3
-      join_prefix_suffix_infix(*fixes)
-    else
-      raise ArgumentError, "join() takes 0-3 arguments; you gave #{fixes.size}]"
-    end
-  end
-
-  # Concatenate the items by joining using a prefix string and suffix string.
-  #
-  # @return [String] concatenated string
-  #
-  # @example
-  #   list=['a','b','c']
-  #   list.join("[","]") => "[a][b][c]"
-  #
-  def join_prefix_suffix(prefix, suffix)
-    prefix = prefix.to_s
-    suffix = suffix.to_s
-    return self.map{|item| prefix + item.to_s + suffix}.ruby_join()
-  end
-
-  # Concatenate the items by joining using a prefix string, suffix string, and infix string.
-  #
-  # @return [String] concatenated string
-  #
-  # @example
-  #   list=['a','b','c']
-  #   list.join("*","[","]") => "[a]*[b]*[c]"
-  #
-  def join_prefix_suffix_infix(prefix, suffix, infix)
-    prefix = prefix.to_s
-    suffix = suffix.to_s
-    infix = infix.to_s
-    return self.map{|item| prefix + item.to_s + suffix}.ruby_join(infix)
-  end
-
   # @return [Boolean] true if size > 0
   #
   # @example
@@ -92,7 +22,7 @@ class Array
   #   [].rotate! => []
   #
   # @return [Array] self
-  
+
   def rotate!
     if size>0
       push item=shift
@@ -100,7 +30,7 @@ class Array
     self
   end
 
-  
+
   # @return [Object] a random item from the array
   #
   # @example
@@ -109,7 +39,7 @@ class Array
   #   [1,2,3,4].choice => 3
   #
   # Implemented in Ruby 1.9
-  
+
   def choice
     self[Kernel.rand(size)]
   end
@@ -120,7 +50,7 @@ class Array
   # @example
   #   [1,2,3,4].choices(2) => [3,1]
   #   [1,2,3,4].choices(3) => [4,2,3]
-  
+
   def choices(count)
     arr = Array.new
     count.times { arr << self.choice }
@@ -139,13 +69,13 @@ class Array
   # This is identical to calling foo.zip(values).to_h
 
   def onto(values)
-    size==values.size or raise ArgumentError, "Array size #{size} must match values size #{size}" 
+    size==values.size or raise ArgumentError, "Array size #{size} must match values size #{size}"
     zip(values).to_h
   end
 
 
   ##############################################################
-  # 
+  #
   # GROUPINGS
   #
   ##############################################################
@@ -166,12 +96,12 @@ class Array
 
 
   ##############################################################
-  # 
+  #
   # COMBINATIONS
   #
   ##############################################################
 
-  
+
   # @return [Array] the union of the array's items.
   #
   # In typical use, each item is an array.
@@ -212,10 +142,10 @@ class Array
     inject{|inj,item| inj & item.to_a } || []
   end
 
-  
+
 
   ##############################################################
-  # 
+  #
   # LIST PROCESSING
   #
   ##############################################################
@@ -256,7 +186,7 @@ class Array
   # Delete the first _number_of_items_ items.
   #
   # @return [Array] the array, minus the deleted items.
-  # 
+  #
   # @example
   #   list=['a','b','c']
   #   list.shifted!
@@ -280,45 +210,8 @@ class Array
   alias :rest! :shifted!
 
 
-  # Randomly arrange the array items.
-  #
-  # @return [Array] the array, with its items shuffled.
-  #
-  # This implementation is optimized for speed, not for memory use.
-  # See http://codeidol.com/other/rubyckbk/Arrays/Shuffling-an-Array/
-  #
-  # @example
-  #   list=
-  #   list=['a','b','c']
-  #   list.shuffle!
-  #   list => ['c','a','b']
-
-  def shuffle!  
-    each_index do |i| 
-      j = rand(length-i) + i
-      self[j], self[i] = self[i], self[j]  
-    end
-  end
-
-
-  # @return [Array] a new array with the items shuffled.
-  #
-  # This implementation is optimized for speed, not for memory use.
-  # See http://codeidol.com/other/rubyckbk/Arrays/Shuffling-an-Array/
-  #
-  # @example
-  #   list=
-  #   list=['a','b','c']
-  #   list.shuffle!
-  #   list => ['c','a','b']
-
-  def shuffle  
-    dup.shuffle!  
-  end
-
-
   ##############################################################
-  # 
+  #
   # CASTS
   #
   ##############################################################
@@ -334,7 +227,7 @@ class Array
   #   [[1,2,3],[4,5,6]] => "1,2,3\n4,5,6\n"
   #
   # @example of a blank array
-  #   
+  #
   #   [].to_csv => ""
   #
   # N.b. this method uses the multi-dimensional if the
@@ -368,7 +261,7 @@ class Array
   # Each subarray becomes one 'line' in the output.
   #
   # @example of a blank array
-  #   
+  #
   #   [].to_csv => ""
 
   def to_tsv(ops={})

data/lib/sixarm_ruby_ramp/enumerable/map.rb

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+module Enumerable
+
+  # 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 faster 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
+  #   hashes = [{1=>2, 3=>4},{5=>6, 7=>8}]
+  #   hashes.map_to_a => [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+  #
+  # This method is a faster way to get the same results as items.map(&:to_a)
+  #
+  def map_to_a
+    map{|item| item.to_a}
+  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
+
+end

data/lib/sixarm_ruby_ramp/enumerable/nitems.rb

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+module Enumerable
+
+  # @example
+  #   enum.nitems?(n) {| obj | block }
+  #    => true iff the block is not false or nil num times
+  #
+  # @return [Boolean] true iff the block is not false or nil num times
+  #
+  def nitems?(n)
+    num = 0
+    each{|item|
+      if yield(item)
+        num+=1
+        if num > n then return false end
+      end
+    }
+    return num==n
+  end
+
+  # @example
+  #   enum.nitems_while {| obj | block }
+  #    => number of items
+  #
+  # @return [Integer] the number of leading elements for which block is not false or nil.
+  #
+  def nitems_while
+    num = 0
+    each{|item| yield(item) ? (num+=1) : break}
+    return num
+  end
+
+  # @example
+  #   enum.nitems_until {| obj | block }
+  #   => number of items
+  #
+  # @return [Integer] the number of leading elements for which block is false.
+  #
+  def nitems_until
+    num = 0
+    each{|item|
+      if yield(item)
+        break
+      else
+        num+=1
+      end
+    }
+    return num
+  end
+
+
+  # Calls block with two arguments, the item and its index, for each item in enum.
+  #
+  # @example
+  #   enum.nitems_with_index {|obj,i| block }
+  #    => number of items
+  #
+  # @return [Integer] the number of leading elements for which block is true.
+  #
+  def nitems_with_index
+    index = 0
+    each{|item| yield(item,index) ? (index+=1) : break}
+    return index
+  end
+
+end

data/lib/sixarm_ruby_ramp/enumerable/select.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+module Enumerable
+
+  # @example
+  #   enum.select_while {|obj| block }
+  #    => array
+  #
+  # @return [Array<Object>] the leading elements for which block is not false or nil.
+  #
+  def select_while
+    arr = []
+    each{|item| yield(item) ? (arr << item) : break}
+    return arr
+  end
+
+  # @example
+  #   enum.select_until {|obj| block }
+  #    => array
+  #
+  # @return [Array<Object>] the leading elements for which block is false or nil.
+  #
+  def select_until
+    arr = []
+    each{|item| yield(item) ? break : (arr << item)}
+    return arr
+  end
+
+  # Calls block with two arguments, the item and its index, for each item in enum.
+  #
+  # @example
+  #   enum.select_with_index {|obj,i| block }
+  #   => array
+  #
+  # @return [Array<Object> the leading elements for which block is not false or nil.
+  #
+  def select_with_index
+    index = 0
+    arr = []
+    each{|item|
+      if yield(item,index)
+        arr << item
+        index+=1
+      else
+        break
+      end
+    }
+    return arr
+  end
+
+end