Breaking up some complex methods in cli, collapsing MUTE/QUIET -> QUIET

README.md

@@ -145,8 +145,8 @@ scheduled job must run (coerced with `Kernel#Float()`) (default `5`)
 * `LOGFORMAT` - Log output format to use (either `'text'` or `'json'`,
 default `'text'`)
 * `PIDFILE` - If non-empty, write process PID to file (default empty)
-* `QUIET` or `MUTE` - Silence most output if non-empty (equivalent to
-a level of `Logger::FATAL`, default `false`)
+* `QUIET` - Silence most output if non-empty (equivalent to a level of
+`Logger::FATAL`, default `false`)
 * `VERBOSE` - Maximize log verbosity if non-empty (equivalent to a level
 of `Logger::DEBUG`, default `false`)
 
@@ -534,8 +534,8 @@ worker is started.
 There are several options to toggle the way scheduler logs its actions. They
 are toggled by environment variables:
 
-  - `MUTE` will stop logging anything. Completely silent.
-  - `VERBOSE` opposite of 'mute'; will log even debug information
+  - `QUIET` will stop logging anything. Completely silent.
+  - `VERBOSE` opposite of 'QUIET'; will log even debug information
   - `LOGFILE` specifies the file to write logs to. (default standard output)
   - `LOGFORMAT` specifies either "text" or "json" output format
     (default "text")
@@ -545,7 +545,7 @@ values:
 
 ```ruby
 Resque::Scheduler.configure do |c|
-  c.mute = false
+  c.quiet = false
   c.verbose = false
   c.logfile = nil # meaning all messages go to $stdout
   c.logformat = 'text'

lib/resque/scheduler.rb

@@ -372,7 +372,7 @@ def procline(string)
 
       def logger
         @logger ||= Resque::Scheduler::LoggerBuilder.new(
-          mute: mute,
+          quiet: quiet,
           verbose: verbose,
           log_dev: logfile,
           format: logformat

lib/resque/scheduler/cli.rb

@@ -53,9 +53,8 @@ class Cli
           callback: ->(options) { ->(p) { options[:pidfile] = p } }
         },
         {
-          args: ['-q', '--quiet',
-                 'Run with minimal output [QUIET] (or [MUTE])'],
-          callback: ->(options) { ->(q) { options[:mute] = q } }
+          args: ['-q', '--quiet', 'Run with minimal output [QUIET]'],
+          callback: ->(options) { ->(q) { options[:quiet] = q } }
         },
         {
           args: ['-v', '--verbose', 'Run with verbose output [VERBOSE]'],
@@ -84,12 +83,7 @@ def pre_run
       end
 
       def parse_options
-        OptionParser.new do |opts|
-          opts.banner = BANNER
-          OPTIONS.each do |opt|
-            opts.on(*opt[:args], &(opt[:callback].call(options)))
-          end
-        end.parse!(argv.dup)
+        option_parser.parse!(argv.dup)
       end
 
       def pre_setup
@@ -104,23 +98,70 @@ def setup_env
         require 'resque'
         require 'resque/scheduler'
 
+        setup_backgrounding
+        setup_pid_file
+        setup_scheduler_configuration
+      end
+
+      def run_forever
+        Resque::Scheduler.run
+      end
+
+      private
+
+      attr_reader :argv, :env
+
+      def option_parser
+        OptionParser.new do |opts|
+          opts.banner = BANNER
+          OPTIONS.each do |opt|
+            opts.on(*opt[:args], &(opt[:callback].call(options)))
+          end
+        end
+      end
+
+      OPTIONS_ENV_MAPPING = {
+        app_name: 'APP_NAME',
+        background: 'BACKGROUND',
+        dynamic: 'DYNAMIC_SCHEDULE',
+        env: 'RAILS_ENV',
+        initializer_path: 'INITIALIZER_PATH',
+        logfile: 'LOGFILE',
+        logformat: 'LOGFORMAT',
+        quiet: 'QUIET',
+        pidfile: 'PIDFILE',
+        poll_sleep_amount: 'RESQUE_SCHEDULER_INTERVAL',
+        verbose: 'VERBOSE'
+      }
+
+      def options
+        @options ||= {}.tap do |o|
+          OPTIONS_ENV_MAPPING.map { |key, envvar| o[key] = env[envvar] }
+        end
+      end
+
+      def setup_backgrounding
         # Need to set this here for conditional Process.daemon redirect of
         # stderr/stdout to /dev/null
-        Resque::Scheduler.mute = !!options[:mute]
+        Resque::Scheduler.quiet = !!options[:quiet]
 
         if options[:background]
           unless Process.respond_to?('daemon')
             abort 'background option is set, which requires ruby >= 1.9'
           end
 
-          Process.daemon(true, !Resque::Scheduler.mute)
+          Process.daemon(true, !Resque::Scheduler.quiet)
           Resque.redis.client.reconnect
         end
+      end
 
+      def setup_pid_file
         File.open(options[:pidfile], 'w') do |f|
           f.puts $PROCESS_ID
         end if options[:pidfile]
+      end
 
+      def setup_scheduler_configuration
         Resque::Scheduler.configure do |c|
           # These settings are somewhat redundant given the defaults present
           # in the attr reader methods.  They are left here for clarity and
@@ -135,30 +176,6 @@ def setup_env
           c.verbose = !!options[:verbose]
         end
       end
-
-      def run_forever
-        Resque::Scheduler.run
-      end
-
-      private
-
-      attr_reader :argv, :env
-
-      def options
-        @options ||= {
-          app_name: env['APP_NAME'],
-          background: env['BACKGROUND'],
-          dynamic: env['DYNAMIC_SCHEDULE'],
-          env: env['RAILS_ENV'],
-          initializer_path: env['INITIALIZER_PATH'],
-          logfile: env['LOGFILE'],
-          logformat: env['LOGFORMAT'],
-          mute: env['MUTE'] || env['QUIET'],
-          pidfile: env['PIDFILE'],
-          poll_sleep_amount: env['RESQUE_SCHEDULER_INTERVAL'],
-          verbose: env['VERBOSE']
-        }
-      end
     end
   end
 end

lib/resque/scheduler/configuration.rb

@@ -26,10 +26,10 @@ def verbose
       end
 
       # If set, produces no output
-      attr_writer :mute
+      attr_writer :quiet
 
-      def mute
-        @mute ||= !!ENV['MUTE']
+      def quiet
+        @quiet ||= !!ENV['QUIET']
       end
 
       # If set, will write messages to the file

lib/resque/scheduler/logger_builder.rb

@@ -10,18 +10,18 @@ class LoggerBuilder
       # Initializes new instance of the builder
       #
       # Pass :opts Hash with
-      #   - :mute if logger needs to be silent for all levels. Default - false
+      #   - :quiet if logger needs to be silent for all levels. Default - false
       #   - :verbose if there is a need in debug messages. Default - false
       #   - :log_dev to output logs into a desired file. Default - STDOUT
       #   - :format log format, either 'text' or 'json'. Default - 'text'
       #
       # Example:
       #
       #   LoggerBuilder.new(
-      #     :mute => false, :verbose => true, :log_dev => 'log/scheduler.log'
+      #     :quiet => false, :verbose => true, :log_dev => 'log/scheduler.log'
       #   )
       def initialize(opts = {})
-        @muted = !!opts[:mute]
+        @quiet = !!opts[:quiet]
         @verbose = !!opts[:verbose]
         @log_dev = opts[:log_dev] || $stdout
         @format = opts[:format] || 'text'
@@ -38,9 +38,9 @@ def build
       private
 
       def level
-        if @verbose && !@muted
+        if @verbose && !@quiet
           Logger::DEBUG
-        elsif !@muted
+        elsif !@quiet
           Logger::INFO
         else
           Logger::FATAL

test/cli_test.rb

@@ -158,25 +158,25 @@ def new_cli(argv = [], env = {})
     cli.pre_run
   end
 
-  test 'initializes mute/quiet from the env' do
+  test 'initializes quiet from the env' do
     cli = new_cli([], 'QUIET' => '1')
-    assert_equal('1', cli.send(:options)[:mute])
+    assert_equal('1', cli.send(:options)[:quiet])
   end
 
-  test 'defaults to unmuted' do
-    assert_equal(false, !!new_cli.send(:options)[:mute])
+  test 'defaults to un-quieted' do
+    assert_equal(false, !!new_cli.send(:options)[:quiet])
   end
 
-  test 'accepts mute/quiet via -q' do
+  test 'accepts quiet via -q' do
     cli = new_cli(%w(-q))
     cli.parse_options
-    assert_equal(true, cli.send(:options)[:mute])
+    assert_equal(true, cli.send(:options)[:quiet])
   end
 
-  test 'accepts mute via --quiet' do
+  test 'accepts quiet via --quiet' do
     cli = new_cli(%w(--quiet))
     cli.parse_options
-    assert_equal(true, cli.send(:options)[:mute])
+    assert_equal(true, cli.send(:options)[:quiet])
   end
 
   test 'initializes logfile from the env' do

test/delayed_queue_test.rb

@@ -3,7 +3,7 @@
 
 context 'DelayedQueue' do
   setup do
-    Resque::Scheduler.mute = true
+    Resque::Scheduler.quiet = true
     Resque.redis.flushall
   end
 

test/scheduler_args_test.rb

@@ -7,7 +7,7 @@
     Resque::Scheduler.clear_schedule!
     Resque::Scheduler.configure do |c|
       c.dynamic = false
-      c.mute = true
+      c.quiet = true
       c.poll_sleep_amount = nil
     end
   end

test/scheduler_setup_test.rb

@@ -19,11 +19,11 @@
   end
 
   test 'configure block' do
-    Resque::Scheduler.mute = false
+    Resque::Scheduler.quiet = false
     Resque::Scheduler.configure do |c|
-      c.mute = true
+      c.quiet = true
     end
-    assert_equal(Resque::Scheduler.mute, true)
+    assert_equal(Resque::Scheduler.quiet, true)
   end
 
   context 'when getting the env' do
@@ -67,7 +67,7 @@ def wipe
       assert Resque::Scheduler.send(:logger).level > Logger::DEBUG
     end
 
-    test 'not muted' do
+    test 'not quieted' do
       assert Resque::Scheduler.send(:logger).level < Logger::FATAL
     end
   end
@@ -90,8 +90,8 @@ def wipe
       assert Resque::Scheduler.send(:logger).level == Logger::DEBUG
     end
 
-    test 'mute logger' do
-      Resque::Scheduler.mute = true
+    test 'quiet logger' do
+      Resque::Scheduler.quiet = true
       assert Resque::Scheduler.send(:logger).level == Logger::FATAL
     end
   end

test/scheduler_task_test.rb

@@ -8,7 +8,7 @@
       c.poll_sleep_amount = 0.1
     end
     Resque.redis.flushall
-    Resque::Scheduler.mute = true
+    Resque::Scheduler.quiet = true
     Resque::Scheduler.clear_schedule!
     Resque::Scheduler.send(:instance_variable_set, :@scheduled_jobs, {})
     Resque::Scheduler.send(:instance_variable_set, :@shutdown, false)

test/scheduler_test.rb

@@ -5,7 +5,7 @@
   setup do
     Resque::Scheduler.configure do |c|
       c.dynamic = false
-      c.mute = true
+      c.quiet = true
       c.env = nil
       c.app_name = nil
     end

test/test_helper.rb

@@ -95,7 +95,7 @@ def self.perform(*args)
   DYNAMIC_SCHEDULE
   LOGFILE
   LOGFORMAT
-  MUTE
+  QUIET
   RAILS_ENV
   RESQUE_SCHEDULER_INTERVAL
   VERBOSE
@@ -105,7 +105,7 @@ def self.perform(*args)
 
 def nullify_logger
   Resque::Scheduler.configure do |c|
-    c.mute = nil
+    c.quiet = nil
     c.verbose = nil
     c.logfile = nil
     c.send(:logger=, nil)