api_resource 0.6.21 → 0.6.22

data/lib/api_resource/finders/abstract_finder.rb

@@ -1,110 +1,191 @@
 
 module ApiResource
 
-	module Finders
-
-		class AbstractFinder
-
-			attr_accessor :condition, :klass
-			attr_reader :found, :internal_object
-
-			# TODO: Make this list longer since there are for sure more methods to delegate
-			delegate :to_s, :inspect, :reload, :present?, :blank?, :size, :count, :to => :internal_object
-
-			def initialize(klass, condition)
-				@klass = klass
-				@condition = condition
-				@found = false
-
-				@klass.load_resource_definition
-			end
-
-			def load
-				raise NotImplementedError("Must be defined in a subclass")
-			end
-
-			def internal_object
-				# If we've already tried to load return what we've got
-				if instance_variable_defined?(:@internal_object)
-					return instance_variable_get(:@internal_object)
-				end
-				# If we haven't tried to load then just call load
-				self.load
-			end
-
-			def all(*args)
-				if args.blank?
-					self.internal_object
-				else
-					self.klass.send(:all, *args)
-				end
-			end
-
-			# proxy unknown methods to the internal_object
-			def method_missing(method, *args, &block)
-				self.internal_object.send(method, *args, &block)
-			end
-
-			protected
-
-			# This returns a hash of class_names (given by the condition object)
-			# to an array of objects
-			def load_includes(id_hash)
-				# Quit early if the condition is not eager
-				return {} unless self.condition.eager_load?
-				# Otherwise go through each class_name that is included, and load the ids
-				# given in id_hash, at this point we know all these associations have their
-				# proper names
-
-				hsh = HashWithIndifferentAccess.new
-				id_hash = HashWithIndifferentAccess.new(id_hash)
-				# load each individually
-				self.condition.included_objects.inject(hsh) do |accum, assoc|
-					id_hash[assoc].each_slice(400).each do |ids|
-						accum[assoc.to_sym] ||= []
-						accum[assoc.to_sym].concat(
-							self.klass.association_class(assoc).all(
-								:params => {:ids => ids}
-							)
-						)
-					end
-					accum
-				end
-
-				hsh
-			end
-
-			def apply_includes(objects, includes)
-				Array.wrap(objects).each do |obj|
-					includes.each_pair do |assoc, vals|
-						ids_to_keep = Array.wrap(obj.send(obj.class.association_foreign_key_field(assoc)))
-						to_keep = vals.select{|elm| ids_to_keep.include?(elm.id)}
-						# if this is a single association take the first
-						# TODO: subclass instead of this
-						if self.klass.has_many?(assoc)
-							obj.send("#{assoc}=", to_keep, false)
-						else
-							obj.send("#{assoc}=", to_keep.first, false)
-						end
-					end
-				end
-			end
-
-			def build_load_path
-				raise "This is not finding an association" unless self.condition.remote_path
+  module Finders
+
+    class AbstractFinder
+
+      attr_accessor :condition, :klass
+      attr_reader :found, :internal_object
+
+      # TODO: Make this list longer since there are for sure more methods to delegate
+      delegate :to_s, :inspect, :reload, :present?, :blank?, :size, :count, :to => :internal_object
+
+      def initialize(klass, condition)
+        @klass = klass
+        @condition = condition
+        @found = false
+
+        @klass.load_resource_definition
+      end
+
+      #
+      # Allows us to respond correctly to instance_of? based
+      # on our internal_object
+      #
+      # @param  klass [Class] Class to check
+      #
+      # @return [Boolean]
+      def instance_of?(klass)
+        super || self.internal_object.instance_of?(klass)
+      end
+
+      #
+      # Allows us to respond correctly to is_a? based
+      # on our internal_object
+      #
+      # @param  klass [Class] Class to check
+      #
+      # @return [Boolean]
+      def is_a?(klass)
+        super || self.internal_object.is_a?(klass)
+      end
+
+      #
+      # Allows us to respond correctly to kind_of? based
+      # on our internal_object
+      #
+      # @param  klass [Class] Class to check
+      #
+      # @return [Boolean]
+      def kind_of?(klass)
+        self.is_a?(klass)
+      end
+
+      #
+      # Return the headers for our response from
+      # the server
+      #
+      # @return [Hash] Headers hash
+      def headers
+        self.response.try(:headers)
+      end
+
+      def internal_object
+        # If we've already tried to load return what we've got
+        if instance_variable_defined?(:@internal_object)
+          return instance_variable_get(:@internal_object)
+        end
+        # If we haven't tried to load then just call load
+        self.load
+      end
+
+      def load
+        raise NotImplementedError("Must be defined in a subclass")
+      end
+
+      #
+      # Offset returned from the server
+      #
+      # @return [Fixnum]
+      def offset
+        self.headers.try(:[], 'ApiResource-Offset').to_i
+      end
+
+      #
+      # Is this a paginated find?
+      #
+      # @return [Boolean]
+      def paginated?
+        @condition.paginated?
+      end
+
+      #
+      # Total number of entries the server has told us are
+      # in our collection
+      #
+      # @return [Fixnum]
+      def total_entries
+        self.headers.try(:[], 'ApiResource-Total-Entries').to_i
+      end
+
+      #
+      # Getter for our response from the server
+      #
+      # @return [ApiResource::Response]
+      def response
+        @response ||= begin
+          self.klass.connection.get(self.build_load_path)
+        end
+      end
+
+      def all(*args)
+        if args.blank?
+          self.internal_object
+        else
+          self.klass.send(:all, *args)
+        end
+      end
+
+      # proxy unknown methods to the internal_object
+      def method_missing(method, *args, &block)
+        self.internal_object.send(method, *args, &block)
+      end
+
+      protected
+
+      # This returns a hash of class_names (given by the condition object)
+      # to an array of objects
+      def load_includes(id_hash)
+        # Quit early if the condition is not eager
+        return {} unless self.condition.eager_load?
+        # Otherwise go through each class_name that is included, and load the ids
+        # given in id_hash, at this point we know all these associations have their
+        # proper names
+
+        hsh = HashWithIndifferentAccess.new
+        id_hash = HashWithIndifferentAccess.new(id_hash)
+        # load each individually
+        self.condition.included_objects.inject(hsh) do |accum, assoc|
+          id_hash[assoc].each_slice(400).each do |ids|
+            accum[assoc.to_sym] ||= []
+            accum[assoc.to_sym].concat(
+              self.klass.association_class(assoc).all(
+                :params => {:ids => ids}
+              )
+            )
+          end
+          accum
+        end
+
+        hsh
+      end
+
+      def apply_includes(objects, includes)
+        if !objects.is_a?(Enumerable)
+          objects = Array.wrap(objects)
+        end
+
+        objects.each do |obj|
+          includes.each_pair do |assoc, vals|
+            ids_to_keep = Array.wrap(obj.send(obj.class.association_foreign_key_field(assoc)))
+            to_keep = vals.select{|elm| ids_to_keep.include?(elm.id)}
+            # if this is a single association take the first
+            # TODO: subclass instead of this
+            if self.klass.has_many?(assoc)
+              obj.send("#{assoc}=", to_keep, false)
+            else
+              obj.send("#{assoc}=", to_keep.first, false)
+            end
+          end
+        end
+      end
+
+      def build_load_path
+        raise "This is not finding an association" unless self.condition.remote_path
 
         path = self.condition.remote_path
         # add a format if it doesn't exist and there is no query string yet
         path += ".#{self.klass.format.extension}" unless path =~ /\./ || path =~/\?/
         # add the query string, allowing for other user-provided options in the remote_path if we have options
         unless self.condition.blank_conditions?
-          path += (path =~ /\?/ ? "&" : "?") + self.condition.to_query 
+          path += (path =~ /\?/ ? "&" : "?") + self.condition.to_query
         end
         path
-			end
+      end
 
-		end
+    end
 
-	end
+  end
 
 end

data/lib/api_resource/finders/multi_object_association_finder.rb

@@ -4,12 +4,17 @@ module ApiResource
 
 		class MultiObjectAssociationFinder < AbstractFinder
 
+			delegate :select,
+				to: :internal_object
+
 			# If they pass in the internal object just skip the first
 			# step and apply the includes
 			def initialize(klass, condition, internal_object = nil)
 				super(klass, condition)
 
-				@internal_object = internal_object
+				if internal_object
+					@internal_object = internal_object
+				end
 			end
 
 			def load
@@ -18,15 +23,11 @@ module ApiResource
 					raise "Tried to load association without a remote path"
 				end
 
-				unless @internal_object
-					data = self.klass.connection.get(self.build_load_path)
-					return [] if data.blank?
+				return [] if self.response.blank?
 
-					# handle non-array data for more flexibility in our endpoints
-					data = [data] unless data.is_a?(Array)
-
-					@internal_object = self.klass.instantiate_collection(data)
-				end
+				@internal_object ||= self.klass.instantiate_collection(
+					Array.wrap(self.response)
+				)
 
 				@loaded = true
 

data/lib/api_resource/finders/resource_finder.rb

@@ -1,59 +1,69 @@
 module ApiResource
 
-	module Finders
-
-		class ResourceFinder < AbstractFinder
-
-			# this is a little bit simpler, it's always a collection and does
-			# not require a remote path
-			def load
-				begin
-					@loaded = true
-					@internal_object = self.klass.connection.get(self.build_load_path)
-					return [] if @internal_object.blank?
-
-					if @internal_object.is_a?(Array)
-						@internal_object = self.klass.instantiate_collection(@internal_object)
-					else
-						@internal_object = [self.klass.instantiate_record(@internal_object)]
-					end
-
-					id_hash = self.condition.included_objects.inject({}) do |accum, assoc|
-						accum[assoc] = @internal_object.collect do |obj|
-							obj.send(self.klass.association_foreign_key_field(assoc))
-						end
-						accum[assoc].flatten!
-						accum[assoc].uniq!
-						accum
-					end
-					included_objects = self.load_includes(id_hash)
-
-					self.apply_includes(@internal_object, included_objects)
-
-					# looks hacky, but we want to return only a single
-					# object in case of a find call.
-					if @internal_object.count == 1 && self.build_load_path =~ /find/
-						@internal_object = @internal_object.first
-					end
-
-					return @internal_object
-				rescue ApiResource::ResourceNotFound
-					nil
-				end
-				@internal_object
-			end
-
-			protected
+  module Finders
+
+    class ResourceFinder < AbstractFinder
+
+      # this is a little bit simpler, it's always a collection and does
+      # not require a remote path
+      def load
+        begin
+          return [] if self.response.blank?
+
+          @loaded = true
+
+          if self.response.is_a?(Array)
+            @internal_object = self.klass.instantiate_collection(
+              self.response
+            )
+          else
+            @internal_object = [
+              self.klass.instantiate_record(self.response)
+            ]
+          end
+
+          id_hash = self.condition.included_objects.inject({}) do |accum, assoc|
+            accum[assoc] = @internal_object.collect do |obj|
+              obj.send(self.klass.association_foreign_key_field(assoc))
+            end
+            accum[assoc].flatten!
+            accum[assoc].uniq!
+            accum
+          end
+          included_objects = self.load_includes(id_hash)
+
+          self.apply_includes(@internal_object, included_objects)
+
+
+          # Removed to mirror ActiveRecord
+          # e.g. LifebookerClient::Provider.find([1])
+          #
+          # # looks hacky, but we want to return only a single
+          # # object in case of a find call.
+          # if @internal_object.count == 1 && self.build_load_path =~ /(&|\?)find/
+          #   @internal_object = @internal_object.first
+          # end
+
+          return @internal_object
+        rescue ApiResource::ResourceNotFound
+          nil
+        end
+        @internal_object
+      end
+
+      protected
 
 
         # Find every resource
         def build_load_path
-        	prefix_opts, query_opts = self.klass.split_options(self.condition.to_hash)
-	        self.klass.collection_path(prefix_opts, query_opts)
+          prefix_opts, query_opts = self.klass.split_options(
+            self.condition.to_hash
+          )
+          self.klass.collection_path(prefix_opts, query_opts)
         end
 
-		end
+    end
 
-	end
+  end
 
-end
+end

data/lib/api_resource/finders/single_finder.rb

@@ -5,20 +5,19 @@ module ApiResource
     class SingleFinder < AbstractFinder
 
       def load
-        data = self.klass.connection.get(self.build_load_path)
+        return nil if self.response.blank?
 
         @loaded = true
-        return nil if data.blank?
 
-        @internal_object = self.klass.instantiate_record(data)
+        @internal_object = self.klass.instantiate_record(self.response)
         # now that the object is loaded, resolve the includes
-        id_hash = self.condition.included_objects.inject({}) do |accum, assoc|
-          accum[assoc] = Array.wrap(
+        id_hash = self.condition.included_objects.inject({}) do |hash, assoc|
+          hash[assoc] = Array.wrap(
             @internal_object.send(
               @internal_object.class.association_foreign_key_field(assoc)
             )
           )
-          accum
+          hash
         end
 
         included_objects = self.load_includes(id_hash)

data/lib/api_resource/finders/single_object_association_finder.rb

@@ -1,55 +1,56 @@
 module ApiResource
 
-	module Finders
-
-		class SingleObjectAssociationFinder < AbstractFinder
-
-			def initialize(klass, condition, internal_object = nil)
-				super(klass, condition)
-
-				@internal_object = internal_object
-			end
-
-			# since it is only a single object we can just load from
-			# the service_uri and deal with includes
-			def load
-				# otherwise just instantiate the record
-				unless self.condition.remote_path
-					raise "Tried to load association without a remote path"
-				end
-
-				unless @internal_object
-					data = self.klass.connection.get(self.build_load_path)
-					
-					return nil if data.blank?
-
-					# we want to handle an array if we get one back from our endpoint
-					# this allows for more flexibility
-					data = data.first if data.is_a?(Array)
-
-					@internal_object = self.klass.instantiate_record(data)
-				end
-
-				@loaded = true
-				# now that the object is loaded, resolve the includes
-				id_hash = self.condition.included_objects.inject({}) do |accum, assoc|
-					accum[assoc] = Array.wrap(
-						@internal_object.send(
-							@internal_object.class.association_foreign_key_field(assoc)
-						)
-					)
-					accum
-				end
-
-				included_objects = self.load_includes(id_hash)
-
-				self.apply_includes(@internal_object, included_objects)
-
-				return @internal_object
-			end
-
-		end
-
-	end
+  module Finders
+
+    class SingleObjectAssociationFinder < AbstractFinder
+
+      def initialize(klass, condition, internal_object = nil)
+        super(klass, condition)
+        @internal_object = internal_object
+      end
+
+      # since it is only a single object we can just load from
+      # the service_uri and deal with includes
+      def load
+        # otherwise just instantiate the record
+        unless self.condition.remote_path
+          raise "Tried to load association without a remote path"
+        end
+
+        # check our response
+        return nil if self.response.blank?
+
+        # get our internal object
+        @internal_object ||= begin
+          if self.response.is_a?(Array)
+            self.klass.instantiate_record(self.response.first)
+          else
+            self.klass.instantiate_record(self.response)
+          end
+        end
+
+        # mark us as loaded
+        @loaded = true
+
+        # now that the object is loaded, resolve the includes
+        id_hash = self.condition.included_objects.inject({}) do |hash, assoc|
+          hash[assoc] = Array.wrap(
+            @internal_object.send(
+              @internal_object.class.association_foreign_key_field(assoc)
+            )
+          )
+          hash
+        end
+
+        # apply our includes
+        included_objects = self.load_includes(id_hash)
+        self.apply_includes(@internal_object, included_objects)
+
+        return @internal_object
+      end
+
+    end
+
+  end
 
 end

data/lib/api_resource/finders.rb

@@ -110,7 +110,7 @@ module ApiResource
       def arg_ary
         if @scope.blank?
           return :none
-        elsif Array.wrap(@scope).size == 1
+        elsif !@scope.is_a?(Array)
           return :single
         else
           return :multiple

data/lib/api_resource/formats/file_upload_format.rb

@@ -0,0 +1,75 @@
+require 'active_support/json'
+require 'json'
+
+module ApiResource
+  module Formats
+
+
+    #
+    # @module FileUploadFormat
+    #
+    # Class to handle posting of multipart data to HTTPClient
+    #
+    module FileUploadFormat
+      extend self
+
+      #
+      # The extension for the request
+      #
+      # @return [String]
+      #
+      def extension
+        "json"
+      end
+
+      #
+      # The mime_type header for the request
+      #
+      # @return [String]
+      #
+      def mime_type
+        "multipart/form-data"
+      end
+
+      #
+      # Implementation of {#encode} - encodes data to POST
+      # to the server
+      #
+      # @return [Hash]
+      #
+      def encode(hash, options = nil)
+        ret = {}
+        hash.each_pair do |k,v|
+          ret[k] = self.encode_value(v)
+        end
+        ret
+      end
+
+      #
+      # Implementation of {#decode} - decodes data back from the server
+      # We expect the data to be JSON-formatted
+      #
+      # @return [Hash]
+      #
+      def decode(json)
+        JSON.parse(json)
+      end
+
+      protected
+
+      def encode_value(val)
+        case val
+          when Hash
+            self.encode(val)
+          when Array
+            val.collect{|v| self.encode_value(v)}
+          when ActionDispatch::Http::UploadedFile
+            val.tempfile
+          else
+            val
+        end
+      end
+
+    end
+  end
+end

data/lib/api_resource/formats.rb

@@ -1,7 +1,10 @@
 module ApiResource
   module Formats
-    autoload :XmlFormat, 'api_resource/formats/xml_format'
+
+    autoload :FileUploadFormat, 'api_resource/formats/file_upload_format'
     autoload :JsonFormat, 'api_resource/formats/json_format'
+    autoload :XmlFormat, 'api_resource/formats/xml_format'
+
 
     # Lookup the format class from a mime type reference symbol. Example:
     #