maid 0.10.0 → 0.11.0

data/lib/maid/rule.rb

@@ -1,6 +1,6 @@
 class Maid::Rule < Struct.new(:description, :instructions, :maid)
   # Follow the instructions of the rule.
-  def follow(*args)
-    maid.instance_exec(*args, &instructions)
+  def follow(*)
+    maid.instance_exec(*, &instructions)
   end
 end

data/lib/maid/rule_container.rb

@@ -3,9 +3,9 @@ module Maid::RuleContainer
   attr_reader :rules
 
   # initialize_rules
-  def initialize_rules(&block)
+  def initialize_rules(&)
     @rules ||= []
-    instance_exec(&block)
+    instance_exec(&)
   end
 
   # Register a rule with a description and instructions (lambda function).

data/lib/maid/tools.rb

@@ -328,7 +328,7 @@ module Maid::Tools
   def mkdir(path, options = {})
     path = expand(path)
     log("mkdir -p #{sh_escape(path)}")
-    FileUtils.mkdir_p(path, **@file_options.merge(options))
+    FileUtils.mkdir_p(path, **@file_options, **options)
     path
   end
 
@@ -727,7 +727,7 @@ module Maid::Tools
   #     where_content_type(dir('~/Downloads/*'), 'public.image')
   def where_content_type(paths, filter_types)
     filter_types = Array(filter_types)
-    Array(paths).select { |p| !(filter_types & content_types(p)).empty? }
+    Array(paths).select { |p| filter_types.intersect?(content_types(p)) }
   end
 
   # Test whether a directory is either empty, or contains only empty
@@ -739,7 +739,7 @@ module Maid::Tools
   #       trash('~/Downloads/foo')
   #     end
   def tree_empty?(root)
-    return nil if File.file?(root)
+    return false if File.file?(root)
     return true if Dir.glob(root + '/*').length == 0
 
     ignore = []

data/lib/maid/trash_migration.rb

@@ -20,6 +20,8 @@ module Maid
       end
 
       def perform
+        # FIXME: This is tightly coupled, we can't pass a custom log device
+        # etc.
         maid = ::Maid::Maid.new(trash_path: correct_trash)
         # Use local variable so it's available in the closure used by `instance_eval`
         path = incorrect_trash

data/lib/maid/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Maid
-  VERSION = '0.10.0'
+  VERSION = '0.11.0'
   SUMMARY = 'Be lazy. Let Maid clean up after you, based on rules you define. ' \
             'Think of it as "Hazel for hackers".'
 end

data/lib/maid/watch.rb

@@ -5,7 +5,7 @@ class Maid::Watch
 
   attr_reader :path, :listener, :logger
 
-  def initialize(maid, path, options = {}, &block)
+  def initialize(maid, path, options = {}, &)
     @maid = maid
 
     if options.nil? || options.empty?
@@ -19,7 +19,7 @@ class Maid::Watch
 
     @logger = maid.logger # TODO: Maybe it's better to create seperate loggers?
     @path = File.expand_path(path)
-    initialize_rules(&block)
+    initialize_rules(&)
   end
 
   def run

data/lib/maid.rb

@@ -4,6 +4,7 @@ Deprecated.set_action(:warn)
 
 # Must be in this order:
 require 'maid/version'
+require 'maid/logger/logger'
 require 'maid/downloading'
 require 'maid/tools'
 require 'maid/rule_container'
@@ -32,8 +33,8 @@ module Maid
     end
 
     # Define rules for the Maid instance.
-    def rules(&block)
-      @instance.instance_exec(&block)
+    def rules(&)
+      @instance.instance_exec(&)
     end
   end
 end

data/maid.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = 'maid'
 
-  s.required_ruby_version = '>= 2.7.0'
+  s.required_ruby_version = '>= 3.2.0'
 
   # Strategy: if possible, use ranges (so there are fewer chances of version conflicts)
   s.add_dependency('deprecated', '~> 3.0.0')
@@ -46,20 +46,23 @@ 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('fuubar')
+  s.add_development_dependency('fuubar', '~> 2.5.1')
   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('guard-rubocop', '~> 1.5.0')
+  s.add_development_dependency('irb', '~> 1.15.1')
+  s.add_development_dependency('ostruct', '~> 0.6.1')
+  s.add_development_dependency('pry-byebug', '~> 3.10.1')
   s.add_development_dependency('rake', '~> 13.0.6')
-  s.add_development_dependency('rake-notes')
+  s.add_development_dependency('rake-notes', '~> 0.2.2')
   s.add_development_dependency('redcarpet', '~> 3.6.0') # Soft dependency of `yard`
+  s.add_development_dependency('reline', '~> 0.6.0')
   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('rubocop', '~> 1.50')
+  s.add_development_dependency('rubocop-rake', '~> 0.6.0')
+  s.add_development_dependency('rubocop-rspec', '~> 3.5.0')
+  s.add_development_dependency('simplecov', '~> 0.22.0')
   s.add_development_dependency('timecop', '~> 0.9.6')
   s.add_development_dependency('vcr', '~> 6.1.0')
   s.add_development_dependency('webmock', '~> 3.18.1')

data/release-please-config.json

@@ -0,0 +1,18 @@
+{
+  "always-update": true,
+  "bootstrap-sha": "d4901ad446c8a614ef80472ed5e6f1ba8c702ed5",
+  "bump-minor-pre-major": true,
+  "bump-patch-for-minor-pre-major": true,
+  "commit-search-depth": 500,
+  "group-pull-request-title-pattern": "chore: release ${version}",
+  "release-search-depth": 400,
+  "release-type": "ruby",
+  "sequential-calls": false,
+  "packages": {
+    ".": {
+      "release-type": "ruby",
+      "package-name": "maid",
+      "version-file": "lib/maid/version.rb"
+    }
+  }
+}

data/script/docker-test

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+
+# Run RSpec in a docker container, to avoid mistakenly writing to the live
+# filesystem while developing.
+docker rm -f maid-dev
+docker build -t maid-dev .
+docker run -it --rm --name maid-dev --mount type=bind,src="$(pwd)",target=/usr/src/app maid-dev

data/spec/fakefs_helper.rb

@@ -0,0 +1,13 @@
+# FakeFS is missing #flock, see https://github.com/fakefs/fakefs/issues/433 and
+# https://github.com/whitesmith/rubycritic/commit/57edc6244a9ebea8078a9c1dba32204ee7d1d895
+
+# NOTE: This avoid NotImplementedError on File.flock, but causes a myriad of
+# other issues since it doesn't really provide any locking in practice.
+# If required, include this file in spec_helper.rb to monkey-patch FakeFS.
+module FakeFS
+  class File < StringIO
+    def flock(*)
+      true
+    end
+  end
+end

data/spec/lib/maid/logger/logger_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'maid/logger/logger'
+
+module Maid
+  # FakeFS not required because we're writing the log to /tmp/ and deleting it
+  # after the test.
+  describe Logger do
+    let(:logfile) { '/tmp/maid/test.log' }
+    let(:logger) { described_class.new(device: logfile) }
+
+    after { FileUtils.rm('/tmp/maid/test.log', force: true) }
+
+    levels = %i[debug info warn error fatal unknown]
+    levels.each do |level|
+      it "responds to #{level}" do
+        expect(logger).to respond_to(level)
+      end
+    end
+
+    context 'with a filename' do
+      before { logger.info('test message') }
+
+      it 'creates that file' do
+        expect(File.exist?(logfile)).to be true
+      end
+
+      it 'sets the default progname' do
+        expect(File.read(logfile)).to match(/Maid: /)
+      end
+
+      context 'with the ::Logger::DEBUG log level' do
+        let(:logger) { described_class.new(device: logfile, level: ::Logger::DEBUG) }
+
+        levels.each do |level|
+          it "logs #{level} messages" do
+            logger.send(level, "#{level} test message")
+
+            expect(File.read(logfile)).to match("#{level} test message")
+          end
+        end
+      end
+
+      it 'works with a string' do
+        logger.info('test message')
+
+        expect(File.read(logfile)).to match 'test message'
+      end
+
+      it 'works with a custom progname and a block' do
+        logger.info('TestProgname') { 'test message' }
+
+        expect(File.read(logfile)).to match 'TestProgname: test message'
+      end
+    end
+
+    context 'with an IO' do
+      let(:logger) { described_class.new(device: StringIO.new) }
+
+      it 'is happy' do
+        expect { logger.info('test message') }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/lib/maid/maid_spec.rb

@@ -1,48 +1,48 @@
 require 'spec_helper'
 
 module Maid
-  describe Maid, fakefs: true do
-    let(:logger) { instance_spy('Logger') }
+  describe Maid do
+    let(:logger) { class_spy(::Logger) }
+    let(:logfile) { '/tmp/maid-specs/test.log' }
+    let(:rules_file) { File.expand_path(File.join(File.dirname(__dir__), '../../fixtures/files/test_rules.rb')) }
+    let(:test_defaults) { Maid::DEFAULTS.merge({ log_device: logfile, rules_path: rules_file }) }
 
     before do
-      allow(Logger).to receive(:new).and_return(logger)
+      FileUtils.mkdir_p(File.dirname(logfile))
+      # Avoid FakeFS error when the logfile doesn't already exist.
+      FileUtils.touch(logfile) if FakeFS.activated?
     end
 
-    describe '.new' do
-      it 'sets up a logger with the default path' do
-        expect(Logger).to receive(:new).with(Maid::DEFAULTS[:log_device], anything, anything)
-        Maid.new
-      end
-
-      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)
-      end
+    after do
+      # Cleanup afterwards
+      FileUtils.rm_rf(File.dirname(logfile))
+    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],)
-        Maid.new
-      end
+    describe '.new' do
+      context 'with the default options' do
+        before { Maid.new(**test_defaults, logger: logger) }
 
-      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)
+        it 'sets up a logger with the default path' do
+          expect(logger).to have_received(:new).with(device: test_defaults[:log_device])
+        end
       end
 
-      it 'makes the log directory in case it does not exist' do
-        expect(File.exist?('/home/username/log')).to be false
+      context 'with a custom logfile path' do
+        let(:device) { '/tmp/maid-specs/overridden-maid.log' }
 
-        Maid.new(log_device: '/home/username/log/maid.log')
+        before { Maid.new(log_device: device, logger: logger) }
 
-        expect(File.exist?('/home/username/log')).to be true
+        it 'sets up a logger with the given path, when provided' do
+          expect(logger).to have_received(:new).with(device: device)
+        end
       end
 
-      it 'takes a logger object during intialization' do
-        allow(Logger).to receive(:new).and_call_original
-        maid = Maid.new(logger: logger)
-        expect(maid.logger).to eq(logger)
+      context 'with a custom logger' do
+        let(:maid) { Maid.new(logger: logger) }
+
+        it 'uses it' do
+          expect(maid.logger).to eq(logger)
+        end
       end
 
       describe 'platform-specific behavior' do
@@ -87,25 +87,14 @@ module Maid
         end
       end
 
-      it 'sets the trash to the given path, if provided' do
-        trash_path = '/home/username/tmp/my_trash/'
-
-        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
-        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
-        Maid.new(progname: 'Fran')
+      context 'with a custom trash path' do
+        let(:trash_path) { '/tmp/maid-specs/my_trash/' }
+        let(:maid) { Maid.new(log_device: test_defaults[:log_device], trash_path: trash_path) }
 
-        expect(logger).to have_received(:progname=).with('Fran')
+        it 'sets the trash to the given path' do
+          expect(maid.trash_path).not_to be_nil
+          expect(maid.trash_path).to eq(trash_path)
+        end
       end
 
       it 'sets the file options to the defaults' do
@@ -133,21 +122,34 @@ module Maid
     end
 
     describe '#clean' do
+      let(:maid) { Maid.new(**test_defaults) }
+
       before do
-        @maid = Maid.new
-        allow(logger).to receive(:info)
+        # Start with a clean logfile
+        FileUtils.rm_rf(logfile)
+        # Create the files that the test rules will impact
+        FileUtils.mkdir_p('/tmp/maid-specs')
+        FileUtils.touch('/tmp/maid-specs/perfect_man')
+
+        maid.load_rules
+        maid.clean
+      end
+
+      after do
+        FileUtils.rm_rf('/tmp/maid-specs')
       end
 
-      it 'logs start and finish' do
-        @maid.clean
+      it 'logs the beginning' do
+        expect(File.read(logfile)).to match(/Started/)
+      end
 
-        expect(logger).to have_received(:info).with('Started')
-        expect(logger).to have_received(:info).with('Finished')
+      it 'logs the end' do
+        expect(File.read(logfile)).to match(/Finished/)
       end
 
       it 'follows the given rules' do
-        expect(@maid).to receive(:follow_rules)
-        @maid.clean
+        expect(File.exist?('/tmp/maid-specs/perfect_man')).to be false
+        expect(File.exist?('/tmp/maid-specs/buffalo_fuzz')).to be true
       end
     end
 
@@ -166,17 +168,17 @@ module Maid
       end
 
       context 'when there is a LoadError' do
-        let(:maid) { Maid.new }
+        let(:maid) { Maid.new(**test_defaults) }
 
         before do
           allow(Kernel).to receive(:load).and_raise(LoadError)
-          allow(Logger).to receive(:warn)
+          FileUtils.rm_rf(logfile)
         end
 
         it 'gives an error on STDERR if there is a LoadError' do
           maid.load_rules
 
-          expect(logger).to have_received(:warn).once
+          expect(File.read(logfile)).to match(/LoadError/)
         end
       end
     end
@@ -218,30 +220,37 @@ module Maid
       end
 
       # 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 }
-        FileUtils.mkdir_p('some_dir')
+      context 'with a hash of options' do
+        let(:hash) { { some: :options } }
+        let(:listener) { double('listener') }
 
-        @maid.watch('some_dir', hash) do
-          rule 'test' do
+        before do
+          FileUtils.mkdir_p('some_dir')
+          @maid.watch('some_dir', hash) do
+            rule 'test' do
+            end
           end
         end
 
-        listener = double('listener')
-
-        expect(Listen).to receive(:to) do |dir, opts|
-          expect(dir).to eq File.expand_path('some_dir')
-          expect(opts).to eq(hash)
-          listener
-        end
+        it 'passes them to Listen' do
+          expect(Listen).to receive(:to) do |dir, opts|
+            expect(dir).to eq File.expand_path('some_dir')
+            expect(opts).to eq(hash)
+            listener
+          end
 
-        expect(listener).to receive(:start)
+          expect(listener).to receive(:start)
 
-        @maid.watches.last.run
+          @maid.watches.last.run
+        end
       end
 
       context('with a non-existent directory') do
-        let(:maid) { Maid.new }
+        let(:maid) { Maid.new(**test_defaults) }
+
+        before do
+          FileUtils.rm_rf(logfile)
+        end
 
         it 'raises with an intelligible message' do
           expect { maid.watch('/doesnt_exist/') }.to raise_error(/file.*exist/)
@@ -256,14 +265,18 @@ module Maid
           rescue StandardError # rubocop:disable Lint/SuppressedException
           end
 
-          expect(logger).to have_received(:warn).with(/file.*exist/)
+          expect(File.read(logfile)).to match(/file.*exist/)
         end
       end
     end
 
-    describe '#repeat', fake_zoneinfo: true do
+    describe '#repeat', fake_zoneinfo: false do
       before do
-        @maid = Maid.new
+        # Avoid FakeFS error when the logfile doesn't already exist.
+        FileUtils.mkdir_p(File.dirname(logfile))
+        FileUtils.touch(logfile)
+
+        @maid = Maid.new(log_device: logfile)
       end
 
       it 'adds a repeat to the list of repeats' do
@@ -277,53 +290,50 @@ module Maid
         expect(@maid.repeats.first.timestring).to eq('1s')
       end
 
-      # 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)
+      context 'with a hash of options' do
+        let(:scheduler) { double('scheduler') }
+        let(:hash) { { some: :options } }
+
+        before do
+          allow(Rufus::Scheduler).to receive(:singleton).and_return(scheduler)
 
-        hash = { some: :options }
-        @maid.repeat('1s', hash) do
-          rule 'test' do
+          @maid.repeat('1s', hash) do
+            rule 'test' do
+            end
           end
         end
 
-        expect(scheduler).to receive(:repeat).with('1s', hash)
+        it 'passes them to Rufus' do
+          expect(scheduler).to receive(:repeat).with('1s', hash)
 
-        @maid.repeats.last.run
+          @maid.repeats.last.run
+        end
       end
     end
 
     describe '#follow_rules' 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
-
-        rules = (1..n).map do |i|
-          d = double("rule ##{i}", description: 'description')
-          expect(d).to receive(:follow)
-          d
-        end
-        maid.instance_eval { @rules = rules }
+      let(:maid) { Maid.new(**test_defaults) }
 
+      it 'follows each rule' do
+        # FIXME: This should run in a before and rules should be a let, but it
+        # fails when arranged that way.
+        rules = [spy(Rule), spy(Rule), spy(Rule)]
+        maid.instance_eval { @rules = rules }
         maid.follow_rules
 
-        expect(logger).to have_received(:info).exactly(n).times
+        expect(rules).to all(have_received(:follow).once)
       end
     end
 
     describe '#cmd' do
-      before do
-        @maid = Maid.new
-      end
+      let(:maid) { Maid.new(log_device: logfile) }
 
       it 'reports `not-a-real-command` as not being a supported command' do
-        expect { @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 'reports `echo` as a real command' do
-        expect { @maid.cmd('echo .') }.not_to raise_error
+        expect { maid.cmd('echo .') }.not_to raise_error
       end
     end
   end

data/spec/lib/maid/rake/single_rule_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Maid
   module Rake
-    describe SingleRule, fakefs: true do
+    describe SingleRule, :fakefs do
       subject(:single_rule) { described_class.new name, task }
       let(:name)            { double(:rule_description) }
       let(:task)            { proc {} }