module ActiveDump

# File lib/active-dump.rb, line 103
def self.all_models                                           # {{{1
  return @models if @models
  eager_load!
  @models = ActiveRecord::Base.descendants.select do |m|
    (m.to_s != 'ActiveRecord::SchemaMigration') && \
     m.table_exists? && m.exists?
  end .map(&:to_s)
end

# File lib/active-dump.rb, line 113
def self.config(cfg = {})                                     # {{{1
  c1 = File.exists?(CFG_DUMP) ? YAML.load(File.read(CFG_DUMP)) : {}
  c2 = Hash[ c1.map { |k,v| [k.to_sym, v] } ]
  c3 = c2.merge cfg.reject { |k,v| v.nil? }
  c4 = { file: DUMP } .merge c3.reject { |k,v| v.nil? }
  c4[:models] && !c4[:models].empty? ? c4
                                     : c4.merge(models: all_models)
end

# File lib/active-dump.rb, line 124
def self.connection                                           # {{{1
  return @connection if @connection
  unless (ActiveRecord::Base.connection rescue nil)
    c = YAML.load ERB.new(File.read(CFG_DB)).result
    ActiveRecord::Base.establish_connection c[env]
  end
  @connection = ActiveRecord::Base.connection
end

# File lib/active-dump.rb, line 55
def self.delete(cfg)                                          # {{{1
  conn = connection
  ActiveRecord::Base.transaction do
    cfg[:models].each do |m|
      sql = "DELETE FROM #{m.constantize.quoted_table_name};"
      execute conn, cfg, sql
    end
  end
end

# File lib/active-dump.rb, line 89
def self.delete_record(conn, cfg, table, id)
  sql = "DELETE FROM #{table} WHERE id = #{id};"
  execute conn, cfg, sql
end

# File lib/active-dump.rb, line 26
def self.dump(cfg)                                            # {{{1
  data = Hash[ cfg[:models].map do |m|
    records = m.constantize.all.map(&:attributes)
    printf "dumping model %-30s: %10d record(s)\n",
      m, records.length if cfg[:verbose] or cfg[:dryrun]
    [m, records]
  end ]
  File.write cfg[:file], YAML.dump(data) unless cfg[:dryrun]
end

# File lib/active-dump.rb, line 134
def self.eager_load!                                          # {{{1
  return false if @eager_load
  if defined? ::Rails
    ::Rails::Engine.subclasses.each do |e|
      e.eager_load!
    end
    ::Rails.application.eager_load!
  end
  @eager_load = true
end

# File lib/active-dump.rb, line 146
def self.env
  @env ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
end

# File lib/active-dump.rb, line 83
def self.execute(conn, cfg, sql)
  puts sql if cfg[:verbose] or cfg[:dryrun]
  conn.execute sql unless cfg[:dryrun]
end

# File lib/active-dump.rb, line 66
def self.fix_seqs(cfg)                                        # {{{1
  conn = connection
  ActiveRecord::Base.transaction do
    cfg[:models].each do |m|
      mod = m.constantize
      seq = conn.quote_table_name mod.sequence_name
      max = mod.all.max_by(&:id)
      n   = (max ? max.id : 0) + 1;
      sql = "ALTER SEQUENCE #{seq} RESTART WITH #{n};"
      execute conn, cfg, sql
    end
  end
end

# File lib/active-dump.rb, line 95
def self.insert_record(conn, cfg, table, cols, vals)
  sql = "INSERT INTO #{table} (#{cols*','}) VALUES (#{vals*','});"
  execute conn, cfg, sql
end

# File lib/active-dump.rb, line 37
def self.restore(cfg)                                         # {{{1
  data = YAML.load File.read(cfg[:file])
  conn = connection
  ActiveRecord::Base.transaction do
    data.each do |m,records|
      table = m.constantize.quoted_table_name
      records.each do |record|
        cols = record.keys.map { |k| conn.quote_column_name k }
        vals = record.values.map { |v| conn.quote v }
        delete_record conn, cfg, table, conn.quote(record['id']) \
          if cfg[:delete]
        insert_record conn, cfg, table, cols, vals
      end
    end
  end
end