api_resource 0.2.11 → 0.3.0

data/lib/api_resource/associations/scope.rb

@@ -56,7 +56,8 @@ module ApiResource
       
       # gets the current hash and calls to_query on it
       def to_query
-        self.to_hash.to_query
+        #We need to add the unescape because to_query breaks on nested arrays
+        CGI.unescape(self.to_hash.to_query)
       end
 
       def method_missing(method, *args, &block)

data/lib/api_resource/attributes.rb

@@ -10,10 +10,10 @@ module ApiResource
       
       alias_method_chain :save, :dirty_tracking
       
-      class_inheritable_accessor :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]
-      
+
       attr_reader :attributes
       
       self.attribute_names = []
@@ -41,24 +41,23 @@ module ApiResource
             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.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}
-              self.attributes[:#{arg}]
+              attributes[:#{arg}]
             end
           
             def #{arg}=(val)
               real_val = typecast_attribute(:#{arg}, val)
               #{arg}_will_change! unless self.#{arg} == real_val
-              self.attributes[:#{arg}] = real_val
+              attributes[:#{arg}] = real_val
             end
             
             def #{arg}?
-              self.attributes[:#{arg}].present?
+              attributes[:#{arg}].present?
             end
           EOE
         end
@@ -74,8 +73,8 @@ module ApiResource
             arg = arg.first
           end
 
-          self.attribute_names << arg.to_sym
-          self.protected_attribute_names << arg.to_sym
+          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
@@ -118,79 +117,76 @@ module ApiResource
       end
     end
     
-    module InstanceMethods
-      
-      # set new attributes
-      def attributes=(new_attrs)
-        new_attrs.each_pair do |k,v|
-          self.send("#{k}=",v) unless k.to_sym == :id
-        end
-        new_attrs
+    # set new attributes
+    def attributes=(new_attrs)
+      new_attrs.each_pair do |k,v|
+        self.send("#{k}=",v) unless k.to_sym == :id
       end
-      
-      def save_with_dirty_tracking(*args)
-        if save_without_dirty_tracking(*args)
-          @previously_changed = self.changes
-          @changed_attributes.clear
-          return true
-        else
-          return false
-        end
-      end
-      
-      def set_attributes_as_current(*attrs)
-        @changed_attributes.clear and return if attrs.blank?
-        attrs.each do |attr|
-          @changed_attributes.delete(attr.to_s)
-        end
+      new_attrs
+    end
+    
+    def save_with_dirty_tracking(*args)
+      if save_without_dirty_tracking(*args)
+        @previously_changed = self.changes
+        @changed_attributes.clear
+        return true
+      else
+        return false
       end
-      
-      def reset_attribute_changes(*attrs)
-        attrs = self.class.public_attribute_names if attrs.blank?
-        attrs.each do |attr|
-          self.send("reset_#{attr}!")
-        end
-        
-        set_attributes_as_current(*attrs)
+    end
+    
+    def set_attributes_as_current(*attrs)
+      @changed_attributes.clear and return if attrs.blank?
+      attrs.each do |attr|
+        @changed_attributes.delete(attr.to_s)
       end
-      
-      def attribute?(name)
-        self.class.attribute?(name)
+    end
+    
+    def reset_attribute_changes(*attrs)
+      attrs = self.class.public_attribute_names if attrs.blank?
+      attrs.each do |attr|
+        self.send("reset_#{attr}!")
       end
       
-      def protected_attribute?(name)
-        self.class.protected_attribute?(name)
+      set_attributes_as_current(*attrs)
+    end
+    
+    def attribute?(name)
+      self.class.attribute?(name)
+    end
+    
+    def protected_attribute?(name)
+      self.class.protected_attribute?(name)
+    end
+    
+    def respond_to?(sym, include_private_methods = false)
+      if sym =~ /\?$/
+        return true if self.attribute?($`)
+      elsif sym =~ /=$/
+        return true if self.class.public_attribute_names.include?($`)
+      else
+        return true if self.attribute?(sym.to_sym)
       end
-      
-      def respond_to?(sym)
-        if sym =~ /\?$/
-          return true if self.attribute?($`)
-        elsif sym =~ /=$/
-          return true if self.class.public_attribute_names.include?($`)
+      super
+    end
+    
+    protected
+    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
         else
-          return true if self.attribute?(sym.to_sym)
-        end
-        super
-      end
-      
-      protected
-      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
-          else
-            # catches the nil case and just leaves it alone
-            return val.dup rescue val
-        end
+          # catches the nil case and just leaves it alone
+          return val.dup rescue val
       end
     end
     

data/lib/api_resource/base.rb

@@ -7,13 +7,24 @@ module ApiResource
   
   class Base
     
-    class_inheritable_accessor :site, :proxy, :user, :password, :auth_type, :format, :timeout, :open_timeout, :ssl_options, :token
+    class_attribute :site, :proxy, :user, :password, :auth_type, :format, 
+      :timeout, :open_timeout, :ssl_options, :token, :ttl
     
-    class_inheritable_accessor :include_root_in_json; self.include_root_in_json = true
-    class_inheritable_accessor :include_blank_attributes_on_create; self.include_blank_attributes_on_create = false
-    class_inheritable_accessor :include_all_attributes_on_update; self.include_all_attributes_on_update = false
+
+    class_attribute :include_root_in_json
+    self.include_root_in_json = true
+    
+    class_attribute :include_blank_attributes_on_create
+    self.include_blank_attributes_on_create = false
+    
+    class_attribute :include_all_attributes_on_update
+    self.include_blank_attributes_on_create = false
+
+    class_attribute :format
+    self.format = ApiResource::Formats::JsonFormat
     
-    class_inheritable_accessor :primary_key; self.primary_key = "id"
+    class_attribute :primary_key
+    self.primary_key = "id"
     
     attr_accessor :prefix_options
     
@@ -97,7 +108,11 @@ module ApiResource
           return e.respond_to?(:request) ? e.request : nil
         end
       end
-
+      
+      def reset_connection
+        remove_instance_variable(:@connection) if @connection.present?
+      end
+      
       def reload_class_attributes
         # clear the public_attribute_names, protected_attribute_names
         remove_instance_variable(:@class_data) if instance_variable_defined?(:@class_data)
@@ -106,24 +121,26 @@ module ApiResource
         self.set_class_attributes_upon_load
       end
       
-      def token=(new_token)
-        self.write_inheritable_attribute(:token, new_token)
+      def token_with_new_token_set=(new_token)
+        self.token_without_new_token_set = new_token
         self.descendants.each do |child|
           child.send(:token=, new_token)
         end
       end
+      
+      alias_method_chain :token=, :new_token_set
 
-      def site=(site)
+      def site_with_connection_reset=(site)
         # store so we can reload attributes if the site changed
         old_site = self.site.to_s.clone
         @connection = nil
         
         if site.nil?
-          write_inheritable_attribute(:site, nil)
+          self.site_without_connection_reset = nil
           # no site, so we'll skip the reload
           return site
         else
-          write_inheritable_attribute(:site, create_site_uri_from(site))
+          self.site_without_connection_reset = create_site_uri_from(site)
         end
         
         # reset class attributes and try to reload them if the site changed
@@ -134,38 +151,37 @@ module ApiResource
         return site
       end
       
+      alias_method_chain :site=, :connection_reset
+      
       
-      def format=(mime_type_or_format)
+      def format_with_mimetype_or_format_set=(mime_type_or_format)
         format = mime_type_or_format.is_a?(Symbol) ? ApiResource::Formats[mime_type_or_format] : mime_type_or_format
-        write_inheritable_attribute(:format, format)
+        self.format_without_mimetype_or_format_set = format
         self.connection.format = format if self.site
       end
       
-      # Default format is json
-      def format
-        read_inheritable_attribute(:format) || ApiResource::Formats::JsonFormat
-      end
+      alias_method_chain :format=, :mimetype_or_format_set
       
-      def timeout=(timeout)
+      def timeout_with_connection_reset=(timeout)
         @connection = nil
-        write_inheritable_attribute(:timeout, timeout)
+        self.timeout_without_connection_reset = timeout
       end
       
-      def open_timeout=(timeout)
+      alias_method_chain :timeout=, :connection_reset
+      
+      def open_timeout_with_connection_reset=(timeout)
         @connection = nil
-        write_inheritable_attribute(:open_timeout, timeout)
+        self.open_timeout_without_connection_reset = timeout
       end
       
+      alias_method_chain :open_timeout=, :connection_reset
+      
       def connection(refresh = false)
         @connection = Connection.new(self.site, self.format) if refresh || @connection.nil?
         @connection.timeout = self.timeout
         @connection
       end
-      
-      def reset_connection
-        remove_instance_variable(:@connection) if @connection.present?
-      end
-      
+            
       def headers
         {}.tap do |ret|
           ret['Lifebooker-Token'] = self.token if self.token.present?
@@ -469,40 +485,40 @@ module ApiResource
       return if attributes.nil?
       raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
       @prefix_options, attributes = split_options(attributes)
-     
       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)
-              SingleObjectProxy.new(self.association_class_name(key), value)
+          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
-          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
       end
       return self
     end

data/lib/api_resource/callbacks.rb

@@ -16,32 +16,28 @@ module ApiResource
       
     end
     
-    module InstanceMethods
-      
-      def save_with_callbacks(*args)
-        _run_save_callbacks do
-          save_without_callbacks(*args)
-        end
+    def save_with_callbacks(*args)
+      run_callbacks :save do
+        save_without_callbacks(*args)
       end
-      
-      def create_with_callbacks(*args)
-        _run_create_callbacks do
-          create_without_callbacks(*args)
-        end
+    end
+    
+    def create_with_callbacks(*args)
+      run_callbacks :create do
+        create_without_callbacks(*args)
       end
-      
-      def update_with_callbacks(*args)
-        _run_update_callbacks do
-          update_without_callbacks(*args)
-        end
+    end
+    
+    def update_with_callbacks(*args)
+      run_callbacks :update do
+        update_without_callbacks(*args)
       end
-      
-      def destroy_with_callbacks(*args)
-        _run_destroy_callbacks do
-          destroy_without_callbacks(*args)
-        end
+    end
+    
+    def destroy_with_callbacks(*args)
+      run_callbacks :destroy do
+        destroy_without_callbacks(*args)
       end
-      
     end
     
   end