eac_tools 0.122.0 → 0.123.0

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

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

@@ -0,0 +1,45 @@
+# 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, *, &)
+        runner_context.runner_missing_method_responder(method).if_callable do |v|
+          return v.call(*, &)
+        end
+
+        super
+      end
+    end
+  end
+end

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

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

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

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

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

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

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

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