avm-tools 0.108.0 → 0.111.0

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

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

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

data/vendor/eac_cli/lib/eac_cli/speaker/list.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require 'ostruct'
-
-module EacCli
-  class Speaker
-    class List
-      class << self
-        def build(list)
-          return List.new(hash_to_values(list)) if list.is_a?(::Hash)
-          return List.new(array_to_values(list)) if list.is_a?(::Array)
-
-          raise "Invalid list: #{list} (#{list.class})"
-        end
-
-        private
-
-        def hash_to_values(list)
-          list.map { |key, value| ::OpenStruct.new(key: key, label: key, value: value) }
-        end
-
-        def array_to_values(list)
-          list.map { |value| ::OpenStruct.new(key: value, label: value, value: value) }
-        end
-      end
-
-      attr_reader :values
-
-      def initialize(values)
-        @values = values.map do |v|
-          ::OpenStruct.new(key: to_key(v.key), label: to_label(v.label), value: v.value)
-        end
-      end
-
-      def valid_labels
-        values.map(&:label)
-      end
-
-      def valid_value?(value)
-        values.any? { |v| v.key == to_key(value) }
-      end
-
-      def to_key(value)
-        to_label(value).downcase
-      end
-
-      def to_label(value)
-        value.to_s.strip
-      end
-
-      def build_value(value)
-        key = to_key(value)
-        values.each do |v| # rubocop:disable Style/HashEachMethods
-          return v.value if v.key == key
-        end
-        raise "Value not found: \"#{value}\" (#{values})"
-      end
-    end
-  end
-end

data/vendor/eac_cli/lib/eac_cli/speaker/options.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module EacCli
-  class Speaker
-    module Options
-      common_concern do
-        enable_listable
-        lists.add_symbol :option, :out_out, :err_out, :in_in, :parent, :err_line_prefix
-      end
-
-      def err_out
-        option(OPTION_ERR_OUT, ::EacCli::Speaker::STDERR)
-      end
-
-      def out_out
-        option(OPTION_OUT_OUT, ::EacCli::Speaker::STDOUT)
-      end
-
-      def in_in
-        option(OPTION_IN_IN, ::EacCli::Speaker::STDIN)
-      end
-
-      def err_line_prefix
-        option(OPTION_ERR_LINE_PREFIX, '')
-      end
-
-      def parent
-        options[OPTION_PARENT]
-      end
-
-      def option(key, default)
-        options[key] || parent.if_present(default) { |v| v.send(__METHOD__) }
-      end
-    end
-  end
-end