api_resource 0.4.3 → 0.5.0

data/lib/api_resource/associations/single_object_proxy.rb

@@ -1,23 +1,45 @@
-require 'api_resource/associations/association_proxy'
+require 'api_resource/associations/association_scope'
 
 module ApiResource
   
   module Associations
     
-    class SingleObjectProxy < AssociationProxy
+    class SingleObjectProxy < AssociationScope
 
       def serializable_hash(options = {})
         return if self.internal_object.nil?
         self.internal_object.serializable_hash(options)
       end
+
+      def internal_object
+        unless instance_variable_defined?(:@internal_object)
+          if self.remote_path.present?
+            instance_variable_set(:@internal_object, self.load)
+          else
+            instance_variable_set(:@internal_object, nil)
+          end
+        end
+        instance_variable_get(:@internal_object)
+      end
       
       def internal_object=(contents)
-        if contents.is_a?(self.klass) ||
-          contents.respond_to?(:internal_object) && contents.internal_object.is_a?(self.klass) ||
-          contents.nil?
+        if contents.is_a?(self.klass) || contents.nil?
           return @internal_object = contents 
+        elsif contents.is_a?(self.class)
+          return @internal_object = contents.internal_object
+        # a Hash may be attributes and/or a service_uri
+        elsif contents.is_a?(Hash) 
+          contents = contents.symbolize_keys
+          @remote_path = contents.delete(
+            self.class.remote_path_element.to_sym
+          )
+          if contents.present?
+            return @internal_object = self.klass.instantiate_record(contents)
+          end
         else
-          return load(contents)
+          raise ArgumentError.new(
+            "#{contents} must be a #{self.klass}, a #{self.class} or a Hash"
+          )
         end
       end
       
@@ -27,53 +49,22 @@ module ApiResource
         return true
       end
 
-      protected
-      def load_scope_with_options(scope, options)
-        scope = self.loaded_hash_key(scope.to_s, options)
-        # If the service uri is blank you can't load
-        return nil if self.remote_path.blank?
-        self.loaded[scope] ||= begin
-          self.times_loaded += 1
-          self.klass.new(self.load_from_remote(options))
-        end
+      def hash
+        self.id.hash
       end
 
-      def load(contents)
-        # If we get something nil this should just behave like nil
-        return if contents.nil?
-        # if we get an array with a length of one, make it a hash
-        if contents.is_a?(self.class)
-          contents = contents.internal_object.serializable_hash
-        elsif contents.is_a?(Array) && contents.length == 1
-          contents = contents.first
-        end
-        raise "Expected an attributes hash got #{contents}" unless contents.is_a?(Hash)
-        contents = contents.with_indifferent_access
-        # If we don't have a 'service_uri' just assume that these are all attributes and make an object
-        return @internal_object = self.klass.new(contents) unless contents[self.class.remote_path_element]
-        # allow for symbols vs strings with these elements
-        self.remote_path = contents.delete(self.class.remote_path_element)
-        # There's only one hash here so it's hard to distinguish attributes from scopes, the key scopes_only says everything
-        # in this hash is a scope
-        no_attrs = (contents.delete(:scopes_only) || false)
-        attrs = {}
-        contents.each do |key, val|
-          # if this key is an attribute add it to attrs, warn if we've set scopes_only
-          if self.klass.attribute_names.include?(key.to_sym) && !no_attrs
-            attrs[key] = val
-          else
-            warn("#{key} is an attribute of #{self.klass}, beware of name collisions") if no_attrs && self.klass.attribute_names.include?(key)
-            raise "Expected the scope #{key} to have a hash for a value, got #{val}" unless val.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] = val
-          end
-        end
-        @internal_object = attrs.present? ? self.klass.new(attrs) : nil
+      def eql?(other)
+        return self == other
       end
+
+
+      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)
+      end
+
       
     end
     

data/lib/api_resource/associations.rb

@@ -1,13 +1,12 @@
 require 'active_support'
 require 'active_support/string_inquirer'
 require 'api_resource/association_activation'
-require 'api_resource/associations/relation_scope'
+require 'api_resource/associations/abstract_scope'
+require 'api_resource/associations/scope'
 require 'api_resource/associations/resource_scope'
-require 'api_resource/associations/dynamic_resource_scope'
-require 'api_resource/associations/generic_scope'
-require 'api_resource/associations/multi_argument_resource_scope'
-require 'api_resource/associations/multi_object_proxy'
+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'
@@ -129,6 +128,10 @@ module ApiResource
         # structure is {:has_many => {"myname" => "ClassName"}}
         self.related_objects.clone.delete_if{|k,v| k.to_s == "scopes"}.collect{|k,v| v.keys.collect(&:to_sym)}.flatten
       end
+
+      def association_class(assoc)
+        self.association_class_name(assoc).constantize
+      end
       
       def association_class_name(assoc)
         raise ArgumentError, "#{assoc} is not a valid association of #{self}" unless self.association?(assoc)
@@ -162,18 +165,32 @@ module ApiResource
         end
 
         def define_association_as_attribute(assoc_type, assoc_name)
-          # set up dirty tracking for associations
-          
+          # set up dirty tracking for associations, but only for ApiResource
+          # these methods are also used for ActiveRecord
+          # TODO: change this
+          if self.ancestors.include?(ApiResource::Base)
+            define_attribute_method(assoc_name)
+          end
+        
           self.class_eval <<-EOE, __FILE__, __LINE__ + 1
             def #{assoc_name}
-              self.assoc_attributes[:#{assoc_name}] ||= (self.attributes[:#{assoc_name}] || #{self.association_types[assoc_type.to_sym].to_s.classify}ObjectProxy.new(self.association_class_name('#{assoc_name}'), nil, self))
+              @attributes_cache[:#{assoc_name}] ||= begin
+                klass = #{self.association_types[assoc_type.to_sym].to_s.classify}ObjectProxy
+                instance = klass.new(
+                  self.association_class('#{assoc_name}'), self
+                )
+                if @attributes[:#{assoc_name}].present?
+                  instance.internal_object = @attributes[:#{assoc_name}]
+                end
+                instance
+              end
             end
             def #{assoc_name}=(val)
               # get old internal object
-              old_internal_object = self.#{assoc_name}.internal_object
+              unless self.#{assoc_name}.internal_object == val
+                #{assoc_name}_will_change! 
+              end
               self.#{assoc_name}.internal_object = val
-              #{assoc_name}_will_change! unless self.#{assoc_name} == old_internal_object
-              self.#{assoc_name}.internal_object
             end
             def #{assoc_name}?
               self.#{assoc_name}.internal_object.present?
@@ -204,6 +221,10 @@ module ApiResource
       self.class.association?(assoc)
     end
     
+    def association_class(assoc)
+      self.class.association_class(assoc)
+    end
+
     def association_class_name(assoc)
       self.class.association_class_name(assoc)
     end

data/lib/api_resource/attributes.rb

@@ -10,27 +10,20 @@ module ApiResource
       
       alias_method_chain :save, :dirty_tracking
       
-      class_attribute :attribute_names, :public_attribute_names, :protected_attribute_names, :attribute_types
+      class_attribute(
+        :attribute_names, 
+        :public_attribute_names, 
+        :protected_attribute_names, 
+        :attribute_types
+      )
       
       cattr_accessor :valid_typecasts; self.valid_typecasts = [:date, :time, :float, :integer, :int, :fixnum, :string, :array]
 
-      attr_reader :attributes
-      
       self.attribute_names = []
       self.public_attribute_names = []
       self.protected_attribute_names = []
       self.attribute_types = {}.with_indifferent_access
       
-      define_method(:attributes) do
-        return @attributes if @attributes
-        # Otherwise make the attributes hash of all the attributes
-        @attributes = HashWithIndifferentAccess.new
-        self.class.attribute_names.each do |attr|
-          @attributes[attr] = self.send("#{attr}")
-        end
-        @attributes
-      end
-
 
       # This method is important for reloading an object. If the
       # object has already been loaded, its associations will trip
@@ -68,6 +61,7 @@ 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)
@@ -75,24 +69,9 @@ module ApiResource
           end
           self.attribute_names += [arg.to_sym]
           self.public_attribute_names += [arg.to_sym]
-          
-          # Override the setter for dirty tracking
-          self.class_eval <<-EOE, __FILE__, __LINE__ + 1
-            def #{arg}
-              attribute_with_default(:#{arg})
-            end
-          
-            def #{arg}=(val)
-              real_val = typecast_attribute(:#{arg}, val)
-              #{arg}_will_change! unless self.#{arg} == real_val
-              attributes[:#{arg}] = real_val
-            end
-            
-            def #{arg}?
-              attributes[:#{arg}].present?
-            end
-          EOE
+          self.define_accessor_methods(arg)
         end
+
         self.attribute_names.uniq!
         self.public_attribute_names.uniq!
       end
@@ -108,28 +87,35 @@ module ApiResource
           self.attribute_names += [arg.to_sym]
           self.protected_attribute_names += [arg.to_sym]
           
-          # These attributes cannot be set, throw an error if you try
-          self.class_eval <<-EOE, __FILE__, __LINE__ + 1
-
-            def #{arg}
-              self.attribute_with_default(:#{arg})
-            end
-          
-            def #{arg}=(val)
-              raise "#{arg} is a protected attribute and cannot be set"
-            end
-            
-            def #{arg}?
-              self.attributes[:#{arg}].present?
-            end
-          EOE
+          self.define_accessor_methods(arg)
         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
+          def #{meth}
+            read_attribute(:#{meth})
+          end
+        
+          def #{meth}=(new_val)
+            write_attribute(:#{meth}, new_val)
+          end
+          
+          def #{meth}?
+            read_attribute(:#{meth}).present?
+          end
+        EOE
+        # sets up dirty tracking
+        define_attribute_method(meth)
+      end
+
       def define_attribute_type(field, type)
-        raise "#{type} is not a valid type" unless self.valid_typecasts.include?(type.to_sym)
+        unless self.valid_typecasts.include?(type.to_sym)
+          raise "#{type} is not a valid type" 
+        end
         self.attribute_types[field] = type.to_sym
       end
       
@@ -148,15 +134,31 @@ module ApiResource
         self.protected_attribute_names.clear
       end
     end
-    
+
+    # override the initializer to set up some default values
+    def initialize(*args)
+      @attributes = @attributes_cache = HashWithIndifferentAccess.new
+    end
+
+    def attributes
+      attrs = {}
+      self.attribute_names.each{|name| attrs[name] = read_attribute(name)}
+      attrs
+    end
+
     # set new attributes
     def attributes=(new_attrs)
       new_attrs.each_pair do |k,v|
+        if self.protected_attribute?(k)
+          raise Exception.new(
+            "#{k} is a protected attribute and cannot be mass-assigned"
+          )
+        end
         self.send("#{k}=",v) unless k.to_sym == :id
       end
       new_attrs
     end
-    
+
     def save_with_dirty_tracking(*args)
       if save_without_dirty_tracking(*args)
         @previously_changed = self.changes
@@ -182,6 +184,23 @@ module ApiResource
       
       set_attributes_as_current(*attrs)
     end
+
+    def read_attribute(name)
+      self.typecasted_attribute(name.to_sym)
+    end
+
+    def write_attribute(name, val)
+      old_val = read_attribute(name)
+      new_val = self.typecast_attribute(name, val)
+
+      unless old_val == new_val
+        self.send("#{name}_will_change!")
+      end
+      # delete the old cached value and assign new val to both
+      # @attributes and @attributes_cache
+      @attributes_cache.delete(name.to_sym)
+      @attributes[name.to_sym] = @attributes_cache[name.to_sym] = new_val
+    end
     
     def attribute?(name)
       self.class.attribute?(name)
@@ -204,10 +223,6 @@ module ApiResource
     
     protected
     
-    def attribute_with_default(field)
-      self.attributes[field].nil? ? self.default_value_for_field(field) : self.attributes[field]
-    end
-
     def default_value_for_field(field)
       case self.class.attribute_types[field.to_sym]
         when :array
@@ -217,25 +232,49 @@ module ApiResource
       end
     end
 
-    def typecast_attribute(field, val)
-      return val unless self.class.attribute_types.include?(field)
-      case self.class.attribute_types[field.to_sym]
-        when :date
-          return val.class == Date ? val.dup : Date.parse(val)
-        when :time
-          return val.class == Time ? val.dup : Time.parse(val)
-        when :integer, :int, :fixnum
-          return val.class == Fixnum ? val.dup : val.to_i rescue val
-        when :float
-          return val.class == Float ? val.dup : val.to_f rescue val
-        when :string
-          return val.class == String ? val.dup : val.to_s rescue val
-        when :array
-          return val.class == Array ? val.dup : Array.wrap(val)
+    def typecasted_attribute(field)
+
+      @attributes ||= HashWithIndifferentAccess.new
+      @attributes_cache ||= HashWithIndifferentAccess.new
+
+      if @attributes_cache.has_key?(field.to_sym)
+        return @attributes_cache[field.to_sym]
+      else
+        # pull out of the raw attributes
+        if @attributes.has_key?(field.to_sym)
+          val = @attributes[field.to_sym]
         else
-          # catches the nil case and just leaves it alone
-          return val.dup rescue val
+          val = self.default_value_for_field(field)
+        end
+        # now we typecast
+        val = self.typecast_attribute(field, val)
+        return @attributes_cache[field.to_sym] = val
+      end
+    end
+
+    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
+        end
       end
+      val
     end
     
   end