rake-commander 0.4.0 → 0.4.2

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

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

@@ -3,31 +3,34 @@ class RakeCommander
     module Name
       BOOLEAN_TOKEN       = '[no-]'.freeze
       # Substitions
-      HYPHEN_START_REGEX  = /^-+/.freeze
-      HYPEN_REGEX         = /-+/.freeze
-      UNDERSCORE_REGEX    = /_+/.freeze
-      WORD_DELIMITER      = /[\s=]+/.freeze
+      HYPHEN_START_REGEX  = /^-+/
+      HYPEN_REGEX         = /-+/
+      UNDERSCORE_REGEX    = /_+/
+      WORD_DELIMITER      = /[\s=]+/
       # Checkers / Capturers
-      OPTIONAL_REGEX      = /\[\w+\]$/.freeze
-      SINGLE_HYPHEN_REGEX = /^-(?<options>[^- ][^ ]*)/.freeze
-      DOUBLE_HYPHEN_REGEX = /^(?:--\[?no-\]?|--)(?<option>[^- ][^ \r\n]*).*$/.freeze
-      BOOLEAN_NAME_REGEX  = /^[^ ]*#{Regexp.escape(BOOLEAN_TOKEN)}[^ ]{2,}/.freeze
+      OPTIONAL_REGEX      = /\[\w+\]$/
+      SINGLE_HYPHEN_REGEX = /^-(?<options>[^- ][^ ]*)/
+      DOUBLE_HYPHEN_REGEX = /^(?:--\[?no-\]?|--)(?<option>[^- ][^ \r\n]*).*$/
+      BOOLEAN_NAME_REGEX  = /^[^ ]*#{Regexp.escape(BOOLEAN_TOKEN)}[^ ]{2,}/
 
       # @return [Boolean]
       def single_hyphen?(value)
         return false unless value.respond_to?(:to_s)
+
         !!value.to_s.match(SINGLE_HYPHEN_REGEX)
       end
 
       # @return [Boolean]
       def double_hyphen?(value)
         return false unless value.respond_to?(:to_s)
+
         !!value.to_s.match(DOUBLE_HYPHEN_REGEX)
       end
 
       # @return [Boolean] whether the name has the boolean switch `[no-]`
       def boolean_name?(value)
         return false unless value.respond_to?(:to_s)
+
         !!value.to_s.match(BOOLEAN_NAME_REGEX)
       end
 
@@ -35,9 +38,11 @@ class RakeCommander
       # @return [Boolean]
       def valid_short?(value, strict: false)
         return false unless value.respond_to?(:to_s)
+
         value = value.to_s.strip
         return false if value.empty?
         return false if strict && !single_hyphen?(value)
+
         value = value.gsub(HYPHEN_START_REGEX, '')
         value.length == 1
       end
@@ -46,9 +51,11 @@ class RakeCommander
       # @return [Boolean]
       def valid_name?(value, strict: false)
         return false unless value.respond_to?(:to_s)
+
         value = value.to_s.strip
         return false if value.empty?
         return false if strict && !double_hyphen?(value)
+
         name_sym(value).to_s.length > 1
       end
 
@@ -59,6 +66,7 @@ class RakeCommander
         capture_argument_with!(args) do |arg|
           next false unless arg.is_a?(String) || arg.is_a?(Symbol)
           next false if symbol && !arg.is_a?(Symbol)
+
           valid_short?(arg, strict: strict)
         end
       end
@@ -70,6 +78,7 @@ class RakeCommander
         capture_argument_with!(args) do |arg|
           next false unless arg.is_a?(String) || arg.is_a?(Symbol)
           next false if symbol && !arg.is_a?(Symbol)
+
           valid_name?(arg, strict: strict)
         end
       end
@@ -79,13 +88,16 @@ class RakeCommander
       # @return [String, Symbol, NilClass] the arg candidate
       def capture_argument_with!(args)
         raise ArgumentError, "Expecting Array. Given: #{args.class}" unless args.is_a?(Array)
+
         args.dup.find.with_index do |arg, i|
           yield(arg).tap do |valid|
             next unless valid
+
             args.slice!(i)
             return arg
           end
         end
+
         nil
       end
 
@@ -94,10 +106,12 @@ class RakeCommander
       #   * `"-d"` becomes `:d`
       # @return [Symbol, NilClass]
       def short_sym(value)
-        return nil unless value
+        return unless value
+
         value = value.to_s.gsub(BOOLEAN_TOKEN, '')
         value = value.gsub(HYPHEN_START_REGEX, '')
-        return nil unless value = value.chars.first
+        return unless value = value.chars.first
+
         value.to_sym
       end
 
@@ -110,11 +124,13 @@ class RakeCommander
       #   3. Replaces any multi-spacing by single space ` `
       # @return [Symbol, NilClass]
       def name_sym(value)
-        return nil unless value
+        return unless value
+
         value = value.to_s.gsub(HYPHEN_START_REGEX, '')
         value = value.gsub(HYPEN_REGEX, '_')
         value = value.gsub(WORD_DELIMITER, ' ')
-        return nil if value.empty?
+        return if value.empty?
+
         value.to_sym
       end
 
@@ -128,14 +144,16 @@ class RakeCommander
       # @return [Symbol, NilClass]
       def name_word_sym(value)
         value = value.to_s.gsub(BOOLEAN_TOKEN, '')
-        return nil unless value = name_sym(value)
-        return nil unless value = name_words(value).first
+        return unless (value = name_sym(value))
+        return unless (value = name_words(value).first)
+
         value.downcase.to_sym
       end
 
       # @return [String, NilClass] it returns the hyphened (`-`) version of a short `value`
       def short_hyphen(value)
-        return nil unless value = short_sym(value)
+        return unless (value = short_sym(value))
+
         "-#{value}"
       end
 
@@ -146,9 +164,11 @@ class RakeCommander
       #   * `:there_we_go` becomes `"--there-we-go"`
       # @return [String, NilClass] option `name` alone double hypened (`--`)
       def name_hyphen(value)
-        return nil unless value = name_sym(value)
+        return unless value = name_sym(value)
+
         value = value.to_s.gsub(UNDERSCORE_REGEX, '-')
-        return nil if value.empty?
+        return if value.empty?
+
         "--#{value}"
       end
 
@@ -174,6 +194,7 @@ class RakeCommander
       # @return [Boolean] `true` if `value` does NOT end with `[String]`
       def argument_required?(value)
         return false unless value
+
         !argument_optional?(value)
       end
 
@@ -185,6 +206,7 @@ class RakeCommander
       # @return [Boolean] `true` if `value` ends with `[String]`
       def argument_optional?(value)
         return true unless value
+
         !!value.match(OPTIONAL_REGEX)
       end
 
@@ -194,7 +216,8 @@ class RakeCommander
       #   * `"--there-we-go   [ARGUMENT]"` returns `["there-we-go","[ARGUMENT]"]`
       # @return [Array<String>] the words of `value` without hyphen start
       def name_words(value)
-        return nil unless value
+        return unless value
+
         value = value.to_s.gsub(HYPHEN_START_REGEX, '')
         value.to_s.split(WORD_DELIMITER)
       end

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

@@ -3,7 +3,7 @@ class RakeCommander
     module Result
       class << self
         def included(base)
-          super(base)
+          super
           base.extend ClassMethods
           base.attr_inheritable :options_with_defaults
         end
@@ -46,7 +46,7 @@ class RakeCommander
         #   2. We use `task_context` to open up extensibility.
         # @todo think if it should rather raise an `ArgumentError` when the task
         #   was not defined in an instance object of his class.
-        def install_task(&task_method)
+        def install_task(&task_method) # rubocop:disable Naming/BlockForwarding
           super(&task_context(&task_method))
         end
 
@@ -57,6 +57,7 @@ class RakeCommander
         def task_context(&task_method)
           instance = eval('self', task_method.binding, __FILE__, __LINE__)
           return task_method unless instance.is_a?(self)
+
           proc do |*task_args|
             # launch `ARGV` parsing
             instance.options
@@ -72,6 +73,7 @@ class RakeCommander
         # @return [Proc] the results collector that wraps the middleware.
         def results_collector(results, &middleware)
           results = result_defaults(results)
+
           proc do |value, default, short, name, opt|
             middleware&.call(value, default, short, name, opt)
             results[name] = results[short] = value.nil?? default : value
@@ -91,12 +93,21 @@ class RakeCommander
         end
       end
 
+      # INSTANCE METHODS
+
       # Launches the options parsing of this class.
       # @return [Hash] keyed by short.
-      def options(argv = ARGV, &block)
+      def options(argv = ARGV, &block) # rubocop:disable Naming/BlockForwarding
         return @options if instance_variable_defined?(:@options)
+
         @options = {}
-        self.class.parse_options(argv, results: @options, leftovers: options_leftovers, &block)
+        self.class.parse_options(
+          argv,
+          results:   @options,
+          leftovers: options_leftovers,
+          &block
+        )
+
         @options
       end
 

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

@@ -9,11 +9,13 @@ class RakeCommander
         # Name of the `Options::Set`
         def name(value = :not_used)
           return @name if value == :not_used
+
           @name = value.to_sym
         end
 
         def each(&block)
           return to_enum(:each) unless block
+
           options.each(&block)
         end
       end

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

@@ -0,0 +1,28 @@
+class RakeCommander
+  module Options
+    module Type
+      ALLOWED_TYPES = [
+        Class,
+        Array
+      ].freeze
+
+      private
+
+      def fetch_type!(args)
+        args.dup.select do |arg|
+          allowed_type?(arg).tap do |is_type|
+            next unless is_type
+
+            args.delete(arg)
+          end
+        end.first
+      end
+
+      def allowed_type?(value)
+        ALLOWED_TYPES.any? do |allowed|
+          value.is_a?(allowed)
+        end
+      end
+    end
+  end
+end

data/lib/rake-commander/options.rb

@@ -1,5 +1,6 @@
 require_relative 'options/name'
 require_relative 'options/description'
+require_relative 'options/type'
 require_relative 'options/arguments'
 require_relative 'options/result'
 require_relative 'options/error'
@@ -9,16 +10,20 @@ class RakeCommander
   module Options
     class << self
       def included(base)
-        super(base)
+        super
+
         base.extend RakeCommander::Base::ClassHelpers
         base.extend RakeCommander::Base::ClassInheritable
         base.extend ClassMethods
         base.attr_inheritable :banner
+
         base.attr_inheritable(:options_hash) do |value, subclass|
-          next nil unless value
+          next unless value
+
           value.values.uniq.each {|opt| subclass.send :add_to_options, opt.dup}
           subclass.send(:options_hash)
         end
+
         base.class_resolver :option_class, RakeCommander::Option
         base.send :include, RakeCommander::Options::Result
         base.send :include, RakeCommander::Options::Error
@@ -30,15 +35,17 @@ class RakeCommander
       # Overrides the auto-generated banner
       def banner(desc = :not_used)
         return @banner = desc unless desc == :not_used
-        return @banner if @banner
-        return task_options_banner if respond_to?(:task_options_banner, true)
+        return @banner        if @banner
+
+        task_options_banner   if respond_to?(:task_options_banner, true)
       end
 
       # Defines a new option or opens for edition an existing one if `reopen: true` is used.
       # @note
       #   - If override is `true`, it will with a Warning when same `short` or `name` clashes.
-      def option(*args, override: true, reopen: false, **kargs, &block)
+      def option(*args, override: true, reopen: false, **kargs, &block) # rubocop:disable Naming/BlockForwarding, Style/ArgumentsForwarding
         return option_reopen(*args, override: override, **kargs, &block) if reopen
+
         opt = option_class.new(*args, **kargs, &block)
         add_to_options(opt, override: override)
       end
@@ -52,13 +59,15 @@ class RakeCommander
       #   2. It will have the effect of overriding existing options
       # @note when `short` and `name` are provided, `name` takes precedence over `short`
       #   in the lookup (to identify the existing option)
-      def option_reopen(*args, override: false, **kargs, &block)
-        aux = option_class.new(*args, **kargs, sample: true, &block)
+      def option_reopen(*args, override: false, **kargs, &block) # rubocop:disable Naming/BlockForwarding, Style/ArgumentsForwarding
+        aux = option_class.new(*args, **kargs, sample: true, &block) # rubocop:disable Naming/BlockForwarding, Style/ArgumentsForwarding
         opt = options_hash.values_at(aux.name, aux.short).compact.first
         return option(*args, **kargs, &block) unless opt
+
         mod = {}.tap do |mkargs|
           mkargs.merge!(name: opt.name_full) if aux.name_full.is_a?(Symbol)
         end
+
         replace_in_options(opt, opt.merge(aux, **mod), override: override)
       end
 
@@ -77,10 +86,13 @@ class RakeCommander
       #   should be overriden, may they clash
       # @param options [Enumerable<RakeCommander::Option>]
       def options_use(opts, override: true)
-        raise "Could not obtain list of RakeCommander::Option from #{opts.class}" unless opts = to_options(opts)
+        msg = "Could not obtain list of RakeCommander::Option from #{opts.class}"
+        raise msg unless (opts = to_options(opts))
+
         opts.each do |opt|
           add_to_options(opt.deep_dup, override: override)
         end
+
         self
       end
 
@@ -103,6 +115,7 @@ class RakeCommander
       def options_hash(with_implicit: false)
         @options_hash ||= {}
         return @options_hash unless with_implicit
+
         @options_hash.merge(implicit_shorts)
       end
 
@@ -153,7 +166,7 @@ class RakeCommander
       end
 
       # @return [OptionParser]
-      def new_options_parser(&block)
+      def new_options_parser(&block) # rubocop:disable Naming/BlockForwarding
         require 'optparse'
         OptionParser.new(&block)
       end
@@ -180,6 +193,7 @@ class RakeCommander
       # @param opts [OptionParser] where the help will be added.
       def option_help(opts)
         return false if option?(:help) || option?(:h)
+
         option(:h, :help, 'Prints this help') do
           puts opts
           exit(0)
@@ -212,16 +226,19 @@ class RakeCommander
       # @return [RakeCommander::Option, NilClass] the option that was added, `nil` is returned otherwise.
       def add_to_options(opt, override: true)
         name_ref = respond_to?(:name)? " (#{name})" : ''
-        if sprev = option_get(opt.short)
+        if (sprev = option_get(opt.short))
           return nil unless override
           puts "Warning#{name_ref}: Overriding option '#{sprev.name}' with short '#{sprev.short}' ('#{opt.name}')"
           delete_from_options(sprev)
         end
-        if nprev = option_get(opt.name)
-          return nil unless override
+
+        if (nprev = option_get(opt.name))
+          return unless override
+
           puts "Warning#{name_ref}: Overriding option '#{nprev.short}' with name '#{nprev.name}' ('#{opt.short}')"
           delete_from_options(nprev)
         end
+
         options_hash[opt.name] = options_hash[opt.short] = opt
       end
 
@@ -245,6 +262,7 @@ class RakeCommander
         add_to_options(opt, override: override).tap do |added_opt|
           # restore previous status
           next options_hash[ref.short] = options_hash[ref.name] = ref unless added_opt
+
           delete_empty_keys(options_hash)
         end
       end
@@ -254,6 +272,7 @@ class RakeCommander
         hash.tap do |_h|
           hash.dup.each do |k, v|
             next unless v.nil?
+
             hash.delete(k)
           end
         end

data/lib/rake-commander/patcher/application/top_level_resume.rb

@@ -11,11 +11,13 @@ class RakeCommander
 
           def patch_prepend(_invoked_by)
             return unless target_defined?
+
             Rake::Application.prepend Patch
           end
 
           def target_defined?
             return true if defined?(target)
+
             puts "Warning (#{self}): undefined target #{target}"
             false
           end