class ActiveRecord::ModelSpaces::Context

holds the current and working tables for a ModelSpace

Attributes

current_model_versions[R]
model_space[R]
model_space_key[R]
persistor[R]
working_model_versions[R]

Public Class Methods

drop_tables(model_space, model_space_key) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 39
def self.drop_tables(model_space, model_space_key)
  model_space.registered_model_keys.map do |model_name|
    m = Util.model_from_name(model_name)
    tm = TableManager.new(m)

    all_table_names = (0..model_space.history_versions(m)).map do |v|
      TableNames.table_name(model_space.name, model_space_key, model_space.base_table_name(m), model_space.history_versions(m), v)
    end

    all_table_names.each do |table_name|
      tm.drop_table(table_name)
    end
  end
end
new(model_space, model_space_key, persistor) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 18
def initialize(model_space, model_space_key, persistor)
  @model_space = model_space
  @model_space_key = model_space_key.to_sym
  @persistor = persistor
  read_versions
  create_tables
end

Public Instance Methods

base_table_name(model) click to toggle source

base table name

# File lib/active_record/model_spaces/context.rb, line 61
def base_table_name(model)
  model_space.base_table_name(model)
end
commit() click to toggle source
# File lib/active_record/model_spaces/context.rb, line 155
def commit
  persistor.update_model_space_model_versions(model_space.name, model_space_key, current_model_versions.merge(working_model_versions))
end
create_tables() click to toggle source
# File lib/active_record/model_spaces/context.rb, line 31
def create_tables
  model_space.registered_model_keys.map do |model_name|
    m = Util.model_from_name(model_name)
    tm = TableManager.new(m)
    tm.create_table(base_table_name(m), current_table_name(m))
  end
end
current_table_name(model) click to toggle source

current table_name, seen by everyone outside of this context

# File lib/active_record/model_spaces/context.rb, line 71
def current_table_name(model)
  table_name_from_model_version(model, get_current_model_version(model))
end
hoover() click to toggle source

copy all data to the base model-space tables and drop all history tables

# File lib/active_record/model_spaces/context.rb, line 123
def hoover
  raise "can't hoover with active working versions: #{working_model_versions.keys.inspect}" if !working_model_versions.empty?

  model_names = model_space.registered_model_keys

  new_versions = Hash[ model_names.map do |model_name|
                         m = Util.model_from_name(model_name)
                         base_name = base_table_name(m)
                         current_name = current_table_name(m)
                         hoovered_name = hoovered_table_name(m)

                         tm = TableManager.new(m)

                         # copy to hoovered table
                         if current_name != hoovered_name
                           tm.recreate_table(base_name, hoovered_name)
                           tm.copy_table(current_name, hoovered_name)
                         end

                         # drop history tables
                         (1..model_space.history_versions(m)).map do |v|
                           htn = table_name_from_model_version(m, v)
                           tm.drop_table(htn)
                         end

                         [model_name, 0]
                       end ]
  persistor.update_model_space_model_versions(new_versions)

  read_versions
end
hoovered_table_name(model) click to toggle source

table_name for version 0

# File lib/active_record/model_spaces/context.rb, line 66
def hoovered_table_name(model)
  table_name_from_model_version(model, 0)
end
new_version(model, copy_old_version=false, &block) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 87
def new_version(model, copy_old_version=false, &block)
  raise "new_version: a block must be supplied" if !block

  if get_working_model_version(model)
    block.call # nothing to do
  else
    current_version = get_current_model_version(model)
    next_version = TableNames.next_version(model_space.history_versions(model), current_version)

    tm = TableManager.new(model)
    ok = false
    begin
      btn = base_table_name(model)
      ctn = current_table_name(model)
      ntn = next_table_name(model)
      if next_version != current_version
        tm.recreate_table(btn, ntn)
        tm.copy_table(ctn, ntn) if copy_old_version
      else # no history
        tm.truncate_table(ntn) if !copy_old_version
      end
      set_working_model_version(model, next_version)
      r = block.call
      ok = true
      r
    ensure
      delete_working_model_version(model) if !ok
    end
  end
end
next_table_name(model) click to toggle source

table_name which would be seen by this context in or after a new_version/updated_version. always returns a name

# File lib/active_record/model_spaces/context.rb, line 76
def next_table_name(model)
  current_version = get_current_model_version(model)
  next_version = TableNames.next_version(model_space.history_versions(model), current_version)
  table_name_from_model_version(model, next_version)
end
read_versions() click to toggle source
# File lib/active_record/model_spaces/context.rb, line 26
def read_versions
  @current_model_versions = persistor.read_model_space_model_versions(model_space.name, model_space_key)
  @working_model_versions = {}
end
table_name(model) click to toggle source

implements the Model.table_name method

# File lib/active_record/model_spaces/context.rb, line 55
def table_name(model)
  version = get_working_model_version(model) || get_current_model_version(model)
  table_name_from_model_version(model, version)
end
updated_version(model, &block) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 118
def updated_version(model, &block)
  new_version(model, true, &block)
end
working_table_name(model) click to toggle source

table_name of working table, seen by this context in or after new_version/updated_version. null if no new_version/updated_version has been issued/completed

# File lib/active_record/model_spaces/context.rb, line 83
def working_table_name(model)
  table_name_from_model_version(model, get_working_model_version(model)) if get_working_model_version(model)
end

Private Instance Methods

delete_working_model_version(model) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 179
def delete_working_model_version(model)
  self.working_model_versions.delete(model_space.registered_model_name(model))
end
get_current_model_version(model) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 165
def get_current_model_version(model)
  raise "#{model}: not registered with ModelSpace: #{model_space.name}" if !model_space.is_registered?(model)
  self.current_model_versions[model_space.registered_model_name(model)] || 0
end
get_working_model_version(model) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 170
def get_working_model_version(model)
  raise "#{model}: not registered with ModelSpace: #{model_space.name}" if !model_space.is_registered?(model)
  self.working_model_versions[model_space.registered_model_name(model)]
end
set_working_model_version(model, version) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 175
def set_working_model_version(model, version)
  self.working_model_versions[model_space.registered_model_name(model)] = version
end
table_name_from_model_version(model, version) click to toggle source
# File lib/active_record/model_spaces/context.rb, line 161
def table_name_from_model_version(model, version)
  TableNames.table_name(model_space.name, model_space_key, model_space.base_table_name(model), model_space.history_versions(model), version)
end