him 0.1.0

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

@@ -0,0 +1,147 @@
+module Him
+  module Model
+    module Associations
+      class Association
+
+        # @private
+        attr_accessor :params, :cached_result
+
+        # @private
+        def initialize(parent, opts = {})
+          @parent = parent
+          @opts = opts
+          @params = {}
+
+          @klass = @parent.class.her_nearby_class(@opts[:class_name])
+          @name = @opts[:name]
+        end
+
+        # Returns the foreign key to use when building child records,
+        # respecting the :foreign_key option or falling back to convention.
+        def foreign_key
+          @opts[:foreign_key]&.to_sym || :"#{@parent.singularized_resource_name}_id"
+        end
+
+        # @private
+        def self.proxy(parent, opts = {})
+          AssociationProxy.new new(parent, opts)
+        end
+
+        # @private
+        def self.parse_single(association, klass, data)
+          data_key = association[:data_key]
+          return {} unless data[data_key]
+
+          klass = klass.her_nearby_class(association[:class_name])
+          { association[:name] => klass.instantiate_record(klass, data: data[data_key]) }
+        end
+
+        # @private
+        def assign_single_nested_attributes(attributes)
+          if @parent.attributes[@name].blank?
+            @parent.attributes[@name] = @klass.new(@klass.parse(attributes))
+          else
+            @parent.attributes[@name].assign_attributes(attributes)
+          end
+        end
+
+        # @private
+        def fetch(opts = {})
+          attribute_value = @parent.attributes[@name]
+          return @opts[:default].try(:dup) if @parent.attributes.include?(@name) && (attribute_value.nil? || !attribute_value.nil? && attribute_value.empty?) && @params.empty?
+
+          return @cached_result unless @params.any? || @cached_result.nil?
+          return @parent.attributes[@name] unless @params.any? || @parent.attributes[@name].blank?
+          return @opts[:default].try(:dup) if @parent.new?
+
+          if @params.values.include?([]) && !is_a?(HasOneAssociation)
+            Him::Collection.new
+          else
+            path = build_association_path -> { "#{@parent.request_path(@params)}#{@opts[:path]}" }
+            request_association(path, @params).tap do |result|
+              @cached_result = result unless @params.any?
+            end
+          end
+        end
+
+        # @private
+        def request_association(path, params)
+          if @opts[:default].is_a?(Array)
+            @klass.get_collection(path, params)
+          else
+            @klass.get(path, params)
+          end
+        end
+
+        # @private
+        def build_association_path(code)
+          instance_exec(&code)
+        rescue Him::Errors::PathError
+          nil
+        end
+
+        # @private
+        def reset
+          @params = {}
+          @cached_result = nil
+          @parent.attributes.delete(@name)
+        end
+
+        # Add query parameters to the HTTP request performed to fetch the data
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_many :comments
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments.where(:approved => 1) # Fetched via GET "/users/1/comments?approved=1
+        def where(params = {})
+          return self if params.blank? && @parent.attributes[@name].blank?
+          AssociationProxy.new clone.tap { |a| a.params = a.params.merge(params) }
+        end
+        alias all where
+
+        # Fetches the data specified by id
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_many :comments
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments.find(3) # Fetched via GET "/users/1/comments/3
+        def find(id)
+          return nil if id.blank?
+          path = build_association_path -> { "#{@parent.request_path(@params)}#{@opts[:path]}/#{id}" }
+          @klass.get_resource(path, @params)
+        end
+
+        # Refetches the association and puts the proxy back in its initial state,
+        # which is unloaded. Cached associations are cleared.
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Him::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments = [#<Comment(comments/2) id=2 body="Hello!">]
+        #   user.comments.first.id = "Oops"
+        #   user.comments.reload # => [#<Comment(comments/2) id=2 body="Hello!">]
+        #   # Fetched again via GET "/users/1/comments"
+        def reload
+          reset
+          fetch
+        end
+      end
+    end
+  end
+end

data/lib/him/model/associations/association_proxy.rb

@@ -0,0 +1,47 @@
+module Him
+  module Model
+    module Associations
+      class AssociationProxy < BasicObject
+
+        # @private
+        def self.install_proxy_methods(target_name, *names)
+          names.each do |name|
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}(*args, &block)
+                #{target_name}.send(#{name.inspect}, *args, &block)
+              end
+            RUBY
+          end
+        end
+
+        install_proxy_methods :association,
+                              :build, :create, :where, :find, :all, :assign_nested_attributes, :reload
+
+        install_proxy_methods 'association.fetch',
+                              :class, :inspect, :==, :kind_of?, :is_a?, :respond_to?, :nil?, :hash, :eql?
+
+        # @private
+        def initialize(association)
+          @_her_association = association
+        end
+
+        def association
+          @_her_association
+        end
+
+        # @private
+        def method_missing(name, *args, &block)
+          if name == :object_id # avoid redefining object_id
+            return association.fetch.object_id
+          end
+
+          # create a proxy to the fetched object's method
+          AssociationProxy.install_proxy_methods 'association.fetch', name
+
+          # resend message to fetched object
+          __send__(name, *args, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+module Him
+  module Model
+    module Associations
+      class BelongsToAssociation < Association
+
+        # @private
+        def self.attach(klass, name, opts)
+          opts = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :data_key => name,
+            :default => nil,
+            :foreign_key => "#{name}_id"
+          }.merge(opts)
+          klass.associations[:belongs_to] << 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, Him::Model::Associations::BelongsToAssociation.proxy(self, #{opts.inspect}))
+            end
+          RUBY
+        end
+
+        # @private
+        def self.parse(*args)
+          parse_single(*args)
+        end
+
+        # Initialize a new object
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     belongs_to :organization
+        #   end
+        #
+        #   class Organization
+        #     include Him::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_organization = user.organization.build(:name => "Foo Inc.")
+        #   new_organization # => #<Organization name="Foo Inc.">
+        def build(attributes = {})
+          @klass.build(attributes)
+        end
+
+        # Create a new object, save it and associate it to the parent
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     belongs_to :organization
+        #   end
+        #
+        #   class Organization
+        #     include Him::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.organization.create(:name => "Foo Inc.")
+        #   user.organization # => #<Organization id=2 name="Foo Inc.">
+        def create(attributes = {})
+          resource = build(attributes)
+          @parent.attributes[@name] = resource if resource.save
+          resource
+        end
+
+        # @private
+        def fetch
+          foreign_key_value = @parent.attributes[@opts[:foreign_key].to_sym]
+          data_key_value = @parent.attributes[@opts[:data_key].to_sym]
+          return @opts[:default].try(:dup) if (@parent.attributes.include?(@name) && @parent.attributes[@name].nil? && @params.empty?) || (foreign_key_value.blank? && data_key_value.blank?)
+
+          return @cached_result unless @params.any? || @cached_result.nil?
+          return @parent.attributes[@name] unless @params.any? || @parent.attributes[@name].blank?
+
+          path_params = @parent.attributes.merge(@params.merge(@klass.primary_key => foreign_key_value))
+          path = build_association_path -> { @klass.build_request_path(@opts[:path], path_params) }
+          @klass.get_resource(path, @params).tap do |result|
+            @cached_result = result if @params.blank?
+          end
+        end
+
+        # @private
+        def assign_nested_attributes(attributes)
+          assign_single_nested_attributes(attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+module Him
+  module Model
+    module Associations
+      class HasManyAssociation < Association
+
+        # @private
+        def self.attach(klass, name, opts)
+          opts = {
+            :class_name     => name.to_s.classify,
+            :name           => name,
+            :data_key       => name,
+            :default        => Him::Collection.new,
+            :path           => "/#{name}",
+            :inverse_of => nil
+          }.merge(opts)
+          klass.associations[:has_many] << 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, Him::Model::Associations::HasManyAssociation.proxy(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.instantiate_collection(klass, :data => data[data_key]) }
+        end
+
+        # Initialize a new object with a foreign key to the parent
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Him::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_comment = user.comments.build(:body => "Hello!")
+        #   new_comment # => #<Comment user_id=1 body="Hello!">
+        def build(attributes = {})
+          resource = @klass.build(attributes.merge(foreign_key => @parent.id))
+
+          collection = @cached_result || @parent.attributes[@name] || Him::Collection.new
+          collection << resource
+          @cached_result = collection
+          @parent.attributes[@name] = collection
+
+          resource
+        end
+
+        # Create a new object, save it and add it to the associated collection
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Him::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.comments.create(:body => "Hello!")
+        #   user.comments # => [#<Comment id=2 user_id=1 body="Hello!">]
+        def create(attributes = {})
+          resource = build(attributes)
+
+          unless resource.save
+            # Remove the built resource from the collection if save failed
+            @cached_result&.delete(resource)
+            @parent.attributes[@name]&.delete(resource)
+          end
+
+          resource
+        end
+
+        # @private
+        def fetch
+          super.tap do |o|
+            inverse_of = @opts[:inverse_of] || @parent.singularized_resource_name
+            o.each do |entry|
+              inverse_association = entry.send(inverse_of).association rescue nil
+              if inverse_association.present?
+                inverse_association.cached_result = @parent
+              else
+                entry.attributes[inverse_of] = @parent
+              end
+            end
+          end
+        end
+
+        # @private
+        def assign_nested_attributes(attributes)
+          data = attributes.is_a?(Hash) ? attributes.values : attributes
+          @parent.attributes[@name] = @klass.instantiate_collection(@klass, :data => data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module Him
+  module Model
+    module Associations
+      class HasOneAssociation < Association
+
+        # @private
+        def self.attach(klass, name, opts)
+          opts = {
+            :class_name => name.to_s.classify,
+            :name => name,
+            :data_key => name,
+            :default => nil,
+            :path => "/#{name}"
+          }.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, Him::Model::Associations::HasOneAssociation.proxy(self, #{opts.inspect}))
+            end
+          RUBY
+        end
+
+        # @private
+        def self.parse(*args)
+          parse_single(*args)
+        end
+
+        # Initialize a new object with a foreign key to the parent
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_one :role
+        #   end
+        #
+        #   class Role
+        #     include Him::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_role = user.role.build(:title => "moderator")
+        #   new_role # => #<Role user_id=1 title="moderator">
+        def build(attributes = {})
+          @klass.build(attributes.merge(foreign_key => @parent.id))
+        end
+
+        # Create a new object, save it and associate it to the parent
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_one :role
+        #   end
+        #
+        #   class Role
+        #     include Him::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   user.role.create(:title => "moderator")
+        #   user.role # => #<Role id=2 user_id=1 title="moderator">
+        def create(attributes = {})
+          resource = build(attributes)
+          @parent.attributes[@name] = resource if resource.save
+          resource
+        end
+
+        # @private
+        def assign_nested_attributes(attributes)
+          assign_single_nested_attributes(attributes)
+        end
+      end
+    end
+  end
+end

data/lib/him/model/associations.rb

@@ -0,0 +1,141 @@
+require "him/model/associations/association"
+require "him/model/associations/association_proxy"
+require "him/model/associations/belongs_to_association"
+require "him/model/associations/has_many_association"
+require "him/model/associations/has_one_association"
+
+module Him
+  module Model
+    # This module adds associations to models
+    module Associations
+      extend ActiveSupport::Concern
+
+      # Returns true if the model has a association_name association, false otherwise.
+      #
+      # @private
+      def has_association?(association_name)
+        associations = self.class.associations.values.flatten.map { |r| r[:name] }
+        associations.include?(association_name)
+      end
+
+      # Returns the resource/collection corresponding to the association_name association.
+      #
+      # @private
+      def get_association(association_name)
+        send(association_name) if has_association?(association_name)
+      end
+
+      module ClassMethods
+        # Return @_her_associations, lazily initialized with copy of the
+        # superclass' her_associations, or an empty hash.
+        #
+        # @private
+        def associations
+          @_her_associations ||= begin
+            superclass.respond_to?(:associations) ? superclass.associations.dup : Hash.new { |h, k| h[k] = [] }
+          end
+        end
+
+        # @private
+        def association_names
+          associations.inject([]) { |memo, (_, details)| memo << details }.flatten.map { |a| a[:name] }
+        end
+
+        # @private
+        def association_keys
+          associations.inject([]) { |memo, (_, details)| memo << details }.flatten.map { |a| a[:data_key] }
+        end
+
+        # Parse associations data after initializing a new object
+        #
+        # @private
+        def parse_associations(data)
+          associations.each_pair do |type, definitions|
+            definitions.each do |association|
+              association_class = "him/model/associations/#{type}_association".classify.constantize
+              data.merge! association_class.parse(association, self, data)
+            end
+          end
+
+          data
+        end
+
+        # Define an *has_many* association.
+        #
+        # @param [Symbol] name The name of the method added to resources
+        # @param [Hash] opts Options
+        # @option opts [String] :class_name The name of the class to map objects to
+        # @option opts [Symbol] :data_key The attribute where the data is stored
+        # @option opts [Path] :path The relative path where to fetch the data (defaults to `/{name}`)
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_many :articles
+        #   end
+        #
+        #   class Article
+        #     include Him::Model
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.articles # => [#<Article(articles/2) id=2 title="Hello world.">]
+        #   # Fetched via GET "/users/1/articles"
+        def has_many(name, opts = {})
+          Him::Model::Associations::HasManyAssociation.attach(self, name, opts)
+        end
+
+        # Define an *has_one* association.
+        #
+        # @param [Symbol] name The name of the method added to resources
+        # @param [Hash] opts Options
+        # @option opts [String] :class_name The name of the class to map objects to
+        # @option opts [Symbol] :data_key The attribute where the data is stored
+        # @option opts [Path] :path The relative path where to fetch the data (defaults to `/{name}`)
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     has_one :organization
+        #   end
+        #
+        #   class Organization
+        #     include Him::Model
+        #   end
+        #
+        #   @user = User.find(1)
+        #   @user.organization # => #<Organization(organizations/2) id=2 name="Foobar Inc.">
+        #   # Fetched via GET "/users/1/organization"
+        def has_one(name, opts = {})
+          Him::Model::Associations::HasOneAssociation.attach(self, name, opts)
+        end
+
+        # Define a *belongs_to* association.
+        #
+        # @param [Symbol] name The name of the method added to resources
+        # @param [Hash] opts Options
+        # @option opts [String] :class_name The name of the class to map objects to
+        # @option opts [Symbol] :data_key The attribute where the data is stored
+        # @option opts [Path] :path The relative path where to fetch the data
+        # @option opts [Symbol] :foreign_key The foreign key used to build the `:id` part of the path (defaults to `{name}_id`)
+        #
+        # @example
+        #   class User
+        #     include Him::Model
+        #     belongs_to :team, :class_name => "Group"
+        #   end
+        #
+        #   class Group
+        #     include Him::Model
+        #   end
+        #
+        #   @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, opts = {})
+          Him::Model::Associations::BelongsToAssociation.attach(self, name, opts)
+        end
+      end
+    end
+  end
+end