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

data/Vagrantfile

@@ -3,12 +3,12 @@
 
 Vagrant.configure('2') do |config|
   # See also: `script/vagrant-test`, `script/vagrant-test-all`
-  config.vm.box     = ENV['MAID_TARGET_BOX'] || 'hashicorp/precise64'
+  config.vm.box = ENV['MAID_TARGET_BOX'] || 'hashicorp/precise64'
 
   config.vm.provider :virtualbox do |vb|
     # Maid has very low system requirements
     vb.customize ['modifyvm', :id, '--cpus', 1, '--memory', 192]
   end
 
-  config.vm.provision(:shell, :path => 'script/vagrant-provision', :args => ENV['MAID_TARGET_RUBY'] || '1.9.3')
+  config.vm.provision(:shell, path: 'script/vagrant-provision', args: ENV['MAID_TARGET_RUBY'] || '1.9.3')
 end

data/lib/maid/app.rb

@@ -8,18 +8,18 @@ class Maid::App < Thor
 
   desc 'introduction', 'Become aquainted with maid'
   def introduction
-    say <<EOF
-#{Maid::UserAgent.short}
-#{'=' * Maid::UserAgent.short.length}
+    say <<~EOF
+      #{Maid::UserAgent.short}
+      #{'=' * Maid::UserAgent.short.length}
 
-#{Maid::SUMMARY}
+      #{Maid::SUMMARY}
 
-  * Tutorial: https://github.com/benjaminoakes/maid#tutorial
-  * Community & examples: https://github.com/benjaminoakes/maid/wiki
-  * Documentation: http://www.rubydoc.info/gems/maid/#{Maid::VERSION}/Maid/Tools
+        * Tutorial: https://github.com/benjaminoakes/maid#tutorial
+        * Community & examples: https://github.com/benjaminoakes/maid/wiki
+        * Documentation: http://www.rubydoc.info/gems/maid/#{Maid::VERSION}/Maid/Tools
 
-For more information, run "maid help".
-EOF
+      For more information, run "maid help".
+    EOF
   end
 
   def self.sample_rules_path
@@ -27,10 +27,10 @@ EOF
   end
 
   desc 'clean', 'Clean based on rules'
-  method_option :rules,   :type => :string,  :aliases => %w(-r)
-  method_option :noop,    :type => :boolean, :aliases => %w(-n --dry-run)
-  method_option :force,   :type => :boolean, :aliases => %w(-f)
-  method_option :silent,  :type => :boolean, :aliases => %w(-s)
+  method_option :rules,   type: :string,  aliases: %w[-r]
+  method_option :noop,    type: :boolean, aliases: %w[-n --dry-run]
+  method_option :force,   type: :boolean, aliases: %w[-f]
+  method_option :silent,  type: :boolean, aliases: %w[-s]
   def clean
     maid = Maid::Maid.new(maid_options(options))
 
@@ -43,16 +43,14 @@ EOF
       return
     end
 
-    unless options.silent? || options.noop?
-      say "Logging actions to #{ maid.log_device.inspect }"
-    end
+    say "Logging actions to #{maid.log_device.inspect}" unless options.silent? || options.noop?
 
     maid.load_rules
     maid.clean
   end
 
   desc 'version', 'Print version information (optionally: system info)'
-  method_option :long, :type => :boolean, :aliases => %w(-l)
+  method_option :long, type: :boolean, aliases: %w[-l]
   def version
     if options.long?
       say Maid::UserAgent.value
@@ -64,53 +62,49 @@ EOF
   # Since this happens a lot by mistake
   map '--version' => :version
 
-  desc 'sample', "Create sample rules at #{ self.sample_rules_path }"
+  desc 'sample', "Create sample rules at #{sample_rules_path}"
   def sample
     path = self.class.sample_rules_path
 
     FileUtils.mkdir_p(File.dirname(path))
     File.open(path, 'w').puts(File.read(File.join(File.dirname(__FILE__), 'rules.sample.rb')))
 
-    say "Sample rules created at #{ path.inspect }", :green
+    say "Sample rules created at #{path.inspect}", :green
   end
-  
+
   desc 'daemon', 'Runs the watch/repeat rules in a daemon'
-  method_option :rules,   :type => :string,  :aliases => %w(-r)
-  method_option :silent,  :type => :boolean, :aliases => %w(-s)
+  method_option :rules,   type: :string,  aliases: %w[-r]
+  method_option :silent,  type: :boolean, aliases: %w[-s]
   def daemon
     maid = Maid::Maid.new(maid_options(options))
-    
+
     if Maid::TrashMigration.needed?
       migrate_trash
       return
     end
 
-    unless options.silent?
-      say "Logging actions to #{ maid.log_device.inspect }"
-    end
-    
+    say "Logging actions to #{maid.log_device.inspect}" unless options.silent?
+
     maid.load_rules
     maid.daemonize
   end
 
   desc 'logs', 'Manages logs written by maid'
-  method_option :path, :type => :boolean, :aliases => %w(-p)
-  method_option :tail, :type => :boolean, :aliases => %w(-t)
+  method_option :path, type: :boolean, aliases: %w[-p]
+  method_option :tail, type: :boolean, aliases: %w[-t]
   def logs
     maid = Maid::Maid.new(maid_options(options))
 
     if options.path?
       say maid.log_device
-    else
-      unless File.readable?(maid.log_device)
-        error "Log file #{maid.log_device} does not exist."
+    elsif File.readable?(maid.log_device)
+      if options.tail?
+        system("tail -f #{maid.log_device}")
       else
-        if options.tail?
-          system("tail -f #{maid.log_device}")
-        else
-          say `tail #{maid.log_device}`
-        end
+        say `tail #{maid.log_device}`
       end
+    else
+      error "Log file #{maid.log_device} does not exist."
     end
   end
 
@@ -120,18 +114,16 @@ EOF
 
       if options['noop']
         # You're testing, so a simple log goes to STDOUT and no actions are taken
-        h[:file_options] = { :noop => true }
+        h[:file_options] = { noop: true }
 
         unless options['silent']
           h[:logger] = false
           h[:log_device] = STDOUT
-          h[:log_formatter] = lambda { |_, _, _, msg| "#{ msg }\n" }
+          h[:log_formatter] = ->(_, _, _, msg) { "#{msg}\n" }
         end
       end
 
-      if options['rules']
-        h[:rules_path] = options['rules']
-      end
+      h[:rules_path] = options['rules'] if options['rules']
 
       h
     end
@@ -144,15 +136,20 @@ EOF
     migration = Maid::TrashMigration
     banner('Trash Migration', :yellow)
 
-    say <<-EOF
+    say <<~EOF
 
-You are using Linux and have a "~/.Trash" directory.  If you used Maid 0.1.2 or earlier, that directory may exist because Maid incorrectly moved trash files there.
+      You are using Linux and have a "~/.Trash" directory.  If you used Maid 0.1.2 or earlier, that directory may exist because Maid incorrectly moved trash files there.
 
-But no worries.  Maid can migrate those files to the correct place.
+      But no worries.  Maid can migrate those files to the correct place.
 
     EOF
 
-    response = ask("Would you like Maid to move the files in #{ migration.incorrect_trash.inspect } to #{ migration.correct_trash.inspect }?", :limited_to => %w(Y N))
+    response = ask(
+      "Would you like Maid to move the files in #{migration.incorrect_trash.inspect} " \
+      "to #{migration.correct_trash.inspect}?", limited_to: %w[
+        Y N
+      ],
+    )
 
     case response
     when 'Y'
@@ -163,16 +160,16 @@ But no worries.  Maid can migrate those files to the correct place.
 
       say('Migrated.  See the Maid log for details.')
     when 'N'
-      say <<-EOF
+      say <<~EOF
 
-Running Maid again will continue to give this warning until #{ migration.incorrect_trash.inspect } no longer exists, or the environment variable MAID_NO_MIGRATE_TRASH has a value.
+        Running Maid again will continue to give this warning until #{migration.incorrect_trash.inspect} no longer exists, or the environment variable MAID_NO_MIGRATE_TRASH has a value.
 
-Exiting...
+        Exiting...
       EOF
 
-      exit -1
+      exit(-1)
     else
-      raise "Reached 'impossible' case (response: #{ response.inspect })"
+      raise "Reached 'impossible' case (response: #{response.inspect})"
     end
   end
 

data/lib/maid/maid.rb

@@ -9,18 +9,20 @@ require 'xdg'
 class Maid::Maid
   include Maid::RuleContainer
   DEFAULTS = {
-    :progname     => 'Maid',
+    progname: 'Maid',
 
-    :log_device   => File.expand_path('~/.maid/maid.log'),
-    # We don't want the log files to grow without check, but 50 MB doesn't seem too bad.  (We're going with a larger size just for safety right now.)
-    :log_shift_age  => 5,
-    :log_shift_size => 10 * 1_048_576, # 10 * 1 MB
+    log_device: File.expand_path('~/.maid/maid.log'),
+    # We don't want the log files to grow without check, but 50 MB doesn't seem
+    # too bad.  (We're going with a larger size just for safety right now.)
+    log_shift_age: 5,
+    log_shift_size: 10 * 1_048_576, # 10 * 1 MB
 
-    :rules_path   => File.expand_path('~/.maid/rules.rb'),
-    :file_options => { :noop => false }, # for `FileUtils`
+    rules_path: File.expand_path('~/.maid/rules.rb'),
+    file_options: { noop: false }, # for `FileUtils`
   }.freeze
 
   attr_reader :file_options, :logger, :log_device, :rules_path, :trash_path, :watches, :repeats
+
   include ::Maid::Tools
 
   # Make a new Maid, setting up paths for the log and trash.
@@ -30,16 +32,16 @@ class Maid::Maid
   #     Maid::Maid.new(:log_device => '/home/username/log/maid.log', :trash_path => '/home/username/my_trash')
   #
   def initialize(options = {})
-    options = DEFAULTS.merge(options.reject { |k, v| v.nil? })
+    options = DEFAULTS.merge(options.reject { |_k, v| v.nil? })
 
     # TODO: Refactor and simplify (see also https://github.com/benjaminoakes/maid/pull/48#discussion_r1683942)
-    @logger = unless options[:logger]
-      @log_device = options[:log_device]
-      FileUtils.mkdir_p(File.dirname(@log_device)) unless @log_device.kind_of?(IO)
-      @logger = Logger.new(@log_device, options[:log_shift_age], options[:log_shift_size])
-    else
-      options[:logger]
-    end
+    @logger = if options[:logger]
+                options[:logger]
+              else
+                @log_device = options[:log_device]
+                FileUtils.mkdir_p(File.dirname(@log_device)) unless @log_device.is_a?(IO)
+                @logger = Logger.new(@log_device, options[:log_shift_age], options[:log_shift_size])
+              end
 
     @logger.progname  = options[:progname]
     @logger.formatter = options[:log_formatter] if options[:log_formatter]
@@ -59,16 +61,16 @@ class Maid::Maid
 
   # Start cleaning, based on the rules defined at rules_path.
   def clean
-    unless @log_device.kind_of?(IO)
-      @logger.info "v#{ Maid::VERSION }"
+    unless @log_device.is_a?(IO)
+      @logger.info "v#{Maid::VERSION}"
       @logger.info 'Started'
     end
 
     follow_rules
 
-    unless @log_device.kind_of?(IO)
-      @logger.info 'Finished'
-    end
+    return if @log_device.is_a?(IO)
+
+    @logger.info 'Finished'
   end
 
   # Add the rules at rules_path.
@@ -82,26 +84,26 @@ class Maid::Maid
       Kernel.load(path)
     end
   rescue LoadError => e
-    STDERR.puts e.message
+    warn e.message
   end
 
-  def watch(path, options = {}, &rules)
-    @watches << ::Maid::Watch.new(self, path, options, &rules)
+  def watch(path, options = {}, &block)
+    @watches << ::Maid::Watch.new(self, path, options, &block)
   end
 
-  def repeat(timestring, options = {}, &rules)
-    @repeats << ::Maid::Repeat.new(self, timestring, options, &rules)
+  def repeat(timestring, options = {}, &block)
+    @repeats << ::Maid::Repeat.new(self, timestring, options, &block)
   end
 
   # Daemonizes the process by starting all watches and repeats and joining
   # the threads of the schedulers/watchers
   def daemonize
     if @watches.empty? && @repeats.empty?
-      STDERR.puts 'Cannot run daemon. Nothing to watch or repeat.'
+      warn 'Cannot run daemon. Nothing to watch or repeat.'
     else
       all = @watches + @repeats
       all.each(&:run)
-      trap("SIGINT") do
+      trap('SIGINT') do
         # Running in a thread fixes celluloid ThreadError
         Thread.new do
           all.each(&:stop)
@@ -115,18 +117,16 @@ class Maid::Maid
   # Run a shell command.
   #--
   # Delegates to `Kernel.\``.  Made primarily for testing other commands and some error handling.
-  def cmd(command) #:nodoc:
-    if supported_command?(command)
-      %x(#{ command })
-    else
-      raise NotImplementedError, "Unsupported system command: #{ command.inspect }"
-    end
+  def cmd(command) # :nodoc:
+    raise NotImplementedError, "Unsupported system command: #{command.inspect}" unless supported_command?(command)
+
+    `#{command}`
   end
 
   private
 
   # Does the OS support this command?
-  def supported_command?(command) #:nodoc:
+  def supported_command?(command) # :nodoc:
     @@supported_commands ||= {}
 
     command_name = command.strip.split(/\s+/)[0]
@@ -134,20 +134,20 @@ class Maid::Maid
     # TODO: Instead of using `which`, use an alternative listed at:
     #
     #     http://stackoverflow.com/questions/592620/check-if-a-program-exists-from-a-bash-script
-    @@supported_commands[command_name] = supported ? supported : !%x(which #{ command_name }).empty?
+    @@supported_commands[command_name] = supported || !`which #{command_name}`.empty?
   end
 
   def default_trash_path
     # TODO: Refactor module declaration so this can be `Platform`
     if Maid::Platform.linux?
       # See the [FreeDesktop.org Trash specification](http://www.ramendik.ru/docs/trashspec.html)
-      path = "#{ XDG['DATA_HOME'] }/Trash/files"
+      path = "#{XDG['DATA_HOME']}/Trash/files"
     elsif Maid::Platform.osx?
       path = File.expand_path('~/.Trash')
     else
-      raise NotImplementedError, "Unknown default trash path (unsupported host OS: #{ Maid::Platform.host_os.inspect })"
+      raise NotImplementedError, "Unknown default trash path (unsupported host OS: #{Maid::Platform.host_os.inspect})"
     end
 
-    "#{ path }/"
+    "#{path}/"
   end
 end

data/lib/maid/numeric_extensions.rb

@@ -33,32 +33,32 @@ module Maid::NumericExtensions
     def seconds
       self
     end
-    alias :second :seconds
+    alias second seconds
 
     def minutes
       self * 60
     end
-    alias :minute :minutes
+    alias minute minutes
 
     def hours
       self * 3600
     end
-    alias :hour :hours
+    alias hour hours
 
     def days
       self * 24.hours
     end
-    alias :day :days
+    alias day days
 
     def weeks
       self * 7.days
     end
-    alias :week :weeks
+    alias week weeks
 
     def fortnights
       self * 2.weeks
     end
-    alias :fortnight :fortnights
+    alias fortnight fortnights
 
     # Reads best without arguments:  10.minutes.ago
     def ago(time = ::Time.now)
@@ -66,7 +66,7 @@ module Maid::NumericExtensions
     end
 
     # Reads best with argument:  10.minutes.until(time)
-    alias :until :ago
+    alias until ago
 
     # Reads best with argument:  10.minutes.since(time)
     def since(time = ::Time.now)
@@ -74,21 +74,22 @@ module Maid::NumericExtensions
     end
 
     # Reads best without arguments:  10.minutes.from_now
-    alias :from_now :since
+    alias from_now since
 
     ######################
     ### Maid additions ###
     ######################
 
-    # TODO find a better place for these to live?
+    # TODO: find a better place for these to live?
 
     # Reads well in a case like:
     #
     #   1.week.since? accessed_at('filename')
     def since?(other_time)
-      other_time < self.ago
+      other_time < ago
     end
   end
+
   module SizeToKb
     # Enables Computer disk size conversion into kilobytes.
     #
@@ -100,29 +101,29 @@ module Maid::NumericExtensions
     def kb
       self
     end
-    alias :kilobytes :kb
-    alias :kilobyte :kb
-    alias :kB :kb
+    alias kilobytes kb
+    alias kilobyte kb
+    alias kB kb
 
     def mb
-      self * 1024 ** 1
+      self * (1024**1)
     end
-    alias :megabytes :mb
-    alias :megabyte :mb
-    alias :mB :mb
+    alias megabytes mb
+    alias megabyte mb
+    alias mB mb
 
     def gb
-      self * 1024 ** 2
+      self * (1024**2)
     end
-    alias :gigabytes :gb
-    alias :gigabyte :gb
-    alias :gB :gb
+    alias gigabytes gb
+    alias gigabyte gb
+    alias gB gb
 
     def tb
-      self * 1024 ** 3
+      self * (1024**3)
     end
-    alias :terabytes :tb
-    alias :terabyte :tb
-    alias :tB :tb
+    alias terabytes tb
+    alias terabyte tb
+    alias tB tb
   end
 end

data/lib/maid/platform.rb

@@ -15,7 +15,7 @@ module Maid::Platform
     end
 
     def has_tag_available?
-      osx? && system("which -s tag")
+      osx? && system('which -s tag')
     end
   end
 

data/lib/maid/rake/task.rb

@@ -29,7 +29,7 @@ module Maid
 
       def define
         desc task_description
-        task *args do |task|
+        task(*args) do |task|
           SingleRule.perform(task.name, task_proc)
         end
       end

data/lib/maid/repeat.rb

@@ -1,24 +1,24 @@
 require 'rufus-scheduler'
 class Maid::Repeat
   include Maid::RuleContainer
-  
+
   attr_reader :timestring, :scheduler, :logger
-  
-  def initialize(maid, timestring, options = {}, &rules)
+
+  def initialize(maid, timestring, options = {}, &block)
     @maid = maid
     @logger = maid.logger # TODO: Maybe it's better to create seperate loggers?
     @scheduler = Rufus::Scheduler.singleton
     @timestring = timestring
     @options = options
-    initialize_rules(&rules)
+    initialize_rules(&block)
   end
 
   def run
-    unless rules.empty?
-      @scheduler.repeat(timestring, @options) { follow_rules }
-    end
+    return if rules.empty?
+
+    @scheduler.repeat(timestring, @options) { follow_rules }
   end
-  
+
   def stop
     @scheduler.shutdown(:join) # Join the work threads
   end

data/lib/maid/rule_container.rb

@@ -3,9 +3,9 @@ module Maid::RuleContainer
   attr_reader :rules
 
   # initialize_rules
-  def initialize_rules(&rules)
+  def initialize_rules(&block)
     @rules ||= []
-    instance_exec(&rules)
+    instance_exec(&block)
   end
 
   # Register a rule with a description and instructions (lambda function).
@@ -16,7 +16,7 @@ module Maid::RuleContainer
   # Follow all registered rules.
   def follow_rules(*args)
     @rules.each do |rule|
-      @logger.info("Rule: #{ rule.description }") unless @logger.nil?
+      @logger.info("Rule: #{rule.description}") unless @logger.nil?
       rule.follow(*args)
     end
   end

data/lib/maid/rules.sample.rb

@@ -8,12 +8,14 @@
 # what they do, you might run into unwanted results!
 #
 # Don't forget, it's just Ruby!  You can define custom methods and use them below:
-# 
+#
 #     def magic(*)
 #       # ...
 #     end
-# 
-# If you come up with some cool tools of your own, please send me a pull request on GitHub!  Also, please consider sharing your rules with others via [the wiki](https://github.com/benjaminoakes/maid/wiki).
+#
+# If you come up with some cool tools of your own, please send me a pull
+# request on GitHub!  Also, please consider sharing your rules with others via
+# [the wiki](https://github.com/benjaminoakes/maid/wiki).
 #
 # For more help on Maid:
 #
@@ -39,37 +41,35 @@ Maid.rules do
   end
 
   rule 'Mac OS X applications in zip files' do
-    found = dir('~/Downloads/*.zip').select { |path|
-      zipfile_contents(path).any? { |c| c.match(/\.app\/Contents\//) }
-    }
+    found = dir('~/Downloads/*.zip').select do |path|
+      zipfile_contents(path).any? { |c| c.match(%r{\.app/Contents/}) }
+    end
 
     trash(found)
   end
 
   rule 'Misc Screenshots' do
     dir('~/Desktop/Screen shot *').each do |path|
-      if 1.week.since?(accessed_at(path))
-        move(path, '~/Documents/Misc Screenshots/')
-      end
+      move(path, '~/Documents/Misc Screenshots/') if 1.week.since?(accessed_at(path))
     end
   end
 
   # NOTE: Currently, only Mac OS X supports `duration_s`.
   rule 'MP3s likely to be music' do
     dir('~/Downloads/*.mp3').each do |path|
-      if duration_s(path) > 30.0
-        move(path, '~/Music/iTunes/iTunes Media/Automatically Add to iTunes/')
-      end
+      move(path, '~/Music/iTunes/iTunes Media/Automatically Add to iTunes/') if duration_s(path) > 30.0
     end
   end
-  
+
   # NOTE: Currently, only Mac OS X supports `downloaded_from`.
   rule 'Old files downloaded while developing/testing' do
     dir('~/Downloads/*').each do |path|
-      if downloaded_from(path).any? { |u| u.match('http://localhost') || u.match('http://staging.yourcompany.com') } &&
-          1.week.since?(accessed_at(path))
-        trash(path)
-      end
+      next unless downloaded_from(path).any? do |u|
+                    u.match('http://localhost') || u.match('http://staging\.yourcompany\.com')
+                  end &&
+                  1.week.since?(accessed_at(path))
+
+      trash(path)
     end
   end
 end