api_resource 0.5.1 → 0.6.0

data/lib/api_resource/finders.rb

@@ -0,0 +1,122 @@
+module ApiResource
+
+	module Finders
+
+		extend ActiveSupport::Concern
+		extend ActiveSupport::Autoload
+
+		autoload :AbstractFinder
+		autoload :ResourceFinder
+		autoload :SingleObjectAssociationFinder
+		autoload :MultiObjectAssociationFinder
+
+		module ClassMethods
+
+   	# This decides which finder method to call. 
+      # It accepts arguments of the form "scope", "options={}"
+      # where options can be standard rails options or :expires_in. 
+      # If :expires_in is set, it caches it for expires_in seconds.
+      def find(*arguments)
+
+        # make sure we have class data before loading
+        self.load_resource_definition
+
+        scope   = arguments.slice!(0)
+        options = arguments.slice!(0) || {}
+        
+        expiry = options.delete(:expires_in) || ApiResource::Base.ttl || 0
+        ApiResource.with_ttl(expiry.to_f) do
+          case scope
+            when :all   then find_every(options)
+            when :first then find_every(options).first
+            when :last  then find_every(options).last
+            when :one   then find_one(options)
+            else             find_single(scope, options)
+          end
+        end
+      end
+
+
+      # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass
+      # in all the same arguments to this method as you can to
+      # <tt>find(:first)</tt>.
+      def first(*args)
+        find(:first, *args)
+      end
+
+      # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass
+      # in all the same arguments to this method as you can to
+      # <tt>find(:last)</tt>.
+      def last(*args)
+        find(:last, *args)
+      end
+
+      # This is an alias for find(:all).  You can pass in all the same
+      # arguments to this method as you can to <tt>find(:all)</tt>
+      def all(*args)
+        find(:all, *args)
+      end
+
+       def instantiate_collection(collection)
+        collection.collect{|record| 
+          instantiate_record(record)
+        }
+      end
+
+      def instantiate_record(record)
+        self.load_resource_definition
+        ret = self.allocate
+        ret.instance_variable_set(
+          :@attributes, record.with_indifferent_access
+        )
+        ret.instance_variable_set(
+          :@attributes_cache, HashWithIndifferentAccess.new
+        )
+        ret
+      end
+
+      private
+
+        # Find every resource
+        def find_every(options)
+          begin
+            case from = options[:from]
+            when Symbol
+              instantiate_collection(get(from, options[:params]))
+            when String
+              path = "#{from}#{query_string(options[:params])}"
+              instantiate_collection(connection.get(path, headers) || [])
+            else
+              prefix_options, query_options = split_options(options[:params])
+              path = collection_path(prefix_options, query_options)
+              instantiate_collection( (connection.get(path, headers) || []))
+            end
+          rescue ApiResource::ResourceNotFound
+            # Swallowing ResourceNotFound exceptions and return nil - as per
+            # ActiveRecord.
+            nil
+          end
+        end
+
+        # Find a single resource from a one-off URL
+        def find_one(options)
+          case from = options[:from]
+          when Symbol
+            instantiate_record(get(from, options[:params]))
+          when String
+            path = "#{from}#{query_string(options[:params])}"
+            instantiate_record(connection.get(path, headers))
+          end
+        end
+
+        # Find a single resource from the default URL
+        def find_single(scope, options)
+          prefix_options, query_options = split_options(options[:params])
+          path = element_path(scope, prefix_options, query_options)
+          instantiate_record(connection.get(path, headers))
+        end
+
+		end 
+	end
+
+end

data/lib/api_resource/finders/abstract_finder.rb

@@ -0,0 +1,89 @@
+
+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, :to => :internal_object
+
+			def initialize(klass, condition)
+				@klass = klass
+				@condition = condition
+				@found = false
+				@internal_object = nil
+			end
+
+			def find
+				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 find
+				self.find
+			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|
+					accum[assoc.to_sym] = self.klass.association_class(assoc).find(
+						:all, 
+						:id => id_hash[assoc])
+				end
+
+				hsh
+			end
+
+			def apply_includes(objects, includes)
+				Array.wrap(objects).each do |obj|
+					includes.each_pair do |assoc, vals|
+						ids_to_keep = obj.send(obj.class.association_foreign_key_field(assoc))
+						to_keep = vals.select{|elm| ids_to_keep.include?(elm.id)}
+						obj.send("#{assoc}=", to_keep)
+					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 
+        end
+        path
+			end
+
+		end
+
+	end
+
+end

data/lib/api_resource/finders/multi_object_association_finder.rb

@@ -0,0 +1,39 @@
+module ApiResource
+
+	module Finders
+
+		class MultiObjectAssociationFinder < AbstractFinder
+
+			def find
+				# otherwise just instantiate the record
+				unless self.condition.remote_path
+					raise "Tried to load association without a remote path"
+				end
+
+				data = self.klass.connection.get(self.build_load_path)
+				@loaded = true
+				return [] if data.blank?
+
+				@internal_object = self.klass.instantiate_collection(data)
+
+				id_hash = self.condition.included_objects.inject({}) do |accum, assoc|
+					accum[assoc] = @internal_object.collect do |obj|
+						obj.send(obj.class.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)
+
+				return @internal_object
+			end
+		end
+
+	end
+
+end

data/lib/api_resource/finders/resource_finder.rb

@@ -0,0 +1,33 @@
+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 find
+				@loaded = true
+				@internal_object = self.klass.find(:all, self.condition.to_hash)
+				return [] if @internal_object.blank?
+
+				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)
+
+				return @internal_object
+			end
+
+		end
+
+	end
+
+end

data/lib/api_resource/finders/single_object_association_finder.rb

@@ -0,0 +1,40 @@
+module ApiResource
+
+	module Finders
+
+		class SingleObjectAssociationFinder < AbstractFinder
+
+			# since it is only a single object we can just load from
+			# the service_uri and deal with includes
+			def find
+				# otherwise just instantiate the record
+				unless self.condition.remote_path
+					raise "Tried to load association without a remote path"
+				end
+
+				data = self.klass.connection.get(self.build_load_path)
+				@loaded = true
+				return nil if data.blank?
+				@internal_object = self.klass.instantiate_record(data)
+				# 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
+
+end

data/lib/api_resource/observing.rb

@@ -7,21 +7,37 @@ module ApiResource
     
     # Redefine these methods to 
     included do
+
       %w( create save update destroy ).each do |method|
         alias_method_chain method, :observers
+      end
     end
     
     %w( create save update destroy ).each do |method|
       module_eval <<-EOE, __FILE__, __LINE__ + 1
         def #{method}_with_observers(*args)
-          notify_observers(:before_#method)
-          if result = #{method}_without_observers(*args)
-            notify_observers(:after_#{method})
+          unless notify_observers(:before_#{method})
+            return false
           end
+          result = #{method}_without_observers(*args)
+          notify_observers(:after_#{method}) if result
           return result
         end
       EOE
     end
+
+    # also need to override notify_observers to return false if
+    # ANY of the observers return false, however it will ALWAYS run them all
+    def notify_observers(method)
+      self.class.observer_instances.inject(true) do |accum, obs|
+        obs.update(method, self) && accum
+      end
+    end
     
   end
+
+  # Blank class here for ease of use, might need
+  # some methods some day
+  class Observer < ActiveModel::Observer
+  end
 end

data/lib/api_resource/scopes.rb

@@ -4,6 +4,7 @@ module ApiResource
     extend ActiveSupport::Concern
     
     module ClassMethods
+      # TODO: calling these methods should force loading of the resource definition
       def scopes
         return self.related_objects[:scopes]
       end
@@ -61,9 +62,8 @@ module ApiResource
               finder_opts[scope_name] = true
             end
 
-            ApiResource::Associations::ResourceScope.new(
-              self, finder_opts
-            )
+            ApiResource::Conditions::ScopeCondition.new(finder_opts, self)
+
           end
         end
       end

data/lib/api_resource/typecast.rb

@@ -0,0 +1,85 @@
+require 'api_resource/typecasters/boolean_typecaster'
+require 'api_resource/typecasters/date_typecaster'
+require 'api_resource/typecasters/float_typecaster'
+require 'api_resource/typecasters/integer_typecaster'
+require 'api_resource/typecasters/string_typecaster'
+require 'api_resource/typecasters/time_typecaster'
+require 'api_resource/typecasters/array_typecaster'
+
+# Apparently need to require the active_support class_attribute
+require 'active_support/core_ext/class/attribute'
+
+
+module ApiResource
+
+  module Typecast
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :typecasters
+
+      self.typecasters = self.default_typecasters
+    end
+
+    module ClassMethods
+      # Takes a typecaster name (converted to all lowercase) and
+      # either a klass (as a constant) or a block to define an anonymous module
+      # and registers a new typecaster that defines the method typecast!(value)
+      def register_typecaster(name, klass = nil, &block)
+        caster = name.to_s.downcase.to_sym
+
+        if self.typecasters[caster]
+          raise ArgumentError, "Typecaster #{name} already exists"
+        end
+
+        if block_given?
+          unless klass.nil?
+            raise ArgumentError, "Cannot declare a typecaster with a class and a block"
+          end
+
+          klass = Module.new(&block)
+        elsif klass.nil?
+          raise ArgumentError, "Must specify a typecaster with either a class or a block"
+        end
+
+        unless klass.respond_to?(:from_api) && klass.respond_to?(:to_api)
+          raise ArgumentError, "Typecaster must respond to from_api and to_api"
+        end
+
+        self.typecasters[caster] = klass
+
+      end
+
+      # Redefines a typecaster (or defines it if it doesn't exist)
+      # basically just delegates to register_typecaster
+      def redefine_typecaster!(name, klass = nil, &block)
+        caster = name.to_s.downcase.to_sym
+        # clone the original typecasters hash so that the override
+        # only applies to this class and subclasses
+        self.typecasters = self.typecasters.clone
+        self.typecasters.delete(caster)
+        self.register_typecaster(name, klass, &block)
+      end
+
+      def default_typecasters
+        @default_typecasters ||= {
+          :boolean => BooleanTypecaster,
+          :bool => BooleanTypecaster,
+          :date => DateTypecaster,
+          :decimal => FloatTypecaster,
+          :float => FloatTypecaster,
+          :integer => IntegerTypecaster,
+          :int => IntegerTypecaster,
+          :string => StringTypecaster,
+          :time => TimeTypecaster,
+          :datetime => TimeTypecaster,
+          :array => ArrayTypecaster,
+        }
+      end
+
+    end
+
+  end
+
+end