maid 0.9.0.alpha.2 → 0.10.0.pre.alpha.2

data/lib/maid/watch.rb

@@ -5,33 +5,31 @@ class Maid::Watch
 
   attr_reader :path, :listener, :logger
 
-  def initialize(maid, path, options = {}, &rules)
+  def initialize(maid, path, options = {}, &block)
     @maid = maid
 
     if options.nil? || options.empty?
       @lazy = true
       @options = { wait_for_delay: 10,
-                   ignore: Maid::Downloading.downloading_file_regexps }
+                   ignore: Maid::Downloading.downloading_file_regexps, }
     else
-      @lazy = options.delete(:lazy) { |key| true }
+      @lazy = options.delete(:lazy) { |_key| true }
       @options = options
     end
 
     @logger = maid.logger # TODO: Maybe it's better to create seperate loggers?
     @path = File.expand_path(path)
-    initialize_rules(&rules)
+    initialize_rules(&block)
   end
 
   def run
-    unless rules.empty?
-      @listener = Listen.to(path, @options) do |modified, added, removed|
-        if !@lazy || added.any? || removed.any?
-          follow_rules(modified, added, removed)
-        end
-      end
-
-      @listener.start
+    return if rules.empty?
+
+    @listener = Listen.to(path, @options) do |modified, added, removed|
+      follow_rules(modified, added, removed) if !@lazy || added.any? || removed.any?
     end
+
+    @listener.start
   end
 
   def stop

data/maid.gemspec

@@ -1,34 +1,43 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path('../lib', __FILE__)
+$:.push File.expand_path('lib', __dir__)
 require 'maid/version'
 
 Gem::Specification.new do |s|
   s.name        = 'maid'
   s.version     = Maid::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.authors     = ['Benjamin Oakes']
-  s.email       = %w(hello@benjaminoakes.com)
+  s.authors     = ['Benjamin Oakes', 'Coaxial']
+  s.email       = ['hello@benjaminoakes.com', 'c+rubygems@64b.it']
   s.license     = 'GPLv2'
-  s.homepage    = 'http://github.com/benjaminoakes/maid'
+  s.homepage    = 'http://github.com/maid/maid'
   s.summary     = Maid::SUMMARY
   s.description = s.summary
+  s.files       = Dir['lib/**/*.rb'] + Dir['bin/maid']
+  s.metadata    = {
+    'bug_tracker_uri' => 'https://github.com/maid/maid/issues',
+    'changelog_uri' => 'https://github.com/maid/maid/blob/master/CHANGELOG.md',
+    'documentation_uri' => 'https://github.com/maid/maid/blob/master/README.md',
+    'source_code_uri' => 'https://github.com/maid/maid',
+    'wiki_uri' => 'https://github.com/maid/maid/wiki',
+    'rubygems_mfa_required' => 'true',
+  }
 
   s.rubyforge_project = 'maid'
 
   s.required_ruby_version = '>= 2.7.0'
 
   # Strategy: if possible, use ranges (so there are fewer chances of version conflicts)
-  s.add_dependency('escape', '>= 0.0.1', '< 0.1.0') # Used for better Ruby 1.8.7 support, could be replaced with `Shellwords`
-  s.add_dependency('thor', '~> 1.2.1')
   s.add_dependency('deprecated', '~> 3.0.0')
   s.add_dependency('dimensions', '>= 1.0.0', '< 2.0')
+  # Used for better Ruby 1.8.7 support, could be replaced with `Shellwords`
+  s.add_dependency('escape', '>= 0.0.1', '< 0.1.0')
+  s.add_dependency('exifr', '~> 1.3.10')
+  s.add_dependency('geocoder', '~> 1.8.1')
+  s.add_dependency('listen', '~> 3.8.0')
   s.add_dependency('mime-types', '~> 3.0', '< 4.0')
   s.add_dependency('rubyzip', '~> 2.3.2')
-  s.add_dependency('xdg', '~> 2.2.3') # previous versions had bugs
-  s.add_dependency('listen', '~> 3.8.0')
   s.add_dependency('rufus-scheduler', '~> 3.8.2')
-  s.add_dependency('exifr', '~> 1.3.10')
-  s.add_dependency('geocoder', '~> 1.8.1')
+  s.add_dependency('thor', '~> 1.2.1')
+  s.add_dependency('xdg', '~> 2.2.3') # previous versions had bugs
 
   # TODO: use one of these two gems instead of `mdfind`.  **But** They have to work on Linux as well.
   #
@@ -37,25 +46,34 @@ Gem::Specification.new do |s|
 
   # Strategy: specific versions (since they're just for development)
   s.add_development_dependency('fakefs', '~> 2.4.0')
-  s.add_development_dependency('guard', '~> 2.12.5')
-  s.add_development_dependency('guard-rspec', '~> 4.6.2')
+  s.add_development_dependency('fuubar')
+  s.add_development_dependency('guard', '~> 2.18.0')
+  s.add_development_dependency('guard-bundler', '~> 3.0.1')
+  s.add_development_dependency('guard-rspec', '~> 4.7.3')
+  s.add_development_dependency('guard-rubocop')
+  s.add_development_dependency('pry-byebug')
   s.add_development_dependency('rake', '~> 13.0.6')
   s.add_development_dependency('redcarpet', '~> 3.6.0') # Soft dependency of `yard`
   s.add_development_dependency('rspec', '~> 3.12.0')
+  s.add_development_dependency('rubocop')
+  s.add_development_dependency('rubocop-rake')
+  s.add_development_dependency('rubocop-rspec')
+  s.add_development_dependency('simplecov')
   s.add_development_dependency('timecop', '~> 0.9.6')
   s.add_development_dependency('yard', '>= 0.9.11')
-  s.add_development_dependency('pry-byebug')
 
   # In Vagrant, polling won't cross over the OS boundary if you develop in the host OS but run your tests in the
   # guest.  One way around this is to force polling instead:
   #
   #     bundle exec guard --force-polling
   #
-  s.add_development_dependency('rb-inotify', '~> 0.10.1')
   s.add_development_dependency('rb-fsevent', '~> 0.11.2')
+  s.add_development_dependency('rb-inotify', '~> 0.10.1')
 
   s.files         = `git ls-files -z`.split("\0")
-  s.test_files    = `git ls-files -z -- {test,spec,features}/*`.split("\0")
-  s.executables   = `git ls-files -z -- bin/*`.split("\0").map{ |f| File.basename(f) }
-  s.require_paths = %w(lib)
+  s.executables   = `git ls-files -z -- bin/*`.split("\0").map { |f| File.basename(f) }
+  s.require_paths = %w[lib]
+
+  s.post_install_message = "🙏 Thank you for installing Maid, we hope it's " \
+                           "useful to you! Visit #{s.homepage} to report issues or contribute code."
 end

data/spec/dependency_spec.rb

@@ -20,12 +20,13 @@ describe 'Dependency expectations' do
   end
 
   describe Logger do
-    # Depending on the situation, `Logger` might have been overwritten to have a different interface.  (I'm looking at you, Rails.)
+    # Depending on the situation, `Logger` might have been overwritten to have
+    # a different interface.  (I'm looking at you, Rails.)
     it 'logs with the expected interface' do
       io = StringIO.new
       logger = Logger.new(io)
       logger.info('my message')
-      logger.formatter = lambda { |_, _, _, msg| msg }
+      logger.formatter = ->(_, _, _, msg) { msg }
       expect(io.string).to match(/my message/)
     end
   end
@@ -68,28 +69,28 @@ describe 'Dependency expectations' do
 
   describe Zip::File do
     it 'makes entries available with #entries' do
-      Zip::File.open("#@file_fixtures_path/foo.zip") do |zip_file|
-        expect(zip_file.entries.map { |entry| entry.name }).to match_array(%w(README.txt foo.exe subdir/anything.txt))
+      Zip::File.open("#{@file_fixtures_path}/foo.zip") do |zip_file|
+        expect(zip_file.entries.map { |entry| entry.name }).to match_array(%w[README.txt foo.exe subdir/anything.txt])
       end
     end
 
     it 'supports UTF-8 filenames' do
       # Filename is a Japanese character
-      Zip::File.open("#@file_fixtures_path/\343\201\225.zip") do |zip_file|
-        expect(zip_file.entries.map { |entry| entry.name }).to eq(%w(anything.txt))
+      Zip::File.open("#{@file_fixtures_path}/\343\201\225.zip") do |zip_file|
+        expect(zip_file.entries.map { |entry| entry.name }).to eq(%w[anything.txt])
       end
     end
   end
 
   describe Dimensions do
     it 'returns dimensions as an array' do
-      expect(Dimensions.dimensions("#@file_fixtures_path/sydney.jpg")).to eq([100, 75])
+      expect(Dimensions.dimensions("#{@file_fixtures_path}/sydney.jpg")).to eq([100, 75])
     end
   end
 
   describe EXIFR::JPEG do
     it 'returns latitude and longitude' do
-      gps = EXIFR::JPEG.new("#@file_fixtures_path/sydney.jpg").gps
+      gps = EXIFR::JPEG.new("#{@file_fixtures_path}/sydney.jpg").gps
       expect([gps.latitude, gps.longitude]).to eq([-33.85608611111111, 151.219925])
     end
   end

data/spec/lib/maid/app_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 require 'stringio'
 
+# FIXME: this clobbers rspec's output in the console. out.truncate(0) flushes
+# the StringIO object but fails the test. Maybe stubbing Kernel.warn and
+# Kernel.info would silence the output?
+# Something like spec/lib/maid/maid_spec.rb:5 and :172
 def capture_stdout
   out = StringIO.new
   $stdout = out
@@ -10,6 +14,10 @@ ensure
   $stdout = STDOUT
 end
 
+# FIXME: this clobbers rspec's output in the console. out.truncate(0) flushes
+# the StringIO object but fails the test. Maybe stubbing Kernel.warn and
+# Kernel.info would silence the output?
+# Something like spec/lib/maid/maid_spec.rb:5 and :172
 def capture_stderr
   out = StringIO.new
   $stderr = out
@@ -21,33 +29,33 @@ end
 
 module Maid
   describe App, '#clean' do
-
     before do
       @app = App.new
-      @app.stub(:maid_options)
-      @app.stub(:say)
+      allow(@app).to receive(:maid_options)
+      allow(@app).to receive(:say)
 
-      TrashMigration.stub(:needed?) { false }
+      allow(TrashMigration).to receive(:needed?).and_return(false)
 
-      # NOTE: It's pretty important that this is stubbed, unless you want your rules to be run over and over when you test!
+      # NOTE: It's pretty important that this is stubbed, unless you want your
+      # rules to be run over and over when you test!
       @maid = double('Maid')
-      @maid.stub(:clean)
-      @maid.stub(:log_device)
-      @maid.stub(:load_rules)
-      Maid.stub(:new) { @maid }
+      allow(@maid).to receive(:clean)
+      allow(@maid).to receive(:log_device)
+      allow(@maid).to receive(:load_rules)
+      allow(Maid).to receive(:new).and_return(@maid)
     end
 
     it 'makes a new Maid with the options' do
-      opts = { :foo => 'bar' }
-      @app.stub(:maid_options).and_return(opts)
+      opts = { foo: 'bar' }
+      allow(@app).to receive(:maid_options).and_return(opts)
       expect(Maid).to receive(:new).with(opts).and_return(@maid)
       @app.clean
     end
 
-    it 'cleans when --force is specified' do      
+    it 'cleans when --force is specified' do
       expect(@maid).to receive(:clean)
       App.start(['clean', '--force'])
-    end 
+    end
 
     it 'issues deprecation notice when called without option, but still clean' do
       expect(@maid).to receive(:clean).twice
@@ -94,13 +102,13 @@ module Maid
         # FIXME: This is ugly.  Maybe use `Maid.start(%w(version --long))` instead.
 
         # We can't simply stub `long?` because `options` is a frozen object.
-        options = double('options', :long? => true)
+        options = double('options', long?: true)
         @app.options = options
       end
 
       it 'prints out the gem version' do
         ua = 'Maid/0.0.1'
-        UserAgent.stub(:value) { ua }
+        allow(UserAgent).to receive(:value).and_return(ua)
         expect(@app).to receive(:say).with(ua)
         @app.version
       end
@@ -129,10 +137,10 @@ module Maid
   describe App, '#logs' do
     before do
       @maid = double('Maid')
-      @maid.stub(:clean)
-      @maid.stub(:log_device) { '/var/log/maid.log' }
-      @maid.stub(:load_rules)
-      Maid.stub(:new) { @maid }
+      allow(@maid).to receive(:clean)
+      allow(@maid).to receive(:log_device).and_return('/var/log/maid.log')
+      allow(@maid).to receive(:load_rules)
+      allow(Maid).to receive(:new).and_return(@maid)
     end
 
     describe 'prints out the log' do
@@ -142,11 +150,11 @@ module Maid
         @log_file.write(@log)
         @log_file.close
 
-        @maid.stub(:log_device) { @log_file.path }
+        allow(@maid).to receive(:log_device).and_return(@log_file.path)
       end
 
       after do
-        @log_file.unlink if !@log_file.nil?
+        @log_file.unlink unless @log_file.nil?
       end
 
       it 'dumps the last log entries when invoked without an option' do
@@ -154,14 +162,14 @@ module Maid
       end
 
       it 'prints an error when log does not exist' do
-        @maid.stub(:log_device) { '/maid/file-does-not-exist' }
+        allow(@maid).to receive(:log_device).and_return('/maid/file-does-not-exist')
         message = "Log file #{@maid.log_device} does not exist.\n"
 
         expect(capture_stderr { App.start(['logs']) }).to eq(message)
       end
 
       it 'does not tail when log does not exist' do
-        @maid.stub(:log_device) { '/maid/file-does-not-exist' }
+        allow(@maid).to receive(:log_device).and_return('/maid/file-does-not-exist')
         message = "Log file #{@maid.log_device} does not exist.\n"
 
         expect(capture_stderr { App.start(['logs', '--tail']) }).to eq(message)

data/spec/lib/maid/maid_spec.rb

@@ -2,10 +2,11 @@ require 'spec_helper'
 
 module Maid
   describe Maid do
+    let(:logger) { instance_spy('Logger') }
+
     before do
-      @logger = double('Logger').as_null_object
-      Logger.stub(:new) { @logger }
-      FileUtils.stub(:mkdir_p)
+      allow(Logger).to receive(:new).and_return(logger)
+      allow(FileUtils).to receive(:mkdir_p)
     end
 
     describe '.new' do
@@ -17,45 +18,46 @@ module Maid
       it 'sets up a logger with the given path, when provided' do
         log_device = '/var/log/maid.log'
         expect(Logger).to receive(:new).with(log_device, anything, anything)
-        Maid.new(:log_device => log_device)
+        Maid.new(log_device: log_device)
       end
 
       it 'rotates the log with the default settings' do
-        expect(Logger).to receive(:new).with(anything, Maid::DEFAULTS[:log_shift_age], Maid::DEFAULTS[:log_shift_size])
+        expect(Logger).to receive(:new).with(anything, Maid::DEFAULTS[:log_shift_age],
+                                             Maid::DEFAULTS[:log_shift_size],)
         Maid.new
       end
 
       it 'rotates the log with the given settings, when provided' do
         expect(Logger).to receive(:new).with(anything, 42, 1_000_000)
-        Maid.new(:log_shift_age => 42, :log_shift_size => 1_000_000)
+        Maid.new(log_shift_age: 42, log_shift_size: 1_000_000)
       end
 
       it 'makes the log directory in case it does not exist' do
         expect(FileUtils).to receive(:mkdir_p).with('/home/username/log')
-        Maid.new(:log_device => '/home/username/log/maid.log')
+        Maid.new(log_device: '/home/username/log/maid.log')
       end
 
       it 'takes a logger object during intialization' do
-        Logger.unstub(:new)
-        maid = Maid.new(:logger => @logger)
-        expect(maid.logger).to eq(@logger)
+        allow(Logger).to receive(:new).and_call_original
+        maid = Maid.new(logger: logger)
+        expect(maid.logger).to eq(logger)
       end
 
       describe 'platform-specific behavior' do
         before do
-          Platform.stub(:linux?)
-          Platform.stub(:osx?)
+          allow(Platform).to receive(:linux?)
+          allow(Platform).to receive(:osx?)
           @home = File.expand_path('~')
         end
 
         context 'when running on Linux' do
           before do
-            Platform.stub(:linux?) { true }
-            XDG.stub(:[]).with('DATA_HOME') { "#{ @home }/.local/share" }
+            allow(Platform).to receive(:linux?).and_return(true)
+            allow(XDG).to receive(:[]).with('DATA_HOME').and_return("#{@home}/.local/share")
           end
 
           it 'set the trash to the correct default path' do
-            trash_path = "#{ @home }/.local/share/Trash/files/"
+            trash_path = "#{@home}/.local/share/Trash/files/"
             expect(FileUtils).to receive(:mkdir_p).with(trash_path).once
             maid = Maid.new
             expect(maid.trash_path).to eq(trash_path)
@@ -64,11 +66,11 @@ module Maid
 
         context 'when running on OS X' do
           before do
-            Platform.stub(:osx?) { true }
+            allow(Platform).to receive(:osx?).and_return(true)
           end
 
           it 'sets the trash to the correct default path' do
-            trash_path = "#{ @home }/.Trash/"
+            trash_path = "#{@home}/.Trash/"
             expect(FileUtils).to receive(:mkdir_p).with(trash_path).once
             maid = Maid.new
             expect(maid.trash_path).to eq(trash_path)
@@ -77,7 +79,7 @@ module Maid
 
         context 'when running on an unsupported platform' do
           it 'does not implement trashing files' do
-            expect(lambda { Maid.new }).to raise_error(NotImplementedError)
+            expect { Maid.new }.to raise_error(NotImplementedError)
           end
         end
       end
@@ -85,19 +87,21 @@ module Maid
       it 'sets the trash to the given path, if provided' do
         trash_path = '/home/username/tmp/my_trash/'
         expect(FileUtils).to receive(:mkdir_p).with(trash_path).once
-        maid = Maid.new(:trash_path => trash_path)
+        maid = Maid.new(trash_path: trash_path)
         expect(maid.trash_path).not_to be_nil
         expect(maid.trash_path).to eq(trash_path)
       end
 
       it 'sets the progname for the logger' do
-        expect(@logger).to receive(:progname=).with(Maid::DEFAULTS[:progname])
         Maid.new
+
+        expect(logger).to have_received(:progname=).with(Maid::DEFAULTS[:progname])
       end
 
       it 'sets the progname for the logger to the given name, if provided' do
-        expect(@logger).to receive(:progname=).with('Fran')
-        Maid.new(:progname => 'Fran')
+        Maid.new(progname: 'Fran')
+
+        expect(logger).to have_received(:progname=).with('Fran')
       end
 
       it 'sets the file options to the defaults' do
@@ -105,8 +109,8 @@ module Maid
       end
 
       it 'sets the file options to the given options, if provided' do
-        maid = Maid.new(:file_options => { :verbose => true })
-        expect(maid.file_options).to eq(:verbose => true)
+        maid = Maid.new(file_options: { verbose: true })
+        expect(maid.file_options).to eq(verbose: true)
       end
 
       it 'sets the rules path' do
@@ -114,12 +118,12 @@ module Maid
       end
 
       it 'sets the rules pathto the given path, if provided' do
-        maid = Maid.new(:rules_path => 'Maidfile')
+        maid = Maid.new(rules_path: 'Maidfile')
         expect(maid.rules_path).to eq('Maidfile')
       end
 
       it 'ignores nil options' do
-        maid = Maid.new(:rules_path => nil)
+        maid = Maid.new(rules_path: nil)
         expect(maid.rules_path).to eq(Maid::DEFAULTS[:rules_path])
       end
     end
@@ -127,13 +131,14 @@ module Maid
     describe '#clean' do
       before do
         @maid = Maid.new
-        @logger.stub(:info)
+        allow(logger).to receive(:info)
       end
 
       it 'logs start and finish' do
-        expect(@logger).to receive(:info).with('Started')
-        expect(@logger).to receive(:info).with('Finished')
         @maid.clean
+
+        expect(logger).to have_received(:info).with('Started')
+        expect(logger).to have_received(:info).with('Finished')
       end
 
       it 'follows the given rules' do
@@ -143,20 +148,32 @@ module Maid
     end
 
     describe '#load_rules' do
-      before do
-        Kernel.stub(:load)
-        @maid = Maid.new
-      end
+      context 'when there is no LoadError' do
+        before do
+          allow(Kernel).to receive(:load)
+        end
+
+        let(:maid) { Maid.new }
 
-      it 'sets the Maid instance' do
-        expect(::Maid).to receive(:with_instance).with(@maid)
-        @maid.load_rules
+        it 'sets the Maid instance' do
+          expect(::Maid).to receive(:with_instance).with(maid)
+          maid.load_rules
+        end
       end
 
-      it 'gives an error on STDERR if there is a LoadError' do
-        Kernel.stub(:load).and_raise(LoadError)
-        expect(STDERR).to receive(:puts)
-        @maid.load_rules
+      context 'when there is a LoadError' do
+        let(:maid) { Maid.new }
+
+        before do
+          allow(Kernel).to receive(:load).and_raise(LoadError)
+          allow(Logger).to receive(:warn)
+        end
+
+        it 'gives an error on STDERR if there is a LoadError' do
+          maid.load_rules
+
+          expect(logger).to have_received(:warn).once
+        end
       end
     end
 
@@ -179,8 +196,8 @@ module Maid
 
     describe '#watch' do
       before do
-        Listen.stub(:to)
-        Listen.stub(:start)
+        allow(Listen).to receive(:to)
+        allow(Listen).to receive(:start)
         @maid = Maid.new
       end
 
@@ -195,8 +212,9 @@ module Maid
         expect(@maid.watches.first.path).to eq(File.expand_path('watch_dir'))
       end
 
-      it 'accepts a hash of options and passes them to Listen' do
-        hash = { :some => :options }
+      # FIXME: Example is too long, shouldn't need the rubocop::disable
+      it 'accepts a hash of options and passes them to Listen' do # rubocop:disable RSpec/ExampleLength
+        hash = { some: :options }
         @maid.watch('some_dir', hash) do
           rule 'test' do
           end
@@ -232,11 +250,12 @@ module Maid
         expect(@maid.repeats.first.timestring).to eq('1s')
       end
 
-      it 'accepts a hash of options and passes them to Rufus' do
+      # FIXME: Example is too long, shouldn't need the rubocop::disable
+      it 'accepts a hash of options and passes them to Rufus' do # rubocop:disable RSpec/ExampleLength
         scheduler = double('scheduler')
         expect(Rufus::Scheduler).to receive(:singleton).and_return(scheduler)
 
-        hash = { :some => :options }
+        hash = { some: :options }
         @maid.repeat('1s', hash) do
           rule 'test' do
           end
@@ -249,18 +268,21 @@ module Maid
     end
 
     describe '#follow_rules' do
-      it 'follows each rule' do
+      # FIXME: Example is too long, shouldn't need the rubocop::disable
+      it 'follows each rule' do # rubocop:disable RSpec/ExampleLength
         n = 3
         maid = Maid.new
-        expect(@logger).to receive(:info).exactly(n).times
+
         rules = (1..n).map do |i|
-          d = double("rule ##{ i }", :description => 'description')
+          d = double("rule ##{i}", description: 'description')
           expect(d).to receive(:follow)
           d
         end
         maid.instance_eval { @rules = rules }
 
         maid.follow_rules
+
+        expect(logger).to have_received(:info).exactly(n).times
       end
     end
 
@@ -270,11 +292,11 @@ module Maid
       end
 
       it 'reports `not-a-real-command` as not being a supported command' do
-        expect(lambda { @maid.cmd('not-a-real-command arg1 arg2') }).to raise_error(NotImplementedError)
+        expect { @maid.cmd('not-a-real-command arg1 arg2') }.to raise_error(NotImplementedError)
       end
 
-      it 'should report `echo` as a real command' do
-        expect(lambda { @maid.cmd('echo .') }).not_to raise_error
+      it 'reports `echo` as a real command' do
+        expect { @maid.cmd('echo .') }.not_to raise_error
       end
     end
   end

data/spec/lib/maid/numeric_extensions_spec.rb

@@ -18,7 +18,7 @@ describe Maid::NumericExtensions::SizeToKb do
   it 'tells you that 1 gigabyte equals 1024 megabytes' do
     expect(1.gigabyte).to eq(1024.megabytes)
   end
-  
+
   it 'tells you that 1 terabyte equals 1024 gigabytes' do
     expect(1.terabyte).to eq(1024.gigabytes)
   end

data/spec/lib/maid/platform_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module Maid
   describe Platform do
     def stub_host_os(value)
-      RbConfig::CONFIG.stub(:[]).with('host_os') { value }
+      allow(RbConfig::CONFIG).to receive(:[]).with('host_os').and_return(value)
     end
 
     describe 'determining the host OS' do