activerecord 4.0.13 → 4.1.0.beta1

data/lib/active_record/connection_adapters/schema_cache.rb

@@ -1,4 +1,3 @@
-require 'active_support/deprecation/reporting'
 
 module ActiveRecord
   module ConnectionAdapters
@@ -16,13 +15,8 @@ module ActiveRecord
         prepare_default_proc
       end
 
-      def primary_keys(table_name = nil)
-        if table_name
-          @primary_keys[table_name]
-        else
-          ActiveSupport::Deprecation.warn('call primary_keys with a table name!')
-          @primary_keys.dup
-        end
+      def primary_keys(table_name)
+        @primary_keys[table_name]
       end
 
       # A cached lookup for table existence.
@@ -41,34 +35,19 @@ module ActiveRecord
         end
       end
 
-      def tables(name = nil)
-        if name
-          @tables[name]
-        else
-          ActiveSupport::Deprecation.warn('call tables with a name!')
-          @tables.dup
-        end
+      def tables(name)
+        @tables[name]
       end
 
       # Get the columns for a table
-      def columns(table = nil)
-        if table
-          @columns[table]
-        else
-          ActiveSupport::Deprecation.warn('call columns with a table name!')
-          @columns.dup
-        end
+      def columns(table)
+        @columns[table]
       end
 
       # Get the columns for a table as a hash, key is the column name
       # value is the column object.
-      def columns_hash(table = nil)
-        if table
-          @columns_hash[table]
-        else
-          ActiveSupport::Deprecation.warn('call columns_hash with a table name!')
-          @columns_hash.dup
-        end
+      def columns_hash(table)
+        @columns_hash[table]
       end
 
       # Clears out internal caches

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -53,6 +53,23 @@ module ActiveRecord
     #
     # * <tt>:database</tt> - Path to the database file.
     class SQLite3Adapter < AbstractAdapter
+      include Savepoints
+
+      NATIVE_DATABASE_TYPES = {
+        primary_key:  'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL',
+        string:       { name: "varchar", limit: 255 },
+        text:         { name: "text" },
+        integer:      { name: "integer" },
+        float:        { name: "float" },
+        decimal:      { name: "decimal" },
+        datetime:     { name: "datetime" },
+        timestamp:    { name: "datetime" },
+        time:         { name: "time" },
+        date:         { name: "date" },
+        binary:       { name: "blob" },
+        boolean:      { name: "boolean" }
+      }
+
       class Version
         include Comparable
 
@@ -124,14 +141,12 @@ module ActiveRecord
         'SQLite'
       end
 
-      # Returns true
       def supports_ddl_transactions?
         true
       end
 
-      # Returns true if SQLite version is '3.6.8' or greater, false otherwise.
       def supports_savepoints?
-        sqlite_version >= '3.6.8'
+        true
       end
 
       # Returns true, since this connection adapter supports prepared statement
@@ -145,7 +160,6 @@ module ActiveRecord
         true
       end
 
-      # Returns true.
       def supports_primary_key? #:nodoc:
         true
       end
@@ -154,7 +168,6 @@ module ActiveRecord
         true
       end
 
-      # Returns true
       def supports_add_column?
         true
       end
@@ -176,16 +189,6 @@ module ActiveRecord
         @statements.clear
       end
 
-      # Returns true
-      def supports_count_distinct? #:nodoc:
-        true
-      end
-
-      # Returns true
-      def supports_autoincrement? #:nodoc:
-        true
-      end
-
       def supports_index_sort_order?
         true
       end
@@ -198,20 +201,7 @@ module ActiveRecord
       end
 
       def native_database_types #:nodoc:
-        {
-          :primary_key => default_primary_key_type,
-          :string      => { :name => "varchar", :limit => 255 },
-          :text        => { :name => "text" },
-          :integer     => { :name => "integer" },
-          :float       => { :name => "float" },
-          :decimal     => { :name => "decimal" },
-          :datetime    => { :name => "datetime" },
-          :timestamp   => { :name => "datetime" },
-          :time        => { :name => "time" },
-          :date        => { :name => "date" },
-          :binary      => { :name => "blob" },
-          :boolean     => { :name => "boolean" }
-        }
+        NATIVE_DATABASE_TYPES
       end
 
       # Returns the current database encoding format as a string, eg: 'UTF-8'
@@ -219,7 +209,6 @@ module ActiveRecord
         @connection.encoding.to_s
       end
 
-      # Returns true.
       def supports_explain?
         true
       end
@@ -227,8 +216,8 @@ module ActiveRecord
       # QUOTING ==================================================
 
       def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-          s = column.class.string_to_binary(value).unpack("H*")[0]
+        if value.kind_of?(String) && column && column.type == :binary
+          s = value.unpack("H*")[0]
           "x'#{s}'"
         else
           super
@@ -292,17 +281,17 @@ module ActiveRecord
       end
 
       def exec_query(sql, name = nil, binds = [])
-        log(sql, name, binds) do
+        type_casted_binds = binds.map { |col, val|
+          [col, type_cast(val, col)]
+        }
 
+        log(sql, name, type_casted_binds) do
           # Don't cache statements if they are not prepared
           if without_prepared_statement?(binds)
             stmt    = @connection.prepare(sql)
-            begin
-              cols    = stmt.columns
-              records = stmt.to_a
-            ensure
-              stmt.close
-            end
+            cols    = stmt.columns
+            records = stmt.to_a
+            stmt.close
             stmt = records
           else
             cache = @statements[sql] ||= {
@@ -311,9 +300,7 @@ module ActiveRecord
             stmt = cache[:stmt]
             cols = cache[:cols] ||= stmt.columns
             stmt.reset!
-            stmt.bind_params binds.map { |col, val|
-              type_cast(val, col)
-            }
+            stmt.bind_params type_casted_binds.map { |_, val| val }
           end
 
           ActiveRecord::Result.new(cols, stmt.to_a)
@@ -350,20 +337,8 @@ module ActiveRecord
       end
       alias :create :insert_sql
 
-      def select_rows(sql, name = nil, binds = [])
-        exec_query(sql, name, binds).rows
-      end
-
-      def create_savepoint
-        execute("SAVEPOINT #{current_savepoint_name}")
-      end
-
-      def rollback_to_savepoint
-        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
-      end
-
-      def release_savepoint
-        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
+      def select_rows(sql, name = nil)
+        exec_query(sql, name).rows
       end
 
       def begin_db_transaction #:nodoc:
@@ -609,14 +584,6 @@ module ActiveRecord
           @sqlite_version ||= SQLite3Adapter::Version.new(select_value('select sqlite_version(*)'))
         end
 
-        def default_primary_key_type
-          if supports_autoincrement?
-            'INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL'
-          else
-            'INTEGER PRIMARY KEY NOT NULL'
-          end
-        end
-
         def translate_exception(exception, message)
           case exception.message
           # SQLite 3.8.2 returns a newly formatted error message:

data/lib/active_record/connection_handling.rb

@@ -15,14 +15,14 @@ module ActiveRecord
     # Example for SQLite database:
     #
     #   ActiveRecord::Base.establish_connection(
-    #     adapter:  "sqlite3",
+    #     adapter:  "sqlite",
     #     database: "path/to/dbfile"
     #   )
     #
     # Also accepts keys as strings (for parsing from YAML for example):
     #
     #   ActiveRecord::Base.establish_connection(
-    #     "adapter"  => "sqlite3",
+    #     "adapter"  => "sqlite",
     #     "database" => "path/to/dbfile"
     #   )
     #

data/lib/active_record/core.rb

@@ -69,13 +69,10 @@ module ActiveRecord
       mattr_accessor :timestamped_migrations, instance_writer: false
       self.timestamped_migrations = true
 
-      ##
-      # :singleton-method:
-      # Disable implicit join references. This feature was deprecated with Rails 4.
-      # If you don't make use of implicit references but still see deprecation warnings
-      # you can disable the feature entirely. This will be the default with Rails 4.1.
-      mattr_accessor :disable_implicit_join_references, instance_writer: false
-      self.disable_implicit_join_references = false
+      def self.disable_implicit_join_references=(value)
+        ActiveSupport::Deprecation.warn("Implicit join references were removed with Rails 4.1." \
+                                        "Make sure to remove this configuration because it does nothing.")
+      end
 
       class_attribute :default_connection_handler, instance_writer: false
 
@@ -94,12 +91,12 @@ module ActiveRecord
       def initialize_generated_modules
         super
 
-        generated_feature_methods
+        generated_association_methods
       end
 
-      def generated_feature_methods
-        @generated_feature_methods ||= begin
-          mod = const_set(:GeneratedFeatureMethods, Module.new)
+      def generated_association_methods
+        @generated_association_methods ||= begin
+          mod = const_set(:GeneratedAssociationMethods, Module.new)
           include mod
           mod
         end
@@ -137,19 +134,18 @@ module ActiveRecord
 
       # Returns the Arel engine.
       def arel_engine
-        @arel_engine ||= begin
+        @arel_engine ||=
           if Base == self || connection_handler.retrieve_connection_pool(self)
             self
           else
             superclass.arel_engine
           end
-        end
       end
 
       private
 
       def relation #:nodoc:
-        relation = Relation.new(self, arel_table)
+        relation = Relation.create(self, arel_table)
 
         if finder_needs_type_condition?
           relation.where(type_condition).create_with(inheritance_column.to_sym => sti_name)
@@ -257,7 +253,6 @@ module ActiveRecord
       @attributes_cache  = {}
 
       @new_record  = true
-      @destroyed   = false
 
       ensure_proper_type
       super
@@ -276,7 +271,7 @@ module ActiveRecord
     #   Post.new.encode_with(coder)
     #   coder # => {"attributes" => {"id" => nil, ... }}
     def encode_with(coder)
-      coder['attributes'] = attributes_for_coder
+      coder['attributes'] = attributes
     end
 
     # Returns true if +comparison_object+ is the same exact object, or +comparison_object+
@@ -291,7 +286,7 @@ module ActiveRecord
     def ==(comparison_object)
       super ||
         comparison_object.instance_of?(self.class) &&
-        id.present? &&
+        id &&
         comparison_object.id == id
     end
     alias :eql? :==
@@ -319,6 +314,8 @@ module ActiveRecord
     def <=>(other_object)
       if other_object.is_a?(self.class)
         self.to_key <=> other_object.to_key
+      else
+        super
       end
     end
 
@@ -333,14 +330,6 @@ module ActiveRecord
       @readonly = true
     end
 
-    # Returns the connection currently associated with the class. This can
-    # also be used to "borrow" the connection to do database work that isn't
-    # easily done without going straight to SQL.
-    def connection
-      ActiveSupport::Deprecation.warn("#connection is deprecated in favour of accessing it via the class")
-      self.class.connection
-    end
-
     def connection_handler
       self.class.connection_handler
     end
@@ -363,7 +352,7 @@ module ActiveRecord
 
     # Returns a hash of the given methods with their names as keys and returned values as values.
     def slice(*methods)
-      Hash[methods.map { |method| [method, public_send(method)] }].with_indifferent_access
+      Hash[methods.map! { |method| [method, public_send(method)] }].with_indifferent_access
     end
 
     def set_transaction_state(state) # :nodoc:
@@ -374,17 +363,6 @@ module ActiveRecord
       !_rollback_callbacks.empty? || !_commit_callbacks.empty? || !_create_callbacks.empty?
     end
 
-    # Required to deserialize Syck properly.
-    if YAML.const_defined?(:ENGINE) && YAML::ENGINE.syck?
-      ActiveSupport::Deprecation.warn(
-        "Syck is deprecated and support for serialization has been removed." \
-        " ActiveRecord::Core#yaml_initialize will be removed in 4.1 which will break deserialization support with Syck."
-      )
-      def yaml_initialize(tag, coder) # :nodoc:
-        init_with(coder)
-      end
-    end
-
     private
 
     # Updates the attributes on this particular ActiveRecord object so that
@@ -409,10 +387,13 @@ module ActiveRecord
     end
 
     def update_attributes_from_transaction_state(transaction_state, depth)
-      if transaction_state && transaction_state.finalized? && !has_transactional_callbacks?
+      if transaction_state && !has_transactional_callbacks?
         unless @reflects_state[depth]
-          restore_transaction_record_state if transaction_state.rolledback?
-          clear_transaction_record_state
+          if transaction_state.committed?
+            committed!
+          elsif transaction_state.rolledback?
+            rolledback!
+          end
           @reflects_state[depth] = true
         end
 
@@ -441,8 +422,6 @@ module ActiveRecord
       @aggregation_cache        = {}
       @association_cache        = {}
       @attributes_cache         = {}
-      @previously_changed       = {}
-      @changed_attributes       = {}
       @readonly                 = false
       @destroyed                = false
       @marked_for_destruction   = false
@@ -459,7 +438,7 @@ module ActiveRecord
       # optimistic locking) won't get written unless they get marked as changed
       self.class.columns.each do |c|
         attr, orig_value = c.name, c.default
-        @changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
+        changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
       end
     end
 

data/lib/active_record/counter_cache.rb

@@ -34,8 +34,8 @@ module ActiveRecord
           counter_name = reflection.counter_cache_column
 
           stmt = unscoped.where(arel_table[primary_key].eq(object.id)).arel.compile_update({
-            arel_table[counter_name] => object.send(association).count(:all)
-          })
+            arel_table[counter_name] => object.send(association).count
+          }, primary_key)
           connection.update stmt
         end
         return true
@@ -50,7 +50,7 @@ module ActiveRecord
       # ==== Parameters
       #
       # * +id+ - The id of the object you wish to update a counter on or an Array of ids.
-      # * +counters+ - An Array of Hashes containing the names of the fields
+      # * +counters+ - A Hash containing the names of the fields
       #   to update as keys and the amount to update the field by as values.
       #
       # ==== Examples
@@ -82,10 +82,10 @@ module ActiveRecord
 
       # Increment a numeric field by one, via a direct SQL update.
       #
-      # This method is used primarily for maintaining counter_cache columns used to
-      # store aggregate values. For example, a DiscussionBoard may cache posts_count
-      # and comments_count to avoid running an SQL query to calculate the number of
-      # posts and comments there are each time it is displayed.
+      # This method is used primarily for maintaining counter_cache columns that are
+      # used to store aggregate values. For example, a DiscussionBoard may cache
+      # posts_count and comments_count to avoid running an SQL query to calculate the
+      # number of posts and comments there are, each time it is displayed.
       #
       # ==== Parameters
       #