activerecord 3.2.22.5 → 4.2.11.3

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

@@ -1,57 +1,128 @@
 module ActiveRecord::Associations::Builder
-  class HasAndBelongsToMany < CollectionAssociation #:nodoc:
-    self.macro = :has_and_belongs_to_many
+  class HasAndBelongsToMany # :nodoc:
+    class JoinTableResolver
+      KnownTable = Struct.new :join_table
 
-    self.valid_options += [:join_table, :association_foreign_key, :delete_sql, :insert_sql]
+      class KnownClass
+        def initialize(lhs_class, rhs_class_name)
+          @lhs_class      = lhs_class
+          @rhs_class_name = rhs_class_name
+          @join_table     = nil
+        end
 
-    def build
-      reflection = super
-      check_validity(reflection)
-      define_destroy_hook
-      reflection
-    end
+        def join_table
+          @join_table ||= [@lhs_class.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
+        end
 
-    private
+        private
 
-      def define_destroy_hook
-        name = self.name
-        model.send(:include, Module.new {
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def destroy_associations
-              association(#{name.to_sym.inspect}).delete_all_on_destroy
-              super
-            end
-          RUBY
-        })
+        def klass
+          @lhs_class.send(:compute_type, @rhs_class_name)
+        end
       end
 
-      # TODO: These checks should probably be moved into the Reflection, and we should not be
-      #       redefining the options[:join_table] value - instead we should define a
-      #       reflection.join_table method.
-      def check_validity(reflection)
-        if reflection.association_foreign_key == reflection.foreign_key
-          raise ActiveRecord::HasAndBelongsToManyAssociationForeignKeyNeeded.new(reflection)
+      def self.build(lhs_class, name, options)
+        if options[:join_table]
+          KnownTable.new options[:join_table].to_s
+        else
+          class_name = options.fetch(:class_name) {
+            name.to_s.camelize.singularize
+          }
+          KnownClass.new lhs_class, class_name
         end
-
-        reflection.options[:join_table] ||= join_table_name(
-          model.send(:undecorated_table_name, model.to_s),
-          model.send(:undecorated_table_name, reflection.class_name)
-        )
       end
+    end
 
-      # Generates a join table name from two provided table names.
-      # The names in the join table names end up in lexicographic order.
-      #
-      #   join_table_name("members", "clubs")         # => "clubs_members"
-      #   join_table_name("members", "special_clubs") # => "members_special_clubs"
-      def join_table_name(first_table_name, second_table_name)
-        if first_table_name < second_table_name
-          join_table = "#{first_table_name}_#{second_table_name}"
-        else
-          join_table = "#{second_table_name}_#{first_table_name}"
+    attr_reader :lhs_model, :association_name, :options
+
+    def initialize(association_name, lhs_model, options)
+      @association_name = association_name
+      @lhs_model = lhs_model
+      @options = options
+    end
+
+    def through_model
+      habtm = JoinTableResolver.build lhs_model, association_name, options
+
+      join_model = Class.new(ActiveRecord::Base) {
+        class << self;
+          attr_accessor :left_model
+          attr_accessor :name
+          attr_accessor :table_name_resolver
+          attr_accessor :left_reflection
+          attr_accessor :right_reflection
+        end
+
+        def self.table_name
+          table_name_resolver.join_table
         end
 
-        model.table_name_prefix + join_table + model.table_name_suffix
+        def self.compute_type(class_name)
+          left_model.compute_type class_name
+        end
+
+        def self.add_left_association(name, options)
+          belongs_to name, options
+          self.left_reflection = _reflect_on_association(name)
+        end
+
+        def self.add_right_association(name, options)
+          rhs_name = name.to_s.singularize.to_sym
+          belongs_to rhs_name, options
+          self.right_reflection = _reflect_on_association(rhs_name)
+        end
+
+        def self.retrieve_connection
+          left_model.retrieve_connection
+        end
+
+      }
+
+      join_model.name                = "HABTM_#{association_name.to_s.camelize}"
+      join_model.table_name_resolver = habtm
+      join_model.left_model          = lhs_model
+
+      join_model.add_left_association :left_side, anonymous_class: lhs_model
+      join_model.add_right_association association_name, belongs_to_options(options)
+      join_model
+    end
+
+    def middle_reflection(join_model)
+      middle_name = [lhs_model.name.downcase.pluralize,
+                     association_name].join('_').gsub(/::/, '_').to_sym
+      middle_options = middle_options join_model
+      hm_builder = HasMany.create_builder(lhs_model,
+                                          middle_name,
+                                          nil,
+                                          middle_options)
+      hm_builder.build lhs_model
+    end
+
+    private
+
+    def middle_options(join_model)
+      middle_options = {}
+      middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
+      middle_options[:source] = join_model.left_reflection.name
+      if options.key? :foreign_key
+        middle_options[:foreign_key] = options[:foreign_key]
+      end
+      middle_options
+    end
+
+    def belongs_to_options(options)
+      rhs_options = {}
+
+      if options.key? :class_name
+        rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
+        rhs_options[:class_name] = options[:class_name]
       end
+
+      if options.key? :association_foreign_key
+        rhs_options[:foreign_key] = options[:association_foreign_key]
+      end
+
+      rhs_options
+    end
   end
 end

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

@@ -1,71 +1,15 @@
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord::Associations::Builder
   class HasMany < CollectionAssociation #:nodoc:
-    self.macro = :has_many
-
-    self.valid_options += [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of]
-
-    def build
-      reflection = super
-      configure_dependency
-      reflection
+    def macro
+      :has_many
     end
 
-    private
-
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete_all, :nullify, :restrict])
-            raise ArgumentError, "The :dependent option expects either :destroy, :delete_all, " \
-                                 ":nullify or :restrict (#{options[:dependent].inspect})"
-          end
-
-          send("define_#{options[:dependent]}_dependency_method")
-          model.before_destroy dependency_method_name
-        end
-      end
-
-      def define_destroy_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          send(name).each do |o|
-            # No point in executing the counter update since we're going to destroy the parent anyway
-            counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
-            if o.respond_to?(counter_method)
-              class << o
-                self
-              end.send(:define_method, counter_method, Proc.new {})
-            end
-          end
-
-          send(name).delete_all
-        end
-      end
-
-      def define_delete_all_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          association(name).delete_all_on_destroy
-        end
-      end
-
-      def define_nullify_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          send(name).delete_all
-        end
-      end
-
-      def define_restrict_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).empty?
-        end
-      end
+    def valid_options
+      super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache, :join_table, :foreign_type]
+    end
 
-      def dependency_method_name
-        "has_many_dependent_for_#{name}"
-      end
+    def self.valid_dependent_options
+      [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
+    end
   end
 end

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

@@ -1,62 +1,23 @@
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord::Associations::Builder
   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 macro
+      :has_one
+    end
 
-    def constructable?
-      !options[:through]
+    def valid_options
+      valid = super + [:as, :foreign_type]
+      valid += [:through, :source, :source_type] if options[:through]
+      valid
     end
 
-    def build
-      reflection = super
-      configure_dependency unless options[:through]
-      reflection
+    def self.valid_dependent_options
+      [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
     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 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 define_restrict_dependency_method
-        name = self.name
-        mixin.redefine_method(dependency_method_name) do
-          raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).nil?
-        end
-      end
+    def self.add_destroy_callbacks(model, reflection)
+      super unless reflection.options[:through]
+    end
   end
 end

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

@@ -1,32 +1,38 @@
+# This class is inherited by the has_one and belongs_to association classes
+
 module ActiveRecord::Associations::Builder
   class SingularAssociation < Association #:nodoc:
-    self.valid_options += [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
-
-    def constructable?
-      true
+    def valid_options
+      super + [:dependent, :primary_key, :inverse_of, :required]
     end
 
-    def define_accessors
+    def self.define_accessors(model, reflection)
       super
-      define_constructors if constructable?
+      define_constructors(model.generated_association_methods, reflection.name) if reflection.constructable?
     end
 
-    private
-
-      def define_constructors
-        name = self.name
-
-        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
+      CODE
+    end
+
+    def self.define_validations(model, reflection)
+      super
+      if reflection.options[:required]
+        model.validates_presence_of reflection.name
       end
+    end
   end
 end