dump 1.0.5 → 1.0.6

data/spec/{lib/dump_rake → dump}/env/filter_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
+require 'dump/env/filter'
 
-Filter = DumpRake::Env::Filter
-describe Filter do
-  it 'should pass everything if initialized with nil' do
-    filter = Filter.new(nil)
+describe Dump::Env::Filter do
+  it 'passes everything if initialized with nil' do
+    filter = described_class.new(nil)
     expect(filter.pass?('a')).to be_truthy
     expect(filter.pass?('b')).to be_truthy
     expect(filter.pass?('c')).to be_truthy
     expect(filter.pass?('d')).to be_truthy
   end
 
-  it 'should pass only specified values' do
-    filter = Filter.new('a,c')
+  it 'passes only specified values' do
+    filter = described_class.new('a,c')
     expect(filter.pass?('a')).to be_truthy
     expect(filter.pass?('b')).to be_falsey
     expect(filter.pass?('c')).to be_truthy
     expect(filter.pass?('d')).to be_falsey
   end
 
-  it 'should not pass anything if initialized empty' do
-    filter = Filter.new('')
+  it 'does not pass anything if initialized empty' do
+    filter = described_class.new('')
     expect(filter.pass?('a')).to be_falsey
     expect(filter.pass?('b')).to be_falsey
     expect(filter.pass?('c')).to be_falsey
@@ -27,16 +27,16 @@ describe Filter do
   end
 
   describe 'when initialized with -' do
-    it 'should pass everything except specified values' do
-      filter = Filter.new('-a,c')
+    it 'passes everything except specified values' do
+      filter = described_class.new('-a,c')
       expect(filter.pass?('a')).to be_falsey
       expect(filter.pass?('b')).to be_truthy
       expect(filter.pass?('c')).to be_falsey
       expect(filter.pass?('d')).to be_truthy
     end
 
-    it 'should pass everything if initialized empty' do
-      filter = Filter.new('-')
+    it 'passes everything if initialized empty' do
+      filter = described_class.new('-')
       expect(filter.pass?('a')).to be_truthy
       expect(filter.pass?('b')).to be_truthy
       expect(filter.pass?('c')).to be_truthy
@@ -45,8 +45,8 @@ describe Filter do
   end
 
   describe 'custom_pass?' do
-    it 'should pass only when any call to block returns true' do
-      filter = Filter.new('a,c')
+    it 'passes only when any call to block returns true' do
+      filter = described_class.new('a,c')
       expect(filter.custom_pass?{ |value| value == 'a' }).to be_truthy
       expect(filter.custom_pass?{ |value| value == 'b' }).to be_falsey
       expect(filter.custom_pass?{ |value| value == 'c' }).to be_truthy

data/spec/dump/env_spec.rb

@@ -0,0 +1,139 @@
+require 'spec_helper'
+require 'dump/env'
+
+describe Dump::Env do
+  def silence_warnings
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  before do
+    silence_warnings do
+      @old_env, ENV = ENV, {}
+    end
+  end
+
+  after do
+    silence_warnings do
+      ENV = @old_env
+    end
+  end
+
+  describe 'with_env' do
+    it 'sets env to new_value for duration of block' do
+      ENV['LIKE'] = 'old_value'
+
+      expect(ENV['LIKE']).to eq('old_value')
+      described_class.with_env('LIKE' => 'new_value') do
+        expect(ENV['LIKE']).to eq('new_value')
+      end
+      expect(ENV['LIKE']).to eq('old_value')
+    end
+
+    it 'uses dictionary' do
+      ENV['LIKE'] = 'old_value'
+
+      expect(ENV['LIKE']).to eq('old_value')
+      described_class.with_env(:like => 'new_value') do
+        expect(ENV['LIKE']).to eq('new_value')
+      end
+      expect(ENV['LIKE']).to eq('old_value')
+    end
+  end
+
+  describe '[]' do
+    it 'mimics ENV' do
+      ENV['VERSION'] = 'VERSION_value'
+      expect(described_class['VERSION']).to eq(ENV['VERSION'])
+    end
+
+    it 'returns nil on non existing env variable' do
+      expect(described_class['DESCRIPTON']).to eq(nil)
+    end
+
+    it 'gets first value that is set' do
+      ENV['VERSION'] = 'VERSION_value'
+      expect(described_class[:like]).to eq('VERSION_value')
+      ENV['VER'] = 'VER_value'
+      expect(described_class[:like]).to eq('VER_value')
+      ENV['LIKE'] = 'LIKE_value'
+      expect(described_class[:like]).to eq('LIKE_value')
+    end
+
+    it 'returns nil for unset variable' do
+      expect(described_class[:desc]).to eq(nil)
+    end
+  end
+
+  describe 'filter' do
+    before do
+      described_class.instance_variable_set(:@filters, nil)
+    end
+
+    it 'returns Filter' do
+      ENV['TABLES'] = 'a,b,c'
+      filter = described_class.filter('TABLES')
+      expect(filter).to be_instance_of(described_class::Filter)
+      expect(filter.invert).to be_falsey
+      expect(filter.values).to eq(%w[a b c])
+    end
+
+    it 'caches created filter' do
+      ENV['TABLES'] = 'a,b,c'
+      ENV['TABLES2'] = 'a,b,c'
+      expect(described_class::Filter).to receive(:new).with('a,b,c', nil).once
+      described_class.filter('TABLES')
+      described_class.filter('TABLES')
+      described_class.filter('TABLES2')
+    end
+  end
+
+  describe 'for_command' do
+    describe 'when no vars present' do
+      it 'returns empty hash for every command' do
+        expect(described_class.for_command(:create)).to eq({})
+        expect(described_class.for_command(:restore)).to eq({})
+        expect(described_class.for_command(:versions)).to eq({})
+        expect(described_class.for_command(:bad)).to eq({})
+      end
+
+      it 'returns empty hash for every command when asking for string keys' do
+        expect(described_class.for_command(:create, true)).to eq({})
+        expect(described_class.for_command(:restore, true)).to eq({})
+        expect(described_class.for_command(:versions, true)).to eq({})
+        expect(described_class.for_command(:bad, true)).to eq({})
+      end
+    end
+
+    describe 'when vars are present' do
+      before do
+        ENV['LIKE'] = 'Version'
+        ENV['DESC'] = 'Description'
+      end
+
+      it 'returns hash with symbol keys for every command' do
+        expect(described_class.for_command(:create)).to eq({:desc => 'Description'})
+        expect(described_class.for_command(:restore)).to eq({:like => 'Version'})
+        expect(described_class.for_command(:versions)).to eq({:like => 'Version'})
+        expect(described_class.for_command(:bad)).to eq({})
+      end
+
+      it 'returns hash with symbol keys for every command when asking for string keys' do
+        expect(described_class.for_command(:create, true)).to eq({'DESC' => 'Description'})
+        expect(described_class.for_command(:restore, true)).to eq({'LIKE' => 'Version'})
+        expect(described_class.for_command(:versions, true)).to eq({'LIKE' => 'Version'})
+        expect(described_class.for_command(:bad, true)).to eq({})
+      end
+    end
+  end
+
+  describe 'stringify!' do
+    it 'converts keys to strings' do
+      @env = {:desc => 'text', :tags => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'}
+      described_class.stringify!(@env)
+      expect(@env).to eq({'DESC' => 'text', 'TAGS' => 'a b c', 'LEAVE' => 'none', 'OTHER' => 'data'})
+    end
+  end
+end

data/spec/{lib/dump_rake → dump}/rails_root_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'dump/rails_root'
 
 def temp_remove_const(where, which)
   around do |example|
@@ -14,32 +15,29 @@ def temp_remove_const(where, which)
   end
 end
 
-describe 'RailsRoot' do
+describe Dump::RailsRoot do
+  include described_class
+
   before do
     @root = double('root')
-    expect(@root).to receive(:to_s).and_return(@root)
+    allow(@root).to receive(:to_s).and_return(@root)
   end
 
   temp_remove_const Object, :Rails
   temp_remove_const Object, :RAILS_ROOT
-  temp_remove_const DumpRake, :RailsRoot
 
-  it 'should use Rails if it is present' do
+  it 'uses Rails if it is present' do
     Object.const_set('Rails', double('rails'))
     expect(Rails).to receive(:root).and_return(@root)
-    load 'dump_rake/rails_root.rb'
-    expect(DumpRake::RailsRoot).to equal(@root)
+    expect(rails_root).to equal(@root)
   end
 
-  it 'should use RAILS_ROOT if it is present' do
+  it 'uses RAILS_ROOT if it is present' do
     Object.const_set('RAILS_ROOT', @root)
-    load 'dump_rake/rails_root.rb'
-    expect(DumpRake::RailsRoot).to equal(@root)
+    expect(rails_root).to equal(@root)
   end
 
-  it 'should use Dir.pwd else' do
-    expect(Dir).to receive(:pwd).and_return(@root)
-    load 'dump_rake/rails_root.rb'
-    expect(DumpRake::RailsRoot).to equal(@root)
+  it 'fails otherwaise' do
+    expect{ rails_root }.to raise_error
   end
 end

data/spec/{lib/dump_rake/dump_reader_spec.rb → dump/reader_spec.rb}

@@ -1,22 +1,22 @@
 require 'spec_helper'
-require 'dump_rake'
+require 'dump/reader'
 require 'active_record/migration'
 
-DumpReader = DumpRake::DumpReader
-describe DumpReader do
+Reader = Dump::Reader
+describe Reader do
   describe 'restore' do
-    it 'should create selves instance and open' do
+    it 'creates instance and opens' do
       @dump = double('dump')
       expect(@dump).to receive(:open)
-      expect(DumpReader).to receive(:new).with('/abc/123.tmp').and_return(@dump)
-      DumpReader.restore('/abc/123.tmp')
+      expect(described_class).to receive(:new).with('/abc/123.tmp').and_return(@dump)
+      described_class.restore('/abc/123.tmp')
     end
 
-    it 'should call dump subroutines' do
+    it 'calls dump subroutines' do
       @dump = double('dump')
       allow(@dump).to receive(:open).and_yield(@dump)
       allow(@dump).to receive(:silence).and_yield
-      allow(DumpReader).to receive(:new).and_return(@dump)
+      allow(described_class).to receive(:new).and_return(@dump)
 
       expect(@dump).to receive(:read_config).ordered
       expect(@dump).to receive(:migrate_down).ordered
@@ -24,14 +24,14 @@ describe DumpReader do
       expect(@dump).to receive(:read_tables).ordered
       expect(@dump).to receive(:read_assets).ordered
 
-      DumpReader.restore('/abc/123.tmp')
+      described_class.restore('/abc/123.tmp')
     end
   end
 
   describe 'summary' do
-    Summary = DumpReader::Summary
+    Summary = Reader::Summary
     describe Summary do
-      it 'should format text' do
+      it 'formats text' do
         @summary = Summary.new
         @summary.header 'One'
         @summary.data(%w[fff ggg jjj ppp qqq www])
@@ -57,18 +57,18 @@ describe DumpReader do
         expect("#{@summary}").to eq(output.gsub(/#{output[/^\s+/]}/, '  '))
       end
 
-      it 'should pluralize' do
+      it 'pluralizes' do
         expect(Summary.pluralize(0, 'file')).to eq('0 files')
         expect(Summary.pluralize(1, 'file')).to eq('1 file')
         expect(Summary.pluralize(10, 'file')).to eq('10 files')
       end
     end
 
-    it 'should create selves instance and open' do
+    it 'creates instance and opens' do
       @dump = double('dump')
       expect(@dump).to receive(:open)
-      expect(DumpReader).to receive(:new).with('/abc/123.tmp').and_return(@dump)
-      DumpReader.summary('/abc/123.tmp')
+      expect(described_class).to receive(:new).with('/abc/123.tmp').and_return(@dump)
+      described_class.summary('/abc/123.tmp')
     end
 
     {
@@ -76,14 +76,14 @@ describe DumpReader do
       {'path/a' => 10, 'path/b' => 20} => ['path/a: 10 entries', 'path/b: 20 entries'],
       %w[path/a path/b] => %w[path/a path/b],
     }.each do |assets, formatted_assets|
-      it 'should call dump subroutines and create summary' do
+      it 'calls dump subroutines and creates summary' do
         tables = {'a' => 10, 'b' => 20, 'c' => 666}
         formatted_tables = ['a: 10 rows', 'b: 20 rows', 'c: 666 rows']
 
         @dump = double('dump')
         allow(@dump).to receive(:config).and_return(:tables => tables, :assets => assets)
         allow(@dump).to receive(:open).and_yield(@dump)
-        allow(DumpReader).to receive(:new).and_return(@dump)
+        allow(described_class).to receive(:new).and_return(@dump)
         expect(@dump).to receive(:read_config)
 
         @summary = double('summary')
@@ -93,11 +93,11 @@ describe DumpReader do
         expect(@summary).to receive(:data).with(formatted_assets)
         allow(Summary).to receive(:new).and_return(@summary)
 
-        expect(DumpReader.summary('/abc/123.tmp')).to eq(@summary)
+        expect(described_class.summary('/abc/123.tmp')).to eq(@summary)
       end
     end
 
-    it 'should call dump subroutines and create summary with schema' do
+    it 'calls dump subroutines and creates summary with schema' do
       tables = {'a' => 10, 'b' => 20, 'c' => 666}
       formatted_tables = ['a: 10 rows', 'b: 20 rows', 'c: 666 rows']
       assets = formatted_assets = %w[path/a path/b]
@@ -110,7 +110,7 @@ describe DumpReader do
       allow(@dump).to receive(:config).and_return(:tables => tables, :assets => assets)
       allow(@dump).to receive(:open).and_yield(@dump)
       allow(@dump).to receive(:schema).and_return(schema)
-      allow(DumpReader).to receive(:new).and_return(@dump)
+      allow(described_class).to receive(:new).and_return(@dump)
       expect(@dump).to receive(:read_config)
 
       @summary = double('summary')
@@ -122,18 +122,18 @@ describe DumpReader do
       expect(@summary).to receive(:data).with(schema_lines)
       allow(Summary).to receive(:new).and_return(@summary)
 
-      expect(DumpReader.summary('/abc/123.tmp', :schema => true)).to eq(@summary)
+      expect(described_class.summary('/abc/123.tmp', :schema => true)).to eq(@summary)
     end
   end
 
   describe 'open' do
-    it 'should set stream to gzipped tar reader' do
+    it 'sets stream to gzipped tar reader' do
       @gzip = double('gzip')
       @stream = double('stream')
       expect(Zlib::GzipReader).to receive(:open).with(Pathname('123.tgz')).and_yield(@gzip)
       expect(Archive::Tar::Minitar::Input).to receive(:open).with(@gzip).and_yield(@stream)
 
-      @dump = DumpReader.new('123.tgz')
+      @dump = described_class.new('123.tgz')
       @dump.open do |dump|
         expect(dump).to eq(@dump)
         expect(dump.stream).to eq(@stream)
@@ -147,24 +147,24 @@ describe DumpReader do
       @e2 = double('e2', :full_name => 'first.dump', :read => 'first.dump_data')
       @e3 = double('e3', :full_name => 'second.dump', :read => 'second.dump_data')
       @stream = [@e1, @e2, @e3]
-      @dump = DumpReader.new('123.tgz')
+      @dump = described_class.new('123.tgz')
       allow(@dump).to receive(:stream).and_return(@stream)
     end
 
     describe 'find_entry' do
-      it 'should find first entry in stream equal string' do
+      it 'finds first entry in stream equal string' do
         @dump.find_entry('config') do |entry|
           expect(entry).to eq(@e1)
         end
       end
 
-      it 'should find first entry in stream matching regexp' do
+      it 'finds first entry in stream matching regexp' do
         @dump.find_entry(/\.dump$/) do |entry|
           expect(entry).to eq(@e2)
         end
       end
 
-      it 'should return result of block' do
+      it 'returns result of block' do
         expect(@dump.find_entry(/\.dump$/) do |_entry|
           'hello'
         end).to eq('hello')
@@ -172,23 +172,23 @@ describe DumpReader do
     end
 
     describe 'read_entry' do
-      it 'should call find_entry' do
+      it 'calls find_entry' do
         expect(@dump).to receive(:find_entry).with('config').and_yield(@e1)
         @dump.read_entry('config')
       end
 
-      it 'should read entries data' do
+      it 'reads entries data' do
         expect(@dump.read_entry('config')).to eq('config_data')
       end
     end
 
     describe 'read_entry_to_file' do
-      it 'should call find_entry' do
+      it 'calls find_entry' do
         expect(@dump).to receive(:find_entry).with('config')
         @dump.read_entry_to_file('config')
       end
 
-      it 'should open temp file, write data there, rewind and yield that file' do
+      it 'opens temp file, writes data there, rewinds and yields that file' do
         @entry = double('entry')
         allow(@dump).to receive(:find_entry).and_yield(@entry)
         @temp = double('temp')
@@ -210,13 +210,13 @@ describe DumpReader do
   describe 'subroutines' do
     before do
       @stream = double('stream')
-      @dump = DumpReader.new('123.tgz')
+      @dump = described_class.new('123.tgz')
       allow(@dump).to receive(:stream).and_return(@stream)
       allow(Progress).to receive(:io).and_return(StringIO.new)
     end
 
     describe 'read_config' do
-      it 'should read config' do
+      it 'reads config' do
         @data = {:tables => {:first => 1}, :assets => %w[images videos]}
         expect(@dump).to receive(:read_entry).with('config').and_return(Marshal.dump(@data))
 
@@ -226,22 +226,22 @@ describe DumpReader do
     end
 
     describe 'migrate_down' do
-      it 'should not invoke rake tasks or find_entry if migrate_down is 0, no or false' do
+      it 'does not invoke rake tasks or find_entry if migrate_down is 0, no or false' do
         expect(Rake::Task).not_to receive(:[])
         expect(@dump).not_to receive(:find_entry)
 
-        DumpRake::Env.with_env(:migrate_down => '0') do
+        Dump::Env.with_env(:migrate_down => '0') do
           @dump.migrate_down
         end
-        DumpRake::Env.with_env(:migrate_down => 'no') do
+        Dump::Env.with_env(:migrate_down => 'no') do
           @dump.migrate_down
         end
-        DumpRake::Env.with_env(:migrate_down => 'false') do
+        Dump::Env.with_env(:migrate_down => 'false') do
           @dump.migrate_down
         end
       end
 
-      it 'should invoke db:drop and db:create if migrate_down is reset' do
+      it 'invokes db:drop and db:create if migrate_down is reset' do
         @load_task = double('drop_task')
         @dump_task = double('create_task')
         expect(Rake::Task).to receive(:[]).with('db:drop').and_return(@load_task)
@@ -249,32 +249,32 @@ describe DumpReader do
         expect(@load_task).to receive(:invoke)
         expect(@dump_task).to receive(:invoke)
 
-        DumpRake::Env.with_env(:migrate_down => 'reset') do
+        Dump::Env.with_env(:migrate_down => 'reset') do
           @dump.migrate_down
         end
       end
 
       [nil, '1'].each do |migrate_down_value|
         describe "when migrate_down is #{migrate_down_value.inspect}" do
-          it 'should not find_entry if table schema_migrations is not present' do
+          it 'does not find_entry if table schema_migrations is not present' do
             allow(@dump).to receive(:avaliable_tables).and_return(%w[first])
             expect(@dump).not_to receive(:find_entry)
 
-            DumpRake::Env.with_env(:migrate_down => migrate_down_value) do
+            Dump::Env.with_env(:migrate_down => migrate_down_value) do
               @dump.migrate_down
             end
           end
 
-          it 'should find schema_migrations.dump if table schema_migrations is present' do
+          it 'finds schema_migrations.dump if table schema_migrations is present' do
             allow(@dump).to receive(:avaliable_tables).and_return(%w[schema_migrations first])
             expect(@dump).to receive(:find_entry).with('schema_migrations.dump')
 
-            DumpRake::Env.with_env(:migrate_down => migrate_down_value) do
+            Dump::Env.with_env(:migrate_down => migrate_down_value) do
               @dump.migrate_down
             end
           end
 
-          it 'should call migrate down for each version not present in schema_migrations table' do
+          it 'calls migrate down for each version not present in schema_migrations table' do
             @entry = StringIO.new
             Marshal.dump(['version'], @entry)
             %w[1 2 3 4].each do |i|
@@ -289,7 +289,7 @@ describe DumpReader do
             @versions = []
             @migrate_down_task = double('migrate_down_task')
             expect(@migrate_down_task).to receive('invoke').exactly(3).times do
-              version = DumpRake::Env['VERSION']
+              version = Dump::Env['VERSION']
               @versions << version
               if version == '6'
                 fail ActiveRecord::IrreversibleMigration
@@ -301,7 +301,7 @@ describe DumpReader do
 
             expect(Rake::Task).to receive(:[]).with('db:migrate:down').exactly(3).times.and_return(@migrate_down_task)
 
-            DumpRake::Env.with_env(:migrate_down => migrate_down_value) do
+            Dump::Env.with_env(:migrate_down => migrate_down_value) do
               @dump.migrate_down
             end
             expect(@versions).to eq(%w[5 6 7].reverse)
@@ -317,20 +317,20 @@ describe DumpReader do
         allow(@task).to receive(:invoke)
       end
 
-      it 'should read schema.rb to temp file' do
+      it 'reads schema.rb to temp file' do
         expect(@dump).to receive(:read_entry_to_file).with('schema.rb')
         @dump.read_schema
       end
 
-      it 'should set ENV SCHEMA to temp files path' do
+      it 'sets ENV SCHEMA to temp files path' do
         @file = double('tempfile', :path => '/temp/123-arst')
         allow(@dump).to receive(:read_entry_to_file).and_yield(@file)
 
-        expect(DumpRake::Env).to receive(:with_env).with('SCHEMA' => '/temp/123-arst')
+        expect(Dump::Env).to receive(:with_env).with('SCHEMA' => '/temp/123-arst')
         @dump.read_schema
       end
 
-      it 'should call task db:schema:load and db:schema:dump' do
+      it 'calls task db:schema:load and db:schema:dump' do
         @file = double('tempfile', :path => '/temp/123-arst')
         allow(@dump).to receive(:read_entry_to_file).and_yield(@file)
 
@@ -346,7 +346,7 @@ describe DumpReader do
     end
 
     describe 'schema' do
-      it 'should read schema' do
+      it 'reads schema' do
         @data = 'create table, rows, etc...'
         expect(@dump).to receive(:read_entry).with('schema.rb').and_return(@data)
         expect(@dump.schema).to eq(@data)
@@ -354,13 +354,13 @@ describe DumpReader do
     end
 
     describe 'read_tables' do
-      it 'should verify connection' do
+      it 'verifies connection' do
         allow(@dump).to receive(:config).and_return({:tables => []})
         expect(@dump).to receive(:verify_connection)
         @dump.read_tables
       end
 
-      it 'should call read_table for each table in config' do
+      it 'calls read_table for each table in config' do
         allow(@dump).to receive(:verify_connection)
         allow(@dump).to receive(:config).and_return({:tables => {'first' => 1, 'second' => 3}})
 
@@ -371,25 +371,25 @@ describe DumpReader do
       end
 
       describe 'when called with restore_tables' do
-        it 'should verify connection and call read_table for each table in restore_tables' do
+        it 'verifies connection and calls read_table for each table in restore_tables' do
           allow(@dump).to receive(:config).and_return({:tables => {'first' => 1, 'second' => 3}})
 
           expect(@dump).to receive(:verify_connection)
           expect(@dump).to receive(:read_table).with('first', 1)
           expect(@dump).not_to receive(:read_table).with('second', 3)
 
-          DumpRake::Env.with_env(:restore_tables => 'first') do
+          Dump::Env.with_env(:restore_tables => 'first') do
             @dump.read_tables
           end
         end
 
-        it 'should not verfiy connection or call read_table for empty restore_tables' do
+        it 'does not verfiy connection or call read_table for empty restore_tables' do
           allow(@dump).to receive(:config).and_return({:tables => {'first' => 1, 'second' => 3}})
 
           expect(@dump).not_to receive(:verify_connection)
           expect(@dump).not_to receive(:read_table)
 
-          DumpRake::Env.with_env(:restore_tables => '') do
+          Dump::Env.with_env(:restore_tables => '') do
             @dump.read_tables
           end
         end
@@ -397,13 +397,13 @@ describe DumpReader do
     end
 
     describe 'read_table' do
-      it 'should not read table if no entry found for table' do
+      it 'does not read table if no entry found for table' do
         expect(@dump).to receive(:find_entry).with('first.dump').and_return(nil)
         expect(@dump).not_to receive(:quote_table_name)
         @dump.read_table('first', 10)
       end
 
-      it 'should clear table and read table if entry found for table' do
+      it 'clears table and reads table if entry found for table' do
         @entry = double('entry', :to_str => Marshal.dump('data'), :eof? => true)
         expect(@dump).to receive(:columns_insert_sql).with('data')
         expect(@dump).to receive(:find_entry).with('first.dump').and_yield(@entry)
@@ -412,7 +412,7 @@ describe DumpReader do
         @dump.read_table('first', 10)
       end
 
-      it 'should clear schema table before writing' do
+      it 'clears schema table before writing' do
         @entry = double('entry', :to_str => Marshal.dump('data'), :eof? => true)
         expect(@dump).to receive(:columns_insert_sql).with('data')
         expect(@dump).to receive(:find_entry).with('schema_migrations.dump').and_yield(@entry)
@@ -437,7 +437,7 @@ describe DumpReader do
 
           allow(@dump).to receive(:find_entry).and_yield(@entry)
         end
-        it 'should read to eof' do
+        it 'reads to eof' do
           create_entry(2500)
           allow(@dump).to receive(:clear_table)
           allow(@dump).to receive(:insert_into_table)
@@ -449,7 +449,7 @@ describe DumpReader do
           match{ |actual| actual.length == n }
         end
 
-        it 'should try to insert rows in slices of 1000 rows' do
+        it 'tries to insert rows in slices of 1000 rows' do
           create_entry(2500)
           allow(@dump).to receive(:clear_table)
           expect(@dump).to receive(:insert_into_table).with(anything, anything, object_of_length(1000)).twice
@@ -458,7 +458,7 @@ describe DumpReader do
           @dump.read_table('first', 2500)
         end
 
-        it 'should try to insert row by row if slice method fails' do
+        it 'tries to insert row by row if slice method fails' do
           create_entry(2500)
           allow(@dump).to receive(:clear_table)
           expect(@dump).to receive(:insert_into_table).with(anything, anything, kind_of(Array)).exactly(3).times.and_raise('sql error')
@@ -466,7 +466,7 @@ describe DumpReader do
           @dump.read_table('first', 2500)
         end
 
-        it 'should quote table, columns and values and send them to insert_into_table' do
+        it 'quotes table, columns and values and sends them to insert_into_table' do
           create_entry(100)
           allow(@dump).to receive(:clear_table)
           expect(@dump).to receive(:quote_table_name).with('first').and_return('`first`')
@@ -489,13 +489,13 @@ describe DumpReader do
         allow(@dump).to receive(:assets_root_link).and_yield('/tmp', 'assets')
       end
 
-      it 'should not read assets if config[:assets] is nil' do
+      it 'does not read assets if config[:assets] is nil' do
         allow(@dump).to receive(:config).and_return({})
         expect(@dump).not_to receive(:find_entry)
         @dump.read_assets
       end
 
-      it 'should not read assets if config[:assets] is blank' do
+      it 'does not read assets if config[:assets] is blank' do
         allow(@dump).to receive(:config).and_return({:assets => []})
         expect(@dump).not_to receive(:find_entry)
         @dump.read_assets
@@ -506,7 +506,7 @@ describe DumpReader do
           allow(@stream).to receive(:each)
         end
 
-        it 'should call assets:delete' do
+        it 'calls assets:delete' do
           @assets = %w[images videos]
           allow(@dump).to receive(:config).and_return({:assets => @assets})
           allow(@dump).to receive(:find_entry)
@@ -516,31 +516,31 @@ describe DumpReader do
           @dump.read_assets
         end
 
-        it 'should call assets:delete with ASSETS set to config[:assets] joined with :' do
+        it 'calls assets:delete with ASSETS set to config[:assets] joined with :' do
           @assets = %w[images videos]
           allow(@dump).to receive(:config).and_return({:assets => @assets})
           allow(@dump).to receive(:find_entry)
 
           expect(@task).to receive(:invoke) do
-            expect(DumpRake::Env[:assets]).to eq('images:videos')
+            expect(Dump::Env[:assets]).to eq('images:videos')
           end
 
           @dump.read_assets
         end
 
         describe 'when called with restore_assets' do
-          it 'should delete files and dirs only in requested paths' do
+          it 'deletes files and dirs only in requested paths' do
             @assets = %w[images videos]
             allow(@dump).to receive(:config).and_return({:assets => @assets})
 
-            expect(DumpRake::Assets).to receive('glob_asset_children').with('images', '**/*').and_return(%w[images images/a.jpg images/b.jpg])
-            expect(DumpRake::Assets).to receive('glob_asset_children').with('videos', '**/*').and_return(%w[videos videos/a.mov])
+            expect(Dump::Assets).to receive('glob_asset_children').with('images', '**/*').and_return(%w[images images/a.jpg images/b.jpg])
+            expect(Dump::Assets).to receive('glob_asset_children').with('videos', '**/*').and_return(%w[videos videos/a.mov])
 
-            expect(@dump).to receive('read_asset?').with('images/b.jpg', DumpRake::RailsRoot).ordered.and_return(false)
-            expect(@dump).to receive('read_asset?').with('images/a.jpg', DumpRake::RailsRoot).ordered.and_return(true)
-            expect(@dump).to receive('read_asset?').with('images', DumpRake::RailsRoot).ordered.and_return(true)
-            expect(@dump).to receive('read_asset?').with('videos/a.mov', DumpRake::RailsRoot).ordered.and_return(false)
-            expect(@dump).to receive('read_asset?').with('videos', DumpRake::RailsRoot).ordered.and_return(false)
+            expect(@dump).to receive('read_asset?').with('images/b.jpg', Dump.rails_root).ordered.and_return(false)
+            expect(@dump).to receive('read_asset?').with('images/a.jpg', Dump.rails_root).ordered.and_return(true)
+            expect(@dump).to receive('read_asset?').with('images', Dump.rails_root).ordered.and_return(true)
+            expect(@dump).to receive('read_asset?').with('videos/a.mov', Dump.rails_root).ordered.and_return(false)
+            expect(@dump).to receive('read_asset?').with('videos', Dump.rails_root).ordered.and_return(false)
 
             expect(File).to receive('file?').with('images/a.jpg').and_return(true)
             expect(File).to receive('unlink').with('images/a.jpg')
@@ -549,16 +549,16 @@ describe DumpReader do
             expect(File).to receive('directory?').with('images').and_return(true)
             expect(Dir).to receive('unlink').with('images').and_raise(Errno::ENOTEMPTY)
 
-            DumpRake::Env.with_env(:restore_assets => 'images/a.*:stylesheets') do
+            Dump::Env.with_env(:restore_assets => 'images/a.*:stylesheets') do
               @dump.read_assets
             end
           end
 
-          it 'should not delete any files and dirs for empty list' do
+          it 'does not delete any files and dirs for empty list' do
             @assets = %w[images videos]
             allow(@dump).to receive(:config).and_return({:assets => @assets})
 
-            expect(DumpRake::Assets).not_to receive('glob_asset_children')
+            expect(Dump::Assets).not_to receive('glob_asset_children')
 
             expect(@dump).not_to receive('read_asset?')
 
@@ -566,7 +566,7 @@ describe DumpReader do
             expect(File).not_to receive('file?')
             expect(File).not_to receive('unlink')
 
-            DumpRake::Env.with_env(:restore_assets => '') do
+            Dump::Env.with_env(:restore_assets => '') do
               @dump.read_assets
             end
           end
@@ -574,7 +574,7 @@ describe DumpReader do
       end
 
       describe 'old style' do
-        it 'should find assets.tar' do
+        it 'finds assets.tar' do
           @assets = %w[images videos]
           allow(@dump).to receive(:config).and_return({:assets => @assets})
           allow(Dir).to receive(:glob).and_return([])
@@ -590,7 +590,7 @@ describe DumpReader do
           {'images' => 0, 'videos' => 0},
           {'images' => {:files => 0, :total => 0}, 'videos' => {:files => 0, :total => 0}},
         ].each do |assets|
-          it 'should rewrite rewind method to empty method - to not raise exception, open tar and extract each entry' do
+          it 'rewrites rewind method to empty method - to not raise exception, opens tar and extracts each entry' do
             allow(@dump).to receive(:config).and_return({:assets => assets})
             allow(Dir).to receive(:glob).and_return([])
             allow(FileUtils).to receive(:remove_entry)
@@ -604,7 +604,7 @@ describe DumpReader do
             @entries = %w[a b c d].map do |s|
               file = double("file_#{s}")
               each_excpectation.and_yield(file)
-              expect(@inp).to receive(:extract_entry).with(DumpRake::RailsRoot, file)
+              expect(@inp).to receive(:extract_entry).with(Dump.rails_root, file)
               file
             end
             expect(Archive::Tar::Minitar).to receive(:open).with(@assets_tar).and_yield(@inp)
@@ -624,7 +624,7 @@ describe DumpReader do
           {'images' => 0, 'videos' => 0},
           {'images' => {:files => 0, :total => 0}, 'videos' => {:files => 0, :total => 0}},
         ].each do |assets|
-          it 'should extract each entry' do
+          it 'extracts each entry' do
             allow(@dump).to receive(:config).and_return({:assets => assets})
             allow(Dir).to receive(:glob).and_return([])
             allow(FileUtils).to receive(:remove_entry)
@@ -648,17 +648,17 @@ describe DumpReader do
     end
 
     describe 'read_asset?' do
-      it 'should create filter and call custom_pass? on it' do
+      it 'creates filter and call custom_pass? on it' do
         @filter = double('filter')
         allow(@filter).to receive('custom_pass?')
 
-        expect(DumpRake::Env).to receive('filter').with(:restore_assets, DumpRake::Assets::SPLITTER).and_return(@filter)
+        expect(Dump::Env).to receive('filter').with(:restore_assets, Dump::Assets::SPLITTER).and_return(@filter)
 
         @dump.read_asset?('a', 'b')
       end
 
-      it 'should test path usint fnmatch' do
-        DumpRake::Env.with_env(:restore_assets => '[a-b]') do
+      it 'tests path usint fnmatch' do
+        Dump::Env.with_env(:restore_assets => '[a-b]') do
           expect(@dump.read_asset?('x/a', 'x')).to be_truthy
           expect(@dump.read_asset?('x/b/file', 'x')).to be_truthy
           expect(@dump.read_asset?('x/c', 'x')).to be_falsey