avm-tools 0.113.1 → 0.113.5

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_cli/speaker'
+require 'eac_config/entry_path'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Config < ::SimpleDelegator
+    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?
+
+        input_value
+      end
+
+      delegate :found?, :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/sub/eac_cli/lib/eac_cli/config.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Config < ::SimpleDelegator
+    require_sub __FILE__
+
+    def initialize(sub_node)
+      super(sub_node)
+    end
+
+    def entry(path, options = {})
+      ::EacCli::Config::Entry.new(self, path, options)
+    end
+
+    def sub
+      __getobj__
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/core_ext.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/patches'
+
+::EacCli::RunnerWithSet.default.add_namespace(::EacCli::RunnerWith)

data/sub/eac_cli/lib/eac_cli/default_runner.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/help'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module DefaultRunner
+    common_concern do
+      include ::EacCli::RunnerWith::Help
+      enable_speaker
+      enable_simple_cache
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/definition/alternative.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/argument_option'
+require 'eac_cli/definition/boolean_option'
+require 'eac_cli/definition/positional_argument'
+
+module EacCli
+  class Definition
+    class Alternative
+      SUBCOMMAND_NAME_ARG = :subcommand
+      SUBCOMMAND_ARGS_ARG = :subcommand_args
+
+      def arg_opt(*args)
+        options_set << ::EacCli::Definition::ArgumentOption.from_args(args)
+      end
+
+      def bool_opt(*args)
+        options_set << ::EacCli::Definition::BooleanOption.from_args(args)
+      end
+
+      def options
+        options_set.to_a
+      end
+
+      def options_argument?
+        @options_argument ? true : false
+      end
+
+      def options_argument(enable)
+        @options_argument = enable
+
+        self
+      end
+
+      def pos_arg(name, arg_options = {})
+        new_pos_arg = ::EacCli::Definition::PositionalArgument.new(name, arg_options)
+        check_positional_blocked(new_pos_arg)
+        pos_set << new_pos_arg
+      end
+
+      def positional
+        pos_set.to_a
+      end
+
+      def positional_arguments_blocked?(new_pos_arg)
+        last = pos_set.last
+        return false unless last
+        return true if subcommands?
+        return true if last.repeat?
+        return true if last.optional? && new_pos_arg.if_present(&:required?)
+
+        false
+      end
+
+      def subcommands
+        pos_arg(SUBCOMMAND_NAME_ARG, subcommand: true)
+        pos_set << ::EacCli::Definition::PositionalArgument.new(SUBCOMMAND_ARGS_ARG,
+                                                                optional: true, repeat: true)
+      end
+
+      def subcommands?
+        pos_set.any?(&:subcommand?)
+      end
+
+      private
+
+      def check_positional_blocked(new_pos_arg)
+        raise 'Positional arguments are blocked' if positional_arguments_blocked?(new_pos_arg)
+      end
+
+      def pos_set
+        @pos_set ||= []
+      end
+
+      def options_set
+        @options_set ||= []
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/definition/argument_option.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/base_option'
+
+module EacCli
+  class Definition
+    class ArgumentOption < ::EacCli::Definition::BaseOption
+      def argument?
+        true
+      end
+
+      def build_value(new_value, previous_value)
+        repeat? ? previous_value + [new_value] : new_value
+      end
+
+      def default_default_value
+        repeat? ? [] : nil
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/definition/base_option/initialize_args_parser.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Definition
+    class BaseOption
+      class InitializeArgsParser
+        PROPERTIES = %i[short long description options].freeze
+        attr_reader(*PROPERTIES)
+
+        def initialize(args)
+          self.options = args.extract_options!.freeze
+          args.each { |arg| absorb_arg(arg) }
+        end
+
+        private
+
+        attr_writer(*PROPERTIES)
+
+        def absorb_arg(arg)
+          arg_ext = ArgumentParser.new(arg)
+          send("#{arg_ext.type}=", arg_ext.value)
+        end
+
+        class ArgumentParser
+          TYPES = %i[short long description].freeze
+          common_constructor :value
+
+          def type
+            TYPES.find { |type| send("#{type}?") } || raise("Unknown type for \"#{value}\"")
+          end
+
+          def short?
+            value.start_with?('-') && !long?
+          end
+
+          def long?
+            value.start_with?('--')
+          end
+
+          def description?
+            !short? || !long?
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/definition/base_option.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Definition
+    class BaseOption
+      require_sub __FILE__
+
+      class << self
+        def from_args(args)
+          p = ::EacCli::Definition::BaseOption::InitializeArgsParser.new(args)
+          new(p.short, p.long, p.description, p.options)
+        end
+      end
+
+      DEFAULT_REQUIRED = false
+
+      enable_listable
+      enable_abstract_methods :build_value, :default_value
+      lists.add_symbol :option, :default, :optional, :usage, :repeat, :required
+      common_constructor :short, :long, :description, :options, default: [{}] do
+        raise 'Nor short neither long selector was set' if short.blank? && long.blank?
+
+        self.options = ::EacCli::Definition::BaseOption.lists.option.hash_keys_validate!(
+          options.symbolize_keys
+        )
+      end
+
+      def default_value
+        default_value? ? options[OPTION_DEFAULT] : default_default_value
+      end
+
+      def default_value?
+        options.key?(OPTION_DEFAULT)
+      end
+
+      def identifier
+        [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?
+        options[OPTION_REPEAT]
+      end
+
+      def required?
+        return true if options.key?(:required) && options.fetch(:required)
+        return false if options.key?(:optional) && options.fetch(:optional)
+
+        DEFAULT_REQUIRED
+      end
+
+      def to_s
+        "#{self.class.name.demodulize}[#{identifier}]"
+      end
+
+      def show_on_usage?
+        options[:usage]
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/definition/boolean_option.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/base_option'
+
+module EacCli
+  class Definition
+    class BooleanOption < ::EacCli::Definition::BaseOption
+      def argument?
+        false
+      end
+
+      def build_value(_new_value, previous_value)
+        repeat? ? previous_value + 1 : true
+      end
+
+      def default_value
+        return super unless default_value?
+
+        raise "Unallowed default value for boolean options (Option: #{self})"
+      end
+
+      def default_default_value
+        repeat? ? 0 : false
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/definition/help_formatter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/help/builder/alternative'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Definition
+    class HelpFormatter
+      SEP = ' '
+      IDENT = SEP * 2
+      OPTION_DESC_SEP = IDENT * 2
+
+      class << self
+        def option_long(option)
+          b = option.long
+          b += '=VALUE' if option.argument?
+          b
+        end
+
+        def option_short(option)
+          b = option.short
+          b += 'VALUE' if option.argument?
+          b
+        end
+      end
+
+      common_constructor :definition
+
+      def positional_argument(positional)
+        if positional.subcommand?
+          ::EacCli::RunnerWith::Help::Builder::Alternative::SUBCOMMANDS_MACRO
+        else
+          r = "<#{positional.name}>"
+          r += '...' if positional.repeat?
+          r = "[#{r}]" if positional.optional?
+          r
+        end
+      end
+
+      def section(header, include_header = true)
+        b = include_header ? "#{header.humanize}:\n" : ''
+        b += send("self_#{header}") + "\n"
+        # TO-DO: implement alternatives
+        b
+      end
+
+      def self_options
+        definition.options.map { |option| IDENT + option_definition(option) }.join("\n")
+      end
+
+      def self_usage
+        IDENT + self_usage_arguments.join(SEP)
+      end
+
+      def self_usage_arguments
+        [::EacCli::RunnerWith::Help::Builder::Alternative::PROGRAM_MACRO] +
+          definition.options_argument.if_present([]) { |_v| ['[options]'] } +
+          self_usage_arguments_options +
+          self_usage_arguments_positional
+      end
+
+      def self_usage_arguments_options
+        definition.options.select(&:show_on_usage?).map do |option|
+          self.class.option_long(option)
+        end
+      end
+
+      def self_usage_arguments_positional
+        definition.positional.map { |p| positional_argument(p) }
+      end
+
+      def to_banner
+        "#{definition.description}\n\n#{section('usage')}"
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/definition/positional_argument.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Definition
+    class PositionalArgument
+      DEFAULT_REQUIRED = true
+      DEFAULT_VISIBLE = true
+
+      enable_listable
+      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
+
+      def build_value(new_value, previous_value)
+        if previous_value.is_a?(::Array)
+          previous_value + [new_value]
+        else
+          new_value
+        end
+      end
+
+      def default_value
+        repeat? ? [] : nil
+      end
+
+      def identifier
+        name.to_s.variableize.to_sym
+      end
+
+      def optional?
+        !required?
+      end
+
+      def repeat?
+        options[OPTION_REPEAT]
+      end
+
+      def required?
+        return true if options.key?(OPTION_REQUIRED) && options.fetch(OPTION_REQUIRED)
+        return false if options.key?(OPTION_OPTIONAL) && options.fetch(OPTION_OPTIONAL)
+
+        DEFAULT_REQUIRED
+      end
+
+      def subcommand?
+        options[OPTION_SUBCOMMAND]
+      end
+
+      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/sub/eac_cli/lib/eac_cli/definition.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'eac_cli/definition/argument_option'
+require 'eac_cli/definition/boolean_option'
+require 'eac_cli/definition/positional_argument'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Definition
+    require_sub __FILE__
+
+    MAIN_ALTERNATIVE_KEY = :main
+    SUBCOMMAND_NAME_ARG = 'subcommand'
+    SUBCOMMAND_ARGS_ARG = 'subcommand_args'
+
+    attr_accessor :description
+
+    def initialize
+      self.description = '-- NO DESCRIPTION SET --'
+      alternatives_set[MAIN_ALTERNATIVE_KEY] = main_alternative
+    end
+
+    def alt(&block)
+      r = ::EacCli::Definition::Alternative.new
+      r.instance_eval(&block)
+      alternatives_set[new_alternative_key] = r
+      r
+    end
+
+    def alternatives
+      alternatives_set.values
+    end
+
+    def alternative(key)
+      alternatives_set.fetch(key)
+    end
+
+    def desc(description)
+      self.description = description
+    end
+
+    def help_formatter
+      @help_formatter ||= ::EacCli::Definition::HelpFormatter.new(self)
+    end
+
+    def main_alternative
+      @main_alternative ||= begin
+        r = ::EacCli::Definition::Alternative.new
+        r.options_argument(true)
+        r
+      end
+    end
+
+    def options_arg(options_argument)
+      self.options_argument = options_argument
+    end
+
+    def options_argument
+      main_alternative.options_argument?
+    end
+
+    def options_argument=(enable)
+      main_alternative.options_argument(enable)
+    end
+
+    delegate :arg_opt, :bool_opt, :options, :pos_arg,
+             :positional, :subcommands, to: :main_alternative
+
+    def subcommands?
+      alternatives.any?(&:subcommands?)
+    end
+
+    def options_first(enable = true)
+      @options_first = enable
+    end
+
+    def options_first?
+      @options_first ? true : false
+    end
+
+    private
+
+    def alternatives_set
+      @alternatives_set ||= ::ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def new_alternative_key
+      @last_key ||= 0
+      loop do
+        @last_key += 1
+        break @last_key unless alternatives_set.key?(@last_key)
+      end
+    end
+
+    def pos_set
+      @pos_set ||= []
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/enum.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/enum'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  # A [EacRubyUtils::Enum] which each value is associated with one console color.
+  class Enum < ::EacRubyUtils::Enum
+    # Foreground color used in [to_bg_label]
+    TO_BG_LABEL_FG_COLOR = :light_white
+
+    attr_reader :color
+
+    def initialize(key, color)
+      super(key)
+      @color = color
+    end
+
+    delegate :to_s, to: :key
+
+    # @return [String]
+    def to_label
+      to_fg_label
+    end
+
+    # @return [String]
+    def to_fg_label
+      to_fg_bg_label(color)
+    end
+
+    # @return [String]
+    def to_bg_label
+      to_fg_bg_label(TO_BG_LABEL_FG_COLOR, color)
+    end
+
+    private
+
+    # @return [String]
+    def to_fg_bg_label(fg_color, bg_color = nil)
+      colors = { color: fg_color }
+      bg_color.if_present { |v| colors[:background] = v }
+      ::ColorizedString[to_s].colorize(colors)
+    end
+  end
+end

data/sub/eac_cli/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