Module: ActiveDump

Defined in:
lib/active-dump.rb,
lib/active-dump/rake.rb,
lib/active-dump/rails.rb,
lib/active-dump/version.rb

Overview

namespace

Defined Under Namespace

Modules: Rake Classes: Railtie

Constant Summary collapse

CFG_DB = 
'config/database.yml'
CFG_DUMP = 
'config/active-dump.yml'
DUMP = 
'db/data.yml'
VERSION = 
'0.2.2'
DATE = 
'2014-01-21'

Class Method Summary collapse

Class Method Details

.all_models ⇒ Object

get all existing models' names



103
104
105
106
107
108
109
110
 
# 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

.config(cfg = {}) ⇒ Object

configuration



113
114
115
116
117
118
119
120
 
# 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

.connection ⇒ Object

TODO:

use model?!

ActiveRecord connection



124
125
126
127
128
129
130
131
 
# 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

.delete(cfg) ⇒ Object

delete all records



55
56
57
58
59
60
61
62
63
 
# 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

.delete_record(conn, cfg, table, id) ⇒ Object

delete record w/ id; make sure everything is quoted !!!



89
90
91
92
 
# 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

.dump(cfg) ⇒ Object

dump to yaml



26
27
28
29
30
31
32
33
34
 
# 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

.eager_load! ⇒ Object

eager_load! all rails engines' models (if Rails is defined)



134
135
136
137
138
139
140
141
142
143
 
# File 'lib/active-dump.rb', line 134

def self.eager_load!                                          # {{{1
  return false if @eager_load
  if defined? ::Rails
    ::Rails::Engine::Railties.engines.each do |e|
      e.eager_load!
    end
    ::Rails.application.eager_load!
  end
  @eager_load = true
end

.env ⇒ Object

like Rails.env; (cached)



146
147
148
 
# File 'lib/active-dump.rb', line 146

def self.env
  @env ||= ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
end

.execute(conn, cfg, sql) ⇒ Object

execute sql (optionally verbose)



83
84
85
86
 
# 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

.fix_seqs(cfg) ⇒ Object

fix postgresql sequences



66
67
68
69
70
71
72
73
74
75
76
77
78
 
# 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

.insert_record(conn, cfg, table, cols, vals) ⇒ Object

insert data; make sure everything is quoted !!!



95
96
97
98
 
# 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

.restore(cfg) ⇒ Object

restore from yaml; optionally delete existing records first



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# 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