motion_support 0.0.2 → 0.0.3

data/lib/motion_support/core_ext/hash/keys.rb

@@ -0,0 +1,2 @@
+require 'bubble-wrap/loader'
+BubbleWrap.require('motion/core_ext/hash/keys.rb')

data/lib/motion_support/core_ext/hash.rb

@@ -0,0 +1,4 @@
+require 'bubble-wrap/loader'
+Dir["#{File.dirname(__FILE__)}/hash/*.rb"].sort.each do |path|
+  require path
+end

data/lib/motion_support/core_ext/object/deep_dup.rb

@@ -0,0 +1,4 @@
+require 'bubble-wrap/loader'
+BubbleWrap.require('motion/core_ext/object/*.rb') do
+  file('motion/core_ext/object/deep_dup.rb').depends_on('motion/core_ext/object/duplicable.rb')
+end

data/lib/motion_support/core_ext/object/duplicable.rb

@@ -0,0 +1,2 @@
+require 'bubble-wrap/loader'
+BubbleWrap.require('motion/core_ext/object/duplicable.rb')

data/lib/motion_support/core_ext/object.rb

@@ -0,0 +1,5 @@
+require 'bubble-wrap/loader'
+Dir["#{File.dirname(__FILE__)}/object/*.rb"].sort.each do |path|
+  require path
+end
+

data/lib/motion_support/version.rb

@@ -1,3 +1,3 @@
 module MotionSupport
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/motion/core_ext/hash/keys.rb

@@ -0,0 +1,139 @@
+class Hash
+  # Return a new hash with all keys converted using the block operation.
+  #
+  #  hash = { name: 'Rob', age: '28' }
+  #
+  #  hash.transform_keys{ |key| key.to_s.upcase }
+  #  # => { "NAME" => "Rob", "AGE" => "28" }
+  def transform_keys
+    result = {}
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Destructively convert all keys using the block operations.
+  # Same as transform_keys but modifies +self+
+  def transform_keys!
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  #
+  #   hash = { name: 'Rob', age: '28' }
+  #
+  #   hash.stringify_keys
+  #   #=> { "name" => "Rob", "age" => "28" }
+  def stringify_keys
+    transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings. Same as
+  # +stringify_keys+, but modifies +self+.
+  def stringify_keys!
+    transform_keys!{ |key| key.to_s }
+  end
+
+  # Return a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+.
+  #
+  #   hash = { 'name' => 'Rob', 'age' => '28' }
+  #
+  #   hash.symbolize_keys
+  #   #=> { name: "Rob", age: "28" }
+  def symbolize_keys
+    transform_keys{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options,  :symbolize_keys
+
+  # Destructively convert all keys to symbols, as long as they respond
+  # to +to_sym+. Same as +symbolize_keys+, but modifies +self+.
+  def symbolize_keys!
+    transform_keys!{ |key| key.to_sym rescue key }
+  end
+  alias_method :to_options!, :symbolize_keys!
+
+  # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
+  # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
+  # as keys, this will fail.
+  #
+  #   { :name => 'Rob', :years => '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: years"
+  #   { :name => 'Rob', :age => '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: name"
+  #   { :name => 'Rob', :age => '28' }.assert_valid_keys(:name, :age) # => passes, raises nothing
+  def assert_valid_keys(*valid_keys)
+    valid_keys.flatten!
+    each_key do |k|
+      raise ArgumentError.new("Unknown key: #{k}") unless valid_keys.include?(k)
+    end
+  end
+
+  # Return a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => { "PERSON" => { "NAME" => "Rob", "AGE" => "28" } }
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  # Destructively convert all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
+
+  # Return a new hash with all keys converted to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  #
+  #   hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #   hash.deep_stringify_keys
+  #   # => { "person" => { "name" => "Rob", "age" => "28" } }
+  def deep_stringify_keys
+    deep_transform_keys{ |key| key.to_s }
+  end
+
+  # Destructively convert all keys to strings.
+  # This includes the keys from the root hash and from all
+  # nested hashes.
+  def deep_stringify_keys!
+    deep_transform_keys!{ |key| key.to_s }
+  end
+
+  # Return 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.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => { person: { name: "Rob", age: "28" } }
+  def deep_symbolize_keys
+    deep_transform_keys{ |key| key.to_sym rescue key }
+  end
+
+  # Destructively convert 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.
+  def deep_symbolize_keys!
+    deep_transform_keys!{ |key| key.to_sym rescue key }
+  end
+end
+

data/motion/core_ext/object/deep_dup.rb

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

data/motion/core_ext/object/duplicable.rb

@@ -0,0 +1,95 @@
+#--
+# 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 duplicable? instead of
+# using that rescue idiom.
+#++
+class Object
+  # Can you safely dup this object?
+  #
+  # False for +nil+, +false+, +true+, symbol, and number objects;
+  # true otherwise.
+  def duplicable?
+    true
+  end
+end
+
+class NilClass
+  # +nil+ is not duplicable:
+  #
+  #   nil.duplicable? # => false
+  #   nil.dup         # => TypeError: can't dup NilClass
+  #
+  def duplicable?
+    false
+  end
+end
+
+class FalseClass
+  # +false+ is not duplicable:
+  #
+  #   false.duplicable? # => false
+  #   false.dup         # => TypeError: can't dup FalseClass
+  #
+  def duplicable?
+    false
+  end
+end
+
+class TrueClass
+  # +true+ is not duplicable:
+  #
+  #   true.duplicable? # => false
+  #   true.dup         # => TypeError: can't dup TrueClass
+  #
+  def duplicable?
+    false
+  end
+end
+
+class Symbol
+  # Symbols are not duplicable:
+  #
+  #   :my_symbol.duplicable? # => false
+  #   :my_symbol.dup         # => TypeError: can't dup Symbol
+  #
+  def duplicable?
+    false
+  end
+end
+
+class Numeric
+  # Numbers are not duplicable:
+  #
+  #  3.duplicable? # => false
+  #  3.dup         # => TypeError: can't dup Fixnum
+  #
+  def duplicable?
+    false
+  end
+end
+
+class BigDecimal
+  begin
+    BigDecimal.new('4.56').dup
+
+    def duplicable?
+      true
+    end
+  rescue TypeError
+    # can't dup, so use superclass implementation
+  end
+end
+

data/spec/core_ext/hash/keys_spec.rb

@@ -0,0 +1,205 @@
+describe "Hash Keys" do
+  before do
+    @strings = { 'a' => 1, 'b' => 2 }
+    @nested_strings = { 'a' => { 'b' => { 'c' => 3 } } }
+    @symbols = { :a  => 1, :b  => 2 }
+    @nested_symbols = { :a => { :b => { :c => 3 } } }
+    @mixed   = { :a  => 1, 'b' => 2 }
+    @nested_mixed   = { 'a' => { :b => { 'c' => 3 } } }
+    @fixnums = {  0  => 1,  1  => 2 }
+    @nested_fixnums = {  0  => { 1  => { 2 => 3} } }
+    @illegal_symbols = { [] => 3 }
+    @nested_illegal_symbols = { [] => { [] => 3} }
+    @upcase_strings = { 'A' => 1, 'B' => 2 }
+    @nested_upcase_strings = { 'A' => { 'B' => { 'C' => 3 } } }
+  end
+
+  it "methods" do
+    h = {}
+    h.respond_to?(:transform_keys).should == true
+    h.respond_to?(:transform_keys!).should == true
+    h.respond_to?(:deep_transform_keys).should == true
+    h.respond_to?(:deep_transform_keys!).should == true
+    h.respond_to?(:symbolize_keys).should == true
+    h.respond_to?(:symbolize_keys!).should == true
+    h.respond_to?(:deep_symbolize_keys).should == true
+    h.respond_to?(:deep_symbolize_keys!).should == true
+    h.respond_to?(:stringify_keys).should == true
+    h.respond_to?(:stringify_keys!).should == true
+    h.respond_to?(:deep_stringify_keys).should == true
+    h.respond_to?(:deep_stringify_keys!).should == true
+    h.respond_to?(:to_options).should == true
+    h.respond_to?(:to_options!).should == true
+  end
+
+  it "transform keys" do
+    @strings.transform_keys{ |key| key.to_s.upcase }.should == @upcase_strings
+    @symbols.transform_keys{ |key| key.to_s.upcase }.should == @upcase_strings
+    @mixed.transform_keys{ |key| key.to_s.upcase }.should == @upcase_strings
+  end
+
+  it "transform keys not mutates" do
+    transformed_hash = @mixed.dup
+    transformed_hash.transform_keys{ |key| key.to_s.upcase }
+    transformed_hash.should == @mixed
+  end
+
+  it "deep transform keys" do
+    @nested_symbols.deep_transform_keys{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+    @nested_strings.deep_transform_keys{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+    @nested_mixed.deep_transform_keys{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+  end
+
+  it "deep transform keys not mutates" do
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_transform_keys{ |key| key.to_s.upcase }
+    transformed_hash.should == @nested_mixed
+  end
+
+  it "transform keys!" do
+    @symbols.dup.transform_keys!{ |key| key.to_s.upcase }.should == @upcase_strings
+    @strings.dup.transform_keys!{ |key| key.to_s.upcase }.should == @upcase_strings
+    @mixed.dup.transform_keys!{ |key| key.to_s.upcase }.should == @upcase_strings
+  end
+
+  it "transform keys with bang mutates" do
+    transformed_hash = @mixed.dup
+    transformed_hash.transform_keys!{ |key| key.to_s.upcase }
+    transformed_hash.should == @upcase_strings
+    { :a => 1, "b" => 2 }.should.equal(@mixed)
+  end
+
+  it "deep transform keys!" do
+    @nested_symbols.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+    @nested_strings.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+    @nested_mixed.deep_dup.deep_transform_keys!{ |key| key.to_s.upcase }.should == @nested_upcase_strings
+  end
+
+  it "deep transform keys with bang mutates" do
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_transform_keys!{ |key| key.to_s.upcase }
+    transformed_hash.should == @nested_upcase_strings
+    { 'a' => { :b => { 'c' => 3 } } }.should == @nested_mixed
+  end
+
+  it "symbolize keys" do
+    @symbols.symbolize_keys.should == @symbols
+    @strings.symbolize_keys.should == @symbols
+    @mixed.symbolize_keys.should == @symbols
+  end
+
+  it "symbolize keys not mutates" do
+    transformed_hash = @mixed.dup
+    transformed_hash.symbolize_keys
+    transformed_hash.should == @mixed
+  end
+
+  it "deep symbolize keys" do
+    @nested_symbols.deep_symbolize_keys.should == @nested_symbols
+    @nested_strings.deep_symbolize_keys.should == @nested_symbols
+    @nested_mixed.deep_symbolize_keys.should == @nested_symbols
+  end
+
+  it "deep symbolize keys not mutates" do
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_symbolize_keys
+    transformed_hash.should == @nested_mixed
+  end
+
+  it "symbolize keys!" do
+    @symbols.dup.symbolize_keys!.should == @symbols
+    @strings.dup.symbolize_keys!.should == @symbols
+    @mixed.dup.symbolize_keys!.should == @symbols
+  end
+
+  it "symbolize keys with bang mutates" do
+    transformed_hash = @mixed.dup
+    transformed_hash.deep_symbolize_keys!
+    transformed_hash.should == @symbols
+    { :a => 1, "b" => 2 }.should.equal(@mixed)
+  end
+
+  it "deep symbolize keys!" do
+    @nested_symbols.deep_dup.deep_symbolize_keys!.should == @nested_symbols
+    @nested_strings.deep_dup.deep_symbolize_keys!.should == @nested_symbols
+    @nested_mixed.deep_dup.deep_symbolize_keys!.should == @nested_symbols
+  end
+
+  it "deep symbolize keys with bang mutates" do
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_symbolize_keys!
+    transformed_hash.should == @nested_symbols
+    { 'a' => { :b => { 'c' => 3 } } }.should == @nested_mixed
+  end
+
+  it "symbolize keys preserves keys that cant be symbolized" do
+    @illegal_symbols.symbolize_keys.should == @illegal_symbols
+    @illegal_symbols.dup.symbolize_keys!.should == @illegal_symbols
+  end
+
+  it "deep symbolize keys preserves keys that cant be symbolized" do
+    @nested_illegal_symbols.deep_symbolize_keys.should == @nested_illegal_symbols
+    @nested_illegal_symbols.deep_dup.deep_symbolize_keys!.should == @nested_illegal_symbols
+  end
+
+  it "symbolize keys preserves fixnum keys" do
+    @fixnums.symbolize_keys.should == @fixnums
+    @fixnums.dup.symbolize_keys!.should == @fixnums
+  end
+
+  it "deep symbolize keys preserves fixnum keys" do
+    @nested_fixnums.deep_symbolize_keys.should == @nested_fixnums
+    @nested_fixnums.deep_dup.deep_symbolize_keys!.should == @nested_fixnums
+  end
+
+  it "stringify keys" do
+    @symbols.stringify_keys.should == @strings
+    @strings.stringify_keys.should == @strings
+    @mixed.stringify_keys.should == @strings
+  end
+
+  it "stringify keys not mutates" do
+    transformed_hash = @mixed.dup
+    transformed_hash.stringify_keys
+    transformed_hash.should == @mixed
+  end
+
+  it "deep stringify keys" do
+    @nested_symbols.deep_stringify_keys.should == @nested_strings
+    @nested_strings.deep_stringify_keys.should == @nested_strings
+    @nested_mixed.deep_stringify_keys.should == @nested_strings
+  end
+
+  it "deep stringify keys not mutates" do
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_stringify_keys
+    transformed_hash.should == @nested_mixed
+  end
+
+  it "stringify keys!" do
+    @symbols.dup.stringify_keys!.should == @strings
+    @strings.dup.stringify_keys!.should == @strings
+    @mixed.dup.stringify_keys!.should == @strings
+  end
+
+  it "stringify keys with bang mutates" do
+    transformed_hash = @mixed.dup
+    transformed_hash.stringify_keys!
+    transformed_hash.should == @strings
+    { :a => 1, "b" => 2 }.should.equal(@mixed)
+  end
+
+  it "deep stringify keys!" do
+    @nested_symbols.deep_dup.deep_stringify_keys!.should == @nested_strings
+    @nested_strings.deep_dup.deep_stringify_keys!.should == @nested_strings
+    @nested_mixed.deep_dup.deep_stringify_keys!.should == @nested_strings
+  end
+
+  it "deep stringify keys with bang mutates" do
+    transformed_hash = @nested_mixed.deep_dup
+    transformed_hash.deep_stringify_keys!
+    transformed_hash.should == @nested_strings
+    { 'a' => { :b => { 'c' => 3 } } }.should == @nested_mixed
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: motion_support
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -62,6 +62,11 @@ files:
 - lib/motion_support/core_ext/array.rb
 - lib/motion_support/core_ext/array/extract_options.rb
 - lib/motion_support/core_ext/array/prepend_append.rb
+- lib/motion_support/core_ext/hash.rb
+- lib/motion_support/core_ext/hash/keys.rb
+- lib/motion_support/core_ext/object.rb
+- lib/motion_support/core_ext/object/deep_dup.rb
+- lib/motion_support/core_ext/object/duplicable.rb
 - lib/motion_support/core_ext/string.rb
 - lib/motion_support/core_ext/string/inflections.rb
 - lib/motion_support/inflections.rb
@@ -72,6 +77,9 @@ files:
 - motion/concern.rb
 - motion/core_ext/array/extract_options.rb
 - motion/core_ext/array/prepend_append.rb
+- motion/core_ext/hash/keys.rb
+- motion/core_ext/object/deep_dup.rb
+- motion/core_ext/object/duplicable.rb
 - motion/core_ext/string/inflections.rb
 - motion/inflections.rb
 - motion/inflector/inflections.rb
@@ -80,6 +88,7 @@ files:
 - spec/concern_spec.rb
 - spec/core_ext/array/extract_options_spec.rb
 - spec/core_ext/array/prepend_append_spec.rb
+- spec/core_ext/hash/keys_spec.rb
 - spec/helpers/constantize_test_cases.rb
 - spec/helpers/dup.rb
 - spec/helpers/inflector_test_cases.rb
@@ -98,7 +107,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2308112850745967264
+      hash: 1428780749232898209
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -107,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2308112850745967264
+      hash: 1428780749232898209
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -118,6 +127,7 @@ test_files:
 - spec/concern_spec.rb
 - spec/core_ext/array/extract_options_spec.rb
 - spec/core_ext/array/prepend_append_spec.rb
+- spec/core_ext/hash/keys_spec.rb
 - spec/helpers/constantize_test_cases.rb
 - spec/helpers/dup.rb
 - spec/helpers/inflector_test_cases.rb