api_resource 0.5.1 → 0.6.0

data/lib/api_resource/base.rb

@@ -6,6 +6,30 @@ require 'active_support/string_inquirer'
 module ApiResource
   
   class Base
+
+    # TODO: There's way too much in this class as it stands, some glaring problems:
+    # => 1) class_attributes for connection options belong in the connection class
+    # => 2) Attributes about serialization belong with the serializers
+    # => 3) Logging seems to be an unmitigated disaster
+    # => 4) All the resource definition should be in its own module with the data mapper implementation
+    # => 5) Random shit about tokens all over the place, clearly does not belong
+    # => 6) Everything related to the pathing should go somewhere by itself
+    # => 7) Everything about saving should go in a persistence module
+    # => 8) Everything about loading data should go in a Finder module
+    # => 9) Delete serializable_hash and start again
+    # => 10) setup_create_call and setup_update_call should modify the results from another method
+    # => 11) nil_attributes probably belongs with the attributes
+    # => 12) Add instrumentation in some key places
+
+    # Other Random TODOs:
+    # => 1) Profile and benchmark this code
+    # => 2) Deal with arrays and hashes as attributes in a more reasonable way
+    # => 3) Finish implementing typecasting (to_api portion)
+    # => 4) Add a reasonable way to load and activate observers, verify that it works
+    # => 5) Hook up the custom_methods module
+    # => 6) Implement an IdentityMap
+    # => 7) Write documentation
+    # => 8) Write Examples
     
     class_attribute :site, :proxy, :user, :password, :auth_type, :format, 
       :timeout, :open_timeout, :ssl_options, :token, :ttl
@@ -297,51 +321,6 @@ module ApiResource
       def create(attributes = {})
         self.new(attributes).tap{ |resource| resource.save }
       end
-      
-      # 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
 
 
       # Deletes the resources with the ID in the +id+ parameter.
@@ -362,24 +341,6 @@ module ApiResource
         connection.delete(element_path(id, options))
       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
-
       protected
         def method_missing(meth, *args, &block)
           # make one attempt to load remote attrs
@@ -390,44 +351,6 @@ module ApiResource
         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
 
         # Accepts a URI and creates the site URI from that.
         def create_site_uri_from(site)
@@ -582,6 +505,10 @@ module ApiResource
       self.class.include_root_in_json ? {self.class.element_name => self.serializable_hash(options)}.to_json : self.serializable_hash(options).to_json
     end
     
+    # TODO: this method needs to change seriously to fit in with the
+    # new typecasting scheme, it should call self.outgoing_attributes which
+    # should return the converted versions after calling to_api, that should
+    # be implemented in the attributes module though
     def serializable_hash(options = {})
       
       action = options[:action]
@@ -683,6 +610,7 @@ module ApiResource
       opts[:include_associations] = opts[:include_associations] ? opts[:include_associations].concat(args) : []
       opts[:include_extras] ||= []
       opts[:action] = "create"
+      # TODO: Remove this dependency for saving files
       body = RestClient::Payload.has_file?(self.attributes) ? self.serializable_hash(opts) : encode(opts)
     end
 
@@ -706,6 +634,7 @@ module ApiResource
       opts[:include_extras] ||= []
       opts[:action] = "update"
       opts[:except] = [:id] if self.class.include_all_attributes_on_update
+      # TODO: Remove this dependency for saving files
       body = RestClient::Payload.has_file?(self.attributes) ? self.serializable_hash(opts) : encode(opts)
     end
     
@@ -724,7 +653,7 @@ module ApiResource
     include AssociationActivation
     self.activate_associations
     
-    include Scopes, Callbacks, Attributes, ModelErrors
+    include Scopes, Callbacks, Observing, Attributes, ModelErrors, Conditions, Finders
     
   end
   

data/lib/api_resource/conditions.rb

@@ -0,0 +1,36 @@
+module ApiResource
+
+	module Conditions
+
+		extend ActiveSupport::Autoload
+		extend ActiveSupport::Concern
+
+		autoload :AbstractCondition
+		autoload :AssociationCondition
+		autoload :SingleObjectAssociationCondition
+		autoload :MultiObjectAssociationCondition
+		autoload :IncludeCondition
+		autoload :ScopeCondition
+
+		module ClassMethods
+
+			def includes(*args)
+
+				# everything in args must be an association
+				args.each do |arg|
+					unless self.association?(arg)
+						raise ArgumentError, "Unknown association #{arg} to eager load"
+					end
+				end
+
+				# Everything looks good so just create the scope
+				ApiResource::Conditions::IncludeCondition.new(self, args)
+
+			end
+
+		end
+
+	end
+
+
+end

data/lib/api_resource/conditions/abstract_condition.rb

@@ -0,0 +1,112 @@
+module ApiResource
+
+	module Conditions
+
+		class AbstractCondition
+
+			include Enumerable
+
+			attr_reader :conditions, :klass, :included_objects, :internal_object, :association,
+									:remote_path
+			
+			# TODO: add the other load forcing methods here for collections
+			delegate :[], :[]=, :<<, :first, :second, :last, :blank?, :nil?, :include?, :push, :pop,
+							 :+, :concat, :flatten, :flatten!, :compact, :compact!, :empty?, :fetch, :map,
+							 :reject, :reject!, :reverse, :select, :select!, :size, :sort, :sort!, :uniq, :uniq!,
+							 :to_a, :sample, :slice, :slice!, :count, :present?, :to => :internal_object
+
+			# need to figure out what to do with args in the subclass,
+			# parent is the set of scopes we have right now
+			def initialize(args, klass)
+				@klass = klass
+
+				@conditions = args.with_indifferent_access
+			end
+
+			def each(&block)
+				self.internal_object.each(&block)
+			end
+
+			def blank_conditions?
+				self.conditions.blank?
+			end
+
+			def eager_load?
+				self.included_objects.present?
+			end 
+
+			def included_objects
+				Array.wrap(@included_objects)
+			end
+
+			def to_query
+				CGI.unescape(to_query_safe_hash(self.to_hash).to_query)
+			end
+
+			def to_hash
+				self.conditions
+			end
+
+			def internal_object
+				@internal_object ||= begin
+					@loaded = true
+					self.instantiate_finder.find
+				end
+			end
+
+			alias_method :find, :internal_object
+			alias_method :all, :internal_object
+
+			def loaded?
+				@loaded == true
+			end
+
+			def reload
+				if instance_variable_defined?(:@internal_object)
+					remove_instance_variable(:@internal_object)
+				end
+				@loaded = false
+			end
+
+			def method_missing(sym, *args, &block)
+				result = @klass.send(sym, *args, &block)
+
+				if result.is_a?(ApiResource::Conditions::AbstractCondition)
+					return self.dup.merge!(result)
+				else
+					return result
+				end
+			end
+
+			def expires_in(time)
+				ApiResource::Decorators::CachingDecorator.new(self, time)
+			end
+
+			# TODO: Remove the bang, this doesn't modify anything
+			def merge!(cond)
+				@included_objects = (@included_objects || []).concat(cond.included_objects || []).uniq
+				@conditions = @conditions.merge(cond.to_hash)
+				@association = cond.association || self.association
+				@remote_path = self.remote_path ? self.remote_path : cond.remote_path
+				return self
+			end
+
+			protected
+
+			def instantiate_finder
+				ApiResource::Finders::ResourceFinder.new(self.klass, self)
+			end
+
+			def to_query_safe_hash(hash)
+				hash.each_pair do |k,v|
+					hash[k] = to_query_safe_hash(v) if v.is_a?(Hash)
+					hash[k] = true if v == {}
+				end
+				return hash
+			end
+
+		end
+
+	end
+
+end

data/lib/api_resource/conditions/association_condition.rb

@@ -0,0 +1,18 @@
+module ApiResource
+
+	module Conditions
+
+		class AssociationCondition < AbstractCondition
+
+			def initialize(klass, service_uri)
+				super({}, klass)
+
+				@assocaiton = true
+				@remote_path = service_uri
+			end
+
+		end
+
+	end
+
+end

data/lib/api_resource/conditions/include_condition.rb

@@ -0,0 +1,16 @@
+module ApiResource
+
+	module Conditions
+
+		class IncludeCondition < AbstractCondition
+
+			def initialize(klass, incs)
+				super({}, klass)
+				@included_objects = Array.wrap(incs)
+			end
+
+		end
+
+	end
+
+end

data/lib/api_resource/conditions/multi_object_association_condition.rb

@@ -0,0 +1,17 @@
+module ApiResource
+
+	module Conditions
+
+		class MultiObjectAssociationCondition < AssociationCondition
+
+			protected
+
+			def instantiate_finder
+				ApiResource::Finders::MultiObjectAssociationFinder.new(self.klass, self)
+			end
+
+		end
+
+	end
+
+end

data/lib/api_resource/conditions/scope_condition.rb

@@ -0,0 +1,11 @@
+module ApiResource
+
+	module Conditions
+
+		class ScopeCondition < AbstractCondition
+
+		end
+
+	end
+
+end

data/lib/api_resource/conditions/single_object_association_condition.rb

@@ -0,0 +1,19 @@
+module ApiResource
+
+	module Conditions
+
+		# Special class for passing into a finder object
+		# just defines all the proper methods
+		class SingleObjectAssociationCondition < AssociationCondition
+
+			protected
+
+			def instantiate_finder
+				ApiResource::Finders::SingleObjectAssociationFinder.new(self.klass, self)
+			end
+
+		end
+
+	end
+
+end

data/lib/api_resource/connection.rb

@@ -70,22 +70,28 @@ module ApiResource
       request(:head, path, build_request_headers(headers, :head, self.site.merge(path)))
     end
     
-    
+    # make a put request
     def put(path, body = {}, headers = self.headers)
-      # If there's a file to send then we can't use JSON or XML
-      if !body.is_a?(String) && RestClient::Payload.has_file?(body)
-        format.decode(request(:put, path, body, build_request_headers(headers, :put, self.site.merge(path))))
-      else
-        format.decode(request(:put, path, body, build_request_headers(headers, :put, self.site.merge(path))))
-      end
+      format.decode(
+        request(
+          :put, 
+          path, 
+          body, 
+          build_request_headers(headers, :put, self.site.merge(path))
+        )
+      )
     end
     
+    # make a post request
     def post(path, body = {}, headers = self.headers)
-      if !body.is_a?(String) && RestClient::Payload.has_file?(body)
-        format.decode(request(:post, path, body, build_request_headers(headers, :post, self.site.merge(path))))
-      else
-        format.decode(request(:post, path, body, build_request_headers(headers, :post, self.site.merge(path))))
-      end
+      format.decode(
+        request(
+          :post, 
+          path, 
+          body, 
+          build_request_headers(headers, :post, self.site.merge(path))
+        )
+      )
     end
 
     protected