active_object 1.0.0

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/active_object.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_object/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_object"
+  spec.version       = ActiveObject::VERSION
+  spec.authors       = ["Juan Gomez"]
+  spec.email         = ["j.gomez@drexed.com"]
+  spec.summary       = %q{Commonly used ruby object helpers.}
+  spec.description   = %q{Class extensions of commonly used ruby object helpers.}
+  spec.homepage      = "https://github.com/drexed/active_object"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/active_object.rb

@@ -0,0 +1,9 @@
+require 'active_object/version'
+require 'active_object/array'
+require 'active_object/enumerable'
+require 'active_object/hash'
+require 'active_object/integer'
+require 'active_object/numeric'
+require 'active_object/object'
+require 'active_object/string'
+require 'active_object/time'

data/lib/active_object/array.rb

@@ -0,0 +1,118 @@
+class Array
+
+  def delete_first
+    self[1..-1]
+  end
+
+  def delete_last
+    self[0...-1]
+  end
+
+  unless method_defined?(:from)
+    def from(position)
+      self[position, size] || []
+    end
+  end
+
+  def groups(number)
+    return([]) if number <= 0
+    n, r       = size.divmod(number)
+    collection = (0..(n - 1)).collect { |i| self[(i * number), number] }
+    r > 0 ? collection << self[-r, r] : collection
+  end
+
+  unless method_defined?(:in_groups)
+    def in_groups(number, fill_with=nil)
+      collection_size = size
+      division        = collection_size.div(number)
+      modulo          = collection_size % number
+
+      collection = []
+      start      = 0
+      number.times do |i|
+        grouping = division + (modulo > 0 && modulo > i ? 1 : 0)
+        collection << last_group = slice(start, grouping)
+        last_group << fill_with if fill_with != false && modulo > 0 && grouping == division
+        start += grouping
+      end
+
+      block_given? ? collection.each { |g| yield(g) } : collection
+    end
+  end
+
+  unless method_defined?(:in_groups_of)
+    def in_groups_of(number, fill_with=nil)
+      if number.to_i <= 0
+        raise ArgumentError,
+          "Group size must be a positive integer, was #{number.inspect}"
+      end
+
+      if fill_with == false
+        collection = self
+      else
+        padding    = (number - size % number) % number
+        collection = dup.concat(Array.new(padding, fill_with))
+      end
+
+      block_given? ? collection.each_slice(number) { |slice| yield(slice) } : collection.each_slice(number).to_a
+    end
+  end
+
+  unless method_defined?(:split)
+    def split(number=nil)
+      if block_given?
+        inject([[]]) do |results, element|
+          yield(element) ? results << [] : results.last << element
+          results
+        end
+      else
+        results, arr = [[]], dup
+        until arr.empty?
+          if (idx = arr.index(number))
+            results.last.concat(arr.shift(idx))
+            arr.shift
+            results << []
+          else
+            results.last.concat(arr.shift(arr.size))
+          end
+        end
+        results
+      end
+    end
+  end
+
+  def strip
+    reject { |v| v.blank? }
+  end
+
+  unless method_defined?(:to)
+    def to(position)
+      position >= 0 ? first(position + 1) : self[0..position]
+    end
+  end
+
+  unless method_defined?(:to_sentence)
+    def to_sentence(options={})
+      options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector)
+
+      default_connectors = {
+        words_connector:     ', ',
+        two_words_connector: ' and ',
+        last_word_connector: ', and '
+      }
+      options = default_connectors.merge!(options)
+
+      case size
+      when 0
+        ''
+      when 1
+        self[0].to_s.dup
+      when 2
+        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      else
+        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+      end
+    end
+  end
+
+end

data/lib/active_object/enumerable.rb

@@ -0,0 +1,172 @@
+module Enumerable
+
+  def difference(identity=0, &block)
+    if block_given?
+      map(&block).difference(identity)
+    else
+      inject { |d,v| d - v } || identity
+    end
+  end
+
+  def divisible(identity=0, &block)
+    if block_given?
+      map(&block).divisible(identity)
+    else
+      inject { |d,v| d / v } || identity
+    end
+  end
+
+  def drop_last(n)
+    collection_size = to_a.size
+    return(self) if n > collection_size
+    self[0...(collection_size - n)]
+  end
+
+  def drop_last_if
+    return(to_enum(:drop_last_if)) unless block_given?
+
+    result   = []
+    dropping = true
+    reverse_each do |value|
+      result.unshift(value) unless dropping &&= yield(value)
+    end
+    result
+  end
+
+  def exactly?(n)
+    found_count = 0
+    block_given? ? each { |*o| found_count += 1 if yield(*o) } : each { |o| found_count += 1 if o }
+    (found_count > n) ? false : n == found_count
+  end
+
+  unless method_defined?(:exclude?)
+    def exclude?(object)
+      !include?(object)
+    end
+  end
+
+  def exponential(identity=0, &block)
+    if block_given?
+      map(&block).exponential(identity)
+    else
+      inject { |d,v| d ** v } || identity
+    end
+  end
+
+  def frequencies
+    each_with_object(Hash.new(0)) { |e, a| a[e] += 1 }
+  end
+
+  unless method_defined?(:many?)
+    def many?
+      found_count = 0
+      if block_given?
+        any? do |v|
+          found_count += 1 if yield v
+          found_count > 1
+        end
+      else
+        any? { (found_count += 1) > 1 }
+      end
+    end
+  end
+
+  def max(identity=0)
+    size > 0 ? sort.last : identity
+  end
+
+  def min(identity=0)
+    size > 0 ? sort.first : identity
+  end
+
+  def mean(identity=0)
+    return(identity) unless size > 0
+    collection_size = size
+    sum / collection_size.to_f
+  end
+
+  def median(identity=0)
+    collection_size   = size
+    collection_sorted = sort
+
+    return(identity) unless collection_size > 0
+
+    if (collection_size % 2).zero?
+      (collection_sorted[(collection_size / 2.0) -1.0] + collection_sorted[collection_size / 2.0]) / 2.0
+    else
+      collection_sorted[collection_size / 2.0]
+    end
+  end
+
+  def mode(identity=0)
+    return(identity) unless size > 0
+
+    frequency_distribution = inject(Hash.new(0)) { |h,v| h[v] += 1; h }
+    frequency_top_two      = frequency_distribution.sort { |k,v| v[1] <=> k[1] }.take(2)
+
+    if frequency_top_two.size == 1
+      frequency_top_two.first.first
+    elsif frequency_top_two.first.last == frequency_top_two.last.last
+      nil
+    else
+      frequency_top_two.first.first
+    end
+  end
+
+  def multiple(identity=0, &block)
+    if block_given?
+      map(&block).multiple(identity)
+    else
+      inject { |d,v| d * v } || identity
+    end
+  end
+
+  def range(identity=0)
+    return(identity) unless size > 0
+    collection_sorted = sort
+    collection_sorted.last - collection_sorted.first
+  end
+
+  def several?
+    found_count = 0
+    block_given? ? each { |*o| found_count += 1 if yield(*o) } : each { |o| found_count += 1 if o }
+    (found_count > 1) ? true : false
+  end
+
+  def standard_deviation(identity=0)
+    return(identity) if size < 2
+    Math.sqrt(variance)
+  end
+
+  unless method_defined?(:sum)
+    def sum(identity=0, &block)
+      if block_given?
+        map(&block).sum(identity)
+      else
+        inject { |s,v| s + v } || identity
+      end
+    end
+  end
+
+  def take_last(n)
+    collection_size = to_a.size
+    return(self) if n > collection_size
+    self[(collection_size - n)..-1]
+  end
+
+  def take_last_if
+    return(to_enum(:take_last_if)) unless block_given?
+
+    result = []
+    reverse_each { |e| yield(e) ? result.unshift(e) : break }
+    result
+  end
+
+  def variance(identity=0)
+    collection_size = size
+    return(identity) if collection_size <= 1
+    sum = inject(0.0) { |s,v| s + (v - mean) ** 2.0 }
+    sum / (collection_size.to_f - 1.0)
+  end
+
+end

data/lib/active_object/hash.rb

@@ -0,0 +1,203 @@
+class Hash
+
+  unless method_defined?(:assert_valid_keys)
+    def assert_valid_keys(*valid_keys)
+      valid_keys.flatten!
+      each_key do |k|
+        unless valid_keys.include?(k)
+          raise ArgumentError, "Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}"
+        end
+      end
+    end
+  end
+
+  unless method_defined?(:compact)
+    def compact
+      select { |k,v| !v.nil? }
+    end
+  end
+
+  unless method_defined?(:compact!)
+    def compact!
+      reject! { |k,v| v.nil? }
+    end
+  end
+
+  unless method_defined?(:deep_merge)
+    def deep_merge(other_hash, &block)
+      dup.deep_merge!(other_hash, &block)
+    end
+  end
+
+  unless method_defined?(:deep_merge!)
+    def deep_merge!(other_hash, &block)
+      other_hash.each_pair do |current_key, other_value|
+        this_value = self[current_key]
+
+        self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+          this_value.deep_merge(other_value, &block)
+        else
+          block_given? && key?(current_key) ? block.call(current_key, this_value, other_value) : other_value
+        end
+      end
+      self
+    end
+  end
+
+  unless method_defined?(:except)
+    def except(*keys)
+      dup.except!(*keys)
+    end
+  end
+
+  unless method_defined?(:except!)
+    def except!(*keys)
+      keys.each { |k| delete(k) }
+      self
+    end
+  end
+
+  def nillify
+    dup.nillify!
+  end
+
+  def nillify!
+    each do |k, v|
+      if !v.nil? && ((v.respond_to?(:blank?) && v.blank?) || (v.respond_to?(:to_s) && v.to_s.blank?))
+        self[k] = nil
+      end
+    end
+  end
+
+  unless method_defined?(:only)
+    def only(*keys)
+      dup.only!(*keys)
+    end
+  end
+
+  unless method_defined?(:only!)
+    def only!(*args)
+      hash = {}
+      args.each {|k| hash[k] = self[k] if self.has_key?(k) }
+      hash
+    end
+  end
+
+  def rename_keys(*args)
+    dup.rename_keys!(*args)
+  end
+
+  def rename_keys!(*args)
+    keys = Hash[*args.flatten]
+    keys.each { |k, v| self[v] = delete(k) if self[k] }
+    self
+  end
+
+  unless method_defined?(:reverse_merge)
+    def reverse_merge(other_hash)
+      other_hash.merge(self)
+    end
+  end
+
+  unless method_defined?(:reverse_merge!)
+    def reverse_merge!(other_hash)
+      merge!(other_hash) { |k,l,r| l }
+    end
+  end
+
+  unless method_defined?(:slice)
+    def slice(*keys)
+      keys.each_with_object(self.class.new) { |k, h| h[k] = self[k] if has_key?(k) }
+    end
+  end
+
+  unless method_defined?(:slice!)
+    def slice!(*keys)
+      omit = slice(*self.keys - keys)
+      hash = slice(*keys)
+
+      hash.default      = default
+      hash.default_proc = default_proc if default_proc
+
+      replace(hash)
+      omit
+    end
+  end
+
+  unless method_defined?(:stringify_keys)
+    def stringify_keys
+      dup.stringify_keys!
+    end
+  end
+
+  unless method_defined?(:stringify_keys!)
+    def stringify_keys!
+      inject({}) do |options,(k,v)|
+        options[k.to_s] = v
+        options
+      end
+    end
+  end
+
+  def strip
+    select { |k,v| !v.blank? }
+  end
+
+  def strip!
+    reject! { |k,v| v.blank? }
+  end
+
+  unless method_defined?(:symbolize_keys)
+    def symbolize_keys
+      dup.symbolize_keys!
+    end
+  end
+
+  unless method_defined?(:symbolize_keys!)
+    def symbolize_keys!
+      inject({}) do |options, (k,v)|
+        options[(k.to_sym rescue k) || k] = v
+        options
+      end
+    end
+  end
+
+  def symbolize_and_underscore_keys
+    dup.symbolize_and_underscore_keys!
+  end
+
+  def symbolize_and_underscore_keys!
+    inject({}) do |options, (k,v)|
+      options[(k.to_s.gsub(" ", "_").underscore.to_sym rescue k) || k] = v
+      options
+    end
+  end
+
+  unless method_defined?(:transform_keys)
+    def transform_keys(&block)
+      dup.transform_keys!(&block)
+    end
+  end
+
+  unless method_defined?(:transform_keys!)
+    def transform_keys!(&block)
+      return(enum_for(:transform_keys!)) unless block_given?
+      keys.each { |k| self[yield(k)] = delete(k) }
+      self
+    end
+  end
+
+  unless method_defined?(:transform_values)
+    def transform_values(&block)
+      dup.transform_values!(&block)
+    end
+  end
+
+  unless method_defined?(:transform_values!)
+    def transform_values!(&block)
+      return(enum_for(:transform_values!)) unless block_given?
+      each { |k,v| self[k] = yield(v) }
+    end
+  end
+
+end