her 0.6.3 → 0.6.4

data/lib/her/model/associations/has_one_association.rb

@@ -3,32 +3,29 @@ module Her
     module Associations
       class HasOneAssociation < Association
         # @private
-        def self.attach(klass, name, attrs)
-          attrs = {
+        def self.attach(klass, name, opts)
+          opts = {
             :class_name => name.to_s.classify,
             :name => name,
             :data_key => name,
+            :default => nil,
             :path => "/#{name}"
-          }.merge(attrs)
-          klass.associations[:has_one] << attrs
+          }.merge(opts)
+          klass.associations[:has_one] << opts
 
           klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}
               cached_name = :"@_her_association_#{name}"
 
               cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
-              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasOneAssociation.new(self, #{attrs.inspect}))
+              cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasOneAssociation.new(self, #{opts.inspect}))
             end
           RUBY
         end
 
         # @private
-        def self.parse(association, klass, data)
-          data_key = association[:data_key]
-          return {} unless data[data_key]
-
-          klass = klass.her_nearby_class(association[:class_name])
-          { association[:name] => klass.new(data[data_key]) }
+        def self.parse(*args)
+          parse_single(*args)
         end
 
         # Initialize a new object with a foreign key to the parent
@@ -71,30 +68,9 @@ module Her
           resource
         end
 
-        # @private
-        def fetch
-          return nil if @parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @query_attrs.empty?
-
-          if @parent.attributes[@name].blank? || @query_attrs.any?
-            path = begin
-              @parent.request_path(@query_attrs)
-            rescue Her::Errors::PathError
-              return nil
-            end
-
-            @klass.get_resource("#{path}#{@opts[:path]}", @query_attrs)
-          else
-            @parent.attributes[@name]
-          end
-        end
-
         # @private
         def assign_nested_attributes(attributes)
-          if @parent.attributes[@name].blank?
-            @parent.attributes[@name] = @klass.new(@klass.parse(attributes))
-          else
-            @parent.attributes[@name].assign_attributes(attributes)
-          end
+          assign_single_nested_attributes(attributes)
         end
       end
     end

data/lib/her/model/attributes.rb

@@ -3,7 +3,6 @@ module Her
     # This module handles all methods related to model attributes
     module Attributes
       extend ActiveSupport::Concern
-      attr_accessor :attributes
 
       # Initialize a new object with data
       #
@@ -63,7 +62,7 @@ module Her
       #
       # @private
       def method_missing(method, *args, &blk)
-        if method.to_s =~ /[?=]$/ || attributes.include?(method)
+        if method.to_s =~ /[?=]$/ || @attributes.include?(method)
           # Extract the attribute
           attribute = method.to_s.sub(/[?=]$/, '')
 
@@ -97,41 +96,48 @@ module Her
       #   user = User.find(1) # => #<User id=1 name="Tobias">
       #   user.assign_attributes(name: "Lindsay")
       #   user.changes # => { :name => ["Tobias", "Lindsay"] }
-      def assign_attributes(raw_data)
-        @attributes ||= {}
-        # Use setter methods first, then translate attributes of associations
-        # into association instances, then merge the parsed_data into @attributes.
-        unset_attributes = Her::Model::Attributes.use_setter_methods(self, raw_data)
+      def assign_attributes(new_attributes)
+        @attributes ||= attributes
+        # Use setter methods first
+        unset_attributes = Her::Model::Attributes.use_setter_methods(self, new_attributes)
+
+        # Then translate attributes of associations into association instances
         parsed_attributes = self.class.parse_associations(unset_attributes)
-        attributes.update(parsed_attributes)
+
+        # Then merge the parsed_data into @attributes.
+        @attributes.merge!(parsed_attributes)
+      end
+      alias attributes= assign_attributes
+
+      def attributes
+        @attributes ||= HashWithIndifferentAccess.new
       end
 
       # Handles returning true for the accessible attributes
       #
       # @private
       def has_attribute?(attribute_name)
-        attributes.include?(attribute_name)
+        @attributes.include?(attribute_name)
       end
 
       # Handles returning data for a specific attribute
       #
       # @private
       def get_attribute(attribute_name)
-        attributes[attribute_name]
+        @attributes[attribute_name]
       end
+      alias attribute get_attribute
 
-      # Override the method to prevent from returning the object ID
-      #
-      # @private
+      # Return the value of the model `primary_key` attribute
       def id
-        attributes[self.class.primary_key]
+        @attributes[self.class.primary_key]
       end
 
       # Return `true` if the other object is also a Her::Model and has matching data
       #
       # @private
       def ==(other)
-        other.is_a?(Her::Model) && attributes == other.attributes
+        other.is_a?(Her::Model) && @attributes == other.attributes
       end
 
       # Delegate to the == method
@@ -145,13 +151,14 @@ module Her
       #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
       # @private
       def hash
-        attributes.hash
+        @attributes.hash
       end
 
       module ClassMethods
         # Initialize a collection of resources with raw data from an HTTP request
         #
         # @param [Array] parsed_data
+        # @private
         def new_collection(parsed_data)
           Her::Model::Attributes.initialize_collection(self, parsed_data)
         end
@@ -159,7 +166,6 @@ module Her
         # Define the attributes that will be used to track dirty attributes and validations
         #
         # @param [Array] attributes
-        #
         # @example
         #   class User
         #     include Her::Model
@@ -172,17 +178,17 @@ module Her
             attribute = attribute.to_sym
 
             class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{attribute}
-                @attributes.include?(:'#{attribute}') ? @attributes[:'#{attribute}'] : nil
+              unless instance_methods.include?(:'#{attribute}=')
+                def #{attribute}=(value)
+                  self.send(:"#{attribute}_will_change!") if @attributes[:'#{attribute}'] != value
+                  @attributes[:'#{attribute}'] = value
+                end
               end
 
-              def #{attribute}=(value)
-                self.send(:"#{attribute}_will_change!") if @attributes[:'#{attribute}'] != value
-                @attributes[:'#{attribute}'] = value
-              end
-
-              def #{attribute}?
-                @attributes.include?(:'#{attribute}') && @attributes[:'#{attribute}'].present?
+              unless instance_methods.include?(:'#{attribute}?')
+                def #{attribute}?
+                  @attributes.include?(:'#{attribute}') && @attributes[:'#{attribute}'].present?
+                end
               end
             RUBY
           end
@@ -198,22 +204,7 @@ module Her
         #     store_response_errors :server_errors
         #   end
         def store_response_errors(value = nil)
-          if @_her_store_response_errors
-            remove_method @_her_store_response_errors
-            remove_method :"#{@_her_store_response_errors}="
-          end
-
-          @_her_store_response_errors ||= begin
-            superclass.store_response_errors if superclass.respond_to?(:store_response_errors)
-          end
-
-          return @_her_store_response_errors unless value
-          @_her_store_response_errors = value
-
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{@_her_store_response_errors}; @response_errors; end
-            def #{@_her_store_response_errors}=(value); @response_errors = value; end
-          RUBY
+          store_her_data(:response_errors, value)
         end
 
         # Define the accessor in which the API response metadata (obtained from the parsing middleware) will be stored
@@ -226,22 +217,7 @@ module Her
         #     store_metadata :server_data
         #   end
         def store_metadata(value = nil)
-          if @_her_store_metadata
-            remove_method @_her_store_metadata
-            remove_method :"#{@_her_store_metadata}="
-          end
-
-          @_her_store_metadata ||= begin
-            superclass.store_metadata if superclass.respond_to?(:store_metadata)
-          end
-
-          return @_her_store_metadata unless value
-          @_her_store_metadata = value
-
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{@_her_store_metadata}; @metadata; end
-            def #{@_her_store_metadata}=(value); @metadata = value; end
-          RUBY
+          store_her_data(:metadata, value)
         end
 
         # @private
@@ -251,6 +227,27 @@ module Her
             memo
           end
         end
+
+        private
+        # @private
+        def store_her_data(name, value)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            if @_her_store_#{name} && value.present?
+              remove_method @_her_store_#{name}
+              remove_method @_her_store_#{name}.to_s + '='
+            end
+
+            @_her_store_#{name} ||= begin
+              superclass.store_#{name} if superclass.respond_to?(:store_#{name})
+            end
+
+            return @_her_store_#{name} unless value
+            @_her_store_#{name} = value
+
+            define_method(value) { @#{name} }
+            define_method(value.to_s+'=') { |value| @#{name} = value }
+          RUBY
+        end
       end
     end
   end

data/lib/her/model/http.rb

@@ -5,6 +5,22 @@ module Her
       extend ActiveSupport::Concern
       METHODS = [:get, :post, :put, :patch, :delete]
 
+      # For each HTTP method, define these class methods:
+      #
+      # - <method>(path, params)
+      # - <method>_raw(path, params, &block)
+      # - <method>_collection(path, params, &block)
+      # - <method>_resource(path, params, &block)
+      # - custom_<method>(*paths)
+      #
+      # @example
+      #   class User
+      #     include Her::Model
+      #     custom_get :active
+      #   end
+      #
+      #   User.get(:popular) # GET "/users/popular"
+      #   User.active # GET "/users/active"
       module ClassMethods
         # Change which API the model will use to make its HTTP requests
         #
@@ -32,8 +48,8 @@ module Her
         # Main request wrapper around Her::API. Used to make custom request to the API.
         #
         # @private
-        def request(attrs={})
-          request = her_api.request(attrs)
+        def request(params={})
+          request = her_api.request(params)
 
           if block_given?
             yield request[:parsed_data], request[:response]
@@ -42,18 +58,11 @@ module Her
           end
         end
 
-        # For each HTTP method, define these methods:
-        #
-        # - <method>(path, attrs)
-        # - <method>_raw(path, attrs, &block)
-        # - <method>_collection(path, attrs, &block)
-        # - <method>_resource(path, attrs, &block)
-        # - custom_<method>(path, attrs)
         METHODS.each do |method|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(path, attrs={})
-              path = build_request_path_from_string_or_symbol(path, attrs)
-              send(:'#{method}_raw', path, attrs) do |parsed_data, response|
+            def #{method}(path, params={})
+              path = build_request_path_from_string_or_symbol(path, params)
+              send(:'#{method}_raw', path, params) do |parsed_data, response|
                 if parsed_data[:data].is_a?(Array)
                   new_collection(parsed_data)
                 else
@@ -62,21 +71,21 @@ module Her
               end
             end
 
-            def #{method}_raw(path, attrs={}, &block)
-              path = build_request_path_from_string_or_symbol(path, attrs)
-              request(attrs.merge(:_method => #{method.to_sym.inspect}, :_path => path), &block)
+            def #{method}_raw(path, params={}, &block)
+              path = build_request_path_from_string_or_symbol(path, params)
+              request(params.merge(:_method => #{method.to_sym.inspect}, :_path => path), &block)
             end
 
-            def #{method}_collection(path, attrs={})
-              path = build_request_path_from_string_or_symbol(path, attrs)
-              send(:'#{method}_raw', build_request_path_from_string_or_symbol(path, attrs), attrs) do |parsed_data, response|
+            def #{method}_collection(path, params={})
+              path = build_request_path_from_string_or_symbol(path, params)
+              send(:'#{method}_raw', build_request_path_from_string_or_symbol(path, params), params) do |parsed_data, response|
                 new_collection(parsed_data)
               end
             end
 
-            def #{method}_resource(path, attrs={})
-              path = build_request_path_from_string_or_symbol(path, attrs)
-              send(:"#{method}_raw", path, attrs) do |parsed_data, response|
+            def #{method}_resource(path, params={})
+              path = build_request_path_from_string_or_symbol(path, params)
+              send(:"#{method}_raw", path, params) do |parsed_data, response|
                 new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
               end
             end
@@ -86,9 +95,9 @@ module Her
               opts = paths.last.is_a?(Hash) ? paths.pop : Hash.new
 
               paths.each do |path|
-                metaclass.send(:define_method, path) do |*attrs|
-                  attrs = attrs.first || Hash.new
-                  send(#{method.to_sym.inspect}, path, attrs)
+                metaclass.send(:define_method, path) do |*params|
+                  params = params.first || Hash.new
+                  send(#{method.to_sym.inspect}, path, params)
                 end
               end
             end

data/lib/her/model/introspection.rb

@@ -32,6 +32,7 @@ module Her
         end
       end
 
+      # @private
       module ClassMethods
         # Finds a class at the same level as this one or at the global level.
         #

data/lib/her/model/orm.rb

@@ -154,8 +154,8 @@ module Her
         # Delegate the following methods to `scoped`
         [:all, :where, :create, :build, :first_or_create, :first_or_initialize].each do |method|
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{method}(*attrs)
-              scoped.send(#{method.to_sym.inspect}, *attrs)
+            def #{method}(*params)
+              scoped.send(#{method.to_sym.inspect}, *params)
             end
           RUBY
         end

data/lib/her/model/parse.rb

@@ -10,13 +10,14 @@ module Her
       #   @user.to_params
       #   # => { :id => 1, :name => 'John Smith' }
       def to_params
-        self.class.include_root_in_json? ? { self.class.included_root_element => attributes.dup } : attributes.dup
+        self.class.include_root_in_json? ? { self.class.included_root_element => attributes.dup.symbolize_keys } : attributes.dup.symbolize_keys
       end
 
       module ClassMethods
         # Parse data before assigning it to a resource, based on `parse_root_in_json`.
         #
         # @param [Hash] data
+        # @private
         def parse(data)
           parse_root_in_json? ? data[parsed_root_element] : data
         end

data/lib/her/model/paths.rb

@@ -87,16 +87,12 @@ module Her
 
         # Return a custom path based on the collection path and variable parameters
         #
-        # @example
-        #   class User
-        #     include Her::Model
-        #     collection_path "/utilisateurs"
-        #   end
-        #
-        #   User.all # Fetched via GET /utilisateurs
+        # @private
         def build_request_path(path=nil, parameters={})
+          parameters = parameters.try(:with_indifferent_access)
+
           unless path.is_a?(String)
-            parameters = path || {}
+            parameters = path.try(:with_indifferent_access) || parameters
             path =
               if parameters.include?(primary_key) && parameters[primary_key]
                 resource_path.dup
@@ -111,13 +107,13 @@ module Her
           path.gsub(/:([\w_]+)/) do
             # Look for :key or :_key, otherwise raise an exception
             value = $1.to_sym
-            parameters.delete(value) || parameters.delete(:"_#{value}") || raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path. Path is `#{path}`. Parameters are `#{parameters.inspect}`.", $1))
+            parameters.delete(value) || parameters.delete(:"_#{value}") || raise(Her::Errors::PathError.new("Missing :_#{$1} parameter to build the request path. Path is `#{path}`. Parameters are `#{parameters.symbolize_keys.inspect}`.", $1))
           end
         end
 
         # @private
-        def build_request_path_from_string_or_symbol(path, attrs={})
-          path.is_a?(Symbol) ? "#{build_request_path(attrs)}/#{path}" : path
+        def build_request_path_from_string_or_symbol(path, params={})
+          path.is_a?(Symbol) ? "#{build_request_path(params)}/#{path}" : path
         end
       end
     end