geoffreywiseman-prune 1.3.1 → 1.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1cabe7b54d6be975a001aabb086928275d572c4f
-  data.tar.gz: 7e597d2bf76ccf5b0699783d8c8e3ff9cb9bc737
+  metadata.gz: daed96c1d85b82b3b7ebada4575e27659c27049d
+  data.tar.gz: 78ef1ce3951e62e29f1cc8dd8de98373d0d16765
 SHA512:
-  metadata.gz: 359b5317271207d42ad2b1353b46b158ad7bf75f946fb7e59e4b96bc48db0ee5ec49e278f3f2c869a23ccbbaf53f387cf6f4fc99618e84a65fd83ebd25ffe106
-  data.tar.gz: ee680bd731faff3f791b7d45826edd1699a04ec981ce27e03a2e73c909528729e371b18810d7344456b1a5250b6fded1426e35165f86d55b87e9b5406fa461d7
+  metadata.gz: 7acfa1fda4d6b9984f4d66c8e62066f8658cc0fa43521645918b5fe98cd6fb076ff55b1d8af0cc82c56057d79289cc3fe0bd1ff06917bcbd4ad43a24551dc950
+  data.tar.gz: e7178a263ab4dac01b8aa8b71035e4c1cc259a5328ff3fc49617735d86f5ce80b33e0f1e97f24ce52251a205b42a0f6adce39696198b80f478912ae9790ca0a0

data/Rakefile

@@ -4,6 +4,9 @@ require 'rspec/core/rake_task'
 require 'rspec'
 require 'rubygems'
 require 'rubygems/package_task'
+
+$: << './lib'
+
 require 'prune'
 
 CLEAN.include( 'pkg' )

data/lib/prune/archiver.rb

@@ -4,7 +4,7 @@ require 'date'
 require 'zlib'
 require 'archive/tar/minitar'
 require 'tmpdir'
-include Archive::Tar
+require 'minitar'
 
 module Prune
 

data/lib/prune/meta.rb

@@ -5,8 +5,8 @@
 # @author Geoffrey Wiseman
 module Prune
   # The version of the prune gem and all the associated code.
-  VERSION = Gem::Version.new '1.3.1'
+  VERSION = Gem::Version.new '1.3.2'
 
   # The release date associated with the version
-  RELEASE_DATE = '2016-06-24'
+  RELEASE_DATE = '2018-01-31'
 end

data/spec/archiver_spec.rb

@@ -15,18 +15,18 @@ describe Prune::Archiver do
     subject { Prune::Archiver.new( nil, '/mysql', true ) }
 
     it "should have #{DESTINATION} destination" do
-      subject.destination.should eq( DESTINATION )
+      expect(subject.destination).to eq( DESTINATION )
     end
 
     it "should create #{DESTINATION} if does not exist" do
-      File.stub( :exists? ).with( DESTINATION ) { false }
-      Dir.should_receive( :mkdir ).with( DESTINATION )
+      allow(File).to receive( :exists? ).with( DESTINATION ) { false }
+      expect(Dir).to receive( :mkdir ).with( DESTINATION )
       subject.make_destination_dir
     end
 
     it "should not attempt to create #{DESTINATION} if it exists" do
-      File.stub( :exists? ).with( DESTINATION ) { true }
-      Dir.should_not_receive( :mkdir )
+      allow(File).to receive( :exists? ).with( DESTINATION ) { true }
+      expect(Dir).not_to receive( :mkdir )
       subject.make_destination_dir
     end
 
@@ -36,19 +36,19 @@ describe Prune::Archiver do
       it "should write new archive file in #{DESTINATION} if none exists" do
 
         # Destination Exists
-        File.stub( :exists? ).with( DESTINATION ) { true }
+        allow(File).to receive( :exists? ).with( DESTINATION ) { true }
 
         # Archive File Exists
-        File.stub( :exists? ).with( ARCHIVE_FILE ) { false }
+        allow(File).to receive( :exists? ).with( ARCHIVE_FILE ) { false }
 
         # Create Zip File
         archive_file = double "file"
         gz = double "GzipWriter"
         paths = [ "/mysql/a", "/mysql/b", "/mysql/c" ]
-        File.stub( :open ).with( ARCHIVE_FILE, 'wb' ) { archive_file }
-        Zlib::GzipWriter.stub( :new ) { gz }
-        Minitar.should_receive( :pack ).with( paths, gz )
-        File.should_receive( :delete ).with( *paths )
+        allow(File).to receive( :open ).with( ARCHIVE_FILE, 'wb' ) { archive_file }
+        allow(Zlib::GzipWriter).to receive( :new ) { gz }
+        expect(Minitar).to receive( :pack ).with( paths, gz )
+        expect(File).to receive( :delete ).with( *paths )
 
         subject.archive "May-2011", ["a", "b", "c"]
       end
@@ -56,35 +56,35 @@ describe Prune::Archiver do
       it "should add to existing archive file if it exists" do
 
         # Destination Exists
-        File.stub( :exists? ).with( DESTINATION ) { true }
+        allow(File).to receive( :exists? ).with( DESTINATION ) { true }
 
         # Archive File Exists
-        File.stub( :exists? ).with( ARCHIVE_FILE ) { true }
+        allow(File).to receive( :exists? ).with( ARCHIVE_FILE ) { true }
 
         # Should Create Temp Dir
         tmpdir = "/tmp"
-        Dir.stub( :mktmpdir ).and_yield( tmpdir )
+        allow(Dir).to receive( :mktmpdir ).and_yield( tmpdir )
 
         # Should Extract Contents
         archive_file = double "archive file"
-        File.stub( :open ).with( ARCHIVE_FILE, 'rb' ) { archive_file }
+        allow(File).to receive( :open ).with( ARCHIVE_FILE, 'rb' ) { archive_file }
         gzr = double "GzipReader"
-        Zlib::GzipReader.stub( :new ) { gzr }
-        Minitar.should_receive( :unpack ).with( gzr, tmpdir )
-        Dir.should_receive( :entries ).with( tmpdir ) { ["c", "d"] }
+        allow(Zlib::GzipReader).to receive( :new ) { gzr }
+        expect(Minitar).to receive( :unpack ).with( gzr, tmpdir )
+        expect(Dir).to receive( :entries ).with( tmpdir ) { ["c", "d"] }
         extracted_paths = [ "/tmp/c", "/tmp/d" ]
-        extracted_paths.each { |path| File.stub( :directory? ).with( path ).and_return( false ) }
+        extracted_paths.each { |path| allow(File).to receive( :directory? ).with( path ).and_return( false ) }
 
         # Should Create Final Archive
-        File.stub( :open ).with( ARCHIVE_FILE, 'wb' ) { archive_file }
+        allow(File).to receive( :open ).with( ARCHIVE_FILE, 'wb' ) { archive_file }
         gzw = double "GzipWriter"
-        Zlib::GzipWriter.stub( :new ) { gzw }
+        allow(Zlib::GzipWriter).to receive( :new ) { gzw }
         original_paths = [ "/mysql/a", "/mysql/b" ]
         combined_paths = extracted_paths + original_paths
-        Minitar.should_receive( :pack ).with( combined_paths, gzw )
+        expect(Minitar).to receive( :pack ).with( combined_paths, gzw )
 
         # Delete Files
-        File.should_receive( :delete ).with( *original_paths )
+        expect(File).to receive( :delete ).with( *original_paths )
 
         # Go
         subject.archive "May-2011", ["a", "b"]
@@ -97,7 +97,7 @@ describe Prune::Archiver do
       subject { Prune::Archiver.new( '/mysql/archives', '/mysql', true ) }
 
       it "should use the explicit destination" do
-        subject.destination.should eq( '/mysql/archives' )
+        expect(subject.destination).to eq( '/mysql/archives' )
       end
 
     end

data/spec/cli_spec.rb

@@ -10,7 +10,7 @@ describe Prune::CommandLineInterface do
 
   before(:each) do
     @messages = []
-    $stdout.stub( :write ) { |message| @messages << message  }
+    allow($stdout).to receive( :write ) { |message| @messages << message  }
 
     @pruner = double( "pruner" )
   end
@@ -20,7 +20,7 @@ describe Prune::CommandLineInterface do
     it "should print help" do
       ARGV.clear
       Prune::CommandLineInterface::parse_and_run
-      @messages.should include_match( USAGE_TEXT )
+      expect(@messages).to include_match( USAGE_TEXT )
     end
 
   end
@@ -30,17 +30,17 @@ describe Prune::CommandLineInterface do
 
     before(:each) do
       ARGV.clear.push( PATH )
-      @pruner.stub(:prune)
+      allow(@pruner).to receive(:prune)
     end
 
     it "should call prune with path" do
-      Prune::Pruner.stub( :new ) { @pruner }
-      @pruner.should_receive( :prune ).with( PATH )
+      allow(Prune::Pruner).to receive( :new ) { @pruner }
+      expect(@pruner).to receive( :prune ).with( PATH )
       Prune::CommandLineInterface::parse_and_run
     end
 
     it "should create pruner with defaults" do
-      Prune::Pruner.stub( :new ).with( Prune::CommandLineInterface::DEFAULT_OPTIONS ) { @pruner }
+      allow(Prune::Pruner).to receive( :new ).with( Prune::CommandLineInterface::DEFAULT_OPTIONS ) { @pruner }
       Prune::CommandLineInterface::parse_and_run
     end
 
@@ -89,8 +89,8 @@ describe Prune::CommandLineInterface do
     describe "and a --config argument" do
       it "should set the configure option to true" do
         configurer = double( "Configurer" )
-        Prune::Configurer.should_receive( :new ).with( PATH, hash_including( :configure => true ) ).and_return( configurer )
-        configurer.should_receive( :configure )
+        expect(Prune::Configurer).to receive( :new ).with( PATH, hash_including( :configure => true ) ).and_return( configurer )
+        expect(configurer).to receive( :configure )
         ARGV.push( "--config" )
         Prune::CommandLineInterface::parse_and_run
       end
@@ -103,9 +103,9 @@ describe Prune::CommandLineInterface do
 
       describe "with no folder name" do
         it "should print a parsing error" do
-          $stderr.stub( :print ) { |message| @messages << message  }
+          allow($stderr).to receive( :print ) { |message| @messages << message  }
           Prune::CommandLineInterface::parse_and_run
-          @messages.should include_match( /missing argument: -a/ )
+          expect(@messages).to include_match( /missing argument: -a/ )
         end
       end
 
@@ -123,9 +123,9 @@ describe Prune::CommandLineInterface do
 
       describe "with no folder name" do
         it "should print a parsing error" do
-          $stderr.stub( :print ) { |message| @messages << message  }
+          allow($stderr).to receive( :print ) { |message| @messages << message  }
           Prune::CommandLineInterface::parse_and_run
-          @messages.should include_match( /missing argument: --archive-folder/ )
+          expect(@messages).to include_match( /missing argument: --archive-folder/ )
         end
       end
 
@@ -144,11 +144,11 @@ describe Prune::CommandLineInterface do
 
       it "should print help" do
         Prune::CommandLineInterface::parse_and_run
-        @messages.should include_match( USAGE_TEXT )
+        expect(@messages).to include_match( USAGE_TEXT )
       end
 
       it "should not invoke prune" do
-        @pruner.should_not_receive( :prune )
+        expect(@pruner).not_to receive( :prune )
         Prune::CommandLineInterface::parse_and_run
       end
 
@@ -162,11 +162,11 @@ describe Prune::CommandLineInterface do
 
       it "should print help" do
         Prune::CommandLineInterface::parse_and_run
-        @messages.should include_match( USAGE_TEXT )
+        expect(@messages).to include_match( USAGE_TEXT )
       end
 
       it "should not invoke prune" do
-        @pruner.should_not_receive( :prune )
+        expect(@pruner).not_to receive( :prune )
         Prune::CommandLineInterface::parse_and_run
       end
 
@@ -175,9 +175,9 @@ describe Prune::CommandLineInterface do
     describe "and an unknown argument" do
       it "should print a parsing error" do
         ARGV.push "--unknown-argument"
-        $stderr.stub( :print ) { |message| @messages << message  }
+        allow($stderr).to receive( :print ) { |message| @messages << message  }
         Prune::CommandLineInterface::parse_and_run
-        @messages.should include_match( /invalid option/ )
+        expect(@messages).to include_match( /invalid option/ )
       end
     end
 
@@ -187,13 +187,13 @@ describe Prune::CommandLineInterface do
       end
 
       it "should print version number" do
-          $stderr.stub( :print ) { |message| @messages << message  }
+          allow($stderr).to receive( :print ) { |message| @messages << message  }
           Prune::CommandLineInterface::parse_and_run
-          @messages.should include_match( /Prune #{Prune::VERSION}/ )
+          expect(@messages).to include_match( /Prune #{Prune::VERSION}/ )
       end
 
       it "should not invoke prune" do
-        @pruner.should_not_receive( :prune )
+        expect(@pruner).not_to receive( :prune )
         Prune::CommandLineInterface::parse_and_run
       end
 
@@ -206,7 +206,7 @@ describe Prune::CommandLineInterface do
     end
 
     def assert_arg_to_option( arg, *options )
-      Prune::Pruner.should_receive( :new ).with( hash_including( *options ) ).and_return( @pruner )
+      expect(Prune::Pruner).to receive( :new ).with( hash_including( *options ) ).and_return( @pruner )
       ARGV.push( arg )
       Prune::CommandLineInterface::parse_and_run
     end

data/spec/configurer_spec.rb

@@ -16,7 +16,7 @@ describe Prune::Configurer do
   context "with no config file present" do
     it "should copy core retention policy if no config file" do
       surpress_messages
-      FileUtils.should_receive(:cp).with( match(/default_retention.rb/), CONFIG_FILE )
+      expect(FileUtils).to receive(:cp).with( match(/default_retention.rb/), CONFIG_FILE )
       subject.configure
     end
   end
@@ -24,46 +24,46 @@ describe Prune::Configurer do
   context "with a directory in place of the config file" do
     before do
       stub_messages 
-      File.stub( :directory? ) { true }
+      allow(File).to receive( :directory? ) { true }
     end
     it "should warn that it can't create file" do
       subject.configure
-      @messages.should include_match( /cannot create or edit configuration/ )
+      expect(@messages).to include_match( /cannot create or edit configuration/ )
     end
   end
 
   context "with config file that canot be written" do
     before do
-      File.stub( :directory? ).with( CONFIG_FILE ) { false }
-      File.stub( :file? ).with( CONFIG_FILE ) { true }
-      File.stub( :writable? ).with( CONFIG_FILE ) { false }
+      allow(File).to receive( :directory? ).with( CONFIG_FILE ) { false }
+      allow(File).to receive( :file? ).with( CONFIG_FILE ) { true }
+      allow(File).to receive( :writable? ).with( CONFIG_FILE ) { false }
       stub_messages 
     end
     it "should warn that cannot edit config" do
       subject.configure
-      @messages.should include_match( /cannot edit configuration/ )
+      expect(@messages).to include_match( /cannot edit configuration/ )
     end
   end
   
   context "with a writeable config file" do
     
     before do
-      File.stub( :directory? ).with( CONFIG_FILE ) { false }
-      File.stub( :file? ).with( CONFIG_FILE ) { true }
-      File.stub( :writable? ).with( CONFIG_FILE ) { true }
+      allow(File).to receive( :directory? ).with( CONFIG_FILE ) { false }
+      allow(File).to receive( :file? ).with( CONFIG_FILE ) { true }
+      allow(File).to receive( :writable? ).with( CONFIG_FILE ) { true }
     end
     
     it "should warn if no editor defined" do
       stub_messages 
       subject.configure
-      @messages.should include_match( /No editor defined/ )
+      expect(@messages).to include_match( /No editor defined/ )
     end
   
     context "with EDITOR environment variable defined" do
       it "should invoke editor" do
         surpress_messages
         ENV['EDITOR']='ed'
-        subject.should_receive( :system ).with( "ed #{CONFIG_FILE}" ).and_return( true )
+        expect(subject).to receive( :system ).with( "ed #{CONFIG_FILE}" ).and_return( true )
         subject.configure
       end
     end
@@ -73,7 +73,7 @@ describe Prune::Configurer do
         surpress_messages
         ENV['VISUAL']='gedit'
         ENV['EDITOR']='ed'
-        subject.should_receive( :system ).with( "gedit #{CONFIG_FILE}" ).and_return( true )
+        expect(subject).to receive( :system ).with( "gedit #{CONFIG_FILE}" ).and_return( true )
         subject.configure
       end
     end
@@ -82,7 +82,7 @@ describe Prune::Configurer do
       it "should invoke visual editor if defined in VISUAL" do
         surpress_messages
         ENV['VISUAL']='gedit'
-        subject.should_receive( :system ).with( "gedit #{CONFIG_FILE}" ).and_return( true )
+        expect(subject).to receive( :system ).with( "gedit #{CONFIG_FILE}" ).and_return( true )
         subject.configure
       end
     end

data/spec/grouper_spec.rb

@@ -14,7 +14,7 @@ describe "Prune::Grouper" do
   context "w/o files" do
 
     it "should not archive" do
-      @archiver.should_not_receive( :archive )
+      expect(@archiver).not_to receive( :archive )
       @grouper.group( GROUP_PATH, [] ).archive
     end
 
@@ -24,26 +24,26 @@ describe "Prune::Grouper" do
 
     it "should archive files" do
       files = mock_files( Date.new(2011,01,01) )
-      @archiver.should_receive( :archive )
+      expect(@archiver).to receive( :archive )
       @grouper.group( GROUP_PATH, files ).archive
     end
 
     it "should specify month and year" do
       files = mock_files( Date.new(2008,03,01) )
-      @archiver.should_receive( :archive ).with( "Mar-2008", files )
+      expect(@archiver).to receive( :archive ).with( "Mar-2008", files )
       @grouper.group( GROUP_PATH, files ).archive
     end
 
     it "should combine files with same month/year" do
       files = mock_files( Date.new(2008,03,01), Date.new(2008,03,02) )
-      @archiver.should_receive( :archive ).with( "Mar-2008", files )
+      expect(@archiver).to receive( :archive ).with( "Mar-2008", files )
       @grouper.group( GROUP_PATH, files ).archive
     end
 
     it "should not combine files with same month, different year" do
       files = mock_files( Date.new(2008,03,01), Date.new(2009,03,01) )
-      @archiver.should_receive( :archive ).with( "Mar-2008", [files.first] )
-      @archiver.should_receive( :archive ).with( "Mar-2009", [files.last] )
+      expect(@archiver).to receive( :archive ).with( "Mar-2008", [files.first] )
+      expect(@archiver).to receive( :archive ).with( "Mar-2009", [files.last] )
       @grouper.group( GROUP_PATH, files ).archive
     end
 
@@ -54,7 +54,7 @@ describe "Prune::Grouper" do
     dates.map do |item|
       month_name = Date::ABBR_MONTHNAMES[item.month]
       file_name = "file-#{month_name}-#{item.year}.sql"
-      File.stub( :mtime ).with( "#{GROUP_PATH}/#{file_name}" ) { item }
+      allow(File).to receive( :mtime ).with( "#{GROUP_PATH}/#{file_name}" ) { item }
       files << file_name
     end
     return files;

data/spec/pruner_spec.rb

@@ -10,8 +10,8 @@ describe Prune::Pruner do
   before( :each ) do
     @categories = [ Prune::Category.new( "Unmatched Files", :retain, true ) ]
     @retention_policy = double( "RetentionPolicy" )
-    @retention_policy.stub( :categories ) { @categories }
-    Prune::RetentionPolicy.stub( :new ) { @retention_policy }
+    allow(@retention_policy).to receive( :categories ) { @categories }
+    allow(Prune::RetentionPolicy).to receive( :new ) { @retention_policy }
   end
 
   context "w/o prompt" do
@@ -20,9 +20,9 @@ describe Prune::Pruner do
     end
 
     it "should not attempt to process folder that does not exist" do
-      File.stub( :exists? ).with( PRUNE_PATH ) { false }
-      Dir.should_not_receive( :foreach )
-      $stdout.should_receive( :write ).with( /ERROR: Cannot find folder/ )
+      allow(File).to receive( :exists? ).with( PRUNE_PATH ) { false }
+      expect(Dir).not_to receive( :foreach )
+      expect($stdout).to receive( :write ).with( /ERROR: Cannot find folder/ )
       subject.prune( PRUNE_PATH )
     end
 
@@ -35,19 +35,19 @@ describe Prune::Pruner do
       end
 
       it "should not invoke the retention policy" do
-        @retention_policy.should_not_receive( :categorize )
+        expect(@retention_policy).not_to receive( :categorize )
       end
 
       it "should print 'Analyzing #{PRUNE_PATH}'" do
-        @messages.should include("Analyzing '#{PRUNE_PATH}':\n")
+        expect(@messages).to include("Analyzing '#{PRUNE_PATH}':\n")
       end
 
       it "should say no action was required" do
-        @messages.should include("No actions necessary.\n")
+        expect(@messages).to include("No actions necessary.\n")
       end
 
       it "should say no files were analyzed" do
-        @messages.should include_match( /0 file\(s\) analyzed/ )
+        expect(@messages).to include_match( /0 file\(s\) analyzed/ )
       end
 
     end
@@ -61,19 +61,19 @@ describe Prune::Pruner do
       end
 
       it "should not invoke the retention policy" do
-        @retention_policy.should_not_receive( :categorize )
+        expect(@retention_policy).not_to receive( :categorize )
       end
 
       it "should print 'Analyzing #{PRUNE_PATH}'" do
-        @messages.should include("Analyzing '#{PRUNE_PATH}':\n")
+        expect(@messages).to include("Analyzing '#{PRUNE_PATH}':\n")
       end
 
       it "should say no action was required" do
-        @messages.should include("No actions necessary.\n")
+        expect(@messages).to include("No actions necessary.\n")
       end
 
       it "should say no files were analyzed" do
-        @messages.should include_match( /0 file\(s\) analyzed/ )
+        expect(@messages).to include_match( /0 file\(s\) analyzed/ )
       end
 
     end
@@ -88,16 +88,16 @@ describe Prune::Pruner do
       end
 
       it "should categorize each file in modified order" do
-        @retention_policy.should_receive( :categorize ).with( 'alpha.txt' ).ordered
-        @retention_policy.should_receive( :categorize ).with( 'beta.txt' ).ordered
-        @retention_policy.should_receive( :categorize ).with( 'gamma.txt' ).ordered
+        expect(@retention_policy).to receive( :categorize ).with( 'alpha.txt' ).ordered
+        expect(@retention_policy).to receive( :categorize ).with( 'beta.txt' ).ordered
+        expect(@retention_policy).to receive( :categorize ).with( 'gamma.txt' ).ordered
         subject.prune PRUNE_PATH
       end
 
       it "should say three files were analyzed" do
         @retention_policy.as_null_object
         subject.prune PRUNE_PATH
-        @messages.should include_match( /3 file\(s\) analyzed/ )
+        expect(@messages).to include_match( /3 file\(s\) analyzed/ )
       end
 
     end
@@ -111,27 +111,27 @@ describe Prune::Pruner do
         stub_files FILENAME
         
         category = double( category )
-        category.stub( :description ) { "Old" }
-        category.stub( :action ) { :remove }
-        category.stub( :quiet? ) { false }
-        @retention_policy.should_receive( :categorize ).with( FILENAME ) { category }
+        allow(category).to receive( :description ) { "Old" }
+        allow(category).to receive( :action ) { :remove }
+        allow(category).to receive( :quiet? ) { false }
+        expect(@retention_policy).to receive( :categorize ).with( FILENAME ) { category }
       end
       
       it "should delete file" do
-        FileUtils.should_receive( :remove_entry ).with( File.join( PRUNE_PATH, FILENAME ), true ) { 1 }
+        expect(FileUtils).to receive( :remove_entry ).with( File.join( PRUNE_PATH, FILENAME ), true ) { 1 }
         subject.prune PRUNE_PATH
       end
       
       it "should display file deleted message" do
-        FileUtils.should_receive( :remove_entry ).with( File.join( PRUNE_PATH, FILENAME ), true ) { 1 }
+        expect(FileUtils).to receive( :remove_entry ).with( File.join( PRUNE_PATH, FILENAME ), true ) { 1 }
         subject.prune PRUNE_PATH
-        @messages.should include_match( /1 file\(s\) deleted/ )
+        expect(@messages).to include_match( /1 file\(s\) deleted/ )
       end
 
       it "should display failed deletion mesage" do
-        FileUtils.should_receive( :remove_entry ).with( File.join( PRUNE_PATH, FILENAME ), true ) { 0 }
+        expect(FileUtils).to receive( :remove_entry ).with( File.join( PRUNE_PATH, FILENAME ), true ) { 0 }
         subject.prune PRUNE_PATH
-        @messages.should include_match( /0 file\(s\) deleted, 1 file\(s\) could not be deleted/ )
+        expect(@messages).to include_match( /0 file\(s\) deleted, 1 file\(s\) could not be deleted/ )
       end
 
     end
@@ -144,17 +144,17 @@ describe Prune::Pruner do
         stub_messages
         
         category = double( "category" )
-        category.stub( :action ) { :archive }
-        category.stub( :description ) { "Archive" }
-        category.stub( :quiet? ) { false }
+        allow(category).to receive( :action ) { :archive }
+        allow(category).to receive( :description ) { "Archive" }
+        allow(category).to receive( :quiet? ) { false }
         
-        @retention_policy.stub( :categories ) { [ category ]}
+        allow(@retention_policy).to receive( :categories ) { [ category ]}
       end
         
       it "should indicate no archive necessary" do
         subject.prune PRUNE_PATH
         puts "Messages: #{@messages}"
-        @messages.should include_match( /No files categorized for archival/ )
+        expect(@messages).to include_match( /No files categorized for archival/ )
       end
         
     end
@@ -168,17 +168,17 @@ describe Prune::Pruner do
         stub_messages
 
         category = double( "category" )
-        @retention_policy.stub( :categorize ) { category }
-        category.stub( :action ) { :archive }
-        category.stub( :description ) { "Ancient" }
-        category.stub( :quiet? ) { false }
+        allow(@retention_policy).to receive( :categorize ) { category }
+        allow(category).to receive( :action ) { :archive }
+        allow(category).to receive( :description ) { "Ancient" }
+        allow(category).to receive( :quiet? ) { false }
       end
 
       it "should archive files in groups" do
         grouper = double( "Grouper" )
-        Prune::Grouper.stub( :new ) { grouper }
-        grouper.should_receive( :group ).with( PRUNE_PATH, files )
-        grouper.should_receive( :archive ) { "2 Archives created." }
+        allow(Prune::Grouper).to receive( :new ) { grouper }
+        expect(grouper).to receive( :group ).with( PRUNE_PATH, files )
+        expect(grouper).to receive( :archive ) { "2 Archives created." }
 
         subject.prune PRUNE_PATH
       end
@@ -186,7 +186,7 @@ describe Prune::Pruner do
       it "should display message if archive option disabled" do
         subject.options[:archive] = false
         subject.prune PRUNE_PATH
-        @messages.should include_match( /Archive option disabled/ )
+        expect(@messages).to include_match( /Archive option disabled/ )
       end
     end
   
@@ -206,17 +206,17 @@ describe Prune::Pruner do
         
       it "should display empty categories" do
         subject.display_categories( { Prune::Category.new( "Empty Category", :retain ) => [] } )
-        @messages.should include_match( /Empty Category/ )
+        expect(@messages).to include_match( /Empty Category/ )
       end
         
       it "should display quiet categories" do
         subject.display_categories( { Prune::Category.new( "Quiet Category", :retain, true ) => [ 'quiet.txt' ] } )
-        @messages.should include_match( /Quiet Category/ )
+        expect(@messages).to include_match( /Quiet Category/ )
       end
       
       it "should display categories with files" do
         subject.display_categories( { Prune::Category.new( "Normal Category", :retain ) => [ 'normal.txt' ] } )
-        @messages.should include_match( /Normal Category/ )
+        expect(@messages).to include_match( /Normal Category/ )
       end
     end
     
@@ -228,17 +228,17 @@ describe Prune::Pruner do
         
       it "should not display empty categories" do
         subject.display_categories( { Prune::Category.new( "Empty Category", :retain, true ) => [] } )
-        @messages.should_not include_match( /Empty Category/ )
+        expect(@messages).not_to include_match( /Empty Category/ )
       end
       
       it "should not display quiet categories" do
         subject.display_categories( { Prune::Category.new( "Quiet Category", :retain, true ) => [ 'shhh.txt' ] } )
-        @messages.should_not include_match( /Quiet Category/ )
+        expect(@messages).not_to include_match( /Quiet Category/ )
       end
       
       it "should display categories with files" do
         subject.display_categories( { Prune::Category.new( "Normal Category", :retain ) => [ 'normal.txt' ] } )
-        @messages.should include_match( /Normal Category/ )
+        expect(@messages).to include_match( /Normal Category/ )
       end
 
     end
@@ -251,76 +251,76 @@ describe Prune::Pruner do
 
     it "should interpret 'Y' as true" do
       expect_prompt_with_response( "Y\n")
-      subject.prompt.should be_true
+      expect(subject.prompt).to be_truthy
     end
 
     it "should interpret 'Y ' as true" do
       expect_prompt_with_response("Y \n")
-      subject.prompt.should be_true
+      expect(subject.prompt).to be_truthy
     end
 
     it "should interpret ' Y' as true" do
       expect_prompt_with_response(" Y\n")
-      subject.prompt.should be_true
+      expect(subject.prompt).to be_truthy
     end
 
     it "should interpret ' Y ' as true" do
       expect_prompt_with_response(" Y \n")
-      subject.prompt.should be_true
+      expect(subject.prompt).to be_truthy
     end
 
     it "should interpret 'y' as true" do
       expect_prompt_with_response("y\n")
-      subject.prompt.should be_true
+      expect(subject.prompt).to be_truthy
     end
 
     it "should interpret 'yes' as true" do
       expect_prompt_with_response("yes\n")
-      subject.prompt.should be_true
+      expect(subject.prompt).to be_truthy
     end
 
     it "should interpret 'no' as false" do
       expect_prompt_with_response("no\n")
-      subject.prompt.should be_false
+      expect(subject.prompt).to be_falsey
     end
 
     it "should interpret 'n' as false" do
       expect_prompt_with_response("n\n")
-      subject.prompt.should be_false
+      expect(subject.prompt).to be_falsey
     end
 
     it "should interpret 'N' as false" do
       expect_prompt_with_response("N\n")
-      subject.prompt.should be_false
+      expect(subject.prompt).to be_falsey
     end
 
     it "should interpret 'q' as false" do
       expect_prompt_with_response("q\n")
-      subject.prompt.should be_false
+      expect(subject.prompt).to be_falsey
     end
 
     def expect_prompt_with_response( response )
-      $stdout.should_receive( :write ).with( /Proceed?/ )
-      STDIN.stub(:gets) { response }
+      expect($stdout).to receive( :write ).with( /Proceed?/ )
+      allow(STDIN).to receive(:gets) { response }
     end
 
   end
 
   def stub_files( files = nil )
-    File.stub( :exists? ).with( PRUNE_PATH ) { true }
-    File.stub( :directory? ).with( PRUNE_PATH ) { true }
+    allow(File).to receive( :exists? ).with( PRUNE_PATH ) { true }
+    allow(File).to receive( :directory? ).with( PRUNE_PATH ) { true }
     case files
     when nil
-      Dir.stub( :entries ).with( PRUNE_PATH ) { Array.new }
+      allow(Dir).to receive( :entries ).with( PRUNE_PATH ) { Array.new }
     when String
-      subject.stub(:test).with( ?M, File.join( PRUNE_PATH, files ) ) { Time.now }
-      Dir.stub( :entries ).with( PRUNE_PATH ) { [ files ] }
+      allow(subject).to receive(:test).with( ?M, File.join( PRUNE_PATH, files ) ) { Time.now }
+      allow(Dir).to receive( :entries ).with( PRUNE_PATH ) { [ files ] }
     when Array
-      files.each_index { |index| subject.stub(:test).with( ?M, File.join( PRUNE_PATH, files[index] ) ) { index }  }
-      Dir.stub( :entries ).with( PRUNE_PATH ) { files }
+      files.each_index { |index| allow(subject).to receive(:test).with( ?M, File.join( PRUNE_PATH, files[index] ) ) { index }  }
+      allow(Dir).to receive( :entries ).with( PRUNE_PATH ) { files }
     when Hash
-      files.each_key { |key| subject.stub(:test).with( ?M, File.join( PRUNE_PATH, key ) ) { files[key] } }
-      Dir.stub( :entries ).with( PRUNE_PATH ) { files.keys }
+      files.each_key { |key| allow(subject).to receive(:test).with( ?M, File.join( PRUNE_PATH, key ) ) { files[key] } }
+      allow(Dir).to receive( :entries ).with( PRUNE_PATH ) { files.keys }
     else
       raise "Don't know how to stub files for #{files.class}"
     end

data/spec/retention_spec.rb

@@ -21,28 +21,28 @@ describe Prune::RetentionPolicy do
 
     it "should return categories in dsl order" do
       cats = subject.categories
-      cats.shift.description.should include( "Ignoring directories" )
-      cats.shift.description.should include( "from the Last Two Weeks" )
-      cats.shift.description.should include( "Retaining 'Friday'" )
-      cats.shift.description.should include( "Removing 'Non-Friday'" )
-      cats.shift.description.should include( "Archiving" )
-      cats.should be_empty
+      expect(cats.shift.description).to include( "Ignoring directories" )
+      expect(cats.shift.description).to include( "from the Last Two Weeks" )
+      expect(cats.shift.description).to include( "Retaining 'Friday'" )
+      expect(cats.shift.description).to include( "Removing 'Non-Friday'" )
+      expect(cats.shift.description).to include( "Archiving" )
+      expect(cats).to be_empty
     end
   
     describe "analyzing a directory" do
       let( :dircat ) do
-        File.stub( :directory? ).with( SOURCE_PATH ) { true }
-        File.stub( :mtime ).with( SOURCE_PATH ) { Time.now }
+        allow(File).to receive( :directory? ).with( SOURCE_PATH ) { true }
+        allow(File).to receive( :mtime ).with( SOURCE_PATH ) { Time.now }
         subject.categorize( SOURCE_FILE )
       end
       
       
       it "should be categorized as 'Ignoring directories'" do
-        dircat.description.should eq( "Ignoring directories" )
+        expect(dircat.description).to eq( "Ignoring directories" )
       end
 
       it "should invoke action :ignore" do
-        dircat.action.should eq( :ignore )
+        expect(dircat.action).to eq( :ignore )
       end
     end
 
@@ -51,35 +51,35 @@ describe Prune::RetentionPolicy do
       describe "created yesterday" do
         
         let( :yestercat ) do
-          File.stub( :directory? ).with( SOURCE_PATH ) { false }
-          File.stub( :mtime ).with( SOURCE_PATH ) { Time.now - DAY }
+          allow(File).to receive( :directory? ).with( SOURCE_PATH ) { false }
+          allow(File).to receive( :mtime ).with( SOURCE_PATH ) { Time.now - DAY }
           subject.categorize( SOURCE_FILE )
         end
 
         it "should be categorized as '... Last Two Weeks'" do
-          yestercat.description.should include( 'Last Two Weeks' )
+          expect(yestercat.description).to include( 'Last Two Weeks' )
         end
 
         it "should invoke action :retain" do
-          yestercat.action.should eq( :retain )
+          expect(yestercat.action).to eq( :retain )
         end
       end
 
       describe "created three weeks ago, wednesday" do
 
         let( :weeksago ) do
-          File.stub( :directory? ).with( SOURCE_PATH ) { false }
-          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 3, 'Wed' ) }
+          allow(File).to receive( :directory? ).with( SOURCE_PATH ) { false }
+          allow(File).to receive( :mtime ).with( SOURCE_PATH ) { weeks_ago( 3, 'Wed' ) }
           subject.categorize( SOURCE_FILE )
         end
 
         it "should be described as 'Older than Two Weeks' and 'Non-Friday'" do
-          weeksago.description.should include 'Non-Friday'
-          weeksago.description.should include 'Older than Two Weeks'
+          expect(weeksago.description).to include 'Non-Friday'
+          expect(weeksago.description).to include 'Older than Two Weeks'
         end
 
         it "should invoke action :remove" do
-          weeksago.action.should eq( :remove )
+          expect(weeksago.action).to eq( :remove )
         end
 
       end
@@ -87,18 +87,18 @@ describe Prune::RetentionPolicy do
       describe "created three weeks ago, friday" do
 
         let( :weeksagofriday ) do
-          File.stub( :directory? ).with( SOURCE_PATH ) { false }
-          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 3, 'Fri' ) }
+          allow(File).to receive( :directory? ).with( SOURCE_PATH ) { false }
+          allow(File).to receive( :mtime ).with( SOURCE_PATH ) { weeks_ago( 3, 'Fri' ) }
           subject.categorize( SOURCE_FILE )
         end
 
         it "should be described as 'Friday files', 'Older than Two Weeks'" do
-          weeksagofriday.description.should include( "'Friday' files" )
-          weeksagofriday.description.should include( 'Older than Two Weeks' )
+          expect(weeksagofriday.description).to include( "'Friday' files" )
+          expect(weeksagofriday.description).to include( 'Older than Two Weeks' )
         end
 
         it "should invoke action :remove" do
-          weeksagofriday.action.should eq( :retain )
+          expect(weeksagofriday.action).to eq( :retain )
         end
 
       end
@@ -106,17 +106,17 @@ describe Prune::RetentionPolicy do
       describe "created three months ago, friday" do
 
         let( :oldfriday ) do
-          File.stub( :directory? ).with( SOURCE_PATH ) { false }
-          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 12, 'Fri' ) }
+          allow(File).to receive( :directory? ).with( SOURCE_PATH ) { false }
+          allow(File).to receive( :mtime ).with( SOURCE_PATH ) { weeks_ago( 12, 'Fri' ) }
           subject.categorize( SOURCE_FILE )
         end
 
         it "should be described as 'Older than Two Months'" do
-          oldfriday.description.should include( 'Older than Two Months' )
+          expect(oldfriday.description).to include( 'Older than Two Months' )
         end
 
         it "should invoke action :archive" do
-          oldfriday.action.should eq( :archive )
+          expect(oldfriday.action).to eq( :archive )
         end
 
       end
@@ -124,18 +124,18 @@ describe Prune::RetentionPolicy do
       describe "created three months ago, wednesday" do
 
         let( :oldwednesday ) do
-          File.stub( :directory? ).with( SOURCE_PATH ) { false }
-          File.stub( :mtime ).with( SOURCE_PATH ) { weeks_ago( 12, 'Wed' ) }
+          allow(File).to receive( :directory? ).with( SOURCE_PATH ) { false }
+          allow(File).to receive( :mtime ).with( SOURCE_PATH ) { weeks_ago( 12, 'Wed' ) }
           subject.categorize( SOURCE_FILE )
         end
 
         it "should be described as 'Non-Friday files', 'Older than Two Weeks'" do
-          oldwednesday.description.should include( "'Non-Friday' files" )
-          oldwednesday.description.should include( "Older than Two Weeks" )
+          expect(oldwednesday.description).to include( "'Non-Friday' files" )
+          expect(oldwednesday.description).to include( "Older than Two Weeks" )
         end
 
         it "should invoke action :remove" do
-          oldwednesday.action.should eq( :remove )
+          expect(oldwednesday.action).to eq( :remove )
         end
 
       end
@@ -170,33 +170,33 @@ describe Prune::RetentionPolicy do
     end
     
     it "should ignore directories" do
-      subject.categorize( "." ).description.should eq( "Ignoring" )
+      expect(subject.categorize( "." ).description).to eq( "Ignoring" )
     end
     
     it "should ignore files not matching pattern" do
-      File.stub(:file?) { true }
-      subject.categorize( 'readme.txt' ).description.should eq( 'Ignoring' )
+      allow(File).to receive(:file?) { true }
+      expect(subject.categorize( 'readme.txt' ).description).to eq( 'Ignoring' )
     end
     
     describe "with a file named with 20101001" do
       before do
-        File.stub(:directory?) { false }
-        File.stub(:file?) { true }
+        allow(File).to receive(:directory?) { false }
+        allow(File).to receive(:file?) { true }
       end
       
       it "should categorize as 2010" do
-        subject.categorize( 'mysql-prod-20101001.sql.gz' ).description.should eq( '2010' )
+        expect(subject.categorize( 'mysql-prod-20101001.sql.gz' ).description).to eq( '2010' )
       end
     end
 
     describe "with a file named with 20110215" do
       before do
-        File.stub(:directory?) { false }
-        File.stub(:file?) { true }
+        allow(File).to receive(:directory?) { false }
+        allow(File).to receive(:file?) { true }
       end
       
       it "should categorize as 2011" do
-        subject.categorize( 'subversion-20110215.tar.gz' ).description.should eq( '2011' )
+        expect(subject.categorize( 'subversion-20110215.tar.gz' ).description).to eq( '2011' )
       end
     end
   end

data/spec/spec_helper.rb

@@ -3,11 +3,11 @@ SimpleCov.start
 
 def stub_messages
   @messages = []
-  $stdout.stub( :write ) { |message| @messages << message  }
+  allow($stdout).to receive( :write ) { |message| @messages << message  }
 end
 
 def surpress_messages
-  $stdout.stub( :write )
+  allow($stdout).to receive( :write )
 end
 
 RSpec::Matchers.define :include_match do |expected|

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: geoffreywiseman-prune
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.2
 platform: ruby
 authors:
 - Geoffrey Wiseman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-24 00:00:00.000000000 Z
+date: 2018-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.3
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.3
+        version: '0.6'
 description: Prune is meant to analyze a folder full of files, run them against a
   retention policy and decide which to keep, which to remove and which to archive.
   It is extensible and embeddable.
@@ -54,7 +54,8 @@ files:
 - spec/retention_spec.rb
 - spec/spec_helper.rb
 homepage: http://geoffreywiseman.github.com/prune
-licenses: []
+licenses:
+- UNLICENSE
 metadata: {}
 post_install_message: 
 rdoc_options: []