sixarm_ruby_ramp 4.0.0 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15836defff39ae99045d8296deb36ef351e6029c
-  data.tar.gz: 7182b4e6c8df8418d04960e4a8d2d52bd2da9492
+  metadata.gz: a60c19644a07626f66aae272432fb95dc384d5f3
+  data.tar.gz: 289def436e9f4683c32d22baad4e42567aa69dbf
 SHA512:
-  metadata.gz: 288170ce6181ac89d943ec7abe6065ea67a6b64df274efb2038cb1db16566e88d84d861aef98ae19ee9a12888d3b8ca0e0b36d9df10dfb8a4e984bd3a4da8dd4
-  data.tar.gz: 8aa243bfb866ae9470bbb6bcb9cbbebb69466263bbded9be671cef88ff3ca2e9efaff35f788359418e2e69a2388114c98c781158388c2cfe30f586e9b504d570
+  metadata.gz: 3ba91da4fcfc8e1bfba53b6375623f2e9849c0f97f0629da4cecc6d29e7b96d38594709d82b117593566d8125cf61ab725dbb22f2949cd7880f5de1c3713e3cb
+  data.tar.gz: b8af5a9742251db4518c10fec767c61ee9e9ec1910e3e203aa9615b6a0c146efdfb18aa79d0793925a43ba4cc5b796b16cdbc87871465e2b7e5363fe1710e66d

data/README.md

@@ -1,4 +1,4 @@
-# SixArm.com » Ruby » <br> Ramp gem is a toolkit of Ruby base class extensions
+# SixArm.com » Ruby » <br> Ramp is a toolkit of Ruby base class extensions
 
 [![Code Climate](https://codeclimate.com/github/SixArm/sixarm_ruby_ramp.png)](https://codeclimate.com/github/SixArm/sixarm_ruby_ramp)
 [![Build Status](https://travis-ci.org/SixArm/sixarm_ruby_ramp.png)](https://travis-ci.org/SixArm/sixarm_ruby_ramp)
@@ -28,7 +28,7 @@ Install:
 
 Bundler:
 
-    gem "sixarm_ruby_ramp", "~>4.0.0"
+    gem "sixarm_ruby_ramp", ">=4.1.0", "<5"
 
 Require:
 
@@ -45,7 +45,7 @@ To enable high security for all our gems:
 
 To install with high security:
 
-    gem install sixarm_ruby_ramp --test --trust-policy HighSecurity
+    gem install sixarm_ruby_ramp --trust-policy HighSecurity
 
 
 ## Array
@@ -88,9 +88,11 @@ To install with high security:
 ## Enumerable
 
 * cartesian_product: return an array of all possible ordered tuples from arrays.
-* hash_by: convert the array to a hash by mapping each item to a key=>value pair.
-* index_by: convert the array to a hash by mapping each ite to a key=>item pair.
+* hash_by: convert the object to a hash by mapping each item to a key=>value pair.
+* index_by: convert the object to a hash by mapping each item to a key=>item pair.
 * 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.
 * 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
@@ -227,7 +229,9 @@ Extensions that help debug Ruby programs.
 
 ## Changes
 
-* 2014-12-17 4.0.0 Add `Pairable` methods; change semantics of `Hash#map_pair`
+* 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
 * 2013-08-19 3.0.1 Update for Code Climate, Travis CI, gem dependencies
 * 2013-08-18 3.0.0 Update to Ruby 2
 * 2012-09-01 2.1.7 Add Numeric#floor_precision
@@ -272,4 +276,4 @@ This license is for the included software that is created by SixArm;
 some of the included software may have its own licenses, copyrights,
 authors, etc. and these do take precedence over the SixArm license.
 
-Copyright (c) 2005-2012 Joel Parker Henderson
+Copyright (c) 2005-2015 Joel Parker Henderson

data/VERSION

@@ -1 +1 @@
-4.0.0
+4.1.0

data/lib/sixarm_ruby_ramp/enumerable.rb

@@ -2,13 +2,13 @@
 
 # Enumberable extensions
 
+require 'set'
 module Enumerable
 
-
   ########################################################################
   #
   #  typecast
-  #  
+  #
   ########################################################################
 
   # Convert an enumerable to a hash.
@@ -19,24 +19,42 @@ module Enumerable
   #   array=[[:a, :b],[:c, :d],[:e, :f]]
   #   array.to_h => {:a=>:b, :c=>:d, :e=>:f}
   #
-  # If a key occurs more than once, then this will automatically 
-  # convert the value to an array of the keys' values.
+  if !Enumerable.instance_methods.include?:to_h
+    def to_h
+      hash={}
+      each{|key,val|
+        hash[key]=val
+      }
+      return hash
+    end
+  end
+
+  # Convert an enumerable to a hash and merge values.
+  #
+  # @return [Hash<Object,Object>] a hash of the enumerable's items
+  #
+  # @example
+  #   array=[[:a, :b],[:c, :d],[:e, :f]]
+  #   array.to_h => {:a=>:b, :c=>:d, :e=>:f}
+  #
+  # If a key occurs more than once, then this will automatically
+  # merge the values to an array of the keys' values.
   #
   # @example
   #   array=[[:a,:b],[:a,:c],[:a,:d]]
   #   array.to_h => {:a=>[:b, :c, :d]}
-
-  def to_h
+  #
+  def to_h_merge
     hash={}
-    dupe={}
+    seen=Set.new
     each{|key,val|
       if hash.key? key
-        if dupe.key? key
+        if seen.include? key
           hash[key] << val
         else
           hash[key]=[hash[key]]
           hash[key] << val
-          dupe[key]=true
+          seen << key
         end
       else
         hash[key]=val
@@ -45,7 +63,6 @@ module Enumerable
     return hash
   end
 
-
   # Convert the enumerable to a hash by mapping each item to a pair [index ,item]
   #
   # @return [Hash<Integer,Object>] a hash of the enumerable's items
@@ -60,36 +77,32 @@ module Enumerable
   # From http://stackoverflow.com/questions/412771/cleanest-way-to-create-a-hash-from-an-array
   #
   # @see #hash_by
-
+  #
   def index_by
     inject({}) {|hash, elem| hash.merge!(yield(elem) => elem) }
   end
 
-
   # Convert the enumerable to a hash by mapping each item to a pair [item, new item]
   #
   # @return [Hash<Object,Object>] a hash of the enumerable's items
-  # 
+  #
   # @example
   #   strings = ["red","blue","green"]
   #   strings.hash_by{|a| [a.size, a.upcase]}
   #   => {3 => "RED", 4 => "BLUE", 5 => "GREEN"}
   #
   # @see #index_by
-
+  #
   def hash_by
     map{|item| yield(item)}.to_h
   end
 
-
-
   ########################################################################
   #
   #  map_to_xxx
-  #  
+  #
   ########################################################################
 
-
   # Map each item => item.id
   #
   # @return [Enumerable<Object>] an list of each item.id
@@ -101,12 +114,11 @@ module Enumerable
   # 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
@@ -122,12 +134,11 @@ module Enumerable
   # 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
@@ -139,46 +150,43 @@ module Enumerable
   # 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]  
+  #   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"]  
+  #   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
@@ -190,12 +198,11 @@ module Enumerable
   # 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
@@ -206,58 +213,54 @@ module Enumerable
   #   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
-  #  
+  #
   ########################################################################
-  
-  
+
   # @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 } 
+  #   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| 
+    each{|item|
       if yield(item,index)
         arr << item
         index+=1
@@ -268,25 +271,24 @@ module Enumerable
     return arr
   end
 
-
   ########################################################################
   #
   #  bisect
-  #  
+  #
   ########################################################################
 
   # @example
   #   enum.bisect {|obj| block}
   #   => array of positives, array of negatives
-  # 
+  #
   # @return [Array<Array<Object>] an array of two arrays:
   #    the first array is the elements for which block is true,
   #    the second array is the elements for which block is false or nil.
-
+  #
   def bisect
     accept=[]
     reject=[]
-    each{|item| 
+    each{|item|
      if yield(item)
       accept << item
      else
@@ -296,19 +298,18 @@ module Enumerable
     return accept,reject
   end
 
-
   ########################################################################
   #
   #  mutually exclusive?
-  #  
+  #
   ########################################################################
 
   # @example
   #   enum.mutex? {|obj| block}
   #   => true iff block is not false or nil, zero or one time
   #
-  # @return boolean true iff block is not false or nil, zero or one time 
-
+  # @return boolean true iff block is not false or nil, zero or one time
+  #
   def mutex?
     num = 0
     each{|item|
@@ -320,20 +321,18 @@ module Enumerable
     return true
   end
 
-
   ########################################################################
   #
   #  nitems
-  #  
+  #
   ########################################################################
-  
-  
+
   # @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|
@@ -345,30 +344,28 @@ module Enumerable
     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) 
+      if yield(item)
         break
       else
         num+=1
@@ -385,7 +382,7 @@ module Enumerable
   #    => 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}
@@ -402,19 +399,17 @@ module Enumerable
   # @return [String] concatenated string
   #
   # @see Array#join
-
+  #
   def join(*op)
    to_a.join(*op)
   end
 
-
   ########################################################################
   #
   #  set math
-  #  
+  #
   ########################################################################
 
-
   # @return [Boolean] true if this  _enum_ intersects another _enum_.
   #
   # A developer may want to optimize this implementation for
@@ -429,7 +424,6 @@ module Enumerable
     return enum.any?{|item| self.include?(item)}
   end
 
-
   # @return [Array] the cartesian product of the enumerations.
   #
   # @see http://en.wikipedia.org/wiki/Cartesian_product
@@ -443,7 +437,7 @@ module Enumerable
   # For our benchmarks, we also compared these:
   # - By William James, http://www.ruby-forum.com/topic/95519
   # - By Brian Schröäer, http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/151857
- 
+  #
   def self.cartesian_product(*enums)
     result = [[]]
     while [] != enums
@@ -458,12 +452,12 @@ module Enumerable
     result
   end
 
-
+  # Calculate the cartesian product.
+  #
   def cartesian_product(*enums)
     Enumerable.cartesian_product(self,*enums)
   end
 
-
   # Calculate the power set.
   #
   # @return [Array<Array<Object>>] the power set: an array with all subsets of the enum's elements.
@@ -475,7 +469,7 @@ module Enumerable
   # @example
   #   [1,2,3].power_set.sort
   #   =>  [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]
-
+  #
   def power_set
     inject([[]]){|c,y|r=[];c.each{|i|r<<i;r<<i+[y]};r}
   end

data/lib/sixarm_ruby_ramp/process.rb

@@ -19,7 +19,6 @@
 
 module Process
 
-
   # Get the 'ps' command as one long text string.
   #
   # This is typically useful for logging to a text file.
@@ -30,12 +29,11 @@ module Process
   #   => "0.0 bfd86194 21:14:51 ..."
   #
   # @return [String] lots of data about the process
-
+  #
   def self.ps(pid=Process.pid)
     `#{self.ps_command} #{pid.to_i}`
   end
 
-
   # Get the 'ps' command as a hash of keys and values.
   #
   # @return [Hash<String,String>] the ps command options as keys and values
@@ -46,7 +44,7 @@ module Process
   #   => {"cp"=>0.0, "esp"=>"bfd86194", "etime"=>"21:14:51", ...  }
   # -
   # OPTIMIZE: add dates, times
-
+  #
   PS_TO_I = %w(c egid egroup uid fgid lwp ni nlwp pgid pid ppid rgid rss ruid sid sgid suid)
   PS_TO_F = %w(cp pcpu pmem)
 
@@ -59,17 +57,16 @@ module Process
     return h
   end
 
-
   # Get the list of process alias keywords as typically defined by the shell.
   #
   # For example, a shell may consider "%cpu" and "pcpu" to be identical.
   #
   # @example
   #   Process::PS_ALIASES_DEFAULT
-  #   => {"%cpu"=>"pcpu", "sigmask"=>"blocked", "cls"=>"policy", ... }
+  #   => {"%cpu"=>"pcpu", "sigmask"=>"blocked", "class"=>"cls", ... }
   #
   # @return [Hash<String,String>] process keyword aliases
-
+  #
   PS_ALIASES_DEFAULT={
     '%cpu'=>'pcpu',
     '%mem'=>'pmem',
@@ -77,8 +74,8 @@ module Process
     'sigmask'=>'blocked',
     'sig_catch'=>'caught',
     'sigcatch'=>'caught',
-    'cls'=>'class',
-    'cls'=>'policy',
+    'class'=>'cls',
+    'policy'=>'pol',
     'cputime'=>'time',
     'gid'=>'egid',
     'group'=>'egroup',
@@ -104,46 +101,42 @@ module Process
     'session'=>'sid',
     'svgid'=>'sgid',
     'tt'=>'tname',
-    'tty'=>'tname', 
+    'tty'=>'tname',
     'vsz'=>'vsize'
   }
 
-
   # Get the list of process alias keywords as typically defined by the shell.
   #
   # For example, a shell may consider "%cpu" and "pcpu" to be identical.
   #
-  # @example                                                                          
+  # @example
   #   Process.ps_aliases
-  #   => {"%cpu"=>"pcpu", "sigmask"=>"blocked", "cls"=>"policy", ... }                                   
-  #                                                                                                                
-  # @return [Hash<String,String>] process keyword aliases 
-
+  #   => {"%cpu"=>"pcpu", "sigmask"=>"blocked", "class"=>"cls", ... }
+  #
+  # @return [Hash<String,String>] process keyword aliases
+  #
   def self.ps_aliases
     @@ps_aliases||=PS_ALIASES_DEFAULT
   end
 
-
   # Set the list of process alias keywords.
   #
   # For example, a shell may consider "%cpu" and "pcpu" to be identical.
   #
-  # @example                                                                          
-  #   Process::ps_aliases={ {"%cpu"=>"pcpu", "sigmask"=>"blocked", "cls"=>"policy" }
-  #   => {"%cpu"=>"pcpu", "sigmask"=>"blocked", "cls"=>"policy"}     
-  #        
-  # @param [Hash<String,String>] aliases                                 
+  # @example
+  #   Process::ps_aliases={ {"%cpu"=>"pcpu", "sigmask"=>"blocked", "class"=>"cls" }
+  #   => {"%cpu"=>"pcpu", "sigmask"=>"blocked", "class"=>"cls"}
+  #
+  # @param [Hash<String,String>] aliases
   # @return [Hash<String,String>] aliases
-
+  #
   def self.ps_aliases=(aliases)
     @@ps_aliases=aliases
   end
 
-
   # The list of process keywords.
 
-  PS_KEYS_DEFAULT=%w'blocked bsdtime c caught class cp egid egroup eip esp etime euid euser f fgid fgroup fuid fuser group ignored label lwp ni nlwp nwchan pending pcpu pgid pid pmem ppid pri psr rgid rgroup rss rtprio ruid ruser s sched sgi_p sgid sgroup sid sig size stackp start_time stat suid suser sz time tname tpgid vsize wchan'
-
+  PS_KEYS_DEFAULT=%w'%cpu %mem acflag acflg args blocked comm command cpu cputime etime f flags gid group inblk inblock jobc ktrace ktracep lim login logname lstart majflt minflt msgrcv msgsnd ni nice nivcsw nsignals nsigs nswap nvcsw nwchan oublk oublock p_ru paddr pagein pcpu pending pgid pid pmem ppid pri pstime putime re rgid rgroup rss ruid ruser sess sig sigmask sl start stat state stime svgid svuid tdev time tpgid tsess tsiz tt tty ucomm uid upr user usrpri utime vsize vsz wchan wq wqb wql wqr xstat'
 
   # Get the list of process keywords.
   #
@@ -152,30 +145,26 @@ module Process
   #   => ["blocked","group","pending","size"]
   #
   # @return [Array<String>] the list of process keywords.
-
-
+  #
   def self.ps_keys
     @@ps_keys||=PS_KEYS_DEFAULT
   end
 
- 
   # Set the list of process keywords.
   #
-  # @example 
+  # @example
   #   Process.ps_keys = ["blocked","group","pending","size"]
   #
   # @param [Array<String>] keywords
   # @return [Array<String>] keywords
-
+  #
   def self.ps_keys=(keys)
     @@ps_keys=keys
   end
 
-
   # The process command, i.e. what the sytem will call for the "ps" command.
 
-  PS_COMMAND_DEFAULT='ps h ww -o "'+self.ps_keys.join(',')+'"'
-
+  PS_COMMAND_DEFAULT="ps hww -o #{ps_keys.join(',')}"
 
   # Get the process command, i.e. what the sytem will call for the "ps" command.
   #
@@ -184,23 +173,21 @@ module Process
   #   => "ps h ww -o blocked,group,pending,size"
   #
   # @return [String] the process command
- 
+  #
   def self.ps_command
     @@ps_command||=PS_COMMAND_DEFAULT
   end
 
-
   # Set the process command, i.e. what the sytem will call for the "ps" command.
   #
   # @example
   #   Process.ps_command = "ps h ww -o blocked,group,pending,size"
   #
   # @param [String] the process command
-  # @return [String] the process command 
-
+  # @return [String] the process command
+  #
   def self.ps_command=(command)
     @@ps_command=command
   end
 
-
 end

data/test/sixarm_ruby_ramp_test/enumerable_test.rb

@@ -19,13 +19,23 @@ class EnumerableTest < Minitest::Test
 
 
   def test_to_h_with_unique_keys
-    a=[[:a,:b],[:c,:d],[:e,:f]] 
+    a=[[:a,:b],[:c,:d],[:e,:f]]
     assert_equal({:a=>:b, :c=>:d, :e=>:f}, a.to_h)
   end
 
   def test_to_h_with_duplicate_keys
-    a=[[:a,:b],[:a,:c],[:a,:d]] 
-    assert_equal({:a=>[:b, :c, :d]}, a.to_h)
+    a=[[:a,:b],[:a,:c],[:a,:d]]
+    assert_equal({:a=>:d}, a.to_h)
+  end
+
+  def test_to_h_merge_with_unique_keys
+    a=[[:a,:b],[:c,:d],[:e,:f]]
+    assert_equal({:a=>:b, :c=>:d, :e=>:f}, a.to_h_merge)
+  end
+
+  def test_to_h_merge_with_duplicate_keys
+    a=[[:a,:b],[:a,:c],[:a,:d]]
+    assert_equal({:a=>[:b, :c, :d]}, a.to_h_merge)
   end
 
   def test_index_by
@@ -36,7 +46,7 @@ class EnumerableTest < Minitest::Test
     assert_equal({3=>"RED",4=>"BLUE",5=>"GREEN"},RGB.hash_by{|x| [x.size,x.upcase]})
   end
 
-    
+
   ########################################################################
   #
   #  map
@@ -58,11 +68,11 @@ class EnumerableTest < Minitest::Test
   end
 
 
-  A = Mock.new('a') 
-  B = Mock.new('b') 
-  C = Mock.new('c') 
+  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
@@ -173,7 +183,7 @@ class EnumerableTest < Minitest::Test
   end
 
 
-  def test_nitems_while  
+  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')
@@ -190,7 +200,7 @@ class EnumerableTest < Minitest::Test
     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')
@@ -297,7 +307,3 @@ class EnumerableTest < Minitest::Test
   end
 
 end
-
-
-
-

data/test/sixarm_ruby_ramp_test/hash_test.rb

@@ -19,132 +19,6 @@ class HashTest < Minitest::Test
     assert_equal({'a' => 'x', 'b' => 'y', 'c' => 'z'}, h.sort_by_keys)
   end
 
-  def test_each_sort
-    out = []
-    h = {'c' => 'z', 'b' => 'y', 'a' => 'x'}
-    h.each_sort{|key,val| out << key.upcase; out << val.upcase}
-    assert_equal(['A','X','B','Y','C','Z'], out)
-  end
-
-  def test_each_sort_with_empty
-    out = []
-    h = {}
-    h.each_sort{|key,val| out << key.upcase; out << val.upcase}
-    assert_equal([], out)
-  end
-
-  def test_each_key_bang
-    actual = { "a" => "b", "c" => "d" }
-    expect = { "A" => "b", "C" => "d" }
-    actual.each_key! {|key| key.upcase }
-    assert_equal(expect,actual)
-  end
-
-  def test_each_key_bang_with_empty
-    actual = {}
-    expect = {}
-    actual.each_key! {|key| key.upcase }
-    assert_equal(expect,actual)
-  end
-
-  def test_each_pair_bang
-    actual = { "a" => "b", "c" => "d" }
-    expect = { "A" => "B", "C" => "D" }
-    actual.each_pair! {|key,value| [key.upcase, value.upcase] }
-    assert_equal(expect,actual)
-  end
-
-  def test_each_pair_bang_with_empty
-    actual = {}
-    expect = {}
-    actual.each_pair! {|key,value| [key.upcase, value.upcase] }
-    assert_equal(expect,actual)
-  end
-
-  def test_each_pair_bang_with_same_key_different_value
-    actual = { "a" => "b", "c" => "d" }
-    expect = { "a" => "B", "c" => "D" }
-    actual.each_pair! {|key,value| [key, value.upcase] }
-    assert_equal(expect,actual)
-  end
-
-  def test_each_pair_bang_with_same_key_same_value
-    actual = { "a" => "b", "c" => "d" }
-    expect = { "a" => "b", "c" => "d" }
-    actual.each_pair! {|key,value| [key, value] }
-    assert_equal(expect,actual)
-  end
-
-  def test_each_value_bang
-    actual = { "a" => "b", "c" => "d" }
-    expect = { "a" => "B", "c" => "D" }
-    actual.each_value! {|value| value.upcase }
-    assert_equal(expect,actual)
-  end
-
-  def test_each_value_bang_with_empty
-    actual = {}
-    expect = {}
-    actual.each_value! {|value| value.upcase }
-    assert_equal(expect,actual)
-  end
-
-  def test_map_key
-    h = {"a"=>"b"}
-    expect = {"A" => "b"}
-    actual = h.map_key{|key| key.upcase }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
-  def test_map_value
-    h = {"a"=>"b"}
-    expect = {"a" => "B"}
-    actual = h.map_value{|value| value.upcase }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
-  def test_map_value
-    h = {"a"=>"b"}
-    expect = {"A" => "B"}
-    actual = h.map_value{|key, value| key.upcase, value.upcase }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
-  def test_yield_pair
-    h = {"a"=>"b", "c"=>"d", "e"=>"f" }
-    expect=["ab","cd","ef"]
-    actual=h.yield_pair{|key,value| key+value }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
-  def test_yield_pair_with_empty
-    h = {}
-    expect=[]
-    actual=h.yield_pair{|key,value| key+value }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
-  def test_map_key
-    h={"a"=>"b", "c"=>"d", "e"=>"f" }
-    expect={"a1"=>"b", "c1"=>"d", "e1"=>"f" }
-    actual=h.map_pair{|key,value| "#{key}1" }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
-  def test_map_value
-    h={"a"=>"b", "c"=>"d", "e"=>"f" }
-    expect={"a"=>"b2", "c"=>"d2", "e"=>"f2" }
-    actual=h.map_pair{|key,value| "#{value}2" }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
-  def test_map_pair
-    h={"a"=>"b", "c"=>"d", "e"=>"f" }
-    expect={"a1"=>"b2", "c1"=>"d2", "e1"=>"f2" }
-    actual=h.map_pair{|key,value| ["#{key}1", "#{value}2" }.sort
-    assert_equal(expect,actual,h.inspect)
-  end
-
   def test_merge_recurse
     # Test with three kinds of items:
     #   * same key => same value #=> must stay the same

data/test/sixarm_ruby_ramp_test/process_test.rb

@@ -62,6 +62,5 @@ class ProcessTest < Minitest::Test
    assert_equal(['a','b','c'], Process.ps_keys)
    Process.ps_keys=Process::PS_KEYS_DEFAULT
  end
-  
-end
 
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sixarm_ruby_ramp
 version: !ruby/object:Gem::Version
-  version: 4.0.0
+  version: 4.1.0
 platform: ruby
 authors:
 - SixArm
@@ -30,7 +30,7 @@ cert_chain:
   sWRVEyjnjnNuAeLP9zv43IDXjS22L2efhap7IOinYjcecpfXJgQaU+6BFAY4sdkQ
   S1STYSfs3qySBxxAeEyZTw==
   -----END CERTIFICATE-----
-date: 2014-12-18 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sixarm_ruby_rexml
@@ -174,10 +174,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
-summary: SixArm.com » Ruby » Ramp gem provides base extensions to ruby classes.
+summary: SixArm.com » Ruby » Ramp provides base extensions to ruby classes.
 test_files:
 - test/sixarm_ruby_ramp_test.rb
 - test/sixarm_ruby_ramp_test/array_test.rb
@@ -203,3 +203,4 @@ test_files:
 - test/sixarm_ruby_ramp_test/xml_test.rb
 - test/sixarm_ruby_ramp_test/yaml_test.rb
 - test/sixarm_ruby_ramp_test/io_test.txt
+has_rdoc: true