eac_tools 0.106.0 → 0.106.1

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,46 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module Runner
-    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,63 +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
-    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

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Help
-      class Builder
-        include ::EacCli::RunnerWith::Help::Layout
-
-        require_sub __FILE__, require_mode: :kernel
-        common_constructor :runner
-
-        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)].compact_blank.join(word_separator)
-            else
-              option_short(option)
-            end
-          end
-
-          def word_separator
-            WORD_SEPARATOR
-          end
-        end
-
-        delegate :word_separator, to: :class
-
-        def definition
-          runner.class.runner_definition
-        end
-
-        # @return [Enumerable<String>]
-        def extra_sections
-          runner.if_respond(:help_extra_text, []) do |v|
-            [v.to_s]
-          end
-        end
-
-        def option_definition(option)
-          [self.class.option_usage_full(option), option.description,
-           option.default_value? ? "[Default: \"#{option.default_value}\"]" : nil]
-            .compact_blank.join(OPTION_DESCRIPTION_SEPARATOR)
-        end
-
-        # @return [String]
-        def options_section
-          list_section(
-            'Options',
-            definition.alternatives.flat_map(&:options).map { |option| option_definition(option) }
-          )
-        end
-
-        # @return [String]
-        def usage_section
-          list_section(
-            'Usage',
-            definition.alternatives.map { |alternative| self.alternative(alternative) }
-          )
-        end
-
-        def to_s
-          join_sections(definition.description, usage_section, options_section, *extra_sections)
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner_with/help/layout.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Help
-      module Layout
-        common_concern do
-          include InstanceClassMethods
-          extend InstanceClassMethods
-        end
-
-        module InstanceClassMethods
-          WORD_SEPARATOR = ' '
-          IDENTATION = WORD_SEPARATOR * 2
-          OPTION_DESCRIPTION_SEPARATOR = IDENTATION * 2
-          LINE_BREAK = "\n"
-          SECTION_SEPARATOR = LINE_BREAK * 2
-
-          # @param title String
-          # @param items [Enumerable<String>]
-          # @return [String]
-          def list_section(title, items)
-            (["#{title}:"] + items.map { |line| "#{IDENTATION}#{line}" })
-              .map { |line| "#{line}\n" }.join
-          end
-
-          # @param sections [Enumerable<String>]
-          # @return [String]
-          def join_sections(*sections)
-            sections.map { |s| s.to_s.strip }.join(SECTION_SEPARATOR) + LINE_BREAK
-          end
-        end
-
-        extend InstanceClassMethods
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Help
-      common_concern do
-        include ::EacCli::Runner
-        include ::EacCli::RunnerWith::Help::Layout
-
-        runner_definition.alt do
-          bool_opt '-h', '--help', 'Show help.', usage: true, required: true
-          any_opt
-          pos_arg :any_arg_with_help, repeat: true, optional: true, visible: false
-        end
-
-        set_callback :run, :before do
-          help_run
-        end
-      end
-
-      # @param items [Enumerable<String>]
-      # @return [String]
-      def help_list_section(title, items)
-        ::EacCli::RunnerWith::Help::Layout.list_section(title, items)
-      end
-
-      # @param items [Enumerable<String>]
-      # @return [String]
-      def help_join_sections(*sections)
-        ::EacCli::RunnerWith::Help::Layout.join_sections(*sections)
-      end
-
-      def help_run
-        return unless show_help?
-
-        puts help_text
-        raise ::EacCli::Runner::Exit
-      end
-
-      # @return [String]
-      def help_text
-        ::EacCli::RunnerWith::Help::Builder.new(self).to_s
-      end
-
-      def show_help?
-        parsed.help? && !if_respond(:run_subcommand?, false)
-      end
-    end
-  end
-end