ehbrs-tools 0.16.4 → 0.20.0

data/vendor/eac_cli/lib/eac_cli/parser/alternative/option_argument.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module OptionArgument
+        private
+
+        attr_accessor :argument_option
+
+        def argument_option_collect_argv(option)
+          self.argument_option = option
+          self.phase = PHASE_OPTION_ARGUMENT
+        end
+
+        def option_argument_collect(option, value)
+          collector.collect(option, value)
+          self.argument_option = nil
+          self.phase = PHASE_ANY
+          option
+        end
+
+        def option_argument_collect_argv_value
+          option_argument_collect(argument_option, argv_enum.peek)
+        end
+      end
+    end
+  end
+end

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

@@ -4,49 +4,20 @@ 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
+        def option_collect_option(option)
+          if option.argument?
+            argument_option_collect_argv(option)
+          else
+            boolean_option_collect_argv(option)
+          end
 
-            true
-          end || raise_argv_current_invalid_option
+          option
         end
 
         def raise_argv_current_invalid_option

data/vendor/eac_cli/lib/eac_cli/parser/alternative/short_options.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module ShortOptions
+        SHORT_OPTION_PREFIX = '-'
+
+        private
+
+        def argv_current_short_option?
+          phase == PHASE_ANY && argv_enum.peek.start_with?(SHORT_OPTION_PREFIX) &&
+            !argv_current_long_option?
+        end
+
+        def find_short_option(char)
+          alternative.options.find { |option| short_without_prefix(option.short) == char }
+        end
+
+        def short_option_collect_argv_value
+          last_option = nil
+          short_without_prefix(argv_enum.peek).each_char do |char|
+            raise_error "Option \"#{last_option}\" requires a argument not provided" if
+            last_option.present?
+
+            collected_option = short_option_collect_char(char)
+            last_option = collected_option if collected_option.argument?
+          end
+        end
+
+        # @return [EacCli::Definition::BaseOption] The option collected.
+        def short_option_collect_char(char)
+          option = find_short_option(char)
+          raise_error "Invalid short option \"#{char}\"" unless option
+
+          option_collect_option(option)
+        end
+
+        def short_without_prefix(short)
+          short.gsub(/\A#{::Regexp.quote(SHORT_OPTION_PREFIX)}/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -24,11 +24,7 @@ module EacCli
       end
 
       def collect(option, value)
-        if data[option].is_a?(::Array)
-          data[option] << value
-        else
-          data[option] = value
-        end
+        data[option] = option.build_value(value, data[option])
       end
 
       def supplied?(option)
@@ -42,18 +38,8 @@ module EacCli
       end
 
       def default_values
-        definition.options.each { |option| data[option] = option_default_value(option) }
-        definition.positional.each do |positional|
-          data[positional] = positional_default_value(positional)
-        end
-      end
-
-      def option_default_value(option)
-        option.argument? ? nil : false
-      end
-
-      def positional_default_value(positional)
-        positional.repeat? ? [] : nil
+        definition.options.each { |option| data[option] = option.default_value }
+        definition.positional.each { |positional| data[positional] = positional.default_value }
       end
     end
   end

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

@@ -3,6 +3,7 @@
 require 'eac_ruby_utils/core_ext'
 require 'eac_cli/runner'
 require 'eac_cli/runner_with'
+require 'eac_cli/runner_with_set'
 
 class Object
   def runner_with(*runners, &block)
@@ -10,7 +11,7 @@ class Object
     enable_simple_cache
     enable_console_speaker
     runners.each do |runner|
-      include runner_with_to_module(runner)
+      include ::EacCli::RunnerWithSet.default.item_to_module(runner)
     end
     runner_definition(&block) if block
   end

data/vendor/eac_cli/lib/eac_cli/runner.rb

@@ -47,53 +47,5 @@ module EacCli
       include ActiveSupport::Callbacks
       define_callbacks :run
     end
-
-    module AfterClassMethods
-      def create(*runner_context_args)
-        r = new
-        r.runner_context = ::EacCli::Runner::Context.new(r, *runner_context_args)
-        r
-      end
-
-      def run(*runner_context_args)
-        r = create(*runner_context_args)
-        r.run_run
-        r
-      end
-
-      def runner_definition(&block)
-        @runner_definition ||= super_runner_definition
-        @runner_definition.instance_eval(&block) if block
-        @runner_definition
-      end
-
-      def super_runner_definition
-        superclass.try(:runner_definition).if_present(&:dup) || ::EacCli::Definition.new
-      end
-    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
-
-        raise 'Context was required, but was not set yet'
-      end
-
-      def runner_context=(new_runner_context)
-        @runner_context = new_runner_context
-        @parsed = nil
-      end
-
-      def parsed
-        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition, runner_context.argv).parsed
-      end
-    end
   end
 end

data/vendor/eac_cli/lib/eac_cli/runner/after_class_methods.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module AfterClassMethods
+      def create(*runner_context_args)
+        r = new
+        r.runner_context = ::EacCli::Runner::Context.new(r, *runner_context_args)
+        r
+      end
+
+      def run(*runner_context_args)
+        r = create(*runner_context_args)
+        r.run_run
+        r
+      end
+
+      def runner_definition(&block)
+        @runner_definition ||= super_runner_definition
+        @runner_definition.instance_eval(&block) if block
+        @runner_definition
+      end
+
+      def super_runner_definition
+        superclass.try(:runner_definition).if_present(&:dup) || ::EacCli::Definition.new
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/runner/instance_methods.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module InstanceMethods
+      def run_run
+        parsed
+        run_callbacks(:run) { run }
+      rescue ::EacCli::Parser::Error => e
+        $stderr.write("#{e}\n")
+      rescue ::EacCli::Runner::Exit # rubocop:disable Lint/SuppressedException
+        # Do nothing
+      end
+
+      def runner_context
+        return @runner_context if @runner_context
+
+        raise 'Context was required, but was not set yet'
+      end
+
+      def runner_context=(new_runner_context)
+        @runner_context = new_runner_context
+        @parsed = nil
+      end
+
+      def parsed
+        @parsed ||= ::EacCli::Parser.new(self.class.runner_definition, runner_context.argv).parsed
+      end
+    end
+  end
+end

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

@@ -6,6 +6,14 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   module RunnerWith
     module Subcommands
+      class << self
+        def runner?(object)
+          ::EacCli::Runner.runner?(object) || (
+            object.is_a?(::Class) && object < ::EacRubyUtils::Console::DocoptRunner
+          )
+        end
+      end
+
       common_concern do
         include ::EacCli::Runner
       end
@@ -19,7 +27,7 @@ module EacCli
       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]) }
+            .select { |c| ::EacCli::RunnerWith::Subcommands.runner?(c[1]) }
             .to_h.with_indifferent_access
       end
 
@@ -32,7 +40,7 @@ module EacCli
       end
 
       def help_extra_text
-        (['Subcommands:'] + available_subcommands.keys.map { |s| "  #{s}" })
+        (['Subcommands:'] + available_subcommands.keys.sort.map { |s| "  #{s}" })
           .map { |v| "#{v}\n" }.join
       end
 
@@ -49,7 +57,11 @@ module EacCli
 
       def run_with_subcommand
         if subcommand_name
-          subcommand_runner.run_run
+          if subcommand_runner.respond_to?(:run_run)
+            subcommand_runner.run_run
+          else
+            subcommand_runner.run
+          end
         else
           run_without_subcommand
         end

data/vendor/eac_cli/lib/eac_cli/runner_with_set.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module EacCli
+  class RunnerWithSet
+    class << self
+      def default
+        @default ||= new
+      end
+    end
+
+    def add_namespace(namespace)
+      namespace = sanitize_namespace(namespace)
+      raise "\"#{namespace}\" already was included" if namespace_set.include?(namespace)
+
+      namespace_set << namespace
+      self
+    end
+
+    def item_to_module(item)
+      item.is_a?(::Module) ? item : key_to_module(item)
+    end
+
+    def namespaces
+      namespace_set.dup
+    end
+
+    private
+
+    def namespace_set
+      @namespace_set ||= ::Array.new
+    end
+
+    def key_to_module(key)
+      namespace_set.lazy
+                   .map { |namespace| key_to_module_in_namespace(namespace, key) }
+                   .find(&:present?) ||
+        raise("Not module found with key \"#{key}\" (Namespaces: #{namespace_set})")
+    end
+
+    def key_to_module_in_namespace(namespace, key)
+      namespace.const_get(key.to_s.camelize)
+    rescue ::NameError
+      nil
+    end
+
+    def sanitize_namespace(source)
+      source.is_a?(::Module) ? source : source.to_s.constantize
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/version.rb

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

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

@@ -7,6 +7,10 @@ RSpec.describe ::EacCli::Definition::Alternative do
 
   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.bool_opt '-b', '--no-description' }.not_to raise_error }
+  it { expect { instance.bool_opt '--opt1', 'A option without short' }.not_to raise_error }
+  it { expect { instance.bool_opt '-b', 'A option without long' }.not_to raise_error }
+  it { expect { instance.bool_opt 'A option without selectors' }.to raise_error(::StandardError) }
   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 }

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

@@ -11,7 +11,9 @@ RSpec.describe ::EacCli::Runner do
 
       runner_definition do
         arg_opt '-o', '--opt1', 'A arg option.'
-        bool_opt '-o', '--opt2', 'A boolean option'
+        bool_opt '-p', '--opt2', 'A boolean option'
+        arg_opt '-q', '--opt4', 'A repeatable argument option.', repeat: true
+        bool_opt '-r', '--opt5', 'A repeatable boolean option', repeat: true
         pos_arg :pos1
         pos_arg :pos2, repeat: true, optional: true
         alt do
@@ -29,7 +31,7 @@ RSpec.describe ::EacCli::Runner do
   context 'when all args are supplied' do
     let(:argv) { %w[--opt1 aaa --opt2 bbb ccc ddd] }
     let(:parsed_expected) do
-      { opt1: 'aaa', opt2: true, opt3: false, pos1: 'bbb',
+      { opt1: 'aaa', opt2: true, opt3: false, opt4: [], opt5: 0, pos1: 'bbb',
         pos2: %w[ccc ddd] }
     end
 
@@ -40,9 +42,33 @@ RSpec.describe ::EacCli::Runner do
     it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
   end
 
+  context 'with long option and argument in same position' do
+    let(:argv) { %w[--opt1=aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+  end
+
+  context 'with valid grouped short options' do
+    let(:argv) { %w[-po aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+    it { expect(instance.parsed.opt2?).to eq(true) }
+  end
+
+  context 'with invalid grouped short options' do
+    let(:argv) { %w[-op aaa pos1] }
+
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+
   context 'when only required args are supplied' do
     let(:argv) { %w[bbb] }
-    let(:parsed_expected) { { opt1: nil, opt2: false, opt3: false, pos1: 'bbb', pos2: [] } }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: [], opt5: 0, pos1: 'bbb',
+        pos2: [] }
+    end
 
     it { expect(parsed_actual).to eq(parsed_expected) }
     it { expect(instance.parsed.opt1).to be_nil }
@@ -61,12 +87,25 @@ RSpec.describe ::EacCli::Runner do
 
   context 'when alternative args are supplied' do
     let(:argv) { %w[--opt3] }
-    let(:parsed_expected) { { opt1: nil, opt2: false, opt3: true, pos1: nil, pos2: [] } }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: true, opt4: [], opt5: 0, pos1: nil,
+        pos2: [] }
+    end
 
     it { expect(parsed_actual).to eq(parsed_expected) }
     it { expect(instance.parsed.opt3?).to eq(true) }
   end
 
+  context 'when repeated options are supplied' do
+    let(:argv) { %w[--opt5 -rrr --opt4=A -q B --opt4 C AAA] }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: %w[A B C], opt5: 4, pos1: 'AAA',
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+  end
+
   context 'when extra args are not supplied' do
     let(:runner_class) do
       the_module = described_class