activerecord 3.2.22.5 → 5.2.8

data/lib/active_record/associations/builder/has_one.rb

@@ -1,62 +1,30 @@
-require 'active_support/core_ext/object/inclusion'
+# frozen_string_literal: true
 
-module ActiveRecord::Associations::Builder
+module ActiveRecord::Associations::Builder # :nodoc:
   class HasOne < SingularAssociation #:nodoc:
-    self.macro = :has_one
-
-    self.valid_options += [:order, :as]
-
-    class_attribute :through_options
-    self.through_options = [:through, :source, :source_type]
-
-    def constructable?
-      !options[:through]
+    def self.macro
+      :has_one
     end
 
-    def build
-      reflection = super
-      configure_dependency unless options[:through]
-      reflection
+    def self.valid_options(options)
+      valid = super + [:as]
+      valid += [:through, :source, :source_type] if options[:through]
+      valid
     end
 
-    private
-
-      def validate_options
-        valid_options = self.class.valid_options
-        valid_options += self.class.through_options if options[:through]
-        options.assert_valid_keys(valid_options)
-      end
-
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete, :nullify, :restrict])
-            raise ArgumentError, "The :dependent option expects either :destroy, :delete, " \
-                                 ":nullify or :restrict (#{options[:dependent].inspect})"
-          end
-
-          send("define_#{options[:dependent]}_dependency_method")
-          model.before_destroy dependency_method_name
-        end
-      end
-
-      def dependency_method_name
-        "has_one_dependent_#{options[:dependent]}_for_#{name}"
-      end
+    def self.valid_dependent_options
+      [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
+    end
 
-      def define_destroy_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          association(name).delete
-        end
-      end
-      alias :define_delete_dependency_method :define_destroy_dependency_method
-      alias :define_nullify_dependency_method :define_destroy_dependency_method
+    def self.add_destroy_callbacks(model, reflection)
+      super unless reflection.options[:through]
+    end
 
-      def define_restrict_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).nil?
-        end
+    def self.define_validations(model, reflection)
+      super
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name, message: :required
       end
+    end
   end
 end

data/lib/active_record/associations/builder/singular_association.rb

@@ -1,32 +1,42 @@
-module ActiveRecord::Associations::Builder
-  class SingularAssociation < Association #:nodoc:
-    self.valid_options += [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+# frozen_string_literal: true
+
+# This class is inherited by the has_one and belongs_to association classes
 
-    def constructable?
-      true
+module ActiveRecord::Associations::Builder # :nodoc:
+  class SingularAssociation < Association #:nodoc:
+    def self.valid_options(options)
+      super + [:foreign_type, :dependent, :primary_key, :inverse_of, :required]
     end
 
-    def define_accessors
+    def self.define_accessors(model, reflection)
       super
-      define_constructors if constructable?
-    end
+      mixin = model.generated_association_methods
+      name = reflection.name
 
-    private
+      define_constructors(mixin, name) if reflection.constructable?
 
-      def define_constructors
-        name = self.name
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def reload_#{name}
+          association(:#{name}).force_reload_reader
+        end
+      CODE
+    end
 
-        mixin.redefine_method("build_#{name}") do |*params, &block|
-          association(name).build(*params, &block)
+    # Defines the (build|create)_association methods for belongs_to or has_one association
+    def self.define_constructors(mixin, name)
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def build_#{name}(*args, &block)
+          association(:#{name}).build(*args, &block)
         end
 
-        mixin.redefine_method("create_#{name}") do |*params, &block|
-          association(name).create(*params, &block)
+        def create_#{name}(*args, &block)
+          association(:#{name}).create(*args, &block)
         end
 
-        mixin.redefine_method("create_#{name}!") do |*params, &block|
-          association(name).create!(*params, &block)
+        def create_#{name}!(*args, &block)
+          association(:#{name}).create!(*args, &block)
         end
-      end
+      CODE
+    end
   end
 end