eac_tools 0.123.0 → 0.123.1

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

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

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

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

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

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

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

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'csv'
-
-module EacCli
-  module RunnerWith
-    module OutputList
-      class CsvFormatter < ::EacCli::RunnerWith::OutputList::BaseFormatter
-        # @return [Array]
-        def build_row(row)
-          build_columns.map { |c| build_value(row, c) }
-        end
-
-        # @return [String]
-        def to_output
-          ::CSV.generate do |csv|
-            csv << build_columns
-            build_rows.each { |row| csv << row }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty/table'
-
-module EacCli
-  module RunnerWith
-    module OutputList
-      class TtyFormatter < ::EacCli::RunnerWith::OutputList::BaseFormatter
-        # @param row [Object]
-        # @return [Array]
-        def build_row(row)
-          build_columns.map { |c| build_value(row, c) }
-        end
-
-        # @return [String]
-        def to_output
-          "#{tty_table_output}\n"
-        end
-
-        # @return [TTY::Table]
-        def tty_table
-          ::TTY::Table.new(build_columns, build_rows)
-        end
-
-        # @return [String]
-        def tty_table_output
-          tty_table.render(:unicode, multiline: true) do |renderer|
-            renderer.border.separator = ->(row) { ((row + 1) % columns.count).zero? }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module EacCli
-  module RunnerWith
-    module OutputList
-      class YamlFormatter < ::EacCli::RunnerWith::OutputList::BaseFormatter
-        # @return [Hash<String, String>]
-        def build_row(row)
-          build_columns.inject({}) { |a, e| a.merge(e => build_value(row, e).to_s) }
-        end
-
-        # @return [String]
-        def to_output
-          ::YAML.dump(build_rows)
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module OutputList
-      FORMATS = {
-        'csv' => ::EacCli::RunnerWith::OutputList::CsvFormatter,
-        'tty' => ::EacCli::RunnerWith::OutputList::TtyFormatter,
-        'yaml' => ::EacCli::RunnerWith::OutputList::YamlFormatter
-      }.freeze
-
-      common_concern do
-        acts_as_abstract :list_columns, :list_rows
-        include ::EacCli::RunnerWith::Output
-
-        runner_definition do
-          arg_opt '-f', '--format', 'Format to output list.', default: 'yaml'
-        end
-      end
-
-      # @return [String]
-      def output_content
-        formatter.to_output
-      end
-
-      # @return [EacCli::RunnerWith::OutputList::BaseFormatter]
-      def formatter
-        formatter_class.new(list_columns, list_rows)
-      end
-
-      # @return [Class]
-      def formatter_class
-        FORMATS.fetch(parsed.format)
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner_with/subcommands/definition_concern.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Subcommands
-      module DefinitionConcern
-      end
-    end
-  end
-end

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

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  module RunnerWith
-    module Subcommands
-      class << self
-        delegate :runner?, to: :'::EacCli::Runner'
-
-        # @return [Hash<String, EacCli::Runner>]
-        def subcommands_from_module(a_module)
-          a_module.constants
-            .map { |name| [name.to_s.underscore.gsub('_', '-'), a_module.const_get(name)] }
-            .select { |c| runner?(c[1]) }
-            .to_h.with_indifferent_access
-        end
-      end
-
-      common_concern do
-        include ::EacCli::Runner
-        runner_definition.singleton_class
-          .include(::EacCli::RunnerWith::Subcommands::DefinitionConcern)
-      end
-
-      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
-
-      def available_subcommands
-        @available_subcommands ||= available_subcommands_auto.merge(available_subcommands_extra)
-      end
-
-      # @return [Hash<String, EacCli::Runner>]
-      def available_subcommands_auto
-        ::EacCli::RunnerWith::Subcommands.subcommands_from_module(self.class)
-      end
-
-      def available_subcommands_extra
-        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
-          send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
-        else
-          {}
-        end
-      end
-
-      def available_subcommands_to_s
-        available_subcommands.keys.sort.join(', ')
-      end
-
-      # @return [Hash<String, Enumerable<String>]
-      def help_extra_text
-        help_list_section('Subcommands', available_subcommands.keys.sort)
-      end
-
-      def method_missing(method_name, *, &)
-        return run_with_subcommand(*, &) if
-        run_with_subcommand_alias_run?(method_name)
-
-        super
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        run_with_subcommand_alias_run?(method_name) || super
-      end
-
-      def run_with_subcommand
-        if run_subcommand?
-          if subcommand_runner.respond_to?(:run_run)
-            subcommand_runner.run_run
-          else
-            subcommand_runner.run
-          end
-        else
-          run_without_subcommand
-        end
-      end
-
-      def run_with_subcommand_alias_run?(method_name)
-        subcommands? && method_name.to_sym == :run
-      end
-
-      def run_without_subcommand
-        "Method #{__method__} should be overrided in #{self.class.name}"
-      end
-
-      def run_subcommand?
-        subcommand_name.present?
-      end
-
-      def subcommands?
-        self.class.runner_definition.subcommands?
-      end
-
-      def subcommand_args
-        parsed.fetch(::EacCli::Definition::SUBCOMMAND_ARGS_ARG)
-      end
-
-      def subcommand_class
-        available_subcommands[subcommand_name].if_present { |v| return v }
-
-        raise(::EacCli::Parser::Error.new(
-                self.class.runner_definition, runner_context.argv,
-                "Subcommand \"#{subcommand_name}\" not found " \
-                "(Available: #{available_subcommands_to_s})"
-              ))
-      end
-
-      def subcommand_name
-        parsed.fetch(::EacCli::Definition::SUBCOMMAND_NAME_ARG)
-      end
-
-      def subcommand_program
-        [program_name, subcommand_name]
-      end
-
-      def subcommand_runner
-        @subcommand_runner ||= subcommand_class.create(
-          argv: subcommand_args,
-          program_name: subcommand_program,
-          parent: self
-        )
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner_with_set/from_gems_registry.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class RunnerWithSet
-    class FromGemsRegistry < ::EacCli::RunnerWithSet
-      enable_memoized
-
-      MODULE_SUFFIX = 'RunnerWith'
-
-      protected
-
-      # @return [EacRubyUtils::GemsRegistry]
-      memoize def gems_registry
-        ::EacRubyUtils::GemsRegistry.new(MODULE_SUFFIX)
-      end
-
-      # @return [Enumerable<Object>]
-      def namespace_set
-        super + gems_registry.registered.map(&:registered_module)
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/runner_with_set.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class RunnerWithSet
-    class << self
-      def default
-        @default ||= ::EacCli::RunnerWithSet::FromGemsRegistry.new
-      end
-    end
-
-    def add_namespace(namespace)
-      namespace = sanitize_namespace(namespace)
-      namespace_set << namespace unless namespace_set.include?(namespace)
-      self
-    end
-
-    def item_to_module(item)
-      item.is_a?(::Module) ? item : key_to_module(item)
-    end
-
-    def namespaces
-      namespace_set.dup
-    end
-
-    private
-
-    def namespace_set
-      @namespace_set ||= []
-    end
-
-    def key_to_module(key)
-      namespace_set.lazy
-        .map { |namespace| key_to_module_in_namespace(namespace, key) }
-        .find(&:present?) ||
-        raise("Not module found with key \"#{key}\" (Namespaces: #{namespace_set})")
-    end
-
-    def key_to_module_in_namespace(namespace, key)
-      leaf_name = key.to_s.camelize.to_sym
-      namespace.const_get(leaf_name)
-    rescue ::NameError => e
-      e.receiver == namespace && e.name == leaf_name ? nil : raise(e)
-    end
-
-    def sanitize_namespace(source)
-      source.is_a?(::Module) ? source : source.to_s.constantize
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/speaker/constants.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Speaker
-    module Constants
-      STDERR = ::EacRubyUtils::ByReference.new { $stderr }
-      STDIN = ::EacRubyUtils::ByReference.new { $stdin }
-      STDOUT = ::EacRubyUtils::ByReference.new { $stdout }
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/speaker/input_blocked.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Speaker
-    class InputBlocked
-      %w[gets noecho].each do |method|
-        define_method(method) do
-          raise ::EacCli::Speaker::InputRequested,
-                "Method (\"#{method}\") was requested, but input is blocked"
-        end
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/speaker/input_requested.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Speaker
-    class InputRequested < ::RuntimeError
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/speaker/list.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-
-module EacCli
-  class Speaker
-    class List
-      VALUE_STRUCT = ::Struct.new(:key, :label, :value)
-
-      class << self
-        # @param list [Array, Hash]
-        # @param options [Hash]
-        def build(list, options = {})
-          return List.new(hash_to_values(list), options) if list.is_a?(::Hash)
-          return List.new(array_to_values(list), options) if list.is_a?(::Array)
-
-          raise "Invalid list: #{list} (#{list.class})"
-        end
-
-        private
-
-        def hash_to_values(list)
-          list.map { |key, value| VALUE_STRUCT.new(key, key, value) }
-        end
-
-        def array_to_values(list)
-          list.map { |value| VALUE_STRUCT.new(value, value, value) }
-        end
-      end
-
-      DEFAULT_IGNORE_CASE = true
-
-      enable_listable
-      lists.add_symbol :option, :ignore_case
-
-      # @!attribute [r] values
-      #   @return [Array<VALUE_STRUCT>]
-      #   # @!attribute [r] options
-      #   @return [Hash]
-      # @!method initialize(values)
-      #   @param values [Array<VALUE_STRUCT>]
-      #   @param options [Hash]
-      common_constructor :values, :options, default: [{}] do
-        self.options = self.class.lists.option.hash_keys_validate!(options)
-        self.values = values.map do |v|
-          VALUE_STRUCT.new(to_key(v.key), to_label(v.label), v.value)
-        end
-      end
-
-      # @return [Boolean]
-      def ignore_case?
-        options.if_key(OPTION_IGNORE_CASE, DEFAULT_IGNORE_CASE, &:to_bool)
-      end
-
-      def valid_labels
-        values.map(&:label)
-      end
-
-      def valid_value?(value)
-        values.any? { |v| v.key == to_key(value) }
-      end
-
-      # @param value [Object]
-      # @return [String]
-      def to_key(value)
-        r = to_label(value)
-        ignore_case? ? r.downcase : r
-      end
-
-      def to_label(value)
-        value.to_s.strip
-      end
-
-      def build_value(value)
-        key = to_key(value)
-        values.each do |v|
-          return v.value if v.key == key
-        end
-        raise "Value not found: \"#{value}\" (#{values})"
-      end
-    end
-  end
-end

data/sub/eac_cli/lib/eac_cli/speaker/options.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class Speaker
-    module Options
-      common_concern do
-        enable_listable
-        lists.add_symbol :option, :out_out, :err_out, :in_in, :parent, :err_line_prefix,
-                         :ignore_case
-      end
-
-      def err_out
-        option(OPTION_ERR_OUT, $stderr)
-      end
-
-      def out_out
-        option(OPTION_OUT_OUT, $stdout)
-      end
-
-      def in_in
-        option(OPTION_IN_IN, $stdin)
-      end
-
-      # @return [Boolean]
-      def ignore_case
-        option(OPTION_IGNORE_CASE, nil)
-      end
-
-      def err_line_prefix
-        option(OPTION_ERR_LINE_PREFIX, '')
-      end
-
-      def parent
-        options[OPTION_PARENT]
-      end
-
-      def option(key, default)
-        options[key] || parent.if_present(default) { |v| v.send(__METHOD__) }
-      end
-    end
-  end
-end