eac_tools 0.103.1 → 0.104.0

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, *args, &block)
-        context_call_responder(method_name).call(*args, &block)
-      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, *args, &block)
-        return parent.runner_context.call(method_name, *args, &block) 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(*args, &block)
-          return parent.runner_context.call(method_name, *args, &block) 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(*args, &block)
-          runner.send(method_name, *args, &block)
-        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(*args, &block)
-          responder_runner.send(method_name, *args, &block)
-        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

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

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

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

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    module InstanceMethods
-      def run_run
-        parsed
-        run_callbacks(:run) { run }
-      rescue ::EacCli::Runner::Exit
-        # 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.runner_missing_method_responder(method).callable? || super
-      end
-
-      def method_missing(method, *args, &block)
-        runner_context.runner_missing_method_responder(method).if_callable do |v|
-          return v.call(*args, &block)
-        end
-
-        super
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-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 ::EacCli::Runner::ForContext
-      include ActiveSupport::Callbacks
-
-      define_callbacks :run
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner_with/confirmation/input_result.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Confirmation
-      class InputResult
-        INPUT_NO_FOR_ONE = 'n'
-        INPUT_NO_FOR_ALL = 'N'
-        INPUT_YES_FOR_ONE = 'y'
-        INPUT_YES_FOR_ALL = 'Y'
-        INPUT_FOR_ONE = [INPUT_NO_FOR_ONE, INPUT_YES_FOR_ONE].freeze
-        INPUT_FOR_ALL = [INPUT_NO_FOR_ALL, INPUT_YES_FOR_ALL].freeze
-        INPUT_NO = [INPUT_NO_FOR_ONE, INPUT_NO_FOR_ALL].freeze
-        INPUT_YES = [INPUT_YES_FOR_ONE, INPUT_YES_FOR_ALL].freeze
-        INPUT_LIST = [INPUT_NO_FOR_ALL, INPUT_NO_FOR_ONE, INPUT_YES_FOR_ONE, INPUT_YES_FOR_ALL]
-                       .freeze
-
-        class << self
-          enable_speaker
-
-          # @param message [String]
-          # @return [EacCli::RunnerWith::Confirmation::InputResult]
-          def by_message(message)
-            new(input_value_by_speaker(message))
-          end
-
-          # @param message [String]
-          # @return [String]
-          def input_value_by_speaker(message)
-            input(message, list: INPUT_LIST, ignore_case: false)
-          end
-        end
-
-        common_constructor :input_value
-
-        # @return [Boolean]
-        def confirm?
-          input_value_to_bool(INPUT_NO, INPUT_YES)
-        end
-
-        # @return [Boolean]
-        def for_all?
-          input_value_to_bool(INPUT_FOR_ONE, INPUT_FOR_ALL)
-        end
-
-        private
-
-        # @param false_list [Array<String>]
-        # @param true_list [Array<String>]
-        # @return [Boolean]
-        def input_value_to_bool(false_list, true_list)
-          return false if false_list.include?(input_value)
-          return true if true_list.include?(input_value)
-
-          ibr input_value
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Confirmation
-      DEFAULT_CONFIRM_QUESTION_TEXT = 'Confirm?'
-
-      common_concern do
-        include ::EacCli::Runner
-
-        enable_settings_provider
-        enable_simple_cache
-        runner_definition do
-          bool_opt '--no', 'Deny confirmation without question.'
-          bool_opt '--yes', 'Accept confirmation without question.'
-        end
-      end
-
-      # @param message [String, nil]
-      # @return [Boolean]
-      def confirm?(message = nil)
-        return for_all_answers.fetch(message) if for_all_answers.key?(message)
-        return false if parsed.no?
-        return true if parsed.yes?
-
-        confirm_input_and_register(message)
-      rescue ::EacCli::Speaker::InputRequested => e
-        fatal_error e.message
-      end
-
-      def run_confirm(message = nil)
-        yield if confirm?(message)
-      end
-
-      private
-
-      def cached_confirm_uncached?(message = nil)
-        confirm?(message)
-      end
-
-      # @param message [String, nil]
-      # @return [Boolean]
-      def confirm_input(message)
-        ::EacCli::RunnerWith::Confirmation::InputResult.by_message(
-          message || setting_value(:confirm_question_text, default: DEFAULT_CONFIRM_QUESTION_TEXT)
-        )
-      end
-
-      # @param message [String, nil]
-      # @return [Boolean]
-      def confirm_input_and_register(message) # rubocop:disable Naming/PredicateMethod
-        r = confirm_input(message)
-        for_all_answers[message] = r.confirm? if r.for_all?
-        r.confirm?
-      end
-
-      # @return [Hash<String, Boolean>]
-      def for_all_answers_uncached
-        {}
-      end
-
-      require_sub __FILE__
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-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) }.compact_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