her 0.5.5 → 0.6

data/lib/her/model/associations.rb

@@ -1,3 +1,8 @@
+require "her/model/associations/association"
+require "her/model/associations/belongs_to_association"
+require "her/model/associations/has_many_association"
+require "her/model/associations/has_one_association"
+
 module Her
   module Model
     # This module adds associations to models
@@ -86,29 +91,11 @@ module Her
           }.merge(attrs)
           (associations[:has_many] ||= []) << attrs
 
-          define_method(name) do |*method_attrs|
-            method_attrs = method_attrs[0] || {}
-            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
-                request_path(method_attrs)
-              rescue Her::Errors::PathError
-                return nil
-              end
-
-              @attributes[name] = klass.get_collection("#{path}#{attrs[:path]}", method_attrs)
-            end
-
-            inverse_of = attrs[:inverse_of] || self.class.name.split('::').last.tableize.singularize
+          define_method(name) do
+            cached_name = :"@_her_association_#{name}"
 
-            @attributes[name].each do |entry|
-              entry.send("#{inverse_of}=", self)
-            end
-
-            @attributes[name]
+            cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+            cached_data || instance_variable_set(cached_name, Her::Model::Associations::HasManyAssociation.new(self, attrs))
           end
         end
 
@@ -139,23 +126,11 @@ module Her
           }.merge(attrs)
           (associations[:has_one] ||= []) << attrs
 
-          define_method(name) do |*method_attrs|
-            method_attrs = method_attrs[0] || {}
-            klass = self.class.her_nearby_class(attrs[:class_name])
-
-            return nil if @attributes.include?(name) && @attributes[name].nil? && method_attrs.empty?
+          define_method(name) do
+            cached_name = :"@_her_association_#{name}"
 
-            if @attributes[name].blank? || method_attrs.any?
-              path = begin
-                request_path(method_attrs)
-              rescue Her::Errors::PathError
-                return nil
-              end
-
-              @attributes[name] = klass.get_resource("#{path}#{attrs[:path]}", method_attrs)
-            end
-
-            @attributes[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))
           end
         end
 
@@ -187,23 +162,11 @@ module Her
           }.merge(attrs)
           (associations[:belongs_to] ||= []) << attrs
 
-          define_method(name) do |*method_attrs|
-            method_attrs = method_attrs[0] || {}
-            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(klass.primary_key => @attributes[attrs[:foreign_key].to_sym])))
-              rescue Her::Errors::PathError
-                return nil
-              end
-
-              @attributes[name] = klass.get_resource("#{path}", method_attrs)
-            end
+          define_method(name) do
+            cached_name = :"@_her_association_#{name}"
 
-            @attributes[name]
+            cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+            cached_data || instance_variable_set(cached_name, Her::Model::Associations::BelongsToAssociation.new(self, attrs))
           end
         end
       end

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

@@ -0,0 +1,46 @@
+module Her
+  module Model
+    module Associations
+      class Association
+        attr_accessor :query_attrs
+
+        # @private
+        def initialize(parent, opts = {})
+          @parent = parent
+          @opts = opts
+          @query_attrs = {}
+
+          @klass = @parent.class.her_nearby_class(@opts[:class_name])
+          @name = @opts[:name]
+        end
+
+        def where(attrs = {})
+          return self if attrs.blank?
+          self.clone.tap { |a| a.query_attrs = a.query_attrs.merge(attrs) }
+        end
+        alias :all :where
+
+        # @private
+        def nil?
+          fetch.nil?
+        end
+
+        # @private
+        def kind_of?(thing)
+          fetch.kind_of?(thing)
+        end
+
+        # @private
+        def ==(other)
+          fetch.eql?(other)
+        end
+        alias :eql? :==
+
+        # @private
+        def method_missing(method, *args, &blk)
+          fetch.send(method, *args, &blk)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Her
+  module Model
+    module Associations
+      class BelongsToAssociation < Association
+        def build(attributes = {})
+          @klass.new(attributes)
+        end
+
+        def create(attributes = {})
+          resource = build(attributes)
+          @parent.attributes[@name] = resource if resource.save
+          resource
+        end
+
+        def fetch
+          foreign_key_value = @parent.attributes[@opts[:foreign_key].to_sym]
+          return nil if (@parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @query_attrs.empty?) || foreign_key_value.blank?
+
+          if @parent.attributes[@name].blank? || @query_attrs.any?
+            path = begin
+              @klass.build_request_path(@parent.attributes.merge(@query_attrs.merge(@klass.primary_key => foreign_key_value)))
+            rescue Her::Errors::PathError
+              return nil
+            end
+
+            @klass.get_resource("#{path}", @query_attrs)
+          else
+            @parent.attributes[@name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Her
+  module Model
+    module Associations
+      class HasManyAssociation < Association
+        def build(attributes = {})
+          @klass.new(attributes.merge(:"#{@parent.singularized_resource_name}_id" => @parent.id))
+        end
+
+        def create(attributes = {})
+          resource = build(attributes)
+
+          if resource.save
+            @parent.attributes[@name] ||= Her::Collection.new
+            @parent.attributes[@name] << resource
+          end
+
+          resource
+        end
+
+        def fetch
+          return Her::Collection.new if @parent.attributes.include?(@name) && @parent.attributes[@name].empty? && @query_attrs.empty?
+
+          output = if @parent.attributes[@name].blank? || @query_attrs.any?
+            path = begin
+              @parent.request_path(@query_attrs)
+            rescue Her::Errors::PathError
+              return nil
+            end
+
+            @klass.get_collection("#{path}#{@opts[:path]}", @query_attrs)
+          else
+            @parent.attributes[@name]
+          end
+
+          inverse_of = @opts[:inverse_of] || @parent.singularized_resource_name
+          output.each { |entry| entry.send("#{inverse_of}=", @parent) }
+
+          output
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Her
+  module Model
+    module Associations
+      class HasOneAssociation < Association
+        def build(attributes = {})
+          @klass.new(attributes.merge(:"#{@parent.singularized_resource_name}_id" => @parent.id))
+        end
+
+        def create(attributes = {})
+          resource = build(attributes)
+          @parent.attributes[@name] = resource if resource.save
+          resource
+        end
+
+        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
+      end
+    end
+  end
+end

data/lib/her/model/attributes.rb

@@ -40,9 +40,7 @@ module Her
           if setter_method_names.include?(setter_method)
             model.send(setter_method, value)
           else
-            if key.is_a?(String)
-              key = key.to_sym
-            end
+            key = key.to_sym if key.is_a?(String)
             memo[key] = value
           end
           memo
@@ -145,33 +143,26 @@ module Her
           attributes.each do |attribute|
             attribute = attribute.to_sym
 
-            define_method "#{attribute}".to_sym do
+            define_method attribute 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
+            define_method :"#{attribute}=" do |value|
+              self.send(:"#{attribute}_will_change!") if @attributes[attribute] != value
               @attributes[attribute] = value
             end
 
-            define_method "#{attribute}?".to_sym do
+            define_method :"#{attribute}?" 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
-
+        # Define the accessor in which the API response errors (obtained from the parsing middleware) will be stored
         def store_response_errors(value = nil)
           if @_her_store_response_errors
             remove_method @_her_store_response_errors
-            remove_method "#{@_her_store_response_errors}="
+            remove_method :"#{@_her_store_response_errors}="
           end
 
           @_her_store_response_errors ||= begin
@@ -182,13 +173,14 @@ module Her
           @_her_store_response_errors = value
 
           define_method(@_her_store_response_errors) { @response_errors }
-          define_method("#{@_her_store_response_errors}=") { |value| @response_errors = value }
+          define_method(:"#{@_her_store_response_errors}=") { |value| @response_errors = value }
         end
 
+        # Define the accessor in which the API response metadata (obtained from the parsing middleware) will be stored
         def store_metadata(value = nil)
           if @_her_store_metadata
             remove_method @_her_store_metadata
-            remove_method "#{@_her_store_metadata}="
+            remove_method :"#{@_her_store_metadata}="
           end
 
           @_her_store_metadata ||= begin
@@ -199,7 +191,15 @@ module Her
           @_her_store_metadata = value
 
           define_method(@_her_store_metadata) { @metadata }
-          define_method("#{@_her_store_metadata}=") { |value| @metadata = value }
+          define_method(:"#{@_her_store_metadata}=") { |value| @metadata = value }
+        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

data/lib/her/model/base.rb

@@ -19,6 +19,11 @@ module Her
         get_attribute(attribute_name) ||
         get_association(attribute_name)
       end
+
+      # @private
+      def singularized_resource_name
+        self.class.name.split('::').last.tableize.singularize
+      end
     end
   end
 end

data/lib/her/model/http.rb

@@ -5,21 +5,17 @@ module Her
       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
+        # Change which API the model will use to make its HTTP requests
+        def use_api(value = nil)
+          @_her_use_api ||= begin
+            superclass.use_api if superclass.respond_to?(:use_api)
           end
-        end
 
-        # Link a model with a Her::API object
-        def uses_api(api)
-          @_her_api = api
+          return @_her_use_api unless value
+          @_her_use_api = value
         end
+        alias :her_api :use_api
+        alias :uses_api :use_api
 
         # Main request wrapper around Her::API. Used to make custom request to the API.
         # @private
@@ -40,10 +36,10 @@ module Her
         # - <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|
+        [:get, :post, :put, :patch, :delete].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|
+            send(:"#{method}_raw", path, attrs) do |parsed_data, response|
               if parsed_data[:data].is_a?(Array)
                 new_collection(parsed_data)
               else
@@ -52,31 +48,31 @@ module Her
             end
           end
 
-          define_method "#{method}_raw".to_sym do |path, attrs={}, &block|
+          define_method :"#{method}_raw" do |path, attrs={}, &block|
             path = build_request_path_from_string_or_symbol(path, attrs)
             request(attrs.merge(:_method => method, :_path => path), &block)
           end
 
-          define_method "#{method}_collection".to_sym do |path=nil, attrs={}|
+          define_method :"#{method}_collection" 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|
+            send(:"#{method}_raw", build_request_path_from_string_or_symbol(path, attrs), attrs) do |parsed_data, response|
               new_collection(parsed_data)
             end
           end
 
-          define_method "#{method}_resource".to_sym do |path, attrs={}|
+          define_method :"#{method}_resource" do |path, attrs={}|
             path = build_request_path_from_string_or_symbol(path, attrs)
-            send("#{method}_raw".to_sym, path, attrs) do |parsed_data, response|
+            send(:"#{method}_raw", path, attrs) do |parsed_data, response|
               new(parse(parsed_data[:data]).merge :_metadata => parsed_data[:metadata], :_errors => parsed_data[:errors])
             end
           end
 
-          define_method "custom_#{method}".to_sym do |*paths|
+          define_method :"custom_#{method}" do |*paths|
             metaclass = (class << self; self; end)
             opts = paths.last.is_a?(Hash) ? paths.pop : Hash.new
 
             paths.each do |path|
-              metaclass.send(:define_method, path.to_sym) do |*attrs|
+              metaclass.send(:define_method, path) do |*attrs|
                 attrs = attrs.first || Hash.new
                 send(method, path, attrs)
               end

data/lib/her/model/orm.rb

@@ -19,7 +19,8 @@ module Her
         @destroyed == true
       end
 
-      # Save a resource
+      # Save a resource and return `false` if the response is not a successful one or
+      # if there are errors in the resource. Otherwise, return the newly updated resource
       #
       # @example Save a resource after fetching it
       #   @user = User.find(1)
@@ -33,9 +34,6 @@ module Her
       #   @user.save
       #   # Called via POST "/users"
       def save
-        params = to_params
-        resource = self
-
         if new?
           callback = :create
           method = :post
@@ -46,7 +44,7 @@ module Her
 
         run_callbacks callback do
           run_callbacks :save do
-            self.class.request(params.merge(:_method => method, :_path => "#{request_path}")) do |parsed_data, response|
+            self.class.request(to_params.merge(:_method => method, :_path => "#{request_path}")) do |parsed_data, response|
               assign_attributes(self.class.parse(parsed_data[:data])) if parsed_data[:data].any?
               self.metadata = parsed_data[:metadata]
               self.response_errors = parsed_data[:errors]
@@ -103,6 +101,7 @@ module Her
             end
             resource
           end
+
           if ids.length > 1 || ids.first.kind_of?(Array)
             results
           else
@@ -110,39 +109,16 @@ module Her
           end
         end
 
-        # Fetch a collection of resources
-        #
-        # @example
-        #   @users = User.all
-        #   # Fetched via GET "/users"
-        def all(params={})
-          request(params.merge(:_method => :get, :_path => "#{build_request_path(params)}")) do |parsed_data, response|
-            new_collection(parsed_data)
+        # Delegate the following methods to `scoped`
+        [:all, :where, :create, :page, :per_page].each do |method|
+          define_method method do |*attrs|
+            scoped.send(method, attrs.first)
           end
         end
 
-        # Create a resource and return it
-        #
-        # @example
-        #   @user = User.create({ :fullname => "Tobias Fünke" })
-        #   # Called via POST "/users/1"
-        def create(params={})
-          resource = new(params)
-          resource.run_callbacks :create do
-            resource.run_callbacks :save do
-              params = resource.to_params
-              request(params.merge(:_method => :post, :_path => "#{build_request_path(params)}")) do |parsed_data, response|
-                data = parse(parsed_data[:data])
-                resource.instance_eval do
-                  assign_attributes(data)
-                  @metadata = parsed_data[:metadata]
-                  @response_errors = parsed_data[:errors]
-                  @changed_attributes.clear if @changed_attributes.present?
-                end
-              end
-            end
-          end
-          resource
+        # @private
+        def scoped
+          Relation.new(self)
         end
 
         # Save an existing resource and return it