eac_tools 0.117.4 → 0.117.5

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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,30 @@
+# 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

@@ -0,0 +1,54 @@
+# 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

@@ -0,0 +1,99 @@
+# 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

@@ -0,0 +1,52 @@
+# 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

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,23 @@
+# 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

@@ -0,0 +1,41 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,32 @@
+# 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

@@ -0,0 +1,57 @@
+# 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

@@ -0,0 +1,22 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Set < ::EacCli::Runner::ContextResponders::Base
+        attr_reader :responders_names
+
+        def initialize(context, method_name, responders_names)
+          super(context, method_name)
+          @responders_names = responders_names
+        end
+
+        def callable?
+          responders_instances.any?(&:callable?)
+        end
+
+        def call(...)
+          caller = responder_to_call
+          return caller.call(...) if caller
+
+          raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
+        end
+
+        private
+
+        def responder_class(class_name)
+          ::EacCli::Runner::ContextResponders.const_get(class_name.to_s.camelize)
+        end
+
+        def responders_instances
+          responders_names.lazy.map { |name| responder_class(name).new(context, method_name) }
+        end
+
+        def responder_to_call
+          responders_instances.lazy.select(&:callable?).first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    class Exit < ::StandardError
+      attr_reader :status
+
+      def initialize(status = true) # rubocop:disable Style/OptionalBooleanParameter
+        super
+        @status = status
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module EacCli
+  module Runner
+    module ForContext
+      common_concern
+
+      module ClassMethods
+        # @param methods_names [Enumerable<Symbol>]
+        # @return [void]
+        def for_context(*methods_names)
+          for_context_methods.merge(methods_names.map(&:to_sym))
+        end
+
+        # @param method_name [Symbol]
+        # @return [Boolean]
+        def for_context?(method_name)
+          for_context_methods.include?(method_name.to_sym)
+        end
+
+        private
+
+        # @return [EacRubyUtils::ModuleAncestorsVariable::Set<Symbol>]
+        def for_context_methods
+          @for_context_methods ||=
+            ::EacRubyUtils::ModuleAncestorsVariable::Set.new(self, __method__)
+        end
+      end
+
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      delegate :for_context?, to: :class
+    end
+  end
+end