avm-tools 0.76.0 → 0.76.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 523777fd378f3ba655e65b12e452660f192e2875791439146808c472ee5cd982
-  data.tar.gz: 253dabfb78beaefa4b40dcfe6f669ae0e74761cb63a2e3418fda41ca8e107d2f
+  metadata.gz: cd41b3c790de4a2264c78b5daa5afbd469de6ba2e74b616f096619d0a7bc5460
+  data.tar.gz: 0a1890b253e90debb2951fe90193fef541df4c4d0701dcf82712696377b1adbe
 SHA512:
-  metadata.gz: 7208ff787a4d219d9a66b9e6e978dbf51cb142ea6af94b4347f9fc7f56c478962113b775896d52351fc35bea6fad3b796c9d5387af70c491a56542cd42872d25
-  data.tar.gz: 77004875dc073ea43aca01a5a3c4bbbf178fed773056bae70206745ce6d677ebfdf797871a0e5a8196eac1fd30774ab49e0e6b7503009abc22e0f278e5e6aaf0
+  metadata.gz: 2ebb73966071bb959e16f10f37b784971f65b3f2cfede241fe4b02c127f24d057bbaedec098e900b8b69edf55e5951637f905a07d5a242d0b7bfd7b51907a3be
+  data.tar.gz: 510d2e7625a10c523269684a6e269212a5d8b027d671dc38e337be9c1015d9c69d4ba8f78049ee13090a9e6c733fabfd6b5d40541b6ddbd1e86cd8b4e524ba7c

data/lib/avm/tools/runner/eac_redmine_base0/project_rename.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
+require 'eac_cli/core_ext'
 require 'avm/eac_rails_base1/runner/code_runner'
-require 'eac_cli/default_runner'
 
 module Avm
   module Tools
     class Runner < ::EacRubyUtils::Console::DocoptRunner
       class EacRedmineBase0 < ::Avm::EacRailsBase1::Runner
-        class ProjectRename < ::Avm::EacRailsBase1::Runner::CodeRunner
-          include ::EacCli::DefaultRunner
-
-          runner_definition do
+        class ProjectRename
+          runner_with ::Avm::EacRailsBase1::RunnerWith::Bundle do
             pos_arg :from
             pos_arg :to
           end
 
           def run
-            start_banner
-            command.system!
+            bundle_run
           end
 
           def start_banner
@@ -25,16 +22,10 @@ module Avm
             infov 'To', to
           end
 
-          def from
-            options.fetch('<from>')
-          end
-
-          def to
-            options.fetch('<to>')
-          end
+          delegate :from, :to, to: :parsed
 
-          def command
-            context(:instance).bundle('exec', 'rails', 'runner', code)
+          def bundle_args
+            %w[exec rails runner] + [code]
           end
 
           def code

data/lib/avm/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Avm
   module Tools
-    VERSION = '0.76.0'
+    VERSION = '0.76.1'
   end
 end

data/vendor/eac_cli/eac_cli.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |s|
 
   s.files = Dir['{lib}/**/*', 'Gemfile']
 
-  s.add_dependency 'eac_ruby_utils', '~> 0.45'
+  s.add_dependency 'eac_ruby_utils', '~> 0.50'
 
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.1', '>= 0.1.2'
 end

data/vendor/eac_cli/lib/eac_cli/definition.rb

@@ -8,6 +8,10 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   class Definition
     require_sub __FILE__
+
+    SUBCOMMAND_NAME_ARG = 'subcommand'
+    SUBCOMMAND_ARGS_ARG = 'subcommand_args'
+
     attr_accessor :description
     attr_accessor :options_argument
 
@@ -41,6 +45,10 @@ module EacCli
       self.description = description
     end
 
+    def help_formatter
+      @help_formatter ||= ::EacCli::Definition::HelpFormatter.new(self)
+    end
+
     def options_arg(options_argument)
       self.options_argument = options_argument
     end
@@ -50,15 +58,33 @@ module EacCli
     end
 
     def pos_arg(name, arg_options = {})
-      positional << ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+      new_pos_arg = ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+      raise 'Positional arguments are blocked' if positional_arguments_blocked?(new_pos_arg)
+
+      pos_set << new_pos_arg
     end
 
     def positional
-      @positional ||= []
+      pos_set.to_a
+    end
+
+    def positional_arguments_blocked?(new_pos_arg)
+      last = pos_set.last
+      return false unless last
+      return true if last.repeat?
+      return true if last.optional? && new_pos_arg.required?
+
+      false
     end
 
     def subcommands
-      positional << ::EacCli::Definition::PositionalArgument.new('subcommand', subcommand: true)
+      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
 
     def options_first(enable = true)
@@ -68,5 +94,11 @@ module EacCli
     def options_first?
       @options_first ? true : false
     end
+
+    private
+
+    def pos_set
+      @pos_set ||= []
+    end
   end
 end

data/vendor/eac_cli/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/vendor/eac_cli/lib/eac_cli/definition/help_formatter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Definition
+    class HelpFormatter
+      SEP = ' '
+      IDENT = SEP * 2
+      OPTION_DESC_SEP = IDENT * 2
+
+      class << self
+        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
+      end
+
+      common_constructor :definition
+
+      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
+        end
+      end
+
+      def section(header, include_header = true)
+        b = include_header ? "#{header.humanize}:\n" : ''
+        b += send("self_#{header}") + "\n"
+        # TO-DO: implement alternatives
+        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 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/vendor/eac_cli/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/vendor/eac_cli/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/vendor/eac_cli/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/vendor/eac_cli/lib/eac_cli/parser/options_collection.rb

@@ -6,28 +6,46 @@ require 'optparse'
 module EacCli
   class Parser
     class OptionsCollection
-      SEP = ' '
-      IDENT = SEP * 2
-      OPTION_DESC_SEP = IDENT * 2
-
       enable_simple_cache
       common_constructor(:definition, :argv, :collector) { collect }
       attr_reader :arguments
 
+      def options_first?
+        definition.options_first? || definition.subcommands?
+      end
+
       private
 
+      def check_required_options
+        definition.options.each do |option|
+          next unless option.required?
+          next if collector.supplied?(option)
+
+          raise ::EacCli::Parser::Error.new(
+            definition, argv, "Option \"#{option}\" is required and a value was not supplied"
+          )
+        end
+      end
+
       def collect
         build_banner
         build_options
-        @arguments = option_parser.parse(argv)
+        parse_argv
+        check_required_options
       end
 
       def option_parser_uncached
         ::OptionParser.new
       end
 
+      def parse_argv
+        @arguments = options_first? ? option_parser.order(argv) : option_parser.parse(argv)
+      rescue ::OptionParser::InvalidOption => e
+        raise ::EacCli::Parser::Error.new(definition, argv, e.message)
+      end
+
       def build_banner
-        option_parser.banner = "#{definition.description}\n\n#{section('usage')}"
+        option_parser.banner = definition.help_formatter.to_banner
       end
 
       def build_options
@@ -38,68 +56,13 @@ module EacCli
 
       def build_option(option)
         option_parser.on(
-          *[option_short(option), option_long(option), option.description].reject(&:blank?)
+          *[::EacCli::Definition::HelpFormatter.option_short(option),
+            ::EacCli::Definition::HelpFormatter.option_long(option),
+            option.description].reject(&:blank?)
         ) do |value|
           collector.collect(option, value)
         end
       end
-
-      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
-        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"
-        # TO-DO: implement alternatives
-        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) }
-      end
-
-      def self_usage_arguments_positional
-        definition.positional.map { |p| positional_argument(p) }
-      end
     end
   end
 end

data/vendor/eac_cli/lib/eac_cli/parser/parse_result.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'eac_cli/parser/error'
 require 'eac_ruby_utils/core_ext'
 
 module EacCli
@@ -8,6 +9,20 @@ module EacCli
       common_constructor :definition, :argv
 
       def result
+        result_or_error = parse(definition)
+        return result_or_error unless result_or_error.is_a?(::Exception)
+
+        definition.alternatives.each do |alternative|
+          alt_result_or_error = parse(alternative)
+          return alt_result_or_error unless alt_result_or_error.is_a?(::Exception)
+        end
+
+        raise result_or_error
+      end
+
+      private
+
+      def parse(definition)
         ::EacCli::Parser::Collector.to_data(definition) do |collector|
           ::EacCli::Parser::PositionalCollection.new(
             definition,
@@ -15,6 +30,8 @@ module EacCli
             collector
           )
         end
+      rescue ::EacCli::Parser::Error => e
+        e
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/parser/positional_collection.rb

@@ -10,39 +10,67 @@ module EacCli
 
       private
 
+      def argv_enum
+        @argv_enum ||= argv.each
+      end
+
+      def argv_pending?
+        argv_enum.ongoing?
+      end
+
+      def argv_pending_check
+        return unless argv_pending?
+        return unless positional_enum.stopped?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, "No positional left for argv \"#{argv_enum.current}\""
+        )
+      end
+
       def collected
         @collected ||= ::Set.new
       end
 
       def collect
-        argv.each { |argv_value| colect_argv_value(argv_value) }
-        return unless pending_required_positional?
+        loop do
+          break unless enums('pending?').any?
 
-        raise ::EacCli::Parser::Error.new(
-          definition, argv, 'No value for required positional ' \
-            "\"#{current_positional.identifier}\""
-        )
+          enums('pending_check')
+          collect_argv_value
+        end
+      end
+
+      def collect_argv_value
+        collector.collect(*enums('enum', &:peek))
+        collected << positional_enum.peek
+        positional_enum.next unless positional_enum.peek.repeat?
+        argv_enum.next
       end
 
-      def colect_argv_value(argv_value)
-        collector.collect(current_positional, argv_value)
-        collected << current_positional
-        positional_enumerator.next unless current_positional.repeat?
+      def enums(method_suffix, &block)
+        %w[positional argv].map do |method_prefix|
+          v = send("#{method_prefix}_#{method_suffix}")
+          block ? block.call(v) : v
+        end
       end
 
-      def pending_required_positional?
-        !(current_positional.blank? || current_positional.optional? ||
-            collected.include?(current_positional))
+      def positional_enum
+        @positional_enum ||= definition.positional.each
       end
 
-      def positional_enumerator
-        @positional_enumerator ||= definition.positional.each
+      def positional_pending?
+        !(positional_enum.stopped? || positional_enum.current.optional? ||
+            collected.include?(positional_enum.current))
       end
 
-      def current_positional
-        positional_enumerator.peek
-      rescue ::StopIteration
-        nil
+      def positional_pending_check
+        return unless positional_pending?
+        return unless argv_enum.stopped?
+
+        raise ::EacCli::Parser::Error.new(
+          definition, argv, 'No value for required positional ' \
+            "\"#{positional_enum.current.identifier}\""
+        )
       end
     end
   end

data/vendor/eac_cli/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/vendor/eac_cli/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)

data/vendor/eac_cli/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/vendor/eac_cli/lib/eac_cli/version.rb

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

data/vendor/eac_cli/spec/lib/eac_cli/docopt/runner_extension_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_cli/docopt/runner_extension'
+
+RSpec.describe ::EacCli::Docopt::RunnerExtension do
+  let(:stub_runner) do
+    r = Class.new(::EacRubyUtils::Console::DocoptRunner) do
+      def run; end
+    end
+    r.include ::EacCli::Runner
+    r.runner_definition do
+      desc 'A stub runner.'
+      arg_opt '-o', '--opt1', 'A argument option'
+      pos_arg 'pos1'
+    end
+    r
+  end
+
+  let(:instance) { stub_runner.new(argv: %w[-o aaa bbb]) }
+
+  before { instance.run }
+
+  it { expect(instance.options.fetch('--opt1')).to eq('aaa') }
+  it { expect(instance.options.fetch('<pos1>')).to eq('bbb') }
+end

data/vendor/eac_cli/spec/lib/eac_cli/runner_spec.rb

@@ -4,67 +4,75 @@ require 'eac_ruby_utils/console/docopt_runner'
 require 'eac_cli/runner'
 
 RSpec.describe ::EacCli::Runner do
-  let(:stub_runner) do
-    r = Class.new(::EacRubyUtils::Console::DocoptRunner) do
+  let(:runner_class) do
+    the_module = described_class
+    ::Class.new do
+      include the_module
+
+      runner_definition do
+        arg_opt '-o', '--opt1', 'A arg option.'
+        bool_opt '-o', '--opt2', 'A boolean option'
+        pos_arg :pos1
+        pos_arg :pos2, repeat: true, optional: true
+        alt do
+          bool_opt '-a', '--opt3', 'A boolean option in a alternative.', required: true
+        end
+      end
+
       def run; end
     end
-    r.include described_class
-    r.runner_definition do
-      desc 'A stub runner.'
-      arg_opt '-o', '--opt1', 'A argument option'
-      pos_arg 'pos1'
-    end
-    r
   end
 
-  let(:instance) { stub_runner.new(argv: %w[-o aaa bbb]) }
+  context 'when all args are supplied' do
+    let(:instance) { runner_class.create(%w[--opt1 aaa --opt2 bbb ccc ddd]) }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+    it { expect(instance.parsed.opt2?).to eq(true) }
+    it { expect(instance.parsed.pos1).to eq('bbb') }
+    it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
+  end
+
+  context 'when only required args are supplied' do
+    let(:instance) { runner_class.create(%w[bbb]) }
+
+    it { expect(instance.parsed.opt1).to be_nil }
+    it { expect(instance.parsed.opt2?).to eq(false) }
+    it { expect(instance.parsed.pos1).to eq('bbb') }
+    it { expect(instance.parsed.pos2).to eq([]) }
+  end
+
+  context 'when required args are not supplied' do
+    let(:instance) { runner_class.create(%w[]) }
 
-  before { instance.run }
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+
+  context 'when alternative args are supplied' do
+    let(:instance) { runner_class.create(%w[--opt3]) }
 
-  it { expect(instance.options.fetch('--opt1')).to eq('aaa') }
-  it { expect(instance.options.fetch('<pos1>')).to eq('bbb') }
+    it { expect(instance.parsed.opt3?).to eq(true) }
+  end
 
-  context 'without docopt runner' do
+  context 'when extra args are not supplied' do
     let(:runner_class) do
       the_module = described_class
       ::Class.new do
         include the_module
 
         runner_definition do
-          arg_opt '-o', '--opt1', 'A arg option.'
-          bool_opt '-o', '--opt2', 'A boolean option'
           pos_arg :pos1
-          pos_arg :pos2, repeat: true, optional: true
         end
 
         def run; end
       end
     end
 
-    context 'when all args are supplied' do
-      let(:instance) { runner_class.create(%w[--opt1 aaa --opt2 bbb ccc ddd]) }
-
-      it { expect(instance.parsed.opt1).to eq('aaa') }
-      it { expect(instance.parsed.opt2?).to eq(true) }
-      it { expect(instance.parsed.pos1).to eq('bbb') }
-      it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
-    end
+    let(:instance) { runner_class.create(%w[aaa bbb]) }
 
-    context 'when only required args are supplied' do
-      let(:instance) { runner_class.create(%w[bbb]) }
-
-      it { expect(instance.parsed.opt1).to be_nil }
-      it { expect(instance.parsed.opt2?).to eq(false) }
-      it { expect(instance.parsed.pos1).to eq('bbb') }
-      it { expect(instance.parsed.pos2).to eq([]) }
-    end
-
-    context 'when required args are not supplied' do
-      let(:instance) { runner_class.create(%w[]) }
-
-      it do
-        expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
-      end
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
     end
   end
 end

data/vendor/eac_cli/spec/lib/eac_cli/runner_with/subcommands_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_cli/runner_with/subcommands'
+
+RSpec.describe ::EacCli::RunnerWith::Subcommands do
+  let(:parent_runner) do
+    the_module = described_class
+    the_child = child_runner
+    Class.new do
+      include ::EacCli::Runner
+      include the_module
+      const_set('ChildCmd', the_child)
+
+      runner_definition do
+        desc 'A stub root runner.'
+        arg_opt '-r', '--root-var', 'A root variable.'
+        subcommands
+      end
+
+      delegate :root_var, to: :parsed
+    end
+  end
+
+  let(:child_runner) do
+    ::Class.new do
+      include ::EacCli::Runner
+
+      runner_definition do
+        bool_opt '-c', '--child-opt', 'A boolean option.'
+        pos_arg :child_var
+      end
+
+      def run; end
+    end
+  end
+
+  let(:instance) { parent_runner.create(argv: parent_argv) }
+
+  context 'when subcommand is supplied' do
+    let(:parent_argv) { %w[--root-var 123 child-cmd --child-opt 456] }
+
+    it { expect(instance.parsed.root_var).to eq('123') }
+    it { expect(instance.parsed.subcommand).to eq('child-cmd') }
+    it { expect(instance.parsed.subcommand_args).to eq(%w[--child-opt 456]) }
+    it { expect(instance.subcommand_runner.parsed.child_opt).to eq(true) }
+    it { expect(instance.subcommand_runner.parsed.child_var).to eq('456') }
+  end
+
+  context 'when subcommand is not supplied' do
+    let(:instance) { parent_runner.create(%w[456]) }
+
+    it do
+      expect { instance.run }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub __FILE__

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator/current.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Enumerator
+  def current(default_value = nil)
+    peek
+  rescue ::StopIteration
+    default_value
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator/stopped.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Enumerator
+  def ongoing?
+    !stopped?
+  end
+
+  def stopped?
+    peek
+    false
+  rescue ::StopIteration
+    true
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/debug.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Object
+  def print_debug
+    STDERR.write(to_debug + "\n")
+
+    self
+  end
+
+  def to_debug
+    "|#{self.class}|#{self}|"
+  end
+
+  def raise_debug
+    raise to_debug
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  VERSION = '0.49.1'
+  VERSION = '0.51.0'
 end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/current_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerator/current'
+
+RSpec.describe ::Enumerator do
+  let(:list) { %w[a b] }
+  let(:instance) { list.each }
+
+  it { expect(instance).to be_a(described_class) }
+  it { expect(instance.current).to eq('a') }
+
+  context 'with first next' do
+    before { instance.next }
+
+    it { expect(instance.current).to eq('b') }
+  end
+
+  context 'with last next' do
+    before do
+      instance.next
+      instance.next
+    end
+
+    it { expect(instance.current).to eq(nil) }
+  end
+end

data/vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/stopped_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/enumerator/stopped'
+
+RSpec.describe ::Enumerator do
+  let(:list) { %w[a b] }
+  let(:instance) { list.each }
+
+  it { expect(instance).to be_a(described_class) }
+  it { expect(instance.peek).to eq('a') }
+  it { expect(instance).to be_ongoing }
+  it { expect(instance).not_to be_stopped }
+
+  context 'with first next' do
+    before { instance.next }
+
+    it { expect(instance.peek).to eq('b') }
+    it { expect(instance).to be_ongoing }
+    it { expect(instance).not_to be_stopped }
+  end
+
+  context 'with last next' do
+    before do
+      instance.next
+      instance.next
+    end
+
+    it { expect { instance.peek }.to raise_error(::StopIteration) }
+    it { expect(instance).not_to be_ongoing }
+    it { expect(instance).to be_stopped }
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: avm-tools
 version: !ruby/object:Gem::Version
-  version: 0.76.0
+  version: 0.76.1
 platform: ruby
 authors:
 - Esquilo Azul Company
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2020-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aranha-parsers
@@ -601,6 +601,7 @@ files:
 - vendor/eac_cli/lib/eac_cli/definition/argument_option.rb
 - vendor/eac_cli/lib/eac_cli/definition/base_option.rb
 - vendor/eac_cli/lib/eac_cli/definition/boolean_option.rb
+- vendor/eac_cli/lib/eac_cli/definition/help_formatter.rb
 - vendor/eac_cli/lib/eac_cli/definition/positional_argument.rb
 - vendor/eac_cli/lib/eac_cli/docopt/doc_builder.rb
 - vendor/eac_cli/lib/eac_cli/docopt/runner_extension.rb
@@ -618,8 +619,11 @@ files:
 - vendor/eac_cli/lib/eac_cli/runner_with.rb
 - vendor/eac_cli/lib/eac_cli/runner_with/help.rb
 - vendor/eac_cli/lib/eac_cli/runner_with/output_file.rb
+- vendor/eac_cli/lib/eac_cli/runner_with/subcommands.rb
 - vendor/eac_cli/lib/eac_cli/version.rb
+- vendor/eac_cli/spec/lib/eac_cli/docopt/runner_extension_spec.rb
 - vendor/eac_cli/spec/lib/eac_cli/runner_spec.rb
+- vendor/eac_cli/spec/lib/eac_cli/runner_with/subcommands_spec.rb
 - vendor/eac_cli/spec/rubocop_spec.rb
 - vendor/eac_cli/spec/spec_helper.rb
 - vendor/eac_docker/Gemfile
@@ -959,6 +963,9 @@ files:
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/class/common_constructor.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerable.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerable/boolean_combinations.rb
+- vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator.rb
+- vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator/current.rb
+- vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator/stopped.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/hash.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/options_consumer.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/sym_keys_hash.rb
@@ -972,6 +979,7 @@ files:
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/module/simple_cache.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/asserts.rb
+- vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/debug.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/if_present.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/if_respond.rb
 - vendor/eac_ruby_utils/lib/eac_ruby_utils/patches/object/template.rb
@@ -1030,6 +1038,8 @@ files:
 - vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/listable_spec.rb
 - vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/options_consumer_spec.rb
 - vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerable/boolean_combinations_spec.rb
+- vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/current_spec.rb
+- vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/enumerator/stopped_spec.rb
 - vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/options_consumer_spec.rb
 - vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/hash/sym_keys_hash_spec.rb
 - vendor/eac_ruby_utils/spec/lib/eac_ruby_utils/patches/module/console_speaker_spec.rb