activerecord 4.1.8 → 4.2.11.3

data/lib/active_record/fixtures.rb

@@ -2,6 +2,7 @@ require 'erb'
 require 'yaml'
 require 'zlib'
 require 'active_support/dependencies'
+require 'active_support/core_ext/digest/uuid'
 require 'active_record/fixture_set/file'
 require 'active_record/errors'
 
@@ -14,9 +15,10 @@ module ActiveRecord
   # They are stored in YAML files, one file per model, which are placed in the directory
   # appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically
   # configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/</tt>).
-  # The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
-  # <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>). The format of a fixture file looks
-  # like this:
+  # The fixture file ends with the +.yml+ file extension, for example:
+  # <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>).
+  #
+  # The format of a fixture file looks like this:
   #
   #   rubyonrails:
   #     id: 1
@@ -32,7 +34,7 @@ module ActiveRecord
   # is followed by an indented list of key/value pairs in the "key: value" format. Records are
   # separated by a blank line for your viewing pleasure.
   #
-  # Note that fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
+  # Note: Fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
   # See http://yaml.org/type/omap.html
   # for the specification. You will need ordered fixtures when you have foreign key constraints
   # on keys in the same table. This is commonly needed for tree structures. Example:
@@ -60,8 +62,8 @@ module ActiveRecord
   #     end
   #   end
   #
-  # By default, <tt>test_helper.rb</tt> will load all of your fixtures into your test database,
-  # so this test will succeed.
+  # By default, +test_helper.rb+ will load all of your fixtures into your test
+  # database, so this test will succeed.
   #
   # The testing environment will automatically load the all fixtures into the database before each
   # test. To ensure consistent data, the environment deletes the fixtures before running the load.
@@ -179,6 +181,9 @@ module ActiveRecord
   # * Stable, autogenerated IDs
   # * Label references for associations (belongs_to, has_one, has_many)
   # * HABTM associations as inline lists
+  #
+  # There are some more advanced features available even if the id is specified:
+  #
   # * Autofilled timestamp columns
   # * Fixture label interpolation
   # * Support for YAML defaults
@@ -361,6 +366,7 @@ module ActiveRecord
   #   geeksomnia:
   #     name: Geeksomnia's Account
   #     subdomain: $LABEL
+  #     email: $LABEL@email.com
   #
   # Also, sometimes (like when porting older join table fixtures) you'll need
   # to be able to get a hold of the identifier for a given label. ERB
@@ -372,8 +378,9 @@ module ActiveRecord
   #
   # == Support for YAML defaults
   #
-  # You probably already know how to use YAML to set and reuse defaults in
-  # your <tt>database.yml</tt> file. You can use the same technique in your fixtures:
+  # You can set and reuse defaults in your fixtures YAML file.
+  # This is the same technique used in the +database.yml+ file to specify
+  # defaults:
   #
   #   DEFAULTS: &DEFAULTS
   #     created_on: <%= 3.weeks.ago.to_s(:db) %>
@@ -389,7 +396,8 @@ module ActiveRecord
   # Any fixture labeled "DEFAULTS" is safely ignored.
   class FixtureSet
     #--
-    # An instance of FixtureSet is normally stored in a single YAML file and possibly in a folder with the same name.
+    # An instance of FixtureSet is normally stored in a single YAML file and
+    # possibly in a folder with the same name.
     #++
 
     MAX_ID = 2 ** 30 - 1
@@ -459,13 +467,7 @@ module ActiveRecord
         @config      = config
 
         # Remove string values that aren't constants or subclasses of AR
-        @class_names.delete_if { |k,klass|
-          unless klass.is_a? Class
-            klass = klass.safe_constantize
-            ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name to `set_fixture_class` will be removed in Rails 4.2. Use the class itself instead.")
-          end
-          !insert_class(@class_names, k, klass)
-        }
+        @class_names.delete_if { |klass_name, klass| !insert_class(@class_names, klass_name, klass) }
       end
 
       def [](fs_name)
@@ -516,14 +518,14 @@ module ActiveRecord
               ::File.join(fixtures_directory, fs_name))
           end
 
-          all_loaded_fixtures.update(fixtures_map)
+          update_all_loaded_fixtures fixtures_map
 
           connection.transaction(:requires_new => true) do
             fixture_sets.each do |fs|
               conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
               table_rows = fs.table_rows
 
-              table_rows.keys.each do |table|
+              table_rows.each_key do |table|
                 conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
               end
 
@@ -532,12 +534,10 @@ module ActiveRecord
                   conn.insert_fixture(row, fixture_set_name)
                 end
               end
-            end
 
-            # Cap primary key sequences to max(pk).
-            if connection.respond_to?(:reset_pk_sequence!)
-              fixture_sets.each do |fs|
-                connection.reset_pk_sequence!(fs.table_name)
+              # Cap primary key sequences to max(pk).
+              if conn.respond_to?(:reset_pk_sequence!)
+                conn.reset_pk_sequence!(fs.table_name)
               end
             end
           end
@@ -549,9 +549,13 @@ module ActiveRecord
     end
 
     # Returns a consistent, platform-independent identifier for +label+.
-    # Identifiers are positive integers less than 2^32.
-    def self.identify(label)
-      Zlib.crc32(label.to_s) % MAX_ID
+    # Integer identifiers are values less than 2^30. UUIDs are RFC 4122 version 5 SHA-1 hashes.
+    def self.identify(label, column_type = :integer)
+      if column_type == :uuid
+        Digest::UUID.uuid_v5(Digest::UUID::OID_NAMESPACE, label.to_s)
+      else
+        Zlib.crc32(label.to_s) % MAX_ID
+      end
     end
 
     # Superclass for the evaluation contexts used by ERB fixtures.
@@ -559,6 +563,10 @@ module ActiveRecord
       @context_class ||= Class.new
     end
 
+    def self.update_all_loaded_fixtures(fixtures_map) # :nodoc:
+      all_loaded_fixtures.update(fixtures_map)
+    end
+
     attr_reader :table_name, :name, :fixtures, :model_class, :config
 
     def initialize(connection, name, class_name, path, config = ActiveRecord::Base)
@@ -567,10 +575,6 @@ module ActiveRecord
       @config   = config
       @model_class = nil
 
-      if class_name.is_a?(String)
-        ActiveSupport::Deprecation.warn("The ability to pass in strings as a class name to `FixtureSet.new` will be removed in Rails 4.2. Use the class itself instead.")
-      end
-
       if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
         @model_class = class_name
       else
@@ -627,12 +631,12 @@ module ActiveRecord
 
           # interpolate the fixture label
           row.each do |key, value|
-            row[key] = label if "$LABEL" == value
+            row[key] = value.gsub("$LABEL", label.to_s) if value.is_a?(String)
           end
 
           # generate a primary key if necessary
           if has_primary_key_column? && !row.include?(primary_key_name)
-            row[primary_key_name] = ActiveRecord::FixtureSet.identify(label)
+            row[primary_key_name] = ActiveRecord::FixtureSet.identify(label, primary_key_type)
           end
 
           # If STI is used, find the correct subclass for association reflection
@@ -643,19 +647,20 @@ module ActiveRecord
               model_class
             end
 
-          reflection_class._reflections.values.each do |association|
+          reflection_class._reflections.each_value do |association|
             case association.macro
             when :belongs_to
               # Do not replace association name with association foreign key if they are named the same
               fk_name = (association.options[:foreign_key] || "#{association.name}_id").to_s
 
               if association.name.to_s != fk_name && value = row.delete(association.name.to_s)
-                if association.options[:polymorphic] && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
+                if association.polymorphic? && value.sub!(/\s*\(([^\)]*)\)\s*$/, "")
                   # support polymorphic belongs_to as "label (Type)"
                   row[association.foreign_type] = $1
                 end
 
-                row[fk_name] = ActiveRecord::FixtureSet.identify(value)
+                fk_type = reflection_class.columns_hash[fk_name].type
+                row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
               end
             when :has_many
               if association.options[:through]
@@ -682,6 +687,10 @@ module ActiveRecord
       def name
         @association.name
       end
+
+      def primary_key_type
+        @association.klass.column_types[@association.klass.primary_key].type
+      end
     end
 
     class HasManyThroughProxy < ReflectionProxy # :nodoc:
@@ -692,6 +701,10 @@ module ActiveRecord
       def lhs_key
         @association.through_reflection.foreign_key
       end
+
+      def join_table
+        @association.through_reflection.table_name
+      end
     end
 
     private
@@ -699,17 +712,22 @@ module ActiveRecord
         @primary_key_name ||= model_class && model_class.primary_key
       end
 
+      def primary_key_type
+        @primary_key_type ||= model_class && model_class.column_types[model_class.primary_key].type
+      end
+
       def add_join_records(rows, row, association)
         # This is the case when the join table has no fixtures file
         if (targets = row.delete(association.name.to_s))
-          table_name = association.join_table
-          lhs_key    = association.lhs_key
-          rhs_key    = association.rhs_key
+          table_name  = association.join_table
+          column_type = association.primary_key_type
+          lhs_key     = association.lhs_key
+          rhs_key     = association.rhs_key
 
           targets = targets.is_a?(Array) ? targets : targets.split(/\s*,\s*/)
           rows[table_name].concat targets.map { |target|
             { lhs_key => row[primary_key_name],
-              rhs_key => ActiveRecord::FixtureSet.identify(target) }
+              rhs_key => ActiveRecord::FixtureSet.identify(target, column_type) }
           }
         end
       end
@@ -790,7 +808,9 @@ module ActiveRecord
 
     def find
       if model_class
-        model_class.find(fixture[model_class.primary_key])
+        model_class.unscoped do
+          model_class.find(fixture[model_class.primary_key])
+        end
       else
         raise FixtureClassNotFound, "No class attached to find."
       end
@@ -854,34 +874,9 @@ module ActiveRecord
         end
 
         self.fixture_table_names |= fixture_set_names
-        require_fixture_classes(fixture_set_names, self.config)
         setup_fixture_accessors(fixture_set_names)
       end
 
-      def try_to_load_dependency(file_name)
-        require_dependency file_name
-      rescue LoadError => e
-        unless fixture_class_names.key?(file_name.pluralize)
-          if ActiveRecord::Base.logger
-            ActiveRecord::Base.logger.warn("Unable to load #{file_name}, make sure you added it to ActiveSupport::TestCase.set_fixture_class")
-            ActiveRecord::Base.logger.warn("underlying cause #{e.message} \n\n #{e.backtrace.join("\n")}")
-          end
-        end
-      end
-
-      def require_fixture_classes(fixture_set_names = nil, config = ActiveRecord::Base)
-        if fixture_set_names
-          fixture_set_names = fixture_set_names.map { |n| n.to_s }
-        else
-          fixture_set_names = fixture_table_names
-        end
-
-        fixture_set_names.each do |file_name|
-          file_name = file_name.singularize if config.pluralize_table_names
-          try_to_load_dependency(file_name)
-        end
-      end
-
       def setup_fixture_accessors(fixture_set_names = nil)
         fixture_set_names = Array(fixture_set_names || fixture_table_names)
         methods = Module.new do
@@ -958,7 +953,7 @@ module ActiveRecord
       end
 
       # Instantiate fixtures for every test if requested.
-      instantiate_fixtures(config) if use_instantiated_fixtures
+      instantiate_fixtures if use_instantiated_fixtures
     end
 
     def teardown_fixtures
@@ -985,16 +980,9 @@ module ActiveRecord
         Hash[fixtures.map { |f| [f.name, f] }]
       end
 
-      # for pre_loaded_fixtures, only require the classes once. huge speed improvement
-      @@required_fixture_classes = false
-
-      def instantiate_fixtures(config)
+      def instantiate_fixtures
         if pre_loaded_fixtures
           raise RuntimeError, 'Load fixtures before instantiating them.' if ActiveRecord::FixtureSet.all_loaded_fixtures.empty?
-          unless @@required_fixture_classes
-            self.class.require_fixture_classes ActiveRecord::FixtureSet.all_loaded_fixtures.keys, config
-            @@required_fixture_classes = true
-          end
           ActiveRecord::FixtureSet.instantiate_all_loaded_fixtures(self, load_instances?)
         else
           raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?

data/lib/active_record/gem_version.rb

@@ -1,14 +1,14 @@
 module ActiveRecord
-  # Returns the version of the currently loaded ActiveRecord as a <tt>Gem::Version</tt>
+  # Returns the version of the currently loaded Active Record as a <tt>Gem::Version</tt>
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
     MAJOR = 4
-    MINOR = 1
-    TINY  = 8
-    PRE   = nil
+    MINOR = 2
+    TINY  = 11
+    PRE   = "3"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -1,6 +1,37 @@
 require 'active_support/core_ext/hash/indifferent_access'
 
 module ActiveRecord
+  # == Single table inheritance
+  #
+  # Active Record allows inheritance by storing the name of the class in a column that by
+  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
+  # This means that an inheritance looking like this:
+  #
+  #   class Company < ActiveRecord::Base; end
+  #   class Firm < Company; end
+  #   class Client < Company; end
+  #   class PriorityClient < Client; end
+  #
+  # When you do <tt>Firm.create(name: "37signals")</tt>, this record will be saved in
+  # the companies table with type = "Firm". You can then fetch this row again using
+  # <tt>Company.where(name: '37signals').first</tt> and it will return a Firm object.
+  #
+  # Be aware that because the type column is an attribute on the record every new
+  # subclass will instantly be marked as dirty and the type column will be included
+  # in the list of changed attributes on the record. This is different from non
+  # STI classes:
+  #
+  #   Company.new.changed? # => false
+  #   Firm.new.changed?    # => true
+  #   Firm.new.changes     # => {"type"=>["","Firm"]}
+  #
+  # If you don't have a type column defined in your table, single-table inheritance won't
+  # be triggered. In that case, it'll work just like normal subclasses with no special magic
+  # for differentiating between them or reloading the right type with find.
+  #
+  # Note, all the attributes for all the cases are kept in the same table. Read more:
+  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  #
   module Inheritance
     extend ActiveSupport::Concern
 
@@ -49,12 +80,12 @@ module ActiveRecord
       end
 
       def symbolized_base_class
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.symbolized_base_class is deprecated and will be removed without replacement.")
+        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_base_class` is deprecated and will be removed without replacement.')
         @symbolized_base_class ||= base_class.to_s.to_sym
       end
 
       def symbolized_sti_name
-        ActiveSupport::Deprecation.warn("ActiveRecord::Base.symbolized_sti_name is deprecated and will be removed without replacement.")
+        ActiveSupport::Deprecation.warn('`ActiveRecord::Base.symbolized_sti_name` is deprecated and will be removed without replacement.')
         @symbolized_sti_name ||= sti_name.present? ? sti_name.to_sym : symbolized_base_class
       end
 
@@ -120,14 +151,8 @@ module ActiveRecord
           candidates << type_name
 
           candidates.each do |candidate|
-            begin
-              constant = ActiveSupport::Dependencies.constantize(candidate)
-              return constant if candidate == constant.to_s
-            # We don't want to swallow NoMethodError < NameError errors
-            rescue NoMethodError
-              raise
-            rescue NameError
-            end
+            constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+            return constant if candidate == constant.to_s
           end
 
           raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)

data/lib/active_record/integration.rb

@@ -55,16 +55,16 @@ module ActiveRecord
     def cache_key(*timestamp_names)
       case
       when new_record?
-        "#{self.class.model_name.cache_key}/new"
+        "#{model_name.cache_key}/new"
       when timestamp_names.any?
         timestamp = max_updated_column_timestamp(timestamp_names)
         timestamp = timestamp.utc.to_s(cache_timestamp_format)
-        "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
+        "#{model_name.cache_key}/#{id}-#{timestamp}"
       when timestamp = max_updated_column_timestamp
         timestamp = timestamp.utc.to_s(cache_timestamp_format)
-        "#{self.class.model_name.cache_key}/#{id}-#{timestamp}"
+        "#{model_name.cache_key}/#{id}-#{timestamp}"
       else
-        "#{self.class.model_name.cache_key}/#{id}"
+        "#{model_name.cache_key}/#{id}"
       end
     end
 

data/lib/active_record/legacy_yaml_adapter.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module LegacyYamlAdapter
+    def self.convert(klass, coder)
+      return coder unless coder.is_a?(Psych::Coder)
+
+      case coder["active_record_yaml_version"]
+      when 0 then coder
+      else
+        if coder["attributes"].is_a?(AttributeSet)
+          coder
+        else
+          Rails41.convert(klass, coder)
+        end
+      end
+    end
+
+    module Rails41
+      def self.convert(klass, coder)
+        attributes = klass.attributes_builder
+          .build_from_database(coder["attributes"])
+        new_record = coder["attributes"][klass.primary_key].blank?
+
+        {
+          "attributes" => attributes,
+          "new_record" => new_record,
+        }
+      end
+    end
+  end
+end

data/lib/active_record/locking/optimistic.rb

@@ -66,7 +66,16 @@ module ActiveRecord
           send(lock_col + '=', previous_lock_value + 1)
         end
 
-        def _update_record(attribute_names = @attributes.keys) #:nodoc:
+        def _create_record(attribute_names = self.attribute_names, *) # :nodoc:
+          if locking_enabled?
+            # We always want to persist the locking version, even if we don't detect
+            # a change from the default, since the database might have no default
+            attribute_names |= [self.class.locking_column]
+          end
+          super
+        end
+
+        def _update_record(attribute_names = self.attribute_names) #:nodoc:
           return super unless locking_enabled?
           return 0 if attribute_names.empty?
 
@@ -80,17 +89,15 @@ module ActiveRecord
           begin
             relation = self.class.unscoped
 
-            stmt = relation.where(
-              relation.table[self.class.primary_key].eq(id).and(
-                relation.table[lock_col].eq(self.class.quote_value(previous_lock_value, column_for_attribute(lock_col)))
-              )
-            ).arel.compile_update(
-              arel_attributes_with_values_for_update(attribute_names),
-              self.class.primary_key
+            affected_rows = relation.where(
+              self.class.primary_key => id,
+              lock_col => previous_lock_value,
+            ).update_all(
+              Hash[attributes_for_update(attribute_names).map do |name|
+                [name, _read_attribute(name)]
+              end]
             )
 
-            affected_rows = self.class.connection.update stmt
-
             unless affected_rows == 1
               raise ActiveRecord::StaleObjectError.new(self, "update")
             end
@@ -120,7 +127,7 @@ module ActiveRecord
           if locking_enabled?
             column_name = self.class.locking_column
             column      = self.class.columns_hash[column_name]
-            substitute  = self.class.connection.substitute_at(column, relation.bind_values.length)
+            substitute  = self.class.connection.substitute_at(column)
 
             relation = relation.where(self.class.arel_table[column_name].eq(substitute))
             relation.bind_values << [column, self[column_name].to_i]
@@ -141,7 +148,7 @@ module ActiveRecord
 
         # Set the column to use for optimistic locking. Defaults to +lock_version+.
         def locking_column=(value)
-          @column_defaults = nil
+          clear_caches_calculated_from_columns
           @locking_column = value.to_s
         end
 
@@ -151,12 +158,6 @@ module ActiveRecord
           @locking_column
         end
 
-        # Quote the column name used for optimistic locking.
-        def quoted_locking_column
-          ActiveSupport::Deprecation.warn "ActiveRecord::Base.quoted_locking_column is deprecated and will be removed in Rails 4.2 or later."
-          connection.quote_column_name(locking_column)
-        end
-
         # Reset the column used for optimistic locking back to the +lock_version+ default.
         def reset_locking_column
           self.locking_column = DEFAULT_LOCKING_COLUMN
@@ -169,18 +170,37 @@ module ActiveRecord
           super
         end
 
-        def column_defaults
-          @column_defaults ||= begin
-            defaults = super
-
-            if defaults.key?(locking_column) && lock_optimistically
-              defaults[locking_column] ||= 0
+        private
+
+        # We need to apply this decorator here, rather than on module inclusion. The closure
+        # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
+        # sub class being decorated. As such, changes to `lock_optimistically`, or
+        # `locking_column` would not be picked up.
+        def inherited(subclass)
+          subclass.class_eval do
+            is_lock_column = ->(name, _) { lock_optimistically && name == locking_column }
+            decorate_matching_attribute_types(is_lock_column, :_optimistic_locking) do |type|
+              LockingType.new(type)
             end
-
-            defaults
           end
+          super
         end
       end
     end
+
+    class LockingType < SimpleDelegator # :nodoc:
+      def type_cast_from_database(value)
+        # `nil` *should* be changed to 0
+        super.to_i
+      end
+
+      def init_with(coder)
+        __setobj__(coder['subtype'])
+      end
+
+      def encode_with(coder)
+        coder['subtype'] = __getobj__
+      end
+    end
   end
 end

data/lib/active_record/migration/command_recorder.rb

@@ -74,7 +74,9 @@ module ActiveRecord
         :rename_index, :rename_column, :add_index, :remove_index, :add_timestamps, :remove_timestamps,
         :change_column_default, :add_reference, :remove_reference, :transaction,
         :drop_join_table, :drop_table, :execute_block, :enable_extension,
-        :change_column, :execute, :remove_columns, :change_column_null # irreversible methods need to be here too
+        :change_column, :execute, :remove_columns, :change_column_null,
+        :add_foreign_key, :remove_foreign_key
+       # irreversible methods need to be here too
       ].each do |method|
         class_eval <<-EOV, __FILE__, __LINE__ + 1
           def #{method}(*args, &block)          # def create_table(*args, &block)
@@ -85,7 +87,7 @@ module ActiveRecord
       alias :add_belongs_to :add_reference
       alias :remove_belongs_to :remove_reference
 
-      def change_table(table_name, options = {})
+      def change_table(table_name, options = {}) # :nodoc:
         yield delegate.update_table_definition(table_name, self)
       end
 
@@ -167,6 +169,21 @@ module ActiveRecord
         [:change_column_null, args]
       end
 
+      def invert_add_foreign_key(args)
+        from_table, to_table, add_options = args
+        add_options ||= {}
+
+        if add_options[:name]
+          options = { name: add_options[:name] }
+        elsif add_options[:column]
+          options = { column: add_options[:column] }
+        else
+          options = to_table
+        end
+
+        [:remove_foreign_key, [from_table, options]]
+      end
+
       # Forwards any missing method call to the \target.
       def method_missing(method, *args, &block)
         if @delegate.respond_to?(method)

data/lib/active_record/migration/join_table.rb

@@ -8,7 +8,7 @@ module ActiveRecord
       end
 
       def join_table_name(table_1, table_2)
-        [table_1.to_s, table_2.to_s].sort.join("_").to_sym
+        ModelSchema.derive_join_table_name(table_1, table_2).to_sym
       end
     end
   end