activerecord 3.0.0.rc → 3.0.0.rc2

data/lib/active_record/relation/finder_methods.rb

@@ -21,23 +21,28 @@ module ActiveRecord
     #
     # ==== Parameters
     #
-    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>, or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
+    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>,
+    #   or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
     # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
     # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
-    # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
+    # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a
+    #   <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
     # * <tt>:limit</tt> - An integer determining the limit on the number of rows that should be returned.
-    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5, it would skip rows 0 through 4.
+    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5,
+    #   it would skip rows 0 through 4.
     # * <tt>:joins</tt> - Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed),
-    #   named associations in the same form used for the <tt>:include</tt> option, which will perform an <tt>INNER JOIN</tt> on the associated table(s),
+    #   named associations in the same form used for the <tt>:include</tt> option, which will perform an
+    #   <tt>INNER JOIN</tt> on the associated table(s),
     #   or an array containing a mixture of both strings and named associations.
-    #   If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+    #   If the value is a string, then the records will be returned read-only since they will
+    #   have attributes that do not correspond to the table's columns.
     #   Pass <tt>:readonly => false</tt> to override.
     # * <tt>:include</tt> - Names associations that should be loaded alongside. The symbols named refer
     #   to already defined associations. See eager loading under Associations.
-    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you, for example, want to do a join but not
-    #   include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
-    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
-    #   of a database view).
+    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you,
+    #   for example, want to do a join but not include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
+    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed
+    #   to an alternate table name (or even the name of a database view).
     # * <tt>:readonly</tt> - Mark the returned records read-only so they cannot be saved or updated.
     # * <tt>:lock</tt> - An SQL fragment like "FOR UPDATE" or "LOCK IN SHARE MODE".
     #   <tt>:lock => true</tt> gives connection's default exclusive lock, usually "FOR UPDATE".
@@ -164,6 +169,8 @@ module ActiveRecord
     #   Person.exists?(['name LIKE ?', "%#{query}%"])
     #   Person.exists?
     def exists?(id = nil)
+      id = id.id if ActiveRecord::Base === id
+
       case id
       when Array, Hash
         where(id).exists?
@@ -279,10 +286,12 @@ module ActiveRecord
     end
 
     def find_one(id)
+      id = id.id if ActiveRecord::Base === id
+
       record = where(primary_key.eq(id)).first
 
       unless record
-        conditions = arel.send(:where_clauses).join(', ')
+        conditions = arel.wheres.map { |x| x.value }.join(', ')
         conditions = " [WHERE #{conditions}]" if conditions.present?
         raise RecordNotFound, "Couldn't find #{@klass.name} with ID=#{id}#{conditions}"
       end
@@ -308,7 +317,7 @@ module ActiveRecord
       if result.size == expected_size
         result
       else
-        conditions = arel.send(:where_clauses).join(', ')
+        conditions = arel.wheres.map { |x| x.value }.join(', ')
         conditions = " [WHERE #{conditions}]" if conditions.present?
 
         error = "Couldn't find all #{@klass.name.pluralize} with IDs "
@@ -339,7 +348,7 @@ module ActiveRecord
     end
 
     def using_limitable_reflections?(reflections)
-      reflections.none?(&:collection?)
+      reflections.none? { |r| r.collection? }
     end
 
   end

data/lib/active_record/relation/query_methods.rb

@@ -11,7 +11,7 @@ module ActiveRecord
 
     def includes(*args)
       args.reject! { |a| a.blank? }
-      clone.tap {|r| r.includes_values += args if args.present? }
+      clone.tap {|r| r.includes_values = (r.includes_values + args).flatten.uniq if args.present? }
     end
 
     def eager_load(*args)
@@ -31,7 +31,7 @@ module ActiveRecord
     end
 
     def group(*args)
-      clone.tap {|r| r.group_values += args if args.present? }
+      clone.tap {|r| r.group_values += args.flatten if args.present? }
     end
 
     def order(*args)
@@ -47,9 +47,11 @@ module ActiveRecord
       clone.tap {|r| r.joins_values += args if args.present? }
     end
 
-    def where(*args)
-      value = build_where(*args)
-      clone.tap {|r| r.where_values += Array.wrap(value) if value.present? }
+    def where(opts, *rest)
+      value = build_where(opts, rest)
+      copy = clone
+      copy.where_values += Array.wrap(value) if value
+      copy
     end
 
     def having(*args)
@@ -58,7 +60,9 @@ module ActiveRecord
     end
 
     def limit(value = true)
-      clone.tap {|r| r.limit_value = value }
+      copy = clone
+      copy.limit_value = value
+      copy
     end
 
     def offset(value = true)
@@ -117,8 +121,10 @@ module ActiveRecord
         when Hash, Array, Symbol
           if array_of_strings?(join)
             join_string = join.join(' ')
-            arel = arel.join(join_string)
+            arel = arel.join(Arel::SqlLiteral.new(join_string))
           end
+        when String
+          arel = arel.join(Arel::SqlLiteral.new(join))
         else
           arel = arel.join(join)
         end
@@ -129,11 +135,9 @@ module ActiveRecord
     def build_arel
       arel = table
 
-      arel = build_joins(arel, @joins_values) if @joins_values.present?
-
-      @where_values.uniq.each do |where|
-        next if where.blank?
+      arel = build_joins(arel, @joins_values) unless @joins_values.empty?
 
+      (@where_values - ['']).uniq.each do |where|
         case where
         when Arel::SqlLiteral
           arel = arel.where(where)
@@ -143,36 +147,27 @@ module ActiveRecord
         end
       end
 
-      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) if @having_values.present?
+      arel = arel.having(*@having_values.uniq.select{|h| h.present?}) unless @having_values.empty?
 
-      arel = arel.take(@limit_value) if @limit_value.present?
-      arel = arel.skip(@offset_value) if @offset_value.present?
+      arel = arel.take(@limit_value) if @limit_value
+      arel = arel.skip(@offset_value) if @offset_value
 
-      arel = arel.group(*@group_values.uniq.select{|g| g.present?}) if @group_values.present?
+      arel = arel.group(*@group_values.uniq.select{|g| g.present?}) unless @group_values.empty?
 
-      arel = arel.order(*@order_values.uniq.select{|o| o.present?}) if @order_values.present?
+      arel = arel.order(*@order_values.uniq.select{|o| o.present?}) unless @order_values.empty?
 
       arel = build_select(arel, @select_values.uniq)
 
-      arel = arel.from(@from_value) if @from_value.present?
-
-      case @lock_value
-      when TrueClass
-        arel = arel.lock
-      when String
-        arel = arel.lock(@lock_value)
-      end if @lock_value.present?
+      arel = arel.from(@from_value) if @from_value
+      arel = arel.lock(@lock_value) if @lock_value
 
       arel
     end
 
-    def build_where(*args)
-      return if args.blank?
-
-      opts = args.first
+    def build_where(opts, other = [])
       case opts
       when String, Array
-        @klass.send(:sanitize_sql, args.size > 1 ? args : opts)
+        @klass.send(:sanitize_sql, other.empty? ? opts : ([opts] + other))
       when Hash
         attributes = @klass.send(:expand_hash_conditions_for_aggregates, opts)
         PredicateBuilder.new(table.engine).build_from_hash(attributes, table)
@@ -226,7 +221,7 @@ module ActiveRecord
     end
 
     def build_select(arel, selects)
-      if selects.present?
+      unless selects.empty?
         @implicit_readonly = false
         # TODO: fix this ugly hack, we should refactor the callers to get an ARel compatible array.
         # Before this change we were passing to ARel the last element only, and ARel is capable of handling an array
@@ -236,7 +231,7 @@ module ActiveRecord
           arel.project(selects.last)
         end
       else
-        arel.project(@klass.quoted_table_name + '.*')
+        arel.project(Arel::SqlLiteral.new(@klass.quoted_table_name + '.*'))
       end
     end
 

data/lib/active_record/relation/spawn_methods.rb

@@ -8,7 +8,13 @@ module ActiveRecord
 
       ((Relation::ASSOCIATION_METHODS + Relation::MULTI_VALUE_METHODS) - [:joins, :where]).each do |method|
         value = r.send(:"#{method}_values")
-        merged_relation.send(:"#{method}_values=", value) if value.present?
+        if value.present?
+          if method == :includes
+            merged_relation = merged_relation.includes(value)
+          else
+            merged_relation.send(:"#{method}_values=", value)
+          end
+        end
       end
 
       merged_relation = merged_relation.joins(r.joins_values)
@@ -16,8 +22,10 @@ module ActiveRecord
       merged_wheres = @where_values
 
       r.where_values.each do |w|
-        if w.is_a?(Arel::Predicates::Equality)
-          merged_wheres = merged_wheres.reject {|p| p.is_a?(Arel::Predicates::Equality) && p.operand1.name == w.operand1.name }
+        if w.respond_to?(:operator) && w.operator == :==
+          merged_wheres = merged_wheres.reject { |p|
+            p.respond_to?(:operator) && p.operator == :== && p.operand1.name == w.operand1.name
+          }
         end
 
         merged_wheres += [w]
@@ -80,10 +88,14 @@ module ActiveRecord
 
       options.assert_valid_keys(VALID_FIND_OPTIONS)
 
-      [:joins, :select, :group, :having, :limit, :offset, :from, :lock, :readonly].each do |finder|
-        relation = relation.send(finder, options[finder]) if options.has_key?(finder)
+      [:joins, :select, :group, :having, :limit, :offset, :from, :lock].each do |finder|
+        if value = options[finder]
+          relation = relation.send(finder, value)
+        end
       end
 
+      relation = relation.readonly(options[:readonly]) if options.key? :readonly
+
       # 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)

data/lib/active_record/schema.rb

@@ -2,7 +2,7 @@ require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Schema
-  # 
+  #
   # Allows programmers to programmatically define a schema in a portable
   # DSL. This means you can define tables, indexes, etc. without using SQL
   # directly, so your applications can more easily support multiple

data/lib/active_record/schema_dumper.rb

@@ -8,13 +8,13 @@ module ActiveRecord
   # output format (i.e., ActiveRecord::Schema).
   class SchemaDumper #:nodoc:
     private_class_method :new
-    
+
     ##
     # :singleton-method:
-    # A list of tables which should not be dumped to the schema. 
+    # A list of tables which should not be dumped to the schema.
     # Acceptable values are strings as well as regexp.
     # This setting is only used if ActiveRecord::Base.schema_format == :ruby
-    cattr_accessor :ignore_tables 
+    cattr_accessor :ignore_tables
     @@ignore_tables = []
 
     def self.dump(connection=ActiveRecord::Base.connection, stream=STDOUT)
@@ -41,11 +41,11 @@ module ActiveRecord
         define_params = @version ? ":version => #{@version}" : ""
 
         stream.puts <<HEADER
-# This file is auto-generated from the current state of the database. Instead 
+# This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.
 #
-# Note that this schema.rb definition is the authoritative source for your 
+# Note that this schema.rb definition is the authoritative source for your
 # database schema. If you need to create the application database on another
 # system, you should be using db:schema:load, not running all the migrations
 # from scratch. The latter is a flawed and unsustainable approach (the more migrations
@@ -71,7 +71,7 @@ HEADER
             else
               raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
             end
-          end 
+          end
           table(tbl, stream)
         end
       end
@@ -87,7 +87,7 @@ HEADER
           elsif @connection.respond_to?(:primary_key)
             pk = @connection.primary_key(table)
           end
-          
+
           tbl.print "  create_table #{table.inspect}"
           if columns.detect { |c| c.name == pk }
             if pk != 'id'
@@ -105,7 +105,7 @@ HEADER
             next if column.name == pk
             spec = {}
             spec[:name]      = column.name.inspect
-            
+
             # AR has an optimisation which handles zero-scale decimals as integers.  This
             # code ensures that the dumper still dumps the column as a decimal.
             spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
@@ -123,7 +123,7 @@ HEADER
           end.compact
 
           # find all migration keys used in this table
-          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map(&:keys).flatten
+          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map{ |k| k.keys }.flatten
 
           # figure out the lengths for each column based on above keys
           lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
@@ -148,7 +148,7 @@ HEADER
 
           tbl.puts "  end"
           tbl.puts
-          
+
           indexes(table, tbl)
 
           tbl.rewind
@@ -158,7 +158,7 @@ HEADER
           stream.puts "#   #{e.message}"
           stream.puts
         end
-        
+
         stream
       end
 
@@ -172,7 +172,7 @@ HEADER
           value.inspect
         end
       end
-      
+
       def indexes(table, stream)
         if (indexes = @connection.indexes(table)).any?
           add_index_statements = indexes.map do |index|

data/lib/active_record/serialization.rb

@@ -23,7 +23,7 @@ module ActiveRecord #:nodoc:
 
     private
       # Add associations specified via the <tt>:includes</tt> option.
-      # 
+      #
       # Expects a block that takes as arguments:
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized

data/lib/active_record/serializers/xml_serializer.rb

@@ -80,7 +80,7 @@ module ActiveRecord #:nodoc:
     # closure created by a Proc, to_xml can be used to add elements that normally fall
     # outside of the scope of the model -- for example, generating and appending URLs
     # associated with models.
-    # 
+    #
     #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
     #   firm.to_xml :procs => [ proc ]
     #

data/lib/active_record/session_store.rb

@@ -9,7 +9,7 @@ module ActiveRecord
   #   +id+ (numeric primary key),
   #   +session_id+ (text, or longtext if your session data exceeds 65K), and
   #   +data+ (text or longtext; careful if your session data exceeds 65KB).
-  # 
+  #
   # The +session_id+ column should always be indexed for speedy lookups.
   # Session data is marshaled to the +data+ column in Base64 format.
   # If the data you write is larger than the column's size limit,
@@ -59,17 +59,15 @@ module ActiveRecord
       end
 
       def drop_table!
-        connection.execute "DROP TABLE #{table_name}"
+        connection.drop_table table_name
       end
 
       def create_table!
-        connection.execute <<-end_sql
-          CREATE TABLE #{table_name} (
-            id #{connection.type_to_sql(:primary_key)},
-            #{connection.quote_column_name(session_id_column)} VARCHAR(255) UNIQUE,
-            #{connection.quote_column_name(data_column_name)} TEXT
-          )
-        end_sql
+        connection.create_table(table_name) do |t|
+          t.string session_id_column, :limit => 255
+          t.text data_column_name
+        end
+        connection.add_index table_name, session_id_column, :unique => true
       end
     end
 
@@ -205,6 +203,7 @@ module ActiveRecord
       class << self
         alias :data_column_name :data_column
 
+        remove_method :connection
         def connection
           @@connection ||= ActiveRecord::Base.connection
         end
@@ -293,6 +292,7 @@ module ActiveRecord
     private
       def get_session(env, sid)
         Base.silence do
+          sid ||= generate_sid
           session = find_session(sid)
           env[SESSION_RECORD_KEY] = session
           [sid, session.data]

data/lib/active_record/test_case.rb

@@ -1,6 +1,6 @@
 module ActiveRecord
   # = Active Record Test Case
-  # 
+  #
   # Defines some test assertions to test against SQL queries.
   class TestCase < ActiveSupport::TestCase #:nodoc:
     def assert_date_from_db(expected, actual, message = nil)
@@ -21,7 +21,7 @@ module ActiveRecord
       patterns_to_match.each do |pattern|
         failed_patterns << pattern unless $queries_executed.any?{ |sql| pattern === sql }
       end
-      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map(&:inspect).join(', ')} not found.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
+      assert failed_patterns.empty?, "Query pattern(s) #{failed_patterns.map{ |p| p.inspect }.join(', ')} not found.#{$queries_executed.size == 0 ? '' : "\nQueries:\n#{$queries_executed.join("\n")}"}"
     end
 
     def assert_queries(num = 1)

data/lib/active_record/timestamp.rb

@@ -1,8 +1,8 @@
 module ActiveRecord
   # = Active Record Timestamp
-  # 
+  #
   # Active Record automatically timestamps create and update operations if the
-  # table has fields named <tt>created_at/created_on</tt> or 
+  # table has fields named <tt>created_at/created_on</tt> or
   # <tt>updated_at/updated_on</tt>.
   #
   # Timestamping can be turned off by setting:
@@ -12,6 +12,19 @@ module ActiveRecord
   # Timestamps are in the local timezone by default but you can use UTC by setting:
   #
   #   <tt>ActiveRecord::Base.default_timezone = :utc</tt>
+  #
+  # == Time Zone aware attributes
+  #
+  # By default, ActiveRecord::Base keeps all the datetime columns time zone aware by executing following code.
+  #
+  #   ActiveRecord::Base.time_zone_aware_attributes = true
+  #
+  # This feature can easily be turned off by assigning value <tt>false</tt> .
+  #
+  # If your attributes are time zone aware and you desire to skip time zone conversion for certain
+  # attributes then you can do following:
+  #
+  #   Topic.skip_time_zone_conversion_for_attributes = [:written_on]
   module Timestamp
     extend ActiveSupport::Concern
 
@@ -19,19 +32,6 @@ module ActiveRecord
       class_inheritable_accessor :record_timestamps, :instance_writer => false
       self.record_timestamps = true
     end
-    
-    # Saves the record with the updated_at/on attributes set to the current time.
-    # Please note that no validation is performed and no callbacks are executed.
-    # If an attribute name is passed, that attribute is updated along with 
-    # updated_at/on attributes.
-    #
-    # Examples:
-    #
-    #   product.touch               # updates updated_at/on
-    #   product.touch(:designed_at) # updates the designed_at attribute and updated_at/on
-    def touch(attribute = nil)
-      update_attribute(attribute, current_time_from_proper_timezone)
-    end
 
   private
 
@@ -39,34 +39,33 @@ module ActiveRecord
       if record_timestamps
         current_time = current_time_from_proper_timezone
 
-        timestamp_attributes_for_create.each do |column|
+        all_timestamp_attributes.each do |column|
           write_attribute(column.to_s, current_time) if respond_to?(column) && self.send(column).nil?
         end
-
-        timestamp_attributes_for_update_in_model.each do |column|
-          write_attribute(column.to_s, current_time) if self.send(column).nil?
-        end
       end
 
       super
     end
 
     def update(*args) #:nodoc:
-      record_update_timestamps if !partial_updates? || changed?
+      if should_record_timestamps?
+        current_time = current_time_from_proper_timezone
+
+        timestamp_attributes_for_update_in_model.each do |column|
+          column = column.to_s
+          next if attribute_changed?(column)
+          write_attribute(column, current_time)
+        end
+      end
       super
     end
 
-    def record_update_timestamps #:nodoc:
-      return unless record_timestamps
-      current_time = current_time_from_proper_timezone
-      timestamp_attributes_for_update_in_model.inject({}) do |hash, column|
-        hash[column.to_s] = write_attribute(column.to_s, current_time)
-        hash
-      end
+    def should_record_timestamps?
+      record_timestamps && !partial_updates? || changed?
     end
 
-    def timestamp_attributes_for_update_in_model #:nodoc:
-      timestamp_attributes_for_update.select { |elem| respond_to?(elem) }
+    def timestamp_attributes_for_update_in_model
+      timestamp_attributes_for_update.select { |c| respond_to?(c) }
     end
 
     def timestamp_attributes_for_update #:nodoc:
@@ -78,9 +77,9 @@ module ActiveRecord
     end
 
     def all_timestamp_attributes #:nodoc:
-      timestamp_attributes_for_update + timestamp_attributes_for_create
+      timestamp_attributes_for_create + timestamp_attributes_for_update
     end
-    
+
     def current_time_from_proper_timezone #:nodoc:
       self.class.default_timezone == :utc ? Time.now.utc : Time.now
     end