activerecord 3.1.10 → 4.2.11

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

@@ -1,85 +1,116 @@
-require 'active_support/core_ext/object/inclusion'
-
 module ActiveRecord::Associations::Builder
   class BelongsTo < SingularAssociation #:nodoc:
-    self.macro = :belongs_to
+    def macro
+      :belongs_to
+    end
+
+    def valid_options
+      super + [:foreign_type, :polymorphic, :touch, :counter_cache]
+    end
 
-    self.valid_options += [:foreign_type, :polymorphic, :touch]
+    def self.valid_dependent_options
+      [:destroy, :delete]
+    end
 
-    def constructable?
-      !options[:polymorphic]
+    def self.define_callbacks(model, reflection)
+      super
+      add_counter_cache_callbacks(model, reflection) if reflection.options[:counter_cache]
+      add_touch_callbacks(model, reflection)         if reflection.options[:touch]
     end
 
-    def build
-      reflection = super
-      add_counter_cache_callbacks(reflection) if options[:counter_cache]
-      add_touch_callbacks(reflection)         if options[:touch]
-      configure_dependency
-      reflection
+    def self.define_accessors(mixin, reflection)
+      super
+      add_counter_cache_methods mixin
     end
 
     private
 
-      def add_counter_cache_callbacks(reflection)
-        cache_column = reflection.counter_cache_column
-        name         = self.name
+    def self.add_counter_cache_methods(mixin)
+      return if mixin.method_defined? :belongs_to_counter_cache_after_update
 
-        method_name = "belongs_to_counter_cache_after_create_for_#{name}"
-        model.redefine_method(method_name) do
-          record = send(name)
-          record.class.increment_counter(cache_column, record.id) unless record.nil?
-        end
-        model.after_create(method_name)
+      mixin.class_eval do
+        def belongs_to_counter_cache_after_update(reflection)
+          foreign_key  = reflection.foreign_key
+          cache_column = reflection.counter_cache_column
 
-        method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        model.redefine_method(method_name) do
-          record = send(name)
-          record.class.decrement_counter(cache_column, record.id) unless record.nil?
-        end
-        model.before_destroy(method_name)
+          if (@_after_create_counter_called ||= false)
+            @_after_create_counter_called = false
+          elsif attribute_changed?(foreign_key) && !new_record? && reflection.constructable?
+            model           = reflection.klass
+            foreign_key_was = attribute_was foreign_key
+            foreign_key     = attribute foreign_key
 
-        model.send(:module_eval,
-          "#{reflection.class_name}.send(:attr_readonly,\"#{cache_column}\".intern) if defined?(#{reflection.class_name}) && #{reflection.class_name}.respond_to?(:attr_readonly)", __FILE__, __LINE__
-        )
+            if foreign_key && model.respond_to?(:increment_counter)
+              model.increment_counter(cache_column, foreign_key)
+            end
+            if foreign_key_was && model.respond_to?(:decrement_counter)
+              model.decrement_counter(cache_column, foreign_key_was)
+            end
+          end
+        end
       end
+    end
 
-      def add_touch_callbacks(reflection)
-        name        = self.name
-        method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
-        touch       = options[:touch]
+    def self.add_counter_cache_callbacks(model, reflection)
+      cache_column = reflection.counter_cache_column
 
-        model.redefine_method(method_name) do
-          record = send(name)
+      model.after_update lambda { |record|
+        record.belongs_to_counter_cache_after_update(reflection)
+      }
 
-          unless record.nil?
-            if touch == true
-              record.touch
-            else
-              record.touch(touch)
-            end
-          end
-        end
+      klass = reflection.class_name.safe_constantize
+      klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
+    end
 
-        model.after_save(method_name)
-        model.after_touch(method_name)
-        model.after_destroy(method_name)
-      end
+    def self.touch_record(o, foreign_key, name, touch) # :nodoc:
+      old_foreign_id = o.changed_attributes[foreign_key]
+
+      if old_foreign_id
+        association = o.association(name)
+        reflection = association.reflection
+        if reflection.polymorphic?
+          klass = o.public_send("#{reflection.foreign_type}_was").constantize
+        else
+          klass = association.klass
+        end
+        old_record = klass.find_by(klass.primary_key => old_foreign_id)
 
-      def configure_dependency
-        if options[:dependent]
-          unless options[:dependent].in?([:destroy, :delete])
-            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
+        if old_record
+          if touch != true
+            old_record.touch touch
+          else
+            old_record.touch
           end
+        end
+      end
 
-          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
-          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-            def #{method_name}
-              association = #{name}
-              association.#{options[:dependent]} if association
-            end
-          eoruby
-          model.after_destroy method_name
+      record = o.send name
+      if record && record.persisted?
+        if touch != true
+          record.touch touch
+        else
+          record.touch
         end
       end
+    end
+
+    def self.add_touch_callbacks(model, reflection)
+      foreign_key = reflection.foreign_key
+      n           = reflection.name
+      touch       = reflection.options[:touch]
+
+      callback = lambda { |record|
+        BelongsTo.touch_record(record, foreign_key, n, touch)
+      }
+
+      model.after_save    callback, if: :changed?
+      model.after_touch   callback
+      model.after_destroy callback
+    end
+
+    def self.add_destroy_callbacks(model, reflection)
+      name = reflection.name
+      model.after_destroy lambda { |o| o.association(name).handle_dependency }
+    end
   end
 end

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

@@ -1,75 +1,95 @@
+# This class is inherited by the has_many and has_many_and_belongs_to_many association classes
+
+require 'active_record/associations'
+
 module ActiveRecord::Associations::Builder
   class CollectionAssociation < Association #:nodoc:
+
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
-    self.valid_options += [
-      :table_name, :order, :group, :having, :limit, :offset, :uniq, :finder_sql,
-      :counter_sql, :before_add, :after_add, :before_remove, :after_remove
-    ]
+    def valid_options
+      super + [:table_name, :before_add,
+               :after_add, :before_remove, :after_remove, :extend]
+    end
 
     attr_reader :block_extension
 
-    def self.build(model, name, options, &extension)
-      new(model, name, options, &extension).build
-    end
-
-    def initialize(model, name, options, &extension)
-      super(model, name, options)
-      @block_extension = extension
+    def initialize(model, name, scope, options)
+      super
+      @mod = nil
+      if block_given?
+        @mod = Module.new(&Proc.new)
+        @scope = wrap_scope @scope, @mod
+      end
     end
 
-    def build
-      wrap_block_extension
-      reflection = super
-      CALLBACKS.each { |callback_name| define_callback(callback_name) }
-      reflection
+    def self.define_callbacks(model, reflection)
+      super
+      name    = reflection.name
+      options = reflection.options
+      CALLBACKS.each { |callback_name|
+        define_callback(model, callback_name, name, options)
+      }
     end
 
-    def writable?
-      true
+    def define_extensions(model)
+      if @mod
+        extension_module_name = "#{model.name.demodulize}#{name.to_s.camelize}AssociationExtension"
+        model.parent.const_set(extension_module_name, @mod)
+      end
     end
 
-    private
-
-      def wrap_block_extension
-        options[:extend] = Array.wrap(options[:extend])
-
-        if block_extension
-          silence_warnings do
-            model.parent.const_set(extension_module_name, Module.new(&block_extension))
-          end
-          options[:extend].push("#{model.parent}::#{extension_module_name}".constantize)
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
+
+      # TODO : why do i need method_defined? I think its because of the inheritance chain
+      model.class_attribute full_callback_name unless model.method_defined?(full_callback_name)
+      callbacks = Array(options[callback_name.to_sym]).map do |callback|
+        case callback
+        when Symbol
+          ->(method, owner, record) { owner.send(callback, record) }
+        when Proc
+          ->(method, owner, record) { callback.call(owner, record) }
+        else
+          ->(method, owner, record) { callback.send(method, owner, record) }
         end
       end
+      model.send "#{full_callback_name}=", callbacks
+    end
 
-      def extension_module_name
-        @extension_module_name ||= "#{model.to_s.demodulize}#{name.to_s.camelize}AssociationExtension"
-      end
-
-      def define_callback(callback_name)
-        full_callback_name = "#{callback_name}_for_#{name}"
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(mixin, name)
+      super
 
-        # TODO : why do i need method_defined? I think its because of the inheritance chain
-        model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
-        model.send("#{full_callback_name}=", Array.wrap(options[callback_name.to_sym]))
-      end
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids
+          association(:#{name}).ids_reader
+        end
+      CODE
+    end
 
-      def define_readers
-        super
+    def self.define_writers(mixin, name)
+      super
 
-        name = self.name
-        model.redefine_method("#{name.to_s.singularize}_ids") do
-          association(name).ids_reader
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name.to_s.singularize}_ids=(ids)
+          association(:#{name}).ids_writer(ids)
         end
-      end
+      CODE
+    end
 
-      def define_writers
-        super
+    private
 
-        name = self.name
-        model.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
-          association(name).ids_writer(ids)
+    def wrap_scope(scope, mod)
+      if scope
+        if scope.arity > 0
+          proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        else
+          proc { instance_exec(&scope).extending(mod) }
         end
+      else
+        proc { extending(mod) }
       end
+    end
   end
 end

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
-        model.send(:define_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
-        model.send(:define_method, dependency_method_name) do
-          association(name).delete_all_on_destroy
-        end
-      end
-
-      def define_nullify_dependency_method
-        name = self.name
-        model.send(:define_method, dependency_method_name) do
-          send(name).delete_all
-        end
-      end
-
-      def define_restrict_dependency_method
-        name = self.name
-        model.send(:define_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,63 +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
-        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-          def #{dependency_method_name}
-            association(#{name.to_sym.inspect}).delete
-          end
-        eoruby
-      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
-        model.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