rake-commander 0.1.4 → 0.2.0

data/lib/rake-commander/option.rb

@@ -3,26 +3,41 @@ class RakeCommander
   class Option < @option_struct
     extend RakeCommander::Base::ClassHelpers
     extend RakeCommander::Options::Name
+    include RakeCommander::Options::Description
 
-    attr_accessor :desc, :default
-    attr_writer :type_coertion, :required
-    attr_reader :name_full
+    attr_reader :name_full, :desc, :default
 
-    def initialize(short, name, *args, **kargs, &block)
-      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)
+    # @param sample [Boolean] allows to skip the `short` and `name` validations
+    def initialize(*args, sample: false, **kargs, &block)
+      short, name = capture_arguments_short_n_name!(args, kargs, sample: sample)
 
-      @name_full = name
-      super(short, name)
+      @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_coertion  = kargs[:type]     if kargs.key?(:type)
       @other_args     = args
       @original_block = block
-      yield(self) if block_given?
       configure_other
     end
 
+    # Makes a copy of this option
+    # @return [RakeCommander::Option]
+    def dup(**kargs, &block)
+      block ||= original_block
+      self.class.new(**dup_key_arguments.merge(kargs), &block)
+    end
+    alias_method :deep_dup, :dup
+
+    # Creates a new option, result of merging this `opt` with this option,
+    # @return [RakeCommander::Option] where opt has been merged
+    def merge(opt)
+      raise "Expecting RakeCommander::Option. Given: #{opt.class}" unless opt.is_a?(RakeCommander::Option)
+      dup(**opt.dup_key_arguments, &opt.original_block)
+    end
+
+    # @return [Boolean] whether this option is required.
     def required?
       !!@required
     end
@@ -32,6 +47,13 @@ class RakeCommander
       self.class.short_sym(super)
     end
 
+    # `OptionParser` interprets free shorts that match the first letter of an option name
+    # as an invocation of that option. This method allows to identify this.
+    # return [Symbol]
+    def short_implicit
+      self.class.short_sym(@name_full)
+    end
+
     # @return [String]
     def short_hyphen
       self.class.short_hyphen(short)
@@ -47,6 +69,11 @@ class RakeCommander
       self.class.name_hyphen(name_full)
     end
 
+    # @return [Boolean]
+    def boolean_name?
+      self.class.boolean_name?(name_full)
+    end
+
     # @param [Boolean] whether this option allows an argument
     def argument?
       self.class.name_argument?(name_full)
@@ -75,26 +102,43 @@ class RakeCommander
 
     # Adds this option's switch to the `OptionParser`
     # @note it allows to add a `middleware` block that will be called at `parse` runtime
-    def add_switch(opts_parser, where: :base, &middleware)
+    # @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)
+      args  = switch_args(implicit_short: implicit_short)
+      block = option_block(&middleware)
       case where
       when :head, :top
-        opts_parser.on_head(*switch_args, &option_block(&middleware))
+        opts_parser.on_head(*args, &block)
       when :tail, :end
-        opts_parser.on_tail(*switch_args, &option_block(&middleware))
+        opts_parser.on_tail(*args, &block)
       else # :base
-        opts_parser.on(*switch_args, &option_block(&middleware))
+        opts_parser.on(*args, &block)
       end
       opts_parser
     end
 
+    protected
+
+    attr_reader :original_block
+
+    # @return [Hash] keyed arguments to create a new object
+    def dup_key_arguments
+      {}.tap do |kargs|
+        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!(required: required?)
+      end
+    end
+
     # @return [Array<Variant>]
-    def switch_args
+    def switch_args(implicit_short: false)
       configure_other
       args = [short_hyphen, name_hyphen]
-      if str = switch_desc
-        args << str
-      end
+      args.push(*switch_desc(implicit_short: implicit_short))
       args << type_coertion if type_coertion
       args
     end
@@ -106,26 +150,72 @@ class RakeCommander
       block_extra_args = [default, short, name]
       proc do |value|
         args = block_extra_args.dup.unshift(value)
-        @original_block&.call(*args)
+        original_block&.call(*args)
         middleware&.call(*args)
       end
     end
 
-    def switch_desc
-      val = "#{desc}#{default_desc}"
-      return nil if val.empty?
-      val
+    # @note in `OptionParser` you can multiline the description with alignment
+    #   by providing multiple strings.
+    # @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}"
+      return [] if str.empty?
+      string_to_lines(str, max: line_width)
+    end
+
+    def required_desc
+      required?? "< REQ >  " : "[ opt ]  "
     end
 
     def default_desc
       return nil unless default?
-      str = "Default: '#{default}'"
+      str = "{ Default: '#{default}' }"
       if desc && !desc.downcase.include?('default')
         str = desc.end_with?('.') ? " #{str}" : ". #{str}"
       end
       str
     end
 
+    # Helper to simplify `short` and `name` capture from arguments and keyed arguments.
+    # @return [Array<Symbol, String>] the pair `[short, name]`
+    def capture_arguments_short_n_name!(args, kargs, sample: false)
+      name, short = kargs.values_at(:name, :short)
+      short ||= capture_arguments_short!(args)
+      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)
+      end
+
+      [short, name]
+    end
+
+    # Helper to figure out the option short from args
+    # @note if found it removes it from args.
+    # @return [String, Symbol, NilClass]
+    def capture_arguments_short!(args)
+      short = nil
+      short ||= self.class.capture_arguments_short!(args, symbol: true)
+      short ||= self.class.capture_arguments_short!(args, symbol: true, strict: false)
+      short ||= self.class.capture_arguments_short!(args)
+      short || self.class.capture_arguments_short!(args, strict: false)
+    end
+
+    # Helper to figure out the option name from args
+    # @note if found it removes it from args.
+    # @return [String, Symbol, NilClass]
+    def capture_arguments_name!(args, sample_n_short: false)
+      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
+    end
+
+    # The remaining `args` received in the initialization
     def other_args(*args)
       @other_args ||= []
       if args.empty?
@@ -138,11 +228,11 @@ class RakeCommander
     # It consumes `other_args`, to prevent direct overrides to be overriden by it.
     def configure_other
       if type = other_args.find {|arg| arg.is_a?(Class)}
-        self.type_coertion = type
+        @type_coertion = type
         other_args.delete(type)
       end
       if value = other_args.find {|arg| arg.is_a?(String)}
-        self.desc = value
+        @desc = value
         other_args.dup.each do |val|
           other_args.delete(val) if val.is_a?(String)
         end

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

@@ -2,112 +2,224 @@ class RakeCommander
   module Options
     # Offers helpers to treat `ARGV`
     module Arguments
-      include RakeCommander::Options::Name
-
-      # Options with arguments should not take another option as value.
-      # `OptionParser` can do this even if the the argument is optional.
-      # This method re-arranges the arguments based on options that receive parameters,
-      # provided that an option is not taken as a value of a previous option that accepts arguments.
-      # If an option with argument is missing the argument, but has a `default` value,
-      # that `default` value will be inserted after the option in the array
-      # to prevent the `OptionParser::MissingArgument` error to stop the parsing process.
-      # @note
-      #   1. Any word or letter with _hypen_ -`` or _double hypen_ `--` is interpreted as option(s)
-      #   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`
-      # @param argv [Array<String>]
-      # @param options [Hash] the defined `RakeCommander::Option` to re-arrange `argv` with.
-      # @return [Array<String>] the re-arranged `argv`
-      def pre_parse_arguments(argv = 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)
-          out.push(opt_str, *args)
-        end.tap do |out|
-          out.push("-#{compact_short}") unless compact_short.empty?
+      RAKE_COMMAND_EXTENDED_OPTIONS_START = '--'.freeze
+      NAME_ARGUMENT    = /^--(?<option>[\w_-]*).*?$/.freeze
+      BOOLEAN_ARGUMENT = /(?:^|--)no-(?<option>[\w_-]*).*?$/.freeze
+
+      class << self
+        def included(base)
+          super(base)
+          base.extend ClassMethods
         end
       end
 
-      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`
-      # @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
+      module ClassMethods
+        include RakeCommander::Options::Name
+
+        # @note it assumes `ARGV` has been left unaltered.
+        # @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
-      end
 
-      # It adds the missing argument to options that expect it.
-      # @note it uses `default` if present, and `nil` otherwise.
-      # @param groups [@see #pair_symbols_with_strings]
-      def insert_missing_argument_to_groups(groups, options)
-        groups.each do |group|
-          args = group.dup
-          opt_ref = args.shift
-          next unless args.empty?
-          next unless opt_ref.is_a?(Symbol)
-          next unless opt = options[opt_ref]
-          next unless opt.argument?
-          next group.push(opt.default) if opt.default?
-          group.push(nil)
+        # Configuration setting
+        # Whether the additional arguments (extended options) managed by this gem
+        # should be removed/consumed from `ARGV` before `Rake` processes option arguments.
+        # @note
+        #   1. When `true` it **will enable**
+        #     * A **patch** on `Rake::Application`**, provided that `ARGV` is cropped
+        #       before `Rake` identifies **tasks** and rake native **options**.
+        #       Note that this specific patch only works if rake commander was loaded
+        #       BEFORE `Rake::Application#run` is invoked.
+        #   2. When `false`, an implicit `exit(0)` is added at the end of a rake task
+        #     defined via `RakeCommander`, as a work-around that prevents `Rake` from
+        #     chaining option arguments as if they were actual tasks.
+        # @note
+        #   1. This only refers to what comes after `RAKE_COMMAND_EXTENDED_OPTIONS_START` (`--`)
+        # @return [Boolean]
+        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
+
+        # It returns the part of `ARGV` that are arguments of `RakeCommander::Options` parsing.
+        # @note please observe that `Rake` has it's own options. For this reason using
+        #   a delimiter (`RAKE_COMMAND_EXTENDED_OPTIONS_START`) shows up to be necessary to
+        #   create some sort of command line argument namespacing.
+        # @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]
+          else
+            []
+          end
         end
-      end
 
-      # @return [Array<Array>] where the first element of each `Array` is a symbol
-      #   followed by one or more `String`.
-      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])
-            else # must be `String`
-              out << (curr_ary = []) unless curr_ary
-              curr_ary << arg
+        # It slices from the original `ARGV` the extended_options of this gem.
+        # @note this is necessary to prevent `Rake` to interpret them.
+        # @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)
+            argv = argv[0..idx]
+          end
+          argv
+        end
+
+        # **Re-open** `parse_options` method, provided that we slice `ARGV`
+        # to only include the extended options of this gem, which start at
+        # `RAKE_COMMAND_EXTENDED_OPTIONS_START`.
+        # @note
+        #   1. Without this `ARGV` cut, it will throw `OptionParser::InvalidOption` error
+        #     - 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)
+          argv = argv_extended_options(argv)
+          argv = argv_pre_parsed(argv, options: options_hash(with_implicit: true))
+          super(argv, *args, **kargs, &block)
+        end
+
+        # Options with arguments should not take another option as value.
+        # `OptionParser` can do this even if the the argument is optional.
+        # This method re-arranges the arguments based on options that receive parameters,
+        # provided that an option is not taken as a value of a previous option that accepts arguments.
+        # If an option with argument is missing the argument, but has a `default` value,
+        # that `default` value will be inserted after the option in the array
+        # to prevent the `OptionParser::MissingArgument` error to stop the parsing process.
+        # @note
+        #   1. Any word or letter with _hypen_ -`` or _double hypen_ `--` is interpreted as option(s)
+        #   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`
+        # @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)
+          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)
+            out.push(opt_str, *args)
+          end.tap do |out|
+            out.push("-#{compact_short}") unless compact_short.empty?
+          end
+        end
+
+        protected
+
+        # It wraps the `task_method` to check if the patch to crop `ARGV` is active.
+        # If it's not active it will call `exit(0)` at the end of the task run, to prevent
+        # `Rake` from interpreting option arguments as rake tasks.
+        # @note **reopens** `RakeCommander::RakeTask` method
+        #   * If `argv_cropping_for_rake` is `false` it calls `exit(0)` right at the end of the task.
+        #   * This relates on whether the patch to `Rake::Application` has been applied.
+        # @return [Proc] the wrapped block.
+        def task_context(&task_method)
+          proc do |*task_args|
+            super(&task_method).call(*task_args)
+            exit(0) unless argv_cropping_for_rake
+          end
+        end
+
+        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`
+        # @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
+          end
+        end
+
+        # It ADDS  the missing argument to options that expect it.
+        # @note
+        #  1. It uses `default` if present
+        #  2. Otherwise it uses `nil`, but only if required (not when optional).
+        # @param groups [@see #pair_symbols_with_strings]
+        def insert_missing_argument_to_groups(groups, options)
+          groups.each do |group|
+            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.argument?
+            next group.push(opt.default) if opt.default?
+            next unless opt.argument_required?
+            group.push(nil)
+          end
+        end
+
+        # Retrieve the option based on `ref`
+        # @note It might be `--no-option-name`
+        # @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?
+          opt
+        end
+
+        # @return [Array<Array>] where the first element of each `Array` is a symbol
+        #   followed by one or more `String`.
+        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])
+              else # must be `String`
+                out << (curr_ary = []) unless curr_ary
+                curr_ary << arg
+              end
             end
           end
         end
-      end
 
-      # It splits `argv` compacted shorts into their `Symbol` version.
-      # Symbolizes option `names` (long version).
-      # @return [Array<String, Symbol>] where symbols are options and strings arguments.
-      def decluster_shorts_n_names_to_sym(argv)
-        argv.each_with_object([]) do |arg, out|
-          if single_hyphen?(arg) # short option(s)
-            options = arg.match(SINGLE_HYPHEN_REGEX)[:options]
-            options.split('').each do |short|
-              out << short_sym(short)
+        # It splits `argv` compacted shorts into their `Symbol` version.
+        # Symbolizes option `names` (long version).
+        # @return [Array<String, Symbol>] where symbols are options and strings arguments.
+        def decluster_shorts_n_names_to_sym(argv)
+          argv.each_with_object([]) do |arg, out|
+            if single_hyphen?(arg) # short option(s)
+              options = arg.match(SINGLE_HYPHEN_REGEX)[:options]
+              options.split('').each do |short|
+                out << short_sym(short)
+              end
+            elsif double_hyphen?(arg) # name option
+              name = arg.match(NAME_ARGUMENT)[:option]
+              out << name_sym(name)
+            else # argument
+              out << arg
             end
-          elsif double_hyphen?(arg) # name option
-            name = arg.match(DOUBLE_HYPHEN_REGEX)[:option]
-            out << name_sym(name)
-          else # argument
-            out << arg
           end
         end
       end

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

@@ -0,0 +1,17 @@
+class RakeCommander
+  module Options
+    module Description
+      DESC_MAX_LENGTH = 80
+
+      private
+
+      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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+class RakeCommander
+  module Options
+    module Error
+      # 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
+
+        class << self
+          # Helper to check if `error` is this class or any children class
+          # @raise ArgumentError if it does not meet this condition.
+          def require_argument!(error, arg_name, accept_children: true)
+            msg  = "Expecting #{arg_name} to be #{self}"
+            msg << "or child thereof." if accept_children
+            msg << ". Given: #{error.is_a?(Class)? error : error.class}"
+            raise ArgumentError, msg unless error <= self
+          end
+
+          # To (re)define the RegExp used to identify the option of an error message.
+          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)
+            option = match[:option]
+            return name_word_sym(option) if option.length > 1
+            short_sym(option)
+          end
+        end
+
+        attr_reader :from, :option
+
+        def initialize(value = nil, from: nil, option: nil)
+          @from   = from
+          @option = option
+          super(value)
+        end
+
+        # Options that are related to the error. There may not be any.
+        def options
+          [option].compact.flatten
+        end
+
+        def name?
+          option_sym.to_s.length > 1
+        end
+
+        def short?
+          option_sym.to_s.length == 1
+        end
+
+        def option_sym
+          @option_sym ||= self.class.option_sym(message)
+        end
+
+        def from_desc
+          return '' unless from
+          if from.respond_to?(:name)
+            "(#{from.name}) "
+          elsif from.respond_to?(:to_s)
+            "(#{from}) "
+          else
+            ''
+          end
+        end
+
+        protected
+
+        def to_message(value)
+          case value
+          when Array
+            to_message(value.map {|v| "'#{v}'"}.join(', '))
+          when String
+            "#{from_desc}#{super}"
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end