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.



277
278
279
280
281
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 277

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 



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

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

Class Method Details

.current_version ⇒ Object 



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

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 



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

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

.forward(migrations_path, steps = 1) ⇒ Object 



216
217
218
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 216

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



241
242
243
244
245
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 241

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 



193
194
195
196
197
198
199
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 193

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 



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

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 



205
206
207
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 205

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

.rollback_to(migrations_path, target_version) ⇒ Object 



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

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 



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

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

.status(migrations_path) ⇒ Object 



201
202
203
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 201

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

.up(migrations_path, target_version = nil) ⇒ Object 



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

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

Instance Method Details

#current_migration ⇒ Object 



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

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

#current_version ⇒ Object 



283
284
285
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 283

def current_version
  migrated.last || 0
end

#migrate ⇒ Object 



300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 300

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
      raise StandardError, "An error has occurred, #{migration.version} and all later migrations canceled:\n\n#{e}", e.backtrace
    end
  end
end

#migrated ⇒ Object 



400
401
402
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 400

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

#migrations ⇒ Object 



345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 345

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 



377
378
379
380
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 377

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

#run ⇒ Object

Raises:



291
292
293
294
295
296
297
298
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 291

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 



382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 382

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 



333
334
335
336
337
338
339
340
341
342
343
 
# File 'lib/mongoid_rails_migrations/active_record_ext/migrations.rb', line 333

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