ehbrs-tools 0.14.1 → 0.16.3

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/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,13 +18,17 @@ 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)
         sklass = klass.singleton_class
         return unless sklass.method_defined?(from)
 
-        sklass.alias_method to, from
+        sklass.send(:alias_method, to, from)
       end
 
       def build_method_name(name, suffix)
@@ -40,19 +44,20 @@ module EacCli
       extend AfterClassMethods
       include InstanceMethods
       ::EacCli::Docopt::RunnerExtension.check(self)
+      include ActiveSupport::Callbacks
+      define_callbacks :run
     end
 
     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
 
       def run(*runner_context_args)
         r = create(*runner_context_args)
-        r.parsed
-        r.run
+        r.run_run
         r
       end
 
@@ -68,6 +73,13 @@ module EacCli
     end
 
     module InstanceMethods
+      def run_run
+        parsed
+        run_callbacks(:run) { run }
+      rescue ::EacCli::Runner::Exit # rubocop:disable Lint/SuppressedException
+        # Do nothing
+      end
+
       def runner_context
         return @runner_context if @runner_context
 
@@ -80,7 +92,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/vendor/eac_cli/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/vendor/eac_cli/lib/eac_cli/runner/exit.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    class Exit < ::StandardError
+      attr_reader :status
+
+      def initialize(status = true)
+        @status = status
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/runner_with/help.rb

@@ -10,9 +10,24 @@ module EacCli
         include ::EacCli::Runner
 
         runner_definition.alt do
-          options_arg false
+          options_argument false
           bool_opt '-h', '--help', 'Show help.', usage: true
         end
+
+        set_callback :run, :before do
+          help_run
+        end
+      end
+
+      def help_run
+        return unless parsed.help?
+
+        puts help_text
+        raise ::EacCli::Runner::Exit
+      end
+
+      def help_text
+        ::EacCli::Docopt::DocBuilder.new(self.class.runner_definition).to_s
       end
     end
   end

data/vendor/eac_cli/lib/eac_cli/runner_with/output_file.rb

@@ -2,12 +2,16 @@
 
 require 'eac_cli/runner'
 require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/abstract_methods'
 
 module EacCli
   module RunnerWith
     module OutputFile
       common_concern do
         include ::EacCli::Runner
+        include ::EacRubyUtils::AbstractMethods
+
+        abstract_methods :output_content
 
         runner_definition do
           arg_opt '-o', '--output-file', 'Output to file.'
@@ -18,7 +22,7 @@ module EacCli
         if parsed.output_file.present?
           ::File.write(parsed.output_file, output_content)
         else
-          out output_content
+          $stdout.write(output_content)
         end
       end
     end

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_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.8.0'
+  VERSION = '0.12.3'
 end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/alternative'
+
+RSpec.describe ::EacCli::Definition::Alternative do
+  let(:instance) { described_class.new }
+
+  it { expect { instance.arg_opt '-a', '--opt2', 'A argument option' }.not_to raise_error }
+  it { expect { instance.bool_opt '-b', '--opt1', 'A boolean option' }.not_to raise_error }
+  it { expect { instance.options_argument(true) }.not_to raise_error }
+  it { expect { instance.pos_arg :pos1 }.not_to raise_error }
+  it { expect { instance.pos_arg :pos2, optional: true, repeat: true }.not_to raise_error }
+  it { expect { instance.subcommands }.not_to raise_error }
+end

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

@@ -0,0 +1,35 @@
+# 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') }
+  it { expect(instance.doc).to eq(<<~EXPECTED) }
+    A stub runner.
+
+    Usage:
+      __PROGRAM__ [options] <pos1>
+
+    Options:
+      -o --opt1=<value>    A argument option
+
+  EXPECTED
+end

data/vendor/eac_cli/spec/lib/eac_cli/parser/alternative_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'eac_cli/docopt/runner_extension'
+
+RSpec.describe ::EacCli::Parser::Alternative do
+  let(:instance) { described_class.new(alternative, argv) }
+  let(:actual_parsed) { instance.parsed.to_h.symbolize_keys }
+
+  context 'without subcommands' do
+    let(:alternative) do
+      r = ::EacCli::Definition::Alternative.new
+      r.bool_opt '-b', '--opt1', 'A boolean option'
+      r.arg_opt '-a', '--opt2', 'A argument option'
+      r.bool_opt '-c', '--opt3', 'A required boolean option', required: true
+      r.pos_arg :pos1
+      r.pos_arg :pos2, optional: true, repeat: true
+      r
+    end
+
+    context 'with all values' do
+      let(:argv) { %w[--opt1 --opt2 OPT2 --opt3 POS1 POS2_1 POS2_2] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: 'OPT2', opt3: true, pos1: 'POS1', pos2: %w[POS2_1 POS2_2]
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with only required values' do
+      let(:argv) { %w[--opt3 POS1] }
+      let(:parsed_expected) { { opt1: false, opt2: nil, opt3: true, pos1: 'POS1', pos2: [] } }
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with double dash' do
+      let(:argv) { %w[--opt3 POS1 -- --opt1 --] }
+      let(:parsed_expected) do
+        { opt1: false, opt2: nil, opt3: true, pos1: 'POS1', pos2: %w[--opt1 --] }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required positional' do
+      let(:argv) { %w[--opt1 --opt3] }
+      let(:parsed_expected) { { opt1: true, opt2: nil, opt3: true, pos1: nil, pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required option' do
+      let(:argv) { %w[--opt1 POS1] }
+      let(:parsed_expected) { { opt1: true, opt2: nil, opt3: false, pos1: 'POS1', pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without any required option or positional' do
+      let(:argv) { %w[] }
+      let(:parsed_expected) { { opt1: false, opt2: nil, opt3: false, pos1: nil, pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with excedent positional' do
+      let(:alternative) do
+        r = ::EacCli::Definition::Alternative.new
+        r.pos_arg :pos1
+        r
+      end
+
+      let(:argv) { %w[POS1 POS2] }
+      let(:parsed_expected) { { pos1: 'POS1' } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+  end
+
+  context 'with subcommands' do
+    let(:alternative) do
+      r = ::EacCli::Definition::Alternative.new
+      r.bool_opt '-b', '--opt1', 'A boolean option'
+      r.arg_opt '-a', '--opt2', 'A argument option'
+      r.subcommands
+      r
+    end
+
+    context 'with all values' do
+      let(:argv) { %w[--opt1 --opt2 OPT2 CMD CMD_ARG_1 --CMD_ARG_2] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: 'OPT2',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => 'CMD',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => %w[CMD_ARG_1 --CMD_ARG_2]
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with only required values' do
+      let(:argv) { %w[CMD] }
+      let(:parsed_expected) do
+        {
+          opt1: false, opt2: nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => 'CMD',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => []
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required values' do
+      let(:argv) { %w[--opt1] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => []
+        }
+      end
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+  end
+end