eac_cli 0.16.1 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23a97e547ebd10f3efd4f64da1d46c47942b46baacf7407e0dc9079c76c20f4a
-  data.tar.gz: ddcabc7f42f2f616c86435098d7e2d9b840342965abf6e65d72f7311a0cdf06d
+  metadata.gz: cfee9c78c899be3c4e2d36915e4d0cac08cf5f2a63269813b5c05527a06d0e75
+  data.tar.gz: c0374336ed9fea6c351ce00b0a9e5e210b53ca7a34c201dc1a0699fcda12b943
 SHA512:
-  metadata.gz: a56fa25e3023ab586c482573f170584927fd451dd9ab8fd0f53ae9707dfc037af24293ab856254512916c31bf218890b89e647a432e4ea1064fc3555ddd61e47
-  data.tar.gz: 0e303addfc58031901fb5a559184cd07fed828ef5ab80ffd7f6f16ad6f84b02136c181e90bb825799ed6af775747d0668ff6cda2179338f5366e4e7bcb2ec50f
+  metadata.gz: d2e1c8009e10490cde982e4d8cc0fce02d67d0114ddb3a852180298c6f83edd7d5e4e2ee0bf04188199d615739297b3fdbf41a61d532e6614b86dece3c63b864
+  data.tar.gz: fba7139e87ea3959a2498f20d83a08d19c299acd71e576ed0d446ca47a77bb97ab9e670c4280984001feb6467d6cdd01d3a989dc6b44b5e4d5345d9f87c66a0c

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
+      include ::EacCli::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
+          request_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
@@ -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
@@ -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,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'docopt'
+
+module EacCli
+  class DocoptRunner
+    require_sub __FILE__
+    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/_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