api_resource 0.4.3 → 0.5.0

data/lib/api_resource/associations/abstract_scope.rb

@@ -0,0 +1,191 @@
+module ApiResource
+
+  module Associations
+
+    class AbstractScope
+
+      attr_reader :klass, :finder_opts
+
+      def initialize(klass, finder_opts = {})
+
+        # the base class for our scope, e.g. ApiResource::SomeClass
+        @klass = klass.is_a?(String) ? klass.constantize : klass
+
+        # load the resource definition
+        @klass.load_resource_definition
+
+        # the parent scope - for composing all of the finder options
+        @parent = finder_opts.delete(:__parent)
+
+        @finder_opts = finder_opts
+        
+        # Where subscope is any scope down the chain, e.g. active.*future*
+        @klass.scopes.each do |scope_name, scope_definition|
+          self.define_subscope(scope_name, scope_definition)
+        end
+      end
+
+      def ttl
+        @ttl || 0
+      end
+
+      # Use this method to access the internal data, this guarantees that loading only occurs once per object
+      def internal_object
+        if instance_variable_defined?(:@internal_object)
+          return instance_variable_get(:@internal_object)
+        end
+        instance_variable_set(:@internal_object, self.load)
+      end
+
+      # has the scope been loaded?
+      def loaded?
+        @loaded == true
+      end
+
+      def load_resource_definition
+        self.klass.load_resource_definition
+      end
+
+      def scopes
+        @scopes ||= HashWithIndifferentAccess.new
+      end
+
+      def scope?(scp)
+        self.scopes.key?(scp.to_s)
+      end
+
+      # def current_scope
+      #   ActiveSupport::StringInquirer.new(@current_scope.join("_and_").concat("_scope"))
+      # end
+
+      def to_hash
+        self.parent_hash.merge(self.finder_opts)
+      end
+
+      # takes empty hashes and replaces them with true so that to_query doesn't strip them out
+      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
+
+       # gets the current hash and calls to_query on it
+      def to_query
+        #We need to add the unescape because to_query breaks on nested arrays
+        CGI.unescape(to_query_safe_hash(self.to_hash).to_query)
+      end
+
+      # unset all of our scope values and our internal object
+      def reload
+        (self.scopes.keys + [:internal_object]).each do |ivar|
+          if instance_variable_defined?("@#{ivar}")
+            remove_instance_variable("@#{ivar}")
+          end
+        end
+        @loaded = false
+        self
+      end
+
+      def to_s
+        self.internal_object.to_s
+      end
+
+      def inspect
+        self.internal_object.inspect
+      end
+
+      def blank?
+        self.internal_object.blank?
+      end
+      alias_method :empty?, :blank?
+
+      def present?
+        self.internal_object.present?
+      end
+
+      def expires_in(ttl)
+        ApiResource::Decorators::CachingDecorator.new(self, ttl)
+      end
+
+      protected
+
+        # scope_name => e.g. paged
+        # scope_definition => e.g. {:page => "req", "per_page" => "opt"}
+
+        def define_subscope(scope_name, scope_definition)
+
+          self.scopes[scope_name] = scope_definition
+
+          self.class_eval do
+
+            define_method(scope_name) do |*args|
+            
+              unless instance_variable_defined?("@#{scope_name}")
+               
+                arg_names = scope_definition.keys
+                arg_types = scope_definition.values
+
+                finder_opts = {
+                  scope_name => {}
+                }
+
+                arg_names.each_with_index do |arg_name, i|
+                  
+                  # If we are dealing with a scope with multiple args
+                  if arg_types[i] == :rest
+                    finder_opts[scope_name][arg_name] = 
+                      args.slice(i, args.count)
+                  # Else we are only dealing with a single argument
+                  else
+                    if arg_types[i] == :req || args[i].present?
+                      finder_opts[scope_name][arg_name] = args[i]
+                    end
+                  end
+                end
+
+                # if we have nothing at this point we should just pass 'true'
+                if finder_opts[scope_name] == {}
+                  finder_opts[scope_name] = true
+                end
+
+                instance_variable_set(
+                  "@#{scope_name}",
+                  self.get_subscope_instance(finder_opts)
+                )
+              end
+              instance_variable_get("@#{scope_name}")
+            end
+          end
+        end
+
+        def get_subscope_instance(finder_opts)
+          ApiResource::Associations::Scope.new(
+            self, finder_opts.merge(:__parent => self)
+          )
+        end
+
+        def method_missing(method, *args, &block)
+          self.internal_object.send(method, *args, &block)
+        end
+
+        # querystring hash from parent
+        def parent_hash
+          @parent ? @parent.to_hash : {}
+        end
+
+        # require our subclasses to implement a way to find records
+        def load
+          raise NotImplementedError.new("#{self.class} must implement #load")
+        end
+        
+        # make sure we have a valid scope
+        def check_scope(scp)
+          raise ArgumentError, "Unknown scope #{scp}" unless self.scope?(scp.to_s)
+        end
+    end
+
+  end
+
+end

data/lib/api_resource/associations/association_scope.rb

@@ -0,0 +1,47 @@
+module ApiResource
+  
+  module Associations
+   
+    class AssociationScope < AbstractScope
+
+      class_attribute :remote_path_element
+      self.remote_path_element = :service_uri 
+
+      attr_accessor :remote_path
+      attr_reader :owner 
+      
+      # TODO: added owner - moved it to the end because the tests don't use it - it's useful here though
+      def initialize(klass, owner, opts = {})
+        super(klass)
+
+        @owner = owner
+        
+        self.internal_object = opts
+      end
+      
+      def ==(other)
+         raise "Not Implemented: This method must be implemented in a subclass"
+      end
+
+      def scopes
+        self.klass.scopes
+      end
+
+      protected
+      
+      # get the remote URI based on our config and options
+      def build_load_path(options)
+        path = self.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 options.blank?
+          path += (path =~ /\?/ ? "&" : "?") + options.to_query 
+        end
+        path
+      end
+    end
+    
+  end
+  
+end

data/lib/api_resource/associations/belongs_to_remote_object_proxy.rb

@@ -2,14 +2,13 @@ require 'api_resource/associations/single_object_proxy'
 module ApiResource
   module Associations
     class BelongsToRemoteObjectProxy < SingleObjectProxy
-      def initialize(klass_name, contents, owner)
-        super
-        return if self.internal_object
+      def initialize(klass, owner)
+        super(klass, owner)
+        
         # now if we have an owner and a foreign key, we set the data up to load
-        if owner && key = owner.send(self.klass.to_s.foreign_key)
-          self.load({"service_uri" => self.klass.element_path(key), "scopes_only" => true}.merge(self.klass.scopes))
+        if key = owner.send(self.klass.to_s.foreign_key)
+          self.remote_path =  self.klass.element_path(key)
         end
-        true
       end
     end
   end

data/lib/api_resource/associations/has_many_remote_object_proxy.rb

@@ -2,14 +2,11 @@ require 'api_resource/associations/multi_object_proxy'
 module ApiResource
   module Associations
     class HasManyRemoteObjectProxy < MultiObjectProxy
-      def initialize(klass_name, contents, owner)
-        super
-        return if self.internal_object.present? || self.remote_path
-        # now if we have an owner and a foreign key, we set the data up to load
-        if owner
-          self.load({"service_uri" => self.klass.collection_path(self.owner.class.to_s.foreign_key => self.owner.id)}.merge(self.klass.scopes))
-        end
-        true
+      def initialize(klass, owner)
+        super(klass, owner)
+        self.remote_path = self.klass.collection_path(
+          self.owner.class.to_s.foreign_key => self.owner.id
+        )
       end
     end
   end

data/lib/api_resource/associations/has_one_remote_object_proxy.rb

@@ -2,23 +2,22 @@ require 'api_resource/associations/single_object_proxy'
 module ApiResource
   module Associations
     class HasOneRemoteObjectProxy < SingleObjectProxy
-      def initialize(klass_name, contents, owner)
-        super
-        return if self.internal_object
+      
+      def initialize(klass, owner)
+        super(klass, owner)
+        
         # now if we have an owner and a foreign key, we set the data up to load
-        if owner
-          self.load({"service_uri" => self.klass.collection_path(self.owner.class.to_s.foreign_key => self.owner.id)}.merge(self.klass.scopes))
-        end
-        true
+        self.remote_path = self.klass.collection_path(self.owner.class.to_s.foreign_key => self.owner.id)
       end
+
       protected
-      # load data from the remote server
-      # In a has_one, we can get back an Array, so we use the first element
-      def load_from_remote(options)
-        data = super(options)
-        data = data.first if data.is_a?(Array)
-        data
+      
+      def load(opts = {})
+        data = self.klass.connection.get(self.build_load_path(opts))
+        return nil if data.blank?
+        return self.klass.new(data.first)
       end
+
     end
   end
 end

data/lib/api_resource/associations/multi_object_proxy.rb

@@ -1,13 +1,19 @@
-require 'api_resource/associations/association_proxy'
+require 'api_resource/associations/association_scope'
 
 module ApiResource
   
   module Associations
    
-      class MultiObjectProxy < AssociationProxy
+      class MultiObjectProxy < AssociationScope
 
         include Enumerable
 
+        # override the constructor to set data to nil by 
+        # default
+        def initialize(klass, owner, data = nil)
+          super
+        end
+
         def all
           self.internal_object
         end
@@ -16,6 +22,39 @@ module ApiResource
           self.internal_object.each(*args, &block)
         end
         
+        def internal_object
+          @internal_object ||= begin
+            if self.remote_path.present?
+              self.load
+            else
+              []
+            end
+          end
+        end
+
+        def internal_object=(contents)
+          # if we were passed in a service uri, stop here
+          return true if self.set_remote_path_and_scopes(contents)
+
+          if contents.try(:first).is_a?(self.klass)
+            return @internal_object = contents 
+          elsif contents.instance_of?(self.class)
+            return @internal_object = contents.internal_object
+          elsif contents.is_a?(Array)
+            return @internal_object = self.klass.instantiate_collection(
+              contents
+            )
+          # we have only provided the resource definition
+          elsif contents.nil?
+            return @internal_object = nil
+          else
+            raise ArgumentError.new(
+              "#{contents} must be a #{self.klass}, #{self.class}, " + 
+              "Array or nil"
+            )
+          end
+        end
+
         def ==(other)
           return false if self.class != other.class
           if self.internal_object.is_a?(Array)
@@ -30,53 +69,40 @@ module ApiResource
           self.internal_object.collect{|obj| obj.serializable_hash(options) }
         end
 
-        # force a load when calling this method
-        def internal_object
-          @internal_object ||= self.load_scope_with_options(:all, {})
-        end
-        
-        def internal_object=(contents)
-          return @internal_object = contents if contents.all?{|o| o.is_a?(self.klass)}
-          return load(contents)
+        def load(opts = {})
+          data = self.klass.connection.get(self.build_load_path(opts))
+          @loaded = true
+          return [] if data.blank?
+          return self.klass.instantiate_collection(data)
         end
 
         protected
-        def load_scope_with_options(scope, options)
-          scope = self.loaded_hash_key(scope.to_s, options)
-          return [] if self.remote_path.blank?
 
-          self.loaded[scope] ||= begin
-            self.times_loaded += 1
-            self.load_from_remote(options).collect{|item| self.klass.new(item)}
-          end
-          
-        end
-
-        def load(contents)
-          @internal_object = [] and return nil if contents.blank?
-          if contents.is_a?(Array) && contents.first.is_a?(Hash) && contents.first[self.class.remote_path_element]
-            settings = contents.slice!(0).with_indifferent_access
+        # set up the remote path from a set of options passed in
+        def set_remote_path_and_scopes(opts)
+          if opts.is_a?(Array) && opts.first.is_a?(Hash)
+            if opts.first.symbolize_keys[self.class.remote_path_element.to_sym]
+              service_uri_el = opts.shift
+            else
+              service_uri_el = {}
+            end
+          elsif opts.is_a?(Hash)
+            service_uri_el = opts
+          else
+            service_uri_el = {}
           end
 
-          settings = contents.with_indifferent_access if contents.is_a?(Hash)
-          settings ||= {}.with_indifferent_access
+          @remote_path = service_uri_el.symbolize_keys.delete(
+            self.class.remote_path_element.to_sym
+          )
 
-          raise "Invalid response for multi object relationship: #{contents}" unless settings[self.class.remote_path_element] || contents.is_a?(Array)
-          self.remote_path = settings.delete(self.class.remote_path_element)
-
-          settings.each do |key, value|
-            raise "Expected the scope #{key} to point to a hash, to #{value}" unless value.is_a?(Hash)
-            self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
-              def #{key}(opts = {})
-                @#{key} ||= ApiResource::Associations::RelationScope.new(self, :#{key}, opts)
-              end
-            EOE
-            self.scopes[key.to_s] = value
+          service_uri_el.each_pair do |scope_name, scope_def|
+            self.define_subscope(scope_name, scope_def)
           end
 
-          # Create the internal object
-          @internal_object = contents.is_a?(Array) ? contents.collect{|item| self.klass.new(item)} : nil
+          return @remote_path.present?
         end
+
       end
     
   end

data/lib/api_resource/associations/resource_scope.rb

@@ -1,31 +1,20 @@
-require 'api_resource/associations/scope'
-
 module ApiResource
-
   module Associations
-
-    class ResourceScope < Scope
+    class ResourceScope < AbstractScope
 
       include Enumerable
 
-      def internal_object
-        ApiResource.with_ttl(ttl) do
-          @internal_object ||= self.klass.send(:find, :all, :params => self.to_hash)
-        end
-      end
-
       alias_method :all, :internal_object
 
       def each(*args, &block)
         self.internal_object.each(*args, &block)
       end
 
-      # Used by ApiResource::Scopes to create methods with the same name
-      # as the scope
-      #
-      # Weird place to have a factory... could have been on Scope or a separate class...
-      def self.class_factory(hsh)
-        return ApiResource::Associations::GenericScope
+      # perform a find with a given set of query params
+      def load(opts = {})
+        ret = self.klass.all(:params => opts)
+        @loaded = true
+        ret
       end
     end
   end

data/lib/api_resource/associations/scope.rb

@@ -1,132 +1,34 @@
 module ApiResource
-
   module Associations
-
-    class Scope
-
-      attr_accessor :klass, :current_scope, :internal_object
-
-      attr_reader :scopes
-
-      def initialize(klass, current_scope, opts = {})
-        # Holds onto the association proxy this RelationScope is bound to
-        @klass = klass
-        @parent = opts.delete(:parent)
-        @ttl = opts.delete(:expires_in)
-        # splits on _and_ and sorts to get a consistent scope key order
-        @current_scope = (self.parent_scope + Array.wrap(current_scope.to_s)).sort
-        # define methods for the scopes of the object
-
-        klass.scopes.each do |key, val|
-          self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
-            # This class always has at least one scope, adding a new one should clone this object
-            def #{key}(*args)
-              obj = self.clone
-              # Call reload to make it go back to the webserver the next time it loads
-              obj.reload
-              return obj.enhance_current_scope(:#{key}, *args)
-            end
-          EOE
-          self.scopes[key.to_s] = val
+    class Scope < AbstractScope
+
+      def initialize(klass, opts = {})
+        # see if we have a hash of options and it has a parent in it
+        unless opts[:__parent].respond_to?(:load)
+          raise ArgumentError.new(
+            "Scopes must have a parent object passed in that " + 
+            "responds to #load"
+          )
         end
-        # Use the method current scope because it gives a string
-        # This expression substitutes the options from opts into the default attributes of the scope, it will only copy keys that exist in the original
-        self.scopes[self.current_scope] = opts.inject(self.scopes[current_scope]){|accum,(k,v)| accum.key?(k.to_s) ? accum.merge(k.to_s => v) : accum}
-      end
-
-      def ttl
-        @ttl || 0
-      end
-
-      # Use this method to access the internal data, this guarantees that loading only occurs once per object
-      def internal_object
-        raise "Not Implemented: This method must be implemented in a subclass"
+        super(klass, opts)
       end
 
-      def scopes
-        @scopes ||= {}.with_indifferent_access
+      def load
+        ret = self.klass.load(self.to_hash)
+        @loaded = true
+        ret
       end
 
-      def scope?(scp)
-        self.scopes.key?(scp.to_s)
+      # we break this out here because Scope needs to pass self.klass to 
+      # any sub-scopes.  This is because Scope does not have knowledge
+      # of how to actually load data and delegates that to either
+      # a ResourceScope or an AssociationScope
+      def get_subscope_instance(finder_opts)
+        ApiResource::Associations::Scope.new(
+          self.klass, finder_opts.merge(:__parent => self)
+        )
       end
 
-      def current_scope
-        ActiveSupport::StringInquirer.new(@current_scope.join("_and_").concat("_scope"))
-      end
-
-      def to_hash
-        self.parent_hash.merge(self.scopes[self.current_scope])
-      end
-
-      # takes empty hashes and replaces them with true so that to_query doesn't strip them out
-      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
-
-       # gets the current hash and calls to_query on it
-      def to_query
-        #We need to add the unescape because to_query breaks on nested arrays
-        CGI.unescape(to_query_safe_hash(self.to_hash).to_query)
-      end
-
-      def method_missing(method, *args, &block)
-        self.internal_object.send(method, *args, &block)
-      end
-
-      def reload
-        remove_instance_variable(:@internal_object) if instance_variable_defined?(:@internal_object)
-        self
-      end
-
-      def to_s
-        self.internal_object.to_s
-      end
-
-      def inspect
-        self.internal_object.inspect
-      end
-
-      def blank?
-        self.internal_object.blank?
-      end
-      alias_method :empty?, :blank?
-
-      def present?
-        self.internal_object.present?
-      end
-
-      def expires_in(ttl)
-        ApiResource::Decorators::CachingDecorator.new(self, ttl)
-      end
-
-      protected
-        # scope from the parent
-        def parent_scope
-          ret = @parent ? Array.wrap(@parent.current_scope).collect{|el| el.gsub(/_scope$/,'')} : []
-          ret.collect{|el| el.split(/_and_/)}.flatten
-        end
-        # querystring hash from parent
-        def parent_hash
-          @parent ? @parent.to_hash : {}
-        end
-        def enhance_current_scope(scp, *args)
-          opts = args.extract_options!
-          check_scope(scp)
-          cache_key = "a#{Digest::MD5.hexdigest((args.sort + [scp]).to_s)}"
-          return instance_variable_get("@#{cache_key}") if instance_variable_defined?("@#{cache_key}")
-          return instance_variable_set("@#{cache_key}", self.class.class_factory(self.scopes[scp]).new(self.klass, scp, *args, opts.merge(:parent => self)))
-        end
-        # make sure we have a valid scope
-        def check_scope(scp)
-          raise ArgumentError, "Unknown scope #{scp}" unless self.scope?(scp.to_s)
-        end
     end
-
   end
-
-end
+end