api_resource 0.4.0 → 0.4.1

data/lib/api_resource/associations/belongs_to_remote_object_proxy.rb

@@ -1,16 +0,0 @@
-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
-        # 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))
-        end
-        true
-      end
-    end
-  end
-end

data/lib/api_resource/associations/dynamic_resource_scope.rb

@@ -1,23 +0,0 @@
-require 'api_resource/associations/resource_scope'
-
-module ApiResource
-  module Associations
-    class DynamicResourceScope < ResourceScope
-      
-      attr_accessor :dynamic_value
-      # initializer - set up the dynamic value
-      def initialize(klass, current_scope, dynamic_value, opts = {})
-        self.dynamic_value = dynamic_value
-        super(klass, current_scope, opts)
-      end
-      # get the to_query value for this resource scope
-      def to_hash
-        hsh = self.scopes[self.current_scope].clone
-        hsh.each_pair do |k,v|
-          hsh[k] = self.dynamic_value
-        end
-        self.parent_hash.merge(hsh)
-      end
-    end
-  end
-end

data/lib/api_resource/associations/generic_scope.rb

@@ -1,68 +0,0 @@
-require 'api_resource/associations/resource_scope'
-
-module ApiResource
-  module Associations
-
-    class GenericScope < ResourceScope
-      attr_reader :name
-      attr_reader :params
-      attr_reader :types
-      attr_reader :values
-
-      # Gets called when a scope is called.  Stores everything in
-      # this class.  Sorry, couldn't be bothered to figure out the 
-      # class hierarchy.
-      #
-      # klass - ApiResourceBase class
-      # current_scope - sym for the scope
-      # *args - arguments being passed to the scope
-      def initialize(klass, current_scope, *args)
-
-        @name = current_scope # contains sym with scope ie :for_provider
-        @params = klass.related_objects[:scopes][current_scope].keys
-        @types = klass.related_objects[:scopes][current_scope].values
-
-        # Bail if we have crap
-        if @params == nil
-          raise "Scope #{@name} does not exist #{klass.name}.  Scopes: #{klass.related_objects[:scopes]}" 
-        end
-
-        # extract parent scope stuff
-        opts = {}
-        last_arg = args[args.count - 1]
-        if last_arg != nil && last_arg.is_a?(Hash) && last_arg[:parent] != nil
-          args = args.slice(0, args.count - 1)
-          opts = last_arg
-        end
-
-        # walk through parameters and types and assign values from *args to parameters
-        @values = []
-        @params.count.times do |i|
-          if @types[i] == :rest
-            @values << args.slice(i, args.count)
-          else
-            @values << args[i]
-          end
-        end
-
-        # Let the parent class do its magic.
-        super(klass, current_scope, opts)
-      end
-
-      # get the to_query value for this resource scope
-      def to_hash
-        # debugger
-        if @params.count == 0
-          scope_arguments = true 
-        else 
-          scope_arguments = {}
-          @params.count.times do |i|
-            scope_arguments[@params[i]] = @values[i] if @values[i] != nil
-          end
-        end
-        self.parent_hash.merge({@name => scope_arguments})
-      end
-    end
-  end
-end
-

data/lib/api_resource/associations/has_many_remote_object_proxy.rb

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

data/lib/api_resource/associations/has_many_through_remote_object_proxy.rb

@@ -1,13 +0,0 @@
-module ApiResource
-  module Associations
-    module HasManyThroughRemoteObjectProxy
-      def has_many_through_remote(association, options) 
-        self.instance_eval do
-          send(:define_method, association) do
-            send(options[:through]).collect{ |t| t.send(association.to_s.singularize) }.flatten  
-          end
-        end
-      end
-    end    
-  end
-end

data/lib/api_resource/associations/has_one_remote_object_proxy.rb

@@ -1,24 +0,0 @@
-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
-        # 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
-      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
-      end
-    end
-  end
-end

data/lib/api_resource/associations/multi_argument_resource_scope.rb

@@ -1,15 +0,0 @@
-require 'api_resource/associations/dynamic_resource_scope'
-
-module ApiResource
-  module Associations
-    class MultiArgumentResourceScope < DynamicResourceScope
-      # initialize with a variable number of dynamic arguments
-      def initialize(klass, current_scope, *dynamic_value)
-        # pull off opts
-        opts = dynamic_value.extract_options!
-        # we always dynamic value to be an Array, so we don't use the splat here
-        super(klass, current_scope, dynamic_value.flatten, opts)
-      end
-    end
-  end
-end

data/lib/api_resource/associations/multi_object_proxy.rb

@@ -1,84 +0,0 @@
-require 'api_resource/associations/association_proxy'
-
-module ApiResource
-  
-  module Associations
-   
-      class MultiObjectProxy < AssociationProxy
-
-        include Enumerable
-
-        def all
-          self.internal_object
-        end
-
-        def each(*args, &block)
-          self.internal_object.each(*args, &block)
-        end
-        
-        def ==(other)
-          return false if self.class != other.class
-          if self.internal_object.is_a?(Array)
-            self.internal_object.sort.each_with_index do |elem, i|
-              return false if other.internal_object.sort[i].attributes != elem.attributes
-            end
-          end
-          return true
-        end
-
-        def serializable_hash(options)
-          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)
-        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
-          end
-
-          settings = contents.with_indifferent_access if contents.is_a?(Hash)
-          settings ||= {}.with_indifferent_access
-
-          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
-          end
-
-          # Create the internal object
-          @internal_object = contents.is_a?(Array) ? contents.collect{|item| self.klass.new(item)} : nil
-        end
-      end
-    
-  end
-  
-end

data/lib/api_resource/associations/related_object_hash.rb

@@ -1,12 +0,0 @@
-module ApiResource
-  module Associations 
-    # RelatedObjectHash, re-defines dup to be recursive
-    class RelatedObjectHash < HashWithIndifferentAccess
-      def dup
-        Marshal.load(Marshal.dump(self))
-      end
-      # use this behavior for clone too
-      alias_method :clone, :dup
-    end
-  end
-end

data/lib/api_resource/associations/relation_scope.rb

@@ -1,25 +0,0 @@
-require 'api_resource/associations/scope'
-
-module ApiResource
-  
-  module Associations
-    
-    class RelationScope < Scope
-
-      # Use this method to access the internal data, this guarantees that loading only occurs once per object
-      def internal_object
-        ApiResource.with_ttl(ttl) do
-          @internal_object ||= self.klass.send(:load_scope_with_options, self.current_scope, self.to_hash)
-        end
-      end
-      # 
-      # class factory
-      def self.class_factory(hsh)
-        ApiResource::Associations::RelationScope
-      end
-
-    end
-    
-  end
-  
-end

data/lib/api_resource/associations/resource_scope.rb

@@ -1,32 +0,0 @@
-require 'api_resource/associations/scope'
-
-module ApiResource
-
-  module Associations
-
-    class ResourceScope < Scope
-
-      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
-      end
-    end
-  end
-end

data/lib/api_resource/associations/scope.rb

@@ -1,132 +0,0 @@
-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
-        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"
-      end
-
-      def scopes
-        @scopes ||= {}.with_indifferent_access
-      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.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