oha_extensions 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oha_extensions.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Bookrenter/Rafter
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# OhaExtensions
+
+Gem adds convenience methods listed below to Object, Hash and Array classes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'oha_extensions'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install oha_extensions
+
+## Usage
+
+***
+### Object extension methods:
+
+* - has_additional_functionality_in(*files)
+* - send_if_respond_to(method, *args)
+
+***
+### Hash extension methods:
+
+* - sum(&block)
+* - increment(key, amount=1, &block)
+* - percent(key, &block)
+* - assert_required_keys(*required_keys)
+* - select_pairs(&block)
+* - Hash.from_xml_string(s, options = {})
+
+***
+### Array extension methods:
+
+* - stats
+* - average
+* - process_in_batches(batch_size)
+* - to_hash_with_keys(options={}, &block)
+* - to_lookup_hash()
+* - to_identity_hash(id_proc = nil)
+* - rand
+* - next
+* - shuffle
+* - delete(first_element)
+
+***
+# Credits
+
+[Oha_extensions](https://github.com/bkr/oha_extensions) is maintained by [Bookrenter/Rafter](http://github.com/bkr) and is funded by [BookRenter.com](http://www.bookrenter.com "BookRenter.com").
+
+![BookRenter.com Logo](http://assets0.bookrenter.com/images/header/bookrenter_logo.gif "BookRenter.com")
+
+# Copyright
+
+Copyright (c) 2012 Bookrenter.com. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/oha_extensions/array_extension.rb

@@ -0,0 +1,111 @@
+#This class adds the stats methods to array which computes sum, min, max, med, mean, count, std deviation
+module ArrayExtension
+  #Given an array of values it returns the mean, median, min, max in a hash
+  #*array*:: An array whose values are used to calculate the various statistics
+  #returns:: A hash with the following keys
+  #* sum
+  #* mean
+  #* min
+  #* max
+  #* median
+  #* count (number of items in the array)
+  #<b> All keys will => 0, if the array is empty</b>
+  #<b> The array is automatically sorted when you call stats</b>
+  def stats
+    return {:sum => 0, :mean => 0, :min => 0, :max => 0, :median => 0, :std_dev => 0, :count => 0} if empty?
+    out = Hash.new
+    sort!
+    out[:sum] = inject(0){|sum, element| sum + element}
+    out[:mean] = out[:sum]/size.to_f
+    out[:min] = min
+    out[:max] = max
+    out[:median] = size % 2 == 0 ? (self[size/2] + self[size/2 - 1]) / 2.0 : self[size/2]
+    out[:count] = size
+    if size > 1
+      out[:std_dev] = Math.sqrt((inject(0){|sum_square, element| sum_square += element * element} - out[:sum]*out[:mean]) / (size - 1)) 
+    else
+      out[:std_dev] = 0
+    end
+    return out
+  end
+
+  #returns:: The average value of the elements in the array
+  def average
+    return stats[:sum] / size.to_f
+  end
+  
+  #Divides the calling array into +batch_size+ batches, (the last batch could be less than +batch_size+ if the calling array.size % batch_size != 0) and yields each batch
+  #*batch_size*:: The number elements to yield to the given block
+  #Example:
+  # (1..30).to_a.process_in_batches(10) do |batch|
+  #   p batch
+  # end
+  #
+  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+  # [11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
+  # [21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
+  def process_in_batches(batch_size)
+    raise ArgumentError if batch_size.nil? or batch_size <= 0
+    
+    index = 0
+    
+    while index < self.size
+      yield self[index...index+batch_size]
+      index += batch_size
+    end
+  end
+  
+  def to_hash_with_keys(options={}, &block)
+    options = {:value_acts_as_array => false}.merge(options)
+    return self.inject(Hash.new) do |injection, var| 
+      key = block.call(var)
+      if options[:value_acts_as_array]
+        if injection[key].nil?
+          injection[key] = [var]
+        else
+          injection[key] << var
+        end
+      else
+        injection[key] = var
+      end
+      
+      injection
+    end
+  end
+  
+  def to_lookup_hash()
+    h = Hash.new
+    self.each do |e|
+      h[e] = block_given? ? yield(e) : true
+    end
+    return h
+  end
+  
+  # useful for creating in memory mappings of ActiveRecord models
+  def to_identity_hash(id_proc = nil)
+    h = Hash.new
+    self.each do |e|
+      key = id_proc ? id_proc.call(e) : (block_given? ? yield(e) : e.id)
+      h[key] = e
+    end
+    return h
+  end
+  
+  def rand
+    self[Kernel.rand(self.length)]
+  end
+  
+  def next
+    @next_index = @next_index.nil? ? 0 : (@next_index + 1) % self.size
+    return self[@next_index]
+  end
+  
+  def shuffle
+    self.sort_by{ Kernel.rand }
+  end
+  
+  def delete_first(element)
+    index = self.index(element)
+    self.delete_at(index) if index
+  end
+end

data/lib/oha_extensions/hash_extension.rb

@@ -0,0 +1,159 @@
+require 'nokogiri'
+
+module HashExtension
+
+  #returns:: The sum of each element in the hash
+  #An optional block can be given which takes two parameters, key and value for each element in the hash.  The return value of the block is summed for each element in the hash.
+  #If the result of sum is nil, 0 is returned
+  #Examples:
+  # {:a => 1, :b => 2, :c => 3}.sum #returns 6
+  # {:a => ['foo', 1], :b => ['monkey', 2], :c => ['bunny', 3]}.sum { |k, v| v[1] } #returns 6
+  # {:a => ['foo', 1], :b => ['monkey', 2], :c => ['bunny', 3]}.sum { |k, v| v } #returns ['foo', 1, 'monkey', 2, 'bunny', 3] <b>Order of elements is NOT guaranteed</b>
+  # {}.sum #returns 0
+  def sum(&block)
+    block = lambda { |k, v| v } if block.nil?
+    
+    total = nil
+    
+    each do |k, v| 
+      total.nil? ? total = block.call(k, v) : total += block.call(k, v)
+    end
+
+    return total || 0
+  end
+
+  #Increments the value pointed to from the key
+  #If the key is nil then it is initialized to amount
+  #An optional block may be given, which is passed +key+, and each key in the hash.  The block should return true for the key you wish to increment.
+  #Examples:
+  # h = Hash.new #h['foo'] = nil
+  # h.increment('foo') #1
+  # h.increment('foo') #2
+  #
+  # age = Hash.new
+  # age['0 - 18'] = 0
+  # age['18 - 24'] = 0
+  # age['24 - 99999'] = 0
+  # 
+  # #increment the key where 18 is in range of the min and max
+  # age.increment(18) do |v, e|
+  #   min, max = e.split(' - ')
+  #   v >= min.to_i && v < max.to_i
+  # end
+  # 
+  # assert_equal(0, age['0 - 18'])
+  # assert_equal(1, age['18 - 24'])
+  # assert_equal(0, age['24 - 99999'])
+  def increment(key, amount=1, &block)
+    if block.nil?
+      key_to_use = key
+    else
+      key_to_use = self.keys.detect { |k| block.call(key, k) } 
+    end
+    
+    if self[key_to_use].nil?
+      self[key_to_use] = amount
+    else
+      self[key_to_use] += amount
+    end
+  end
+  
+  #returns:: What percent of the sum of the hash is the value for +key+
+  #Examples:
+  # {:a => 1, :b => 2, :c => 3, :d => 4}.percent(:c) #0.30 because 3 is 30% of 10 and 10 is the total of the hash
+  # {:a => ['foo', 1], :b => ['monkey', 2], :c => ['bunny', 3], :d => ['kitty', 4]}.percent(:c) { |e| e[1] } #0.30 
+  # {:a => 0} #0.0, if the sum of the hash is 0, then 0 is returned
+  def percent(key, &block)
+    block = lambda { |v| v } if block.nil?
+    sum_block = lambda { |k, v| block.call(v) }
+    
+    total = self.sum(&sum_block)
+    return 0 if total == 0
+    return block.call(self[key]) / total.to_f
+  end
+  
+  #If keys does not include everything in required_keys, throw an ArgumentError.
+  #
+  #*required_keys*: list of keys that must be present for the hash (if a required key hashes to nil, but is passed it is still valid.
+  #Example:: 
+  #  {:happy => nil}.assert_required_keys(:happy) #will not raise error
+  #required_keys may be passed as strings, symbols or both.  Likewise the keys in the has maybe a strings or symbols or both.
+  #Example::
+  #  {:happy => 'bunny'}.assert_required_keys(:happy) #will not raise error
+  #  {'happy' => 'bunny'}.assert_required_keys(:happy) #will not raise error  
+  #====Raises
+  #*ArgumentError*:: if a required key is missing  
+  def assert_required_keys(*required_keys)
+    keys_not_passed = [required_keys].flatten.map { |required_key| required_key.to_s } - self.stringify_keys.keys
+    raise(ArgumentError, "The following keys were nil when expected not to be: #{keys_not_passed.join(", ")}") unless keys_not_passed.empty?
+  end
+  alias_method :must_include, :assert_required_keys
+  
+  
+  def select_pairs(&block)
+    return Hash[*self.select(&block).flatten]
+  end
+  
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    # Generates a hash from XML. This is specifically being used generate JSON for the API. It makes the assumption that elements contain arrays
+    #  must be explicitly specified.  Assuming otherwise generates larger JSON.
+    #  This also utilizes XML attributes which Hash.from_xml ignores.
+    def from_xml_string(s, options = {})
+      options = {:array_nodes => [], :parent_array_nodes => []}.merge(options)
+      return node_to_hash(Nokogiri.parse(s).children.first, options)
+    end
+  
+    private
+  
+    def node_to_hash(node, options)
+      children = node.children.select {|n| n.element?}
+      node_name = node.name
+      hash = {}
+    
+      if ! node.attributes.empty?
+        hash[node_name] = {}
+        node.attributes.each do |attr_name, attr_value|
+          hash[node_name][attr_name] = attr_value.to_s
+        end
+        content_hash = hash[node_name]
+        # this is the name of the key for the sub elements, could also use something like 'content'
+        node_name = node.name
+      else
+        content_hash = hash
+      end
+
+      if children.empty?
+        nc = node.children.detect{|n| n.text?}
+        content_hash[node_name] = nc.nil? ? nil : nc.text
+      
+        if options[:parent_array_nodes].include?(node_name)
+          content_hash[node_name] = []
+        end
+      else
+        children_hash = children.inject({}) do |acc, node|
+          child_hash = node_to_hash(node, options)
+          child_hash.each do |key, value|
+            if options[:array_nodes].include?(key)
+              acc[key] = [] if acc[key].nil?
+              acc[key] << value
+            else
+              acc[key] = value if acc[key].nil?
+            end
+          end
+          acc
+        end
+        content_hash[node_name] = children_hash
+      
+        if options[:parent_array_nodes].include?(node_name)
+          content_hash[node_name] = children_hash.values.flatten
+        end
+      end
+    
+      return hash
+    end
+  end
+end

data/lib/oha_extensions/object_extension.rb

@@ -0,0 +1,11 @@
+module ObjectExtension
+  def has_additional_functionality_in(*files)
+    files.each do |file|
+      require_dependency "#{name.underscore}_extensions/#{file}"
+    end
+  end
+  
+  def send_if_respond_to(method, *args)
+    self.respond_to?(method) ? self.send(method, *args) : nil
+  end
+end

data/lib/oha_extensions/version.rb

@@ -0,0 +1,3 @@
+module OhaExtensions
+  VERSION = "0.0.2"
+end

data/lib/oha_extensions.rb

@@ -0,0 +1,17 @@
+require "oha_extensions/version"
+require "oha_extensions/hash_extension"
+require "oha_extensions/object_extension"
+require "oha_extensions/array_extension"
+
+class Array
+  include ArrayExtension
+end
+
+class Hash
+  include HashExtension
+end
+
+class Object
+  include ObjectExtension
+end
+

data/oha_extensions.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/oha_extensions/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Bookrenter/Rafter"]
+  gem.email         = ["cp@bookrenter.com"]
+  gem.description   = %q{Extends Object, Hash and Array classes with additional methods.}
+  gem.summary       = %q{Additional methods for Object, Hash, Array classes.}
+  gem.homepage      = "https://github.com/bkr/oha_extensions"
+
+  gem.add_development_dependency('mocha', '> 0')
+  gem.add_development_dependency('shoulda', "> 0")
+  gem.add_dependency('nokogiri', '> 0')
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "oha_extensions"
+  gem.require_paths = ["lib"]
+  gem.version       = OhaExtensions::VERSION
+end

data/test/oha_extensions/array_extension_test.rb

@@ -0,0 +1,373 @@
+require "test_helper"
+
+class ArrayExtensionTest < Test::Unit::TestCase
+  
+  def setup
+  end
+  
+  def test_array_stats
+    #= Test Empty
+    stats = [].stats
+    stats.values.all? { |e| e == 0 }
+    
+    #== Only 0s
+    stats = Array[0].stats
+    assert_equal 0, stats[:sum]
+    assert_equal 0, stats[:mean]
+    assert_equal 0, stats[:min]
+    assert_equal 0, stats[:max] 
+    assert_equal 0, stats[:median]
+    assert_equal 1, stats[:count]
+    assert_equal 0, stats[:std_dev]
+    
+    stats = Array[0, 0, 0].stats
+    assert_equal 0, stats[:sum]
+    assert_equal 0, stats[:mean]
+    assert_equal 0, stats[:min]
+    assert_equal 0, stats[:max] 
+    assert_equal 0, stats[:median]
+    assert_equal 3, stats[:count]
+    assert_equal 0, stats[:std_dev]
+    
+    #== Integers
+    #==== simple in order (even size)
+    stats = Array[0, 1, 2, 3].stats
+    assert_equal 6, stats[:sum]
+    assert_in_delta(1.5, stats[:mean], 2 ** -20)
+    assert_equal 0, stats[:min]
+    assert_equal 3, stats[:max] 
+    assert_in_delta(1.5, stats[:median], 2 ** -20)
+    assert_equal 4, stats[:count]
+    assert_in_delta(1.29,stats[:std_dev], 0.1)
+    
+    #==== simple out of order (odd size)
+    stats = Array[0, 1, 2, 3, 1].stats
+    assert_equal 7, stats[:sum]
+    assert_in_delta(1.4, stats[:mean], 2 ** -20)
+    assert_equal 0, stats[:min]
+    assert_equal 3, stats[:max] 
+    assert_in_delta(1, stats[:median], 2 ** -20)
+    assert_equal 5, stats[:count]
+    assert_in_delta(1.14,stats[:std_dev], 0.1)
+    
+    #==== 0 sum with negatives
+    stats = Array[-99, 99, 0].stats
+    assert_equal 0, stats[:sum]
+    assert_in_delta(0.0, stats[:mean], 2 ** -20)
+    assert_equal -99, stats[:min]
+    assert_equal 99, stats[:max] 
+    assert_in_delta(0.0, stats[:median], 2 ** -20)
+    assert_equal 3, stats[:count]
+    assert_in_delta(99, stats[:std_dev], 0.1)
+    
+    #==== Random
+    a = rand(1000) - rand(1000)
+    b = rand(1000) - rand(1000)
+    c = rand(1000) - rand(1000)
+    input = [a, b, c]
+    stats = input.stats
+    assert_in_delta((a + b + c), stats[:sum], 2 ** -20)
+    assert_in_delta((a + b + c)/3.0, stats[:mean], 2 ** -20)
+    assert_equal input.min, stats[:min]
+    assert_equal input.max, stats[:max] 
+    assert_in_delta(input[1], stats[:median], 2 ** -20)
+    assert_equal 3, stats[:count]
+    
+    #== Floats
+    #==== simple in order (even size)
+    stats = Array[0.0, 1.4, 2.567, 3.8].stats
+    assert_in_delta(7.767, stats[:sum], 2 ** -20)
+    assert_in_delta(1.94175, stats[:mean], 2 ** -20)
+    assert_in_delta(0.0, stats[:min], 2 ** -20)
+    assert_in_delta(3.8, stats[:max] , 2 ** -20)
+    assert_in_delta(1.9835, stats[:median], 2 ** -20)
+    assert_equal 4, stats[:count]
+    assert_in_delta(1.62, stats[:std_dev], 0.1)
+    
+    #==== simple out of order (odd size)
+    stats = Array[0.0, 1.4, 2.567, 3.8, 1.378].stats
+    assert_in_delta(9.145, stats[:sum], 2 ** -20)
+    assert_in_delta(1.829, stats[:mean], 2 ** -20)
+    assert_in_delta(0.0, stats[:min], 2 ** -20)
+    assert_in_delta(3.8, stats[:max] , 2 ** -20)
+    assert_in_delta(1.4, stats[:median], 2 ** -20)
+    assert_equal 5, stats[:count]
+    assert_in_delta(1.428, stats[:std_dev], 0.1)
+    
+    
+    #==== 0 sum with negatives
+    stats = Array[-99.88, 99.88, 0].stats
+    assert_in_delta(0.0, stats[:sum], 2 ** -20)
+    assert_in_delta(0.0, stats[:mean], 2 ** -20)
+    assert_in_delta(-99.88, stats[:min], 2 ** -20)
+    assert_in_delta(99.88, stats[:max] , 2 ** -20)
+    assert_in_delta(0.0, stats[:median], 2 ** -20)
+    assert_equal 3, stats[:count]
+    assert_in_delta(99.88, stats[:std_dev], 0.1)
+    
+    
+    #==== Random
+    a = rand() * rand(1000) - rand() * rand(1000)
+    b = rand() * rand(1000) - rand() * rand(1000)
+    c = rand() * rand(1000) - rand() * rand(1000)
+    input = [a, b, c]
+    stats = input.stats
+    assert_in_delta((a + b + c), stats[:sum], 2 ** -20)
+    assert_in_delta((a + b + c)/3.0, stats[:mean], 2 ** -20)
+    assert_in_delta(input.min, stats[:min], 2 ** -20)
+    assert_in_delta(input.max, stats[:max] , 2 ** -20)
+    assert_in_delta(input[1], stats[:median], 2 ** -20)
+    assert_equal 3, stats[:count]
+    
+    #== Mixed
+    a = rand() * rand(1000) - rand() * rand(1000)
+    b = rand() * rand(1000) - rand() * rand(1000)
+    c = rand() * rand(1000) - rand() * rand(1000)
+    d = rand(1000) - rand(1000)
+    e = rand(1000) - rand(1000)
+    f = rand(1000) - rand(1000)
+    input = [a, b, c, d, e, f]
+    stats = input.stats
+    assert_in_delta((a + b + c + d + e + f), stats[:sum], 2 ** -20)
+    assert_in_delta((a + b + c + d + e + f)/6.0, stats[:mean], 2 ** -20)
+    assert_in_delta(input.min, stats[:min], 2 ** -20)
+    assert_in_delta(input.max, stats[:max] , 2 ** -20)
+    assert_in_delta((input[3] + input[2])/2.0, stats[:median], 2 ** -20)
+    assert_equal 6, stats[:count]
+  end
+
+  def test_average
+    assert_equal 0, [-1, 0, 1].average
+    assert_equal 1, [1].average
+    assert_equal 46.5, [10, 45, 34, 97].average
+    assert_equal 66.065, [34.7, 97.43].average
+    
+    a = rand() * rand(1000) - rand() * rand(1000)
+    b = rand() * rand(1000) - rand() * rand(1000)
+    c = rand() * rand(1000) - rand() * rand(1000)
+    d = rand(1000) - rand(1000)
+    e = rand(1000) - rand(1000)
+    f = rand(1000) - rand(1000)
+    input = [a, b, c, d, e, f]
+    assert_in_delta((a + b + c + d + e + f)/6.0, input.average, 2 ** -20)
+  end
+  
+  #======================================================================
+  #====================== Test process_in_batches =======================
+  #======================================================================
+  def setup_process_in_batches_tests
+    @array = %W[one two three four five six seven eight nine ten]
+    @empty = Array.new
+  end
+
+  def test_process_in_batches_missing_batch_size_argument
+    setup_process_in_batches_tests
+    assert_raise(ArgumentError) { @array.process_in_batches }
+  end
+  
+  def test_process_in_batches_empty_array
+    setup_process_in_batches_tests
+    assert_nil @empty.process_in_batches(3)
+  end
+
+  def test_process_in_batches_batch_size_less_than_or_equal_to_zero
+    setup_process_in_batches_tests
+    assert_raise(ArgumentError) { @array.process_in_batches(0) }
+    assert_raise(ArgumentError) { @array.process_in_batches(-3) }
+  end
+  
+  def test_process_in_batches_batch_size_less_than_array_size
+    setup_process_in_batches_tests
+
+    #should get three batchs; two with 4 elements and one with 2 elements
+    batch_size = 4
+    batch_cnt = 0
+    
+    @array.process_in_batches(batch_size) do |batch|
+      case batch_cnt
+      when 0, 1
+        assert_equal batch_size, batch.size
+      when 2
+        assert_equal 2, batch.size
+      end
+      batch_cnt += 1
+    end
+
+    assert_equal 3, batch_cnt
+  end
+  
+  def test_process_in_batches_batch_size_greater_than_array_size
+    setup_process_in_batches_tests
+
+    #should get one batch only 
+    batch_size = @array.size + 1
+    batch_cnt = 0
+      
+    @array.process_in_batches(batch_size) do |batch|
+      batch_cnt += 1
+      assert_equal @array.size, batch.size
+    end
+    assert_equal 1, batch_cnt
+  end
+  
+  def test_process_in_batches_batch_size_equal_to_array_size
+    setup_process_in_batches_tests
+
+    #should get one batch only
+    batch_size = @array.size
+    batch_cnt = 0
+    
+    @array.process_in_batches(batch_size) do |batch|
+      batch_cnt += 1
+      assert_equal @array.size, batch.size
+    end
+    assert_equal 1, batch_cnt
+  end  
+  #======================================================================
+  #==================== End test process_in_batches =====================
+  #======================================================================
+  
+  def test_to_hash_with_keys
+    assert_equal({}, [].to_hash_with_keys { |e| e })
+    
+    actual = [1, 2, 3, 4].to_hash_with_keys { |e| e + 10 }
+    expected = {11 => 1, 12 => 2, 13 => 3, 14 => 4}
+    assert_equal(expected, actual)
+    
+    actual = [{:msg => 'apples'}, {:msg => 'foos'}, {:msg => 'cows'}].to_hash_with_keys { |e| "i_like_#{e[:msg]}".to_sym }
+    expected = { :i_like_apples => {:msg => 'apples'}, :i_like_foos => {:msg => 'foos'}, :i_like_cows => {:msg => 'cows'} }
+    assert_equal(expected, actual)
+  end
+  
+  def test_to_lookup_hash
+    assert_equal({}, [].to_lookup_hash)
+    assert_equal({1 => true, 2 => true, 3 => true}, [1, 2, 3].to_lookup_hash)
+    assert_equal({1 => 2, 2 => 3, 3 => 4}, [1, 2, 3].to_lookup_hash {|e| e + 1})
+  end
+  
+  context "to_identity_hash" do
+    should "use id attribute as key with no args" do
+      o1 = mock
+      o1.stubs(:id).returns(123)
+      o2 = mock
+      o2.stubs(:id).returns(456)
+      o3 = mock
+      o3.stubs(:id).returns(789)
+      assert_equal({o1.id => o1, o2.id => o2, o3.id => o3}, [o1, o2, o3].to_identity_hash)
+    end
+    
+    should "allow symbol proc as the first argument for key creation" do
+      o1 = mock
+      o1.stubs(:foo).returns(123)
+      o2 = mock
+      o2.stubs(:foo).returns(456)
+      o3 = mock
+      o3.stubs(:foo).returns(789)
+      assert_equal({o1.foo => o1, o2.foo => o2, o3.foo => o3}, [o1, o2, o3].to_identity_hash(&:foo))
+    end
+    
+    should "allow proc to specify key" do
+      o1 = mock
+      o1.stubs(:foo).returns(123)
+      o2 = mock
+      o2.stubs(:foo).returns(456)
+      o3 = mock
+      o3.stubs(:foo).returns(789)
+      assert_equal({o1.foo => o1, o2.foo => o2, o3.foo => o3}, [o1, o2, o3].to_identity_hash {|e| e.foo})
+    end
+  end
+  
+
+  context "rand" do
+    context "empty array" do
+      setup do
+        @execute_result = [].rand
+      end
+      
+      should "be nil" do
+        assert_nil(@execute_result)
+      end
+    end
+    
+    context "array with 1 item" do
+      setup do
+        @execute_result = ['foo'].rand
+      end
+      
+      should "be just that item" do
+        assert_equal 'foo', @execute_result
+      end
+    end
+    
+    context "array with multiple items" do
+      setup do
+        @array = ['a', 'b', 'c']
+        @execute_result = @array.rand
+      end
+      
+      should "return an item from the array" do
+        assert_contains(@array, @execute_result)
+      end
+    end
+  end
+  
+  context "next" do
+    context "empty array" do
+      should "return nil" do
+        assert_equal nil, [].next
+      end
+    end
+    
+    context "single element" do
+      setup do
+        @element = 1
+        @array = [@element]
+      end
+      
+      should "always return only element" do
+        assert_equal @element, @array.next
+        assert_equal @element, @array.next
+        assert_equal @element, @array.next
+      end
+    end
+    
+    context "multiple elements" do
+      setup do
+        @array = [1, 'a']
+      end
+      
+      should "loop" do
+        assert_equal 1, @array.next
+        assert_equal 'a', @array.next
+        assert_equal 1, @array.next
+      end
+    end
+  end
+  
+  context "delete_first" do
+    context "empty array" do
+      should "return nil" do
+        assert_equal nil, [].delete_first("a")
+      end
+    end
+    
+    context "multiple elements" do
+      setup do
+        @ary = [1,'a',3,'a']
+      end
+      
+      should "delete first element found" do
+        deleted = @ary.delete_first('a')
+        assert_equal 'a', deleted
+        assert_equal [1, 3, 'a'], @ary
+      end
+      
+      should "return nil if nothing found" do
+        deleted = @ary.delete_first('b')
+        assert_equal nil, deleted
+        assert_equal [1, 'a', 3, 'a'], @ary
+      end
+    end
+  end
+  
+end

data/test/oha_extensions/hash_extension_test.rb

@@ -0,0 +1,211 @@
+require "test_helper"
+
+class HashExtensionTest < Test::Unit::TestCase
+  
+  def setup
+    @simple = {:a => 1, :b => 2, :c => 3}
+    @simple_sum = 6
+    
+    @zeros = {:zero => 0, :another_zero => 0, :yet_another_zero => 0}
+    
+    @integers = {:an_integer => 48, :an_negative => -77, :zero => 0}
+    @integers_sum = -29
+    
+    @floats = {:a_float => 24.5, :a_negative_float => -74.8, :zero => 0.0}
+    @floats_sum = -50.3
+
+    @mixed = @integers.merge(@floats)
+    @mixed_sum = @integers_sum + @floats_sum        
+  end
+  
+  def test_empty
+    assert_equal 0, {}.sum
+    assert_equal 0, {}.sum { |k, v| v }
+  end
+  
+  def test_zeros
+    assert_equal 0, @zeros.sum
+  end
+  
+  def test_integers
+    assert_equal @integers_sum, @integers.sum
+  end
+
+  def test_floats
+    assert_equal @floats_sum, @floats.sum
+  end    
+  
+  def test_mixed
+    assert_equal @mixed_sum, @mixed.sum
+  end
+  
+  def test_block
+    test = {:a => ['foo', 48], :b => ['monkey', -99], :c => ['bunny', 34]}
+    
+    #sum index 1 of each element
+    assert_equal -17, test.sum { |k, v| v[1] }
+
+    #sum index 0
+    assert_match 'foo', test.sum { |k, v| v[0] }
+    assert_match 'monkey', test.sum { |k, v| v[0] }
+    assert_match 'bunny', test.sum { |k, v| v[0] }
+    
+    #sum key
+    assert_match 'a', test.sum { |k, v| k.to_s }
+    assert_match 'b', test.sum { |k, v| k.to_s }
+    assert_match 'c', test.sum { |k, v| k.to_s }
+    
+    #sum entire array 
+    assert_equal true, test.sum { |k, v| v }.any? { |e| e == 'foo' }
+    assert_equal true, test.sum { |k, v| v }.any? { |e| e == 'monkey' }
+    assert_equal true, test.sum { |k, v| v }.any? { |e| e == 'bunny' }
+    assert_equal true, test.sum { |k, v| v }.any? { |e| e == 48 }
+    assert_equal true, test.sum { |k, v| v }.any? { |e| e == -99 }
+    assert_equal true, test.sum { |k, v| v }.any? { |e| e == 34 }
+    
+    #sum manipulating value
+    assert_equal 0, test.sum { |k, v| v[1] - v[1] }
+    assert_equal -34, test.sum { |k, v| v[1] * 2 }
+    assert_equal [], test.sum { |k, v| v - v }
+  end
+  
+  
+  def test_increment
+    h = Hash.new
+    
+    assert_equal nil, h['foo']
+    assert_equal 1, h.increment('foo')
+    assert_equal 2, h.increment('foo')
+    
+    h = Hash.new 
+    assert_equal 10, h.increment(['foo'], 10)
+    assert_equal 20, h.increment(['foo'], 10)
+    
+    age = Hash.new
+    age['0 - 18'] = 0
+    age['18 - 24'] = 0
+    age['24 - 99999'] = 0
+    
+    age.increment(18) do |v, e|
+      min, max = e.split(' - ')
+       v >= min.to_i && v < max.to_i
+    end
+    
+    assert_equal(0, age['0 - 18'])
+    assert_equal(1, age['18 - 24'])
+    assert_equal(0, age['24 - 99999'])
+  end
+  
+  def test_percent
+    h = {'a' => 25, 'b' => 50, 'c' => 25}
+    assert_in_delta(0.25, h.percent('a'), 2 ** -20)
+    assert_in_delta(0.50, h.percent('b'), 2 ** -20)
+    assert_in_delta(0.25, h.percent('c'), 2 ** -20)
+    
+    h = {'hot' => ['steamy', 3], 'hotter' => ['smoking', 4], 'hottest' => ['global warming', 7]}
+    assert_in_delta(0.21428571428571428571, h.percent('hot') { |v| v[1] }, 2 ** -20)
+    assert_in_delta(0.28571428571428571428, h.percent('hotter') { |v| v[1] }, 2 ** -20)
+    assert_in_delta(0.5, h.percent('hottest') { |v| v[1] }, 2 ** -20)
+
+    assert_raise(NoMethodError) { h.percent('cold') }
+    
+    h = {'a' => 0}
+    assert_equal 0, h.percent('a')    
+  end
+  
+  context ".select_pairs" do
+    context "empty" do
+      setup do
+        @hash = {}
+        @execute_result = @hash.select_pairs { |k, v| v % 2 == 0 }
+      end
+      
+      should "return empty hash" do
+        assert_equal({}, @execute_result)
+      end      
+    end
+    
+    context "populated" do
+      setup do
+        @hash = {'A' => 1, 'B' => 2}
+        @execute_result = @hash.select_pairs { |k, v| v % 2 == 0 }
+      end
+      
+      should "return hash where values are even" do
+        assert_equal({'B' => 2}, @execute_result)
+      end
+    end
+  end
+
+  context ".from_xml_string" do
+    should "handle empty root node" do
+      xml = '<a />'
+      expected = {'a' => nil}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    should "handle empty string root node" do
+      xml = '<a></a>'
+      expected = {'a' => nil}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    should "handle text string root node" do
+      xml = '<a>text</a>'
+      expected = {'a' => 'text'}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    should "handle attributes in root node" do
+      xml = '<a a1="aye1" />'
+      expected = {'a' => {'a1' => 'aye1', 'a' => nil}}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    should "handle element nodes" do
+      xml = '<a><b>value</b></a>'
+      expected = {'a' => {'b' => 'value'}}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    should "handle empty element nodes" do
+      xml = '<a><b/><c/></a>'
+      expected = {'a' => {'b' => nil, 'c' => nil}}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    should "handle attributes in nodes" do
+      xml = '<a a1="aye1" a2="aye2"><b b1="bee1"/><c c1="see1">see2</c></a>'
+      expected = {'a' => {'a1' => 'aye1', 'a2' => 'aye2', 'a' => {
+        'b' => {'b1' => 'bee1', 'b' => nil},
+        'c' => {'c1' => 'see1', 'c' => 'see2'}}}}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    should "flatten array nodes by default" do
+      xml = '<a><b>bee1</b><b>bee2</b><c /></a>'
+      expected = {'a' => {'b' => 'bee1', 'c' => nil}}
+      assert_equal expected, Hash.from_xml_string(xml)
+    end
+    
+    context "with array nodes" do
+      should "not flatten array nodes when array_nodes specified" do
+        xml = '<a><b>bee1</b><b>bee2</b><c /></a>'
+        expected = {'a' => {'b' => ['bee1', 'bee2'], 'c' => nil}}
+        assert_equal expected, Hash.from_xml_string(xml, :array_nodes => ['b'])
+      end
+      
+      should "not flatten array nodes and remove inner nodes when array_nodes and parent_array_nodes specified" do
+        xml = '<a><b>bee1</b><b>bee2</b><c>see</c></a>'
+        expected = {'a' => ['bee1', 'bee2', 'see']}
+        assert_equal expected, Hash.from_xml_string(xml, :array_nodes => ['b', 'c'], :parent_array_nodes => ['a'])
+      end
+      
+      should "have empty array node when no child nodes present and parent_array_nodes specified" do
+        xml = '<a> \n </a>'
+        expected = {'a' => []}
+        assert_equal expected, Hash.from_xml_string(xml, :parent_array_nodes => ['a'])
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require File.dirname(__FILE__) + '/../lib/oha_extensions'
+
+require 'oha_extensions'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: oha_extensions
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Bookrenter/Rafter
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Extends Object, Hash and Array classes with additional methods.
+email:
+- cp@bookrenter.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/oha_extensions.rb
+- lib/oha_extensions/array_extension.rb
+- lib/oha_extensions/hash_extension.rb
+- lib/oha_extensions/object_extension.rb
+- lib/oha_extensions/version.rb
+- oha_extensions.gemspec
+- test/oha_extensions/array_extension_test.rb
+- test/oha_extensions/hash_extension_test.rb
+- test/test_helper.rb
+homepage: https://github.com/bkr/oha_extensions
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Additional methods for Object, Hash, Array classes.
+test_files:
+- test/oha_extensions/array_extension_test.rb
+- test/oha_extensions/hash_extension_test.rb
+- test/test_helper.rb