rake-commander 0.3.6 → 0.4.1

data/lib/rake-commander/option.rb

@@ -4,6 +4,7 @@ class RakeCommander
     extend RakeCommander::Base::ClassHelpers
     extend RakeCommander::Options::Name
     include RakeCommander::Options::Description
+    include RakeCommander::Options::Type
 
     attr_reader :name_full, :desc, :default
 
@@ -13,12 +14,14 @@ class RakeCommander
 
       @name_full  = name.freeze
       super(short.freeze, @name_full)
+
       @default        = kargs[:default]  if kargs.key?(:default)
       @desc           = kargs[:desc]     if kargs.key?(:desc)
       @required       = kargs[:required] if kargs.key?(:required)
       @type_coercion  = kargs[:type]     if kargs.key?(:type)
       @other_args     = args
       @original_block = block
+
       configure_other
     end
 
@@ -33,7 +36,9 @@ class RakeCommander
     # Creates a new option, result of merging this `opt` with this option,
     # @return [RakeCommander::Option] where opt has been merged
     def merge(opt, **kargs)
-      raise "Expecting RakeCommander::Option. Given: #{opt.class}" unless opt.is_a?(RakeCommander::Option)
+      msg = "Expecting RakeCommander::Option. Given: #{opt.class}"
+      raise msg unless opt.is_a?(RakeCommander::Option)
+
       dup(**opt.dup_key_arguments.merge(kargs), &opt.original_block)
     end
 
@@ -81,7 +86,8 @@ class RakeCommander
 
     # @param [String, Nil] the argument, may it exist
     def argument
-      return nil unless argument?
+      return unless argument?
+
       self.class.name_argument(name_full)
     end
 
@@ -93,10 +99,23 @@ class RakeCommander
     # @return [Class, NilClass]
     def type_coercion
       value = @type_coercion || (default? && default.class)
-      return nil unless value.is_a?(Class)
+      return unless allowed_type?(value)
+
       value
     end
 
+    # @return [Boolean] whether the option is an enum with fixed values.
+    def enum?
+      type_coercion.is_a?(Array)
+    end
+
+    # @return [Array, NilClass] the valid options when is `enum?`
+    def enum_options
+      return unless enum?
+
+      type_coercion
+    end
+
     # @return [Boolean]
     def default?
       instance_variable_defined?(:@default)
@@ -107,9 +126,12 @@ class RakeCommander
     # @param opt_parser [OptionParser] the option parser to add this option's switch.
     # @param implicit_short [Boolean] whether the implicit short of this option is active in the opts_parser.
     def add_switch(opts_parser, where: :base, implicit_short: false, &middleware)
-      raise "Expecting OptionParser. Given: #{opts_parser.class}" unless opts_parser.is_a?(OptionParser)
+      msg = "Expecting OptionParser. Given: #{opts_parser.class}"
+      raise msg unless opts_parser.is_a?(OptionParser)
+
       args  = switch_args(implicit_short: implicit_short)
       block = option_block(&middleware)
+
       case where
       when :head, :top
         opts_parser.on_head(*args, &block)
@@ -127,13 +149,14 @@ class RakeCommander
 
     # @return [Hash] keyed arguments to create a new object
     def dup_key_arguments
-      configure_other
       {}.tap do |kargs|
+        configure_other
+
         kargs.merge!(short:    short.dup.freeze)      if short
         kargs.merge!(name:     name_full.dup.freeze)  if name_full
         kargs.merge!(desc:     @desc.dup)             if @desc
         kargs.merge!(default:  @default.dup)          if default?
-        kargs.merge!(type:     @type_coercion)        if @type_coercion.is_a?(Class)
+        kargs.merge!(type:     @type_coercion)        if allowed_type?(@type_coercion)
         kargs.merge!(required: required?)
       end
     end
@@ -141,6 +164,7 @@ class RakeCommander
     # @return [Array<Variant>]
     def switch_args(implicit_short: false)
       configure_other
+
       args = [short_hyphen, name_hyphen]
       args.push(*switch_desc(implicit_short: implicit_short))
       args << type_coercion if type_coercion
@@ -152,10 +176,13 @@ class RakeCommander
     # Called on parse runtime
     def option_block(&middleware)
       block_extra_args = [default, short, name, self]
+
       proc do |value|
         value = !value if type_coercion == FalseClass
         args  = block_extra_args.dup.unshift(value)
+
         original_block&.call(*args)
+
         middleware&.call(*args)
       end
     end
@@ -165,8 +192,9 @@ class RakeCommander
     # @return [Array<String>]
     def switch_desc(implicit_short: false, line_width: DESC_MAX_LENGTH)
       ishort = implicit_short ? "( -#{short_implicit} ) " : ''
-      str    = "#{required_desc}#{ishort}#{desc}#{default_desc}"
+      str    = "#{required_desc}#{ishort}#{desc}#{enum_desc}#{default_desc}"
       return [] if str.empty?
+
       string_to_lines(str, max: line_width)
     end
 
@@ -175,12 +203,15 @@ class RakeCommander
     end
 
     def default_desc
-      return nil unless default?
-      str = "{ Default: '#{default}' }"
-      if desc && !desc.downcase.include?('default')
-        str = desc.end_with?('.') ? " #{str}" : ". #{str}"
-      end
-      str
+      return unless default?
+
+      " { Default: '#{default}' }"
+    end
+
+    def enum_desc
+      return unless enum?
+
+      " Options: [ #{enum_options.join(' | ')} ]."
     end
 
     # Helper to simplify `short` and `name` capture from arguments and keyed arguments.
@@ -191,8 +222,11 @@ class RakeCommander
       name  ||= capture_arguments_name!(args, sample_n_short: sample && short)
 
       unless sample
-        raise ArgumentError, "A short of one letter should be provided. Given: #{short}" unless self.class.valid_short?(short)
-        raise ArgumentError, "A name should be provided. Given: #{name}" unless  self.class.valid_name?(name)
+        msg = "A short of one letter should be provided. Given: #{short}"
+        raise ArgumentError, msg unless self.class.valid_short?(short)
+
+        msg = "A name should be provided. Given: #{name}"
+        raise ArgumentError, msg unless self.class.valid_name?(name)
       end
 
       [short, name]
@@ -213,41 +247,40 @@ class RakeCommander
     # @note if found it removes it from args.
     # @return [String, Symbol, NilClass]
     def capture_arguments_name!(args, sample_n_short: false)
-      name = nil
+      name   = nil
       name ||= self.class.capture_arguments_name!(args, symbol: true)
       name ||= self.class.capture_arguments_name!(args, symbol: true, strict: false)
       name ||= self.class.capture_arguments_name!(args)
-      name || self.class.capture_arguments_name!(args, strict: false) unless sample_n_short
+      name ||= self.class.capture_arguments_name!(args, strict: false) unless sample_n_short
+      name
     end
 
     # The remaining `args` received in the initialization
     def other_args(*args)
       @other_args ||= []
-      if args.empty?
-        @other_args
-      else
-        @other_args.push(*args)
-      end
+      return @other_args if args.empty?
+
+      @other_args.push(*args)
     end
 
     # It consumes `other_args`, to prevent direct overrides to be overriden by it.
+    # @note at the end we will pass the switch arguments to OptsParser.
     def configure_other
-      @type_coercion ||= fetch_type_from_other
-      @desc          ||= fetch_desc_from_other
+      @type_coercion = fetch_type_from_other(@type_coercion)
+      @desc          = fetch_desc_from_other(@desc)
       nil
     end
 
-    def fetch_type_from_other
-      return nil unless type = other_args.find {|arg| arg.is_a?(Class)}
-      type.tap { other_args.delete(type) }
+    def fetch_type_from_other(original = nil)
+      other_type = fetch_type!(other_args)
+
+      return original if original
+
+      other_type
     end
 
-    def fetch_desc_from_other
-      return nil unless value = other_args.find {|arg| arg.is_a?(String)}
-      other_args.dup.each do |val|
-        other_args.delete(val) if val.is_a?(String)
-      end
-      value
+    def fetch_desc_from_other(original = nil)
+      joined_lines(original, fetch_desc!(other_args))
     end
   end
 end

data/lib/rake-commander/options/arguments.rb

@@ -3,12 +3,12 @@ class RakeCommander
     # Offers helpers to treat `ARGV`
     module Arguments
       RAKE_COMMAND_EXTENDED_OPTIONS_START = '--'.freeze
-      NAME_ARGUMENT    = /^--(?<option>[\w_-]*).*?$/.freeze
-      BOOLEAN_ARGUMENT = /(?:^|--)no-(?<option>[\w_-]*).*?$/.freeze
+      NAME_ARGUMENT    = /^--(?<option>[\w_-]*).*?$/
+      BOOLEAN_ARGUMENT = /(?:^|--)no-(?<option>[\w_-]*).*?$/
 
       class << self
         def included(base)
-          super(base)
+          super
           base.extend ClassMethods
         end
       end
@@ -20,6 +20,7 @@ class RakeCommander
         # @return [Boolean] whether enhanced parsing should be switched on or off.
         def argv_with_enhanced_syntax?(argv = ARGV)
           return false unless argv.is_a?(Array)
+
           argv.include?(RAKE_COMMAND_EXTENDED_OPTIONS_START)
         end
 
@@ -41,6 +42,7 @@ class RakeCommander
         def argv_cropping_for_rake(value = :not_used)
           @argv_cropping_for_rake = true if @argv_cropping_for_rake.nil?
           return @argv_cropping_for_rake if value == :not_used
+
           @argv_cropping_for_rake = !!value
         end
 
@@ -51,8 +53,8 @@ class RakeCommander
         # @param argv [Array<String>] the command line arguments array.
         # @return [Array<String>] the target arguments to be parsed by `RakeCommander::Options`
         def argv_extended_options(argv = ARGV.dup)
-          if idx = argv.index(RAKE_COMMAND_EXTENDED_OPTIONS_START)
-            argv[idx+1..-1]
+          if (idx = argv.index(RAKE_COMMAND_EXTENDED_OPTIONS_START))
+            argv[idx + 1..]
           else
             []
           end
@@ -63,9 +65,11 @@ class RakeCommander
         # @return [Array<String>] the argv without the extended options of this gem.
         def argv_rake_native_arguments(argv = ARGV.dup)
           return argv unless argv_cropping_for_rake
-          if idx = argv.index(RAKE_COMMAND_EXTENDED_OPTIONS_START)
+
+          if (idx = argv.index(RAKE_COMMAND_EXTENDED_OPTIONS_START))
             argv = argv[0..idx]
           end
+
           argv
         end
 
@@ -77,10 +81,10 @@ class RakeCommander
         #     - So some tidy up is necessary and the head of the command (i.e. `rake some:task --`)
         #       should be excluded from arguments to input to the options parser.
         # @see `RakeCommander::Options#parse_options`
-        def parse_options(argv = ARGV, *args, **kargs, &block)
+        def parse_options(argv = ARGV, *_args, **_kargs)
           argv = argv_extended_options(argv)
           argv = argv_pre_parsed(argv, options: options_hash(with_implicit: true))
-          super(argv, *args, **kargs, &block)
+          super
         end
 
         # Options with arguments should not take another option as value.
@@ -95,22 +99,31 @@ class RakeCommander
         #   2. To overcome this limitation, you may enclose in double quotes and argument with
         #     that start (i,e, `"--argument"`).
         # @example
-        #   1. `-abc ARGUMENT` where only `c` receives the argument becomes `-ab -c ARGUMENT`
-        #   3. `-abc ARGUMENT` where `b` and `c` are argument receivers becomes `-a -b nil -c ARGUMENT`
-        #   2. `-acb ARGUMENT` where only `c` receives the argument becomes `-a -c nil -b ARGUMENT`
-        #   4. `-c --some-option ARGUMENT` where both options receive argument, becomes `-c nil --some-option ARGUMENT`
-        #   5. `-c --some-option -d ARGUMENT` where both options receive argument, becomes `-c nil --some-option nil -d ARGUMENT`
-        #   6. `-cd ARGUMENT` where `c` default is `"yeah"`, becomes `-c yeah -d ARGUMENT`
+        #   1. `-abc ARGUMENT` where only `c` receives the argument
+        #     becomes `-ab -c ARGUMENT`
+        #   2. `-abc ARGUMENT` where `b` and `c` are argument receivers
+        #     becomes `-a -b nil -c ARGUMENT`
+        #   3. `-acb ARGUMENT` where only `c` receives the argument
+        #     becomes `-a -c nil -b ARGUMENT`
+        #   4. `-c --some-option ARGUMENT` where both options receive argument,
+        #     becomes `-c nil --some-option ARGUMENT`
+        #   5. `-c --some-option -d ARGUMENT` where both options receive argument,
+        #     becomes `-c nil --some-option nil -d ARGUMENT`
+        #   6. `-cd ARGUMENT` where `c` default is `"yeah"`,
+        #     becomes `-c yeah -d ARGUMENT`
         # @param argv [Array<String>]
         # @param options [Hash] the defined `RakeCommander::Option` to re-arrange `argv` with.
         # @return [Array<String>] the re-arranged `argv`
         def argv_pre_parsed(argv = ARGV, options:)
-          pre_parsed = explicit_argument_options(argv, options)
+          pre_parsed    = explicit_argument_options(argv, options)
           compact_short = ''
+
           pre_parsed.each_with_object([]) do |(opt_ref, args), out|
             next out.push(*args) unless opt_ref.is_a?(Symbol)
+
             is_short = opt_ref.to_s.length == 1
             next compact_short << opt_ref.to_s if is_short && args.empty?
+
             out.push("-#{compact_short}") unless compact_short.empty?
             compact_short = ''
             opt_str = is_short ? "-#{opt_ref}" : name_hyphen(opt_ref)
@@ -139,17 +152,24 @@ class RakeCommander
         private
 
         # @example the output is actually a Hash, keyed by the Symbol of the option (short or name)
-        #   1. `-abc ARGUMENT` where only `c` receives the argument becomes `:a :b :c ARGUMENT`
-        #   3. `-abc ARGUMENT` where `b` and `c` are argument receivers becomes `:a :b nil :c ARGUMENT`
-        #   2. `-acb ARGUMENT` where only `c` receives the argument becomes `:a :c nil :b ARGUMENT`
-        #   4. `-c --some-option ARGUMENT` where both options receive argument, becomes `:c nil :some_option ARGUMENT`
-        #   5. `-c --some-option -d ARGUMENT` where first two options receive argument, becomes `:c nil :some_option nil :d ARGUMENT`
-        #   6. `-cd ARGUMENT` where `c` default is `"yeah"`, becomes `:c yeah :d ARGUMENT`
+        #   1. `-abc ARGUMENT` where only `c` receives the argument
+        #     becomes `:a :b :c ARGUMENT`
+        #   2. `-abc ARGUMENT` where `b` and `c` are argument receivers
+        #     becomes `:a :b nil :c ARGUMENT`
+        #   3. `-acb ARGUMENT` where only `c` receives the argument
+        #     becomes `:a :c nil :b ARGUMENT`
+        #   4. `-c --some-option ARGUMENT` where both options receive argument,
+        #     becomes `:c nil :some_option ARGUMENT`
+        #   5. `-c --some-option -d ARGUMENT` where first two options receive argument,
+        #     becomes `:c nil :some_option nil :d ARGUMENT`
+        #   6. `-cd ARGUMENT` where `c` default is `"yeah"`,
+        #     becomes `:c yeah :d ARGUMENT`
         # @return [Hash<Symbol, Array>]
         def explicit_argument_options(argv, options)
           decoupled  = decluster_shorts_n_names_to_sym(argv)
           grouped    = group_symbols_with_strings(decoupled)
           normalized = insert_missing_argument_to_groups(grouped, options)
+
           normalized.each_with_object({}) do |group, pre_parsed|
             opt_ref = group.first.is_a?(Symbol)? group.shift : nil
             pre_parsed[opt_ref] = group
@@ -163,14 +183,17 @@ class RakeCommander
         # @param groups [@see #pair_symbols_with_strings]
         def insert_missing_argument_to_groups(groups, options)
           groups.each do |group|
-            args = group.dup
+            args    = group.dup
             opt_ref = args.shift
+
             next unless args.empty?
             next unless opt_ref.is_a?(Symbol)
-            next unless opt = _retrieve_option_ref(opt_ref, options)
+            next unless (opt = _retrieve_option_ref(opt_ref, options))
             next unless opt.argument?
+
             next group.push(opt.default) if opt.default?
-            next unless opt.argument_required?
+            next                         unless opt.argument_required?
+
             group.push(nil)
           end
         end
@@ -180,11 +203,13 @@ class RakeCommander
         # @return [RakeCommander::Option, NilClass]
         def _retrieve_option_ref(opt_ref, options)
           opt = options[opt_ref]
-          return opt if     opt
-          return nil unless match   = opt_ref.to_s.match(BOOLEAN_ARGUMENT)
-          return nil unless opt_ref = match[:option]
-          return nil unless opt     = options[opt_ref.to_sym]
-          return nil unless opt.boolean_name?
+
+          return opt if opt
+          return     unless (match   = opt_ref.to_s.match(BOOLEAN_ARGUMENT))
+          return     unless (opt_ref = match[:option])
+          return     unless (opt     = options[opt_ref.to_sym])
+          return     unless opt.boolean_name?
+
           opt
         end
 
@@ -193,6 +218,7 @@ class RakeCommander
         def group_symbols_with_strings(argv)
           [].tap do |out|
             curr_ary = nil
+
             argv.each do |arg|
               if arg.is_a?(Symbol)
                 out << (curr_ary = [arg])

data/lib/rake-commander/options/description.rb

@@ -5,12 +5,39 @@ class RakeCommander
 
       private
 
+      def fetch_desc!(args)
+        descs = args.dup.select do |arg|
+          arg.is_a?(String).tap do |is_string|
+            next unless is_string
+
+            args.delete(arg)
+          end
+        end.uniq
+
+        joined_lines(*descs)
+      end
+
       def string_to_lines(str, max: DESC_MAX_LENGTH)
         str.scan(liner_regex(max)).map(&:strip)
       end
 
       def liner_regex(len = DESC_MAX_LENGTH)
-        /.{0,#{len}}[^ ](?:\s|$)/mi
+        /[^\n\r]{0,#{len}}[^ ](?:\s|$)/mi
+      end
+
+      def joined_lines(*lines, join: "\n")
+        lines = lines.compact.map(&:strip).reject(&:empty?)
+        return unless lines.count.positive?
+
+        first = lines.first
+        first = "#{first}." unless first.end_with?('.')
+
+        (lines[1..] || []).reduce(first) do |mem, line|
+          mem = "#{mem}."   unless mem.end_with?('.')
+          line = "#{line}." unless line.end_with?('.')
+
+          "#{mem}#{join}#{line}"
+        end
       end
     end
   end

data/lib/rake-commander/options/error/base.rb

@@ -4,7 +4,7 @@ class RakeCommander
       # Base error class that does a rely between OptionParser and RakeCommander errors
       class Base < RakeCommander::Base::CustomError
         extend RakeCommander::Options::Name
-        OPTION_REGEX = /(?:argument|option): (?<option>.+)/i.freeze
+        OPTION_REGEX = /(?:argument|option): (?<option>.+)/i
 
         class << self
           # Helper to check if `error` is this class or any children class
@@ -20,14 +20,17 @@ class RakeCommander
           def option_regex(value = :not_used)
             @option_regex ||= OPTION_REGEX
             return @option_regex if value == :not_used
+
             @option_regex = value
           end
 
           # Identifies the option `Symbol` (short or name) for a given message
           def option_sym(message)
-            return nil unless match = message.match(option_regex)
+            return unless (match = message.match(option_regex))
+
             option = match[:option]
             return name_word_sym(option) if option.length > 1
+
             short_sym(option)
           end
         end
@@ -59,6 +62,7 @@ class RakeCommander
 
         def from_desc
           return '' unless from
+
           if from.respond_to?(:name)
             "(#{from.name}) "
           elsif from.respond_to?(:to_s)

data/lib/rake-commander/options/error/handling.rb

@@ -4,7 +4,8 @@ class RakeCommander
       module Handling
         class << self
           def included(base)
-            super(base)
+            super
+
             base.extend RakeCommander::Base::ClassHelpers
             base.extend RakeCommander::Base::ClassInheritable
             base.extend ClassMethods
@@ -40,6 +41,7 @@ class RakeCommander
           # @return [Boolean] whether this error is enabled.
           def error_on_options(action = :not_used, error: RakeCommander::Options::Error::Base, &handler)
             RakeCommander::Options::Error::Base.require_argument!(error, :error, accept_children: true)
+
             @options_latest_error       = nil
             @error_on_options         ||= {}
             @error_on_options[error]    = action if action != :not_used
@@ -82,9 +84,10 @@ class RakeCommander
             action = error_on_options(error: eklass)
 
             # here is where we ignore the handler (when !action == `true`)
-            raise            unless !action || handler = error_on_options_handler(eklass)
+            raise            unless !action || (handler = error_on_options_handler(eklass))
             raise            if handler&.call(e, argv, results, leftovers)
             return leftovers if action == :continue
+
             puts e.message
             # https://stackoverflow.com/a/23340693/4352306
             exit 1
@@ -95,7 +98,13 @@ class RakeCommander
           def error_on_options_handler(error = :not_used, &handler)
             @error_on_options_handler        ||= {}
             return @error_on_options_handler if error == :not_used
-            RakeCommander::Options::Error::Base.require_argument!(error, :error, accept_children: true)
+
+            RakeCommander::Options::Error::Base.require_argument!(
+              error,
+              :error,
+              accept_children: true
+            )
+
             @error_on_options_handler[error] = handler if block_given?
             @error_on_options_handler[error]
           end

data/lib/rake-commander/options/error/invalid_argument.rb

@@ -2,12 +2,13 @@ class RakeCommander
   module Options
     module Error
       class InvalidArgument < RakeCommander::Options::Error::Base
-        option_regex(/invalid argument: (?<option>.+)/i.freeze)
+        option_regex(/invalid argument: (?<option>.+)/i)
 
         private
 
         def to_message(value)
-          return super unless opt = option
+          return super unless (opt = option)
+
           case value
           when OptionParser::InvalidArgument
             super("invalid option argument: #{opt.name_hyphen} (#{opt.short_hyphen})")

data/lib/rake-commander/options/error/invalid_option.rb

@@ -2,7 +2,7 @@ class RakeCommander
   module Options
     module Error
       class InvalidOption < RakeCommander::Options::Error::Base
-        option_regex(/invalid option: (?<option>.+)/i.freeze)
+        option_regex(/invalid option: (?<option>.+)/i)
       end
     end
   end

data/lib/rake-commander/options/error/missing_argument.rb

@@ -3,7 +3,7 @@ class RakeCommander
     module Error
       # Relates to options with missing required argument (when there's no `default` value)
       class MissingArgument < RakeCommander::Options::Error::Base
-        option_regex(/missing(?: required|) argument: (?<option>.+)/i.freeze)
+        option_regex(/missing(?: required|) argument: (?<option>.+)/i)
       end
     end
   end

data/lib/rake-commander/options/error.rb

@@ -11,7 +11,7 @@ class RakeCommander
     module Error
       class << self
         def included(base)
-          super(base)
+          super
           base.send :include, RakeCommander::Options::Error::Handling
           base.extend ClassMethods
         end
@@ -22,7 +22,7 @@ class RakeCommander
         # @see RakeCommander::Options::Result
         def parse_options(argv = ARGV, results: {}, leftovers: [], &block)
           with_error_handling(argv, results, leftovers) do
-            super.tap do |_|
+            super.tap do
               check_on_leftovers(leftovers)
               check_required_presence(results)
             end
@@ -37,11 +37,21 @@ class RakeCommander
             raise eklass.new(from: self, option: opt), msg, cause: nil
           rescue OptionParser::InvalidArgument => e
             eklass = RakeCommander::Options::Error::InvalidArgument
+            src_e  = nil
+            msg    = nil
             opt    = error_option(e, eklass)
-            raise eklass.new(e, from: self, option: opt), nil, cause: nil unless opt&.argument_required?
-            eklass = RakeCommander::Options::Error::MissingArgument
-            msg = "missing required argument in option: #{opt.name_hyphen} (#{opt.short_hyphen})"
-            raise eklass.new(from: self, option: opt), msg, cause: nil
+
+            if opt&.enum?
+              msg  = "argument in option #{opt.name_hyphen} (#{opt.short_hyphen}) "
+              msg << "should be any of [#{opt.enum_options.join(' | ')}]"
+            elsif opt&.argument_required?
+              eklass = RakeCommander::Options::Error::MissingArgument
+              msg    = "missing required argument in option: #{opt.name_hyphen} (#{opt.short_hyphen})"
+            else
+              src_e  = e
+            end
+
+            raise eklass.new(src_e, from: self, option: opt), msg, cause: nil
           end
         end
 
@@ -53,7 +63,8 @@ class RakeCommander
         # @param eklass [RakeCommander::Options::Error:Base::Class] the error class to retrive the option key
         # @return [RakeCommander::Option, NilClass]
         def error_option(err, eklass)
-          return false unless option_sym = eklass.option_sym(err.message)
+          return false unless (option_sym = eklass.option_sym(err.message))
+
           options_hash(with_implicit: true)[option_sym]
         end
 
@@ -65,6 +76,7 @@ class RakeCommander
         # @return [Hash] the results (same object)
         def check_on_leftovers(leftovers)
           return if leftovers.empty?
+
           eklass = RakeCommander::Options::Error::UnknownArgument
           raise eklass.new(leftovers, from: self)
         end