api_resource 0.4.3 → 0.5.0

data/lib/api_resource/base.rb

@@ -25,11 +25,15 @@ module ApiResource
     
     class_attribute :primary_key
     self.primary_key = "id"
+
+    delegate :logger, :to => ApiResource
     
     class << self
       
       # writers - accessors with defaults were not working
       attr_writer :element_name, :collection_name
+
+      delegate :logger, :to => ApiResource
       
       def inherited(klass)
         # Call the methods of the superclass to make sure inheritable accessors and the like have been inherited
@@ -44,33 +48,38 @@ module ApiResource
         EOE
         true
       end
+
+      def resource_definition
+        @resource_definition
+      end
+
       # This makes a request to new_element_path
       def set_class_attributes_upon_load
         return true if self == ApiResource::Base
         begin
-          class_data = self.connection.get(
+          @resource_definition = self.connection.get(
             self.new_element_path, self.headers
           )
           # Attributes go first
-          if class_data["attributes"]
+          if resource_definition["attributes"]
             
             define_attributes(
-              *(class_data["attributes"]["public"] || [])
+              *(resource_definition["attributes"]["public"] || [])
             )
             define_protected_attributes(
-              *(class_data["attributes"]["protected"] || [])
+              *(resource_definition["attributes"]["protected"] || [])
             ) 
             
           end
           # Then scopes
-          if class_data["scopes"]
-            class_data["scopes"].each_pair do |scope_name, opts|
+          if resource_definition["scopes"]
+            resource_definition["scopes"].each_pair do |scope_name, opts|
               self.scope(scope_name, opts)
             end
           end
           # Then associations
-          if class_data["associations"]
-            class_data["associations"].each_pair do |key, hash|
+          if resource_definition["associations"]
+            resource_definition["associations"].each_pair do |key, hash|
               hash.each_pair do |assoc_name, assoc_options|
                 self.send(key, assoc_name, assoc_options)
               end
@@ -81,15 +90,14 @@ module ApiResource
           # define the basic methods but we need to override all the setters 
           # so we do dirty tracking
           attrs = []
-          if class_data["attributes"] && class_data["attributes"]["public"]
-            attrs += class_data["attributes"]["public"].collect{|v| 
+          if resource_definition["attributes"] && resource_definition["attributes"]["public"]
+            attrs += resource_definition["attributes"]["public"].collect{|v| 
               v.is_a?(Array) ? v.first : v
             }.flatten
           end
-          if class_data["associations"]
-            attrs += class_data["associations"].values.collect(&:keys).flatten
+          if resource_definition["associations"]
+            attrs += resource_definition["associations"].values.collect(&:keys).flatten
           end
-          define_attribute_methods(attrs)
           
         # Swallow up any loading errors because the site may be incorrect
         rescue Exception => e
@@ -114,29 +122,32 @@ module ApiResource
       # load our resource definition to make sure we know what this class
       # responds to
       def respond_to?(*args)
-        self.load_class_data
+        self.load_resource_definition
         super
       end
       
-      def load_class_data
-        unless instance_variable_defined?(:@class_data)
-          @class_data = true
+      def load_resource_definition
+        unless instance_variable_defined?(:@resource_definition)
+          # set to not nil so we don't get an infinite loop
+          @resource_definition = true
           self.set_class_attributes_upon_load
+          return true
         end
-        true
+        # we didn't do anything
+        false
       end
 
-      def reload_class_data
+      def reload_resource_definition
         # clear the public_attribute_names, protected_attribute_names
-        if instance_variable_defined?(:@class_data)
-          remove_instance_variable(:@class_data)
+        if instance_variable_defined?(:@resource_definition)
+          remove_instance_variable(:@resource_definition)
           self.clear_attributes
           self.clear_related_objects
         end
-        self.load_class_data
+        self.load_resource_definition
       end
       # backwards compatibility
-      alias_method :reload_class_attributes, :reload_class_data
+      alias_method :reload_class_attributes, :reload_resource_definition
       
       def token_with_new_token_set=(new_token)
         self.token_without_new_token_set = new_token
@@ -163,7 +174,7 @@ module ApiResource
         
         # reset class attributes and try to reload them if the site changed
         unless self.site.to_s == old_site
-          self.reload_class_data
+          self.reload_resource_definition
         end
         
         return site
@@ -219,12 +230,17 @@ module ApiResource
       end
 
       def prefix=(value = '/')
-        prefix_call = value.gsub(/:\w+/) { |key| "\#{URI.escape options[#{key}].to_s}"}
+        prefix_call = value.gsub(/:\w+/) { |key| 
+          "\#{URI.escape options[#{key}].to_s}"
+        }
         @prefix_parameters = nil
         silence_warnings do
           instance_eval <<-EOE, __FILE__, __LINE__ + 1
             def prefix_source() "#{value}" end
-            def prefix(options={}) "#{prefix_call}" end
+            def prefix(options={}) 
+              ret = "#{prefix_call}"
+              ret =~ Regexp.new(Regexp.escape("//")) ? "/" : ret
+            end
           EOE
         end
       rescue Exception => e
@@ -258,22 +274,20 @@ module ApiResource
         end
       end
       
-      # TODO: Add back in support for non-dynamic prefix paths (e.g. /subdir/resources/new.json)
-      def new_element_path
-        "/#{collection_name}/new.#{format.extension}"
+      # path to find 
+      def new_element_path(prefix_options = {})
+        File.join(
+          self.prefix(prefix_options), 
+          self.collection_name, 
+          "new.#{format.extension}"
+        )
       end
       
       def collection_path(prefix_options = {}, query_options = nil)
         prefix_options, query_options = split_options(prefix_options) if query_options.nil?
 
-        # If we have a prefix, we need a foreign key id
-        # This regex detects '//', which means no foreign key id is present.
-        if prefix(prefix_options) =~ /\/\/$/
-          "/#{collection_name}.#{format.extension}#{query_string(query_options)}"
-        else
-          # Fall back on this rather than search without the id
-          "#{prefix(prefix_options)}#{collection_name}.#{format.extension}#{query_string(query_options)}"
-        end
+        # Fall back on this rather than search without the id
+        "#{prefix(prefix_options)}#{collection_name}.#{format.extension}#{query_string(query_options)}"
       end
       
       def build(attributes = {})
@@ -289,6 +303,10 @@ module ApiResource
       # 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) || {}
         
@@ -343,13 +361,29 @@ module ApiResource
       def delete(id, options = {})
         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
-          unless self.instance_variable_defined?(:@class_data)
-            self.set_class_attributes_upon_load
-            self.instance_variable_set(:@class_data, true)
+          if self.load_resource_definition
             return self.send(meth, *args, &block)
           end
           super
@@ -395,15 +429,6 @@ module ApiResource
           instantiate_record(connection.get(path, headers))
         end
 
-        def instantiate_collection(collection)
-          collection.collect! { |record| instantiate_record(record) }
-        end
-
-        def instantiate_record(record)
-          new(record)
-        end
-
-
         # Accepts a URI and creates the site URI from that.
         def create_site_uri_from(site)
           site.is_a?(URI) ? site.dup : uri_parser.parse(site)
@@ -443,10 +468,13 @@ module ApiResource
     end
     
     def initialize(attributes = {})
+      # call super's initialize to set up any variables that we need
+      super(attributes)
       # if we initialize this class, load the attributes
-      self.class.load_class_data
-      # Now we can make a call to setup the inheriting klass with its attributes
-      load(attributes)
+      self.class.load_resource_definition
+      # Now we can make a call to setup the inheriting 
+      # klass with its attributes
+      self.attributes = attributes
     end
     
     def new?
@@ -459,12 +487,12 @@ module ApiResource
     end
     
     def id
-      self.attributes[self.class.primary_key]
+      self.read_attribute(self.class.primary_key)
     end
     
     # Bypass dirty tracking for this field
     def id=(id)
-      attributes[self.class.primary_key] = id
+      @attributes[self.class.primary_key] = id
     end
     
     def ==(other)
@@ -480,9 +508,7 @@ module ApiResource
     end
     
     def dup
-      self.class.new.tap do |resource|
-        resource.attributes = self.attributes
-      end
+      self.class.instantiate_record(self.attributes)
     end
     
     def update_attributes(attrs)
@@ -507,8 +533,15 @@ module ApiResource
     end
     
     def reload
-      remove_instance_variable(:@assoc_attributes) if instance_variable_defined?(:@assoc_attributes)
-      self.load(self.class.find(to_param, :params => @prefix_options).attributes_without_proxies)
+      # find the record from the remote service
+      reloaded = self.class.find(self.id)
+      
+      # clear out the attributes cache
+      @attributes_cache = HashWithIndifferentAccess.new
+      # set up our attributes cache on our record
+      @attributes = reloaded.instance_variable_get(:@attributes)
+      
+      reloaded
     end
     
     def to_param
@@ -531,56 +564,13 @@ module ApiResource
       self.class.prefix_source.scan(/\:(\w+)/).collect{|match| match.first.to_sym}
     end
     
-    def load(attributes)
-      return if attributes.nil?
-      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
-      
-      attributes.symbolize_keys.each do |key, value|
-        # If this attribute doesn't exist define it as a protected attribute
-        self.class.define_protected_attributes(key) unless self.respond_to?(key)
-        #self.send("#{key}_will_change!") if self.respond_to?("#{key}_will_change!")
-        self.attributes[key] =
-          case value
-            when Array
-              if self.has_many?(key)
-                MultiObjectProxy.new(self.has_many_class_name(key), value)
-              elsif self.association?(key)
-                raise ArgumentError, "Expected a hash value or nil, got: #{value.inspect}"
-              else
-                typecast_attribute(key, value)
-              end
-            when Hash
-              if self.has_many?(key)
-                MultiObjectProxy.new(self.has_many_class_name(key), value)
-              elsif self.association?(key)
-                #binding.pry
-                SingleObjectProxy.new(self.association_class_name(key), value)
-              else
-                typecast_attribute(key, value)
-              end
-            when NilClass
-              # If it's nil and an association then create a blank object
-              if self.has_many?(key)
-                return MultiObjectProxy.new(self.has_many_class_name(key), [])
-              elsif self.association?(key)
-                SingleObjectProxy.new(self.association_class_name(key), value)
-              end
-            else
-              raise ArgumentError, "expected an array or a hash for the association #{key}, got: #{value.inspect}" if self.association?(key)
-              typecast_attribute(key, value)
-          end
-      end
-      return self
-    end
-    
     # Override to_s and inspect so they only show attributes
     # and not associations, this prevents force loading of associations
     # when we call to_s or inspect on a descendent of base but allows it if we 
     # try to evaluate an association directly
     def to_s
-      return "#<#{self.class}:#{(self.object_id * 2).to_s(16)} @attributes=#{self.attributes.inject({}){|accum,(k,v)| self.association?(k) ? accum : accum.merge(k => v)}}"
+      return "#<#{self.class}:#{(self.object_id * 2).to_s(16)} @attributes=#{self.attributes}"
     end
-    
     alias_method :inspect, :to_s
     
     # Methods for serialization as json or xml, relying on the serializable_hash method
@@ -593,11 +583,17 @@ module ApiResource
     end
     
     def serializable_hash(options = {})
+      
       action = options[:action]
+      
       include_nil_attributes = options[:include_nil_attributes]
+      
       options[:include_associations] = options[:include_associations] ? options[:include_associations].symbolize_array : self.changes.keys.symbolize_array.select{|k| self.association?(k)}
+      
       options[:include_extras] = options[:include_extras] ? options[:include_extras].symbolize_array : []
+      
       options[:except] ||= []
+      
       ret = self.attributes.inject({}) do |accum, (key,val)|
         # If this is an association and it's in include_associations then include it
         if options[:include_extras].include?(key.to_sym)
@@ -614,7 +610,13 @@ module ApiResource
         end
       end
       options[:include_associations].each do |assoc|
-        ret[assoc] = self.send(assoc).serializable_hash({:include_id => true, :include_nil_attributes => include_nil_attributes, :action => action}) if self.association?(assoc)
+        if self.association?(assoc)
+          ret[assoc] = self.send(assoc).serializable_hash({
+            :include_id => true, 
+            :include_nil_attributes => include_nil_attributes, 
+            :action => action
+          })
+        end
       end
       # include id - this is for nested updates
       ret[:id] = self.id if options[:include_id] && !self.new?
@@ -627,7 +629,13 @@ module ApiResource
     end
     
     def load_attributes_from_response(response)
-      load(response)
+      if response.present?
+        @attributes_cache = {}
+        @attributes = @attributes.merge(
+          response.with_indifferent_access
+        )
+      end
+      response
     end
     
     def element_path(id, prefix_override_options = {}, query_options = nil)

data/lib/api_resource/local.rb

@@ -5,7 +5,7 @@ module ApiResource
       true
     end
     # shouldn't do anything here either - 
-    def self.reload_class_attributes
+    def self.reload_resource_definition
       true
     end
   end

data/lib/api_resource/model_errors.rb

@@ -4,11 +4,16 @@ module ApiResource
     
     def from_array(messages, save_cache = false)
       clear unless save_cache
-      humanized_attributes = @base.attributes.keys.inject({}) { |h, attr_name| h.update(attr_name.humanize => attr_name) }
+      humanized_attributes = @base.attributes.keys.inject({}){|h, attr_name| 
+        h.update(attr_name.to_s.humanize => attr_name) 
+      }
       messages.each do |message|
         attr_message = humanized_attributes.keys.detect do |attr_name|
           if message[0,attr_name.size + 1] == "#{attr_name} "
-            add humanized_attributes[attr_name], message[(attr_name.size + 1)..-1]
+            self.add(
+              humanized_attributes[attr_name], 
+              message[(attr_name.size + 1)..-1]
+            )
           end
         end
       end
@@ -18,7 +23,7 @@ module ApiResource
       clear unless save_cache
       messages.each do |attr, message_array|
         message_array.each do |message|
-          add attr, message
+          self.add(attr, message)
         end
       end
     end
@@ -61,10 +66,8 @@ module ApiResource
       elsif error_data.is_a?(Array)
         self.errors.from_array(error_data)
       else
-        raise Exception.new
+        raise "Invalid response for invalid object: expected an array or hash got #{remote_errors}"
       end
-    rescue Exception
-      raise "Invalid response for invalid object: expected an array or hash got #{remote_errors}"
     end
     
     # This method runs any local validations but not remote ones

data/lib/api_resource/scopes.rb

@@ -1,35 +1,72 @@
 module ApiResource
   module Scopes
+
     extend ActiveSupport::Concern
     
-    
     module ClassMethods
       def scopes
         return self.related_objects[:scopes]
       end
       
-      # Called by base.rb
-      # @param name is the name of the scope from the json
-      # @param hsh is always a hash with the arguments for the scope
-      def scope(name, hsh)
-        raise ArgumentError, "Expecting an attributes hash given #{hsh.inspect}" unless hsh.is_a?(Hash)
-        self.related_objects[:scopes][name.to_sym] = hsh
-        # we also need to define a class method for each scope
-        self.instance_eval <<-EOE, __FILE__, __LINE__ + 1
-          def #{name}(*args)
-            return #{ApiResource::Associations::ResourceScope.class_factory(hsh)}.new(self, :#{name}, *args)
-          end
-        EOE
-      end
-      
       def scope?(name)
-        self.related_objects[:scopes][name.to_sym].present?
+        self.related_objects[:scopes].has_key?(name.to_sym)
       end
       
       def scope_attributes(name)
         raise "No such scope #{name}" unless self.scope?(name)
         self.related_objects[:scopes][name.to_sym]
       end
+
+      # Called by base.rb
+      # @param scope_name is the scope_name of the scope from the json
+      # e.g. paged
+      #
+      # @param scope_definition is always a hash with the arguments for the scope
+      # e.g. {:page => "req", "per_page" => "opt"}
+      def scope(scope_name, scope_definition)
+
+        unless scope_definition.is_a?(Hash)
+          raise ArgumentError, "Expecting an attributes hash given #{scope_definition.inspect}" 
+        end
+        
+        self.related_objects[:scopes][scope_name.to_sym] = scope_definition
+
+        self.class_eval do
+
+          define_singleton_method(scope_name) do |*args|
+          
+            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
+
+            ApiResource::Associations::ResourceScope.new(
+              self, finder_opts
+            )
+          end
+        end
+      end
     end
     
     def scopes

data/lib/api_resource.rb

@@ -72,7 +72,9 @@ module ApiResource
   def self.cache(reset = false)
     @cache = nil if reset
     @cache ||= begin
-      defined?(Rails) ? Rails.cache : ActiveSupport::Cache::MemoryStore.new
+        defined?(Rails) ? Rails.cache : ActiveSupport::Cache::MemoryStore.new
+      rescue 
+        ActiveSupport::Cache::MemoryStore.new
     end
   end
   

data/spec/lib/api_resource_spec.rb

@@ -4,13 +4,9 @@ describe ApiResource do
 
   context ".cache" do
 
-    around(:each) do |example|
-      begin
-        old_rails = Object.send(:remove_const, :Rails)
-        example.run
-      ensure
-        Rails = old_rails
-        ApiResource
+    after(:each) do
+      if defined?(Rails)
+        Object.send(:remove_const, :Rails)
       end
     end
 

data/spec/lib/associations/association_scope_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ApiResource::Associations::AssociationScope do
+
+  context "#remote_path" do
+
+    it "should provide access to its remote path when 
+      instantiated through a parent" do
+
+      test_resource = TestResource.find(1)
+      test_resource.has_many_service_uri.remote_path.should eql(
+        "/test_resource/1/has_many"
+      )
+
+    end
+
+  end
+
+end