Class: ActiveColumn::Migrator

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

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

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

Returns a new instance of Migrator.



144
145
146
147
148
149
150
151
152
153
 
# File 'lib/active_column/migration.rb', line 144

def initialize(direction, migrations_path, target_version = nil)
  cf = ActiveColumn::Tasks::ColumnFamily.new
  sm_cf = self.class.schema_migrations_column_family

  unless cf.exists?(sm_cf)
    cf.create(sm_cf, :comparator_type => 'LongType')
  end

  @direction, @migrations_path, @target_version = direction, migrations_path, target_version
end

Class Method Details

.current_version ⇒ Object 



119
120
121
122
123
124
125
126
127
 
# File 'lib/active_column/migration.rb', line 119

def self.current_version
  sm_cf = schema_migrations_column_family
  cf = ActiveColumn::Tasks::ColumnFamily.new
  if cf.exists?(sm_cf)
    get_all_versions.max || 0
  else
    0
  end
end

.down(migrations_path, target_version = nil) ⇒ Object 



98
99
100
 
# File 'lib/active_column/migration.rb', line 98

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

.forward(migrations_path, steps = 1) ⇒ Object 



90
91
92
 
# File 'lib/active_column/migration.rb', line 90

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

.get_all_versions ⇒ Object 



114
115
116
117
 
# File 'lib/active_column/migration.rb', line 114

def self.get_all_versions
  cas = ActiveColumn.connection
  cas.get(schema_migrations_column_family, 'all').map {|(name, _value)| name.to_i}.sort
end

.migrate(migrations_path, target_version = nil) ⇒ Object 



74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/active_column/migration.rb', line 74

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

.migrations_path ⇒ Object 



106
107
108
 
# File 'lib/active_column/migration.rb', line 106

def self.migrations_path
  'ks/migrate'
end

.rollback(migrations_path, steps = 1) ⇒ Object 



86
87
88
 
# File 'lib/active_column/migration.rb', line 86

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

.run(direction, migrations_path, target_version) ⇒ Object 



102
103
104
 
# File 'lib/active_column/migration.rb', line 102

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

.schema_migrations_column_family ⇒ Object 



110
111
112
 
# File 'lib/active_column/migration.rb', line 110

def self.schema_migrations_column_family
  :schema_migrations
end

.up(migrations_path, target_version = nil) ⇒ Object 



94
95
96
 
# File 'lib/active_column/migration.rb', line 94

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

Instance Method Details

#current_migration ⇒ Object 



159
160
161
 
# File 'lib/active_column/migration.rb', line 159

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

#current_version ⇒ Object 



155
156
157
 
# File 'lib/active_column/migration.rb', line 155

def current_version
  migrated.last || 0
end

#migrate ⇒ Object 



172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/active_column/migration.rb', line 172

def migrate
  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.each do |migration|
    #puts "Migrating to #{migration.name} (#{migration.version})"

    # 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

    migration.migrate(@direction)
    record_version_state_after_migrating(migration)
  end
end

#migrated ⇒ Object 



239
240
241
 
# File 'lib/active_column/migration.rb', line 239

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

#migrations ⇒ Object 



204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/active_column/migration.rb', line 204

def migrations
  @migrations ||= begin
    files = Dir["#{@migrations_path}/[0-9]*_*.rb"]

    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 { |m| m.version }
    down? ? migrations.reverse : migrations
  end
end

#pending_migrations ⇒ Object 



234
235
236
237
 
# File 'lib/active_column/migration.rb', line 234

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

#run ⇒ Object

Raises:



163
164
165
166
167
168
169
170
 
# File 'lib/active_column/migration.rb', line 163

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)
  end
end