eac_cli 0.8.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b936a1bc75006a7969bd549ed89750bf7b09ccebf5d77e35a7b2443ad7175b5
-  data.tar.gz: 812fb927a263d8d6aa74600631db16eb07e626217ec1e81614bdf5f1031d7ef7
+  metadata.gz: 22f7790dfca37c3414a3552155806d47808bdee4b6eb6630a07b2eb8b928db59
+  data.tar.gz: 8b6826e7f1f7d4980516ad8d53d2b681890b326f513df49f6394c3f2115f3b64
 SHA512:
-  metadata.gz: 4b2331aa69dd79cf797ab64305f3b088ee012cfe53e71ef0d0f00ec1f84ed2f5bc849e70a9745e17e43d591fc7e02ae9b061870b4d2b27cb93c51385c12780f8
-  data.tar.gz: a62b07e41f454aa85015be5b39a3e427ab41b2afffdacfbf998ce1a261a49bf82c0711e95f7bb42b449fb3b41178dee666124a76eeaeee993c9fe6fdc7a6baf5
+  metadata.gz: 61d6bf83f3e147b7fd9761f6369347c91c208599eacf7ca0a5762e671e86a7eea30758b6101c639a4775acb376988e0ecd3d8dd31d1950fcebeaabc1b8275360
+  data.tar.gz: 66777c73453633a5af6fe8048818d7e07428dd958676b2d9a1cdc800c286910a73140e3a0526cb0ef5e87102a227be0873fcd14146405c33b73e644351e0070f

data/lib/eac_cli/definition.rb

@@ -8,57 +8,66 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     require_sub __FILE__
+
+    MAIN_ALTERNATIVE_KEY = :main
+    SUBCOMMAND_NAME_ARG = 'subcommand'
+    SUBCOMMAND_ARGS_ARG = 'subcommand_args'
+
     attr_accessor :description
-    attr_accessor :options_argument
 
     def initialize
       self.description = '-- NO DESCRIPTION SET --'
-      self.options_argument = true
+      alternatives_set[MAIN_ALTERNATIVE_KEY] = main_alternative
     end
 
     def alt(&block)
-      r = ::EacCli::Definition.new
+      r = ::EacCli::Definition::Alternative.new
       r.instance_eval(&block)
-      alternatives << r
+      alternatives_set[new_alternative_key] = r
       r
     end
 
     def alternatives
-      @alternatives ||= []
-    end
-
-    def arg_opt(short, long, description, option_options = {})
-      options << ::EacCli::Definition::ArgumentOption.new(
-        short, long, description, option_options
-      )
+      alternatives_set.values
     end
 
-    def bool_opt(short, long, description, option_options = {})
-      options << ::EacCli::Definition::BooleanOption.new(short, long, description, option_options)
+    def alternative(key)
+      alternatives_set.fetch(key)
     end
 
     def desc(description)
       self.description = description
     end
 
+    def help_formatter
+      @help_formatter ||= ::EacCli::Definition::HelpFormatter.new(self)
+    end
+
+    def main_alternative
+      @main_alternative ||= begin
+        r = ::EacCli::Definition::Alternative.new
+        r.options_argument(true)
+        r
+      end
+    end
+
     def options_arg(options_argument)
       self.options_argument = options_argument
     end
 
-    def options
-      @options ||= []
+    def options_argument
+      main_alternative.options_argument?
     end
 
-    def pos_arg(name, arg_options = {})
-      positional << ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+    def options_argument=(enable)
+      main_alternative.options_argument(enable)
     end
 
-    def positional
-      @positional ||= []
-    end
+    delegate :arg_opt, :bool_opt, :options, :pos_arg,
+             :positional, :subcommands, to: :main_alternative
 
-    def subcommands
-      positional << ::EacCli::Definition::PositionalArgument.new('subcommand', subcommand: true)
+    def subcommands?
+      alternatives.any?(&:subcommands?)
     end
 
     def options_first(enable = true)
@@ -68,5 +77,23 @@ module EacCli
     def options_first?
       @options_first ? true : false
     end
+
+    private
+
+    def alternatives_set
+      @alternatives_set ||= ::ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def new_alternative_key
+      @last_key ||= 0
+      loop do
+        @last_key += 1
+        break @last_key unless alternatives_set.key?(@last_key)
+      end
+    end
+
+    def pos_set
+      @pos_set ||= []
+    end
   end
 end

data/lib/eac_cli/definition/alternative.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/argument_option'
+require 'eac_cli/definition/boolean_option'
+require 'eac_cli/definition/positional_argument'
+
+module EacCli
+  class Definition
+    class Alternative
+      SUBCOMMAND_NAME_ARG = :subcommand
+      SUBCOMMAND_ARGS_ARG = :subcommand_args
+
+      def arg_opt(short, long, description, option_options = {})
+        options_set << ::EacCli::Definition::ArgumentOption.new(
+          short, long, description, option_options
+        )
+      end
+
+      def bool_opt(short, long, description, option_options = {})
+        options_set << ::EacCli::Definition::BooleanOption.new(short, long, description,
+                                                               option_options)
+      end
+
+      def options
+        options_set.to_a
+      end
+
+      def options_argument?
+        @options_argument ? true : false
+      end
+
+      def options_argument(enable)
+        @options_argument = enable
+
+        self
+      end
+
+      def pos_arg(name, arg_options = {})
+        new_pos_arg = ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+        check_positional_blocked(new_pos_arg)
+        pos_set << new_pos_arg
+      end
+
+      def positional
+        pos_set.to_a
+      end
+
+      def positional_arguments_blocked?(new_pos_arg)
+        last = pos_set.last
+        return false unless last
+        return true if subcommands?
+        return true if last.repeat?
+        return true if last.optional? && new_pos_arg.if_present(&:required?)
+
+        false
+      end
+
+      def subcommands
+        pos_arg(SUBCOMMAND_NAME_ARG, subcommand: true)
+        pos_set << ::EacCli::Definition::PositionalArgument.new(SUBCOMMAND_ARGS_ARG,
+                                                                optional: true, repeat: true)
+      end
+
+      def subcommands?
+        pos_set.any?(&:subcommand?)
+      end
+
+      private
+
+      def check_positional_blocked(new_pos_arg)
+        raise 'Positional arguments are blocked' if positional_arguments_blocked?(new_pos_arg)
+      end
+
+      def pos_set
+        @pos_set ||= []
+      end
+
+      def options_set
+        @options_set ||= []
+      end
+    end
+  end
+end

data/lib/eac_cli/definition/base_option.rb

@@ -5,19 +5,35 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     class BaseOption
+      DEFAULT_REQUIRED = false
+
+      enable_listable
+      lists.add_symbol :option, :optional, :usage, :required
       attr_reader :short, :long, :description, :options
 
       def initialize(short, long, description, options = {})
         @short = short
         @long = long
         @description = description
-        @options = options.with_indifferent_access
+        @options = options.symbolize_keys
+        @options.assert_valid_keys(::EacCli::Definition::BaseOption.lists.option.values)
       end
 
       def identifier
         long.to_s.variableize.to_sym
       end
 
+      def required?
+        return true if options.key?(:required) && options.fetch(:required)
+        return false if options.key?(:optional) && options.fetch(:optional)
+
+        DEFAULT_REQUIRED
+      end
+
+      def to_s
+        "#{self.class.name.demodulize}[#{identifier}]"
+      end
+
       def show_on_usage?
         options[:usage]
       end

data/lib/eac_cli/{parser/options_collection.rb → definition/help_formatter.rb}

@@ -1,49 +1,30 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
-require 'optparse'
 
 module EacCli
-  class Parser
-    class OptionsCollection
+  class Definition
+    class HelpFormatter
       SEP = ' '
       IDENT = SEP * 2
       OPTION_DESC_SEP = IDENT * 2
 
-      enable_simple_cache
-      common_constructor(:definition, :argv, :collector) { collect }
-      attr_reader :arguments
-
-      private
-
-      def collect
-        build_banner
-        build_options
-        @arguments = option_parser.parse(argv)
-      end
-
-      def option_parser_uncached
-        ::OptionParser.new
-      end
-
-      def build_banner
-        option_parser.banner = "#{definition.description}\n\n#{section('usage')}"
-      end
-
-      def build_options
-        definition.options.each do |option|
-          build_option(option)
+      class << self
+        def option_long(option)
+          b = option.long
+          b += '=VALUE' if option.argument?
+          b
         end
-      end
 
-      def build_option(option)
-        option_parser.on(
-          *[option_short(option), option_long(option), option.description].reject(&:blank?)
-        ) do |value|
-          collector.collect(option, value)
+        def option_short(option)
+          b = option.short
+          b += 'VALUE' if option.argument?
+          b
         end
       end
 
+      common_constructor :definition
+
       def positional_argument(positional)
         if positional.subcommand?
           ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
@@ -55,22 +36,6 @@ module EacCli
         end
       end
 
-      def option_argument(option)
-        option_long(option)
-      end
-
-      def option_long(option)
-        b = option.long
-        b += '=VALUE' if option.argument?
-        b
-      end
-
-      def option_short(option)
-        b = option.short
-        b += 'VALUE' if option.argument?
-        b
-      end
-
       def section(header, include_header = true)
         b = include_header ? "#{header.humanize}:\n" : ''
         b += send("self_#{header}") + "\n"
@@ -94,12 +59,18 @@ module EacCli
       end
 
       def self_usage_arguments_options
-        definition.options.select(&:show_on_usage?).map { |option| option_argument(option) }
+        definition.options.select(&:show_on_usage?).map do |option|
+          self.class.option_long(option)
+        end
       end
 
       def self_usage_arguments_positional
         definition.positional.map { |p| positional_argument(p) }
       end
+
+      def to_banner
+        "#{definition.description}\n\n#{section('usage')}"
+      end
     end
   end
 end

data/lib/eac_cli/definition/positional_argument.rb

@@ -5,22 +5,39 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     class PositionalArgument
-      common_constructor :name, :options, default: [{}]
+      DEFAULT_REQUIRED = true
+
+      enable_listable
+      lists.add_symbol :option, :optional, :repeat, :required, :subcommand
+      common_constructor :name, :options, default: [{}] do
+        options.assert_valid_keys(self.class.lists.option.values)
+      end
 
       def identifier
         name.to_s.variableize.to_sym
       end
 
       def optional?
-        options[:optional]
+        !required?
       end
 
       def repeat?
-        options[:repeat]
+        options[OPTION_REPEAT]
+      end
+
+      def required?
+        return true if options.key?(OPTION_REQUIRED) && options.fetch(OPTION_REQUIRED)
+        return false if options.key?(OPTION_OPTIONAL) && options.fetch(OPTION_OPTIONAL)
+
+        DEFAULT_REQUIRED
       end
 
       def subcommand?
-        options[:subcommand]
+        options[OPTION_SUBCOMMAND]
+      end
+
+      def to_s
+        "#{self.class.name.demodulize}[#{identifier}]"
       end
     end
   end

data/lib/eac_cli/docopt/doc_builder.rb

@@ -6,71 +6,49 @@ require 'eac_ruby_utils/console/docopt_runner'
 module EacCli
   module Docopt
     class DocBuilder
+      require_sub __FILE__
       common_constructor :definition
 
       SEP = ' '
       IDENT = SEP * 2
       OPTION_DESC_SEP = IDENT * 2
 
-      def positional_argument(positional)
-        if positional.subcommand?
-          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
-        else
-          r = "<#{positional.name}>"
-          r += '...' if positional.repeat?
-          r = "[#{r}]" if positional.optional?
-          r
+      class << self
+        def option_long(option)
+          b = option.long
+          b += '=<value>' if option.argument?
+          b
         end
       end
 
-      def option_argument(option)
-        option_long(option)
-      end
-
       def option_definition(option)
-        option.short + SEP + option_long(option) + OPTION_DESC_SEP + option.description
-      end
-
-      def option_long(option)
-        b = option.long
-        b += '=<value>' if option.argument?
-        b
+        option.short + SEP + self.class.option_long(option) + OPTION_DESC_SEP + option.description
       end
 
       def section(header, include_header = true)
         b = include_header ? "#{header.humanize}:\n" : ''
         b += send("self_#{header}") + "\n"
         definition.alternatives.each do |alternative|
-          b += self.class.new(alternative).section(header, false)
+          b += IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
         end
         b
       end
 
-      def self_options
-        definition.options.map { |option| IDENT + option_definition(option) }.join("\n")
-      end
-
-      def self_usage
-        IDENT + self_usage_arguments.join(SEP)
-      end
-
-      def self_usage_arguments
-        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
-          definition.options_argument.if_present([]) { |_v| ['[options]'] } +
-          self_usage_arguments_options +
-          self_usage_arguments_positional
-      end
-
-      def self_usage_arguments_options
-        definition.options.select(&:show_on_usage?).map { |option| option_argument(option) }
+      def options_section
+        "Options:\n" +
+          definition.alternatives.flat_map(&:options)
+                    .map { |option| IDENT + option_definition(option) + "\n" }.join
       end
 
-      def self_usage_arguments_positional
-        definition.positional.map { |p| positional_argument(p) }
+      def usage_section
+        "Usage:\n" +
+          definition.alternatives.map do |alternative|
+            IDENT + ::EacCli::Docopt::DocBuilder::Alternative.new(alternative).to_s + "\n"
+          end.join
       end
 
       def to_s
-        "#{definition.description}\n\n#{section('usage')}\n#{section('options')}\n"
+        "#{definition.description}\n\n#{usage_section}\n#{options_section}\n"
       end
     end
   end

data/lib/eac_cli/docopt/doc_builder/alternative.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/console/docopt_runner'
+
+module EacCli
+  module Docopt
+    class DocBuilder
+      class Alternative
+        common_constructor :alternative
+
+        def to_s
+          (
+            [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+              alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
+              options +
+              positionals
+          ).join(::EacCli::Docopt::DocBuilder::SEP)
+        end
+
+        def options
+          alternative.options.select(&:show_on_usage?).map do |option|
+            ::EacCli::Docopt::DocBuilder.option_long(option)
+          end
+        end
+
+        def option_argument(option)
+          b = option.long
+          b += '=<value>' if option.argument?
+          b
+        end
+
+        def positionals
+          alternative.positional.map { |p| positional(p) }
+        end
+
+        def positional(positional)
+          if positional.subcommand?
+            ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+          else
+            r = "<#{positional.name}>"
+            r += '...' if positional.repeat?
+            r = "[#{r}]" if positional.optional?
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/docopt/runner_extension.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_cli/docopt/doc_builder'
+require 'eac_cli/runner'
 require 'eac_ruby_utils/console/docopt_runner'
 
 module EacCli

data/lib/eac_cli/parser.rb

@@ -5,10 +5,28 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Parser
     require_sub __FILE__
-    common_constructor :definition
+    enable_simple_cache
+    common_constructor :definition, :argv
 
-    def parse(argv)
-      ::EacCli::Parser::ParseResult.new(definition, argv).result
+    private
+
+    def parsed_uncached
+      raise 'Definition has no alternatives' if alternatives.empty?
+
+      alternatives.each do |alt_parser|
+        return alt_parser.parsed unless alt_parser.error?
+      end
+
+      raise first_error
+    end
+
+    def alternatives_uncached
+      definition.alternatives
+                .map { |alternative| ::EacCli::Parser::Alternative.new(alternative, argv) }
+    end
+
+    def first_error_uncached
+      alternatives.lazy.select(&:error?).map(&:error).first
     end
   end
 end

data/lib/eac_cli/parser/alternative.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'eac_cli/parser/collector'
+require 'eac_cli/parser/error'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class Alternative
+      require_sub __FILE__, include_modules: true
+      enable_listable
+      lists.add_symbol :phase, :any, :option_argument, :positional
+      attr_reader :error
+
+      common_constructor :alternative, :argv do
+        alternative.assert_argument(::EacCli::Definition::Alternative, :alternative)
+        self.phase = PHASE_ANY
+        collect
+      end
+
+      def error?
+        error.present?
+      end
+
+      def parsed
+        @parsed ||= collector.to_data.freeze
+      end
+
+      private
+
+      attr_accessor :phase
+
+      def any_collect_argv_value
+        if argv_current_option?
+          option_collect_argv_value
+        else
+          positional_collect_argv_value
+        end
+      end
+
+      def collector
+        @collector ||= ::EacCli::Parser::Collector.new(alternative)
+      end
+
+      def collect
+        loop do
+          break unless argv_pending?
+
+          collect_argv_value
+        end
+        validate
+      rescue ::EacCli::Parser::Error => e
+        @error = e
+      end
+
+      def collect_argv_value
+        send("#{phase}_collect_argv_value")
+        argv_enum.next
+      end
+
+      def collect_option_argv_value
+        alternative.options.each do |option|
+        end
+
+        raise ::EacCli::Parser::Error.new(
+          alternative, argv, "Invalid option: #{argv_enum.current}"
+        )
+      end
+
+      def raise_error(message)
+        raise ::EacCli::Parser::Error.new(alternative, argv, message)
+      end
+
+      def validate
+        (alternative.options + alternative.positional).each do |option|
+          validate_option(option)
+        end
+      end
+
+      def validate_option(option)
+        return unless option.required?
+        return if collector.supplied?(option)
+
+        raise_error("Required option/positional #{option} not supplied")
+      end
+    end
+  end
+end

data/lib/eac_cli/parser/alternative/argv.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Argv
+        def argv_enum
+          @argv_enum ||= argv.each
+        end
+
+        def argv_pending?
+          argv_enum.ongoing?
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/parser/alternative/double_dash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module DoubleDash
+        DOUBLE_DASH = '--'
+
+        private
+
+        attr_accessor :double_dash
+
+        def argv_current_double_dash?
+          argv_enum.peek == DOUBLE_DASH && !double_dash
+        end
+
+        def double_dash_collect_argv_value
+          self.phase = PHASE_POSITIONAL
+          self.double_dash = true
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/parser/alternative/options.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Options
+        DOUBLE_DASH = '--'
+
+        private
+
+        attr_accessor :argument_option, :double_dash
+
+        def argument_option_collect_argv(option)
+          self.argument_option = option
+          self.phase = PHASE_OPTION_ARGUMENT
+        end
+
+        def argv_current_option?
+          phase == PHASE_ANY && argv_enum.peek.start_with?('-')
+        end
+
+        def argv_current_double_dash?
+          argv_enum.peek == DOUBLE_DASH && !double_dash
+        end
+
+        def boolean_option_collect_argv(option)
+          collector.collect(option, true)
+        end
+
+        def option_argument_collect_argv_value
+          collector.collect(argument_option, argv_enum.peek)
+          self.argument_option = nil
+          self.phase = PHASE_ANY
+        end
+
+        def option_collect_argv_value
+          return double_dash_collect_argv_value if argv_current_double_dash?
+
+          alternative.options.any? do |option|
+            next false unless [option.short, option.long].include?(argv_enum.peek)
+
+            if option.argument?
+              argument_option_collect_argv(option)
+            else
+              boolean_option_collect_argv(option)
+            end
+
+            true
+          end || raise_argv_current_invalid_option
+        end
+
+        def raise_argv_current_invalid_option
+          raise_error "Invalid option: \"#{argv_enum.peek}\""
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/parser/alternative/positionals.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Positionals
+        private
+
+        def positional_collect_argv_value
+          positional_check
+          collector.collect(positional_enum.peek, argv_enum.peek)
+          positional_next
+        end
+
+        def positional_enum
+          @positional_enum ||= alternative.positional.each
+        end
+
+        def positional_check
+          raise_error("Invalid positional: #{argv_enum.peek}") if positional_enum.stopped?
+        end
+
+        def positional_next
+          self.phase = PHASE_POSITIONAL if positional_enum.peek.subcommand?
+          positional_enum.next unless positional_enum.peek.repeat?
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/parser/collector.rb

@@ -31,6 +31,10 @@ module EacCli
         end
       end
 
+      def supplied?(option)
+        data[option].present?
+      end
+
       private
 
       def data

data/lib/eac_cli/patches/object/runner_with.rb

@@ -5,13 +5,14 @@ require 'eac_cli/runner'
 require 'eac_cli/runner_with'
 
 class Object
-  def runner_with(*runners)
+  def runner_with(*runners, &block)
     include ::EacCli::Runner
     enable_simple_cache
     enable_console_speaker
     runners.each do |runner|
       include runner_with_to_module(runner)
     end
+    runner_definition(&block) if block
   end
 
   private

data/lib/eac_cli/runner.rb

@@ -18,6 +18,10 @@ module EacCli
         end
       end
 
+      def runner?(object)
+        object.is_a?(::Class) && object.included_modules.include?(::EacCli::Runner)
+      end
+
       private
 
       def alias_class_method(klass, from, to)
@@ -45,7 +49,7 @@ module EacCli
     module AfterClassMethods
       def create(*runner_context_args)
         r = new
-        r.runner_context = ::EacCli::Runner::Context.new(*runner_context_args)
+        r.runner_context = ::EacCli::Runner::Context.new(r, *runner_context_args)
         r
       end
 
@@ -80,7 +84,7 @@ module EacCli
       end
 
       def parsed
-        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition).parse(runner_context.argv)
+        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition, runner_context.argv).parsed
       end
     end
   end

data/lib/eac_cli/runner/context.rb

@@ -5,13 +5,30 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   module Runner
     class Context
-      attr_reader :argv, :parent, :program_name
+      attr_reader :argv, :parent, :program_name, :runner
 
-      def initialize(*context_args)
+      def initialize(runner, *context_args)
         options = context_args.extract_options!
         @argv = (context_args[0] || options.delete(:argv) || ARGV).dup.freeze
         @parent = context_args[1] || options.delete(:parent)
         @program_name = options.delete(:program_name)
+        @runner = runner
+      end
+
+      # Call a method in the runner or in one of it ancestors.
+      def call(method_name, *args)
+        return runner.send(method_name, *args) if runner.respond_to?(method_name)
+        return parent_call(method_name, *args) if parent.present?
+
+        raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
+      end
+
+      protected
+
+      def parent_call(method_name, *args)
+        return parent.context(method_name, *args) if parent.respond_to?(:context)
+
+        parent.runner_context.call(method_name, *args)
       end
     end
   end

data/lib/eac_cli/runner_with/help.rb

@@ -10,7 +10,7 @@ module EacCli
         include ::EacCli::Runner
 
         runner_definition.alt do
-          options_arg false
+          options_argument false
           bool_opt '-h', '--help', 'Show help.', usage: true
         end
       end

data/lib/eac_cli/runner_with/subcommands.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module RunnerWith
+    module Subcommands
+      common_concern do
+        include ::EacCli::Runner
+      end
+
+      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
+
+      def available_subcommands
+        @available_subcommands ||= available_subcommands_auto.merge(available_subcommands_extra)
+      end
+
+      def available_subcommands_auto
+        self.class.constants
+            .map { |name| [name.to_s.underscore.gsub('_', '-'), self.class.const_get(name)] }
+            .select { |c| ::EacCli::Runner.runner?(c[1]) }
+            .to_h.with_indifferent_access
+      end
+
+      def available_subcommands_extra
+        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
+          send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
+        else
+          {}
+        end
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        return run_with_subcommand(*arguments, &block) if
+        run_with_subcommand_alias_run?(method_name)
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        run_with_subcommand_alias_run?(method_name) || super
+      end
+
+      def run_with_subcommand
+        if subcommand_name
+          subcommand_runner.run
+        else
+          run_without_subcommand
+        end
+      end
+
+      def run_with_subcommand_alias_run?(method_name)
+        subcommands? && method_name.to_sym == :run
+      end
+
+      def run_without_subcommand
+        "Method #{__method__} should be overrided in #{self.class.name}"
+      end
+
+      def subcommands?
+        self.class.runner_definition.subcommands?
+      end
+
+      def subcommand_args
+        parsed.fetch(::EacCli::Definition::SUBCOMMAND_ARGS_ARG)
+      end
+
+      def subcommand_class
+        available_subcommands[subcommand_name].if_present { |v| return v }
+
+        raise(::EacCli::Parser::Error.new(
+                self.class.runner_definition, runner_context.argv,
+                "Subcommand \"#{subcommand_name}\" not found " \
+                  "(Available: #{available_subcommands.keys}"
+              ))
+      end
+
+      def subcommand_name
+        parsed.fetch(::EacCli::Definition::SUBCOMMAND_NAME_ARG)
+      end
+
+      def subcommand_program
+        subcommand_name
+      end
+
+      def subcommand_runner
+        @subcommand_runner ||= subcommand_class.create(
+          argv: subcommand_args,
+          program_name: subcommand_program,
+          parent: self
+        )
+      end
+    end
+  end
+end

data/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.8.0'
+  VERSION = '0.12.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eac_cli
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Esquilo Azul Company
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-27 00:00:00.000000000 Z
+date: 2020-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: eac_ruby_utils
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.45'
+        version: '0.50'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.45'
+        version: '0.50'
 - !ruby/object:Gem::Dependency
   name: eac_ruby_gem_support
   requirement: !ruby/object:Gem::Requirement
@@ -55,18 +55,23 @@ files:
 - lib/eac_cli/core_ext.rb
 - lib/eac_cli/default_runner.rb
 - lib/eac_cli/definition.rb
+- lib/eac_cli/definition/alternative.rb
 - lib/eac_cli/definition/argument_option.rb
 - lib/eac_cli/definition/base_option.rb
 - lib/eac_cli/definition/boolean_option.rb
+- lib/eac_cli/definition/help_formatter.rb
 - lib/eac_cli/definition/positional_argument.rb
 - lib/eac_cli/docopt/doc_builder.rb
+- lib/eac_cli/docopt/doc_builder/alternative.rb
 - lib/eac_cli/docopt/runner_extension.rb
 - lib/eac_cli/parser.rb
+- lib/eac_cli/parser/alternative.rb
+- lib/eac_cli/parser/alternative/argv.rb
+- lib/eac_cli/parser/alternative/double_dash.rb
+- lib/eac_cli/parser/alternative/options.rb
+- lib/eac_cli/parser/alternative/positionals.rb
 - lib/eac_cli/parser/collector.rb
 - lib/eac_cli/parser/error.rb
-- lib/eac_cli/parser/options_collection.rb
-- lib/eac_cli/parser/parse_result.rb
-- lib/eac_cli/parser/positional_collection.rb
 - lib/eac_cli/patches.rb
 - lib/eac_cli/patches/object.rb
 - lib/eac_cli/patches/object/runner_with.rb
@@ -75,6 +80,7 @@ files:
 - lib/eac_cli/runner_with.rb
 - lib/eac_cli/runner_with/help.rb
 - lib/eac_cli/runner_with/output_file.rb
+- lib/eac_cli/runner_with/subcommands.rb
 - lib/eac_cli/version.rb
 homepage: 
 licenses: []

data/lib/eac_cli/parser/parse_result.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  class Parser
-    class ParseResult
-      common_constructor :definition, :argv
-
-      def result
-        ::EacCli::Parser::Collector.to_data(definition) do |collector|
-          ::EacCli::Parser::PositionalCollection.new(
-            definition,
-            ::EacCli::Parser::OptionsCollection.new(definition, argv, collector).arguments,
-            collector
-          )
-        end
-      end
-    end
-  end
-end

data/lib/eac_cli/parser/positional_collection.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_cli/parser/error'
-
-module EacCli
-  class Parser
-    class PositionalCollection
-      common_constructor(:definition, :argv, :collector) { collect }
-
-      private
-
-      def collected
-        @collected ||= ::Set.new
-      end
-
-      def collect
-        argv.each { |argv_value| colect_argv_value(argv_value) }
-        return unless pending_required_positional?
-
-        raise ::EacCli::Parser::Error.new(
-          definition, argv, 'No value for required positional ' \
-            "\"#{current_positional.identifier}\""
-        )
-      end
-
-      def colect_argv_value(argv_value)
-        collector.collect(current_positional, argv_value)
-        collected << current_positional
-        positional_enumerator.next unless current_positional.repeat?
-      end
-
-      def pending_required_positional?
-        !(current_positional.blank? || current_positional.optional? ||
-            collected.include?(current_positional))
-      end
-
-      def positional_enumerator
-        @positional_enumerator ||= definition.positional.each
-      end
-
-      def current_positional
-        positional_enumerator.peek
-      rescue ::StopIteration
-        nil
-      end
-    end
-  end
-end