cmis-ruby 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 54d939c76212d26bf61e62941fc9c8befd44bd32
-  data.tar.gz: a46f072f12e9309b00334e1c184c9250fd887539
+  metadata.gz: 3fefeee566f1ed7d06b802fe303f25b0dca90680
+  data.tar.gz: 02ed43827b5019697f254b7ebc1fe1ed9b26f00a
 SHA512:
-  metadata.gz: c369361121888cbd294e8c897b153b677377dc115fb31924d46e25cd3c4eb9e24ffdba3081c13a95be8ebf4d490504264b3942febaaade37d43eb10e07f4cb21
-  data.tar.gz: 5c8d73ce97ec3a0b873825e8cb9c1247c9b3ef3529469d03182da7d96a83627a7424003f901d3dd560d7b92a51171eed936227ad0c26072897888857acfd393e
+  metadata.gz: ac6b9a79e134b783db1fdc7a87ec914cfb9e3719dcd56ffbe2c95e29fc355fc6f6da8288b1d0f281cf35b50d4df4da7feedeea42288dfbcf95a21d31fb124720
+  data.tar.gz: f90b18091fd8c2759e492c524561a75dfc70d50fcdf7adb49cf6561c65c13e14025338987851619fe44825a211618cf435a86d5da4c061e8b9f53b1932e84260

data/.travis.yml

@@ -1,6 +1,11 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
+- 2.0.0
+# - 1.9.3
+# - 2.1.0
 env:
-  - TEST_ENV=alfresco
+  matrix:
+  - TEST_ENV=ci
+  global:
+  - secure: PwEKZ/1SJmQQzWeGa1y7EKkIHbfcPrM2jalmCYdPcmJ8Yyp0t/0PbRXmc75QRBjFwkkGo/q1kyfdAImAtqmnTEMToaxoDAJw+DbSjbhN1n3e7heD5eFjaqUtUVZsf1LKR6cXO/L6ZdeNBcQwwlbwN+8I5QJjW0NJGADME+zerP0=
+  - secure: SJRgR4WQzUisGk2Og18WbIsfqRCTIctUVjyEGPptYtLtEVo18A3O46MUZAlm6vyHAMpdq+u35KRw2xdJh7hkYg5yTp6jZG0aziDlhiNn6eOUaH/VZ/xBIZiSj+ceFxaq1G4UjfQnxJMqoadsjhApnNE2iQkgme5izXqmLY0e3tc=

data/cmis-ruby.gemspec

@@ -20,7 +20,6 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.3'
 
   s.add_dependency        'faraday', '~> 0.9'
-  s.add_dependency        'activesupport', '>= 3.2', '< 5.0'
 
   s.description = <<-DESCRIPTION
 CMIS browser binding client library in ruby.

data/lib/cmis-ruby.rb

@@ -1,6 +1,3 @@
-require 'active_support/core_ext'
-require 'core_ext'
-
 require 'cmis/exceptions'
 require 'cmis/helpers'
 require 'cmis/object_factory'

data/lib/cmis/children.rb

@@ -1,12 +1,14 @@
 require 'bigdecimal'
 require 'cmis/query_result'
+require 'core_ext/hash/keys'
+require 'core_ext/hash/slice'
 
 module CMIS
   class Children
     # Options: from, page_size
     def initialize(folder, options = {})
       @folder = folder
-      @options = options.stringify_keys!
+      @options = options.symbolize_keys
 
       init_options
     end
@@ -64,19 +66,19 @@ module CMIS
     private
 
     def init_options
-      @max_items = @options['page_size'] || 10
-      @skip_count = @options['from'] || 0
-      @order_by = @options['order_by']
-      @filter = @options['filter']
-      @include_relationships = @options['include_relationships']
+      @max_items = @options[:page_size] || 10
+      @skip_count = @options[:from] || 0
+      @order_by = @options[:order_by]
+      @filter = @options[:filter]
+      @include_relationships = @options[:include_relationships]
       @has_next = true
 
-      @opts = @options.slice('query', 'headers')
+      @opts = @options.slice(:query, :headers)
     end
 
     def parse_limit(options)
-      options.stringify_keys!
-      limit = options['limit'] || 10
+      options.symbolize_keys!
+      limit = options[:limit] || 10
       limit = BigDecimal::INFINITY if limit == :all
       raise 'Not a valid limit' unless limit.is_a? Numeric
       limit

data/lib/cmis/connection.rb

@@ -1,8 +1,10 @@
-require 'faraday'
-require 'cmis/version'
-require 'cmis/connection/url_resolver'
 require 'cmis/connection/request_modifier'
 require 'cmis/connection/response_parser'
+require 'cmis/connection/url_resolver'
+require 'cmis/version'
+require 'core_ext/hash/compact'
+require 'core_ext/hash/keys'
+require 'faraday'
 
 module CMIS
   class Connection
@@ -37,6 +39,7 @@ module CMIS
     end
 
     def execute!(params = {}, options = {})
+      params.symbolize_keys!
       options.symbolize_keys!
 
       query = options[:query] || {}

data/lib/cmis/connection/request_modifier.rb

@@ -1,3 +1,4 @@
+require 'core_ext/hash/compact'
 require 'faraday'
 
 module CMIS

data/lib/cmis/connection/response_parser.rb

@@ -1,31 +1,42 @@
+require 'core_ext/array/indifferent_access'
+require 'core_ext/hash/indifferent_access'
 require 'faraday'
 require 'json'
 
 module CMIS
   class Connection
     class ResponseParser < Faraday::Middleware
-      JSON_CONTENT_TYPE = /\/(x-)?json(;.+?)?$/
+      JSON_CONTENT_TYPE = /\/(x-)?json(;.+?)?$/i.freeze
 
       def call(env)
         @app.call(env).on_complete do |env|
-          if env[:response_headers][:content_type] =~ JSON_CONTENT_TYPE
-            env[:body] = JSON.parse(env[:body]).with_indifferent_access
-            check_for_exception!(env[:body])
+          case env[:status]
+          when 401
+            raise Exceptions::Unauthorized
+          else
+            if env[:response_headers][:content_type] =~ JSON_CONTENT_TYPE
+              env[:body] = JSON.parse(env[:body]).with_indifferent_access
+              check_for_cmis_exception!(env[:body])
+            end
           end
         end
       end
 
       private
 
-      def check_for_exception!(body)
+      def check_for_cmis_exception!(body)
         return unless body.is_a?(Hash)
 
-        if ex = body[:exception]
-          ruby_exception = "CMIS::Exceptions::#{ex.camelize}".constantize
-          message = "#{ex.underscore.humanize}: #{body[:message]}"
-          raise ruby_exception, message
+        if exception = body[:exception]
+          raise exception_class(exception), "#{exception}: #{body[:message]}"
         end
       end
+
+      def exception_class(exception)
+        clazz = exception.dup
+        clazz[0] = clazz[0].upcase
+        CMIS::Exceptions.const_get(clazz)
+      end
     end
   end
 end

data/lib/cmis/connection/url_resolver.rb

@@ -4,34 +4,22 @@ module CMIS
       def initialize(http, service_url)
         @http = http
         @service_url = service_url
-        @cache = {}
+        @repository_infos = {}
       end
 
       def url(repository_id, object_id)
-        return @service_url if repository_id.nil?
+        return @service_url unless repository_id
 
-        urls = repository_urls(repository_id)
-        urls[object_id ? :root_folder_url : :repository_url]
-      end
-
-      private
-
-      def repository_urls(repository_id)
-        if @cache[repository_id].nil?
-          repository_infos = @http.get(@service_url).body
-
-          unless repository_infos.has_key?(repository_id)
-            raise Exceptions::ObjectNotFound, "repositoryId: #{repository_id}"
-          end
-
-          repository_info = repository_infos[repository_id]
-          @cache[repository_id] = {
-            repository_url:  repository_info[:repositoryUrl],
-            root_folder_url: repository_info[:rootFolderUrl]
-          }
+        unless @repository_infos.key?(repository_id)
+          @repository_infos = @http.get(@service_url).body
         end
 
-        @cache[repository_id]
+        if @repository_infos.key?(repository_id)
+          key = object_id ? 'rootFolderUrl' : 'repositoryUrl'
+          @repository_infos[repository_id][key]
+        else
+          raise Exceptions::ObjectNotFound, "repositoryId: #{repository_id}"
+        end
       end
     end
   end

data/lib/cmis/document.rb

@@ -1,3 +1,5 @@
+require 'core_ext/hash/keys'
+
 module CMIS
   class Document < Object
     def initialize(raw, repository)
@@ -46,10 +48,10 @@ module CMIS
     end
 
     def content=(opts = {})
-      opts.stringify_keys!
-      content = { stream: opts.delete('stream'),
-                  mime_type: opts.delete('mime_type'),
-                  filename: opts.delete('filename') }
+      opts.symbolize_keys!
+      content = { stream: opts.delete(:stream),
+                  mime_type: opts.delete(:mime_type),
+                  filename: opts.delete(:filename) }
 
       if content[:stream].is_a? String
         content[:stream] = StringIO.new(content[:stream])

data/lib/cmis/exceptions.rb

@@ -13,5 +13,8 @@ module CMIS
     class StreamNotSupported      < Exception; end
     class UpdateConflict          < Exception; end
     class Versioning              < Exception; end
+
+    # Non-CMIS
+    class Unauthorized            < Exception; end
   end
 end

data/lib/cmis/helpers.rb

@@ -1,3 +1,6 @@
+require 'core_ext/hash/indifferent_access'
+require 'core_ext/string/underscore'
+
 module CMIS
   module Helpers
     def initialize_properties(raw)
@@ -7,8 +10,8 @@ module CMIS
     def cmis_properties(properties)
       properties.each do |property_name|
         method_name = method_name(property_name)
-        class_eval "def #{method_name};@properties['#{property_name}'];end"
-        class_eval "def #{method_name}=(value);@properties['#{property_name}']=value;end"
+        self.class.class_eval "def #{method_name};@properties['#{property_name}'];end"
+        self.class.class_eval "def #{method_name}=(value);@properties['#{property_name}']=value;end"
       end
     end
 
@@ -50,8 +53,6 @@ module CMIS
     end
 
     def get_properties_map(raw)
-      raw = raw.with_indifferent_access
-
       if raw['succinctProperties']
         result = raw['succinctProperties']
       elsif raw['properties']

data/lib/cmis/property_definition.rb

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

data/lib/cmis/query.rb

@@ -1,5 +1,7 @@
 require 'bigdecimal'
 require 'cmis/query_result'
+require 'core_ext/hash/keys'
+require 'core_ext/hash/slice'
 
 module CMIS
   class Query
@@ -7,7 +9,7 @@ module CMIS
     def initialize(repository, statement, options = {})
       @repository = repository
       @statement = statement
-      @options = options.stringify_keys
+      @options = options.symbolize_keys
 
       init_options
     end
@@ -65,17 +67,17 @@ module CMIS
     private
 
     def init_options
-      @method = (@options['method'] || 'get').to_s.downcase
-      @max_items = @options['page_size'] || 10
-      @skip_count = @options['from'] || 0
+      @method = (@options[:method] || 'get').to_s.downcase
+      @max_items = @options[:page_size] || 10
+      @skip_count = @options[:from] || 0
       @has_next = true
 
-      @opts = @options.slice('query', 'headers')
+      @opts = @options.slice(:query, :headers)
     end
 
     def parse_limit(options)
-      options.stringify_keys!
-      limit = options['limit'] || 10
+      options.symbolize_keys!
+      limit = options[:limit] || 10
       limit = BigDecimal::INFINITY if limit == :all
       raise 'Not a valid limit' unless limit.is_a? Numeric
       limit

data/lib/cmis/relationships.rb

@@ -1,12 +1,14 @@
 require 'bigdecimal'
 require 'cmis/query_result'
+require 'core_ext/hash/keys'
+require 'core_ext/hash/slice'
 
 module CMIS
   class Relationships
     # Options: from, page_size
     def initialize(object, options = {})
       @object = object
-      @options = options.stringify_keys!
+      @options = options.symbolize_keys
 
       init_options
     end
@@ -64,19 +66,19 @@ module CMIS
     private
 
     def init_options
-      @max_items = @options['page_size'] || 10
-      @skip_count = @options['from'] || 0
-      @direction = @options['direction'] || :either
-      @include_subtypes = @options['include_subtypes']
-      @type_id = @options['type_id']
+      @max_items = @options[:page_size] || 10
+      @skip_count = @options[:from] || 0
+      @direction = @options[:direction] || :either
+      @include_subtypes = @options[:include_subtypes]
+      @type_id = @options[:type_id]
       @has_next = true
 
-      @opts = @options.slice('query', 'headers')
+      @opts = @options.slice(:query, :headers)
     end
 
     def parse_limit(options)
-      options.stringify_keys!
-      limit = options['limit'] || 10
+      options.symbolize_keys!
+      limit = options[:limit] || 10
       limit = BigDecimal::INFINITY if limit == :all
       raise 'Not a valid limit' unless limit.is_a? Numeric
       limit

data/lib/cmis/repository.rb

@@ -1,5 +1,6 @@
-require 'json'
 require 'cmis/query'
+require 'core_ext/string/underscore'
+require 'json'
 
 module CMIS
   class Repository
@@ -8,8 +9,8 @@ module CMIS
     def initialize(raw, server)
       @hash = raw
       @hash.each_key do |key|
-        class_eval "def #{key.underscore};@hash['#{key}'];end"
-        class_eval "def #{key.gsub('repository', '').underscore};@hash['#{key}'];end" if key =~ /^repository/
+        self.class.class_eval "def #{key.underscore};@hash['#{key}'];end"
+        self.class.class_eval "def #{key.gsub('repository', '').underscore};@hash['#{key}'];end" if key =~ /^repository/
       end
 
       @server = server
@@ -106,15 +107,27 @@ module CMIS
       Query.new(self, statement, opts)
     end
 
-    def find_object(type_id, properties, opts = {})
-      clause = properties.map { |k, v| "#{k}=#{normalize(v)}" }.join(' and ')
-      statement = "select * from #{type_id} where #{clause}"
+    def find_object(type_id, properties = {}, opts = {})
       opts.merge!(page_size: 1)
+      statement = construct_statement(type_id, properties)
       query(statement, opts).results.first
     end
 
+    def count_objects(type_id, properties = {}, opts = {})
+      opts.merge!(page_size: 0)
+      statement = construct_statement(type_id, properties)
+      query(statement, opts).total
+    end
+
     private
 
+    def construct_statement(type_id, properties)
+      statement = "select * from #{type_id}"
+      clause = properties.map { |k, v| "#{k}=#{normalize(v)}" }.join(' and ')
+      statement << " where #{clause}" unless clause.empty?
+      statement
+    end
+
     BACKSLASH = "\\"
     QUOTE = "\'"
 

data/lib/cmis/type.rb

@@ -1,3 +1,5 @@
+require 'core_ext/hash/indifferent_access'
+require 'core_ext/string/underscore'
 require 'json'
 
 module CMIS
@@ -15,11 +17,11 @@ module CMIS
                        contentStreamAllowed allowedSourceTypes allowedTargetTypes )
 
       properties.each do |key|
-        class_eval "def #{key.underscore};@hash['#{key}'];end"
-        class_eval "def #{key.underscore}=(value);@hash['#{key}']=value;end"
+        self.class.class_eval "def #{key.underscore};@hash['#{key}'];end"
+        self.class.class_eval "def #{key.underscore}=(value);@hash['#{key}']=value;end"
       end
 
-      @hash['propertyDefinitions'] ||= ActiveSupport::HashWithIndifferentAccess.new
+      @hash['propertyDefinitions'] ||= HashWithIndifferentAccess.new
       @hash['propertyDefinitions'].each do |key, value|
         @hash['propertyDefinitions'][key] = PropertyDefinition.new(value)
       end

data/lib/cmis/version.rb

@@ -1,3 +1,3 @@
 module CMIS
-  VERSION = '0.4.0'
+  VERSION = '0.4.1'
 end

data/lib/core_ext/hash/compact.rb

@@ -1,5 +1,3 @@
-# Added in active_support 4.1
-
 class Hash
   # Returns a hash with non +nil+ values.
   #

data/lib/core_ext/hash/indifferent_access.rb

@@ -0,0 +1,288 @@
+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

data/lib/core_ext/hash/keys.rb

@@ -0,0 +1,140 @@
+class Hash
+  # 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"}
+  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
+
+  # Returns 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
+
+  # Returns 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 <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.
+  #
+  #   { 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'"
+  #   { 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|
+      unless valid_keys.include?(k)
+        raise ArgumentError.new("Unknown key: #{k.inspect}. Valid keys are: #{valid_keys.map(&:inspect).join(', ')}")
+      end
+    end
+  end
+
+  # 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.
+  #
+  #  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
+
+  # Returns 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
+
+  # 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.
+  #
+  #   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/lib/core_ext/hash/slice.rb

@@ -0,0 +1,42 @@
+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:
+  #
+  #   def search(criteria = {})
+  #     criteria.assert_valid_keys(:mass, :velocity, :time)
+  #   end
+  #
+  #   search(options.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.slice(*valid_keys))
+  def 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 }.slice!(:a, :b)
+  #   # => {:c=>3, :d=>4}
+  def slice!(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    omit = slice(*self.keys - keys)
+    hash = 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 }.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
+  def extract!(*keys)
+    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
+  end
+end

data/lib/core_ext/string/underscore.rb

@@ -0,0 +1,8 @@
+class String
+  def underscore
+    word = self.dup
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.downcase!
+    word
+  end
+end

data/readme.md

@@ -5,20 +5,43 @@
 [![Build Status](https://travis-ci.org/UP-nxt/cmis-ruby.png?branch=master)](https://travis-ci.org/UP-nxt/cmis-ruby)
 [![Dependency Status](https://gemnasium.com/UP-nxt/cmis-ruby.png)](https://gemnasium.com/UP-nxt/cmis-ruby)
 
-**CMIS ruby** is a [CMIS](http://chemistry.apache.org/project/cmis.html) client library, using the the CMIS browser binding ([CMIS 1.1](http://docs.oasis-open.org/cmis/CMIS/v1.1/CMIS-v1.1.html)) for Ruby.
+**CMIS ruby** is a [CMIS](http://chemistry.apache.org/project/cmis.html) client library, using the the _CMIS Browser Binding_ ([CMIS 1.1](http://docs.oasis-open.org/cmis/CMIS/v1.1/CMIS-v1.1.html)).
 
-## Running specs
+## Example usage
+
+#### `CMIS::Server` and `CMIS::Repository`
+
+```ruby
+server = CMIS::Server.new(service_url: 'http://33.33.33.100:8080/browser',
+                          username: 'foo', password: 'bar')
+repository = server.repository('my_repository')
+```
+
+#### `CMIS::document`
 
-Running the tests requires a separate CMIS server. The default rake task runs the specs.
+```ruby
+# get by object id
+document = repository.object('f3y5wbb6slhkeq3ciu3uazbpxeu')
 
-## TODO
+# find by unique property
+document = repository.find_object('cmis:document', 
+                                  'cmis:name' => 'some_unique_name')
+
+# set content
+document.content = { stream: StringIO.new('Apple is a fruit'),
+                     mime_type: 'text/plain',
+                     filename: 'apple.txt' }
+
+# create a new document
+document = repository.new_document
+document.name = 'new_document'
+document.object_type_id = 'cmis:document'
+document = document.create_in_folder(repository.root)
+```
+
+## Running specs
 
-* remove ActiveSupport dependency:
-    * stringify_keys! -> to_options!
-    * symbolize_keys! -> to_options!
-    * compact!
-    * with_indifferent_access -> ?
-* caching
+The default rake task runs the specs. This requires a separate CMIS server. The environment variable `TEST_ENV` selects the test environment from `spec/config.yml`. The Travis build uses the private `ci` environment.
 
 ## Contributing
 

data/spec/cmis-ruby/repository_spec.rb

@@ -46,6 +46,17 @@ module CMIS
       end
     end
 
+    describe '#count_objects' do
+      it 'returns 1 folder (which is the root folder)' do
+        count = repository.count_objects('cmis:folder')
+        expect(count).to eq 1
+      end
+      it 'returns 0 documents' do
+        count = repository.count_objects('cmis:document')
+        expect(count).to eq 0
+      end
+    end
+
     describe '#new_[document|folder|relationship|item|policy|type]' do
       it 'returns the correct type' do
         expect(repository.new_document)     .to be_a Document

data/spec/cmis-ruby/server_spec.rb

@@ -1,3 +1,4 @@
+require 'securerandom'
 require 'spec_helper'
 
 module CMIS

data/spec/config.yml

@@ -3,6 +3,12 @@ local:
   server:
     service_url: http://33.33.33.100:8080/browser
   repository: test
+ci:
+  server:
+    service_url: https://cmis-service.ci.apps.up-nxt.com/browser
+    username: <%= ENV['CI_USERNAME'] %>
+    password: <%= ENV['CI_PASSWORD'] %>
+  repository: travis_cmis_ruby
 nuxeo:
   server:
     service_url: http://cmis.demo.nuxeo.com/nuxeo/json/cmis

data/spec/spec_helper.rb

@@ -1,33 +1,33 @@
 require 'cmis-ruby'
+require 'yaml'
+require 'erb'
 
 module SpecHelpers
-
   def server
-    @server ||= CMIS::Server.new(options['server'])
+    @@server ||= CMIS::Server.new(options['server'])
   end
 
   def repository
-    @repository ||= server.repository(options['repository'])
+    @@repository ||= server.repository(repository_id)
   end
 
   def repository_id
-    options['repository']
+    @@repository_id ||= options['repository']
   end
 
   private
 
   def options
-    file = File.join(File.dirname(File.expand_path(__FILE__)), 'config.yml')
-    config = YAML::load_file(file)
-    test_env = ENV['TEST_ENV'] || 'local'
+    path = File.join(File.dirname(File.expand_path(__FILE__)), 'config.yml')
+    config = YAML.load ERB.new(File.read(path)).result
 
+    test_env = ENV['TEST_ENV'] || 'local'
     if config.key?(test_env)
       config[test_env]
     else
-      raise "No configuration found for #{test_env}"
+      raise "No configuration found for environment `#{test_env}`"
     end
   end
-
 end
 
 RSpec.configure do |c|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cmis-ruby
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Kenneth Geerts
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-20 00:00:00.000000000 Z
+date: 2014-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -25,26 +25,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.2'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
 description: |
   CMIS browser binding client library in ruby.
 email:
@@ -82,11 +62,12 @@ files:
 - lib/cmis/server.rb
 - lib/cmis/type.rb
 - lib/cmis/version.rb
-- lib/core_ext.rb
-- lib/core_ext/array.rb
 - lib/core_ext/array/indifferent_access.rb
-- lib/core_ext/hash.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
 - readme.md
 - spec/cmis-ruby/document_spec.rb
 - spec/cmis-ruby/folder_spec.rb

data/lib/core_ext.rb

@@ -1,3 +0,0 @@
-Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].each do |path|
-  require path
-end

data/lib/core_ext/array.rb

@@ -1 +0,0 @@
-require 'core_ext/array/indifferent_access'

data/lib/core_ext/hash.rb

@@ -1 +0,0 @@
-require 'core_ext/hash/compact'