Class: Mongoid::Migrator

Inherits:
Object
  • Object
show all
Defined in:
lib/mongoid_rails_migrations/active_record_ext/migrations.rb

Overview

:nodoc:

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

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

Returns a new instance of Migrator.



285
286
287
288
289
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 285

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

Class Attribute Details

.migrations_path ⇒ Object 



240
241
242
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 240

def migrations_path
  @migrations_path ||= ['db/migrate']
end

Class Method Details

.current_version ⇒ Object 



255
256
257
258
259
260
261
262
263
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 255

def current_version
  # sm_table = schema_migrations_table_name
  # if Base.connection.table_exists?(sm_table)
  #   get_all_versions.max || 0
  # else
  #   0
  # end
  get_all_versions.max || 0
end

.down(migrations_path, target_version = nil) ⇒ Object 



232
233
234
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 232

def down(migrations_path, target_version = nil)
  self.new(:down, migrations_path, target_version).migrate
end

.forward(migrations_path, steps = 1) ⇒ Object 



224
225
226
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 224

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

.get_all_versions ⇒ Object

def schema_migrations_table_name

# Base.table_name_prefix + 'schema_migrations' + Base.table_name_suffix
'data_migrations'

end



249
250
251
252
253
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 249

def get_all_versions
  # table = Arel::Table.new(schema_migrations_table_name)
  #         Base.connection.select_values(table.project(table['version']).to_sql).map(&:to_i).sort
  DataMigration.all.map { |datamigration| datamigration.version.to_i }.sort
end

.migrate(migrations_path, target_version = nil) ⇒ Object 



201
202
203
204
205
206
207
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 201

def migrate(migrations_path, target_version = nil)
  case
    when target_version.nil?              then up(migrations_path, target_version)
    when current_version > target_version then down(migrations_path, target_version)
    else                                       up(migrations_path, target_version)
  end
end

.proper_table_name(name) ⇒ Object 



265
266
267
268
269
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 265

def proper_table_name(name)
  # Use the Active Record objects own table_name, or pre/suffix from ActiveRecord::Base if name is a symbol/string
  # name.table_name rescue "#{ActiveRecord::Base.table_name_prefix}#{name}#{ActiveRecord::Base.table_name_suffix}"
  name
end

.rollback(migrations_path, steps = 1) ⇒ Object 



213
214
215
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 213

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

.rollback_to(migrations_path, target_version) ⇒ Object 



217
218
219
220
221
222
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 217

def rollback_to(migrations_path, target_version)
  all_versions = get_all_versions
  rollback_to = all_versions.index(target_version.to_i) + 1
  rollback_steps = all_versions.size - rollback_to
  rollback migrations_path, rollback_steps
end

.run(direction, migrations_path, target_version) ⇒ Object 



236
237
238
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 236

def run(direction, migrations_path, target_version)
  self.new(direction, migrations_path, target_version).run
end

.status(migrations_path) ⇒ Object 



209
210
211
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 209

def status(migrations_path)
  new(:up, migrations_path).status
end

.up(migrations_path, target_version = nil) ⇒ Object 



228
229
230
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 228

def up(migrations_path, target_version = nil)
  self.new(:up, migrations_path, target_version).migrate
end

Instance Method Details

#current_migration ⇒ Object 



295
296
297
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 295

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

#current_version ⇒ Object 



291
292
293
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 291

def current_version
  migrated.last || 0
end

#migrate ⇒ Object 



308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 308

def migrate
  runnable = runnable_migrations

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

    # On our way up, we skip migrating the ones we've already migrated
    next if up? && migrated.include?(migration.version.to_i)

    # On our way down, we skip reverting the ones we've never migrated
    if down? && !migrated.include?(migration.version.to_i)
      migration.announce 'never migrated, skipping'; migration.write
      next
    end

    # begin
    #   ddl_transaction do
    #     migration.migrate(@direction)
    #     record_version_state_after_migrating(migration.version)
    #   end
    # rescue => e
    #   canceled_msg = Base.connection.supports_ddl_transactions? ? "this and " : ""
    #   raise StandardError, "An error has occurred, #{canceled_msg}all later migrations canceled:\n\n#{e}", e.backtrace
    # end
    begin
      migration.migrate(@direction)
      record_version_state_after_migrating(migration.version)
    rescue => e
      output = Migration.buffer_output + "An error has occurred, #{migration.version} and all later migrations canceled:\n\n#{e}\n#{e.backtrace.join("\n")}"
      begin
        Migration.after_migrate.call(output, migration.name, @direction, true) if Migration.after_migrate
        Migration.buffer_output = nil
      rescue => error
        puts("Error in after_migrate hook: #{error}")
      end
      raise StandardError, "An error has occurred, #{migration.version} and all later migrations canceled:\n\n#{e}", e.backtrace
    end
  end
end

#migrated ⇒ Object 



415
416
417
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 415

def migrated
  @migrated_versions ||= self.class.get_all_versions
end

#migrations ⇒ Object 



360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 360

def migrations
  @migrations ||= begin
    files = Array(@migrations_path).inject([]) do |files, path|
      files += Dir["#{path}/[0-9]*_*.rb"]
    end

    migrations = files.inject([]) do |klasses, file|
      version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first

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

      if klasses.detect { |m| m.version == version }
        raise DuplicateMigrationVersionError.new(version)
      end

      if klasses.detect { |m| m.name == name.camelize }
        raise DuplicateMigrationNameError.new(name.camelize)
      end

      migration = MigrationProxy.new
      migration.name     = name.camelize
      migration.version  = version
      migration.filename = file
      klasses << migration
    end

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

#pending_migrations ⇒ Object 



392
393
394
395
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 392

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

#run ⇒ Object

Raises:



299
300
301
302
303
304
305
306
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 299

def run
  target = migrations.detect { |m| m.version == @target_version }
  raise UnknownMigrationVersionError.new(@target_version) if target.nil?
  unless (up? && migrated.include?(target.version.to_i)) || (down? && !migrated.include?(target.version.to_i))
    target.migrate(@direction)
    record_version_state_after_migrating(target.version)
  end
end

#runnable_migrations ⇒ Object 



397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 397

def runnable_migrations
  current = migrations.detect { |m| m.version == current_version }
  target = migrations.detect { |m| m.version == @target_version }

  if target.nil? && !@target_version.nil? && @target_version > 0
    raise UnknownMigrationVersionError.new(@target_version)
  end

  start = up? ? 0 : (migrations.index(current) || 0)
  finish = migrations.index(target) || migrations.size - 1
  runnable = migrations[start..finish]

  # skip the last migration if we're headed down, but not ALL the way down
  runnable.pop if down? && !target.nil?

  runnable
end

#status ⇒ Object 



348
349
350
351
352
353
354
355
356
357
358
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 348

def status
  database_name = Migration.connection.options[:database]
  puts "\ndatabase: #{database_name}\n\n"
  puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
  puts "-" * 50
  up_migrations = migrated.to_set
  migrations.each do |migration|
    status = up_migrations.include?(migration.version.to_i) ? 'up' : 'down'
    puts "#{status.center(8)}  #{migration.version.to_s.ljust(14)}  #{migration.name}"
  end
end