activerecord 3.0.0.beta3 → 3.0.0.beta4

data/lib/active_record/railtie.rb

@@ -15,6 +15,12 @@ module ActiveRecord
     config.generators.orm :active_record, :migration => true,
                                           :timestamps => true
 
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::QueryCache"
+
+    config.app_middleware.insert_after "::ActionDispatch::Callbacks",
+      "ActiveRecord::ConnectionAdapters::ConnectionManagement"
+
     rake_tasks do
       load "active_record/railties/databases.rake"
     end
@@ -58,37 +64,25 @@ module ActiveRecord
       end
     end
 
-    # Setup database middleware after initializers have run
-    initializer "active_record.initialize_database_middleware", :after => "action_controller.set_configs" do |app|
-      middleware = app.config.middleware
-      if middleware.include?("ActiveRecord::SessionStore")
-        middleware.insert_before "ActiveRecord::SessionStore", ActiveRecord::ConnectionAdapters::ConnectionManagement
-        middleware.insert_before "ActiveRecord::SessionStore", ActiveRecord::QueryCache
-      else
-        middleware.use ActiveRecord::ConnectionAdapters::ConnectionManagement
-        middleware.use ActiveRecord::QueryCache
+    initializer "active_record.set_dispatch_hooks", :before => :set_clear_dependencies_hook do |app|
+      unless app.config.cache_classes
+        ActiveSupport.on_load(:active_record) do
+          ActionDispatch::Callbacks.after do
+            ActiveRecord::Base.reset_subclasses
+            ActiveRecord::Base.clear_reloadable_connections!
+          end
+        end
       end
     end
 
-    initializer "active_record.load_observers" do
-      ActiveSupport.on_load(:active_record) { instantiate_observers }
-
+    config.after_initialize do
       ActiveSupport.on_load(:active_record) do
+        instantiate_observers
+
         ActionDispatch::Callbacks.to_prepare(:activerecord_instantiate_observers) do
           ActiveRecord::Base.instantiate_observers
         end
       end
     end
-
-    initializer "active_record.set_dispatch_hooks", :before => :set_clear_dependencies_hook do |app|
-      ActiveSupport.on_load(:active_record) do
-        unless app.config.cache_classes
-          ActionDispatch::Callbacks.after do
-            ActiveRecord::Base.reset_subclasses
-            ActiveRecord::Base.clear_reloadable_connections!
-          end
-        end
-      end
-    end
   end
 end

data/lib/active_record/railties/databases.rake

@@ -258,8 +258,8 @@ namespace :db do
       base_dir = ENV['FIXTURES_PATH'] ? File.join(Rails.root, ENV['FIXTURES_PATH']) : File.join(Rails.root, 'test', 'fixtures')
       fixtures_dir = ENV['FIXTURES_DIR'] ? File.join(base_dir, ENV['FIXTURES_DIR']) : base_dir
 
-      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/).map {|f| File.join(fixtures_dir, f) } : Dir.glob(File.join(fixtures_dir, '*.{yml,csv}'))).each do |fixture_file|
-        Fixtures.create_fixtures(File.dirname(fixture_file), File.basename(fixture_file, '.*'))
+      (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/).map {|f| File.join(fixtures_dir, f) } : Dir["#{fixtures_dir}/**/*.{yml,csv}"]).each do |fixture_file|
+        Fixtures.create_fixtures(fixtures_dir, fixture_file[(fixtures_dir.size + 1)..-5])
       end
     end
 
@@ -435,6 +435,7 @@ namespace :db do
     task :create => :environment do
       raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
       require 'rails/generators'
+      Rails::Generators.configure!
       require 'rails/generators/rails/session_migration/session_migration_generator'
       Rails::Generators::SessionMigrationGenerator.start [ ENV["MIGRATION"] || "add_sessions_table" ]
     end

data/lib/active_record/relation.rb

@@ -356,13 +356,16 @@ module ActiveRecord
     end
 
     def references_eager_loaded_tables?
-      joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.uniq
+      # always convert table names to downcase as in Oracle quoted table names are in uppercase
+      joined_tables = (tables_in_string(arel.joins(arel)) + [table.name, table.table_alias]).compact.map(&:downcase).uniq
       (tables_in_string(to_sql) - joined_tables).any?
     end
 
     def tables_in_string(string)
       return [] if string.blank?
-      string.scan(/([a-zA-Z_][\.\w]+).?\./).flatten.uniq
+      # always convert table names to downcase as in Oracle quoted table names are in uppercase
+      # ignore raw_sql_ that is used by Oracle adapter as alias for limit/offset subqueries
+      string.scan(/([a-zA-Z_][\.\w]+).?\./).flatten.map(&:downcase).uniq - ['raw_sql_']
     end
 
   end

data/lib/active_record/relation/batches.rb

@@ -71,7 +71,12 @@ module ActiveRecord
         yield records
 
         break if records.size < batch_size
-        records = relation.where(primary_key.gt(records.last.id)).all
+
+        if primary_key_offset = records.last.id
+          records = relation.where(primary_key.gt(primary_key_offset)).all
+        else
+          raise "Primary key not included in the custom select clause"
+        end
       end
     end
 

data/lib/active_record/relation/calculations.rb

@@ -45,9 +45,8 @@ module ActiveRecord
       calculate(:count, column_name, options)
     end
 
-    # Calculates the average value on a given column. The value is returned as
-    # a float, or +nil+ if there's no row. See +calculate+ for examples with
-    # options.
+    # Calculates the average value on a given column. Returns +nil+ if there's
+    # no row. See +calculate+ for examples with options.
     #
     #   Person.average('age') # => 35.8
     def average(column_name, options = {})
@@ -195,7 +194,7 @@ module ActiveRecord
 
       select_statement <<  ", #{group_field} AS #{group_alias}"
 
-      relation = select(select_statement).group(group)
+      relation = except(:group).select(select_statement).group(group)
 
       calculated_data = @klass.connection.select_all(relation.to_sql)
 
@@ -239,11 +238,15 @@ module ActiveRecord
     end
 
     def type_cast_calculated_value(value, column, operation = nil)
-      case operation
-        when 'count' then value.to_i
-        when 'sum'   then type_cast_using_column(value || '0', column)
-        when 'average'   then value && (value.is_a?(Fixnum) ? value.to_f : value).to_d
-        else type_cast_using_column(value, column)
+      if value.is_a?(String) || value.nil?
+        case operation
+          when 'count'   then value.to_i
+          when 'sum'     then type_cast_using_column(value || '0', column)
+          when 'average' then value.try(:to_d)
+          else type_cast_using_column(value, column)
+        end
+      else
+        value
       end
     end
 

data/lib/active_record/relation/finder_methods.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveRecord
   module FinderMethods
@@ -187,7 +188,6 @@ module ActiveRecord
     def construct_relation_for_association_calculations
       including = (@eager_load_values + @includes_values).uniq
       join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, including, arel.joins(arel))
-
       relation = except(:includes, :eager_load, :preload)
       apply_join_dependency(relation, join_dependency)
     end
@@ -234,20 +234,24 @@ module ActiveRecord
     end
 
     def find_or_instantiator_by_attributes(match, attributes, *args)
-      guard_protected_attributes = false
-
-      if args[0].is_a?(Hash)
-        guard_protected_attributes = true
-        attributes_for_create = args[0].with_indifferent_access
-        conditions = attributes_for_create.slice(*attributes).symbolize_keys
-      else
-        attributes_for_create = conditions = attributes.inject({}) {|h, a| h[a] = args[attributes.index(a)]; h}
+      protected_attributes_for_create, unprotected_attributes_for_create = {}, {}
+      args.each_with_index do |arg, i|
+        if arg.is_a?(Hash)
+          protected_attributes_for_create = args[i].with_indifferent_access
+        else
+          unprotected_attributes_for_create[attributes[i]] = args[i]
+        end
       end
 
+      conditions = (protected_attributes_for_create.merge(unprotected_attributes_for_create)).slice(*attributes).symbolize_keys
+
       record = where(conditions).first
 
       unless record
-        record = @klass.new { |r| r.send(:attributes=, attributes_for_create, guard_protected_attributes) }
+        record = @klass.new do |r|
+          r.send(:attributes=, protected_attributes_for_create, true) unless protected_attributes_for_create.empty?
+          r.send(:attributes=, unprotected_attributes_for_create, false) unless unprotected_attributes_for_create.empty?
+        end
         yield(record) if block_given?
         record.save if match.instantiator == :create
       end

data/lib/active_record/relation/query_methods.rb

@@ -9,8 +9,8 @@ module ActiveRecord
       (ActiveRecord::Relation::ASSOCIATION_METHODS + ActiveRecord::Relation::MULTI_VALUE_METHODS).each do |query_method|
         attr_accessor :"#{query_method}_values"
 
-        next if [:where, :having].include?(query_method)
-        class_eval <<-CEVAL, __FILE__
+        next if [:where, :having, :select].include?(query_method)
+        class_eval <<-CEVAL, __FILE__, __LINE__ + 1
           def #{query_method}(*args, &block)
             new_relation = clone
             new_relation.send(:apply_modules, Module.new(&block)) if block_given?
@@ -21,8 +21,21 @@ module ActiveRecord
         CEVAL
       end
 
+      class_eval <<-CEVAL, __FILE__, __LINE__ + 1
+        def select(*args, &block)
+          if block_given?
+            to_a.select(&block)
+          else
+            new_relation = clone
+            value = Array.wrap(args.flatten).reject {|x| x.blank? }
+            new_relation.select_values += value if value.present?
+            new_relation
+          end
+        end
+      CEVAL
+
       [:where, :having].each do |query_method|
-        class_eval <<-CEVAL, __FILE__
+        class_eval <<-CEVAL, __FILE__, __LINE__ + 1
           def #{query_method}(*args, &block)
             new_relation = clone
             new_relation.send(:apply_modules, Module.new(&block)) if block_given?
@@ -36,7 +49,7 @@ module ActiveRecord
       ActiveRecord::Relation::SINGLE_VALUE_METHODS.each do |query_method|
         attr_accessor :"#{query_method}_value"
 
-        class_eval <<-CEVAL, __FILE__
+        class_eval <<-CEVAL, __FILE__, __LINE__ + 1
           def #{query_method}(value = true, &block)
             new_relation = clone
             new_relation.send(:apply_modules, Module.new(&block)) if block_given?
@@ -80,6 +93,26 @@ module ActiveRecord
       @arel ||= build_arel
     end
 
+    def custom_join_sql(*joins)
+      arel = table
+      joins.each do |join|
+        next if join.blank?
+
+        @implicit_readonly = true
+
+        case join
+        when Hash, Array, Symbol
+          if array_of_strings?(join)
+            join_string = join.join(' ')
+            arel = arel.join(join_string)
+          end
+        else
+          arel = arel.join(join)
+        end
+      end
+      arel.joins(arel)
+    end
+
     def build_arel
       arel = table
 
@@ -88,50 +121,41 @@ module ActiveRecord
 
       joins = @joins_values.map {|j| j.respond_to?(:strip) ? j.strip : j}.uniq
 
-      # Build association joins first
       joins.each do |join|
         association_joins << join if [Hash, Array, Symbol].include?(join.class) && !array_of_strings?(join)
       end
 
-      if association_joins.any?
-        join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins.uniq, nil)
-        to_join = []
+      stashed_association_joins = joins.select {|j| j.is_a?(ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation)}
 
-        join_dependency.join_associations.each do |association|
-          if (association_relation = association.relation).is_a?(Array)
-            to_join << [association_relation.first, association.association_join.first]
-            to_join << [association_relation.last, association.association_join.last]
-          else
-            to_join << [association_relation, association.association_join]
-          end
-        end
+      non_association_joins = (joins - association_joins - stashed_association_joins).reject {|j| j.blank?}
+      custom_joins = custom_join_sql(*non_association_joins)
 
-        to_join.each do |tj|
-          unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] }
-            joined_associations << tj
-            arel = arel.join(tj[0]).on(*tj[1])
-          end
-        end
-      end
+      join_dependency = ActiveRecord::Associations::ClassMethods::JoinDependency.new(@klass, association_joins, custom_joins)
 
-      joins.each do |join|
-        next if join.blank?
+      join_dependency.graft(*stashed_association_joins)
 
-        @implicit_readonly = true
+      @implicit_readonly = true unless association_joins.empty? && stashed_association_joins.empty?
 
-        case join
-        when Relation::JoinOperation
-          arel = arel.join(join.relation, join.join_class).on(*join.on)
-        when Hash, Array, Symbol
-          if array_of_strings?(join)
-            join_string = join.join(' ')
-            arel = arel.join(join_string)
-          end
+      to_join = []
+
+      join_dependency.join_associations.each do |association|
+        if (association_relation = association.relation).is_a?(Array)
+          to_join << [association_relation.first, association.join_class, association.association_join.first]
+          to_join << [association_relation.last, association.join_class, association.association_join.last]
         else
-          arel = arel.join(join)
+          to_join << [association_relation, association.join_class, association.association_join]
+        end
+      end
+
+      to_join.each do |tj|
+        unless joined_associations.detect {|ja| ja[0] == tj[0] && ja[1] == tj[1] && ja[2] == tj[2] }
+          joined_associations << tj
+          arel = arel.join(tj[0], tj[1]).on(*tj[2])
         end
       end
 
+      arel = arel.join(custom_joins)
+
       @where_values.uniq.each do |where|
         next if where.blank?
 
@@ -151,13 +175,9 @@ module ActiveRecord
       arel = arel.take(@limit_value) if @limit_value.present?
       arel = arel.skip(@offset_value) if @offset_value.present?
 
-      @group_values.uniq.each do |g|
-        arel = arel.group(g) if g.present?
-      end
+      arel = arel.group(*@group_values.uniq.select{|g| g.present?})
 
-      @order_values.uniq.each do |o|
-        arel = arel.order(Arel::SqlLiteral.new(o.to_s)) if o.present?
-      end
+      arel = arel.order(*@order_values.uniq.select{|o| o.present?}.map(&:to_s))
 
       selects = @select_values.uniq
 
@@ -187,15 +207,13 @@ module ActiveRecord
     def build_where(*args)
       return if args.blank?
 
-      builder = PredicateBuilder.new(table.engine)
-
       opts = args.first
       case opts
       when String, Array
         @klass.send(:sanitize_sql, args.size > 1 ? args : opts)
       when Hash
         attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
-        builder.build_from_hash(attributes, table)
+        PredicateBuilder.new(table.engine).build_from_hash(attributes, table)
       else
         opts
       end

data/lib/active_record/relation/spawn_methods.rb

@@ -80,10 +80,15 @@ module ActiveRecord
 
       options.assert_valid_keys(VALID_FIND_OPTIONS)
 
-      [:joins, :select, :group, :having, :order, :limit, :offset, :from, :lock, :readonly].each do |finder|
+      [:joins, :select, :group, :having, :limit, :offset, :from, :lock, :readonly].each do |finder|
         relation = relation.send(finder, options[finder]) if options.has_key?(finder)
       end
 
+      # Give precedence to newly-applied orders and groups to play nicely with with_scope
+      [:group, :order].each do |finder|
+        relation.send("#{finder}_values=", Array.wrap(options[finder]) + relation.send("#{finder}_values")) if options.has_key?(finder)
+      end
+
       relation = relation.where(options[:conditions]) if options.has_key?(:conditions)
       relation = relation.includes(options[:include]) if options.has_key?(:include)
       relation = relation.extending(options[:extend]) if options.has_key?(:extend)

data/lib/active_record/schema_dumper.rb

@@ -178,6 +178,9 @@ HEADER
             statment_parts << (':name => ' + index.name.inspect)
             statment_parts << ':unique => true' if index.unique
 
+            index_lengths = index.lengths.compact if index.lengths.is_a?(Array)
+            statment_parts << (':length => ' + Hash[*index.columns.zip(index.lengths).flatten].inspect) if index_lengths.present?
+
             '  ' + statment_parts.join(', ')
           end
 

data/lib/active_record/serializers/xml_serializer.rb

@@ -182,27 +182,31 @@ module ActiveRecord #:nodoc:
       options[:except] |= Array.wrap(@serializable.class.inheritance_column)
     end
 
-    def serializable_attributes
-      serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
+    def add_extra_behavior
+      add_includes
     end
 
-    def serializable_method_attributes
-      Array.wrap(options[:methods]).inject([]) do |method_attributes, name|
-        method_attributes << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
-        method_attributes
+    def add_includes
+      procs = options.delete(:procs)
+      @serializable.send(:serializable_add_includes, options) do |association, records, opts|
+        add_associations(association, records, opts)
       end
+      options[:procs] = procs
     end
 
+    # TODO This can likely be cleaned up to simple use ActiveSupport::XmlMini.to_tag as well.
     def add_associations(association, records, opts)
+      association_name = association.to_s.singularize
+      merged_options   = options.merge(opts).merge!(:root => association_name, :skip_instruct => true)
+
       if records.is_a?(Enumerable)
-        tag = reformat_name(association.to_s)
-        type = options[:skip_types] ? {} : {:type => "array"}
+        tag  = ActiveSupport::XmlMini.rename_key(association.to_s, options)
+        type = options[:skip_types] ? { } : {:type => "array"}
 
         if records.empty?
-          builder.tag!(tag, type)
+          @builder.tag!(tag, type)
         else
-          builder.tag!(tag, type) do
-            association_name = association.to_s.singularize
+          @builder.tag!(tag, type) do
             records.each do |record|
               if options[:skip_types]
                 record_type = {}
@@ -211,60 +215,30 @@ module ActiveRecord #:nodoc:
                 record_type = {:type => record_class}
               end
 
-              record.to_xml opts.merge(:root => association_name).merge(record_type)
+              record.to_xml merged_options.merge(record_type)
             end
           end
         end
-      else
-        if record = @serializable.send(association)
-          record.to_xml(opts.merge(:root => association))
-        end
-      end
-    end
-
-    def serialize
-      args = [root]
-      if options[:namespace]
-        args << {:xmlns=>options[:namespace]}
-      end
-
-      if options[:type]
-        args << {:type=>options[:type]}
-      end
-
-      builder.tag!(*args) do
-        add_attributes
-        procs = options.delete(:procs)
-        @serializable.send(:serializable_add_includes, options) { |association, records, opts|
-          add_associations(association, records, opts)
-        }
-        options[:procs] = procs
-        add_procs
-        yield builder if block_given?
+      elsif record = @serializable.send(association)
+        record.to_xml(merged_options)
       end
     end
 
     class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
-      protected
-        def compute_type
-          type = @serializable.class.serialized_attributes.has_key?(name) ? :yaml : @serializable.class.columns_hash[name].type
+      def compute_type
+        type = @serializable.class.serialized_attributes.has_key?(name) ?
+          super : @serializable.class.columns_hash[name].type
 
-          case type
-            when :text
-              :string
-            when :time
-              :datetime
-            else
-              type
-          end
-        end
-    end
-
-    class MethodAttribute < Attribute #:nodoc:
-      protected
-        def compute_type
-          Hash::XML_TYPE_NAMES[@serializable.send(name).class.name] || :string
+        case type
+        when :text
+          :string
+        when :time
+          :datetime
+        else
+          type
         end
+      end
+      protected :compute_type
     end
   end
 end