avm-tools 0.120.0 → 0.121.0

data/sub/eac_cli/lib/eac_cli/rspec/setup.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/config/entry'
-require 'eac_cli/speaker'
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/speaker'
-
-module EacCli
-  module Rspec
-    module Setup
-      def disable_input_request
-        disable_config_input_request
-        disable_speaker_input_request
-      end
-
-      def disable_config_input_request
-        rspec_config.before do
-          allow_any_instance_of(::EacCli::Config::Entry).to receive(:input_value) do |obj|
-            raise "Console input requested for entry (Path: #{obj.path})"
-          end
-        end
-      end
-
-      def disable_speaker_input_request
-        ::RSpec.configure do |config|
-          config.around do |example|
-            ::EacRubyUtils::Speaker
-              .context.on(::EacCli::Speaker.new(in_in: FailIfRequestInput.new)) { example.run }
-          end
-        end
-      end
-
-      class FailIfRequestInput
-        %w[gets noecho].each do |method|
-          define_method(method) do
-            raise "Input method requested: #{method}. Should not request input on RSpec."
-          end
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/rspec.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_exts'
-
-module EacCli
-  module Rspec
-    require_sub __FILE__
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/definition'
-require 'eac_cli/runner/class_runner'
-
-module EacCli
-  module Runner
-    module AfterClassMethods
-      # @return [EacCli::Runner::ClassRunner]
-      def class_runner(runner_context_args)
-        ::EacCli::Runner::ClassRunner.new(self, runner_context_args)
-      end
-
-      def create(*runner_context_args)
-        class_runner(runner_context_args).create
-      end
-
-      def run(*runner_context_args)
-        class_runner(runner_context_args).run
-      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/sub/eac_cli/lib/eac_cli/runner/class_runner.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/speaker'
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/speaker'
-
-module EacCli
-  module Runner
-    class ClassRunner
-      PARSER_ERROR_EXIT_CODE = 1
-
-      common_constructor :klass, :context_args
-
-      def create
-        r = klass.new
-        r.runner_context = ::EacCli::Runner::Context.new(r, *context_args)
-        r
-      end
-
-      def run
-        on_asserted_speaker do
-          r = create
-          begin
-            r.run_run
-          rescue ::EacCli::Parser::Error => e
-            run_parser_error(r, e)
-          end
-          r
-        end
-      end
-
-      def run_parser_error(runner_instance, error)
-        $stderr.write("#{runner_instance.program_name}: #{error}\n")
-        ::Kernel.exit(PARSER_ERROR_EXIT_CODE)
-      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/sub/eac_cli/lib/eac_cli/runner/context.rb

@@ -1,40 +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
-
-      def respond_to_call?((method_name))
-        parent.respond_to?(:runner_context) && parent.runner_context.respond_to_call?(method_name)
-      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/sub/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/sub/eac_cli/lib/eac_cli/runner/instance_methods.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    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
-
-      def program_name
-        runner_context.if_present(&:program_name) || $PROGRAM_NAME
-      end
-
-      def respond_to_missing?(method, include_all = false)
-        runner_context.respond_to_call?(method) || super
-      end
-
-      def method_missing(method, *args, &block)
-        return super unless runner_context.respond_to_call?(method)
-
-        runner_context.call(method, *args, &block)
-      end
-    end
-  end
-end

data/sub/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/sub/eac_cli/lib/eac_cli/runner_with/help/builder/alternative.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module RunnerWith
-    module Help
-      class Builder
-        class Alternative
-          enable_method_class
-
-          SUBCOMMANDS_MACRO = '__SUBCOMMANDS__'
-
-          common_constructor :builder, :alternative
-
-          def result
-            (
-              program_name +
-                alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
-                options +
-                positionals
-            ).join(builder.word_separator)
-          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
-
-          def program_name
-            r = builder.runner.program_name
-            r = [r] unless r.is_a?(::Enumerable)
-            r
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module RunnerWith
-    module Help
-      class Builder
-        require_sub __FILE__, require_dependency: true
-        common_constructor :runner
-
-        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(word_separator)
-            else
-              option_short(option)
-            end
-          end
-
-          def word_separator
-            SEP
-          end
-        end
-
-        delegate :word_separator, to: :class
-
-        def definition
-          runner.class.runner_definition
-        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 + self.alternative(alternative) + "\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 + self.alternative(alternative) + "\n"
-            end.join
-        end
-
-        def to_s
-          "#{definition.description}\n\n#{usage_section}\n#{options_section}\n"
-        end
-      end
-    end
-  end
-end

data/sub/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__, require_dependency: true
-      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).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/sub/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

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

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/runner'
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module RunnerWith
-    module Subcommands
-      require_sub __FILE__
-
-      class << self
-        def runner?(object)
-          ::EacCli::Runner.runner?(object)
-        end
-      end
-
-      common_concern do
-        include ::EacCli::Runner
-        runner_definition.singleton_class
-          .include(::EacCli::RunnerWith::Subcommands::DefinitionConcern)
-      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::RunnerWith::Subcommands.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 help_extra_text
-        (['Subcommands:'] + available_subcommands.keys.sort.map { |s| "  #{s}" })
-          .map { |v| "#{v}\n" }.join
-      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 run_subcommand?
-          if subcommand_runner.respond_to?(:run_run)
-            subcommand_runner.run_run
-          else
-            subcommand_runner.run
-          end
-        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 run_subcommand?
-        subcommand_name.present?
-      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
-        [program_name, 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/sub/eac_cli/lib/eac_cli/runner_with.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  module RunnerWith
-    require_sub __FILE__
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner_with_set.rb

@@ -1,50 +0,0 @@
-# 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/sub/eac_cli/lib/eac_cli/speaker/constants.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/by_reference'
-
-module EacCli
-  class Speaker
-    module Constants
-      STDERR = ::EacRubyUtils::ByReference.new { $stderr }
-      STDIN = ::EacRubyUtils::ByReference.new { $stdin }
-      STDOUT = ::EacRubyUtils::ByReference.new { $stdout }
-    end
-  end
-end