activerecord 4.0.13 → 4.1.0.beta1

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

@@ -1,3 +1,5 @@
+# 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
@@ -6,67 +8,57 @@ module ActiveRecord::Associations::Builder
     CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
 
     def valid_options
-      super + [:table_name, :finder_sql, :counter_sql, :before_add,
+      super + [:table_name, :before_add,
                :after_add, :before_remove, :after_remove, :extend]
     end
 
-    attr_reader :block_extension, :extension_module
-
-    def initialize(*args, &extension)
-      super(*args)
-      @block_extension = extension
-    end
+    attr_reader :block_extension
 
-    def build
-      show_deprecation_warnings
-      wrap_block_extension
-      reflection = super
-      CALLBACKS.each { |callback_name| define_callback(callback_name) }
-      reflection
+    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 writable?
-      true
+    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 show_deprecation_warnings
-      [:finder_sql, :counter_sql].each do |name|
-        if options.include? name
-          ActiveSupport::Deprecation.warn("The :#{name} association option is deprecated. Please find an alternative (such as using scopes).")
-        end
+    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
 
-    def wrap_block_extension
-      if block_extension
-        @extension_module = mod = Module.new(&block_extension)
-        silence_warnings do
-          model.parent.const_set(extension_module_name, mod)
-        end
-
-        prev_scope = @scope
+    def self.define_callback(model, callback_name, name, options)
+      full_callback_name = "#{callback_name}_for_#{name}"
 
-        if prev_scope
-          @scope = proc { |owner| instance_exec(owner, &prev_scope).extending(mod) }
+      # 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
-          @scope = proc { extending(mod) }
+          ->(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.name.demodulize}#{name.to_s.camelize}AssociationExtension"
-    end
-
-    def define_callback(callback_name)
-      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.to_sym unless model.method_defined?(full_callback_name)
-      model.send("#{full_callback_name}=", Array(options[callback_name.to_sym]))
-    end
-
-    def define_readers
+    # Defines the setter and getter methods for the collection_singular_ids.
+    def self.define_readers(mixin, name)
       super
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
@@ -76,7 +68,7 @@ module ActiveRecord::Associations::Builder
       CODE
     end
 
-    def define_writers
+    def self.define_writers(mixin, name)
       super
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
@@ -85,5 +77,15 @@ module ActiveRecord::Associations::Builder
         end
       CODE
     end
+
+    private
+
+    def wrap_scope(scope, mod)
+      if scope
+        proc { |owner| instance_exec(owner, &scope).extending(mod) }
+      else
+        proc { extending(mod) }
+      end
+    end
   end
 end

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

@@ -1,39 +1,121 @@
 module ActiveRecord::Associations::Builder
-  class HasAndBelongsToMany < CollectionAssociation #:nodoc:
-    def macro
-      :has_and_belongs_to_many
-    end
+  class HasAndBelongsToMany # :nodoc:
+    class JoinTableResolver
+      KnownTable = Struct.new :join_table
+
+      class KnownClass
+        def initialize(lhs_class, rhs_class_name)
+          @lhs_class      = lhs_class
+          @rhs_class_name = rhs_class_name
+          @join_table     = nil
+        end
+
+        def join_table
+          @join_table ||= [@lhs_class.table_name, klass.table_name].sort.join("\0").gsub(/^(.*_)(.+)\0\1(.+)/, '\1\2_\3').gsub("\0", "_")
+        end
+
+        private
+        def klass; @rhs_class_name.constantize; end
+      end
 
-    def valid_options
-      super + [:join_table, :association_foreign_key, :delete_sql, :insert_sql]
+      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
+      end
     end
 
-    def build
-      reflection = super
-      define_destroy_hook
-      reflection
+    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 show_deprecation_warnings
-      super
+    def through_model
+      habtm = JoinTableResolver.build lhs_model, association_name, options
+
+      join_model = Class.new(ActiveRecord::Base) {
+        class << self;
+          attr_accessor :class_resolver
+          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
+
+        def self.compute_type(class_name)
+          class_resolver.compute_type class_name
+        end
 
-      [:delete_sql, :insert_sql].each do |name|
-        if options.include? name
-          ActiveSupport::Deprecation.warn("The :#{name} association option is deprecated. Please find an alternative (such as using has_many :through).")
+        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
+
+      }
+
+      join_model.name                = "HABTM_#{association_name.to_s.camelize}"
+      join_model.table_name_resolver = habtm
+      join_model.class_resolver      = lhs_model
+
+      join_model.add_left_association :left_side, 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] = join_model
+      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 define_destroy_hook
-      name = self.name
-      model.send(:include, Module.new {
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def destroy_associations
-            association(:#{name}).delete_all
-            super
-          end
-        RUBY
-      })
+    def belongs_to_options(options)
+      rhs_options = {}
+
+      if options.key? :class_name
+        rhs_options[:foreign_key] = options[:class_name].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

@@ -8,8 +8,8 @@ module ActiveRecord::Associations::Builder
       super + [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :counter_cache]
     end
 
-    def valid_dependent_options
-      [:destroy, :delete_all, :nullify, :restrict, :restrict_with_error, :restrict_with_exception]
+    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

@@ -10,16 +10,14 @@ module ActiveRecord::Associations::Builder
       valid
     end
 
-    def constructable?
-      !options[:through]
+    def self.valid_dependent_options
+      [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
     end
 
-    def configure_dependency
-      super unless options[:through]
-    end
+    private
 
-    def valid_dependent_options
-      [:destroy, :delete, :nullify, :restrict, :restrict_with_error, :restrict_with_exception]
+    def self.add_before_destroy_callbacks(model, reflection)
+      super unless reflection.options[:through]
     end
   end
 end

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

@@ -1,19 +1,18 @@
+# This class is inherited by the has_one and belongs_to association classes
+
 module ActiveRecord::Associations::Builder
   class SingularAssociation < Association #:nodoc:
     def valid_options
       super + [:remote, :dependent, :primary_key, :inverse_of]
     end
 
-    def constructable?
-      true
-    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
 
-    def define_constructors
+    # 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)

data/lib/active_record/associations/collection_association.rb

@@ -7,7 +7,6 @@ module ActiveRecord
     # collections. See the class hierarchy in AssociationProxy.
     #
     #   CollectionAssociation:
-    #     HasAndBelongsToManyAssociation => has_and_belongs_to_many
     #     HasManyAssociation => has_many
     #       HasManyThroughAssociation + ThroughAssociation => has_many :through
     #
@@ -34,13 +33,7 @@ module ActiveRecord
           reload
         end
 
-        if owner.new_record?
-          # Cache the proxy separately before the owner has an id
-          # or else a post-save proxy will still lack the id
-          @new_record_proxy ||= CollectionProxy.new(klass, self)
-        else
-          @proxy ||= CollectionProxy.new(klass, self)
-        end
+        @proxy ||= CollectionProxy.create(klass, self)
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
@@ -50,7 +43,7 @@ module ActiveRecord
 
       # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
       def ids_reader
-        if loaded? || options[:finder_sql]
+        if loaded?
           load_target.map do |record|
             record.send(reflection.association_primary_key)
           end
@@ -85,12 +78,9 @@ module ActiveRecord
         if block_given?
           load_target.find(*args) { |*block_args| yield(*block_args) }
         else
-          if options[:finder_sql]
-            find_by_scan(*args)
-          elsif options[:inverse_of] && loaded?
+          if options[:inverse_of] && loaded?
             args_flatten = args.flatten
             raise RecordNotFound, "Couldn't find #{scope.klass.name} without an ID" if args_flatten.blank?
-
             result = find_by_scan(*args)
 
             result_size = Array(result).size
@@ -124,11 +114,11 @@ module ActiveRecord
       end
 
       def create(attributes = {}, &block)
-        _create_record(attributes, &block)
+        create_record(attributes, &block)
       end
 
       def create!(attributes = {}, &block)
-        _create_record(attributes, true, &block)
+        create_record(attributes, true, &block)
       end
 
       # Add +records+ to this association. Returns +self+ so method calls may
@@ -159,11 +149,33 @@ module ActiveRecord
         end
       end
 
-      # Remove all records from this association.
+      # Removes all records from the association without calling callbacks
+      # on the associated records. It honors the `:dependent` option. However
+      # if the `:dependent` value is `:destroy` then in that case the `:delete_all`
+      # deletion strategy for the association is applied.
+      #
+      # You can force a particular deletion strategy by passing a parameter.
+      #
+      # Example:
+      #
+      # @author.books.delete_all(:nullify)
+      # @author.books.delete_all(:delete_all)
       #
       # See delete for more info.
-      def delete_all
-        delete(:all).tap do
+      def delete_all(dependent = nil)
+        if dependent.present? && ![:nullify, :delete_all].include?(dependent)
+          raise ArgumentError, "Valid values are :nullify or :delete_all"
+        end
+
+        dependent = if dependent.present?
+                      dependent
+                    elsif options[:dependent] == :destroy
+                      :delete_all
+                    else
+                      options[:dependent]
+                    end
+
+        delete(:all, dependent: dependent).tap do
           reset
           loaded!
         end
@@ -179,36 +191,29 @@ module ActiveRecord
         end
       end
 
-      # Count all records using SQL. If the +:counter_sql+ or +:finder_sql+ option is set for the
-      # association, it will be used for the query. Otherwise, construct options and pass them with
+      # Count all records using SQL.  Construct options and pass them with
       # scope to the target class's +count+.
       def count(column_name = nil, count_options = {})
+        # TODO: Remove count_options argument as soon we remove support to
+        # activerecord-deprecated_finders.
         column_name, count_options = nil, column_name if column_name.is_a?(Hash)
 
-        if options[:counter_sql] || options[:finder_sql]
-          unless count_options.blank?
-            raise ArgumentError, "If finder_sql/counter_sql is used then options cannot be passed"
-          end
-
-          reflection.klass.count_by_sql(custom_counter_sql)
-        else
-          relation = scope
-          if association_scope.distinct_value
-            # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
-            column_name ||= reflection.klass.primary_key
-            relation = relation.distinct
-          end
+        relation = scope
+        if association_scope.distinct_value
+          # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
+          column_name ||= reflection.klass.primary_key
+          relation = relation.distinct
+        end
 
-          value = relation.count(column_name, count_options)
+        value = relation.count(column_name)
 
-          limit  = options[:limit]
-          offset = options[:offset]
+        limit  = options[:limit]
+        offset = options[:offset]
 
-          if limit || offset
-            [ [value - offset.to_i, 0].max, limit.to_i ].min
-          else
-            value
-          end
+        if limit || offset
+          [ [value - offset.to_i, 0].max, limit.to_i ].min
+        else
+          value
         end
       end
 
@@ -220,19 +225,11 @@ module ActiveRecord
       # are actually removed from the database, that depends precisely on
       # +delete_records+. They are in any case removed from the collection.
       def delete(*records)
-        dependent = options[:dependent]
+        _options = records.extract_options!
+        dependent = _options[:dependent] || options[:dependent]
 
         if records.first == :all
-
-          if dependent && dependent == :destroy
-            message = 'In Rails 4.1 delete_all on associations would not fire callbacks. ' \
-                      'It means if the :dependent option is :destroy then the associated ' \
-                      'records would be deleted without loading and invoking callbacks.'
-
-            ActiveRecord::Base.logger ? ActiveRecord::Base.logger.warn(message) : $stderr.puts(message)
-          end
-
-          if (loaded? || dependent == :destroy) && dependent != :delete_all
+          if loaded? || dependent == :destroy
             delete_or_destroy(load_target, dependent)
           else
             delete_records(:all, dependent)
@@ -243,11 +240,11 @@ module ActiveRecord
         end
       end
 
-      # Destroy +records+ and remove them from this association calling
-      # +before_remove+ and +after_remove+ callbacks.
+      # Deletes the +records+ and removes them from this association calling
+      # +before_remove+ , +after_remove+ , +before_destroy+ and +after_destroy+ callbacks.
       #
-      # Note that this method will _always_ remove records from the database
-      # ignoring the +:dependent+ option.
+      # Note that this method removes records from the database ignoring the
+      # +:dependent+ option.
       def destroy(*records)
         records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || record.kind_of?(String) }
         delete_or_destroy(records, :destroy)
@@ -291,14 +288,14 @@ module ActiveRecord
 
       # Returns true if the collection is empty.
       #
-      # If the collection has been loaded or the <tt>:counter_sql</tt> option
-      # is provided, it is equivalent to <tt>collection.size.zero?</tt>. If the
+      # If the collection has been loaded
+      # it is equivalent to <tt>collection.size.zero?</tt>. If the
       # collection has not been loaded, it is equivalent to
       # <tt>collection.exists?</tt>. If the collection has not already been
       # loaded and you are going to fetch the records anyway it is better to
       # check <tt>collection.length.zero?</tt>.
       def empty?
-        if loaded? || options[:counter_sql]
+        if loaded?
           size.zero?
         else
           @target.blank? && !scope.exists?
@@ -351,7 +348,6 @@ module ActiveRecord
           if record.new_record?
             include_in_memory?(record)
           else
-            load_target if options[:finder_sql]
             loaded? ? target.include?(record) : scope.exists?(record)
           end
         else
@@ -368,8 +364,8 @@ module ActiveRecord
         target
       end
 
-      def add_to_target(record)
-        callback(:before_add, record)
+      def add_to_target(record, skip_callbacks = false)
+        callback(:before_add, record) unless skip_callbacks
         yield(record) if block_given?
 
         if association_scope.distinct_value && index = @target.index(record)
@@ -378,7 +374,7 @@ module ActiveRecord
           @target << record
         end
 
-        callback(:after_add, record)
+        callback(:after_add, record) unless skip_callbacks
         set_inverse_instance(record)
 
         record
@@ -396,31 +392,8 @@ module ActiveRecord
 
       private
 
-        def custom_counter_sql
-          if options[:counter_sql]
-            interpolate(options[:counter_sql])
-          else
-            # replace the SELECT clause with COUNT(SELECTS), preserving any hints within /* ... */
-            interpolate(options[:finder_sql]).sub(/SELECT\b(\/\*.*?\*\/ )?(.*)\bFROM\b/im) do
-              count_with = $2.to_s
-              count_with = '*' if count_with.blank? || count_with =~ /,/ || count_with =~ /\.\*/
-              "SELECT #{$1}COUNT(#{count_with}) FROM"
-            end
-          end
-        end
-
-        def custom_finder_sql
-          interpolate(options[:finder_sql])
-        end
-
         def find_target
-          records =
-            if options[:finder_sql]
-              reflection.klass.find_by_sql(custom_finder_sql)
-            else
-              scope.to_a
-            end
-
+          records = scope.to_a
           records.each { |record| set_inverse_instance(record) }
           records
         end
@@ -455,13 +428,13 @@ module ActiveRecord
           persisted + memory
         end
 
-        def _create_record(attributes, raise = false, &block)
+        def create_record(attributes, raise = false, &block)
           unless owner.persisted?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
           end
 
           if attributes.is_a?(Array)
-            attributes.collect { |attr| _create_record(attr, raise, &block) }
+            attributes.collect { |attr| create_record(attr, raise, &block) }
           else
             transaction do
               add_to_target(build_record(attributes)) do |record|
@@ -535,20 +508,13 @@ module ActiveRecord
 
         def callback(method, record)
           callbacks_for(method).each do |callback|
-            case callback
-            when Symbol
-              owner.send(callback, record)
-            when Proc
-              callback.call(owner, record)
-            else
-              callback.send(method, owner, record)
-            end
+            callback.call(method, owner, record)
           end
         end
 
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{reflection.name}"
-          owner.class.send(full_callback_name.to_sym) || []
+          owner.class.send(full_callback_name)
         end
 
         # Should we deal with assoc.first or assoc.last by issuing an independent query to
@@ -559,24 +525,21 @@ module ActiveRecord
         # Otherwise, go to the database only if none of the following are true:
         #   * target already loaded
         #   * owner is new record
-        #   * custom :finder_sql exists
         #   * target contains new or changed record(s)
-        #   * the first arg is an integer (which indicates the number of records to be returned)
         def fetch_first_or_last_using_find?(args)
           if args.first.is_a?(Hash)
             true
           else
             !(loaded? ||
               owner.new_record? ||
-              options[:finder_sql] ||
-              target.any? { |record| record.new_record? || record.changed? } ||
-              args.first.kind_of?(Integer))
+              target.any? { |record| record.new_record? || record.changed? })
           end
         end
 
         def include_in_memory?(record)
           if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-            owner.send(reflection.through_reflection.name).any? { |source|
+            assoc = owner.association(reflection.through_reflection.name)
+            assoc.reader.any? { |source|
               target = source.send(reflection.source_reflection.name)
               target.respond_to?(:include?) ? target.include?(record) : target == record
             } || target.include?(record)
@@ -585,7 +548,7 @@ module ActiveRecord
           end
         end
 
-        # If using a custom finder_sql or if the :inverse_of option has been
+        # If the :inverse_of option has been
         # specified, then #find scans the entire collection.
         def find_by_scan(*args)
           expects_array = args.first.kind_of?(Array)