avm-tools 0.120.1 → 0.121.1

data/sub/eac_cli/lib/eac_cli/parser/alternative/argv.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module Argv
-        def argv_enum
-          @argv_enum ||= argv.each
-        end
-
-        def argv_pending?
-          argv_enum.ongoing?
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/parser/alternative/double_dash.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module DoubleDash
-        DOUBLE_DASH = '--'
-
-        private
-
-        attr_accessor :double_dash
-
-        def argv_current_double_dash?
-          argv_enum.peek == DOUBLE_DASH && !double_dash
-        end
-
-        def double_dash_collect_argv_value
-          self.phase = PHASE_POSITIONAL
-          self.double_dash = true
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/parser/alternative/long_options.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module LongOptions
-        LONG_OPTION_PREFIX = '--'
-        OPTION_WITH_ARGUMENT_PATTERN = /\A([^=]+)(?:=(.*))\z/.freeze
-
-        private
-
-        def argv_current_long_option?
-          phase == PHASE_ANY && argv_enum.peek.start_with?(LONG_OPTION_PREFIX) &&
-            !argv_current_double_dash?
-        end
-
-        def long_option_collect_argv_value
-          option_long, value = parse_option_current_argv
-          alternative.options.any? do |option|
-            next false unless option.long == option_long
-
-            if value.nil?
-              option_collect_option(option)
-            else
-              option_argument_collect(option, value)
-            end
-          end || raise_argv_current_invalid_option
-        end
-
-        def parse_option_current_argv
-          m = OPTION_WITH_ARGUMENT_PATTERN.match(argv_enum.peek)
-          m ? [m[1], m[2].if_present('')] : [argv_enum.peek, nil]
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# 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/sub/eac_cli/lib/eac_cli/parser/alternative/options.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module Options
-        private
-
-        def boolean_option_collect_argv(option)
-          collector.collect(option, true)
-        end
-
-        def option_collect_option(option)
-          if option.argument?
-            argument_option_collect_argv(option)
-          else
-            boolean_option_collect_argv(option)
-          end
-
-          option
-        end
-
-        def raise_argv_current_invalid_option
-          raise_error "Invalid option: \"#{argv_enum.peek}\""
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/parser/alternative/positionals.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module Positionals
-        private
-
-        def positional_collect_argv_value
-          positional_check
-          collector.collect(positional_enum.peek, argv_enum.peek)
-          positional_next
-        end
-
-        def positional_enum
-          @positional_enum ||= alternative.positional.each
-        end
-
-        def positional_check
-          raise_error("Invalid positional: #{argv_enum.peek}") if positional_enum.stopped?
-        end
-
-        def positional_next
-          self.phase = PHASE_POSITIONAL if positional_enum.peek.subcommand?
-          positional_enum.next unless positional_enum.peek.repeat?
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# 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 do |option|
-            short_without_prefix(option.short).if_present(false) { |v| v == char }
-          end
-        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_argv_current_invalid_option unless option
-
-          option_collect_option(option)
-        end
-
-        def short_without_prefix(short)
-          short.to_s.gsub(/\A#{::Regexp.quote(SHORT_OPTION_PREFIX)}/, '')
-        end
-      end
-    end
-  end
-end

data/sub/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/sub/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/sub/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/sub/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/sub/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/sub/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/sub/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/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