Class: ActiveRecord::Migrator

Inherits:
Object
  • Object
show all
Defined in:
activerecord/lib/active_record/migration.rb

Overview

:nodoc:

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(direction, migrations, target_version = nil) ⇒ Migrator

Returns a new instance of Migrator.

Raises:

  • (StandardError) 


908
909
910
911
912
913
914
915
916
917
918
919
 
# File 'activerecord/lib/active_record/migration.rb', line 908

def initialize(direction, migrations, target_version = nil)
  raise StandardError.new("This database does not yet support migrations") unless Base.connection.supports_migrations?

  @direction         = direction
  @target_version    = target_version
  @migrated_versions = nil
  @migrations        = migrations

  validate(@migrations)

  Base.connection.initialize_schema_migrations_table
end

Class Attribute Details

.migrations_paths ⇒ Object 



866
867
868
869
870
 
# File 'activerecord/lib/active_record/migration.rb', line 866

def migrations_paths
  @migrations_paths ||= ['db/migrate']
  # just to not break things if someone uses: migration_path = some_string
  Array(@migrations_paths)
end

Class Method Details

.current_version(connection = Base.connection) ⇒ Object 



837
838
839
 
# File 'activerecord/lib/active_record/migration.rb', line 837

def current_version(connection = Base.connection)
  get_all_versions(connection).max || 0
end

.down(migrations_paths, target_version = nil, &block) ⇒ Object 



810
811
812
813
814
815
 
# File 'activerecord/lib/active_record/migration.rb', line 810

def down(migrations_paths, target_version = nil, &block)
  migrations = migrations(migrations_paths)
  migrations.select! { |m| yield m } if block_given?

  self.new(:down, migrations, target_version).migrate
end

.forward(migrations_paths, steps = 1) ⇒ Object 



799
800
801
 
# File 'activerecord/lib/active_record/migration.rb', line 799

def forward(migrations_paths, steps=1)
  move(:up, migrations_paths, steps)
end

.get_all_versions(connection = Base.connection) ⇒ Object 



829
830
831
832
833
834
835
 
# File 'activerecord/lib/active_record/migration.rb', line 829

def get_all_versions(connection = Base.connection)
  if connection.table_exists?(schema_migrations_table_name)
    SchemaMigration.all.map { |x| x.version.to_i }.sort
  else
    []
  end
end

.last_migration ⇒ Object

:nodoc:



849
850
851
 
# File 'activerecord/lib/active_record/migration.rb', line 849

def last_migration #:nodoc:
  migrations(migrations_paths).last || NullMigration.new
end

.last_version ⇒ Object 



845
846
847
 
# File 'activerecord/lib/active_record/migration.rb', line 845

def last_version
  last_migration.version
end

.migrate(migrations_paths, target_version = nil, &block) ⇒ Object 



782
783
784
785
786
787
788
789
790
791
792
793
 
# File 'activerecord/lib/active_record/migration.rb', line 782

def migrate(migrations_paths, target_version = nil, &block)
  case
  when target_version.nil?
    up(migrations_paths, target_version, &block)
  when current_version == 0 && target_version == 0
    []
  when current_version > target_version
    down(migrations_paths, target_version, &block)
  else
    up(migrations_paths, target_version, &block)
  end
end

.migrations(paths) ⇒ Object 



876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
 
# File 'activerecord/lib/active_record/migration.rb', line 876

def migrations(paths)
  paths = Array(paths)

  files = Dir[*paths.map { |p| "#{p}/**/[0-9]*_*.rb" }]

  migrations = files.map do |file|
    version, name, scope = file.scan(/([0-9]+)_([_a-z0-9]*)\.?([_a-z0-9]*)?\.rb\z/).first

    raise IllegalMigrationNameError.new(file) unless version
    version = version.to_i
    name = name.camelize

    MigrationProxy.new(name, version, file, scope)
  end

  migrations.sort_by(&:version)
end

.migrations_path ⇒ Object 



872
873
874
 
# File 'activerecord/lib/active_record/migration.rb', line 872

def migrations_path
  migrations_paths.first
end

.needs_migration?(connection = Base.connection) ⇒ Boolean

Returns:

  • (Boolean) 


841
842
843
 
# File 'activerecord/lib/active_record/migration.rb', line 841

def needs_migration?(connection = Base.connection)
  (migrations(migrations_paths).collect(&:version) - get_all_versions(connection)).size > 0
end

.open(migrations_paths) ⇒ Object 



821
822
823
 
# File 'activerecord/lib/active_record/migration.rb', line 821

def open(migrations_paths)
  self.new(:up, migrations(migrations_paths), nil)
end

.proper_table_name(name, options = {}) ⇒ Object 



853
854
855
856
857
858
859
860
861
862
863
864
 
# File 'activerecord/lib/active_record/migration.rb', line 853

def proper_table_name(name, options = {})
  ActiveSupport::Deprecation.warn "ActiveRecord::Migrator.proper_table_name is deprecated and will be removed in Rails 4.2. Use the proper_table_name instance method on ActiveRecord::Migration instead"
  options = {
    table_name_prefix: ActiveRecord::Base.table_name_prefix,
    table_name_suffix: ActiveRecord::Base.table_name_suffix
  }.merge(options)
  if name.respond_to? :table_name
    name.table_name
  else
    "#{options[:table_name_prefix]}#{name}#{options[:table_name_suffix]}"
  end
end

.rollback(migrations_paths, steps = 1) ⇒ Object 



795
796
797
 
# File 'activerecord/lib/active_record/migration.rb', line 795

def rollback(migrations_paths, steps=1)
  move(:down, migrations_paths, steps)
end

.run(direction, migrations_paths, target_version) ⇒ Object 



817
818
819
 
# File 'activerecord/lib/active_record/migration.rb', line 817

def run(direction, migrations_paths, target_version)
  self.new(direction, migrations(migrations_paths), target_version).run
end

.schema_migrations_table_name ⇒ Object 



825
826
827
 
# File 'activerecord/lib/active_record/migration.rb', line 825

def schema_migrations_table_name
  SchemaMigration.table_name
end

.up(migrations_paths, target_version = nil) ⇒ Object 



803
804
805
806
807
808
 
# File 'activerecord/lib/active_record/migration.rb', line 803

def up(migrations_paths, target_version = nil)
  migrations = migrations(migrations_paths)
  migrations.select! { |m| yield m } if block_given?

  self.new(:up, migrations, target_version).migrate
end

Instance Method Details

#current_migration ⇒ Object Also known as: current 



925
926
927
 
# File 'activerecord/lib/active_record/migration.rb', line 925

def current_migration
  migrations.detect { |m| m.version == current_version }
end

#current_version ⇒ Object 



921
922
923
 
# File 'activerecord/lib/active_record/migration.rb', line 921

def current_version
  migrated.max || 0
end

#migrate ⇒ Object 



943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
 
# File 'activerecord/lib/active_record/migration.rb', line 943

def migrate
  if !target && @target_version && @target_version > 0
    raise UnknownMigrationVersionError.new(@target_version)
  end

  runnable.each do |migration|
    Base.logger.info "Migrating to #{migration.name} (#{migration.version})" if Base.logger

    begin
      execute_migration_in_transaction(migration, @direction)
    rescue => e
      canceled_msg = use_transaction?(migration) ? "this and " : ""
      raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
    end
  end
end

#migrated ⇒ Object 



980
981
982
 
# File 'activerecord/lib/active_record/migration.rb', line 980

def migrated
  @migrated_versions ||= Set.new(self.class.get_all_versions)
end

#migrations ⇒ Object 



971
972
973
 
# File 'activerecord/lib/active_record/migration.rb', line 971

def migrations
  down? ? @migrations.reverse : @migrations.sort_by(&:version)
end

#pending_migrations ⇒ Object 



975
976
977
978
 
# File 'activerecord/lib/active_record/migration.rb', line 975

def pending_migrations
  already_migrated = migrated
  migrations.reject { |m| already_migrated.include?(m.version) }
end

#run ⇒ Object

Raises:



930
931
932
933
934
935
936
937
938
939
940
941
 
# File 'activerecord/lib/active_record/migration.rb', line 930

def run
  migration = migrations.detect { |m| m.version == @target_version }
  raise UnknownMigrationVersionError.new(@target_version) if migration.nil?
  unless (up? && migrated.include?(migration.version.to_i)) || (down? && !migrated.include?(migration.version.to_i))
    begin
      execute_migration_in_transaction(migration, @direction)
    rescue => e
      canceled_msg = use_transaction?(migration) ? ", this migration was canceled" : ""
      raise StandardError, "An error has occurred#{canceled_msg}:\n\n#{e}", e.backtrace
    end
  end
end

#runnable ⇒ Object 



960
961
962
963
964
965
966
967
968
969
 
# File 'activerecord/lib/active_record/migration.rb', line 960

def runnable
  runnable = migrations[start..finish]
  if up?
    runnable.reject { |m| ran?(m) }
  else
    # skip the last migration if we're headed down, but not ALL the way down
    runnable.pop if target
    runnable.find_all { |m| ran?(m) }
  end
end