dump 1.0.5 → 1.0.6

data/lib/{dump_rake → dump}/env/filter.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-class DumpRake
+module Dump
   module Env
     # Filter strings by simple pattern:
     #   'a,b,c' will pass only 'a', 'b' and 'c'

data/lib/dump/rails_root.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Dump
+  # Get rails app root (Rails.root or RAILS_ROOT or fail)
+  module RailsRoot
+    def rails_root
+      case
+      when defined?(Rails)
+        Rails.root
+      when defined?(RAILS_ROOT)
+        RAILS_ROOT
+      else
+        fail 'Unknown rails app root'
+      end.to_s
+    end
+
+    Dump.extend RailsRoot
+  end
+end

data/lib/{dump_rake/dump_reader.rb → dump/reader.rb}

@@ -1,6 +1,14 @@
-class DumpRake
+require 'dump/snapshot'
+require 'dump/archive_tar_minitar'
+require 'dump/assets'
+require 'progress'
+require 'rake'
+require 'zlib'
+require 'tempfile'
+
+module Dump
   # Reading dump
-  class DumpReader < Dump
+  class Reader < Snapshot
     attr_reader :stream, :config
 
     def self.restore(path)
@@ -118,10 +126,10 @@ class DumpRake
 
     def migrate_down
       case
-      when DumpRake::Env.downcase(:migrate_down) == 'reset'
+      when Dump::Env.downcase(:migrate_down) == 'reset'
         Rake::Task['db:drop'].invoke
         Rake::Task['db:create'].invoke
-      when !DumpRake::Env.no?(:migrate_down)
+      when !Dump::Env.no?(:migrate_down)
         return unless avaliable_tables.include?('schema_migrations')
         find_entry('schema_migrations.dump') do |entry|
           migrated = table_rows('schema_migrations').map{ |row| row['version'] }
@@ -134,7 +142,7 @@ class DumpRake
 
           unless migrate_down.empty?
             migrate_down.reverse.with_progress('Migrating down') do |version|
-              DumpRake::Env.with_env('VERSION' => version) do
+              Dump::Env.with_env('VERSION' => version) do
                 Rake::Task['db:migrate:down'].tap do |task|
                   begin
                     task.invoke
@@ -151,13 +159,13 @@ class DumpRake
     end
 
     def restore_schema?
-      !DumpRake::Env.no?(:restore_schema)
+      !Dump::Env.no?(:restore_schema)
     end
 
     def read_schema
       return unless restore_schema?
       read_entry_to_file('schema.rb') do |f|
-        DumpRake::Env.with_env('SCHEMA' => f.path) do
+        Dump::Env.with_env('SCHEMA' => f.path) do
           Rake::Task['db:schema:load'].invoke
         end
         Rake::Task['db:schema:dump'].invoke
@@ -169,10 +177,10 @@ class DumpRake
     end
 
     def read_tables
-      return if DumpRake::Env[:restore_tables] && DumpRake::Env[:restore_tables].empty?
+      return if Dump::Env[:restore_tables] && Dump::Env[:restore_tables].empty?
       verify_connection
       config[:tables].with_progress('Tables') do |table, rows|
-        if (restore_schema? && schema_tables.include?(table)) || DumpRake::Env.filter(:restore_tables).pass?(table)
+        if (restore_schema? && schema_tables.include?(table)) || Dump::Env.filter(:restore_tables).pass?(table)
           read_table(table, rows)
         end
       end
@@ -208,7 +216,7 @@ class DumpRake
     end
 
     def read_assets
-      return if DumpRake::Env[:restore_assets] && DumpRake::Env[:restore_assets].empty?
+      return if Dump::Env[:restore_assets] && Dump::Env[:restore_assets].empty?
       return if config[:assets].blank?
 
       assets = config[:assets]
@@ -219,10 +227,10 @@ class DumpRake
         assets_count, assets_paths = nil, assets
       end
 
-      if DumpRake::Env[:restore_assets]
+      if Dump::Env[:restore_assets]
         assets_paths.each do |asset|
-          DumpRake::Assets.glob_asset_children(asset, '**/*').reverse.each do |child|
-            next unless read_asset?(child, DumpRake::RailsRoot)
+          Dump::Assets.glob_asset_children(asset, '**/*').reverse.each do |child|
+            next unless read_asset?(child, Dump.rails_root)
             case
             when File.file?(child)
               File.unlink(child)
@@ -236,20 +244,20 @@ class DumpRake
           end
         end
       else
-        DumpRake::Env.with_env(:assets => assets_paths.join(':')) do
+        Dump::Env.with_env(:assets => assets_paths.join(':')) do
           Rake::Task['assets:delete'].invoke
         end
       end
 
       read_assets_entries(assets_paths, assets_count) do |stream, root, entry, prefix|
-        if !DumpRake::Env[:restore_assets] || read_asset?(entry.full_name, prefix)
+        if !Dump::Env[:restore_assets] || read_asset?(entry.full_name, prefix)
           stream.extract_entry(root, entry)
         end
       end
     end
 
     def read_asset?(path, prefix)
-      DumpRake::Env.filter(:restore_assets, DumpRake::Assets::SPLITTER).custom_pass? do |value|
+      Dump::Env.filter(:restore_assets, Dump::Assets::SPLITTER).custom_pass? do |value|
         File.fnmatch(File.join(prefix, value), path) ||
           File.fnmatch(File.join(prefix, value, '**'), path)
       end
@@ -266,7 +274,7 @@ class DumpRake
           end
           Archive::Tar::Minitar.open(assets_tar) do |inp|
             inp.each do |entry|
-              yield inp, DumpRake::RailsRoot, entry, nil
+              yield inp, Dump.rails_root, entry, nil
               Progress.step if assets_count
             end
           end

data/lib/{dump_rake/dump.rb → dump/snapshot.rb}

@@ -1,11 +1,15 @@
 # encoding: UTF-8
 
-class DumpRake
+require 'dump/rails_root'
+require 'dump/table_manipulation'
+require 'pathname'
+
+module Dump
   # Base class for dump
-  class Dump
+  class Snapshot
     include TableManipulation
     def self.list(options = {})
-      dumps = Dir[File.join(DumpRake::RailsRoot, 'dump', options[:all] ? '*.*' : '*.tgz')].sort.select{ |path| File.file?(path) }.map{ |path| new(path) }
+      dumps = Dir[File.join(Dump.rails_root, 'dump', options[:all] ? '*.*' : '*.tgz')].sort.select{ |path| File.file?(path) }.map{ |path| new(path) }
       dumps = dumps.select{ |dump| dump.name[options[:like]] } if options[:like]
       if options[:tags]
         tags = get_filter_tags(options[:tags])
@@ -128,9 +132,9 @@ class DumpRake
 
     def assets_root_link
       prefix = 'assets'
-      Dir.mktmpdir('assets', File.join(DumpRake::RailsRoot, 'tmp')) do |dir|
+      Dir.mktmpdir('assets', File.join(Dump.rails_root, 'tmp')) do |dir|
         Dir.chdir(dir) do
-          File.symlink(DumpRake::RailsRoot, prefix)
+          File.symlink(Dump.rails_root, prefix)
           begin
             yield dir, prefix
           ensure

data/lib/{dump_rake → dump}/table_manipulation.rb

@@ -1,4 +1,6 @@
-class DumpRake
+require 'dump/env'
+
+module Dump
   # Methods to work with db using ActiveRecord
   module TableManipulation
   protected
@@ -29,7 +31,8 @@ class DumpRake
 
     def insert_into_table(table_sql, columns_sql, values_sql)
       values_sql = values_sql.join(',') if values_sql.is_a?(Array)
-      connection.insert("INSERT INTO #{table_sql} #{columns_sql} VALUES #{values_sql}", 'Loading dump')
+      sql = "INSERT INTO #{table_sql} #{columns_sql} VALUES #{values_sql}"
+      connection.insert(sql, 'Loading dump')
     end
 
     def fix_sequence!(table)
@@ -54,9 +57,10 @@ class DumpRake
     end
 
     def tables_to_dump
-      if DumpRake::Env[:tables]
+      if Dump::Env[:tables]
         avaliable_tables.select do |table|
-          schema_tables.include?(table) || DumpRake::Env.filter(:tables).pass?(table)
+          schema_tables.include?(table) ||
+            Dump::Env.filter(:tables).pass?(table)
         end
       else
         avaliable_tables - %w[sessions]
@@ -64,13 +68,14 @@ class DumpRake
     end
 
     def table_row_count(table)
-      connection.select_value("SELECT COUNT(*) FROM #{quote_table_name(table)}").to_i
+      sql = "SELECT COUNT(*) FROM #{quote_table_name(table)}"
+      connection.select_value(sql).to_i
     end
 
-    CHUNK_SIZE_MIN = 100 unless const_defined?(:CHUNK_SIZE_MIN)
-    CHUNK_SIZE_MAX = 3_000 unless const_defined?(:CHUNK_SIZE_MAX)
+    CHUNK_SIZE_MIN = 100
+    CHUNK_SIZE_MAX = 3_000
     def table_chunk_size(table)
-      expected_row_size = table_columns(table).map do |column|
+      expected_row_size = table_columns(table).sum do |column|
         case column.type
         when :text
           Math.sqrt(column.limit || 2_147_483_647)
@@ -79,8 +84,12 @@ class DumpRake
         else
           column.limit || 10
         end
-      end.sum
-      [[(10_000_000 / expected_row_size).round, CHUNK_SIZE_MIN].max, CHUNK_SIZE_MAX].min
+      end
+      [
+        CHUNK_SIZE_MIN,
+        (10_000_000 / expected_row_size).round,
+        CHUNK_SIZE_MAX,
+      ].sort[1]
     end
 
     def table_columns(table)
@@ -89,7 +98,9 @@ class DumpRake
 
     def table_has_primary_column?(table)
       # bad test for primary column, but primary even for primary column is nil
-      table_columns(table).any?{ |column| column.name == table_primary_key(table) && column.type == :integer }
+      table_columns(table).any? do |column|
+        column.name == table_primary_key(table) && column.type == :integer
+      end
     end
 
     def table_primary_key(_table)
@@ -97,10 +108,12 @@ class DumpRake
     end
 
     def each_table_row(table, row_count, &block)
-      if table_has_primary_column?(table) && row_count > (chunk_size = table_chunk_size(table))
+      chunk_size = table_chunk_size(table)
+      if table_has_primary_column?(table) && row_count > chunk_size
         # adapted from ActiveRecord::Batches
         primary_key = table_primary_key(table)
-        quoted_primary_key = "#{quote_table_name(table)}.#{quote_column_name(primary_key)}"
+        quoted_primary_key =
+          "#{quote_table_name(table)}.#{quote_column_name(primary_key)}"
         select_where_primary_key =
           "SELECT * FROM #{quote_table_name(table)}" \
             " WHERE #{quoted_primary_key} %s" \
@@ -110,7 +123,8 @@ class DumpRake
         until rows.blank?
           rows.each(&block)
           break if rows.count < chunk_size
-          rows = select_all_by_sql(select_where_primary_key % "> #{rows.last[primary_key].to_i}")
+          sql = select_where_primary_key % "> #{rows.last[primary_key].to_i}"
+          rows = select_all_by_sql(sql)
         end
       else
         table_rows(table).each(&block)

data/lib/{dump_rake/dump_writer.rb → dump/writer.rb}

@@ -1,6 +1,14 @@
-class DumpRake
+require 'dump/snapshot'
+require 'dump/archive_tar_minitar'
+require 'dump/assets'
+require 'progress'
+require 'rake'
+require 'zlib'
+require 'tempfile'
+
+module Dump
   # Creating dump
-  class DumpWriter < Dump
+  class Writer < Snapshot
     attr_reader :stream, :config
 
     def self.create(path)
@@ -42,7 +50,7 @@ class DumpRake
 
     def write_schema
       create_file('schema.rb') do |f|
-        DumpRake::Env.with_env('SCHEMA' => f.path) do
+        Dump::Env.with_env('SCHEMA' => f.path) do
           Rake::Task['db:schema:dump'].invoke
         end
       end
@@ -83,7 +91,7 @@ class DumpRake
       return if assets.blank?
 
       config[:assets] = {}
-      Dir.chdir(DumpRake::RailsRoot) do
+      Dir.chdir(Dump.rails_root) do
         assets = Dir[*assets].uniq
         assets.with_progress('Assets') do |asset|
           paths = Dir[File.join(asset, '**/*')]
@@ -110,7 +118,7 @@ class DumpRake
 
     def assets_to_dump
       Rake::Task['assets'].invoke
-      DumpRake::Env[:assets].split(DumpRake::Assets::SPLITTER)
+      Dump::Env[:assets].split(Dump::Assets::SPLITTER)
     rescue
       []
     end

data/lib/tasks/assets.rake

@@ -1,14 +1,14 @@
-require 'dump_rake'
+require 'dump'
 
 task :assets do
-  ENV['ASSETS'] ||= DumpRake::Assets.assets
+  ENV['ASSETS'] ||= Dump::Assets.assets
 end
 
 namespace :assets do
-  desc 'Delete assets' << DumpRake::Env.explain_variables_for_command(:assets)
+  desc 'Delete assets' << Dump::Env.explain_variables_for_command(:assets)
   task :delete => :assets do
     ENV['ASSETS'].split(':').each do |asset|
-      DumpRake::Assets.glob_asset_children(asset, '*').each do |child|
+      Dump::Assets.glob_asset_children(asset, '*').each do |child|
         FileUtils.remove_entry(child)
       end
     end

data/lib/tasks/dump.rake

@@ -1,26 +1,26 @@
-require 'dump_rake'
+require 'dump'
 
-desc 'Short for dump:create' << DumpRake::Env.explain_variables_for_command(:create)
+desc 'Short for dump:create' << Dump::Env.explain_variables_for_command(:create)
 task :dump => 'dump:create'
 
 namespace :dump do
-  desc 'Show avaliable versions' << DumpRake::Env.explain_variables_for_command(:versions)
+  desc 'Show avaliable versions' << Dump::Env.explain_variables_for_command(:versions)
   task :versions => :environment do
-    DumpRake.versions(DumpRake::Env.for_command(:versions))
+    Dump.versions(Dump::Env.for_command(:versions))
   end
 
-  desc 'Create dump' << DumpRake::Env.explain_variables_for_command(:create)
+  desc 'Create dump' << Dump::Env.explain_variables_for_command(:create)
   task :create => :environment do
-    DumpRake.create(DumpRake::Env.for_command(:create))
+    Dump.create(Dump::Env.for_command(:create))
   end
 
-  desc 'Restore dump' << DumpRake::Env.explain_variables_for_command(:restore)
+  desc 'Restore dump' << Dump::Env.explain_variables_for_command(:restore)
   task :restore => :environment do
-    DumpRake.restore(DumpRake::Env.for_command(:restore))
+    Dump.restore(Dump::Env.for_command(:restore))
   end
 
-  desc 'Cleanup dumps' << DumpRake::Env.explain_variables_for_command(:cleanup)
+  desc 'Cleanup dumps' << Dump::Env.explain_variables_for_command(:cleanup)
   task :cleanup => :environment do
-    DumpRake.cleanup(DumpRake::Env.for_command(:cleanup))
+    Dump.cleanup(Dump::Env.for_command(:cleanup))
   end
 end

data/script/update_readme

@@ -4,17 +4,17 @@
 require 'bundler/setup'
 
 require 'pathname'
-require 'dump_rake/env'
+require 'dump/env'
 
 readme = Pathname('README.markdown')
 lines = readme.readlines.map(&:rstrip)
 readme.open('w') do |f|
   lines.each do |line|
     line.sub!(/^`(.+?)`.*—.*$/) do
-      key, names = DumpRake::Env::DICTIONARY.find{ |_key, values| values.include?(Regexp.last_match[1])  }
+      key, names = Dump::Env::DICTIONARY.find{ |_key, values| values.include?(Regexp.last_match[1])  }
       if key
         names = names.map{ |name| "`#{name}`" }.join(', ')
-        explanation = DumpRake::Env::EXPLANATIONS[key]
+        explanation = Dump::Env::EXPLANATIONS[key]
         "#{names} — #{explanation}"
       end
     end

data/spec/cycle_spec.rb

@@ -1,10 +1,12 @@
 require 'spec_helper'
-require 'dump_rake'
+require 'dump'
 require 'tmpdir'
 
 class Chicken < ActiveRecord::Base
 end
 
+ActiveRecord::Base.logger = Logger.new(File.join(Dump.rails_root, 'log/dump.log'))
+
 def database_configs
   YAML.load(IO.read(File.expand_path('../db/database.yml', __FILE__)))
 end
@@ -56,17 +58,6 @@ def load_schema
   end
 end
 
-def in_temp_rails_app
-  old_rails_root = DumpRake::RailsRoot.dup
-  Dir.mktmpdir do |dir|
-    DumpRake::RailsRoot.replace(dir)
-    allow(Progress).to receive(:io).and_return(StringIO.new)
-    yield
-  end
-ensure
-  DumpRake::RailsRoot.replace(old_rails_root)
-end
-
 def create_chickens!(options = {})
   time = Time.local(2000, 'jan', 1, 20, 15, 1)
   data = {
@@ -131,113 +122,116 @@ end
 
 def call_rake_create(*args)
   call_rake do
-    DumpRake.create(*args)
+    Dump.create(*args)
   end
 end
 
 def call_rake_restore(*args)
   call_rake do
-    DumpRake.restore(*args)
+    Dump.restore(*args)
   end
 end
 
 describe 'full cycle' do
+  around do |example|
+    Dir.mktmpdir do |dir|
+      @tmp_dir = dir
+      example.run
+    end
+  end
+  before do
+    allow(Dump).to receive(:rails_root).and_return(@tmp_dir)
+    allow(Progress).to receive(:io).and_return(StringIO.new)
+  end
+
   begin
     database_configs
 
     adapters.each do |adapter|
-      it "should dump and restore using #{adapter}" do
-        in_temp_rails_app do
-          use_adapter(adapter) do
-            # add chickens store their attributes and create dump
-            create_chickens!(:random => 100)
-            saved_chicken_data = chicken_data
-            call_rake_create(:description => 'chickens')
-
-            # clear database
-            load_schema
-            expect(Chicken.all).to eq([])
-
-            # restore dump and verify equality
-            call_rake_restore(:version => 'chickens')
-            expect(chicken_data).to eq(saved_chicken_data)
-
-            # go throught create/restore cycle and verify equality
-            call_rake_create
-            load_schema
-            expect(Chicken.all).to be_empty
-            call_rake_restore
-            expect(chicken_data).to eq(saved_chicken_data)
-          end
+      it "dumps and restores using #{adapter}" do
+        use_adapter(adapter) do
+          # add chickens store their attributes and create dump
+          create_chickens!(:random => 100)
+          saved_chicken_data = chicken_data
+          call_rake_create(:description => 'chickens')
+
+          # clear database
+          load_schema
+          expect(Chicken.all).to eq([])
+
+          # restore dump and verify equality
+          call_rake_restore(:version => 'chickens')
+          expect(chicken_data).to eq(saved_chicken_data)
+
+          # go throught create/restore cycle and verify equality
+          call_rake_create
+          load_schema
+          expect(Chicken.all).to be_empty
+          call_rake_restore
+          expect(chicken_data).to eq(saved_chicken_data)
         end
       end
     end
 
     adapters.each do |adapter|
-      it "should not break id incrementing using #{adapter}" do
-        in_temp_rails_app do
-          use_adapter(adapter) do
-            create_chickens!(:random => 100)
-            call_rake_create(:description => 'chickens')
-            load_schema
-            call_rake_restore(:version => 'chickens')
-            create_chickens!
-          end
+      it "does not break id incrementing using #{adapter}" do
+        use_adapter(adapter) do
+          create_chickens!(:random => 100)
+          call_rake_create(:description => 'chickens')
+          load_schema
+          call_rake_restore(:version => 'chickens')
+          create_chickens!
         end
       end
     end
 
     adapters.combination(2) do |adapter_src, adapter_dst|
-      it "should dump using #{adapter_src} and restore using #{adapter_dst}" do
-        in_temp_rails_app do
-          saved_chicken_data = nil
-          use_adapter(adapter_src) do
-            expect(Chicken.all).to be_empty
-
-            create_chickens!(:random => 100)
-            saved_chicken_data = chicken_data
-            call_rake_create
-          end
+      it "dumps using #{adapter_src} and restores using #{adapter_dst}" do
+        saved_chicken_data = nil
+        use_adapter(adapter_src) do
+          expect(Chicken.all).to be_empty
+
+          create_chickens!(:random => 100)
+          saved_chicken_data = chicken_data
+          call_rake_create
+        end
 
-          use_adapter(adapter_dst) do
-            expect(Chicken.all).to be_empty
+        use_adapter(adapter_dst) do
+          expect(Chicken.all).to be_empty
 
-            call_rake_restore
-            expect(chicken_data).to eq(saved_chicken_data)
-          end
+          call_rake_restore
+          expect(chicken_data).to eq(saved_chicken_data)
         end
       end
     end
 
-    it 'should create same dump for all adapters' do
-      in_temp_rails_app do
-        dumps = []
-        adapters.each do |adapter|
-          use_adapter(adapter) do
-            dump_name = call_rake_create(:desc => adapter)[:stdout].strip
-            dump_path = File.join(DumpRake::RailsRoot, 'dump', dump_name)
-
-            data = []
-            Zlib::GzipReader.open(dump_path) do |gzip|
-              Archive::Tar::Minitar.open(gzip, 'r') do |stream|
-                stream.each do |entry|
-                  entry_data = if entry.full_name == 'schema.rb'
-                    entry.read
-                  else
-                    Marshal.load(entry.read)
-                  end
-                  data << [entry.full_name, entry_data]
+    it 'creates same dump for all adapters' do
+      dumps = []
+      adapters.each do |adapter|
+        use_adapter(adapter) do
+          dump_name = call_rake_create(:desc => adapter)[:stdout].strip
+          dump_path = File.join(Dump.rails_root, 'dump', dump_name)
+
+          data = []
+          Zlib::GzipReader.open(dump_path) do |gzip|
+            Archive::Tar::Minitar.open(gzip, 'r') do |stream|
+              stream.each do |entry|
+                entry_data = if entry.full_name == 'schema.rb'
+                  entry.read
+                else
+                  Marshal.load(entry.read)
                 end
+                data << [entry.full_name, entry_data]
               end
             end
-            dumps << {:path => dump_path, :data => data.sort}
           end
+          dumps << {:path => dump_path, :data => data.sort}
         end
+      end
 
-        dumps.combination(2) do |dump_a, dump_b|
-          expect(dump_a[:path]).not_to eq(dump_b[:path])
-          expect(dump_a[:data]).to eq(dump_b[:data])
-        end
+      dumps.combination(2) do |dump_a, dump_b|
+        expect(dump_a[:path]).not_to eq(dump_b[:path])
+        expect(dump_a[:data]).to eq(dump_b[:data])
       end
     end
   rescue Errno::ENOENT => e