eac_tools 0.123.0 → 0.123.1

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/
-
-        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 || any_option_collect_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,54 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      module ShortOptions
-        SHORT_OPTION_PREFIX = '-'
-        SHORT_OPTION_CHAR_PATTERN = /\A[0-9a-zA-Z]\z/
-
-        private
-
-        # @return [Boolean]
-        def argv_current_short_option?
-          phase == PHASE_ANY && argv_enum.peek.start_with?(SHORT_OPTION_PREFIX) &&
-            !argv_current_long_option?
-        end
-
-        # @para char [String]
-        # @return [EacCli::Definition::Option, nil]
-        def find_short_option(char)
-          alternative.options.find do |option|
-            short_without_prefix(option.short).if_present(false) { |v| v == char }
-          end
-        end
-
-        # @return [void]
-        def short_option_collect_argv_value
-          last_option = nil
-          short_without_prefix(argv_enum.peek).each_char do |char|
-            raise_error "Invalid option: \"#{char}\"" unless SHORT_OPTION_CHAR_PATTERN.match?(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
-
-        # @param char [String]
-        # @return [EacCli::Definition::Option] The option collected.
-        def short_option_collect_char(char)
-          option = find_short_option(char)
-          option ? option_collect_option(option) : any_option_collect_option
-        end
-
-        # @param short [String]
-        # @return [String]
-        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,99 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Alternative
-      require_sub __FILE__, include_modules: true
-      enable_listable
-      lists.add_symbol :phase, :any, :option_argument, :positional
-
-      # @return [EacCli::Parser::Error, nil]
-      attr_reader :error
-
-      # @!method initialize(alternative, argv)
-      # @param alternative [EacCli::Definition::Alternative]
-      # @param argv [Array<String>]
-      common_constructor :alternative, :argv do
-        alternative.assert_argument(::EacCli::Definition::Alternative, :alternative)
-        self.phase = PHASE_ANY
-        collect
-      end
-
-      # @return [Boolean]
-      def error?
-        error.present?
-      end
-
-      # @return [Boolean]
-      def success?
-        !error?
-      end
-
-      # @return [EacRubyUtils::Struct]
-      def parsed
-        @parsed ||= collector.to_data.freeze
-      end
-
-      private
-
-      # @return [Symbol]
-      attr_accessor :phase
-
-      # @return [void]
-      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
-
-      # @return [EacCli::Parser::Collector]
-      def collector
-        @collector ||= ::EacCli::Parser::Collector.new(alternative)
-      end
-
-      # @return [void]
-      def collect
-        loop do
-          break unless argv_pending?
-
-          collect_argv_value
-        end
-        validate
-      rescue ::EacCli::Parser::Error => e
-        @error = e
-      end
-
-      # @return [void]
-      def collect_argv_value
-        send("#{phase}_collect_argv_value")
-        argv_enum.next
-      end
-
-      # @param message [String]
-      # @raise [EacCli::Parser::Error] Always.
-      def raise_error(message)
-        raise ::EacCli::Parser::Error.new(alternative, argv, message)
-      end
-
-      # @return [void]
-      # @raise [EacCli::Parser::Error] If options where not properly supplied.
-      def validate
-        (alternative.options + alternative.positional).each do |option|
-          validate_option(option)
-        end
-      end
-
-      # @param option [EacCli::Definition::Option, EacCli::Definition::Positional]
-      # @return [void]
-      # @raise [EacCli::Parser::Error] If option was not properly supplied.
-      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,52 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    class Collector
-      class << self
-        def to_data(definition)
-          collector = new(definition)
-          yield(collector)
-          collector.to_data
-        end
-      end
-
-      # @!method initialize(definition)
-      # @param definition [EacCli::Definition]
-      common_constructor :definition do
-        default_values
-      end
-
-      # @return [EacRubyUtils::Struct]
-      def to_data
-        ::EacRubyUtils::Struct.new(data.transform_keys(&:identifier))
-      end
-
-      # @param option [EacCli::Definition::Option]
-      # @param value [String]
-      # @return [void]
-      def collect(option, value)
-        data[option] = option.build_value(value, data[option])
-      end
-
-      # @param option [EacCli::Definition::Option]
-      # @return [Boolean]
-      def supplied?(option)
-        data[option].present?
-      end
-
-      private
-
-      # @return [Hash]
-      def data
-        @data ||= {}
-      end
-
-      # @return [void]
-      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,13 +0,0 @@
-# frozen_string_literal: true
-
-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,31 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Parser
-    enable_simple_cache
-    common_constructor :definition, :argv
-
-    private
-
-    def parsed_uncached
-      raise 'Definition has no alternatives' if alternatives.empty?
-      raise first_error unless alternatives.any?(&:success?)
-
-      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,23 +0,0 @@
-# frozen_string_literal: true
-
-class Object
-  def runner_with(*runners, &block)
-    include ::EacCli::Runner
-
-    enable_memoized
-    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/rspec/setup.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-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
-          # Fixes EacCli::Config::Entry does not implement #input_value error
-          ::EacCli::Config::Entry.define_method(:input_value) do
-            super
-          end
-          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/runner/after_class_methods.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-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
-        begin
-          @runner_definition.instance_eval(&block) if block
-        rescue ::EacCli::Definition::Error => _e
-          raise ::EacCli::Definition::Error, "Definition error for #{self}"
-        end
-        @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,32 +0,0 @@
-# frozen_string_literal: true
-
-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
-        r = create
-        begin
-          r.run_run
-        rescue ::EacCli::Parser::Error => e
-          run_parser_error(r, e)
-        end
-        r
-      end
-
-      def run_parser_error(runner_instance, error)
-        $stderr.write("#{runner_instance.program_name}: #{error}\n")
-        ::Kernel.exit(PARSER_ERROR_EXIT_CODE)
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-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, *, &)
-        context_call_responder(method_name).call(*, &)
-      end
-
-      # @return [EacCli::Runner::ContextResponders]
-      def context_call_responder(method_name)
-        ::EacCli::Runner::ContextResponders::Set.new(self, method_name, %i[runner parent])
-      end
-
-      # @param method_name [Symbol]
-      # @return [EacCli::Runner::ContextResponders::Parent]
-      def runner_missing_method_responder(method_name)
-        ::EacCli::Runner::ContextResponders::RunnerMissingMethod
-          .new(self, method_name)
-      end
-
-      # @param method_name [Symbol]
-      # @return [Boolean]
-      def parent_respond_to?(method_name)
-        parent.if_present(false) do |v|
-          next true if v.respond_to?(method_name)
-
-          v.if_respond(:runner_context, false) { |w| w.parent_respond_to?(method_name) }
-        end
-      end
-
-      def parent_call(method_name, *, &)
-        return parent.runner_context.call(method_name, *, &) if
-          parent.respond_to?(:runner_context)
-
-        raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"
-      end
-
-      # @param method_name [Symbol]
-      # @return [EacCli::Runner::ContextResponders::Parent]
-      def parent_responder(method_name)
-        ::EacCli::Runner::ContextResponders::Parent.new(self, method_name)
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/base.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    module ContextResponders
-      class Base
-        acts_as_abstract :call, :callable?
-        common_constructor :context, :method_name do
-          self.method_name = method_name.to_sym
-        end
-        delegate :parent, :runner, to: :context
-
-        def if_callable # rubocop:disable Naming/PredicateMethod
-          return false unless callable?
-
-          yield(self)
-          true
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/parent.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    module ContextResponders
-      class Parent < ::EacCli::Runner::ContextResponders::Base
-        def callable?
-          parent.if_present(false) do |v|
-            next true if v.respond_to?(method_name)
-
-            v.if_respond(:runner_context, false) { |w| w.parent_respond_to?(method_name) }
-          end
-        end
-
-        def call(*, &)
-          return parent.runner_context.call(method_name, *, &) if
-            parent.respond_to?(:runner_context)
-
-          raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    module ContextResponders
-      class Runner < ::EacCli::Runner::ContextResponders::Base
-        def callable?
-          runner.respond_to?(method_name)
-        end
-
-        def call(*, &)
-          runner.send(method_name, *, &)
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/runner_missing_method.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    module ContextResponders
-      class RunnerMissingMethod < ::EacCli::Runner::ContextResponders::Base
-        def callable?
-          responder_runner.present?
-        end
-
-        def call(*, &)
-          responder_runner.send(method_name, *, &)
-        end
-
-        private
-
-        def responder_runner
-          parent.if_present(nil) do |v|
-            next v if v.respond_to?(method_name) && v.for_context?(method_name)
-
-            v.if_respond(:runner_context, nil) do |w|
-              w.runner_missing_method_responder(method_name).send(__method__)
-            end
-          end
-        end
-      end
-    end
-  end
-end