ehbrs-tools 0.28.0 → 0.29.0

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

@@ -1,92 +0,0 @@
-# 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 success?
-        !error?
-      end
-
-      def parsed
-        @parsed ||= collector.to_data.freeze
-      end
-
-      private
-
-      attr_accessor :phase
-
-      def any_collect_argv_value
-        %w[double_dash long_option short_option].each do |arg_type|
-          return send("#{arg_type}_collect_argv_value") if send("argv_current_#{arg_type}?")
-        end
-
-        positional_collect_argv_value
-      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/vendor/eac_cli/lib/eac_cli/parser/collector.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/struct'
-
-module EacCli
-  class Parser
-    class Collector
-      class << self
-        def to_data(definition)
-          collector = new(definition)
-          yield(collector)
-          collector.to_data
-        end
-      end
-
-      common_constructor :definition do
-        default_values
-      end
-
-      # @return [OpenStruct]
-      def to_data
-        ::EacRubyUtils::Struct.new(data.transform_keys(&:identifier))
-      end
-
-      def collect(option, value)
-        data[option] = option.build_value(value, data[option])
-      end
-
-      def supplied?(option)
-        data[option].present?
-      end
-
-      private
-
-      def data
-        @data ||= {}
-      end
-
-      def default_values
-        definition.options.each { |option| data[option] = option.default_value }
-        definition.positional.each { |positional| data[positional] = positional.default_value }
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  class Parser
-    class Error < ::StandardError
-      def initialize(definition, argv, message)
-        @definition = definition
-        @argv = argv
-        super(message)
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  class Parser
-    require_sub __FILE__
-    enable_simple_cache
-    common_constructor :definition, :argv
-
-    private
-
-    def parsed_uncached
-      raise 'Definition has no alternatives' if alternatives.empty?
-      raise first_error unless alternatives.select(&:success?).any?
-
-      alternatives_parsed(true).merge(alternatives_parsed(false))
-    end
-
-    def alternatives_parsed(error)
-      alternatives.select { |a| error == a.error? }.map(&:parsed).reverse
-                  .inject(::EacRubyUtils::Struct.new) { |a, e| a.merge(e) }
-    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/vendor/eac_cli/lib/eac_cli/patches/object/runner_with.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-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)
-    include ::EacCli::Runner
-    enable_simple_cache
-    enable_speaker
-    runners.each do |runner|
-      include ::EacCli::RunnerWithSet.default.item_to_module(runner)
-    end
-    runner_definition(&block) if block
-  end
-
-  private
-
-  def runner_with_to_module(runner)
-    return runner if runner.is_a?(::Module)
-
-    "EacCli::RunnerWith::#{runner.to_s.camelize}".constantize
-  end
-end

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

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-Dir["#{File.dirname(__FILE__)}/#{::File.basename(__FILE__, '.*')}/*.rb"].sort.each do |path|
-  require path
-end

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

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

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/speaker'
-require 'eac_ruby_utils/speaker'
-
-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)
-        on_asserted_speaker do
-          r = create(*runner_context_args)
-          r.run_run
-          r
-        end
-      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
-
-      private
-
-      def on_asserted_speaker
-        if ::EacRubyUtils::Speaker.context.optional_current
-          yield
-        else
-          ::EacRubyUtils::Speaker.context.on(::EacCli::Speaker.new) do
-            yield
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module Runner
-    class Context
-      attr_reader :argv, :parent, :program_name, :runner
-
-      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)
-        return parent.runner_context.call(method_name, *args) if parent.respond_to?(:runner_context)
-
-        raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# 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/instance_methods.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    module InstanceMethods
-      PARSER_ERROR_EXIT_CODE = 1
-
-      def run_run
-        parsed
-        run_callbacks(:run) { run }
-      rescue ::EacCli::Parser::Error => e
-        run_parser_error(e)
-      rescue ::EacCli::Runner::Exit # rubocop:disable Lint/SuppressedException
-        # Do nothing
-      end
-
-      def run_parser_error(error)
-        $stderr.write("#{program_name}: #{error}\n")
-        ::Kernel.exit(PARSER_ERROR_EXIT_CODE)
-      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
-
-      def program_name
-        runner_context.if_present(&:program_name) || $PROGRAM_NAME
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/definition'
-require 'eac_cli/parser'
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module Runner
-    require_sub __FILE__
-    extend ::ActiveSupport::Concern
-
-    class << self
-      def alias_runner_class_methods(klass, from_suffix, to_suffix)
-        %i[create run].each do |method|
-          alias_class_method(klass, build_method_name(method, from_suffix),
-                             build_method_name(method, to_suffix))
-        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.send(:alias_method, to, from)
-      end
-
-      def build_method_name(name, suffix)
-        ss = suffix.if_present('') { |s| "#{s}_" }
-        "#{ss}#{name}"
-      end
-    end
-
-    the_module = self
-    included do
-      the_module.alias_runner_class_methods(self, '', 'original')
-
-      extend AfterClassMethods
-      include InstanceMethods
-      include ActiveSupport::Callbacks
-      define_callbacks :run
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module RunnerWith
-    module Help
-      class Builder
-        class Alternative
-          PROGRAM_MACRO = '__PROGRAM__'
-          SUBCOMMANDS_MACRO = '__SUBCOMMANDS__'
-
-          common_constructor :alternative
-
-          def to_s
-            (
-              [PROGRAM_MACRO] +
-                alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
-                options +
-                positionals
-            ).join(::EacCli::RunnerWith::Help::Builder::SEP)
-          end
-
-          def options
-            alternative.options.select(&:show_on_usage?).map do |option|
-              ::EacCli::RunnerWith::Help::Builder.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) }.reject(&:blank?)
-          end
-
-          def positional(positional)
-            return unless positional.visible?
-
-            if positional.subcommand?
-              SUBCOMMANDS_MACRO
-            else
-              r = "<#{positional.name}>"
-              r += '...' if positional.repeat?
-              r = "[#{r}]" if positional.optional?
-              r
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module RunnerWith
-    module Help
-      class Builder
-        require_sub __FILE__
-        common_constructor :definition
-
-        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
-
-          def option_usage_full(option)
-            if option.long.present?
-              [option.short, option_long(option)].reject(&:blank?).join(SEP)
-            else
-              option_short(option)
-            end
-          end
-        end
-
-        def option_definition(option)
-          [self.class.option_usage_full(option), option.description,
-           option.default_value? ? "[Default: \"#{option.default_value}\"]" : nil]
-            .reject(&:blank?).join(OPTION_DESC_SEP)
-        end
-
-        def section(header, include_header = true)
-          b = include_header ? "#{header.humanize}:\n" : ''
-          b += send("self_#{header}") + "\n"
-          definition.alternatives.each do |alternative|
-            b += IDENT + ::EacCli::RunnerWith::Help::Builder::Alternative.new(alternative).to_s +
-                 "\n"
-          end
-          b
-        end
-
-        def options_section
-          "Options:\n" +
-            definition.alternatives.flat_map(&:options)
-                      .map { |option| IDENT + option_definition(option) + "\n" }.join
-        end
-
-        def usage_section
-          "Usage:\n" +
-            definition.alternatives.map do |alternative|
-              IDENT + ::EacCli::RunnerWith::Help::Builder::Alternative.new(alternative).to_s + "\n"
-            end.join
-        end
-
-        def to_s
-          "#{definition.description}\n\n#{usage_section}\n#{options_section}\n"
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/runner'
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module RunnerWith
-    module Help
-      require_sub __FILE__
-      common_concern do
-        include ::EacCli::Runner
-
-        runner_definition.alt do
-          bool_opt '-h', '--help', 'Show help.', usage: true, required: true
-          pos_arg :any_arg_with_help, repeat: true, optional: true, visible: false
-        end
-
-        set_callback :run, :before do
-          help_run
-        end
-      end
-
-      def help_run
-        return unless show_help?
-
-        puts help_text
-        raise ::EacCli::Runner::Exit
-      end
-
-      def help_text
-        r = ::EacCli::RunnerWith::Help::Builder.new(self.class.runner_definition).to_s
-        r += help_extra_text if respond_to?(:help_extra_text)
-        r
-      end
-
-      def show_help?
-        parsed.help? && !if_respond(:run_subcommand?, false)
-      end
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Subcommands
-      module DefinitionConcern
-      end
-    end
-  end
-end