api_resource 0.5.1 → 0.6.0

data/lib/api_resource.rb

@@ -22,16 +22,19 @@ module ApiResource
   autoload :Attributes
   autoload :Base
   autoload :Callbacks
+  autoload :Conditions
   autoload :Connection
   autoload :CustomMethods
   autoload :Decorators
   autoload :Formats
+  autoload :Finders
   autoload :Local
   autoload :LogSubscriber
   autoload :Mocks
   autoload :ModelErrors
   autoload :Observing
   autoload :Scopes
+  autoload :Typecast
   autoload :Validations
   
   require 'api_resource/railtie'
@@ -65,7 +68,7 @@ module ApiResource
       :token, :token=, :timeout, 
       :open_timeout, 
       :reset_connection, :ttl, :ttl=,
-      :to => ApiResource::Base
+      :to => "ApiResource::Base"
     
   end
 

data/lib/api_resource/associations.rb

@@ -1,22 +1,22 @@
 require 'active_support'
 require 'active_support/string_inquirer'
-require 'api_resource/association_activation'
-require 'api_resource/associations/abstract_scope'
-require 'api_resource/associations/scope'
-require 'api_resource/associations/resource_scope'
-require 'api_resource/associations/association_scope'
-require 'api_resource/associations/single_object_proxy'
-require 'api_resource/associations/multi_object_proxy'
-require 'api_resource/associations/belongs_to_remote_object_proxy'
-require 'api_resource/associations/has_one_remote_object_proxy'
-require 'api_resource/associations/has_many_remote_object_proxy'
-require 'api_resource/associations/has_many_through_remote_object_proxy'
-require 'api_resource/associations/related_object_hash'
 
 module ApiResource
   
   module Associations
+
+    #TODO: many of these methods should also force loading of the resource definition
     extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :AssociationProxy
+    autoload :BelongsToRemoteObjectProxy
+    autoload :HasManyRemoteObjectProxy
+    autoload :HasManyThroughRemoteObjectProxy
+    autoload :HasOneRemoteObjectProxy
+    autoload :MultiObjectProxy
+    autoload :RelatedObjectHash
+    autoload :SingleObjectProxy
 
     included do
       
@@ -81,7 +81,7 @@ module ApiResource
               options = options.with_indifferent_access
               # Raise an error if we have multiple args and options
               raise "Invalid arguments to #{assoc}" unless options.blank? || args.length == 1
-              args.each do |arg|
+              args.each do |arg| 
                 klass_name = (options[:class_name] ? options[:class_name].to_s.classify : arg.to_s.classify)
                 # add this to any descendants - the other methods etc are handled by inheritance
                 ([self] + self.descendants).each do |klass|
@@ -140,6 +140,18 @@ module ApiResource
           return self.find_namespaced_class_name(ret[1]) if ret
         end
       end
+
+      # TODO: add a special foreign_key option to associations
+      def association_foreign_key_field(assoc)
+        # for now just use the association name
+        str = assoc.to_s.singularize.foreign_key
+
+        if has_many?(assoc)
+          str = str.pluralize
+        end
+
+        str.to_sym
+      end
       
       protected
 
@@ -172,10 +184,13 @@ module ApiResource
             define_attribute_method(assoc_name)
           end
         
+          # TODO: Come up with a better implementation for the foreign key thing
+          # implement the rest of the active record methods, refactor this into something
+          # a littel bit more sensible
           self.class_eval <<-EOE, __FILE__, __LINE__ + 1
             def #{assoc_name}
               @attributes_cache[:#{assoc_name}] ||= begin
-                klass = #{self.association_types[assoc_type.to_sym].to_s.classify}ObjectProxy
+                klass = Associations::#{self.association_types[assoc_type.to_sym].to_s.classify}ObjectProxy
                 instance = klass.new(
                   self.association_class('#{assoc_name}'), self
                 )
@@ -195,6 +210,7 @@ module ApiResource
             def #{assoc_name}?
               self.#{assoc_name}.internal_object.present?
             end
+
           EOE
         end
         

data/lib/api_resource/associations/association_proxy.rb

@@ -0,0 +1,97 @@
+module ApiResource
+  
+  module Associations
+   
+    class AssociationProxy
+
+
+      class_attribute :remote_path_element
+      self.remote_path_element = :service_uri 
+
+      attr_accessor :remote_path
+      attr_reader :owner, :klass, :finder_opts
+
+      # 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
+
+      def initialize(klass, owner, 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
+
+        @owner = owner
+        
+        self.internal_object = opts
+      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
+
+      # unset all of our scope values and our internal object
+      def reload
+        @loaded = false
+        if instance_variable_defined?(:@internal_object)
+          remove_instance_variable(:@internal_object)
+        end
+        self
+      end
+
+      def expires_in(ttl)
+        ApiResource::Decorators::CachingDecorator.new(self, ttl)
+      end
+
+
+      def includes(*args)
+        self.to_condition.merge!(self.klass.includes(*args))
+      end
+
+      def ==(other)
+         raise "Not Implemented: This method must be implemented in a subclass"
+      end
+
+      protected
+
+        def method_missing(method, *args, &block)
+          # If we are calling a scoped method that should be allowed
+          if self.klass.scope?(method)
+            cond = self.klass.send(method, *args, &block)
+            self.to_condition.merge!(cond)
+          else
+            self.internal_object.send(method, *args, &block)
+          end
+        end
+
+        # require our subclasses to implement a way to find records
+        def load
+          raise NotImplementedError.new("#{self.class} must implement #load")
+        end
+
+    end
+    
+  end
+  
+end

data/lib/api_resource/associations/belongs_to_remote_object_proxy.rb

@@ -1,4 +1,3 @@
-require 'api_resource/associations/single_object_proxy'
 module ApiResource
   module Associations
     class BelongsToRemoteObjectProxy < SingleObjectProxy

data/lib/api_resource/associations/has_many_remote_object_proxy.rb

@@ -1,4 +1,3 @@
-require 'api_resource/associations/multi_object_proxy'
 module ApiResource
   module Associations
     class HasManyRemoteObjectProxy < MultiObjectProxy

data/lib/api_resource/associations/has_one_remote_object_proxy.rb

@@ -1,4 +1,3 @@
-require 'api_resource/associations/single_object_proxy'
 module ApiResource
   module Associations
     class HasOneRemoteObjectProxy < SingleObjectProxy
@@ -11,11 +10,15 @@ module ApiResource
       end
 
       protected
+
+      # because of how this works we use a multi object proxy and return the first element
+      def to_condition
+        ApiResource::Conditions::MultiObjectAssociationCondition.new(self.klass, self.remote_path)
+      end
       
       def load(opts = {})
-        data = self.klass.connection.get(self.build_load_path(opts))
-        return nil if data.blank?
-        return self.klass.new(data.first)
+        @loaded = true
+        Array.wrap(self.to_condition.find).first
       end
 
     end

data/lib/api_resource/associations/multi_object_proxy.rb

@@ -1,10 +1,8 @@
-require 'api_resource/associations/association_scope'
-
 module ApiResource
   
   module Associations
    
-      class MultiObjectProxy < AssociationScope
+      class MultiObjectProxy < AssociationProxy
 
         include Enumerable
 
@@ -34,7 +32,7 @@ module ApiResource
 
         def internal_object=(contents)
           # if we were passed in a service uri, stop here
-          return true if self.set_remote_path_and_scopes(contents)
+          return true if self.set_remote_path(contents)
 
           if contents.try(:first).is_a?(self.klass)
             return @internal_object = contents 
@@ -69,18 +67,19 @@ module ApiResource
           self.internal_object.collect{|obj| obj.serializable_hash(options) }
         end
 
+        protected
+
+        def to_condition
+          ApiResource::Conditions::MultiObjectAssociationCondition.new(self.klass, self.remote_path)
+        end
+
         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)
+          self.to_condition.find
         end
 
-        protected
-
-        # 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)
+        def set_remote_path(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
@@ -96,10 +95,6 @@ module ApiResource
             self.class.remote_path_element.to_sym
           )
 
-          service_uri_el.each_pair do |scope_name, scope_def|
-            self.define_subscope(scope_name, scope_def)
-          end
-
           return @remote_path.present?
         end
 

data/lib/api_resource/associations/single_object_proxy.rb

@@ -1,10 +1,8 @@
-require 'api_resource/associations/association_scope'
-
 module ApiResource
   
   module Associations
     
-    class SingleObjectProxy < AssociationScope
+    class SingleObjectProxy < AssociationProxy
 
       def serializable_hash(options = {})
         return if self.internal_object.nil?
@@ -57,12 +55,16 @@ module ApiResource
         return self == other
       end
 
+      protected
+
+      def to_condition
+        ApiResource::Conditions::SingleObjectAssociationCondition.new(self.klass, self.remote_path)
+      end
 
+      # Should make a proper conditions object and call find on it
       def load(opts = {})
-        data = self.klass.connection.get(self.build_load_path(opts))
         @loaded = true
-        return nil if data.blank?
-        return self.klass.instantiate_record(data)
+        @internal_object = self.to_condition.find
       end
 
       

data/lib/api_resource/attributes.rb

@@ -7,6 +7,9 @@ module ApiResource
     include ActiveModel::Dirty
     
     included do
+
+      # include ApiResource::Typecast if it isn't already
+      include ApiResource::Typecast
       
       alias_method_chain :save, :dirty_tracking
       
@@ -16,8 +19,6 @@ module ApiResource
         :protected_attribute_names, 
         :attribute_types
       )
-      
-      cattr_accessor :valid_typecasts; self.valid_typecasts = [:date, :time, :float, :integer, :int, :fixnum, :string, :array]
 
       self.attribute_names = []
       self.public_attribute_names = []
@@ -61,38 +62,21 @@ module ApiResource
     module ClassMethods
       
       def define_attributes(*args)
-
         args.each do |arg|
-          if arg.is_a?(Array)
-            self.define_attribute_type(arg.first, arg.second)
-            arg = arg.first
-          end
-          self.attribute_names += [arg.to_sym]
-          self.public_attribute_names += [arg.to_sym]
-          self.define_accessor_methods(arg)
+          self.store_attribute_data(arg, :public)
         end
-
         self.attribute_names.uniq!
         self.public_attribute_names.uniq!
       end
       
       def define_protected_attributes(*args)
         args.each do |arg|
-          
-          if arg.is_a?(Array)
-            self.define_attribute_type(arg.first, arg.second)
-            arg = arg.first
-          end
-
-          self.attribute_names += [arg.to_sym]
-          self.protected_attribute_names += [arg.to_sym]
-          
-          self.define_accessor_methods(arg)
+          self.store_attribute_data(arg, :protected)
         end
         self.attribute_names.uniq!
         self.protected_attribute_names.uniq!
       end
-      
+
       def define_accessor_methods(meth)
         # Override the setter for dirty tracking
         self.class_eval <<-EOE, __FILE__, __LINE__ + 1
@@ -113,7 +97,7 @@ module ApiResource
       end
 
       def define_attribute_type(field, type)
-        unless self.valid_typecasts.include?(type.to_sym)
+        unless self.typecasters.keys.include?(type.to_sym)
           raise "#{type} is not a valid type" 
         end
         self.attribute_types[field] = type.to_sym
@@ -133,6 +117,22 @@ module ApiResource
         self.public_attribute_names.clear
         self.protected_attribute_names.clear
       end
+
+      # stores the attribute type data and the name of the 
+      # attributes we are creating
+      def store_attribute_data(arg, type)
+        if arg.is_a?(Array)
+          self.define_attribute_type(arg.first, arg.second)
+          arg = arg.first
+        end
+        self.attribute_names += [arg.to_sym]
+        self.send(
+          "#{type}_attribute_names=",
+          self.send("#{type}_attribute_names") + [arg.to_sym]
+        )
+        self.define_accessor_methods(arg)
+      end
+
     end
 
     # override the initializer to set up some default values
@@ -255,26 +255,14 @@ module ApiResource
     def typecast_attribute(field, val)
       # if we have a valid value and we are planning to typecast go 
       # into this case statement
-      if self.class.attribute_types.include?(field.to_sym) && val.present?
-        val = case self.class.attribute_types[field.to_sym]
-          when :date
-            val.class == Date ? val.dup : Date.parse(val)
-          when :time
-            val.class == Time ? val.dup : Time.parse(val)
-          when :integer, :int, :fixnum
-            val.class == Fixnum ? val.dup : val.to_i rescue val
-          when :float
-            val.class == Float ? val.dup : val.to_f rescue val
-          when :string
-            val.class == String ? val.dup : val.to_s rescue val
-          when :array
-            val.class == Array ? val.dup : Array.wrap(val)
-          else
-            # catches the nil case and just leaves it alone
-            val.dup rescue val
+      if self.class.attribute_types.include?(field.to_sym)
+        caster = self.class.typecasters[self.class.attribute_types[field.to_sym]]
+        if caster.present?
+          val = caster.from_api(val)
         end
       end
-      val
+
+      return val
     end
     
   end