eac_tools 0.106.0 → 0.106.1

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

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

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

@@ -1,52 +0,0 @@
-# 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.rb

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

@@ -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, *arguments, &block)
-        return run_with_subcommand(*arguments, &block) 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,14 +0,0 @@
-# frozen_string_literal: true
-
-module EacCli
-  class RunnerWithSet
-    class FromGemsRegistry < ::EacCli::RunnerWithSet
-      protected
-
-      # @return [Enumerable<Object>]
-      def namespace_set
-        super + ::EacRubyUtils::GemsRegistry.new('RunnerWith').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