eac_cli 0.16.3 → 0.20.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30d359d444a24b0a8f618b39e2630c1272b8e7eb372c5785641f3a64931cff93
-  data.tar.gz: 0e1391a2382ead2b2d2e3d15d0fc036cfb88f6bde71dac7fdf14bcd633cd57bf
+  metadata.gz: bc6dcd6871b0568383cc0780ac15f0733f44587081c293ddbac199ebda83ffd4
+  data.tar.gz: c7480fc2621cfa9a8c9e40e5784be7ac8a3e2763ba6cb9d289f68f4dc75b0a82
 SHA512:
-  metadata.gz: 0a2bb5941764c0c3172edec4468ec9c31c747eb6fdc899575504c43bd6354d361c33808af41b6dd6019e9c6331ffa2a96ec950bf71f33c0ec48d1c8433e7b194
-  data.tar.gz: bf0c7409ebb3db51fad860006e221730032da4c916d754fda5ace314f1a4d4f2894dbc3ad6a533584336cc039e6e775b09b746c74bd4f7aec79bb850ccb67224
+  metadata.gz: 4bb04ad2674595e31a3dbe906fba02c14c83875e099b4af39ff0e51153404bf97f99cd639716e9e7e9095289036f752e7aa6d0bd763c5339bbb6be03b6c587b5
+  data.tar.gz: a849110f05d77d66f92a1485e3c6529034c27332cdbeed8458f951a2dff522ac79b57979a78e8cb4d11d2053d838d6f7c377c578dc6c90304b0ced44648db34d

data/lib/eac_cli/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eac_config/envvars_node'
+require 'eac_config/yaml_file_node'
+
+module EacCli
+  class Config
+    require_sub __FILE__
+    attr_reader :sub
+
+    def initialize(sub_node)
+      @sub = sub_node
+    end
+
+    def entry(path, options = {})
+      ::EacCli::Config::Entry.new(self, path, options)
+    end
+  end
+end

data/lib/eac_cli/config/entry.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'eac_cli/speaker'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Config
+    class Entry
+      require_sub __FILE__, include_modules: true
+      enable_listable
+      enable_simple_cache
+      enable_speaker
+
+      common_constructor :config, :path, :options do
+        self.path = ::EacConfig::EntryPath.assert(path)
+        self.options = ::EacCli::Config::Entry::Options.new(options)
+      end
+
+      def value
+        return sub_value_to_return if sub_entry.found?
+        return nil unless options.required?
+
+        puts "|#{sub_entry.path}|"
+
+        input_value
+      end
+
+      delegate :value=, to: :sub_entry
+
+      private
+
+      def sub_value_to_return
+        sub_entry.value.presence || ::EacRubyUtils::BlankNotBlank.instance
+      end
+
+      def sub_entry_uncached
+        config.sub.entry(path)
+      end
+
+      def input_value_uncached
+        r = send("#{options.type}_value")
+        sub_entry.value = r if options.store?
+        r
+      end
+    end
+  end
+end

data/lib/eac_cli/config/entry/options.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Config
+    class Entry
+      class Options
+        enable_simple_cache
+        enable_listable
+
+        lists.add_symbol :type, :undefined
+
+        DEFAULT_VALUES = {
+          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
+          required: true, store: true, type: TYPE_UNDEFINED, validator: nil
+        }.freeze
+
+        lists.add_symbol :option, *DEFAULT_VALUES.keys
+
+        common_constructor :options do
+          self.options = self.class.lists.option.hash_keys_validate!(options)
+        end
+
+        delegate :to_h, to: :options
+
+        def [](key)
+          values.fetch(key.to_sym)
+        end
+
+        def request_input_options
+          values.slice(:bool, :list, :noecho)
+        end
+
+        DEFAULT_VALUES.each do |attr, default_value|
+          define_method(attr.to_s + ([true, false].include?(default_value) ? '?' : '')) do
+            self[attr]
+          end
+        end
+
+        private
+
+        def values_uncached
+          consumer = options.to_options_consumer
+          r = {}
+          DEFAULT_VALUES.each do |key, default_value|
+            value = consumer.consume(key)
+            value = default_value if value.nil?
+            r[key] = value
+          end
+          consumer.validate
+          r
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/config/entry/undefined.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Config
+    class Entry
+      module Undefined
+        private
+
+        def undefined_value
+          loop do
+            entry_value = undefined_value_no_loop
+            next unless options[:validator].if_present(true) { |v| v.call(entry_value) }
+
+            return entry_value
+          end
+        end
+
+        def undefined_value_no_loop
+          input("Value for entry \"#{path}\"", options.request_input_options)
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/default_runner.rb

@@ -7,7 +7,7 @@ module EacCli
   module DefaultRunner
     common_concern do
       include ::EacCli::RunnerWith::Help
-      enable_console_speaker
+      enable_speaker
       enable_simple_cache
     end
   end

data/lib/eac_cli/definition/help_formatter.rb

@@ -27,7 +27,7 @@ module EacCli
 
       def positional_argument(positional)
         if positional.subcommand?
-          ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+          ::EacCli::DocoptRunner::SUBCOMMANDS_MACRO
         else
           r = "<#{positional.name}>"
           r += '...' if positional.repeat?
@@ -52,7 +52,7 @@ module EacCli
       end
 
       def self_usage_arguments
-        [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+        [::EacCli::DocoptRunner::PROGRAM_MACRO] +
           definition.options_argument.if_present([]) { |_v| ['[options]'] } +
           self_usage_arguments_options +
           self_usage_arguments_positional

data/lib/eac_cli/definition/positional_argument.rb

@@ -6,9 +6,10 @@ module EacCli
   class Definition
     class PositionalArgument
       DEFAULT_REQUIRED = true
+      DEFAULT_VISIBLE = true
 
       enable_listable
-      lists.add_symbol :option, :optional, :repeat, :required, :subcommand
+      lists.add_symbol :option, :optional, :repeat, :required, :subcommand, :visible
       common_constructor :name, :options, default: [{}] do
         options.assert_valid_keys(self.class.lists.option.values)
       end
@@ -51,6 +52,10 @@ module EacCli
       def to_s
         "#{self.class.name.demodulize}[#{identifier}]"
       end
+
+      def visible?
+        options.key?(OPTION_VISIBLE) ? options.fetch(OPTION_VISIBLE) : DEFAULT_VISIBLE
+      end
     end
   end
 end

data/lib/eac_cli/docopt/doc_builder.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/docopt_runner'
 
 module EacCli
   module Docopt

data/lib/eac_cli/docopt/doc_builder/alternative.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/docopt_runner'
 
 module EacCli
   module Docopt
@@ -11,7 +11,7 @@ module EacCli
 
         def to_s
           (
-            [::EacRubyUtils::Console::DocoptRunner::PROGRAM_MACRO] +
+            [::EacCli::DocoptRunner::PROGRAM_MACRO] +
               alternative.options_argument?.if_present([]) { |_v| ['[options]'] } +
               options +
               positionals
@@ -31,12 +31,14 @@ module EacCli
         end
 
         def positionals
-          alternative.positional.map { |p| positional(p) }
+          alternative.positional.map { |p| positional(p) }.reject(&:blank?)
         end
 
         def positional(positional)
+          return unless positional.visible?
+
           if positional.subcommand?
-            ::EacRubyUtils::Console::DocoptRunner::SUBCOMMANDS_MACRO
+            ::EacCli::DocoptRunner::SUBCOMMANDS_MACRO
           else
             r = "<#{positional.name}>"
             r += '...' if positional.repeat?

data/lib/eac_cli/docopt/runner_extension.rb

@@ -3,7 +3,7 @@
 require 'eac_cli/docopt/doc_builder'
 require 'eac_cli/docopt/runner_context_replacement'
 require 'eac_cli/runner'
-require 'eac_ruby_utils/console/docopt_runner'
+require 'eac_cli/docopt_runner'
 
 module EacCli
   module Docopt
@@ -16,7 +16,7 @@ module EacCli
 
       class << self
         def check(klass)
-          return unless klass < ::EacRubyUtils::Console::DocoptRunner
+          return unless klass < ::EacCli::DocoptRunner
 
           ::EacCli::Runner.alias_runner_class_methods(klass, '', 'eac_cli')
           ::EacCli::Runner.alias_runner_class_methods(klass, 'original', '')

data/lib/eac_cli/docopt_runner.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'docopt'
+
+module EacCli
+  class DocoptRunner
+    require_sub __FILE__
+    extend ::EacCli::DocoptRunner::ClassMethods
+    include ::EacCli::DocoptRunner::Context
+
+    class << self
+      def create(settings = {})
+        new(settings)
+      end
+    end
+
+    attr_reader :settings
+
+    def initialize(settings = {})
+      @settings = settings.with_indifferent_access.freeze
+      check_subcommands
+    end
+
+    def options
+      @options ||= ::Docopt.docopt(target_doc, docopt_options)
+    end
+
+    def parent
+      settings[:parent]
+    end
+
+    protected
+
+    def docopt_options
+      settings.slice(:version, :argv, :help, :options_first).to_sym_keys_hash
+    end
+  end
+end

data/lib/eac_cli/docopt_runner/_doc.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacCli
+  class DocoptRunner
+    PROGRAM_MACRO = '__PROGRAM__'
+
+    def source_doc
+      setting_value(:doc)
+    end
+
+    def target_doc
+      source_doc.gsub(PROGRAM_MACRO, target_program_name).strip + "\n"
+    end
+
+    def source_program_name
+      setting_value(:program_name, false)
+    end
+
+    def target_program_name
+      [source_program_name, ENV['PROGRAM_NAME'], $PROGRAM_NAME].find(&:present?)
+    end
+  end
+end

data/lib/eac_cli/docopt_runner/_settings.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/settings_provider'
+
+module EacCli
+  class DocoptRunner
+    include ::EacRubyUtils::SettingsProvider
+
+    attr_reader :settings
+
+    private
+
+    def setting_value(key, required = true)
+      super(key, required: required, order: %w[method settings_object constant])
+    end
+  end
+end

data/lib/eac_cli/docopt_runner/_subcommands.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'shellwords'
+
+module EacCli
+  class DocoptRunner
+    SUBCOMMAND_ARG = '<subcommand>'
+    SUBCOMMAND_ARGS_ARG = '<subcommand-args>'
+    SUBCOMMANDS_MACRO = '__SUBCOMMANDS__'
+
+    def subcommands?
+      source_doc.include?(SUBCOMMANDS_MACRO)
+    end
+
+    def check_subcommands
+      return unless subcommands?
+
+      singleton_class.include(SubcommandsSupport)
+      check_subcommands_arg
+      return if singleton_class.method_defined?(:run)
+
+      singleton_class.send(:alias_method, :run, :run_with_subcommand)
+    end
+
+    module SubcommandsSupport
+      EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME = :extra_available_subcommands
+
+      def check_subcommands_arg
+        if subcommand_arg_as_list?
+          singleton_class.include(SubcommandsSupport::SubcommandArgAsList)
+        else
+          singleton_class.include(SubcommandsSupport::SubcommandArgAsArg)
+        end
+      end
+
+      def run_with_subcommand
+        if subcommand_name
+          check_valid_subcommand
+          subcommand_run
+        else
+          run_without_subcommand
+        end
+      end
+
+      def subcommand
+        @subcommand ||= subcommand_class_name(subcommand_name).constantize.create(
+          argv: subcommand_args,
+          program_name: subcommand_program,
+          parent: self
+        )
+      end
+
+      def subcommand_run
+        if !subcommand.is_a?(::EacCli::DocoptRunner) &&
+           subcommand.respond_to?(:run_run)
+          subcommand.run_run
+        else
+          subcommand.run
+        end
+      end
+
+      def target_doc
+        super.gsub(SUBCOMMANDS_MACRO,
+                   "#{target_doc_subcommand_arg} [#{SUBCOMMAND_ARGS_ARG}...]") +
+          "\n" + subcommands_target_doc
+      end
+
+      def docopt_options
+        super.merge(options_first: true)
+      end
+
+      def subcommand_class_name(subcommand)
+        "#{self.class.name}::#{subcommand.underscore.camelize}"
+      end
+
+      def subcommand_arg_as_list?
+        setting_value(:subcommand_arg_as_list, false) || false
+      end
+
+      def subcommand_args
+        options.fetch(SUBCOMMAND_ARGS_ARG)
+      end
+
+      def subcommand_program
+        subcommand_name
+      end
+
+      def available_subcommands
+        r = ::Set.new(setting_value(:subcommands, false) || auto_available_subcommands)
+        if respond_to?(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME, true)
+          r += send(EXTRA_AVAILABLE_SUBCOMMANDS_METHOD_NAME)
+        end
+        r.sort
+      end
+
+      def auto_available_subcommands
+        self.class.constants
+            .map { |name| self.class.const_get(name) }
+            .select { |c| c.instance_of? Class }
+            .select { |c| c < ::EacCli::DocoptRunner }
+            .map { |c| c.name.demodulize.underscore.dasherize }
+      end
+
+      def run_without_subcommand
+        "Method #{__method__} should be overrided in #{self.class.name}"
+      end
+
+      protected
+
+      def check_valid_subcommand
+        return if available_subcommands.include?(subcommand_name)
+
+        raise ::Docopt::Exit, "\"#{subcommand_name}\" is not a valid subcommand" \
+          " (Valid: #{available_subcommands.join(', ')})"
+      end
+
+      module SubcommandArgAsArg
+        def target_doc_subcommand_arg
+          SUBCOMMAND_ARG
+        end
+
+        def subcommand_name
+          options.fetch(SUBCOMMAND_ARG)
+        end
+
+        def subcommands_target_doc
+          available_subcommands.inject("Subcommands:\n") do |a, e|
+            a + "  #{e}\n"
+          end
+        end
+      end
+
+      module SubcommandArgAsList
+        def target_doc_subcommand_arg
+          '(' + available_subcommands.join('|') + ')'
+        end
+
+        def subcommand_name
+          available_subcommands.each do |subcommand|
+            return subcommand if options.fetch(subcommand)
+          end
+          nil
+        end
+
+        def subcommands_target_doc
+          "\n"
+        end
+      end
+    end
+  end
+end

data/lib/eac_cli/docopt_runner/class_methods.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'docopt'
+
+module EacCli
+  class DocoptRunner
+    module ClassMethods
+      DOCOPT_ERROR_EXIT_CODE = 0xC0
+
+      def run(options = {})
+        create(options).send(:run)
+      rescue ::Docopt::Exit => e
+        STDERR.write(e.message + "\n")
+        ::Kernel.exit(DOCOPT_ERROR_EXIT_CODE)
+      end
+    end
+  end
+end

data/lib/eac_cli/docopt_runner/context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EacCli
+  class DocoptRunner
+    # Provides the method context which search and call a method in self and ancestor objects.
+    module Context
+      def context(method)
+        current = self
+        while current
+          return current.send(method) if current.respond_to?(method)
+
+          current = current.respond_to?(:parent) ? current.parent : nil
+        end
+        raise "Context method \"#{method}\" not found for #{self.class}"
+      end
+    end
+  end
+end

data/lib/eac_cli/old_configs.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class OldConfigs
+    require_sub __FILE__
+    enable_speaker
+
+    class << self
+      def entry_key_to_envvar_name(entry_key)
+        ::EacCli::OldConfigs::EntryReader.entry_key_to_envvar_name(entry_key)
+      end
+    end
+
+    attr_reader :configs
+
+    def initialize(configs_key, options = {})
+      options.assert_argument(::Hash, 'options')
+      @configs = ::EacConfig::OldConfigs.new(configs_key, options.merge(autosave: true))
+    end
+
+    def read_password(entry_key, options = {})
+      ::EacCli::OldConfigs::PasswordEntryReader.new(self, entry_key, options).read
+    end
+
+    def read_entry(entry_key, options = {})
+      ::EacCli::OldConfigs::EntryReader.new(self, entry_key, options).read
+    end
+
+    def store_passwords?
+      ::EacCli::OldConfigs::StorePasswordsEntryReader.new(self) == 'yes'
+    end
+  end
+end

data/lib/eac_cli/old_configs/entry_reader.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'eac_cli/old_configs/read_entry_options'
+require 'eac_config/paths_hash'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class OldConfigs
+    class EntryReader
+      enable_speaker
+
+      class << self
+        def entry_key_to_envvar_name(entry_key)
+          path = if entry_key.is_a?(::Array)
+                   entry_key
+                 else
+                   ::EacConfig::PathsHash.parse_entry_key(entry_key)
+                 end
+          path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
+              .gsub(/_{2,}/, '_').upcase
+        end
+      end
+
+      common_constructor :console_configs, :entry_key, :options do
+        self.options = ::EacCli::OldConfigs::ReadEntryOptions.new(options)
+      end
+
+      def read
+        %w[envvars storage console].each do |suffix|
+          value = send("read_from_#{suffix}")
+          return value if value.present?
+        end
+        return nil unless options[:required]
+
+        raise "No value found for entry \"#{entry_key}\""
+      end
+
+      def read_from_storage
+        console_configs.configs.read_entry(entry_key)
+      end
+
+      def read_from_envvars
+        return if options[:noenv]
+
+        env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
+        return unless ENV.key?(env_entry_key)
+
+        ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
+      end
+
+      def read_from_console
+        return if options[:noinput]
+
+        options[:before_input].if_present(&:call)
+        entry_value = looped_entry_value_from_input
+        console_configs.configs.write_entry(entry_key, entry_value) if options[:store]
+        entry_value
+      end
+
+      private
+
+      def looped_entry_value_from_input
+        loop do
+          entry_value = entry_value_from_input(entry_key, options)
+          next if entry_value.blank?
+          next if options[:validator] && !options[:validator].call(entry_value)
+
+          return entry_value
+        end
+      end
+
+      def entry_value_from_input(entry_key, options)
+        entry_value = input("Value for entry \"#{entry_key}\"",
+                            options.request_input_options)
+        warn('Entered value is blank') if entry_value.blank?
+        entry_value
+      end
+    end
+  end
+end

data/lib/eac_cli/old_configs/password_entry_reader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_cli/old_configs/entry_reader'
+
+module EacCli
+  class OldConfigs
+    class PasswordEntryReader < ::EacCli::OldConfigs::EntryReader
+      ENTRY_KEY = 'core.store_passwords'
+
+      def initialize(console_configs, entry_key, options = {})
+        super(console_configs, entry_key, options.merge(noecho: true,
+                                                        store: console_configs.store_passwords?))
+      end
+    end
+  end
+end

data/lib/eac_cli/old_configs/read_entry_options.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class OldConfigs
+    class ReadEntryOptions
+      enable_simple_cache
+      common_constructor :options do
+        self.options = options.to_h.symbolize_keys
+                              .assert_valid_keys(DEFAULT_VALUES.keys).freeze
+      end
+
+      DEFAULT_VALUES = {
+        before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
+        required: true, store: true, validator: nil
+      }.freeze
+
+      delegate :to_h, to: :options
+
+      def [](key)
+        values.fetch(key.to_sym)
+      end
+
+      def request_input_options
+        values.slice(:bool, :list, :noecho)
+      end
+
+      private
+
+      def values_uncached
+        consumer = options.to_options_consumer
+        r = {}
+        DEFAULT_VALUES.each do |key, default_value|
+          value = consumer.consume(key)
+          value = default_value if value.nil?
+          r[key] = value
+        end
+        consumer.validate
+        r
+      end
+    end
+  end
+end

data/lib/eac_cli/old_configs/store_passwords_entry_reader.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_cli/old_configs/entry_reader'
+
+module EacCli
+  class OldConfigs
+    class StorePasswordsEntryReader < ::EacCli::OldConfigs::EntryReader
+      ENTRY_KEY = 'core.store_passwords'
+
+      def initialize(console_configs)
+        super(console_configs, ENTRY_KEY,
+          before_input: -> { banner },
+          validator: ->(entry_value) { %w[yes no].include?(entry_value) }
+        )
+      end
+
+      def banner
+        infom 'Do you wanna to store passwords?'
+        infom 'Warning: the passwords will be store in clear text in ' \
+          "\"#{console_configs.configs.storage_path}\""
+        infom 'Enter "yes" or "no"'
+      end
+    end
+  end
+end

data/lib/eac_cli/old_configs_bridge.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_cli/config'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class OldConfigsBridge < ::EacCli::Config
+    ENTRY_KEY = 'core.store_passwords'
+
+    class << self
+      def new_configs_path(configs_key, options)
+        options[:storage_path] || ::File.join(ENV['HOME'], '.config', configs_key, 'settings.yml')
+      end
+    end
+
+    def initialize(configs_key, options = {})
+      options.assert_argument(::Hash, 'options')
+      envvar_node = ::EacConfig::EnvvarsNode.new
+      file_node = ::EacConfig::YamlFileNode.new(self.class.new_configs_path(configs_key, options))
+      envvar_node.load_path.push(file_node.url)
+      envvar_node.write_node = file_node
+      super(envvar_node)
+    end
+
+    def read_entry(entry_key, options = {})
+      entry(entry_key, options).value
+    end
+
+    def read_password(entry_key, options = {})
+      entry(entry_key, options.merge(noecho: true, store: store_passwords?)).value
+    end
+
+    def store_passwords?
+      read_entry(ENTRY_KEY, bool: true)
+    end
+  end
+end

data/lib/eac_cli/patches/object/runner_with.rb

@@ -9,7 +9,7 @@ class Object
   def runner_with(*runners, &block)
     include ::EacCli::Runner
     enable_simple_cache
-    enable_console_speaker
+    enable_speaker
     runners.each do |runner|
       include ::EacCli::RunnerWithSet.default.item_to_module(runner)
     end

data/lib/eac_cli/runner_with/help.rb

@@ -10,8 +10,8 @@ module EacCli
         include ::EacCli::Runner
 
         runner_definition.alt do
-          options_argument false
           bool_opt '-h', '--help', 'Show help.', usage: true
+          pos_arg :any_arg_with_help, repeat: true, optional: true, visible: false
         end
 
         set_callback :run, :before do
@@ -20,7 +20,7 @@ module EacCli
       end
 
       def help_run
-        return unless parsed.help?
+        return unless show_help?
 
         puts help_text
         raise ::EacCli::Runner::Exit
@@ -31,6 +31,10 @@ module EacCli
         r += help_extra_text if respond_to?(:help_extra_text)
         r
       end
+
+      def show_help?
+        parsed.help? && !if_respond(:run_subcommand?, false)
+      end
     end
   end
 end

data/lib/eac_cli/runner_with/subcommands.rb

@@ -6,16 +6,20 @@ require 'eac_ruby_utils/core_ext'
 module EacCli
   module RunnerWith
     module Subcommands
+      require_sub __FILE__
+
       class << self
         def runner?(object)
           ::EacCli::Runner.runner?(object) || (
-            object.is_a?(::Class) && object < ::EacRubyUtils::Console::DocoptRunner
+            object.is_a?(::Class) && object < ::EacCli::DocoptRunner
           )
         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
@@ -56,7 +60,7 @@ module EacCli
       end
 
       def run_with_subcommand
-        if subcommand_name
+        if run_subcommand?
           if subcommand_runner.respond_to?(:run_run)
             subcommand_runner.run_run
           else
@@ -75,6 +79,10 @@ module EacCli
         "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

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

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

data/lib/eac_cli/speaker.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/speaker/receiver'
+
+module EacCli
+  class Speaker
+    require_sub __FILE__, include_modules: true
+    include ::EacRubyUtils::Speaker::Receiver
+
+    common_constructor :options, default: [{}] do
+      self.options = self.class.lists.option.hash_keys_validate!(options)
+    end
+
+    def puts(string = '')
+      string.to_s.each_line do |line|
+        err_out.puts(err_line_prefix.to_s + line)
+      end
+    end
+
+    def out(string = '')
+      out_out.write(string.to_s)
+    end
+
+    def fatal_error(string)
+      puts "ERROR: #{string}".white.on_red
+      Kernel.exit 1
+    end
+
+    def title(string)
+      string = string.to_s
+      puts(('-' * (8 + string.length)).green)
+      puts("--- #{string} ---".green)
+      puts(('-' * (8 + string.length)).green)
+      puts
+    end
+
+    def info(string)
+      puts string.to_s.white
+    end
+
+    def infom(string)
+      puts string.to_s.light_yellow
+    end
+
+    def warn(string)
+      puts string.to_s.yellow
+    end
+
+    # Options:
+    #   +bool+ ([Boolean], default: +false+): requires a answer "yes" or "no".
+    #   +list+ ([Hash] or [Array], default: +nil+): requires a answer from a list.
+    #   +noecho+ ([Boolean], default: +false+): does not output answer.
+    def input(question, options = {})
+      bool, list, noecho = options.to_options_consumer.consume_all(:bool, :list, :noecho)
+      if list
+        request_from_list(question, list, noecho)
+      elsif bool
+        request_from_bool(question, noecho)
+      else
+        request_string(question, noecho)
+      end
+    end
+
+    def infov(*args)
+      r = []
+      args.each_with_index do |v, i|
+        if i.even?
+          r << "#{v}: ".cyan
+        else
+          r.last << v.to_s
+        end
+      end
+      puts r.join(', ')
+    end
+
+    def success(string)
+      puts string.to_s.green
+    end
+
+    private
+
+    def list_value(list, input)
+      values = list_values(list)
+      return input, true unless values
+      return input, false unless values.include?(input)
+    end
+
+    def list_values(list)
+      if list.is_a?(::Hash)
+        list.keys.map(&:to_s)
+      elsif list.is_a?(::Array)
+        list.map(&:to_s)
+      end
+    end
+
+    def request_from_bool(question, noecho)
+      request_from_list(question, { yes: true, y: true, no: false, n: false }, noecho)
+    end
+
+    def request_from_list(question, list, noecho)
+      list = ::EacCli::Speaker::List.build(list)
+      loop do
+        input = request_string("#{question} [#{list.valid_labels.join('/')}]", noecho)
+        return list.build_value(input) if list.valid_value?(input)
+
+        warn "Invalid input: \"#{input}\" (Valid: #{list.valid_labels.join(', ')})"
+      end
+    end
+
+    def request_string(question, noecho)
+      err_out.write "#{question}: ".to_s.yellow
+      noecho ? request_string_noecho : request_string_echo
+    end
+
+    def request_string_noecho
+      r = in_in.noecho(&:gets).chomp.strip
+      err_out.write("\n")
+      r
+    end
+
+    def request_string_echo
+      in_in.gets.chomp.strip
+    end
+  end
+end

data/lib/eac_cli/speaker/_constants.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/by_reference'
+
+module EacCli
+  # https://github.com/fazibear/colorize
+  class Speaker
+    STDERR = ::EacRubyUtils::ByReference.new { $stderr }
+    STDIN = ::EacRubyUtils::ByReference.new { $stdin }
+    STDOUT = ::EacRubyUtils::ByReference.new { $stdout }
+  end
+end

data/lib/eac_cli/speaker/list.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'ostruct'
+
+module EacCli
+  class Speaker
+    class List
+      class << self
+        def build(list)
+          return List.new(hash_to_values(list)) if list.is_a?(::Hash)
+          return List.new(array_to_values(list)) if list.is_a?(::Array)
+
+          raise "Invalid list: #{list} (#{list.class})"
+        end
+
+        private
+
+        def hash_to_values(list)
+          list.map { |key, value| ::OpenStruct.new(key: key, label: key, value: value) }
+        end
+
+        def array_to_values(list)
+          list.map { |value| ::OpenStruct.new(key: value, label: value, value: value) }
+        end
+      end
+
+      attr_reader :values
+
+      def initialize(values)
+        @values = values.map do |v|
+          ::OpenStruct.new(key: to_key(v.key), label: to_label(v.label), value: v.value)
+        end
+      end
+
+      def valid_labels
+        values.map(&:label)
+      end
+
+      def valid_value?(value)
+        values.any? { |v| v.key == to_key(value) }
+      end
+
+      def to_key(value)
+        to_label(value).downcase
+      end
+
+      def to_label(value)
+        value.to_s.strip
+      end
+
+      def build_value(value)
+        key = to_key(value)
+        values.each do |v| # rubocop:disable Style/HashEachMethods
+          return v.value if v.key == key
+        end
+        raise "Value not found: \"#{value}\" (#{values})"
+      end
+    end
+  end
+end

data/lib/eac_cli/speaker/options.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+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
+      end
+
+      def err_out
+        option(OPTION_ERR_OUT, ::EacCli::Speaker::STDERR)
+      end
+
+      def out_out
+        option(OPTION_OUT_OUT, ::EacCli::Speaker::STDOUT)
+      end
+
+      def in_in
+        option(OPTION_IN_IN, ::EacCli::Speaker::STDIN)
+      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

data/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.16.3'
+  VERSION = '0.20.1'
 end

metadata

@@ -1,29 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: eac_cli
 version: !ruby/object:Gem::Version
-  version: 0.16.3
+  version: 0.20.1
 platform: ruby
 authors:
 - Esquilo Azul Company
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-06 00:00:00.000000000 Z
+date: 2021-06-11 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: docopt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: eac_config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: eac_ruby_utils
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.55'
+        version: '0.67'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.55'
+        version: '0.67'
 - !ruby/object:Gem::Dependency
   name: eac_ruby_gem_support
   requirement: !ruby/object:Gem::Requirement
@@ -46,6 +88,10 @@ extra_rdoc_files: []
 files:
 - Gemfile
 - lib/eac_cli.rb
+- lib/eac_cli/config.rb
+- lib/eac_cli/config/entry.rb
+- lib/eac_cli/config/entry/options.rb
+- lib/eac_cli/config/entry/undefined.rb
 - lib/eac_cli/core_ext.rb
 - lib/eac_cli/default_runner.rb
 - lib/eac_cli/definition.rb
@@ -60,6 +106,18 @@ files:
 - lib/eac_cli/docopt/doc_builder/alternative.rb
 - lib/eac_cli/docopt/runner_context_replacement.rb
 - lib/eac_cli/docopt/runner_extension.rb
+- lib/eac_cli/docopt_runner.rb
+- lib/eac_cli/docopt_runner/_doc.rb
+- lib/eac_cli/docopt_runner/_settings.rb
+- lib/eac_cli/docopt_runner/_subcommands.rb
+- lib/eac_cli/docopt_runner/class_methods.rb
+- lib/eac_cli/docopt_runner/context.rb
+- lib/eac_cli/old_configs.rb
+- lib/eac_cli/old_configs/entry_reader.rb
+- lib/eac_cli/old_configs/password_entry_reader.rb
+- lib/eac_cli/old_configs/read_entry_options.rb
+- lib/eac_cli/old_configs/store_passwords_entry_reader.rb
+- lib/eac_cli/old_configs_bridge.rb
 - lib/eac_cli/parser.rb
 - lib/eac_cli/parser/alternative.rb
 - lib/eac_cli/parser/alternative/argv.rb
@@ -82,7 +140,12 @@ files:
 - lib/eac_cli/runner_with.rb
 - lib/eac_cli/runner_with/help.rb
 - lib/eac_cli/runner_with/subcommands.rb
+- lib/eac_cli/runner_with/subcommands/definition_concern.rb
 - lib/eac_cli/runner_with_set.rb
+- lib/eac_cli/speaker.rb
+- lib/eac_cli/speaker/_constants.rb
+- lib/eac_cli/speaker/list.rb
+- lib/eac_cli/speaker/options.rb
 - lib/eac_cli/version.rb
 homepage: 
 licenses: []