ruby-commons 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 160185274617ca4efe76098fa016bcfd60f96db2
+  data.tar.gz: 5bee257041c7f6dedf11ec6bfb5ed298eaa51e3a
+SHA512:
+  metadata.gz: 15d62d5f0d8ab83f6e5fd90fcc08718decb3f4c55c75fa68b0f4f4e2708b4313638df8ce6dea0ddfd0266198b5e7ebb9663b37964e01094470b2b1b5c8f58ff7
+  data.tar.gz: ba1886f48f923d1e493c2b8141343ba6099aa26bcfe2a79f356fbb95bbfb15168994d32370586eba539a5e82d9720a0bb0f61aa5cb318f6a887dcc3609cf395b

data/LICENSE.txt

@@ -0,0 +1,29 @@
+Copyright (c) 2015, MediariuM Ltd. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright notice,
+       this list of conditions and the following disclaimer in the documentation
+       and/or other materials provided with the distribution.
+
+    3. All advertising materials mentioning features or use of this software must
+       display the following acknowledgement: This product includes software
+       developed by the MediariuM Ltd.
+
+    4. Neither the name of MediariuM Ltd. nor the names of its contributors may
+       be used to endorse or promote products derived from this software without
+       specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY MEDIARIUM LTD. "AS IS" AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MEDIARIUM LTD.
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
+IF ADVISEDOF THE POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Ruby::Commons
+
+A toolkit of support libraries and Ruby core extensions.

data/lib/ruby/commons.rb

@@ -0,0 +1,9 @@
+module Ruby
+  module Commons
+    # Do nothing
+  end
+end
+
+require 'ruby/commons/core_ext'
+require 'ruby/commons/error'
+require 'ruby/commons/version'

data/lib/ruby/commons/core_ext.rb

@@ -0,0 +1,2 @@
+# Require all Core Extensions (monkey patches) at once
+Dir[File.join(File.dirname(__FILE__), 'core_ext', '*.rb')].each { |path| require path }

data/lib/ruby/commons/core_ext/file.rb

@@ -0,0 +1 @@
+require_relative 'file/extname'

data/lib/ruby/commons/core_ext/file/extname.rb

@@ -0,0 +1,8 @@
+class File
+  ##
+  # TODO
+  def self.mp_extension(path)
+    extension = File.extname(path || '')
+    extension[1..-1] if extension.mp_present?
+  end
+end

data/lib/ruby/commons/core_ext/hash.rb

@@ -0,0 +1,5 @@
+require_relative 'hash/compact'
+require_relative 'hash/except'
+require_relative 'hash/keys'
+require_relative 'hash/slice'
+require_relative 'hash/values'

data/lib/ruby/commons/core_ext/hash/compact.rb

@@ -0,0 +1,48 @@
+class Hash
+  ##
+  # Returns a hash with non +nil+ values.
+  #
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.compact # => { a: true, b: false}
+  #   hash # => { a: true, b: false, c: nil}
+  #   { c: nil }.compact # => {}
+  def mp_compact
+    self.select { |_, value| !value.nil? }
+  end
+
+  ##
+  # Replaces current hash with non +nil+ values.
+  #
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.compact! # => { a: true, b: false}
+  #   hash # => { a: true, b: false}
+  def mp_compact!
+    self.reject! { |_, value| value.nil? }
+  end
+
+  ##
+  # TODO
+  def mp_deep_compact!
+    proc_val = Proc.new {}
+    proc_hsh = Proc.new {}
+
+    proc_val = Proc.new do |v|
+      result = false
+      case v
+        when Hash
+          v.reject!(&proc_hsh)
+        when Array
+          v.each(&proc_val)
+        else
+          result = v.nil?
+      end
+      result
+    end
+
+    proc_hsh = Proc.new do |k, v|
+      proc_val.call(v)
+    end
+
+    delete_if(&proc_hsh)
+  end
+end

data/lib/ruby/commons/core_ext/hash/except.rb

@@ -0,0 +1,21 @@
+class Hash
+  # Returns a hash that includes everything but the given keys.
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.mp_except(:c) # => { a: true, b: false}
+  #   hash # => { a: true, b: false, c: nil}
+  #
+  # This is useful for limiting a set of parameters to everything but a few known toggles:
+  #   @person.update(params[:person].mp_except(:admin))
+  def mp_except(*keys)
+    dup.mp_except!(*keys)
+  end
+
+  # Replaces the hash without the given keys.
+  #   hash = { a: true, b: false, c: nil}
+  #   hash.mp_except!(:c) # => { a: true, b: false}
+  #   hash # => { a: true, b: false }
+  def mp_except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/lib/ruby/commons/core_ext/hash/keys.rb

@@ -0,0 +1,164 @@
+class Hash
+  ##
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.mp_transform_keys { |key| key.to_s.upcase }
+  #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+  def mp_transform_keys
+    return enum_for(:mp_transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  ##
+  # Destructively converts all keys using the block operations.
+  # Same as +mp_transform_keys+ but modifies +self+.
+  def mp_transform_keys!
+    return enum_for(:mp_transform_keys!) unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  ##
+  # Returns a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.mp_stringify_keys
+  #   # => {"name"=>"Rob", "age"=>"28"}
+  def mp_stringify_keys
+    mp_transform_keys(&:to_s)
+  end
+
+  ##
+  # Destructively converts all keys to strings. Same as
+  # +mp_stringify_keys+, but modifies +self+.
+  def mp_stringify_keys!
+    mp_transform_keys!(&:to_s)
+  end
+
+  ##
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.mp_symbolize_keys
+  #   # => {:name=>"Rob", :age=>"28"}
+  def mp_symbolize_keys
+    mp_transform_keys { |key| key.to_sym rescue key }
+  end
+  alias_method :mp_to_options,  :mp_symbolize_keys
+
+  ##
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +mp_symbolize_keys+, but modifies +self+.
+  def mp_symbolize_keys!
+    mp_transform_keys! { |key| key.to_sym rescue key }
+  end
+  alias_method :mp_to_options!, :mp_symbolize_keys!
+
+  ##
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.mp_deep_transform_keys { |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def mp_deep_transform_keys(&block)
+    __mp_deep_transform_keys_in_object(self, &block)
+  end
+
+  ##
+  # Destructively converts all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def mp_deep_transform_keys!(&block)
+    __mp_deep_transform_keys_in_object!(self, &block)
+  end
+
+  ##
+  # Returns a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.mp_deep_stringify_keys
+  #   # => {"person"=>{"name"=>"Rob", "age"=>"28"}}
+  def mp_deep_stringify_keys
+    mp_deep_transform_keys(&:to_s)
+  end
+
+  ##
+  # Destructively converts all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def mp_deep_stringify_keys!
+    mp_deep_transform_keys!(&:to_s)
+  end
+
+  ##
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.mp_deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def mp_deep_symbolize_keys
+    mp_deep_transform_keys { |key| key.to_sym rescue key }
+  end
+
+  ##
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def mp_deep_symbolize_keys!
+    mp_deep_transform_keys! { |key| key.to_sym rescue key }
+  end
+
+  ##
+  # Support methods for deep transforming nested hashes and arrays
+  private
+  def __mp_deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = __mp_deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| __mp_deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  ##
+  # Support methods for deep transforming nested hashes and arrays
+  private
+  def __mp_deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = __mp_deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! { |e| __mp_deep_transform_keys_in_object!(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/ruby/commons/core_ext/hash/slice.rb

@@ -0,0 +1,51 @@
+class Hash
+  ##
+  # Slice a hash to include only the given keys. Returns a hash containing
+  # the given keys.
+  # 
+  #   { a: 1, b: 2, c: 3, d: 4 }.mp_slice(:a, :b)
+  #   # => {:a=>1, :b=>2}
+  # 
+  # This is useful for limiting an options hash to valid keys before 
+  # passing to a method:
+  #
+  #   def search(criteria = {})
+  #     criteria.assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.mp_slice(:mass, :velocity, :time))
+  #
+  # If you have an array of keys you want to limit to, you should splat them:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.mp_slice(*valid_keys))
+  def mp_slice(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end
+
+  ##
+  # Replaces the hash with only the given keys.
+  # Returns a hash containing the removed key/value pairs.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.mp_slice!(:a, :b)
+  #   # => {:c=>3, :d=>4}
+  def mp_slice!(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    omit = mp_slice(*self.keys - keys)
+    hash = mp_slice(*keys)
+    hash.default      = default
+    hash.default_proc = default_proc if default_proc
+    replace(hash)
+    omit
+  end
+
+  ##
+  # Removes and returns the key/value pairs matching the given keys.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.mp_extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   { a: 1, b: 2 }.mp_extract!(:a, :x)             # => {:a=>1}
+  def mp_extract!(*keys)
+    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
+  end
+end

data/lib/ruby/commons/core_ext/hash/values.rb

@@ -0,0 +1,82 @@
+class Hash
+  ##
+  # Returns a new hash with the results of running +block+ once for every value.
+  # The keys are unchanged.
+  #
+  #   { a: 1, b: 2, c: 3 }.mp_transform_values { |k,v| v * 2 }
+  #   # => { a: 2, b: 4, c: 6 }
+  def mp_transform_values
+    return enum_for(:mp_transform_values) unless block_given?
+    result = self.class.new
+    each do |key, value|
+      result[key] = yield(key, value)
+    end
+    result
+  end
+
+  ##
+  # Destructive +mp_transform_values+
+  def mp_transform_values!
+    return enum_for(:mp_transform_values!) unless block_given?
+    each do |key, value|
+      self[key] = yield(key, value)
+    end
+  end
+
+  ##
+  # Returns a new hash with all values converted by the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', gender: 'Male' } }
+  #
+  #  hash.mp_deep_transform_values { |value| value.to_s.upcase }
+  #  # => {:person=>{:name=>"ROB", :gender=>"MALE"}}
+  def mp_deep_transform_values(&block)
+    __mp_deep_transform_values_in_object(self, &block)
+  end
+
+  ##
+  # Destructively converts all values by using the block operation.
+  # This includes the values from the root hash and from all
+  # nested hashes and arrays.
+  def mp_deep_transform_values!(&block)
+    __mp_deep_transform_values_in_object!(self, &block)
+  end
+
+# MARK: - Private Methods
+
+  ##
+  # Support methods for deep transforming nested hashes and arrays
+  private
+  def __mp_deep_transform_values_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[key] = __mp_deep_transform_values_in_object(yield(key, value), &block)
+      end
+    when Array
+      object.map { |e| __mp_deep_transform_values_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  ##
+  # Support methods for deep transforming nested hashes and arrays
+  private
+  def __mp_deep_transform_values_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[key] = __mp_deep_transform_values_in_object!(yield(key, value), &block)
+      end
+      object
+    when Array
+      object.map! { |e| __mp_deep_transform_values_in_object!(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/ruby/commons/core_ext/json.rb

@@ -0,0 +1,3 @@
+require 'json'
+
+require_relative 'json/include'

data/lib/ruby/commons/core_ext/json/include.rb

@@ -0,0 +1,17 @@
+# How to include a YAML file inside a YAML file?
+# @link http://stackoverflow.com/a/2286760
+
+module JSON
+  ##
+  # TODO
+  def self.mp_include(file_name)
+    require 'erb'
+    ERB.new(IO.read(file_name)).result
+  end
+
+  ##
+  # TODO
+  def self.mp_load_erb(file_name)
+    JSON::load(JSON::mp_include(file_name))
+  end
+end

data/lib/ruby/commons/core_ext/numeric.rb

@@ -0,0 +1 @@
+require_relative 'numeric/integer'

data/lib/ruby/commons/core_ext/numeric/integer.rb

@@ -0,0 +1,14 @@
+class Numeric
+  ##
+  # TODO
+  def self.mp_is_int?(obj)
+    value = obj.to_s
+    value.to_i.to_s == value
+  end
+
+  ##
+  # TODO
+  def self.mp_to_i(value, default = nil)
+    mp_is_int?(value) ? value.to_i : default
+  end
+end

data/lib/ruby/commons/core_ext/object.rb

@@ -0,0 +1,6 @@
+require_relative 'object/blank'
+require_relative 'object/duplicable'
+require_relative 'object/deep_dup'
+require_relative 'object/freeze'
+require_relative 'object/path'
+require_relative 'object/try'

data/lib/ruby/commons/core_ext/object/blank.rb

@@ -0,0 +1,139 @@
+class Object
+  ##
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies
+  #
+  #   address.nil? || address.empty?
+  #
+  # to
+  #
+  #   address.mp_blank?
+  #
+  # @return [true, false]
+  def mp_blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+  ##
+  # An object is present if it's not blank.
+  #
+  # @return [true, false]
+  def mp_present?
+    !mp_blank?
+  end
+
+  ##
+  # Returns the receiver if it's present otherwise returns +nil+.
+  # <tt>object.mp_presence</tt> is equivalent to
+  #
+  #    object.mp_present? ? object : nil
+  #
+  # For example, something like
+  #
+  #   state   = params[:state]   if params[:state].mp_present?
+  #   country = params[:country] if params[:country].mp_present?
+  #   region  = state || country || 'US'
+  #
+  # becomes
+  #
+  #   region = params[:state].mp_presence || params[:country].mp_presence || 'US'
+  #
+  # @return [Object]
+  def mp_presence
+    self if mp_present?
+  end
+end
+
+class NilClass
+  ##
+  # +nil+ is blank:
+  #
+  #   nil.mp_blank? # => true
+  #
+  # @return [true]
+  def mp_blank?
+    true
+  end
+end
+
+class FalseClass
+  ##
+  # +false+ is blank:
+  #
+  #   false.mp_blank? # => true
+  #
+  # @return [true]
+  def mp_blank?
+    true
+  end
+end
+
+class TrueClass
+  ##
+  # +true+ is not blank:
+  #
+  #   true.mp_blank? # => false
+  #
+  # @return [false]
+  def mp_blank?
+    false
+  end
+end
+
+class Array
+  ##
+  # An array is blank if it's empty:
+  #
+  #   [].mp_blank?      # => true
+  #   [1,2,3].mp_blank? # => false
+  #
+  # @return [true, false]
+  alias_method :mp_blank?, :empty?
+end
+
+class Hash
+  ##
+  # A hash is blank if it's empty:
+  #
+  #   {}.mp_blank?                # => true
+  #   { key: 'value' }.mp_blank?  # => false
+  #
+  # @return [true, false]
+  alias_method :mp_blank?, :empty?
+end
+
+class String
+  MP_BLANK_RE = /\A[[:space:]]*\z/
+
+  ##
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.mp_blank?       # => true
+  #   '   '.mp_blank?    # => true
+  #   "\t\n\r".mp_blank? # => true
+  #   ' blah '.mp_blank? # => false
+  #
+  # Unicode whitespace is supported:
+  #
+  #   "\u00a0".mp_blank? # => true
+  #
+  # @return [true, false]
+  def mp_blank?
+    MP_BLANK_RE === self
+  end
+end
+
+class Numeric #:nodoc:
+  ##
+  # No number is blank:
+  #
+  #   1.mp_blank? # => false
+  #   0.mp_blank? # => false
+  #
+  # @return [false]
+  def mp_blank?
+    false
+  end
+end

data/lib/ruby/commons/core_ext/object/deep_dup.rb

@@ -0,0 +1,50 @@
+require_relative 'duplicable'
+
+class Object
+  ##
+  # Returns a deep copy of object if it's duplicable. If it's
+  # not duplicable, returns +self+.
+  #
+  #   object = Object.new
+  #   dup    = object.mp_deep_dup
+  #   dup.instance_variable_set(:@a, 1)
+  #
+  #   object.instance_variable_defined?(:@a) # => false
+  #   dup.instance_variable_defined?(:@a)    # => true
+  def mp_deep_dup
+    mp_duplicable? ? dup : self
+  end
+end
+
+class Array
+  ##
+  # Returns a deep copy of array.
+  #
+  #   array = [1, [2, 3]]
+  #   dup   = array.mp_deep_dup
+  #   dup[1][2] = 4
+  #
+  #   array[1][2] # => nil
+  #   dup[1][2]   # => 4
+  def mp_deep_dup
+    map(&:mp_deep_dup)
+  end
+end
+
+class Hash
+  ##
+  # Returns a deep copy of hash.
+  #
+  #   hash = { a: { b: 'b' } }
+  #   dup  = hash.mp_deep_dup
+  #   dup[:a][:c] = 'c'
+  #
+  #   hash[:a][:c] # => nil
+  #   dup[:a][:c]  # => "c"
+  def mp_deep_dup
+    each_with_object(dup) do |(key, value), hash|
+      hash.delete(key)
+      hash[key.mp_deep_dup] = value.mp_deep_dup
+    end
+  end
+end

data/lib/ruby/commons/core_ext/object/duplicable.rb

@@ -0,0 +1,100 @@
+##
+# Most objects are cloneable, but not all. For example you can't dup +nil+:
+#
+#   nil.dup # => TypeError: can't dup NilClass
+#
+# Classes may signal their instances are not duplicable removing +dup+/+clone+
+# or raising exceptions from them. So, to dup an arbitrary object you normally
+# use an optimistic approach and are ready to catch an exception, say:
+#
+#   arbitrary_object.dup rescue object
+#
+# Rails dups objects in a few critical spots where they are not that arbitrary.
+# That rescue is very expensive (like 40 times slower than a predicate), and it
+# is often triggered.
+#
+# That's why we hardcode the following cases and check +mp_duplicable?+ instead
+# of using that rescue idiom.
+class Object
+  ##
+  # Can you safely dup this object?
+  #
+  # False for +nil+, +false+, +true+, symbol, number objects;
+  # true otherwise.
+  def mp_duplicable?
+    true
+  end
+end
+
+class NilClass
+  ##
+  # +nil+ is not duplicable:
+  #
+  #   nil.mp_duplicable? # => false
+  #   nil.dup            # => TypeError: can't dup NilClass
+  def mp_duplicable?
+    false
+  end
+end
+
+class FalseClass
+  ##
+  # +false+ is not duplicable:
+  #
+  #   false.mp_duplicable? # => false
+  #   false.dup            # => TypeError: can't dup FalseClass
+  def mp_duplicable?
+    false
+  end
+end
+
+class TrueClass
+  ##
+  # +true+ is not duplicable:
+  #
+  #   true.mp_duplicable? # => false
+  #   true.dup            # => TypeError: can't dup TrueClass
+  def mp_duplicable?
+    false
+  end
+end
+
+class Symbol
+  ##
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.mp_duplicable? # => false
+  #   :my_symbol.dup            # => TypeError: can't dup Symbol
+  def mp_duplicable?
+    false
+  end
+end
+
+class Numeric
+  ##
+  # Numbers are not duplicable:
+  #
+  #  3.mp_duplicable? # => false
+  #  3.dup            # => TypeError: can't dup Fixnum
+  def mp_duplicable?
+    false
+  end
+end
+
+require 'bigdecimal'
+class BigDecimal
+  def mp_duplicable?
+    true
+  end
+end
+
+class Method
+  ##
+  # Methods are not duplicable:
+  #
+  #  method(:puts).mp_duplicable? # => false
+  #  method(:puts).dup            # => TypeError: allocator undefined for Method
+  def mp_duplicable?
+    false
+  end
+end

data/lib/ruby/commons/core_ext/object/freeze.rb

@@ -0,0 +1,26 @@
+class Object
+  ##
+  # TODO
+  def mp_deep_freeze
+    proc_val = Proc.new {}
+
+    proc_hsh = Proc.new do |k, v|
+      proc_val.call(v)
+    end
+
+    proc_val = Proc.new do |v|
+      case v
+        when Hash
+          v.each_value(&proc_hsh)
+        when Array
+          v.each(&proc_val)
+        else
+          # Do nothing ..
+      end
+
+      v.freeze
+    end
+
+    proc_val.call(self)
+  end
+end

data/lib/ruby/commons/core_ext/object/path.rb

@@ -0,0 +1,31 @@
+class Object
+  ##
+  # Gets a value from an Object using a dot separated path.
+  #
+  #  { a: 1, b: { c: 3, d: [1, 2, 3] } }.mp_path('b.d')   # => [1, 2, 3]
+  #  { a: 1, b: { c: 3, d: [1, 2, 3] } }.mp_path('b.d.1') # => 2
+  def mp_path(path = '', default = nil, delimiter = '.')
+    value = self
+
+    path.to_s.split(delimiter).each do |key|
+      index = key.to_i
+
+      unless value.respond_to?(:[])
+        value = nil
+        break
+      end
+
+      if key == index.to_s
+        value = value[index]
+      elsif value.respond_to?(:key?)
+        value = value.key?(key) ? value[key] : value[key.to_sym]
+      else
+        value = nil
+      end
+
+      break if value.nil?
+    end
+
+    value || default
+  end
+end

data/lib/ruby/commons/core_ext/object/try.rb

@@ -0,0 +1,102 @@
+class Object
+  ##
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.mp_try(:name)
+  #
+  # instead of
+  #
+  #   @person.name if @person
+  #
+  # +mp_try+ calls can be chained:
+  #
+  #   @person.mp_try(:spouse).mp_try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +mp_try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.mp_try(:non_existing_method) #=> nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) #=> nil
+  #
+  # +mp_try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.mp_try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.mp_try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # in case of argument mismatch.
+  #
+  # If +mp_try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.mp_try do |p|
+  #     ...
+  #   end
+  #
+  # You can also call mp_try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.mp_try { upcase.truncate(50) }
+  #
+  # Please also note that +mp_try+ is defined on +Object+. Therefore, it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+. For example, using +mp_try+ with
+  # +SimpleDelegator+ will delegate +mp_try+ to the target instead of calling it on
+  # the delegator itself.
+  def mp_try(*a, &b)
+    mp_try!(*a, &b) if a.empty? || respond_to?(a.first)
+  end
+
+  ##
+  # Same as #mp_try, but will raise a NoMethodError exception if the receiver is not +nil+ and
+  # does not implement the tried method.
+  def mp_try!(*a, &b)
+    if a.empty? && block_given?
+      if b.arity.zero?
+        instance_eval(&b)
+      else
+        yield self
+      end
+    else
+      public_send(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  ##
+  # Calling +mp_try+ on +nil+ always returns +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.mp_try(:name) # => nil
+  #
+  # Without +mp_try+
+  #   @person && @person.children.any? && @person.children.first.name
+  #
+  # With +mp_try+
+  #   @person.mp_try(:children).mp_try(:first).mp_try(:name)
+  def mp_try(*args)
+    nil
+  end
+
+  def mp_try!(*args)
+    nil
+  end
+end

data/lib/ruby/commons/core_ext/regexp.rb

@@ -0,0 +1 @@
+require_relative 'regexp/match'

data/lib/ruby/commons/core_ext/regexp/match.rb

@@ -0,0 +1,7 @@
+class Regexp
+  ##
+  # TODO
+  def mp_match?(*several_variants)
+    !match(*several_variants).nil?
+  end
+end

data/lib/ruby/commons/core_ext/string.rb

@@ -0,0 +1,2 @@
+require_relative 'string/match'
+require_relative 'string/trim'

data/lib/ruby/commons/core_ext/string/match.rb

@@ -0,0 +1,7 @@
+class String
+  ##
+  # TODO
+  def mp_match?(*several_variants)
+    !match(*several_variants).nil?
+  end
+end

data/lib/ruby/commons/core_ext/string/trim.rb

@@ -0,0 +1,19 @@
+class String
+  ##
+  # TODO
+  def mp_trim(character_set)
+    mp_ltrim(character_set).mp_rtrim(character_set)
+  end
+
+  ##
+  # TODO
+  def mp_ltrim(character_set)
+    sub(/^[#{character_set}]+/, '')
+  end
+
+  ##
+  # TODO
+  def mp_rtrim(character_set)
+    sub(/[#{character_set}]+$/, '')
+  end
+end

data/lib/ruby/commons/core_ext/uri.rb

@@ -0,0 +1,3 @@
+require 'uri'
+
+require_relative 'uri/parse'

data/lib/ruby/commons/core_ext/uri/parse.rb

@@ -0,0 +1,11 @@
+module URI
+  ##
+  # TODO
+  def self.mp_try_parse(uri)
+    begin
+      return URI(uri)
+    rescue ArgumentError, InvalidURIError
+      return nil
+    end
+  end
+end

data/lib/ruby/commons/error.rb

@@ -0,0 +1,2 @@
+# Require all Errors at once
+Dir[File.join(File.dirname(__FILE__), 'error', '*.rb')].each { |path| require path }

data/lib/ruby/commons/error/abstract_class_error.rb

@@ -0,0 +1,3 @@
+class AbstractClassError < StandardError
+  # Do nothing
+end

data/lib/ruby/commons/gem_version.rb

@@ -0,0 +1,17 @@
+module Ruby::Commons
+
+  # Returns the version of the currently loaded Ruby::Commons as a <tt>Gem::Version</tt>
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
+  end
+
+end

data/lib/ruby/commons/version.rb

@@ -0,0 +1,10 @@
+require_relative 'gem_version'
+
+module Ruby::Commons
+
+  # Returns the version of the currently loaded Ruby::Commons as a string.
+  def self.version
+    VERSION::STRING
+  end
+
+end

data/lib/ruby_commons.rb

@@ -0,0 +1 @@
+require 'ruby/commons'

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: ruby-commons
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexander Bragin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-12 00:00:00.000000000 Z
+dependencies: []
+description: A toolkit of support libraries and Ruby core extensions.
+email: alexander.bragin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.rdoc
+- lib/ruby/commons.rb
+- lib/ruby/commons/core_ext.rb
+- lib/ruby/commons/core_ext/file.rb
+- lib/ruby/commons/core_ext/file/extname.rb
+- lib/ruby/commons/core_ext/hash.rb
+- lib/ruby/commons/core_ext/hash/compact.rb
+- lib/ruby/commons/core_ext/hash/except.rb
+- lib/ruby/commons/core_ext/hash/keys.rb
+- lib/ruby/commons/core_ext/hash/slice.rb
+- lib/ruby/commons/core_ext/hash/values.rb
+- lib/ruby/commons/core_ext/json.rb
+- lib/ruby/commons/core_ext/json/include.rb
+- lib/ruby/commons/core_ext/numeric.rb
+- lib/ruby/commons/core_ext/numeric/integer.rb
+- lib/ruby/commons/core_ext/object.rb
+- lib/ruby/commons/core_ext/object/blank.rb
+- lib/ruby/commons/core_ext/object/deep_dup.rb
+- lib/ruby/commons/core_ext/object/duplicable.rb
+- lib/ruby/commons/core_ext/object/freeze.rb
+- lib/ruby/commons/core_ext/object/path.rb
+- lib/ruby/commons/core_ext/object/try.rb
+- lib/ruby/commons/core_ext/regexp.rb
+- lib/ruby/commons/core_ext/regexp/match.rb
+- lib/ruby/commons/core_ext/string.rb
+- lib/ruby/commons/core_ext/string/match.rb
+- lib/ruby/commons/core_ext/string/trim.rb
+- lib/ruby/commons/core_ext/uri.rb
+- lib/ruby/commons/core_ext/uri/parse.rb
+- lib/ruby/commons/error.rb
+- lib/ruby/commons/error/abstract_class_error.rb
+- lib/ruby/commons/gem_version.rb
+- lib/ruby/commons/version.rb
+- lib/ruby_commons.rb
+homepage: http://www.mediarium.com
+licenses:
+- BSD-4-Clause
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--exclude"
+- "."
+require_paths:
+- config
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A toolkit of support libraries and Ruby core extensions.
+test_files: []