eac_tools 0.121.0 → 0.123.0

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

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'clipboard'
+
+module EacCli
+  module RunnerWith
+    module Input
+      CLIPBOARD_OPTION = '!'
+      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 CLIPBOARD_OPTION then ::Clipboard.paste
+        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/clipboard_writer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'clipboard'
+
+module EacCli
+  module RunnerWith
+    module Output
+      class ClipboardWriter
+        def write(content)
+          ::Clipboard.copy(content)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module Output
+      CLIPBOARD_OPTION = '!'
+      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
+        object_to_write.write(output_content)
+      end
+
+      def output_option
+        parsed.output || default_output_option_value
+      end
+
+      def object_to_write
+        case output_option
+        when CLIPBOARD_OPTION then ::EacCli::RunnerWith::Output::ClipboardWriter.new
+        when STDOUT_OPTION then $stdout
+        when DEFAULT_FILE_OPTION then default_file_to_output_value
+        else output_option.to_pathname
+        end
+      end
+
+      def default_output_option_value
+        setting_value(:default_output_option,
+                      default: DEFAULT_DEFAULT_OUTPUT_OPTION)
+      end
+
+      # @return [Pathname]
+      def default_file_to_output_value
+        setting_value(:default_file_to_output, default: DEFAULT_DEFAULT_FILE_TO_OUTPUT).to_pathname
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module OutputItem
+      class AsciidocFormatter < ::EacCli::RunnerWith::OutputItem::BaseFormatter
+        class Section
+          acts_as_instance_method
+          common_constructor :caller, :title, :content, :level
+
+          # @return [String]
+          def result
+            "#{formatted_title}#{formatted_content}"
+          end
+
+          protected
+
+          # @return [String]
+          def formatted_title
+            title.if_present('') { |_e| "#{'=' * level} #{title}\n\n" }
+          end
+
+          # @return [String]
+          def formatted_content
+            caller.send(:output_object, content, level + 1)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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
+
+        require_sub __FILE__, require_mode: :kernel
+      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,45 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module OutputItem
+      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

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module EacCli
+  module RunnerWith
+    module OutputList
+      class BaseFormatter
+        acts_as_abstract :to_output
+        common_constructor :columns, :rows
+
+        # @return [String]
+        def build_column(column)
+          column.to_s
+        end
+
+        # @return [Array<String>]
+        def build_columns
+          columns.map(&:to_s)
+        end
+
+        # @param row [Object]
+        # @return [Object]
+        def build_row(_row)
+          raise_abstract_method __method__
+        end
+
+        # @return [Array<Hash<String, String>>]
+        def build_rows
+          rows.map { |row| build_row(row) }
+        end
+
+        # @param row [Object]
+        # @param column [String]
+        # @return [Object]
+        def build_value(row, column)
+          return row.send(column) if row.respond_to?(column)
+          return row.with_indifferent_access.fetch(column) if row.is_a?(::Hash)
+
+          raise ::ArgumentError, "Row \"#{row}\" do not respond to column \"#{column}\" neither " \
+                                 "is a Hash (Row: #{row}, Column: #{column})"
+        end
+      end
+    end
+  end
+end