restorm 1.0.0

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

@@ -0,0 +1,44 @@
+module Restorm
+  module Model
+    module Associations
+      class AssociationProxy < (ActiveSupport.const_defined?('ProxyObject') ? ActiveSupport::ProxyObject : ActiveSupport::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
+
+        # @private
+        def initialize(association)
+          @_restorm_association = association
+        end
+
+        def association
+          @_restorm_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/restorm/model/associations/belongs_to_association.rb

@@ -0,0 +1,95 @@
+module Restorm
+  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 = :"@_restorm_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Restorm::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 Restorm::Model
+        #     belongs_to :organization
+        #   end
+        #
+        #   class Organization
+        #     include Restorm::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 Restorm::Model
+        #     belongs_to :organization
+        #   end
+        #
+        #   class Organization
+        #     include Restorm::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/restorm/model/associations/has_many_association.rb

@@ -0,0 +1,100 @@
+module Restorm
+  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        => Restorm::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 = :"@_restorm_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Restorm::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.restorm_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 Restorm::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Restorm::Model
+        #   end
+        #
+        #   user = User.find(1)
+        #   new_comment = user.comments.build(:body => "Hello!")
+        #   new_comment # => #<Comment user_id=1 body="Hello!">
+        # TODO: This only merges the id of the parents, handle the case
+        #       where this is more deeply nested
+        def build(attributes = {})
+          @klass.build(attributes.merge(:"#{@parent.singularized_resource_name}_id" => @parent.id))
+        end
+
+        # Create a new object, save it and add it to the associated collection
+        #
+        # @example
+        #   class User
+        #     include Restorm::Model
+        #     has_many :comments
+        #   end
+        #
+        #   class Comment
+        #     include Restorm::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)
+
+          if resource.save
+            @parent.attributes[@name] ||= Restorm::Collection.new
+            @parent.attributes[@name] << resource
+          end
+
+          resource
+        end
+
+        # @private
+        def fetch
+          super.tap do |o|
+            inverse_of = @opts[:inverse_of] || @parent.singularized_resource_name
+            o.each { |entry| entry.attributes[inverse_of] = @parent }
+          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/restorm/model/associations/has_one_association.rb

@@ -0,0 +1,79 @@
+module Restorm
+  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 = :"@_restorm_association_#{name}"
+
+              cached_data = (instance_variable_defined?(cached_name) && instance_variable_get(cached_name))
+              cached_data || instance_variable_set(cached_name, Restorm::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 Restorm::Model
+        #     has_one :role
+        #   end
+        #
+        #   class Role
+        #     include Restorm::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(:"#{@parent.singularized_resource_name}_id" => @parent.id))
+        end
+
+        # Create a new object, save it and associate it to the parent
+        #
+        # @example
+        #   class User
+        #     include Restorm::Model
+        #     has_one :role
+        #   end
+        #
+        #   class Role
+        #     include Restorm::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/restorm/model/associations.rb

@@ -0,0 +1,141 @@
+require "restorm/model/associations/association"
+require "restorm/model/associations/association_proxy"
+require "restorm/model/associations/belongs_to_association"
+require "restorm/model/associations/has_many_association"
+require "restorm/model/associations/has_one_association"
+
+module Restorm
+  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 @_restorm_associations, lazily initialized with copy of the
+        # superclass' her_associations, or an empty hash.
+        #
+        # @private
+        def associations
+          @_restorm_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 = "restorm/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 Restorm::Model
+        #     has_many :articles
+        #   end
+        #
+        #   class Article
+        #     include Restorm::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 = {})
+          Restorm::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 Restorm::Model
+        #     has_one :organization
+        #   end
+        #
+        #   class Organization
+        #     include Restorm::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 = {})
+          Restorm::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 Restorm::Model
+        #     belongs_to :team, :class_name => "Group"
+        #   end
+        #
+        #   class Group
+        #     include Restorm::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 = {})
+          Restorm::Model::Associations::BelongsToAssociation.attach(self, name, opts)
+        end
+      end
+    end
+  end
+end