her 0.5.3 → 0.5.4

data/lib/her/model/associations.rb

@@ -18,12 +18,12 @@ module Her
       alias :get_relationship :get_association
 
       module ClassMethods
-        # Return @her_associations, lazily initialized with copy of the
+        # Return @_her_associations, lazily initialized with copy of the
         # superclass' her_associations, or an empty hash.
         #
         # @private
         def associations
-          @her_associations ||= begin
+          @_her_associations ||= begin
             if superclass.respond_to?(:associations)
               superclass.associations.dup
             else
@@ -42,12 +42,12 @@ module Her
               data_key = association[:data_key]
               next unless data[data_key]
 
-              klass = self.nearby_class(association[:class_name])
+              klass = self.her_nearby_class(association[:class_name])
               name = association[:name]
 
               data[name] = case type
                 when :has_many
-                  Her::Model::ORM.initialize_collection(klass, :data => data[data_key])
+                  Her::Model::Attributes.initialize_collection(klass, :data => data[data_key])
                 when :has_one, :belongs_to
                   klass.new(data[data_key])
                 else
@@ -65,12 +65,12 @@ module Her
         #
         # @example
         #   class User
-        #     include Her::API
+        #     include Her::Model
         #     has_many :articles
         #   end
         #
         #   class Article
-        #     include Her::API
+        #     include Her::Model
         #   end
         #
         #   @user = User.find(1)
@@ -88,13 +88,13 @@ module Her
 
           define_method(name) do |*method_attrs|
             method_attrs = method_attrs[0] || {}
-            klass = self.class.nearby_class(attrs[:class_name])
+            klass = self.class.her_nearby_class(attrs[:class_name])
 
             return Her::Collection.new if @attributes.include?(name) && @attributes[name].empty? && method_attrs.empty?
 
             if @attributes[name].blank? || method_attrs.any?
               path = begin
-                self.class.build_request_path(@attributes.merge(method_attrs))
+                request_path(method_attrs)
               rescue Her::Errors::PathError
                 return nil
               end
@@ -115,16 +115,16 @@ module Her
         # Define an *has_one* association.
         #
         # @param [Symbol] name The name of the model
-        # @param [Hash] attrs Options (currently not used)
+        # @param [Hash] attrs Options
         #
         # @example
         #   class User
-        #     include Her::API
+        #     include Her::Model
         #     has_one :organization
         #   end
         #
         #   class Organization
-        #     include Her::API
+        #     include Her::Model
         #   end
         #
         #   @user = User.find(1)
@@ -141,13 +141,13 @@ module Her
 
           define_method(name) do |*method_attrs|
             method_attrs = method_attrs[0] || {}
-            klass = self.class.nearby_class(attrs[:class_name])
+            klass = self.class.her_nearby_class(attrs[:class_name])
 
             return nil if @attributes.include?(name) && @attributes[name].nil? && method_attrs.empty?
 
             if @attributes[name].blank? || method_attrs.any?
               path = begin
-                self.class.build_request_path(@attributes.merge(method_attrs))
+                request_path(method_attrs)
               rescue Her::Errors::PathError
                 return nil
               end
@@ -162,19 +162,19 @@ module Her
         # Define a *belongs_to* association.
         #
         # @param [Symbol] name The name of the model
-        # @param [Hash] attrs Options (currently not used)
+        # @param [Hash] attrs Options
         #
         # @example
         #   class User
-        #     include Her::API
+        #     include Her::Model
         #     belongs_to :team, :class_name => "Group"
         #   end
         #
         #   class Group
-        #     include Her::API
+        #     include Her::Model
         #   end
         #
-        #   @user = User.find(1)
+        #   @user = User.find(1) # => #<User(users/1) id=1 team_id=2 name="Tobias">
         #   @user.team # => #<Team(teams/2) id=2 name="Developers">
         #   # Fetched via GET "/teams/2"
         def belongs_to(name, attrs={})
@@ -189,13 +189,13 @@ module Her
 
           define_method(name) do |*method_attrs|
             method_attrs = method_attrs[0] || {}
-            klass = self.class.nearby_class(attrs[:class_name])
+            klass = self.class.her_nearby_class(attrs[:class_name])
 
             return nil if @attributes.include?(name) && @attributes[name].nil? && method_attrs.empty?
 
             if @attributes[name].blank? || method_attrs.any?
               path = begin
-                klass.build_request_path(@attributes.merge(method_attrs.merge(:id => @attributes[attrs[:foreign_key].to_sym])))
+                klass.build_request_path(@attributes.merge(method_attrs.merge(klass.primary_key => @attributes[attrs[:foreign_key].to_sym])))
               rescue Her::Errors::PathError
                 return nil
               end

data/lib/her/model/attributes.rb

@@ -0,0 +1,173 @@
+module Her
+  module Model
+    # This module handles all methods related to model attributes
+    module Attributes
+      extend ActiveSupport::Concern
+
+      attr_accessor :attributes, :metadata, :response_errors
+      alias :data :attributes
+      alias :data= :attributes=
+
+      # Initialize a new object with data
+      def initialize(attributes={})
+        attributes ||= {}
+        @metadata = attributes.delete(:_metadata) || {}
+        @response_errors = attributes.delete(:_errors) || {}
+        @destroyed = attributes.delete(:_destroyed) || false
+
+        assign_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
+
+      # @private
+      def respond_to?(method, include_private = false)
+        method.to_s.end_with?('=') || method.to_s.end_with?('?') || @attributes.include?(method) || super
+      end
+
+      # @private
+      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 attributes
+      # @private
+      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)
+        parsed_attributes = self.class.parse_associations(unset_attributes)
+        attributes.update(parsed_attributes)
+      end
+      alias :update_attributes :assign_attributes
+      alias :assign_data :assign_attributes
+
+      # Handles returning true for the accessible attributes
+      # @private
+      def has_attribute?(attribute_name)
+        attributes.include?(attribute_name)
+      end
+      alias :has_data? :has_attribute?
+
+      # Handles returning data for a specific attribute
+      # @private
+      def get_attribute(attribute_name)
+        attributes[attribute_name]
+      end
+      alias :get_data :get_attribute
+
+      # Override the method to prevent from returning the object ID
+      # @private
+      def id
+        attributes[self.class.primary_key] || super
+      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
+      end
+
+      # Delegate to the == method
+      # @private
+      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) ]
+      # @private
+      def hash
+        attributes.hash
+      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::Attributes.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
+
+        # @private
+        def setter_method_names
+          @_her_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
+      end
+    end
+  end
+end

data/lib/her/model/base.rb

@@ -2,6 +2,23 @@ module Her
   module Model
     # This module includes basic functionnality to Her::Model
     module Base
+      extend ActiveSupport::Concern
+
+      # Returns true if attribute_name is
+      # * in resource attributes
+      # * an association
+      def has_key?(attribute_name)
+        has_attribute?(attribute_name) ||
+        has_association?(attribute_name)
+      end
+
+      # Returns
+      # * the value of the attribute_name attribute if it's in orm data
+      # * the resource/collection corrsponding to attribute_name if it's an association
+      def [](attribute_name)
+        get_attribute(attribute_name) ||
+        get_association(attribute_name)
+      end
     end
   end
 end

data/lib/her/model/http.rb

@@ -2,266 +2,82 @@ module Her
   module Model
     # This module interacts with Her::API to fetch HTTP data
     module HTTP
-      # Automatically inherit a superclass' api
-      def her_api
-        @her_api ||= begin
-          if superclass.respond_to?(:her_api)
-            superclass.her_api
-          else
-            Her::API.default_api
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Automatically inherit a superclass' api
+        def her_api
+          @_her_api ||= begin
+            if superclass.respond_to?(:her_api)
+              superclass.her_api
+            else
+              Her::API.default_api
+            end
           end
         end
-      end
 
-      # Link a model with a Her::API object
-      def uses_api(api)
-        @her_api = api
-      end
-
-      # Main request wrapper around Her::API. Used to make custom request to the API.
-      # @private
-      def request(attrs={})
-        request = her_api.request(attrs)
-        if block_given?
-          yield request[:parsed_data], request[:response]
-        else
-          { :parsed_data => request[:parsed_data], :response => request[:response] }
+        # Link a model with a Her::API object
+        def uses_api(api)
+          @_her_api = api
         end
-      end
 
-      # Make a GET request and return either a collection or a resource
-      #
-      # @example
-      #   class User
-      #     include Her::Model
-      #   end
-      #
-      #   @popular_users = User.get(:popular)
-      #   # Fetched via GET "/users/popular"
-      def get(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        get_raw(path, attrs) do |parsed_data, response|
-          if parsed_data[:data].is_a?(Array)
-            new_collection(parsed_data)
-          else
-            new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
-          end
-        end
-      end
+        # Main request wrapper around Her::API. Used to make custom request to the API.
+        # @private
+        def request(attrs={})
+          request = her_api.request(attrs)
 
-      # Make a GET request and return the parsed JSON response (not mapped to objects)
-      def get_raw(path, attrs={}, &block)
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        request(attrs.merge(:_method => :get, :_path => path), &block)
-      end
-
-      # Make a GET request and return a collection of resources
-      def get_collection(path=nil, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        get_raw(path, attrs) do |parsed_data, response|
-          new_collection(parsed_data)
-        end
-      end
-
-      # Make a GET request and return a collection of resources
-      def get_resource(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        get_raw(path, attrs) do |parsed_data, response|
-          new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
-        end
-      end
-
-      # Make a POST request and return either a collection or a resource
-      def post(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        post_raw(path, attrs) do |parsed_data, response|
-          if parsed_data[:data].is_a?(Array)
-            new_collection(parsed_data)
+          if block_given?
+            yield request[:parsed_data], request[:response]
           else
-            new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
+            { :parsed_data => request[:parsed_data], :response => request[:response] }
           end
         end
-      end
 
-      # Make a POST request and return the parsed JSON response (not mapped to objects)
-      def post_raw(path, attrs={}, &block)
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        request(attrs.merge(:_method => :post, :_path => path), &block)
-      end
-
-      # Make a POST request and return a collection of resources
-      def post_collection(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        post_raw(path, attrs) do |parsed_data, response|
-          new_collection(parsed_data)
-        end
-      end
-
-      # Make a POST request and return a collection of resources
-      def post_resource(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        post_raw(path, attrs) do |parsed_data, response|
-          new(parse(parsed_data[:data]))
-        end
-      end
-
-      # Make a PUT request and return either a collection or a resource
-      def put(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        put_raw(path, attrs) do |parsed_data, response|
-          if parsed_data[:data].is_a?(Array)
-            new_collection(parsed_data)
-          else
-            new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
+        # 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)
+        %w{GET POST PUT PATCH DELETE}.map(&:downcase).map(&:to_sym).each do |method|
+          define_method method do |path, attrs={}|
+            path = build_request_path_from_string_or_symbol(path, attrs)
+            send("#{method}_raw".to_sym, path, attrs) do |parsed_data, response|
+              if parsed_data[:data].is_a?(Array)
+                new_collection(parsed_data)
+              else
+                new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+              end
+            end
           end
-        end
-      end
-
-      # Make a PUT request and return the parsed JSON response (not mapped to objects)
-      def put_raw(path, attrs={}, &block)
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        request(attrs.merge(:_method => :put, :_path => path), &block)
-      end
-
-      # Make a PUT request and return a collection of resources
-      def put_collection(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        put_raw(path, attrs) do |parsed_data, response|
-          new_collection(parsed_data)
-        end
-      end
-
-      # Make a PUT request and return a collection of resources
-      def put_resource(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        put_raw(path, attrs) do |parsed_data, response|
-          new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
-        end
-      end
 
-      # Make a PATCH request and return either a collection or a resource
-      def patch(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        patch_raw(path, attrs) do |parsed_data, response|
-          if parsed_data[:data].is_a?(Array)
-            new_collection(parsed_data)
-          else
-            new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
-          end
-        end
-      end
-
-      # Make a PATCH request and return the parsed JSON response (not mapped to objects)
-      def patch_raw(path, attrs={}, &block)
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        request(attrs.merge(:_method => :patch, :_path => path), &block)
-      end
-
-      # Make a PATCH request and return a collection of resources
-      def patch_collection(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        patch_raw(path, attrs) do |parsed_data, response|
-          new_collection(parsed_data)
-        end
-      end
-
-      # Make a PATCH request and return a collection of resources
-      def patch_resource(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        patch_raw(path, attrs) do |parsed_data, response|
-          new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
-        end
-      end
-
-      # Make a DELETE request and return either a collection or a resource
-      def delete(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        delete_raw(path, attrs) do |parsed_data, response|
-          if parsed_data[:data].is_a?(Array)
-            new_collection(parsed_data)
-          else
-            new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
-          end
-        end
-      end
-
-      # Make a DELETE request and return the parsed JSON response (not mapped to objects)
-      def delete_raw(path, attrs={}, &block)
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        request(attrs.merge(:_method => :delete, :_path => path), &block)
-      end
-
-      # Make a DELETE request and return a collection of resources
-      def delete_collection(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        delete_raw(path, attrs) do |parsed_data, response|
-          new_collection(parsed_data)
-        end
-      end
-
-      # Make a DELETE request and return a collection of resources
-      def delete_resource(path, attrs={})
-        path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
-        delete_raw(path, attrs) do |parsed_data, response|
-          new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
-        end
-      end
-
-      # Define custom GET requests
-      #
-      # @example
-      #   class User
-      #     include Her::Model
-      #     custom_get :popular
-      #   end
-      #
-      #   User.popular
-      #   # Fetched from GET "/users/popular"
-      def custom_get(*paths)
-        metaclass = (class << self; self; end)
-        paths.each do |path|
-          metaclass.send(:define_method, path.to_sym) do |*attrs|
-            get(path, attrs.first || Hash.new)
-          end
-        end
-      end
-
-      # Define custom POST requests
-      def custom_post(*paths)
-        metaclass = (class << self; self; end)
-        paths.each do |path|
-          metaclass.send(:define_method, path.to_sym) do |*attrs|
-            post(path, attrs.first || Hash.new)
+          define_method "#{method}_raw".to_sym do |path, attrs={}, &block|
+            path = build_request_path_from_string_or_symbol(path, attrs)
+            request(attrs.merge(:_method => method, :_path => path), &block)
           end
-        end
-      end
 
-      # Define custom PUT requests
-      def custom_put(*paths)
-        metaclass = (class << self; self; end)
-        paths.each do |path|
-          metaclass.send(:define_method, path.to_sym) do |*attrs|
-            put(path, attrs.first || Hash.new)
+          define_method "#{method}_collection".to_sym do |path=nil, attrs={}|
+            path = build_request_path_from_string_or_symbol(path, attrs)
+            send("#{method}_raw".to_sym, build_request_path_from_string_or_symbol(path, attrs), attrs) do |parsed_data, response|
+              new_collection(parsed_data)
+            end
           end
-        end
-      end
 
-      # Define custom PATCH requests
-      def custom_patch(*paths)
-        metaclass = (class << self; self; end)
-        paths.each do |path|
-          metaclass.send(:define_method, path.to_sym) do |*attrs|
-            patch(path, attrs.first || Hash.new)
+          define_method "#{method}_resource".to_sym do |path, attrs={}|
+            path = build_request_path_from_string_or_symbol(path, attrs)
+            send("#{method}_raw".to_sym, path, attrs) do |parsed_data, response|
+              new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
+            end
           end
-        end
-      end
 
-      # Define custom DELETE requests
-      def custom_delete(*paths)
-        metaclass = (class << self; self; end)
-        paths.each do |path|
-          metaclass.send(:define_method, path.to_sym) do |*attrs|
-            delete(path, attrs.first || Hash.new)
+          define_method "custom_#{method}".to_sym do |*paths|
+            metaclass = (class << self; self; end)
+            paths.each do |path|
+              metaclass.send(:define_method, path.to_sym) do |*attrs|
+                send(method, path, attrs.first || Hash.new)
+              end
+            end
           end
         end
       end