cmis-ruby 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98f7dbcd1d1ddca41c48e3228ce8f22ca705fa8c
-  data.tar.gz: 155fd2cbcd5b7a81afc1f2a2ab5e77358fed8b2d
+  metadata.gz: 5751d356e36de24bbaf807339790fa700b49cb2a
+  data.tar.gz: cff1e6160d5765ea6ff4c439fe0025558fe4d3d5
 SHA512:
-  metadata.gz: 52aec11a763819d3c7d5a057fde58fd42ceb9b873c3116e3d4529abbc8edcbf8885748d34dc6f62ecfa414f10570fe650c7d50c59e8f918f0966f9b8cede3b51
-  data.tar.gz: aa6c9538b99d3a4984f18f3b7ff8f2fcdd4e40e562e7dc93d581cbf98c20d16cc41f4bf6fe9b07e1f5ee0bc7e7ae6e5fa42c36902fbc96953fbb437da0ebd5e4
+  metadata.gz: 786a246df433f641fb8c1a9286bebfcda5d48427ec9617a8e1934a354f9c2592220b8e65963bbd04fd5d71ed9a64c082b79305d4e3a59553e1b9c7a49041b9dd
+  data.tar.gz: 00cec2e7f2df17bf8f7b275b8f78d0013981c3c33883af830a96b0554fe0751706ad70514c7bfef861b08a8a7c302b53749185b959181158434dda7ab3fc2514

data/lib/cmis/connection/response_parser.rb

@@ -1,5 +1,3 @@
-require 'core_ext/array/indifferent_access'
-require 'core_ext/hash/indifferent_access'
 require 'faraday'
 require 'json'
 
@@ -15,7 +13,7 @@ module CMIS
             raise Exceptions::Unauthorized
           else
             if env[:response_headers][:content_type] =~ JSON_CONTENT_TYPE
-              env[:body] = JSON.parse(env[:body]).with_indifferent_access
+              env[:body] = JSON.parse(env[:body])
               check_for_cmis_exception!(env[:body])
             end
           end
@@ -27,8 +25,8 @@ module CMIS
       def check_for_cmis_exception!(body)
         return unless body.is_a?(Hash)
 
-        if exception = body[:exception]
-          raise exception_class(exception), "#{exception}: #{body[:message]}"
+        if exception = body['exception']
+          raise exception_class(exception), "#{exception}: #{body['message']}"
         end
       end
 

data/lib/cmis/helpers.rb

@@ -1,4 +1,3 @@
-require 'core_ext/hash/indifferent_access'
 require 'core_ext/string/underscore'
 
 module CMIS
@@ -54,16 +53,14 @@ module CMIS
 
     def get_properties_map(raw)
       if raw['succinctProperties']
-        result = raw['succinctProperties']
+        raw['succinctProperties']
       elsif raw['properties']
-        result = raw['properties'].reduce({}) do |h, (k, v)|
+        raw['properties'].reduce({}) do |h, (k, v)|
           h.merge(k => sanitize(v))
         end
       else
-        result = {}
+        {}
       end
-
-      result.with_indifferent_access
     end
 
     def sanitize(prop)

data/lib/cmis/property_definition.rb

@@ -1,11 +1,10 @@
-require 'core_ext/hash/indifferent_access'
+require 'core_ext/hash/keys'
 require 'core_ext/string/underscore'
 
 module CMIS
   class PropertyDefinition
     def initialize(hash = {})
-      @hash = hash.with_indifferent_access
-
+      @hash = hash.stringify_keys
       @hash.each_key do |key|
         self.class.class_eval "def #{key.underscore};@hash['#{key}'];end"
         self.class.class_eval "def #{key.underscore}=(value);@hash['#{key}']=value;end"

data/lib/cmis/type.rb

@@ -1,4 +1,4 @@
-require 'core_ext/hash/indifferent_access'
+require 'core_ext/hash/keys'
 require 'core_ext/string/underscore'
 require 'json'
 
@@ -8,7 +8,7 @@ module CMIS
 
     def initialize(hash, repository)
       @repository = repository
-      @hash = hash.with_indifferent_access
+      @hash = hash.deep_stringify_keys
 
       properties = %w( id localName localNamespace queryName displayName baseId
                        parentId description creatable fileable queryable
@@ -21,14 +21,15 @@ module CMIS
         self.class.class_eval "def #{key.underscore}=(value);@hash['#{key}']=value;end"
       end
 
-      @hash['propertyDefinitions'] ||= HashWithIndifferentAccess.new
+      @hash['propertyDefinitions'] ||= {}
       @hash['propertyDefinitions'].each do |key, value|
         @hash['propertyDefinitions'][key] = PropertyDefinition.new(value)
       end
     end
 
     def add_property_definition(property)
-      property_definitions[property[:id]] = property
+      property.stringify_keys!
+      property_definitions[property['id']] = property
     end
 
     def create
@@ -36,8 +37,9 @@ module CMIS
     end
 
     def update(changed_property_defs, opts = {})
+      changed_property_defs.deep_stringify_keys!
       new_defs = changed_property_defs.map(&:to_hash).reduce({}) do |result, element|
-        result[element[:id]] = element
+        result[element['id']] = element
         result
       end
 

data/lib/cmis/version.rb

@@ -1,3 +1,3 @@
 module CMIS
-  VERSION = '0.4.2'
+  VERSION = '0.4.3'
 end

data/spec/cmis-ruby/object_spec.rb

@@ -59,9 +59,9 @@ module CMIS
     describe '#acls' do
       it 'returns acls' do
         acls = @document.acls
-        expect(acls).to have_key(:aces)
-        expect(acls).to have_key(:isExact)
-        expect([true, false]).to include(acls[:isExact])
+        expect(acls).to have_key('aces')
+        expect(acls).to have_key('isExact')
+        expect([true, false]).to include(acls['isExact'])
       end
     end
 

data/spec/spec_helper.rb

@@ -10,14 +10,14 @@ module SpecHelpers
     @@server ||= CMIS::Server.new(options['server'])
   end
 
-  def repository
-    @@repository ||= server.repository(repository_id)
-  end
-
   def repository_id
     @@repository_id ||= options['repository']
   end
 
+  def repository
+    @@repository ||= server.repository(repository_id)
+  end
+
   private
 
   def options

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cmis-ruby
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Kenneth Geerts
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-27 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -68,9 +68,7 @@ files:
 - lib/cmis/server.rb
 - lib/cmis/type.rb
 - lib/cmis/version.rb
-- lib/core_ext/array/indifferent_access.rb
 - lib/core_ext/hash/compact.rb
-- lib/core_ext/hash/indifferent_access.rb
 - lib/core_ext/hash/keys.rb
 - lib/core_ext/hash/slice.rb
 - lib/core_ext/string/underscore.rb

data/lib/core_ext/array/indifferent_access.rb

@@ -1,14 +0,0 @@
-class Array
-  def with_indifferent_access
-    map do |value|
-      case value
-      when Hash
-        value.with_indifferent_access
-      when Array
-        value.with_indifferent_access
-      else
-        value
-      end
-    end
-  end
-end

data/lib/core_ext/hash/indifferent_access.rb

@@ -1,288 +0,0 @@
-require 'core_ext/hash/keys'
-
-# Implements a hash where keys <tt>:foo</tt> and <tt>"foo"</tt> are considered
-# to be the same.
-#
-#   rgb = HashWithIndifferentAccess.new
-#
-#   rgb[:black] = '#000000'
-#   rgb[:black]  # => '#000000'
-#   rgb['black'] # => '#000000'
-#
-#   rgb['white'] = '#FFFFFF'
-#   rgb[:white]  # => '#FFFFFF'
-#   rgb['white'] # => '#FFFFFF'
-#
-# Internally symbols are mapped to strings when used as keys in the entire
-# writing interface (calling <tt>[]=</tt>, <tt>merge</tt>, etc). This
-# mapping belongs to the public interface. For example, given:
-#
-#   hash = HashWithIndifferentAccess.new(a: 1)
-#
-# You are guaranteed that the key is returned as a string:
-#
-#   hash.keys # => ["a"]
-#
-# Technically other types of keys are accepted:
-#
-#   hash = HashWithIndifferentAccess.new(a: 1)
-#   hash[0] = 0
-#   hash # => {"a"=>1, 0=>0}
-#
-# but this class is intended for use cases where strings or symbols are the
-# expected keys and it is convenient to understand both as the same. For
-# example the +params+ hash in Ruby on Rails.
-#
-# Note that core extensions define <tt>Hash#with_indifferent_access</tt>:
-#
-#   rgb = { black: '#000000', white: '#FFFFFF' }.with_indifferent_access
-#
-# which may be handy.
-class HashWithIndifferentAccess < Hash
-  # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
-  # this class.
-  def extractable_options?
-    true
-  end
-
-  def with_indifferent_access
-    dup
-  end
-
-  def nested_under_indifferent_access
-    self
-  end
-
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash)
-      super()
-      update(constructor)
-    else
-      super(constructor)
-    end
-  end
-
-  def default(key = nil)
-    if key.is_a?(Symbol) && include?(key = key.to_s)
-      self[key]
-    else
-      super
-    end
-  end
-
-  def self.new_from_hash_copying_default(hash)
-    new(hash).tap do |new_hash|
-      new_hash.default = hash.default
-    end
-  end
-
-  def self.[](*args)
-    new.merge!(Hash[*args])
-  end
-
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  # Assigns a new value to the hash:
-  #
-  #   hash = HashWithIndifferentAccess.new
-  #   hash[:key] = 'value'
-  #
-  # This value can be later fetched using either +:key+ or +'key'+.
-  def []=(key, value)
-    regular_writer(convert_key(key), convert_value(value, for: :assignment))
-  end
-
-  alias_method :store, :[]=
-
-  # Updates the receiver in-place, merging in the hash passed as argument:
-  #
-  #   hash_1 = HashWithIndifferentAccess.new
-  #   hash_1[:key] = 'value'
-  #
-  #   hash_2 = HashWithIndifferentAccess.new
-  #   hash_2[:key] = 'New Value!'
-  #
-  #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
-  #
-  # The argument can be either an
-  # <tt>HashWithIndifferentAccess</tt> or a regular +Hash+.
-  # In either case the merge respects the semantics of indifferent access.
-  #
-  # If the argument is a regular hash with keys +:key+ and +"key"+ only one
-  # of the values end up in the receiver, but which one is unspecified.
-  #
-  # When given a block, the value for duplicated keys will be determined
-  # by the result of invoking the block with the duplicated key, the value
-  # in the receiver, and the value in +other_hash+. The rules for duplicated
-  # keys follow the semantics of indifferent access:
-  #
-  #   hash_1[:key] = 10
-  #   hash_2['key'] = 12
-  #   hash_1.update(hash_2) { |key, old, new| old + new } # => {"key"=>22}
-  def update(other_hash)
-    if other_hash.is_a? HashWithIndifferentAccess
-      super(other_hash)
-    else
-      other_hash.each_pair do |key, value|
-        if block_given? && key?(key)
-          value = yield(convert_key(key), self[key], value)
-        end
-        regular_writer(convert_key(key), convert_value(value))
-      end
-      self
-    end
-  end
-
-  alias_method :merge!, :update
-
-  # Checks the hash for a key matching the argument passed in:
-  #
-  #   hash = HashWithIndifferentAccess.new
-  #   hash['key'] = 'value'
-  #   hash.key?(:key)  # => true
-  #   hash.key?('key') # => true
-  def key?(key)
-    super(convert_key(key))
-  end
-
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
-
-  # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
-  # either a string or a symbol:
-  #
-  #   counters = HashWithIndifferentAccess.new
-  #   counters[:foo] = 1
-  #
-  #   counters.fetch('foo')          # => 1
-  #   counters.fetch(:bar, 0)        # => 0
-  #   counters.fetch(:bar) { |key| 0 } # => 0
-  #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
-  end
-
-  # Returns an array of the values at the specified indices:
-  #
-  #   hash = HashWithIndifferentAccess.new
-  #   hash[:a] = 'x'
-  #   hash[:b] = 'y'
-  #   hash.values_at('a', 'b') # => ["x", "y"]
-  def values_at(*indices)
-    indices.collect { |key| self[convert_key(key)] }
-  end
-
-  # Returns an exact copy of the hash.
-  def dup
-    self.class.new(self).tap do |new_hash|
-      new_hash.default = default
-    end
-  end
-
-  # This method has the same semantics of +update+, except it does not
-  # modify the receiver but rather returns a new hash with indifferent
-  # access with the result of the merge.
-  def merge(hash, &block)
-    self.dup.update(hash, &block)
-  end
-
-  # Like +merge+ but the other way around: Merges the receiver into the
-  # argument and returns a new hash with indifferent access as result:
-  #
-  #   hash = HashWithIndifferentAccess.new
-  #   hash['a'] = nil
-  #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
-  def reverse_merge(other_hash)
-    super(self.class.new_from_hash_copying_default(other_hash))
-  end
-
-  # Same semantics as +reverse_merge+ but modifies the receiver in-place.
-  def reverse_merge!(other_hash)
-    replace(reverse_merge( other_hash ))
-  end
-
-  # Replaces the contents of this hash with other_hash.
-  #
-  #   h = { "a" => 100, "b" => 200 }
-  #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
-  def replace(other_hash)
-    super(self.class.new_from_hash_copying_default(other_hash))
-  end
-
-  # Removes the specified key from the hash.
-  def delete(key)
-    super(convert_key(key))
-  end
-
-  def stringify_keys!; self end
-  def deep_stringify_keys!; self end
-  def stringify_keys; dup end
-  def deep_stringify_keys; dup end
-  undef :symbolize_keys!
-  undef :deep_symbolize_keys!
-  def symbolize_keys; to_hash.symbolize_keys! end
-  def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
-  def to_options!; self end
-
-  def select(*args, &block)
-    dup.tap { |hash| hash.select!(*args, &block) }
-  end
-
-  def reject(*args, &block)
-    dup.tap { |hash| hash.reject!(*args, &block) }
-  end
-
-  # Convert to a regular hash with string keys.
-  def to_hash
-    _new_hash= {}
-    each do |key, value|
-      _new_hash[convert_key(key)] = convert_value(value, for: :to_hash)
-    end
-    Hash.new(default).merge!(_new_hash)
-  end
-
-  protected
-  def convert_key(key)
-    key.kind_of?(Symbol) ? key.to_s : key
-  end
-
-  def convert_value(value, options = {})
-    if value.is_a? Hash
-      if options[:for] == :to_hash
-        value.to_hash
-      else
-        value.nested_under_indifferent_access
-      end
-    elsif value.is_a?(Array)
-      unless options[:for] == :assignment
-        value = value.dup
-      end
-      value.map! { |e| convert_value(e, options) }
-    else
-      value
-    end
-  end
-end
-
-class Hash
-  # Returns a <tt>HashWithIndifferentAccess</tt> out of its receiver:
-  #
-  #   { a: 1 }.with_indifferent_access['a'] # => 1
-  def with_indifferent_access
-    HashWithIndifferentAccess.new_from_hash_copying_default(self)
-  end
-
-  # Called when object is nested under an object that receives
-  # #with_indifferent_access. This method will be called on the current object
-  # by the enclosing object and is aliased to #with_indifferent_access by
-  # default. Subclasses of Hash may overwrite this method to return +self+ if
-  # converting to an <tt>HashWithIndifferentAccess</tt> would not be
-  # desirable.
-  #
-  #   b = { b: 1 }
-  #   { a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
-  #   # => {"b"=>32}
-  alias nested_under_indifferent_access with_indifferent_access
-end