eac_tools 0.102.1 → 0.103.1

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

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

@@ -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,65 @@
+# 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

@@ -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,51 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module Help
+      require_sub __FILE__, require_mode: :kernel
+      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

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module Input
+      STDIN_OPTION = '-'
+      BLANK_OPTION = '+'
+      DEFAULT_DEFAULT_INPUT_OPTION = BLANK_OPTION
+
+      common_concern do
+        enable_settings_provider
+        include ::EacCli::Runner
+
+        runner_definition do
+          arg_opt '-i', '--input', 'Input from file.'
+        end
+      end
+
+      def input_content
+        case input_option
+        when STDIN_OPTION then $stdin.read
+        when BLANK_OPTION then ''
+        else input_option.to_pathname.read
+        end
+      end
+
+      def input_option
+        parsed.input || setting_value(:default_input_option, default: DEFAULT_DEFAULT_INPUT_OPTION)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module Output
+      STDOUT_OPTION = '-'
+      DEFAULT_FILE_OPTION = '+'
+      DEFAULT_DEFAULT_OUTPUT_OPTION = STDOUT_OPTION
+      DEFAULT_DEFAULT_FILE_TO_OUTPUT = 'output'
+
+      common_concern do
+        enable_abstract_methods
+        enable_settings_provider
+        include ::EacCli::Runner
+
+        abstract_methods :output_content
+
+        runner_definition do
+          arg_opt '-o', '--output', 'Output to file.'
+        end
+      end
+
+      def run_output
+        file = file_to_output
+        if file
+          file.to_pathname.write(output_content)
+        else
+          $stdout.write(output_content)
+        end
+      end
+
+      def output_option
+        parsed.output || default_output_option_value
+      end
+
+      def file_to_output
+        case output_option
+        when STDOUT_OPTION then nil
+        when DEFAULT_FILE_OPTION then default_file_to_output_value
+        else output_option
+        end
+      end
+
+      def default_output_option_value
+        setting_value(:default_output_option,
+                      default: DEFAULT_DEFAULT_OUTPUT_OPTION)
+      end
+
+      def default_file_to_output_value
+        setting_value(:default_file_to_output, default: DEFAULT_DEFAULT_FILE_TO_OUTPUT)
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner_with/output_item/asciidoc_formatter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module EacCli
+  module RunnerWith
+    module OutputItem
+      class AsciidocFormatter < ::EacCli::RunnerWith::OutputItem::BaseFormatter
+        STARTING_LEVEL = 2
+
+        # @return [String]
+        def to_output
+          output_hash(item_hash, STARTING_LEVEL)
+        end
+
+        protected
+
+        # @param hash [Hash]
+        # @param level [Integer]
+        # @return [String]
+        def output_enumerable(enumerable, level)
+          enumerable.map { |e| output_object(e, level + 1) }.join
+        end
+
+        # @param hash [Hash]
+        # @param level [Integer]
+        # @return [String]
+        def output_hash(hash, level)
+          hash.map { |k, v| section(k, v, level) }.join("\n")
+        end
+
+        def output_object(object, level)
+          return output_hash(object, level) if object.is_a?(::Hash)
+          return output_enumerable(object, level) if object.is_a?(::Enumerable)
+
+          output_string(object, level)
+        end
+
+        # @param string [String]
+        # @param level [Integer]
+        # @return [String]
+        def output_string(string, _level)
+          "* #{string.to_s.strip}\n"
+        end
+
+        # @param title [String]
+        # @param content [String]
+        # @param level [Integer]
+        # @return [String]
+        def section(title, content, level)
+          "#{section_title(title, level)}\n\n#{section_content(content, level)}"
+        end
+
+        # @param title [String]
+        # @param level [Integer]
+        # @return [String]
+        def section_title(title, level)
+          "#{'=' * level} #{title}"
+        end
+
+        # @param content [String]
+        # @param level [Integer]
+        # @return [String]
+        def section_content(content, level)
+          output_object(content, level)
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner_with/output_item/base_formatter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module OutputItem
+      class BaseFormatter
+        acts_as_abstract :to_output
+        common_constructor :item_hash
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner_with/output_item/csv_formatter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module EacCli
+  module RunnerWith
+    module OutputItem
+      class CsvFormatter < ::EacCli::RunnerWith::OutputItem::BaseFormatter
+        COLUMNS = %w[key value].freeze
+
+        # @return [String]
+        def to_output
+          ::CSV.generate do |csv|
+            csv << COLUMNS
+            item_hash.each { |k, v| csv << [k, v] }
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner_with/output_item/yaml_formatter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module EacCli
+  module RunnerWith
+    module OutputItem
+      class YamlFormatter < ::EacCli::RunnerWith::OutputItem::BaseFormatter
+        # @return [String]
+        def to_output
+          ::YAML.dump(item_hash.deep_stringify_keys)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module OutputItem
+      require_sub __FILE__
+
+      FORMATS = %w[asciidoc csv yaml].freeze
+
+      common_concern do
+        acts_as_abstract :item_hash
+        include ::EacCli::RunnerWith::Output
+
+        runner_definition do
+          arg_opt '-f', '--format', 'Format to output item.', default: 'yaml'
+        end
+      end
+
+      # @return [String]
+      def output_content
+        formatter.to_output
+      end
+
+      # @return [EacCli::RunnerWith::OutputList::BaseFormatter]
+      def formatter
+        formatter_class.new(item_hash)
+      end
+
+      # @return [Class]
+      def formatter_class
+        formats.fetch(parsed.format)
+      end
+
+      # @return [Hash<String, Class>]
+      def formats
+        FORMATS.to_h do |e|
+          [e, ::EacCli::RunnerWith::OutputItem.const_get("#{e.camelize}Formatter")]
+        end
+      end
+
+      # @return [Hash<String, Enumerable<String>]
+      def help_extra_text
+        help_list_section('Formats', formats.keys.sort)
+      end
+    end
+  end
+end