her 0.5.3 → 0.5.4

data/lib/her/model/introspection.rb

@@ -30,24 +30,23 @@ module Her
       module ClassMethods
         # Finds a class at the same level as this one or at the global level.
         # @private
-        def nearby_class(name)
-          sibling_class(name) || name.constantize rescue nil
+        def her_nearby_class(name)
+          her_sibling_class(name) || name.constantize rescue nil
         end
 
         protected
         # Looks for a class at the same level as this one with the given name.
         # @private
-        def sibling_class(name)
-          if mod = self.containing_module
-            @sibling_class ||= {}
-            @sibling_class[mod] ||= {}
-            @sibling_class[mod][name] ||= "#{mod.name}::#{name}".constantize rescue nil
+        def her_sibling_class(name)
+          if mod = self.her_containing_module
+            @_her_sibling_class ||= Hash.new { Hash.new }
+            @_her_sibling_class[mod][name] ||= "#{mod.name}::#{name}".constantize rescue nil
           end
         end
 
         # If available, returns the containing Module for this class.
         # @private
-        def containing_module
+        def her_containing_module
           return unless self.name =~ /::/
           self.name.split("::")[0..-2].join("::").constantize
         end

data/lib/her/model/nested_attributes.rb

@@ -37,8 +37,8 @@ module Her
 
       def assign_nested_attributes_for_has_many_association(association_name, attributes)
         association = self.class.associations[:has_many].find { |association| association[:name] == association_name }
-        klass = self.class.nearby_class(association[:class_name])
-        self.send("#{association[:name]}=", Her::Model::ORM.initialize_collection(klass, :data => attributes))
+        klass = self.class.her_nearby_class(association[:class_name])
+        self.send("#{association[:name]}=", Her::Model::Attributes.initialize_collection(klass, :data => attributes))
       end
 
       private
@@ -47,7 +47,7 @@ module Her
         if has_data?(association[:name])
           self.send("#{association[:name]}").assign_data(attributes)
         else
-          klass = self.class.nearby_class(association[:class_name])
+          klass = self.class.her_nearby_class(association[:class_name])
           instance = klass.new(klass.parse(attributes))
           self.send("#{association[:name]}=", instance)
         end

data/lib/her/model/orm.rb

@@ -3,125 +3,20 @@ module Her
     # This module adds ORM-like capabilities to the model
     module ORM
       extend ActiveSupport::Concern
-      attr_accessor :attributes, :metadata, :response_errors
-      alias :data :attributes
-      alias :data= :attributes=
-
-      # Initialize a new object with data received from an HTTP request
-      def initialize(attributes={})
-        attributes ||= {}
-        @metadata = attributes.delete(:_metadata) || {}
-        @response_errors = attributes.delete(:_errors) || {}
-        @destroyed = attributes.delete(:_destroyed) || false
-
-        update_attributes(attributes)
-      end
-
-      # Initialize a collection of resources
-      # @private
-      def self.initialize_collection(klass, parsed_data={})
-        collection_data = parsed_data[:data].map do |item_data|
-          resource = klass.new(klass.parse(item_data))
-          resource.run_callbacks :find
-          resource
-        end
-        Her::Collection.new(collection_data, parsed_data[:metadata], parsed_data[:errors])
-      end
-
-      # Use setter methods of model for each key / value pair in params
-      # Return key / value pairs for which no setter method was defined on the model
-      # @private
-      def self.use_setter_methods(model, params)
-        setter_method_names = model.class.setter_method_names
-        params ||= {}
-        params.inject({}) do |memo, (key, value)|
-          setter_method = key.to_s + '='
-          if setter_method_names.include?(setter_method)
-            model.send(setter_method, value)
-          else
-            if key.is_a?(String)
-              key = key.to_sym
-            end
-            memo[key] = value
-          end
-          memo
-        end
-      end
-
-      # Handles missing methods
-      # @private
-      def method_missing(method, *args, &blk)
-        if method.to_s =~ /[?=]$/ || attributes.include?(method)
-          # Extract the attribute
-          attribute = method.to_s.sub(/[?=]$/, '')
-
-          # Create a new `attribute` methods set
-          self.class.attributes(*attribute)
-
-          # Resend the method!
-          send(method, *args, &blk)
-        else
-          super
-        end
-      end
-
-      # Handles returning true for the cases handled by method_missing
-      def respond_to?(method, include_private = false)
-        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @attributes.include?(method) || super
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @attributes.include?(method) || @attributes.include?(method) || super
-      end
-
-      # Assign new data to an instance
-      def assign_attributes(new_attributes)
-        new_attributes = Her::Model::ORM.use_setter_methods(self, new_attributes)
-        attributes.update new_attributes
-      end
-      alias :assign_data :assign_attributes
-
-      # Handles returning true for the accessible attributes
-      def has_attribute?(attribute_name)
-        attributes.include?(attribute_name)
-      end
-      alias :has_data? :has_attribute?
-
-      def get_attribute(attribute_name)
-        attributes[attribute_name]
-      end
-      alias :get_data :get_attribute
-
-      # Override the method to prevent from returning the object ID (in ruby-1.8.7)
-      # @private
-      def id
-        attributes[:id] || super
-      end
 
       # Return `true` if a resource was not saved yet
       def new?
-        !attributes.include?(:id)
+        attributes[self.class.primary_key].nil?
       end
 
-      # Return `true` if the other object is also a Her::Model and has matching data
-      def ==(other)
-        other.is_a?(Her::Model) && attributes == other.attributes
-      end
-
-      # Delegate to the == method
-      def eql?(other)
-        self == other
-      end
-
-      # Delegate to @attributes, allowing models to act correctly in code like:
-      #     [ Model.find(1), Model.find(1) ].uniq # => [ Model.find(1) ]
-      def hash
-        attributes.hash
+      # Return `true` if a resource is not `#new?`
+      def persisted?
+        !new?
       end
 
       # Return whether the object has been destroyed
       def destroyed?
-        @destroyed
+        @destroyed == true
       end
 
       # Save a resource
@@ -141,18 +36,18 @@ module Her
         params = to_params
         resource = self
 
-        if attributes[:id]
-          callback = :update
-          method = :put
-        else
+        if new?
           callback = :create
           method = :post
+        else
+          callback = :update
+          method = :put
         end
 
         run_callbacks callback do
           run_callbacks :save do
             self.class.request(params.merge(:_method => method, :_path => "#{request_path}")) do |parsed_data, response|
-              update_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
+              assign_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
               self.metadata = parsed_data[:metadata]
               self.response_errors = parsed_data[:errors]
               self.changed_attributes.clear if self.changed_attributes.present?
@@ -175,7 +70,7 @@ module Her
         resource = self
         run_callbacks :destroy do
           self.class.request(:_method => :delete, :_path => "#{request_path}") do |parsed_data, response|
-            update_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
+            assign_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
             self.metadata = parsed_data[:metadata]
             self.response_errors = parsed_data[:errors]
             @destroyed = true
@@ -184,72 +79,7 @@ module Her
         self
       end
 
-      # @private
-      def update_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::ORM.use_setter_methods(self, raw_data)
-        parsed_attributes = self.class.parse_associations(unset_attributes)
-        attributes.update(parsed_attributes)
-      end
-
-      # Convert into a hash of request parameters
-      #
-      # @example
-      #   @user.to_params
-      #   # => { :id => 1, :name => 'John Smith' }
-      def to_params
-        if self.class.include_root_in_json
-          { (self.class.include_root_in_json == true ? self.class.root_element : self.class.include_root_in_json) => attributes.dup }
-        else
-          attributes.dup
-        end
-      end
-
       module ClassMethods
-        # Initialize a collection of resources with raw data from an HTTP request
-        #
-        # @param [Array] parsed_data
-        def new_collection(parsed_data)
-          Her::Model::ORM.initialize_collection(self, parsed_data)
-        end
-
-        # Define the attributes that will be used to track dirty attributes and validations
-        #
-        # @param [Array] attributes
-        def attributes(*attributes)
-          define_attribute_methods attributes
-
-          attributes.each do |attribute|
-            attribute = attribute.to_sym
-
-            define_method "#{attribute}".to_sym do
-              @attributes.include?(attribute) ? @attributes[attribute] : nil
-            end
-
-            define_method "#{attribute}=".to_sym do |value|
-              self.send("#{attribute}_will_change!".to_sym) if @attributes[attribute] != value
-              @attributes[attribute] = value
-            end
-
-            define_method "#{attribute}?".to_sym do
-              @attributes.include?(attribute) && @attributes[attribute].present?
-            end
-          end
-        end
-
-        # Parse data before assigning it to a resource
-        #
-        # @param [Hash] data
-        def parse(data)
-          if parse_root_in_json
-            parse_root_in_json == true ? data[root_element.to_sym] : data[parse_root_in_json]
-          else
-            data
-          end
-        end
-
         # Fetch specific resource(s) by their ID
         #
         # @example
@@ -263,7 +93,7 @@ module Her
           params = ids.last.is_a?(Hash) ? ids.pop : {}
           results = ids.flatten.compact.uniq.map do |id|
             resource = nil
-            request(params.merge(:_method => :get, :_path => "#{build_request_path(params.merge(:id => id))}")) do |parsed_data, response|
+            request(params.merge(:_method => :get, :_path => "#{build_request_path(params.merge(primary_key => id))}")) do |parsed_data, response|
               if response.success?
                 resource = new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
                 resource.run_callbacks :find
@@ -304,7 +134,7 @@ module Her
               request(params.merge(:_method => :post, :_path => "#{build_request_path(params)}")) do |parsed_data, response|
                 data = parse(parsed_data[:data])
                 resource.instance_eval do
-                  update_attributes(data)
+                  assign_attributes(data)
                   @metadata = parsed_data[:metadata]
                   @response_errors = parsed_data[:errors]
                   @changed_attributes.clear if @changed_attributes.present?
@@ -321,7 +151,7 @@ module Her
         #   @user = User.save_existing(1, { :fullname => "Tobias Fünke" })
         #   # Called via PUT "/users/1"
         def save_existing(id, params)
-          resource = new(params.merge(:id => id))
+          resource = new(params.merge(primary_key => id))
           resource.save
           resource
         end
@@ -332,30 +162,10 @@ module Her
         #   User.destroy_existing(1)
         #   # Called via DELETE "/users/1"
         def destroy_existing(id, params={})
-          request(params.merge(:_method => :delete, :_path => "#{build_request_path(params.merge(:id => id))}")) do |parsed_data, response|
+          request(params.merge(:_method => :delete, :_path => "#{build_request_path(params.merge(primary_key => id))}")) do |parsed_data, response|
             new(parse(parsed_data[:data]).merge(:_destroyed => true))
           end
         end
-
-        # @private
-        def setter_method_names
-          @setter_method_names ||= instance_methods.inject(Set.new) do |memo, method_name|
-            memo << method_name.to_s if method_name.to_s.end_with?('=')
-            memo
-          end
-        end
-
-        # Return or change the value of `include_root_in_json`
-        def include_root_in_json(value=nil)
-          return @include_root_in_json if value.nil?
-          @include_root_in_json = value
-        end
-
-        # Return or change the value of `parse_root_in`
-        def parse_root_in_json(value=nil)
-          return @parse_root_in_json if value.nil?
-          @parse_root_in_json = value
-        end
       end
     end
   end

data/lib/her/model/parse.rb

@@ -0,0 +1,86 @@
+module Her
+  module Model
+    # This module handles resource data parsing at the model level (after the parsing middleware)
+    module Parse
+      extend ActiveSupport::Concern
+
+      # Convert into a hash of request parameters, based on `include_root_in_json`.
+      #
+      # @example
+      #   @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
+      end
+
+      module ClassMethods
+        # Parse data before assigning it to a resource, based on `parse_root_in_json`.
+        #
+        # @param [Hash] data
+        def parse(data)
+          parse_root_in_json? ? data[parsed_root_element] : data
+        end
+
+        # Return or change the value of `include_root_in_json`
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     include_root_in_json true
+        #   end
+        def include_root_in_json(value=nil)
+          return @include_root_in_json if value.nil?
+          @include_root_in_json = value
+        end
+
+        # Return or change the value of `parse_root_in`
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     parse_root_in_json true
+        #   end
+        def parse_root_in_json(value=nil)
+          return @parse_root_in_json if value.nil?
+          @parse_root_in_json = value
+        end
+
+        # Return or change the value of `root_element`
+        #
+        # @example
+        #   class User
+        #     include Her::Model
+        #     parse_root_in_json true
+        #     root_element :huh
+        #   end
+        #
+        #   user = User.find(1) # { :huh => { :id => 1, :name => "Tobias" } }
+        #   user.name # => "Tobias"
+        def root_element(value=nil)
+          return @root_element if value.nil?
+          @root_element = value
+        end
+
+        # @private
+        def parse_root_in_json?
+          @parse_root_in_json
+        end
+
+        # @private
+        def include_root_in_json?
+          @include_root_in_json
+        end
+
+        # @private
+        def included_root_element
+          include_root_in_json == true ? root_element.to_sym : include_root_in_json
+        end
+
+        # @private
+        def parsed_root_element
+          parse_root_in_json == true ? root_element.to_sym : parse_root_in_json
+        end
+      end
+    end
+  end
+end

data/lib/her/model/paths.rb

@@ -11,12 +11,29 @@ module Her
       #   end
       #
       #   User.find(1) # Fetched via GET /utilisateurs/1
-      def request_path
-        self.class.build_request_path(attributes.dup)
+      #
+      # @param [Hash] params An optional set of additional parameters for
+      #   path construction. These will not override attributes of the resource.
+      def request_path(params = {})
+        self.class.build_request_path(params.merge(attributes.dup))
       end
 
       module ClassMethods
 
+        # Define the primary key field that will be used to find and save records
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    primary_key 'UserId'
+        #  end
+        #
+        # @param [Symbol] field
+        def primary_key(field = nil)
+          return @her_primary_key if field.nil?
+          @her_primary_key = field.to_sym
+        end
+
         # Defines a custom collection path for the resource
         #
         # @example
@@ -25,13 +42,13 @@ module Her
         #    collection_path "/users"
         #  end
         def collection_path(path=nil)
-          @her_collection_path ||= begin
+          @_her_collection_path ||= begin
             superclass.collection_path.dup if superclass.respond_to?(:collection_path)
           end
 
-          return @her_collection_path unless path
-          @her_resource_path = "#{path}/:id"
-          @her_collection_path = path
+          return @_her_collection_path unless path
+          @_her_resource_path = "#{path}/:id"
+          @_her_collection_path = path
         end
 
         # Defines a custom resource path for the resource
@@ -41,13 +58,29 @@ module Her
         #    include Her::Model
         #    resource_path "/users/:id"
         #  end
+        #
+        # Note that, if used in combination with resource_path, you may specify
+        # either the real primary key or the string ':id'. For example:
+        #
+        # @example
+        #  class User
+        #    include Her::Model
+        #    primary_key 'user_id'
+        #
+        #    # This works because we'll have a user_id attribute
+        #    resource_path '/users/:user_id'
+        #
+        #    # This works because we replace :id with :user_id
+        #    resource_path '/users/:id'
+        #  end
+        #
         def resource_path(path=nil)
-          @her_resource_path ||= begin
+          @_her_resource_path ||= begin
             superclass.resource_path.dup if superclass.respond_to?(:resource_path)
           end
 
-          return @her_resource_path unless path
-          @her_resource_path = path
+          return @_her_resource_path unless path
+          @_her_resource_path = path
         end
 
         # Return a custom path based on the collection path and variable parameters
@@ -62,7 +95,15 @@ module Her
         def build_request_path(path=nil, parameters={})
           unless path.is_a?(String)
             parameters = path || {}
-            path = parameters.include?(:id) && !parameters[:id].nil? ? resource_path : collection_path
+            path =
+              if parameters.include?(primary_key) && parameters[primary_key]
+                resource_path.dup
+              else
+                collection_path.dup
+              end
+
+            # Replace :id with our actual primary key
+            path.gsub!(/(\A|\/):id(\Z|\/)/, "\\1:#{primary_key}\\2")
           end
 
           path.gsub(/:([\w_]+)/) do
@@ -71,10 +112,9 @@ module Her
           end
         end
 
-        # Return or change the value of `root_element`
-        def root_element(value=nil)
-          return @root_element if value.nil?
-          @root_element = value
+        # @private
+        def build_request_path_from_string_or_symbol(path, attrs={})
+          path.is_a?(Symbol) ? "#{build_request_path(attrs)}/#{path}" : path
         end
       end
     end