avm-tools 0.109.1 → 0.113.0

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

@@ -1,26 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/config/entry.rb

@@ -1,46 +0,0 @@
-# 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?
-
-        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/vendor/eac_cli/lib/eac_cli/config.rb

@@ -1,21 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/core_ext.rb

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

data/vendor/eac_cli/lib/eac_cli/default_runner.rb

@@ -1,14 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition/alternative.rb

@@ -1,80 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition/argument_option.rb

@@ -1,21 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition/base_option/initialize_args_parser.rb

@@ -1,47 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition/base_option.rb

@@ -1,66 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition/boolean_option.rb

@@ -1,27 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition/help_formatter.rb

@@ -1,77 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition/positional_argument.rb

@@ -1,61 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/definition.rb

@@ -1,99 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/old_configs/entry_reader.rb

@@ -1,80 +0,0 @@
-# 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/vendor/eac_cli/lib/eac_cli/old_configs/password_entry_reader.rb

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