eac_cli 0.15.1 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9c71ba3fe820b38f1035645aeaf566d8f157d7dd5fb8333e8dbe7699ae0a7bd
-  data.tar.gz: f7c73dc103dda6e0de304e82ec7e0502fdc3d14b0280b04609827b4dff0ad48d
+  metadata.gz: be83e696754b3da778f4f01601dab1b68e6dc34248bfa70f3fc669ad102d7941
+  data.tar.gz: de452af57c0c3b0609884f82c1aed57878cae0df13f9c1628ded0b2918d20746
 SHA512:
-  metadata.gz: a3d3011de5128efe2c9064f3d732a3ef82f55db3d0e03d69f313894e3f859b209860953063175b590f47f2504b6c687d8e0dd25b3599d239797e77c97e01a6af
-  data.tar.gz: 1b3dbc452801a7a3ce0324b4d28d90d9c2349fe01841d029594afc5fa027cd2403f583595773a55567f82264601540bae8e9bb64725d77035343083f77e8617e
+  metadata.gz: da02c87bffd576e6abe4dc4c143c5ba89a1e5eadf9215b8665e993ff5413eedc345ed8444e2fc9a549f4af757fb0368fe97d15999f65753fde62479ae70ebef6
+  data.tar.gz: b865a33fe9660b7eaa4fc118985ef34ae289bf5593f9799e4b8274ec8694b5d5a32c895f9a30a35d74d8296c410ca6e144cc97c3a232abe18d3d6876a3f0ccb9

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/base_option.rb

@@ -28,7 +28,11 @@ module EacCli
       end
 
       def identifier
-        long.to_s.variableize.to_sym
+        [long, short].each do |v|
+          v.to_s.if_present { |vv| return vv.variableize.to_sym }
+        end
+
+        raise 'No short or long option to build identifier'
       end
 
       def repeat?

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/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
@@ -36,7 +36,9 @@ module EacCli
       end
 
       def option_definition(option)
-        self.class.option_usage_full(option) + OPTION_DESC_SEP + option.description
+        self.class.option_usage_full(option) + option.description.if_present('') do |v|
+          OPTION_DESC_SEP + v
+        end
       end
 
       def section(header, include_header = true)

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
@@ -36,7 +36,7 @@ module EacCli
 
         def positional(positional)
           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,43 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/slice'
+require 'docopt'
+require 'eac_ruby_utils/contextualizable'
+require 'eac_ruby_utils/patches/hash/sym_keys_hash'
+Dir["#{__dir__}/#{::File.basename(__FILE__, '.*')}/_*.rb"].sort.each do |partial|
+  require partial
+end
+
+module EacCli
+  class DocoptRunner
+    include ::EacRubyUtils::Contextualizable
+
+    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/_class_methods.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module EacCli
+  class DocoptRunner
+    DOCOPT_ERROR_EXIT_CODE = 0xC0
+
+    class << self
+      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/_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/old_configs.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/patches/module/speaker'
+
+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 = request_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/patches/module.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub(__FILE__)

data/lib/eac_cli/patches/module/speaker.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_cli/speaker'
+require 'eac_ruby_utils/patch'
+
+class Module
+  def enable_speaker
+    ::EacRubyUtils.patch(self, ::EacCli::Speaker)
+  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/context.rb

@@ -27,8 +27,9 @@ module EacCli
 
       def parent_call(method_name, *args)
         return parent.context(method_name, *args) if parent.respond_to?(:context)
+        return parent.runner_context.call(method_name, *args) if parent.respond_to?(:runner_context)
 
-        parent.runner_context.call(method_name, *args)
+        raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"
       end
     end
   end

data/lib/eac_cli/runner/instance_methods.rb

@@ -3,15 +3,22 @@
 module EacCli
   module Runner
     module InstanceMethods
+      PARSER_ERROR_EXIT_CODE = 1
+
       def run_run
         parsed
         run_callbacks(:run) { run }
       rescue ::EacCli::Parser::Error => e
-        $stderr.write("#{e}\n")
+        run_parser_error(e)
       rescue ::EacCli::Runner::Exit # rubocop:disable Lint/SuppressedException
         # Do nothing
       end
 
+      def run_parser_error(error)
+        $stderr.write("#{error}\n")
+        ::Kernel.exit(PARSER_ERROR_EXIT_CODE)
+      end
+
       def runner_context
         return @runner_context if @runner_context
 

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

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,131 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'io/console'
+require 'eac_ruby_utils/patches/hash/options_consumer'
+require 'eac_ruby_utils/require_sub'
+::EacRubyUtils.require_sub __FILE__
+
+module EacCli
+  # https://github.com/fazibear/colorize
+  module Speaker
+    def on_speaker_node(&block)
+      ::EacCli::Speaker.on_node(&block)
+    end
+
+    def puts(string = '')
+      string.to_s.each_line do |line|
+        current_node.stderr.puts(current_node.stderr_line_prefix.to_s + line)
+      end
+    end
+
+    def out(string = '')
+      current_node.stdout.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 request_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)
+      current_node.stderr.write "#{question}: ".to_s.yellow
+      noecho ? request_string_noecho : request_string_echo
+    end
+
+    def request_string_noecho
+      r = current_node.stdin.noecho(&:gets).chomp.strip
+      current_node.stderr.write("\n")
+      r
+    end
+
+    def request_string_echo
+      current_node.stdin.gets.chomp.strip
+    end
+
+    def current_node
+      ::EacCli::Speaker.current_node
+    end
+  end
+end

data/lib/eac_cli/speaker/_class_methods.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_cli/speaker/node'
+
+module EacCli
+  module Speaker
+    class << self
+      def current_node
+        nodes_stack.last
+      end
+
+      def on_node(&block)
+        push
+        yield(*(block.arity.zero? ? [] : [current_node]))
+      ensure
+        pop
+      end
+
+      def push
+        nodes_stack << ::EacCli::Speaker::Node.new
+        current_node
+      end
+
+      def pop
+        return nodes_stack.pop if nodes_stack.count > 1
+
+        raise "Cannot remove first node (nodes_stack.count: #{nodes_stack.count})"
+      end
+
+      private
+
+      def nodes_stack
+        @nodes_stack ||= [::EacCli::Speaker::Node.new]
+      end
+    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
+  module 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
+  module 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/node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/object/if_present'
+require 'eac_cli/speaker/_constants'
+
+module EacCli
+  module Speaker
+    class Node
+      attr_accessor :stdin, :stdout, :stderr, :stderr_line_prefix
+
+      def initialize(parent = nil)
+        self.stdin = parent.if_present(::EacCli::Speaker::STDIN, &:stdin)
+        self.stdout = parent.if_present(::EacCli::Speaker::STDOUT, &:stdout)
+        self.stderr = parent.if_present(::EacCli::Speaker::STDERR, &:stderr)
+        self.stderr_line_prefix = parent.if_present('', &:stderr_line_prefix)
+      end
+
+      def configure
+        yield(self)
+        self
+      end
+    end
+  end
+end

data/lib/eac_cli/version.rb

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

metadata

@@ -1,49 +1,85 @@
 --- !ruby/object:Gem::Specification
 name: eac_cli
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.17.0
 platform: ruby
 authors:
 - Esquilo Azul Company
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-21 00:00:00.000000000 Z
+date: 2021-05-23 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.64'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.55'
+        version: '0.64'
 - !ruby/object:Gem::Dependency
   name: eac_ruby_gem_support
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: '0.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.2
+        version: '0.2'
 description: 
 email: 
 executables: []
@@ -66,6 +102,16 @@ 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/_class_methods.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/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/parser.rb
 - lib/eac_cli/parser/alternative.rb
 - lib/eac_cli/parser/alternative/argv.rb
@@ -78,6 +124,8 @@ files:
 - lib/eac_cli/parser/collector.rb
 - lib/eac_cli/parser/error.rb
 - lib/eac_cli/patches.rb
+- lib/eac_cli/patches/module.rb
+- lib/eac_cli/patches/module/speaker.rb
 - lib/eac_cli/patches/object.rb
 - lib/eac_cli/patches/object/runner_with.rb
 - lib/eac_cli/runner.rb
@@ -87,9 +135,14 @@ files:
 - lib/eac_cli/runner/instance_methods.rb
 - lib/eac_cli/runner_with.rb
 - lib/eac_cli/runner_with/help.rb
-- lib/eac_cli/runner_with/output_file.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/_class_methods.rb
+- lib/eac_cli/speaker/_constants.rb
+- lib/eac_cli/speaker/list.rb
+- lib/eac_cli/speaker/node.rb
 - lib/eac_cli/version.rb
 homepage: 
 licenses: []
@@ -109,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.0.9
 signing_key: 
 specification_version: 4
 summary: Utilities to build CLI applications with Ruby.

data/lib/eac_cli/runner_with/output_file.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_cli/runner'
-require 'eac_ruby_utils/core_ext'
-require 'eac_ruby_utils/abstract_methods'
-
-module EacCli
-  module RunnerWith
-    module OutputFile
-      common_concern do
-        include ::EacCli::Runner
-        include ::EacRubyUtils::AbstractMethods
-
-        abstract_methods :output_content
-
-        runner_definition do
-          arg_opt '-o', '--output-file', 'Output to file.'
-        end
-      end
-
-      def run_output
-        if parsed.output_file.present?
-          ::File.write(parsed.output_file, output_content)
-        else
-          $stdout.write(output_content)
-        end
-      end
-    end
-  end
-end