activerecord 4.2.11.3 → 5.0.7.2

data/lib/active_record/explain.rb

@@ -16,15 +16,14 @@ module ActiveRecord
     # Makes the adapter execute EXPLAIN for the tuples of queries and bindings.
     # Returns a formatted string ready to be logged.
     def exec_explain(queries) # :nodoc:
-      str = queries.map do |sql, bind|
-        [].tap do |msg|
-          msg << "EXPLAIN for: #{sql}"
-          unless bind.empty?
-            bind_msg = bind.map {|col, val| [col.name, val]}.inspect
-            msg.last << " #{bind_msg}"
-          end
-          msg << connection.explain(sql, bind)
-        end.join("\n")
+      str = queries.map do |sql, binds|
+        msg = "EXPLAIN for: #{sql}"
+        unless binds.empty?
+          msg << " "
+          msg << binds.map { |attr| render_bind(attr) }.inspect
+        end
+        msg << "\n"
+        msg << connection.explain(sql, binds)
       end.join("\n")
 
       # Overriding inspect to be more human readable, especially in the console.
@@ -34,5 +33,17 @@ module ActiveRecord
 
       str
     end
+
+    private
+
+      def render_bind(attr)
+        value = if attr.type.binary? && attr.value
+          "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        else
+          connection.type_cast(attr.value_for_database)
+        end
+
+        [attr.name, value]
+      end
   end
 end

data/lib/active_record/explain_registry.rb

@@ -7,7 +7,7 @@ module ActiveRecord
   #
   # returns the collected queries local to the current thread.
   #
-  # See the documentation of <tt>ActiveSupport::PerThreadRegistry</tt>
+  # See the documentation of ActiveSupport::PerThreadRegistry
   # for further details.
   class ExplainRegistry # :nodoc:
     extend ActiveSupport::PerThreadRegistry

data/lib/active_record/explain_subscriber.rb

@@ -14,7 +14,7 @@ module ActiveRecord
     end
 
     # SCHEMA queries cannot be EXPLAINed, also we do not want to run EXPLAIN on
-    # our own EXPLAINs now matter how loopingly beautiful that would be.
+    # our own EXPLAINs no matter how loopingly beautiful that would be.
     #
     # On the other hand, we want to monitor the performance of our real database
     # queries, not the performance of the access to the query cache.

data/lib/active_record/fixture_set/file.rb

@@ -17,29 +17,50 @@ module ActiveRecord
 
       def initialize(file)
         @file = file
-        @rows = nil
       end
 
       def each(&block)
         rows.each(&block)
       end
 
+      def model_class
+        config_row['model_class']
+      end
 
       private
         def rows
-          return @rows if @rows
+          @rows ||= raw_rows.reject { |fixture_name, _| fixture_name == '_fixture' }
+        end
 
-          begin
+        def config_row
+          @config_row ||= begin
+            row = raw_rows.find { |fixture_name, _| fixture_name == '_fixture' }
+            if row
+              row.last
+            else
+              {'model_class': nil}
+            end
+          end
+        end
+
+        def raw_rows
+          @raw_rows ||= begin
             data = YAML.load(render(IO.read(@file)))
+            data ? validate(data).to_a : []
           rescue ArgumentError, Psych::SyntaxError => error
             raise Fixture::FormatError, "a YAML error occurred parsing #{@file}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{error.class}: #{error}", error.backtrace
           end
-          @rows = data ? validate(data).to_a : []
+        end
+
+        def prepare_erb(content)
+          erb = ERB.new(content)
+          erb.filename = @file
+          erb
         end
 
         def render(content)
           context = ActiveRecord::FixtureSet::RenderContext.create_subclass.new
-          ERB.new(content).result(context.get_binding)
+          prepare_erb(content).result(context.get_binding)
         end
 
         # Validate our unmarshalled data.

data/lib/active_record/fixtures.rb

@@ -1,6 +1,7 @@
 require 'erb'
 require 'yaml'
 require 'zlib'
+require 'set'
 require 'active_support/dependencies'
 require 'active_support/core_ext/digest/uuid'
 require 'active_record/fixture_set/file'
@@ -88,7 +89,7 @@ module ActiveRecord
   #   end
   #
   # In order to use these methods to access fixtured data within your testcases, you must specify one of the
-  # following in your <tt>ActiveSupport::TestCase</tt>-derived class:
+  # following in your ActiveSupport::TestCase-derived class:
   #
   # - to fully enable instantiated fixtures (enable alternate methods #1 and #2 above)
   #     self.use_instantiated_fixtures = true
@@ -109,7 +110,7 @@ module ActiveRecord
   #   <% 1.upto(1000) do |i| %>
   #   fix_<%= i %>:
   #     id: <%= i %>
-  #     name: guy_<%= 1 %>
+  #     name: guy_<%= i %>
   #   <% end %>
   #
   # This will create 1000 very simple fixtures.
@@ -123,7 +124,7 @@ module ActiveRecord
   #
   # Helper methods defined in a fixture will not be available in other fixtures, to prevent against
   # unwanted inter-test dependencies. Methods used by multiple fixtures should be defined in a module
-  # that is included in <tt>ActiveRecord::FixtureSet.context_class</tt>.
+  # that is included in ActiveRecord::FixtureSet.context_class.
   #
   # - define a helper method in `test_helper.rb`
   #     module FixtureFileHelpers
@@ -131,20 +132,20 @@ module ActiveRecord
   #         Digest::SHA2.hexdigest(File.read(Rails.root.join('test/fixtures', path)))
   #       end
   #     end
-  #     ActiveRecord::FixtureSet.context_class.send :include, FixtureFileHelpers
+  #     ActiveRecord::FixtureSet.context_class.include FixtureFileHelpers
   #
   # - use the helper method in a fixture
   #     photo:
   #       name: kitten.png
   #       sha: <%= file_sha 'files/kitten.png' %>
   #
-  # = Transactional Fixtures
+  # = Transactional Tests
   #
   # Test cases can use begin+rollback to isolate their changes to the database instead of having to
   # delete+insert for every test case.
   #
   #   class FooTest < ActiveSupport::TestCase
-  #     self.use_transactional_fixtures = true
+  #     self.use_transactional_tests = true
   #
   #     test "godzilla" do
   #       assert !Foo.all.empty?
@@ -158,14 +159,14 @@ module ActiveRecord
   #   end
   #
   # If you preload your test database with all fixture data (probably in the rake task) and use
-  # transactional fixtures, then you may omit all fixtures declarations in your test cases since
+  # transactional tests, then you may omit all fixtures declarations in your test cases since
   # all the data's already there and every case rolls back its changes.
   #
   # In order to use instantiated fixtures with preloaded data, set +self.pre_loaded_fixtures+ to
   # true. This will provide access to fixture data for every table that has been loaded through
   # fixtures (depending on the value of +use_instantiated_fixtures+).
   #
-  # When *not* to use transactional fixtures:
+  # When *not* to use transactional tests:
   #
   # 1. You're testing whether a transaction works correctly. Nested transactions don't commit until
   #    all parent transactions commit, particularly, the fixtures transaction which is begun in setup
@@ -394,6 +395,20 @@ module ActiveRecord
   #     <<: *DEFAULTS
   #
   # Any fixture labeled "DEFAULTS" is safely ignored.
+  #
+  # == Configure the fixture model class
+  #
+  # It's possible to set the fixture's model class directly in the YAML file.
+  # This is helpful when fixtures are loaded outside tests and
+  # +set_fixture_class+ is not available (e.g.
+  # when running <tt>rails db:fixtures:load</tt>).
+  #
+  #   _fixture:
+  #     model_class: User
+  #   david:
+  #     name: David
+  #
+  # Any fixtures labeled "_fixture" are safely ignored.
   class FixtureSet
     #--
     # An instance of FixtureSet is normally stored in a single YAML file and
@@ -520,13 +535,17 @@ module ActiveRecord
 
           update_all_loaded_fixtures fixtures_map
 
-          connection.transaction(:requires_new => true) do
+          connection.transaction(requires_new: true) do
+            deleted_tables = Hash.new { |h, k| h[k] = Set.new }
             fixture_sets.each do |fs|
               conn = fs.model_class.respond_to?(:connection) ? fs.model_class.connection : connection
               table_rows = fs.table_rows
 
               table_rows.each_key do |table|
-                conn.delete "DELETE FROM #{conn.quote_table_name(table)}", 'Fixture Delete'
+                unless deleted_tables[conn].include? table
+                  conn.delete "DELETE FROM #{conn.quote_table_name(table)}", "Fixture Delete"
+                end
+                deleted_tables[conn] << table
               end
 
               table_rows.each do |fixture_set_name, rows|
@@ -573,21 +592,16 @@ module ActiveRecord
       @name     = name
       @path     = path
       @config   = config
-      @model_class = nil
 
-      if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
-        @model_class = class_name
-      else
-        @model_class = class_name.safe_constantize if class_name
-      end
+      self.model_class = class_name
+
+      @fixtures = read_fixture_files(path)
 
       @connection  = connection
 
       @table_name = ( model_class.respond_to?(:table_name) ?
                       model_class.table_name :
                       self.class.default_fixture_table_name(name, config) )
-
-      @fixtures = read_fixture_files path, @model_class
     end
 
     def [](x)
@@ -610,7 +624,6 @@ module ActiveRecord
     # a list of rows to insert to that table.
     def table_rows
       now = config.default_timezone == :utc ? Time.now.utc : Time.now
-      now = now.to_s(:db)
 
       # allow a standard key to be used for doing defaults in YAML
       fixtures.delete('DEFAULTS')
@@ -639,6 +652,13 @@ module ActiveRecord
             row[primary_key_name] = ActiveRecord::FixtureSet.identify(label, primary_key_type)
           end
 
+          # Resolve enums
+          model_class.defined_enums.each do |name, values|
+            if row.include?(name)
+              row[name] = values.fetch(row[name], row[name])
+            end
+          end
+
           # If STI is used, find the correct subclass for association reflection
           reflection_class =
             if row.include?(inheritance_column_name)
@@ -659,7 +679,7 @@ module ActiveRecord
                   row[association.foreign_type] = $1
                 end
 
-                fk_type = reflection_class.columns_hash[fk_name].type
+                fk_type = reflection_class.type_for_attribute(fk_name).type
                 row[fk_name] = ActiveRecord::FixtureSet.identify(value, fk_type)
               end
             when :has_many
@@ -689,7 +709,7 @@ module ActiveRecord
       end
 
       def primary_key_type
-        @association.klass.column_types[@association.klass.primary_key].type
+        @association.klass.type_for_attribute(@association.klass.primary_key).type
       end
     end
 
@@ -713,7 +733,7 @@ module ActiveRecord
       end
 
       def primary_key_type
-        @primary_key_type ||= model_class && model_class.column_types[model_class.primary_key].type
+        @primary_key_type ||= model_class && model_class.type_for_attribute(model_class.primary_key).type
       end
 
       def add_join_records(rows, row, association)
@@ -747,16 +767,28 @@ module ActiveRecord
       end
 
       def column_names
-        @column_names ||= @connection.columns(@table_name).collect { |c| c.name }
+        @column_names ||= @connection.columns(@table_name).collect(&:name)
+      end
+
+      def model_class=(class_name)
+        if class_name.is_a?(Class) # TODO: Should be an AR::Base type class, or any?
+          @model_class = class_name
+        else
+          @model_class = class_name.safe_constantize if class_name
+        end
       end
 
-      def read_fixture_files(path, model_class)
+      # Loads the fixtures from the YAML file at +path+.
+      # If the file sets the +model_class+ and current instance value is not set,
+      # it uses the file value.
+      def read_fixture_files(path)
         yaml_files = Dir["#{path}/{**,*}/*.yml"].select { |f|
           ::File.file?(f)
         } + [yaml_file_path(path)]
 
         yaml_files.each_with_object({}) do |file, fixtures|
           FixtureSet::File.open(file) do |fh|
+            self.model_class ||= fh.model_class if fh.model_class
             fh.each do |fixture_name, row|
               fixtures[fixture_name] = ActiveRecord::Fixture.new(row, model_class)
             end
@@ -770,12 +802,6 @@ module ActiveRecord
 
   end
 
-  #--
-  # Deprecate 'Fixtures' in favor of 'FixtureSet'.
-  #++
-  # :nodoc:
-  Fixtures = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActiveRecord::Fixtures', 'ActiveRecord::FixtureSet')
-
   class Fixture #:nodoc:
     include Enumerable
 
@@ -822,12 +848,12 @@ module ActiveRecord
   module TestFixtures
     extend ActiveSupport::Concern
 
-    def before_setup
+    def before_setup # :nodoc:
       setup_fixtures
       super
     end
 
-    def after_teardown
+    def after_teardown # :nodoc:
       super
       teardown_fixtures
     end
@@ -836,19 +862,29 @@ module ActiveRecord
       class_attribute :fixture_path, :instance_writer => false
       class_attribute :fixture_table_names
       class_attribute :fixture_class_names
+      class_attribute :use_transactional_tests
       class_attribute :use_transactional_fixtures
       class_attribute :use_instantiated_fixtures # true, false, or :no_instances
       class_attribute :pre_loaded_fixtures
       class_attribute :config
 
+      singleton_class.deprecate 'use_transactional_fixtures=' => 'use use_transactional_tests= instead'
+
       self.fixture_table_names = []
-      self.use_transactional_fixtures = true
       self.use_instantiated_fixtures = false
       self.pre_loaded_fixtures = false
       self.config = ActiveRecord::Base
 
-      self.fixture_class_names = Hash.new do |h, fixture_set_name|
-        h[fixture_set_name] = ActiveRecord::FixtureSet.default_fixture_model_name(fixture_set_name, self.config)
+      self.fixture_class_names = {}
+
+      silence_warnings do
+        define_singleton_method :use_transactional_tests do
+          if use_transactional_fixtures.nil?
+            true
+          else
+            use_transactional_fixtures
+          end
+        end
       end
     end
 
@@ -870,7 +906,7 @@ module ActiveRecord
           fixture_set_names = Dir["#{fixture_path}/{**,*}/*.{yml}"]
           fixture_set_names.map! { |f| f[(fixture_path.to_s.size + 1)..-5] }
         else
-          fixture_set_names = fixture_set_names.flatten.map { |n| n.to_s }
+          fixture_set_names = fixture_set_names.flatten.map(&:to_s)
         end
 
         self.fixture_table_names |= fixture_set_names
@@ -890,7 +926,7 @@ module ActiveRecord
               @fixture_cache[fs_name] ||= {}
 
               instances = fixture_names.map do |f_name|
-                f_name = f_name.to_s
+                f_name = f_name.to_s if f_name.is_a?(Symbol)
                 @fixture_cache[fs_name].delete(f_name) if force_reload
 
                 if @loaded_fixtures[fs_name][f_name]
@@ -910,7 +946,7 @@ module ActiveRecord
 
       def uses_transaction(*methods)
         @uses_transaction = [] unless defined?(@uses_transaction)
-        @uses_transaction.concat methods.map { |m| m.to_s }
+        @uses_transaction.concat methods.map(&:to_s)
       end
 
       def uses_transaction?(method)
@@ -920,13 +956,13 @@ module ActiveRecord
     end
 
     def run_in_transaction?
-      use_transactional_fixtures &&
+      use_transactional_tests &&
         !self.class.uses_transaction?(method_name)
     end
 
     def setup_fixtures(config = ActiveRecord::Base)
-      if pre_loaded_fixtures && !use_transactional_fixtures
-        raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures'
+      if pre_loaded_fixtures && !use_transactional_tests
+        raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_tests'
       end
 
       @fixture_cache = {}

data/lib/active_record/gem_version.rb

@@ -5,10 +5,10 @@ module ActiveRecord
   end
 
   module VERSION
-    MAJOR = 4
-    MINOR = 2
-    TINY  = 11
-    PRE   = "3"
+    MAJOR = 5
+    MINOR = 0
+    TINY  = 7
+    PRE   = "2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end