Improve consistency and readabily of RelationshipBuilder

Author: mmartinson

lib/jsonapi/relationship_builder.rb

@@ -1,152 +1,157 @@
-require 'pry'
-
 module JSONAPI
   class RelationshipBuilder
-    attr_reader :_model_class, :options
+    attr_reader :model_class, :options, :relationship_class
+    delegate :register_relationship, to: :@resource_class
 
-    class DefinitionProxy
-      def initialize(target)
-        @target = target
+    def initialize(relationship_class, model_class, options)
+      @relationship_class = relationship_class
+      @model_class        = model_class
+      @resource_class     = options[:parent_resource]
+      @options            = options
+    end
+
+    def define_relationship_methods(relationship_name)
+      # Initialize from an ActiveRecord model's properties
+      if model_class && model_class.ancestors.collect{|ancestor| ancestor.name}.include?('ActiveRecord::Base')
+        model_association = model_class.reflect_on_association(relationship_name)
+        if model_association
+          options[:class_name] ||= model_association.class_name
+        end
       end
 
-      def define_method(name, &body)
-        @target.inject_class_method(name, body)
+      relationship = register_relationship(
+        relationship_name,
+        relationship_class.new(relationship_name, options)
+      )
+
+      foreign_key = define_foreign_key_setter(relationship.foreign_key)
+
+      case relationship
+      when JSONAPI::Relationship::ToOne
+        associated = define_resource_relationship_accessor(:one, relationship_name)
+        args = [relationship, foreign_key, associated, relationship_name]
+
+        relationship.belongs_to? ? build_belongs_to(*args) : build_has_one(*args)
+      when JSONAPI::Relationship::ToMany
+        associated = define_resource_relationship_accessor(:many, relationship_name)
+
+        build_to_many(relationship, foreign_key, associated, relationship_name)
       end
+    end
 
-      def method_defined?(name)
-        @target.method_defined?(name)
+    def define_foreign_key_setter(foreign_key)
+      define_on_resource "#{foreign_key}=" do |value|
+        @model.method("#{foreign_key}=").call(value)
       end
+      foreign_key
     end
 
-    def initialize(relationship_class, options, model_class, resource_relationships, resource_klass)
-      @relationship_class = relationship_class
-      @options = options
-      @_model_class = model_class
-      @_relationships = resource_relationships
-      @resource_klass = resource_klass
+    def define_resource_relationship_accessor(type, relationship_name)
+      associated_records_method_name = {
+        one:  "record_for_#{relationship_name}",
+        many: "records_for_#{relationship_name}"
+      }
+      .fetch(type)
+
+      define_on_resource associated_records_method_name do
+        relationship = self.class._relationships[relationship_name]
+        relation_name = relationship.relation_name(context: @context)
+        records_for(relation_name)
+      end
+
+      associated_records_method_name
     end
 
-    #TODO change reference in code once refactor is complete
-    def klass
-      @relationship_class
+    def build_belongs_to(relationship, foreign_key, associated_records_method_name, relationship_name)
+      # Calls method matching foreign key name on model instance
+      define_on_resource foreign_key do
+        @model.method(foreign_key).call
+      end
+
+      # Returns instantiated related resource object or nil
+      define_on_resource relationship_name do |options = {}|
+        relationship = self.class._relationships[relationship_name]
+
+        if relationship.polymorphic?
+          associated_model = public_send(associated_records_method_name)
+          resource_klass = self.class.resource_for_model(associated_model) if associated_model
+          return resource_klass.new(associated_model, @context) if resource_klass
+        else
+          resource_klass = relationship.resource_klass
+          if resource_klass
+            associated_model = public_send(associated_records_method_name)
+            return associated_model ? resource_klass.new(associated_model, @context) : nil
+          end
+        end
+      end
     end
 
-    def target_resource
-      @proxy ||= DefinitionProxy.new(@resource_klass)
+    def build_has_one(relationship, foreign_key, associated_records_method_name, relationship_name)
+      # Returns primary key name of related resource class
+      define_on_resource foreign_key do
+        relationship = self.class._relationships[relationship_name]
+
+        record = public_send(associated_records_method_name)
+        return nil if record.nil?
+        record.public_send(relationship.resource_klass._primary_key)
+      end
+
+      # Returns instantiated related resource object or nil
+      define_on_resource relationship_name do |options = {}|
+        relationship = self.class._relationships[relationship_name]
+
+        resource_klass = relationship.resource_klass
+        if resource_klass
+          associated_model = public_send(associated_records_method_name)
+          return associated_model ? resource_klass.new(associated_model, @context) : nil
+        end
+      end
     end
 
-    def build_relationship(attrs)
-        attrs.each do |attr|
-          relationship_name = attr.to_sym
+    def build_to_many(relationship, foreign_key, associated_records_method_name, relationship_name)
+      # Returns array of primary keys of related resource classes
+      define_on_resource foreign_key do
+        records = public_send(associated_records_method_name)
+        return records.collect do |record|
+          record.public_send(relationship.resource_klass._primary_key)
+        end
+      end
 
-          @resource_klass.check_reserved_relationship_name(relationship_name)
+      # Returns array of instantiated related resource objects
+      define_on_resource relationship_name do |options = {}|
+        relationship = self.class._relationships[relationship_name]
 
-          # Initialize from an ActiveRecord model's properties
-          if _model_class && _model_class.ancestors.collect{|ancestor| ancestor.name}.include?('ActiveRecord::Base')
-            model_association = _model_class.reflect_on_association(relationship_name)
-            if model_association
-              options[:class_name] ||= model_association.class_name
-            end
-          end
+        resource_klass = relationship.resource_klass
+        records = public_send(associated_records_method_name)
 
-          @_relationships[relationship_name] = relationship = klass.new(relationship_name, options)
-
-          associated_records_method_name = case relationship
-                                           when JSONAPI::Relationship::ToOne then "record_for_#{relationship_name}"
-                                           when JSONAPI::Relationship::ToMany then "records_for_#{relationship_name}"
-                                           end
-
-          foreign_key = relationship.foreign_key
-
-          target_resource.define_method "#{foreign_key}=" do |value|
-            @model.method("#{foreign_key}=").call(value)
-          end unless target_resource.method_defined?("#{foreign_key}=")
-
-          target_resource.define_method associated_records_method_name do
-            relationship = self.class._relationships[relationship_name]
-            relation_name = relationship.relation_name(context: @context)
-            records_for(relation_name)
-          end unless target_resource.method_defined?(associated_records_method_name)
-
-          if relationship.is_a?(JSONAPI::Relationship::ToOne)
-            if relationship.belongs_to?
-              target_resource.define_method foreign_key do
-                @model.method(foreign_key).call
-              end unless target_resource.method_defined?(foreign_key)
-
-              target_resource.define_method relationship_name do |options = {}|
-                relationship = self.class._relationships[relationship_name]
-
-                if relationship.polymorphic?
-                  associated_model = public_send(associated_records_method_name)
-                  resource_klass = self.class.resource_for_model(associated_model) if associated_model
-                  return resource_klass.new(associated_model, @context) if resource_klass
-                else
-                  resource_klass = relationship.resource_klass
-                  if resource_klass
-                    associated_model = public_send(associated_records_method_name)
-                    return associated_model ? resource_klass.new(associated_model, @context) : nil
-                  end
-                end
-              end unless target_resource.method_defined?(relationship_name)
-            else
-              target_resource.define_method foreign_key do
-                relationship = self.class._relationships[relationship_name]
-
-                record = public_send(associated_records_method_name)
-                return nil if record.nil?
-                record.public_send(relationship.resource_klass._primary_key)
-              end unless target_resource.method_defined?(foreign_key)
-
-              target_resource.define_method relationship_name do |options = {}|
-                relationship = self.class._relationships[relationship_name]
-
-                resource_klass = relationship.resource_klass
-                if resource_klass
-                  associated_model = public_send(associated_records_method_name)
-                  return associated_model ? resource_klass.new(associated_model, @context) : nil
-                end
-              end unless target_resource.method_defined?(relationship_name)
-            end
-          elsif relationship.is_a?(JSONAPI::Relationship::ToMany)
-            target_resource.define_method foreign_key do
-              records = public_send(associated_records_method_name)
-              return records.collect do |record|
-                record.public_send(relationship.resource_klass._primary_key)
-              end
-            end unless target_resource.method_defined?(foreign_key)
-
-            target_resource.define_method relationship_name do |options = {}|
-              relationship = self.class._relationships[relationship_name]
-
-              resource_klass = relationship.resource_klass
-              records = public_send(associated_records_method_name)
-
-              filters = options.fetch(:filters, {})
-              unless filters.nil? || filters.empty?
-                records = resource_klass.apply_filters(records, filters, options)
-              end
-
-              sort_criteria =  options.fetch(:sort_criteria, {})
-              unless sort_criteria.nil? || sort_criteria.empty?
-                order_options = relationship.resource_klass.construct_order_options(sort_criteria)
-                records = resource_klass.apply_sort(records, order_options, @context)
-              end
-
-              paginator = options[:paginator]
-              if paginator
-                records = resource_klass.apply_pagination(records, paginator, order_options)
-              end
-
-              return records.collect do |record|
-                if relationship.polymorphic?
-                  resource_klass = self.class.resource_for_model(record)
-                end
-                resource_klass.new(record, @context)
-              end
-            end unless target_resource.method_defined?(relationship_name)
+        filters = options.fetch(:filters, {})
+        unless filters.nil? || filters.empty?
+          records = resource_klass.apply_filters(records, filters, options)
+        end
+
+        sort_criteria =  options.fetch(:sort_criteria, {})
+        unless sort_criteria.nil? || sort_criteria.empty?
+          order_options = relationship.resource_klass.construct_order_options(sort_criteria)
+          records = resource_klass.apply_sort(records, order_options, @context)
+        end
+
+        paginator = options[:paginator]
+        if paginator
+          records = resource_klass.apply_pagination(records, paginator, order_options)
+        end
+
+        return records.collect do |record|
+          if relationship.polymorphic?
+            resource_klass = self.class.resource_for_model(record)
           end
+          resource_klass.new(record, @context)
         end
+      end
+    end
+
+    def define_on_resource(method_name, &block)
+      return if @resource_class.method_defined?(method_name)
+      @resource_class.inject_method_definition(method_name, block)
     end
   end
 end

lib/jsonapi/resource.rb

@@ -968,16 +968,25 @@ def _add_relationship(klass, *attrs)
         options = attrs.extract_options!
         options[:parent_resource] = self
 
-        JSONAPI::RelationshipBuilder.new(klass, options, _model_class, @_relationships, self)
-          .build_relationship(attrs)
+        attrs.each do |relationship_name|
+          check_reserved_relationship_name(relationship_name)
 
+          JSONAPI::RelationshipBuilder.new(klass, _model_class, options)
+            .define_relationship_methods(relationship_name.to_sym)
+        end
       end
 
-      #added
-      def inject_class_method(name, body)
+      # Allows JSONAPI::RelationshipBuilder to access metaprogramming hooks
+      def inject_method_definition(name, body)
         define_method(name, body)
       end
 
+      def register_relationship(name, relationship_object)
+        @_relationships[name] = relationship_object
+      end
+
+      private
+
       def check_reserved_resource_name(type, name)
         if [:ids, :types, :hrefs, :links].include?(type)
           warn "[NAME COLLISION] `#{name}` is a reserved resource name."