cmis-ruby 0.5.27 → 0.5.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20241ffbac494304de2f6b3040e8dc5694caa336
-  data.tar.gz: 1e3c05723c15c72bee5763d251a854e083495a9d
+  metadata.gz: c1c897e1a19d696085646c92c0fc1c63500765a7
+  data.tar.gz: 627e5e1aaeca5ff09435f4f6f04654cf14433958
 SHA512:
-  metadata.gz: 660254a432b7e889a797e8f4acb502e3ccceeb461df8a85e87744279f6fcce14d09aa95ecbf098c08c33891d8e754b176f926cdd4be682692f4fb806f187caa1
-  data.tar.gz: bbc22a2faa241375b5a1ae3be5579d3a72ec447e63d248c2d5f92e9170be1450e13908f81f70e1a3ffca380f2e17970701b8ffbd495a1cd5fd864f6c7c36b2a2
+  metadata.gz: ad4518ef5d0e1150bd7c62ee17dfc333dff16ab0bd0921867334235c664173702f8770eda6d4e2a93cf26bf29ec32e73ee844b8a7891768512604ba8e1cd1227
+  data.tar.gz: 30ed1ea6be7428319cc65ffd86e00f6a235a0f6cb0cd0bd678102d2f8b4d242f83ad38d3ccd56a53089fcae93498aa61beab3d6c6fbf17c3bb328138a306fb17

data/lib/cmis.rb

@@ -1,4 +1,7 @@
-require 'ext/all'
+require 'ext/hash/except'
+require 'ext/hash/keys'
+require 'ext/hash/slice'
+require 'ext/string/as_ruby_property'
 
 require 'cmis/exceptions'
 require 'cmis/helpers'

data/lib/cmis/version.rb

@@ -1,3 +1,3 @@
 module CMIS
-  VERSION = '0.5.27'
+  VERSION = '0.5.28'
 end

data/lib/ext/hash/except.rb

@@ -0,0 +1,22 @@
+class Hash
+  # Returns a hash that includes everything except given keys.
+  #   hash = { a: true, b: false, c: nil }
+  #   hash.except(:c)     # => { a: true, b: false }
+  #   hash.except(:a, :b) # => { c: nil }
+  #   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].except(:admin))
+  def except(*keys)
+    dup.except!(*keys)
+  end
+
+  # Removes the given keys from hash and returns it.
+  #   hash = { a: true, b: false, c: nil }
+  #   hash.except!(:c) # => { a: true, b: false }
+  #   hash             # => { a: true, b: false }
+  def except!(*keys)
+    keys.each { |key| delete(key) }
+    self
+  end
+end

data/lib/ext/hash/keys.rb

@@ -1,21 +1,27 @@
 class Hash
-  # Returns a new hash with all keys converted using the block operation.
+  # Returns 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"}
+  #  hash.transform_keys { |key| key.to_s.upcase } # => {"NAME"=>"Rob", "AGE"=>"28"}
+  #
+  # If you do not provide a +block+, it will return an Enumerator
+  # for chaining with other methods:
+  #
+  #  hash.transform_keys.with_index { |k, i| [k, i].join } # => {"name0"=>"Rob", "age1"=>"28"}
   def transform_keys
-    result = {}
+    return enum_for(:transform_keys) { size } unless block_given?
+    result = self.class.new
     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+.
+  # Destructively converts all keys using the +block+ operations.
+  # Same as +transform_keys+ but modifies +self+.
   def transform_keys!
+    return enum_for(:transform_keys!) { size } unless block_given?
     keys.each do |key|
       self[yield(key)] = delete(key)
     end
@@ -27,15 +33,15 @@ class Hash
   #   hash = { name: 'Rob', age: '28' }
   #
   #   hash.stringify_keys
-  #   # => { "name" => "Rob", "age" => "28" }
+  #   # => {"name"=>"Rob", "age"=>"28"}
   def stringify_keys
-    transform_keys{ |key| key.to_s }
+    transform_keys(&:to_s)
   end
 
-  # Destructively convert all keys to strings. Same as
+  # Destructively converts all keys to strings. Same as
   # +stringify_keys+, but modifies +self+.
   def stringify_keys!
-    transform_keys!{ |key| key.to_s }
+    transform_keys!(&:to_s)
   end
 
   # Returns a new hash with all keys converted to symbols, as long as
@@ -44,22 +50,24 @@ class Hash
   #   hash = { 'name' => 'Rob', 'age' => '28' }
   #
   #   hash.symbolize_keys
-  #   # => { name: "Rob", age: "28" }
+  #   # => {: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
+  # Destructively converts 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 <tt>*valid_keys</tt>, 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.
+  # Validates all keys in a hash match <tt>*valid_keys</tt>, raising
+  # +ArgumentError+ on a mismatch.
+  #
+  # Note that keys are treated differently than HashWithIndifferentAccess,
+  # meaning that string and symbol keys will not match.
   #
   #   { name: 'Rob', years: '28' }.assert_valid_keys(:name, :age) # => raises "ArgumentError: Unknown key: :years. Valid keys are: :name, :age"
   #   { name: 'Rob', age: '28' }.assert_valid_keys('name', 'age') # => raises "ArgumentError: Unknown key: :name. Valid keys are: 'name', 'age'"
@@ -75,53 +83,45 @@ class Hash
 
   # 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.
+  # nested hashes and arrays.
   #
   #  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
+    _deep_transform_keys_in_object(self, &block)
   end
 
-  # Destructively convert all keys by using the block operation.
+  # Destructively converts all keys by using the block operation.
   # This includes the keys from the root hash and from all
-  # nested hashes.
+  # nested hashes and arrays.
   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
+    _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.
+  # nested hashes and arrays.
   #
   #   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 }
+    deep_transform_keys(&:to_s)
   end
 
-  # Destructively convert all keys to strings.
+  # Destructively converts all keys to strings.
   # This includes the keys from the root hash and from all
-  # nested hashes.
+  # nested hashes and arrays.
   def deep_stringify_keys!
-    deep_transform_keys!{ |key| key.to_s }
+    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 from all nested hashes and arrays.
   #
   #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
   #
@@ -131,10 +131,40 @@ class Hash
     deep_transform_keys{ |key| key.to_sym rescue key }
   end
 
-  # Destructively convert all keys to symbols, as long as they respond
+  # 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.
+  # nested hashes and arrays.
   def deep_symbolize_keys!
     deep_transform_keys!{ |key| key.to_sym rescue key }
   end
+
+  private
+    # support methods for deep transforming nested hashes and arrays
+    def _deep_transform_keys_in_object(object, &block)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+        end
+      when Array
+        object.map {|e| _deep_transform_keys_in_object(e, &block) }
+      else
+        object
+      end
+    end
+
+    def _deep_transform_keys_in_object!(object, &block)
+      case object
+      when Hash
+        object.keys.each do |key|
+          value = object.delete(key)
+          object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+        end
+        object
+      when Array
+        object.map! {|e| _deep_transform_keys_in_object!(e, &block)}
+      else
+        object
+      end
+    end
 end

data/lib/ext/hash/slice.rb

@@ -1,6 +1,12 @@
 class Hash
-  # Slice a hash to include only the given keys. This is useful for
-  # limiting an options hash to valid keys before passing to a method:
+  # Slices a hash to include only the given keys. Returns a hash containing
+  # the given keys.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.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)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cmis-ruby
 version: !ruby/object:Gem::Version
-  version: 0.5.27
+  version: 0.5.28
 platform: ruby
 authors:
 - Kenneth Geerts
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2016-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -77,7 +77,7 @@ files:
 - lib/cmis/type.rb
 - lib/cmis/utils.rb
 - lib/cmis/version.rb
-- lib/ext/all.rb
+- lib/ext/hash/except.rb
 - lib/ext/hash/keys.rb
 - lib/ext/hash/slice.rb
 - lib/ext/string/as_ruby_property.rb

data/lib/ext/all.rb

@@ -1,4 +0,0 @@
-require 'ext/hash/keys'
-require 'ext/hash/slice'
-
-require 'ext/string/as_ruby_property'