activerecord 5.0.7.2 → 5.1.0.beta1

data/lib/active_record/integration.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/string/filters'
+require "active_support/core_ext/string/filters"
 
 module ActiveRecord
   module Integration
@@ -11,13 +11,13 @@ module ActiveRecord
       # Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
       #
       # This is +:usec+, by default.
-      class_attribute :cache_timestamp_format, :instance_writer => false
+      class_attribute :cache_timestamp_format, instance_writer: false
       self.cache_timestamp_format = :usec
     end
 
-    # Returns a String, which Action Pack uses for constructing a URL to this
-    # object. The default implementation returns this record's id as a String,
-    # or nil if this record's unsaved.
+    # Returns a +String+, which Action Pack uses for constructing a URL to this
+    # object. The default implementation returns this record's id as a +String+,
+    # or +nil+ if this record's unsaved.
     #
     # For example, suppose that you have a User model, and that you have a
     # <tt>resources :users</tt> route. Normally, +user_path+ will
@@ -89,7 +89,7 @@ module ActiveRecord
       #
       #   user = User.find_by(name: 'David Heinemeier Hansson')
       #   user.id         # => 125
-      #   user_path(user) # => "/users/125-david"
+      #   user_path(user) # => "/users/125-david-heinemeier"
       #
       # Because the generated param begins with the record's +id+, it is
       # suitable for passing to +find+. In a controller, for example:
@@ -103,7 +103,7 @@ module ActiveRecord
           define_method :to_param do
             if (default = super()) &&
                  (result = send(method_name).to_s).present? &&
-                   (param = result.squish.truncate(20, separator: /\s/, omission: nil).parameterize).present?
+                   (param = result.squish.parameterize.truncate(20, separator: /-/, omission: "")).present?
               "#{default}-#{param}"
             else
               default

data/lib/active_record/internal_metadata.rb

@@ -1,5 +1,5 @@
-require 'active_record/scoping/default'
-require 'active_record/scoping/named'
+require "active_record/scoping/default"
+require "active_record/scoping/named"
 
 module ActiveRecord
   # This class is used to create a table that keeps track of values and keys such
@@ -14,10 +14,6 @@ module ActiveRecord
         "#{table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{table_name_suffix}"
       end
 
-      def original_table_name
-        "#{table_name_prefix}active_record_internal_metadatas#{table_name_suffix}"
-      end
-
       def []=(key, value)
         find_or_initialize_by(key: key).update_attributes!(value: value)
       end
@@ -27,20 +23,11 @@ module ActiveRecord
       end
 
       def table_exists?
-        ActiveSupport::Deprecation.silence { connection.table_exists?(table_name) }
-      end
-
-      def original_table_exists?
-        # This method will be removed in Rails 5.1
-        # Since it is only necessary when `active_record_internal_metadatas` could exist
-        ActiveSupport::Deprecation.silence { connection.table_exists?(original_table_name) }
+        connection.table_exists?(table_name)
       end
 
       # Creates an internal metadata table with columns +key+ and +value+
       def create_table
-        if original_table_exists?
-          connection.rename_table(original_table_name, table_name)
-        end
         unless table_exists?
           key_options = connection.internal_string_options_for_primary_key
 

data/lib/active_record/legacy_yaml_adapter.rb

@@ -4,7 +4,7 @@ module ActiveRecord
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
-      when 1 then coder
+      when 1, 2 then coder
       else
         if coder["attributes"].is_a?(AttributeSet)
           Rails420.convert(klass, coder)

data/lib/active_record/locking/optimistic.rb

@@ -47,6 +47,8 @@ module ActiveRecord
     #     self.locking_column = :lock_person
     #   end
     #
+    # Please note that the optimistic locking will be ignored if you update the
+    # locking column's value.
     module Optimistic
       extend ActiveSupport::Concern
 
@@ -60,13 +62,14 @@ module ActiveRecord
       end
 
       private
+
         def increment_lock
           lock_col = self.class.locking_column
           previous_lock_value = send(lock_col).to_i
-          send(lock_col + '=', previous_lock_value + 1)
+          send(lock_col + "=", previous_lock_value + 1)
         end
 
-        def _create_record(attribute_names = self.attribute_names, *) # :nodoc:
+        def _create_record(attribute_names = self.attribute_names, *)
           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
@@ -75,23 +78,26 @@ module ActiveRecord
           super
         end
 
-        def _update_record(attribute_names = self.attribute_names) #:nodoc:
+        def _update_record(attribute_names = self.attribute_names)
           return super unless locking_enabled?
-          return 0 if attribute_names.empty?
 
           lock_col = self.class.locking_column
-          previous_lock_value = send(lock_col).to_i
-          increment_lock
 
-          attribute_names += [lock_col]
-          attribute_names.uniq!
+          return super if attribute_names.include?(lock_col)
+          return 0 if attribute_names.empty?
 
           begin
+            previous_lock_value = read_attribute_before_type_cast(lock_col)
+
+            increment_lock
+
+            attribute_names.push(lock_col)
+
             relation = self.class.unscoped
 
             affected_rows = relation.where(
               self.class.primary_key => id,
-              lock_col => previous_lock_value,
+              lock_col => previous_lock_value
             ).update_all(
               attributes_for_update(attribute_names).map do |name|
                 [name, _read_attribute(name)]
@@ -104,9 +110,9 @@ module ActiveRecord
 
             affected_rows
 
-          # If something went wrong, revert the version.
+          # If something went wrong, revert the locking_column value.
           rescue Exception
-            send(lock_col + '=', previous_lock_value)
+            send(lock_col + "=", previous_lock_value.to_i)
             raise
           end
         end
@@ -132,61 +138,63 @@ module ActiveRecord
           relation
         end
 
-      module ClassMethods
-        DEFAULT_LOCKING_COLUMN = 'lock_version'
+        module ClassMethods
+          DEFAULT_LOCKING_COLUMN = "lock_version"
 
-        # Returns true if the +lock_optimistically+ flag is set to true
-        # (which it is, by default) and the table includes the
-        # +locking_column+ column (defaults to +lock_version+).
-        def locking_enabled?
-          lock_optimistically && columns_hash[locking_column]
-        end
+          # Returns true if the +lock_optimistically+ flag is set to true
+          # (which it is, by default) and the table includes the
+          # +locking_column+ column (defaults to +lock_version+).
+          def locking_enabled?
+            lock_optimistically && columns_hash[locking_column]
+          end
 
-        # Set the column to use for optimistic locking. Defaults to +lock_version+.
-        def locking_column=(value)
-          reload_schema_from_cache
-          @locking_column = value.to_s
-        end
+          # Set the column to use for optimistic locking. Defaults to +lock_version+.
+          def locking_column=(value)
+            reload_schema_from_cache
+            @locking_column = value.to_s
+          end
 
-        # The version column used for optimistic locking. Defaults to +lock_version+.
-        def locking_column
-          @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
-          @locking_column
-        end
+          # The version column used for optimistic locking. Defaults to +lock_version+.
+          def locking_column
+            @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
+            @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
-        end
+          # Reset the column used for optimistic locking back to the +lock_version+ default.
+          def reset_locking_column
+            self.locking_column = DEFAULT_LOCKING_COLUMN
+          end
 
-        # Make sure the lock version column gets updated when counters are
-        # updated.
-        def update_counters(id, counters)
-          counters = counters.merge(locking_column => 1) if locking_enabled?
-          super
-        end
+          # Make sure the lock version column gets updated when counters are
+          # updated.
+          def update_counters(id, counters)
+            counters = counters.merge(locking_column => 1) if locking_enabled?
+            super
+          end
 
-        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)
+          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
+              end
+              super
             end
-          end
-          super
         end
-      end
     end
 
+    # In de/serialize we change `nil` to 0, so that we can allow passing
+    # `nil` values to `lock_version`, and not result in `ActiveRecord::StaleObjectError`
+    # during update record.
     class LockingType < DelegateClass(Type::Value) # :nodoc:
       def deserialize(value)
-        # `nil` *should* be changed to 0
         super.to_i
       end
 
@@ -195,11 +203,11 @@ module ActiveRecord
       end
 
       def init_with(coder)
-        __setobj__(coder['subtype'])
+        __setobj__(coder["subtype"])
       end
 
       def encode_with(coder)
-        coder['subtype'] = __getobj__
+        coder["subtype"] = __getobj__
       end
     end
   end

data/lib/active_record/locking/pessimistic.rb

@@ -59,7 +59,16 @@ module ActiveRecord
       # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
       # the locked record.
       def lock!(lock = true)
-        reload(:lock => lock) if persisted?
+        if persisted?
+          if changed?
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Locking a record with unpersisted changes is deprecated and will raise an
+              exception in Rails 5.2. Use `save` to persist the changes, or `reload` to
+              discard them explicitly.
+            MSG
+          end
+          reload(lock: lock)
+        end
         self
       end
 

data/lib/active_record/log_subscriber.rb

@@ -15,11 +15,6 @@ module ActiveRecord
       rt
     end
 
-    def initialize
-      super
-      @odd = false
-    end
-
     def sql(event)
       self.class.runtime += event.duration
       return unless logger.debug?
@@ -29,11 +24,12 @@ module ActiveRecord
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
       name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      name  = "CACHE #{name}" if payload[:cached]
       sql   = payload[:sql]
       binds = nil
 
       unless (payload[:binds] || []).empty?
-        casted_params = type_casted_binds(payload[:type_casted_binds])
+        casted_params = type_casted_binds(payload[:binds], payload[:type_casted_binds])
         binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
           render_bind(attr, value)
         }.inspect
@@ -47,30 +43,30 @@ module ActiveRecord
 
     private
 
-    def type_casted_binds(casted_binds)
-      casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
-    end
-
-    def render_bind(attr, value)
-      if attr.is_a?(Array)
-        attr = attr.first
-      elsif attr.type.binary? && attr.value
-        value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+      def type_casted_binds(binds, casted_binds)
+        casted_binds || binds.map { |attr| type_cast attr.value_for_database }
       end
 
-      [attr && attr.name, value]
-    end
+      def render_bind(attr, type_casted_value)
+        value = if attr.type.binary? && attr.value
+          "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        else
+          type_casted_value
+        end
 
-    def colorize_payload_name(name, payload_name)
-      if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
-        color(name, MAGENTA, true)
-      else
-        color(name, CYAN, true)
+        [attr.name, value]
       end
-    end
 
-    def sql_color(sql)
-      case sql
+      def colorize_payload_name(name, payload_name)
+        if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
+          color(name, MAGENTA, true)
+        else
+          color(name, CYAN, true)
+        end
+      end
+
+      def sql_color(sql)
+        case sql
         when /\A\s*rollback/mi
           RED
         when /select .*for update/mi, /\A\s*lock/mi
@@ -87,12 +83,16 @@ module ActiveRecord
           CYAN
         else
           MAGENTA
+        end
       end
-    end
 
-    def logger
-      ActiveRecord::Base.logger
-    end
+      def logger
+        ActiveRecord::Base.logger
+      end
+
+      def type_cast(value)
+        ActiveRecord::Base.connection.type_cast(value)
+      end
   end
 end
 

data/lib/active_record/migration.rb

@@ -277,8 +277,10 @@ module ActiveRecord
   #
   # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes
   #   the column to a different type using the same parameters as add_column.
-  # * <tt>change_column_default(table_name, column_name, default)</tt>: Sets a
-  #   default value for +column_name+ defined by +default+ on +table_name+.
+  # * <tt>change_column_default(table_name, column_name, default_or_changes)</tt>:
+  #   Sets a default value for +column_name+ defined by +default_or_changes+ on
+  #   +table_name+. Passing a hash containing <tt>:from</tt> and <tt>:to</tt>
+  #   as +default_or_changes+ will make this change reversible in the migration.
   # * <tt>change_column_null(table_name, column_name, null, default = nil)</tt>:
   #   Sets or removes a +NOT NULL+ constraint on +column_name+. The +null+ flag
   #   indicates whether the value can be +NULL+. See
@@ -510,8 +512,8 @@ module ActiveRecord
   # Remember that you can still open your own transactions, even if you
   # are in a Migration with <tt>self.disable_ddl_transaction!</tt>.
   class Migration
-    autoload :CommandRecorder, 'active_record/migration/command_recorder'
-    autoload :Compatibility, 'active_record/migration/compatibility'
+    autoload :CommandRecorder, "active_record/migration/command_recorder"
+    autoload :Compatibility, "active_record/migration/compatibility"
 
     # This must be defined before the inherited hook, below
     class Current < Migration # :nodoc:
@@ -520,7 +522,10 @@ module ActiveRecord
     def self.inherited(subclass) # :nodoc:
       super
       if subclass.superclass == Migration
-        subclass.include Compatibility::Legacy
+        raise StandardError, "Directly inheriting from ActiveRecord::Migration is not supported. " \
+          "Please specify the Rails release the migration was written for:\n" \
+          "\n" \
+          "  class #{subclass} < ActiveRecord::Migration[4.2]"
       end
     end
 
@@ -555,9 +560,9 @@ module ActiveRecord
 
       private
 
-      def connection
-        ActiveRecord::Base.connection
-      end
+        def connection
+          ActiveRecord::Base.connection
+        end
     end
 
     class << self
@@ -687,7 +692,7 @@ module ActiveRecord
       connection.respond_to?(:reverting) && connection.reverting
     end
 
-    class ReversibleBlockHelper < Struct.new(:reverting) # :nodoc:
+    ReversibleBlockHelper = Struct.new(:reverting) do # :nodoc:
       def up
         yield unless reverting
       end
@@ -725,7 +730,7 @@ module ActiveRecord
     #    end
     def reversible
       helper = ReversibleBlockHelper.new(reverting?)
-      execute_block{ yield helper }
+      execute_block { yield helper }
     end
 
     # Runs the given migration classes.
@@ -767,7 +772,7 @@ module ActiveRecord
       when :down then announce "reverting"
       end
 
-      time   = nil
+      time = nil
       ActiveRecord::Base.connection_pool.with_connection do |conn|
         time = Benchmark.measure do
           exec_migration(conn, direction)
@@ -795,7 +800,7 @@ module ActiveRecord
       @connection = nil
     end
 
-    def write(text="")
+    def write(text = "")
       puts(text) if verbose
     end
 
@@ -805,7 +810,7 @@ module ActiveRecord
       write "== %s %s" % [text, "=" * length]
     end
 
-    def say(message, subitem=false)
+    def say(message, subitem = false)
       write "#{subitem ? "   ->" : "--"} #{message}"
     end
 
@@ -830,7 +835,7 @@ module ActiveRecord
     end
 
     def method_missing(method, *arguments, &block)
-      arg_list = arguments.map(&:inspect) * ', '
+      arg_list = arguments.map(&:inspect) * ", "
 
       say_with_time "#{method}(#{arg_list})" do
         unless connection.respond_to? :revert
@@ -922,19 +927,18 @@ module ActiveRecord
     end
 
     private
-    def execute_block
-      if connection.respond_to? :execute_block
-        super # use normal delegation to record the block
-      else
-        yield
+      def execute_block
+        if connection.respond_to? :execute_block
+          super # use normal delegation to record the block
+        else
+          yield
+        end
       end
-    end
   end
 
   # MigrationProxy is used to defer loading of the actual migration classes
   # until they are needed
-  class MigrationProxy < Struct.new(:name, :version, :filename, :scope)
-
+  MigrationProxy = Struct.new(:name, :version, :filename, :scope) do
     def initialize(name, version, filename, scope)
       super
       @migration = nil
@@ -960,7 +964,6 @@ module ActiveRecord
         require(File.expand_path(filename))
         name.constantize.new(name, version)
       end
-
   end
 
   class NullMigration < MigrationProxy #:nodoc:
@@ -991,11 +994,11 @@ module ActiveRecord
         end
       end
 
-      def rollback(migrations_paths, steps=1)
+      def rollback(migrations_paths, steps = 1)
         move(:down, migrations_paths, steps)
       end
 
-      def forward(migrations_paths, steps=1)
+      def forward(migrations_paths, steps = 1)
         move(:up, migrations_paths, steps)
       end
 
@@ -1026,12 +1029,10 @@ module ActiveRecord
       end
 
       def get_all_versions(connection = Base.connection)
-        ActiveSupport::Deprecation.silence do
-          if connection.table_exists?(schema_migrations_table_name)
-            SchemaMigration.all.map { |x| x.version.to_i }.sort
-          else
-            []
-          end
+        if connection.table_exists?(schema_migrations_table_name)
+          SchemaMigration.all.map { |x| x.version.to_i }.sort
+        else
+          []
         end
       end
 
@@ -1052,11 +1053,15 @@ module ActiveRecord
       end
 
       def migrations_paths
-        @migrations_paths ||= ['db/migrate']
+        @migrations_paths ||= ["db/migrate"]
         # just to not break things if someone uses: migrations_path = some_string
         Array(@migrations_paths)
       end
 
+      def match_to_migration_filename?(filename) # :nodoc:
+        Migration::MigrationFilenameRegexp.match?(File.basename(filename))
+      end
+
       def parse_migration_filename(filename) # :nodoc:
         File.basename(filename).scan(Migration::MigrationFilenameRegexp).first
       end
@@ -1064,7 +1069,9 @@ module ActiveRecord
       def migrations(paths)
         paths = Array(paths)
 
-        migrations = migration_files(paths).map do |file|
+        files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]
+
+        migrations = files.map do |file|
           version, name, scope = parse_migration_filename(file)
           raise IllegalMigrationNameError.new(file) unless version
           version = version.to_i
@@ -1076,30 +1083,6 @@ module ActiveRecord
         migrations.sort_by(&:version)
       end
 
-      def migrations_status(paths)
-        paths = Array(paths)
-
-        db_list = ActiveRecord::SchemaMigration.normalized_versions
-
-        file_list = migration_files(paths).map do |file|
-          version, name, scope = parse_migration_filename(file)
-          raise IllegalMigrationNameError.new(file) unless version
-          version = ActiveRecord::SchemaMigration.normalize_migration_number(version)
-          status = db_list.delete(version) ? "up" : "down"
-          [status, version, (name + scope).humanize]
-        end.compact
-
-        db_list.map! do |version|
-          ["up", version, "********** NO FILE **********"]
-        end
-
-        (db_list + file_list).sort_by { |_, version, _| version }
-      end
-
-      def migration_files(paths)
-        Dir[*paths.flat_map { |path| "#{path}/**/[0-9]*_*.rb" }]
-      end
-
       private
 
       def move(direction, migrations_paths, steps)
@@ -1124,8 +1107,8 @@ module ActiveRecord
 
       validate(@migrations)
 
-      Base.connection.initialize_schema_migrations_table
-      Base.connection.initialize_internal_metadata_table
+      ActiveRecord::SchemaMigration.create_table
+      ActiveRecord::InternalMetadata.create_table
     end
 
     def current_version
@@ -1183,148 +1166,148 @@ module ActiveRecord
 
     private
 
-    # Used for running a specific migration.
-    def run_without_lock
-      migration = migrations.detect { |m| m.version == @target_version }
-      raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
-      result = execute_migration_in_transaction(migration, @direction)
+      # Used for running a specific migration.
+      def run_without_lock
+        migration = migrations.detect { |m| m.version == @target_version }
+        raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
+        result = execute_migration_in_transaction(migration, @direction)
 
-      record_environment
-      result
-    end
-
-    # Used for running multiple migrations up to or down to a certain value.
-    def migrate_without_lock
-      if invalid_target?
-        raise UnknownMigrationVersionError.new(@target_version)
+        record_environment
+        result
       end
 
-      result = runnable.each do |migration|
-        execute_migration_in_transaction(migration, @direction)
-      end
+      # Used for running multiple migrations up to or down to a certain value.
+      def migrate_without_lock
+        if invalid_target?
+          raise UnknownMigrationVersionError.new(@target_version)
+        end
 
-      record_environment
-      result
-    end
+        result = runnable.each do |migration|
+          execute_migration_in_transaction(migration, @direction)
+        end
 
-    # Stores the current environment in the database.
-    def record_environment
-      return if down?
-      ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
-    end
+        record_environment
+        result
+      end
 
-    def ran?(migration)
-      migrated.include?(migration.version.to_i)
-    end
+      # Stores the current environment in the database.
+      def record_environment
+        return if down?
+        ActiveRecord::InternalMetadata[:environment] = ActiveRecord::Migrator.current_environment
+      end
 
-    # Return true if a valid version is not provided.
-    def invalid_target?
-      !target && @target_version && @target_version > 0
-    end
+      def ran?(migration)
+        migrated.include?(migration.version.to_i)
+      end
 
-    def execute_migration_in_transaction(migration, direction)
-      return if down? && !migrated.include?(migration.version.to_i)
-      return if up?   &&  migrated.include?(migration.version.to_i)
+      # Return true if a valid version is not provided.
+      def invalid_target?
+        !target && @target_version && @target_version > 0
+      end
+
+      def execute_migration_in_transaction(migration, direction)
+        return if down? && !migrated.include?(migration.version.to_i)
+        return if up?   &&  migrated.include?(migration.version.to_i)
 
-      Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
+        Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger
 
-      ddl_transaction(migration) do
-        migration.migrate(direction)
-        record_version_state_after_migrating(migration.version)
+        ddl_transaction(migration) do
+          migration.migrate(direction)
+          record_version_state_after_migrating(migration.version)
+        end
+      rescue => e
+        msg = "An error has occurred, "
+        msg << "this and " if use_transaction?(migration)
+        msg << "all later migrations canceled:\n\n#{e}"
+        raise StandardError, msg, e.backtrace
       end
-    rescue => e
-      msg = "An error has occurred, "
-      msg << "this and " if use_transaction?(migration)
-      msg << "all later migrations canceled:\n\n#{e}"
-      raise StandardError, msg, e.backtrace
-    end
 
-    def target
-      migrations.detect { |m| m.version == @target_version }
-    end
+      def target
+        migrations.detect { |m| m.version == @target_version }
+      end
 
-    def finish
-      migrations.index(target) || migrations.size - 1
-    end
+      def finish
+        migrations.index(target) || migrations.size - 1
+      end
 
-    def start
-      up? ? 0 : (migrations.index(current) || 0)
-    end
+      def start
+        up? ? 0 : (migrations.index(current) || 0)
+      end
 
-    def validate(migrations)
-      name ,= migrations.group_by(&:name).find { |_,v| v.length > 1 }
-      raise DuplicateMigrationNameError.new(name) if name
+      def validate(migrations)
+        name , = migrations.group_by(&:name).find { |_, v| v.length > 1 }
+        raise DuplicateMigrationNameError.new(name) if name
 
-      version ,= migrations.group_by(&:version).find { |_,v| v.length > 1 }
-      raise DuplicateMigrationVersionError.new(version) if version
-    end
+        version , = migrations.group_by(&:version).find { |_, v| v.length > 1 }
+        raise DuplicateMigrationVersionError.new(version) if version
+      end
 
-    def record_version_state_after_migrating(version)
-      if down?
-        migrated.delete(version)
-        ActiveRecord::SchemaMigration.where(:version => version.to_s).delete_all
-      else
-        migrated << version
-        ActiveRecord::SchemaMigration.create!(version: version.to_s)
+      def record_version_state_after_migrating(version)
+        if down?
+          migrated.delete(version)
+          ActiveRecord::SchemaMigration.where(version: version.to_s).delete_all
+        else
+          migrated << version
+          ActiveRecord::SchemaMigration.create!(version: version.to_s)
+        end
       end
-    end
 
-    def self.last_stored_environment
-      return nil if current_version == 0
-      raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
+      def self.last_stored_environment
+        return nil if current_version == 0
+        raise NoEnvironmentInSchemaError unless ActiveRecord::InternalMetadata.table_exists?
 
-      environment = ActiveRecord::InternalMetadata[:environment]
-      raise NoEnvironmentInSchemaError unless environment
-      environment
-    end
+        environment = ActiveRecord::InternalMetadata[:environment]
+        raise NoEnvironmentInSchemaError unless environment
+        environment
+      end
 
-    def self.current_environment
-      ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
-    end
+      def self.current_environment
+        ActiveRecord::ConnectionHandling::DEFAULT_ENV.call
+      end
 
-    def self.protected_environment?
-      ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
-    end
+      def self.protected_environment?
+        ActiveRecord::Base.protected_environments.include?(last_stored_environment) if last_stored_environment
+      end
 
-    def up?
-      @direction == :up
-    end
+      def up?
+        @direction == :up
+      end
 
-    def down?
-      @direction == :down
-    end
+      def down?
+        @direction == :down
+      end
 
-    # Wrap the migration in a transaction only if supported by the adapter.
-    def ddl_transaction(migration)
-      if use_transaction?(migration)
-        Base.transaction { yield }
-      else
-        yield
+      # Wrap the migration in a transaction only if supported by the adapter.
+      def ddl_transaction(migration)
+        if use_transaction?(migration)
+          Base.transaction { yield }
+        else
+          yield
+        end
       end
-    end
 
-    def use_transaction?(migration)
-      !migration.disable_ddl_transaction && Base.connection.supports_ddl_transactions?
-    end
+      def use_transaction?(migration)
+        !migration.disable_ddl_transaction && Base.connection.supports_ddl_transactions?
+      end
 
-    def use_advisory_lock?
-      Base.connection.supports_advisory_locks?
-    end
+      def use_advisory_lock?
+        Base.connection.supports_advisory_locks?
+      end
 
-    def with_advisory_lock
-      lock_id = generate_migrator_advisory_lock_id
-      got_lock = Base.connection.get_advisory_lock(lock_id)
-      raise ConcurrentMigrationError unless got_lock
-      load_migrated # reload schema_migrations to be sure it wasn't changed by another process before we got the lock
-      yield
-    ensure
-      Base.connection.release_advisory_lock(lock_id) if got_lock
-    end
+      def with_advisory_lock
+        lock_id = generate_migrator_advisory_lock_id
+        got_lock = Base.connection.get_advisory_lock(lock_id)
+        raise ConcurrentMigrationError unless got_lock
+        load_migrated # reload schema_migrations to be sure it wasn't changed by another process before we got the lock
+        yield
+      ensure
+        Base.connection.release_advisory_lock(lock_id) if got_lock
+      end
 
-    MIGRATOR_SALT = 2053462845
-    def generate_migrator_advisory_lock_id
-      db_name_hash = Zlib.crc32(Base.connection.current_database)
-      MIGRATOR_SALT * db_name_hash
-    end
+      MIGRATOR_SALT = 2053462845
+      def generate_migrator_advisory_lock_id
+        db_name_hash = Zlib.crc32(Base.connection.current_database)
+        MIGRATOR_SALT * db_name_hash
+      end
   end
 end