duck_record 0.0.20 → 0.0.21

data/lib/duck_record/associations/foreign_association.rb

@@ -0,0 +1,11 @@
+module DuckRecord::Associations
+  module ForeignAssociation # :nodoc:
+    def foreign_key_present?
+      if reflection.klass.primary_key
+        owner.attribute_present?(reflection.active_record_primary_key)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/duck_record/associations/has_many_association.rb

@@ -0,0 +1,17 @@
+module DuckRecord
+  # = Active Record Has Many Association
+  module Associations
+    # This is the proxy that handles a has many association.
+    #
+    # If the association has a <tt>:through</tt> option further specialization
+    # is provided by its child HasManyThroughAssociation.
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+      include ForeignAssociation
+
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+        super
+      end
+    end
+  end
+end

data/lib/duck_record/associations/has_one_association.rb

@@ -0,0 +1,39 @@
+module DuckRecord
+  # = Active Record Has One Association
+  module Associations
+    class HasOneAssociation < SingularAssociation #:nodoc:
+      include ForeignAssociation
+
+      def replace(record)
+        if owner.class.readonly_attributes.include?(reflection.foreign_key.to_s)
+          return
+        end
+
+        raise_on_type_mismatch!(record) if record
+        load_target
+
+        return target unless target || record
+
+        self.target = record
+      end
+
+      private
+
+        def foreign_key_present?
+          true
+        end
+
+        # The reason that the save param for replace is false, if for create (not just build),
+        # is because the setting of the foreign keys is actually handled by the scoping when
+        # the record is instantiated, and so they are set straight away and do not need to be
+        # updated within replace.
+        def set_new_record(record)
+          replace(record)
+        end
+
+        def nullify_owner_attributes(record)
+          record[reflection.foreign_key] = nil
+        end
+    end
+  end
+end

data/lib/duck_record/associations/singular_association.rb

@@ -0,0 +1,73 @@
+module DuckRecord
+  module Associations
+    class SingularAssociation < Association #:nodoc:
+      # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
+      def reader
+        if !loaded? || stale_target?
+          reload
+        end
+
+        target
+      end
+
+      # Implements the writer method, e.g. foo.bar= for Foo.belongs_to :bar
+      def writer(record)
+        replace(record)
+      end
+
+      def build(attributes = {})
+        record = build_record(attributes)
+        yield(record) if block_given?
+        set_new_record(record)
+        record
+      end
+
+      # Implements the reload reader method, e.g. foo.reload_bar for
+      # Foo.has_one :bar
+      def force_reload_reader
+        klass.uncached { reload }
+        target
+      end
+
+      private
+
+        def create_scope
+          scope.scope_for_create.stringify_keys.except(klass.primary_key)
+        end
+
+        def find_target
+          return scope.take if skip_statement_cache?
+
+          conn = klass.connection
+          sc = reflection.association_scope_cache(conn, owner) do
+            ActiveRecord::StatementCache.create(conn) { |params|
+              as = ActiveRecord::Associations::AssociationScope.create { params.bind }
+              target_scope.merge(as.scope(self, conn)).limit(1)
+            }
+          end
+
+          binds = ActiveRecord::Associations::AssociationScope.get_bind_values(owner, reflection.chain)
+          sc.execute(binds, klass, conn).first
+        rescue ::RangeError
+          nil
+        end
+
+        def replace(record)
+          raise NotImplementedError, "Subclasses must implement a replace(record) method"
+        end
+
+        def set_new_record(record)
+          replace(record)
+        end
+
+        def _create_record(attributes, raise_error = false)
+          record = build_record(attributes)
+          yield(record) if block_given?
+          saved = record.save
+          set_new_record(record)
+          raise ActiveRecord::RecordInvalid.new(record) if !saved && raise_error
+          record
+        end
+    end
+  end
+end

data/lib/duck_record/nested_validate_association.rb

@@ -139,7 +139,7 @@ module DuckRecord
     end
 
     included do
-      Associations::Builder::EmbedsAssociation.extensions << AssociationBuilderExtension
+      Associations::Builder::Association.extensions << AssociationBuilderExtension
       mattr_accessor :index_nested_attribute_errors, instance_writer: false
       self.index_nested_attribute_errors = false
     end

data/lib/duck_record/reflection.rb

@@ -12,18 +12,24 @@ module DuckRecord
       self._reflections = {}
     end
 
-    def self.create(macro, name, options, ar)
+    def self.create(macro, name, scope, options, ar)
       klass = \
         case macro
         when :embeds_many
           EmbedsManyReflection
         when :embeds_one
           EmbedsOneReflection
+        when :belongs_to
+          BelongsToReflection
+        when :has_many
+          HasManyReflection
+        when :has_one
+          HasOneReflection
         else
           raise "Unsupported Macro: #{macro}"
         end
 
-      klass.new(name, options, ar)
+      klass.new(name, scope, options, ar)
     end
 
     def self.add_reflection(ar, name, reflection)
@@ -110,7 +116,7 @@ module DuckRecord
     #     ThroughReflection
     #     PolymorphicReflection
     #       RuntimeReflection
-    class AbstractReflection # :nodoc:
+    class AbstractReflection
       # Returns a new, unsaved instance of the associated class. +attributes+ will
       # be passed to the class's constructor.
       def build_association(attributes, &block)
@@ -143,6 +149,8 @@ module DuckRecord
       # <tt>has_many :clients</tt> returns <tt>:clients</tt>
       attr_reader :name
 
+      attr_reader :scope
+
       # Returns the hash of options used for the macro.
       #
       # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>{ class_name: "Money" }</tt>
@@ -153,8 +161,9 @@ module DuckRecord
 
       attr_reader :plural_name # :nodoc:
 
-      def initialize(name, options, duck_record)
+      def initialize(name, scope, options, duck_record)
         @name          = name
+        @scope         = scope
         @options       = options
         @duck_record   = duck_record
         @klass         = options[:anonymous_class]
@@ -173,6 +182,16 @@ module DuckRecord
         name.constantize
       end
 
+      # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
+      # and +other_aggregation+ has an options hash assigned to it.
+      def ==(other_aggregation)
+        super ||
+          other_aggregation.kind_of?(self.class) &&
+            name == other_aggregation.name &&
+            !other_aggregation.options.nil? &&
+            active_record == other_aggregation.active_record
+      end
+
       private
 
         def derive_class_name
@@ -182,7 +201,7 @@ module DuckRecord
 
     # Holds all the metadata about an association as it was specified in the
     # Active Record class.
-    class EmbedsAssociationReflection < MacroReflection #:nodoc:
+    class EmbedsAssociationReflection < MacroReflection
       # Returns the target association's class.
       #
       #   class Author < ActiveRecord::Base
@@ -205,7 +224,7 @@ module DuckRecord
 
       attr_accessor :parent_reflection # Reflection
 
-      def initialize(name, options, duck_record)
+      def initialize(name, scope, options, duck_record)
         super
         @constructable = calculate_constructable(macro, options)
 
@@ -286,7 +305,7 @@ module DuckRecord
         end
     end
 
-    class EmbedsManyReflection < EmbedsAssociationReflection # :nodoc:
+    class EmbedsManyReflection < EmbedsAssociationReflection
       def macro; :embeds_many; end
 
       def collection?; true; end
@@ -296,7 +315,7 @@ module DuckRecord
       end
     end
 
-    class EmbedsOneReflection < EmbedsAssociationReflection # :nodoc:
+    class EmbedsOneReflection < EmbedsAssociationReflection
       def macro; :embeds_one; end
 
       def has_one?; true; end
@@ -305,5 +324,323 @@ module DuckRecord
         Associations::EmbedsOneAssociation
       end
     end
+
+    # Holds all the metadata about an association as it was specified in the
+    # Active Record class.
+    class AssociationReflection < MacroReflection
+      alias active_record duck_record
+
+      def quoted_table_name
+        klass.quoted_table_name
+      end
+
+      def primary_key_type
+        klass.type_for_attribute(klass.primary_key)
+      end
+
+      JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
+
+      def join_keys
+        get_join_keys klass
+      end
+
+      # Returns a list of scopes that should be applied for this Reflection
+      # object when querying the database.
+      def scopes
+        scope ? [scope] : []
+      end
+
+      def scope_chain
+        chain.map(&:scopes)
+      end
+      deprecate :scope_chain
+
+      def join_scopes(table, predicate_builder) # :nodoc:
+        if scope
+          [ActiveRecord::Relation.create(klass, table, predicate_builder)
+             .instance_exec(&scope)]
+        else
+          []
+        end
+      end
+
+      def klass_join_scope(table, predicate_builder) # :nodoc:
+        relation = ActiveRecord::Relation.create(klass, table, predicate_builder)
+        klass.scope_for_association(relation)
+      end
+
+      def constraints
+        chain.map(&:scopes).flatten
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}"
+      end
+
+      def chain
+        collect_join_chain
+      end
+
+      def get_join_keys(association_klass)
+        JoinKeys.new(join_pk(association_klass), join_fk)
+      end
+
+      # Returns the target association's class.
+      #
+      #   class Author < ActiveRecord::Base
+      #     has_many :books
+      #   end
+      #
+      #   Author.reflect_on_association(:books).klass
+      #   # => Book
+      #
+      # <b>Note:</b> Do not call +klass.new+ or +klass.create+ to instantiate
+      # a new association object. Use +build_association+ or +create_association+
+      # instead. This allows plugins to hook into association object creation.
+      def klass
+        @klass ||= compute_class(class_name)
+      end
+
+      def compute_class(name)
+        active_record.send(:compute_type, name)
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      attr_reader :type, :foreign_type
+      attr_accessor :parent_reflection # Reflection
+
+      def initialize(name, scope, options, active_record)
+        super
+        @type         = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
+        @foreign_type = options[:foreign_type] || "#{name}_type"
+        @constructable = calculate_constructable(macro, options)
+        @association_scope_cache = {}
+        @scope_lock = Mutex.new
+
+        if options[:class_name] && options[:class_name].class == Class
+          ActiveSupport::Deprecation.warn(<<-MSG.squish)
+            Passing a class to the `class_name` is deprecated and will raise
+            an ArgumentError in Rails 5.2. It eagerloads more classes than
+            necessary and potentially creates circular dependencies.
+
+            Please pass the class name as a string:
+            `#{macro} :#{name}, class_name: '#{options[:class_name]}'`
+          MSG
+        end
+      end
+
+      def association_scope_cache(conn, owner)
+        key = conn.prepared_statements
+        @association_scope_cache[key] ||= @scope_lock.synchronize {
+          @association_scope_cache[key] ||= yield
+        }
+      end
+
+      def constructable? # :nodoc:
+        @constructable
+      end
+
+      def join_table
+        @join_table ||= options[:join_table] || derive_join_table
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
+      end
+
+      def association_foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      # klass option is necessary to support loading polymorphic associations
+      def association_primary_key(klass = nil)
+        options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      def association_primary_key_type
+        klass.type_for_attribute(association_primary_key.to_s)
+      end
+
+      def active_record_primary_key
+        @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
+      end
+
+      def check_validity!
+        unless klass < ActiveRecord::Base
+          raise ArgumentError, "#{klass} must be inherited from ActiveRecord::Base."
+        end
+      end
+
+      def check_preloadable!
+        return unless scope
+
+        if scope.arity > 0
+          raise ArgumentError, <<-MSG.squish
+            The association scope '#{name}' is instance dependent (the scope
+            block takes an argument). Preloading instance dependent scopes is
+            not supported.
+          MSG
+        end
+      end
+      alias :check_eager_loadable! :check_preloadable!
+
+      def join_id_for(owner) # :nodoc:
+        owner[active_record_primary_key]
+      end
+
+      def source_reflection
+        self
+      end
+
+      # A chain of reflections from this one back to the owner. For more see the explanation in
+      # ThroughReflection.
+      def collect_join_chain
+        [self]
+      end
+
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        @association_scope_cache.clear
+      end
+
+      def nested?
+        false
+      end
+
+      def has_scope?
+        scope
+      end
+
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      def macro; raise NotImplementedError; end
+
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      def collection?
+        false
+      end
+
+      # Returns whether or not the association should be validated as part of
+      # the parent's validation.
+      #
+      # Unless you explicitly disable validation with
+      # <tt>validate: false</tt>, validation will take place when:
+      #
+      # * you explicitly enable validation; <tt>validate: true</tt>
+      # * you use autosave; <tt>autosave: true</tt>
+      # * the association is a +has_many+ association
+      def validate?
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || collection?)
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?; false; end
+
+      # Returns +true+ if +self+ is a +has_one+ reflection.
+      def has_one?; false; end
+
+      def association_class; raise NotImplementedError; end
+
+      def add_as_source(seed)
+        seed
+      end
+
+      def extensions
+        Array(options[:extend])
+      end
+
+      protected
+
+      def actual_source_reflection # FIXME: this is a horrible name
+        self
+      end
+
+      private
+
+      def join_pk(_)
+        foreign_key
+      end
+
+      def join_fk
+        active_record_primary_key
+      end
+
+      def calculate_constructable(_macro, _options)
+        false
+      end
+
+      def derive_class_name
+        class_name = name.to_s
+        class_name = class_name.singularize if collection?
+        class_name.camelize
+      end
+
+      def derive_foreign_key
+        if options[:as]
+          "#{options[:as]}_id"
+        else
+          "#{name}_id"
+        end
+      end
+
+      def primary_key(klass)
+        klass.primary_key || raise(ActiveRecord::UnknownPrimaryKey.new(klass))
+      end
+    end
+
+    class BelongsToReflection < AssociationReflection # :nodoc:
+      def macro; :belongs_to; end
+
+      def belongs_to?; true; end
+
+      def association_class
+        Associations::BelongsToAssociation
+      end
+
+      def join_id_for(owner) # :nodoc:
+        owner[foreign_key]
+      end
+
+      private
+
+      def join_fk
+        foreign_key
+      end
+
+      def join_pk(_klass)
+        association_primary_key
+      end
+    end
+
+    class HasManyReflection < AssociationReflection # :nodoc:
+      def macro; :has_many; end
+
+      def collection?; true; end
+
+      def association_class
+        Associations::HasManyAssociation
+      end
+
+      def association_primary_key(klass = nil)
+        primary_key(klass || self.klass)
+      end
+    end
+
+    class HasOneReflection < AssociationReflection # :nodoc:
+      def macro; :has_one; end
+
+      def has_one?; true; end
+
+      def association_class
+        Associations::HasOneAssociation
+      end
+    end
   end
 end