avm-tools 0.113.1 → 0.113.5

data/sub/eac_cli/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/sub/eac_cli/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/sub/eac_cli/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/sub/eac_cli/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/sub/eac_cli/lib/eac_cli/parser/alternative/argv.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Argv
+        def argv_enum
+          @argv_enum ||= argv.each
+        end
+
+        def argv_pending?
+          argv_enum.ongoing?
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/double_dash.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module DoubleDash
+        DOUBLE_DASH = '--'
+
+        private
+
+        attr_accessor :double_dash
+
+        def argv_current_double_dash?
+          argv_enum.peek == DOUBLE_DASH && !double_dash
+        end
+
+        def double_dash_collect_argv_value
+          self.phase = PHASE_POSITIONAL
+          self.double_dash = true
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/long_options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module LongOptions
+        LONG_OPTION_PREFIX = '--'
+        OPTION_WITH_ARGUMENT_PATTERN = /\A([^=]+)(?:=(.*))\z/.freeze
+
+        private
+
+        def argv_current_long_option?
+          phase == PHASE_ANY && argv_enum.peek.start_with?(LONG_OPTION_PREFIX) &&
+            !argv_current_double_dash?
+        end
+
+        def long_option_collect_argv_value
+          option_long, value = parse_option_current_argv
+          alternative.options.any? do |option|
+            next false unless option.long == option_long
+
+            if value.nil?
+              option_collect_option(option)
+            else
+              option_argument_collect(option, value)
+            end
+          end || raise_argv_current_invalid_option
+        end
+
+        def parse_option_current_argv
+          m = OPTION_WITH_ARGUMENT_PATTERN.match(argv_enum.peek)
+          m ? [m[1], m[2].if_present('')] : [argv_enum.peek, nil]
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/option_argument.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module OptionArgument
+        private
+
+        attr_accessor :argument_option
+
+        def argument_option_collect_argv(option)
+          self.argument_option = option
+          self.phase = PHASE_OPTION_ARGUMENT
+        end
+
+        def option_argument_collect(option, value)
+          collector.collect(option, value)
+          self.argument_option = nil
+          self.phase = PHASE_ANY
+          option
+        end
+
+        def option_argument_collect_argv_value
+          option_argument_collect(argument_option, argv_enum.peek)
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/options.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Options
+        private
+
+        def boolean_option_collect_argv(option)
+          collector.collect(option, true)
+        end
+
+        def option_collect_option(option)
+          if option.argument?
+            argument_option_collect_argv(option)
+          else
+            boolean_option_collect_argv(option)
+          end
+
+          option
+        end
+
+        def raise_argv_current_invalid_option
+          raise_error "Invalid option: \"#{argv_enum.peek}\""
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/positionals.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module Positionals
+        private
+
+        def positional_collect_argv_value
+          positional_check
+          collector.collect(positional_enum.peek, argv_enum.peek)
+          positional_next
+        end
+
+        def positional_enum
+          @positional_enum ||= alternative.positional.each
+        end
+
+        def positional_check
+          raise_error("Invalid positional: #{argv_enum.peek}") if positional_enum.stopped?
+        end
+
+        def positional_next
+          self.phase = PHASE_POSITIONAL if positional_enum.peek.subcommand?
+          positional_enum.next unless positional_enum.peek.repeat?
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/alternative/short_options.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module EacCli
+  class Parser
+    class Alternative
+      module ShortOptions
+        SHORT_OPTION_PREFIX = '-'
+
+        private
+
+        def argv_current_short_option?
+          phase == PHASE_ANY && argv_enum.peek.start_with?(SHORT_OPTION_PREFIX) &&
+            !argv_current_long_option?
+        end
+
+        def find_short_option(char)
+          alternative.options.find do |option|
+            short_without_prefix(option.short).if_present(false) { |v| v == char }
+          end
+        end
+
+        def short_option_collect_argv_value
+          last_option = nil
+          short_without_prefix(argv_enum.peek).each_char do |char|
+            raise_error "Option \"#{last_option}\" requires a argument not provided" if
+            last_option.present?
+
+            collected_option = short_option_collect_char(char)
+            last_option = collected_option if collected_option.argument?
+          end
+        end
+
+        # @return [EacCli::Definition::BaseOption] The option collected.
+        def short_option_collect_char(char)
+          option = find_short_option(char)
+          raise_error "Invalid short option \"#{char}\"" unless option
+
+          option_collect_option(option)
+        end
+
+        def short_without_prefix(short)
+          short.to_s.gsub(/\A#{::Regexp.quote(SHORT_OPTION_PREFIX)}/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'eac_cli/parser/collector'
+require 'eac_cli/parser/error'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class Alternative
+      require_sub __FILE__, include_modules: true
+      enable_listable
+      lists.add_symbol :phase, :any, :option_argument, :positional
+      attr_reader :error
+
+      common_constructor :alternative, :argv do
+        alternative.assert_argument(::EacCli::Definition::Alternative, :alternative)
+        self.phase = PHASE_ANY
+        collect
+      end
+
+      def error?
+        error.present?
+      end
+
+      def success?
+        !error?
+      end
+
+      def parsed
+        @parsed ||= collector.to_data.freeze
+      end
+
+      private
+
+      attr_accessor :phase
+
+      def any_collect_argv_value
+        %w[double_dash long_option short_option].each do |arg_type|
+          return send("#{arg_type}_collect_argv_value") if send("argv_current_#{arg_type}?")
+        end
+
+        positional_collect_argv_value
+      end
+
+      def collector
+        @collector ||= ::EacCli::Parser::Collector.new(alternative)
+      end
+
+      def collect
+        loop do
+          break unless argv_pending?
+
+          collect_argv_value
+        end
+        validate
+      rescue ::EacCli::Parser::Error => e
+        @error = e
+      end
+
+      def collect_argv_value
+        send("#{phase}_collect_argv_value")
+        argv_enum.next
+      end
+
+      def collect_option_argv_value
+        alternative.options.each do |option|
+        end
+
+        raise ::EacCli::Parser::Error.new(
+          alternative, argv, "Invalid option: #{argv_enum.current}"
+        )
+      end
+
+      def raise_error(message)
+        raise ::EacCli::Parser::Error.new(alternative, argv, message)
+      end
+
+      def validate
+        (alternative.options + alternative.positional).each do |option|
+          validate_option(option)
+        end
+      end
+
+      def validate_option(option)
+        return unless option.required?
+        return if collector.supplied?(option)
+
+        raise_error("Required option/positional #{option} not supplied")
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/collector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/struct'
+
+module EacCli
+  class Parser
+    class Collector
+      class << self
+        def to_data(definition)
+          collector = new(definition)
+          yield(collector)
+          collector.to_data
+        end
+      end
+
+      common_constructor :definition do
+        default_values
+      end
+
+      # @return [OpenStruct]
+      def to_data
+        ::EacRubyUtils::Struct.new(data.transform_keys(&:identifier))
+      end
+
+      def collect(option, value)
+        data[option] = option.build_value(value, data[option])
+      end
+
+      def supplied?(option)
+        data[option].present?
+      end
+
+      private
+
+      def data
+        @data ||= {}
+      end
+
+      def default_values
+        definition.options.each { |option| data[option] = option.default_value }
+        definition.positional.each { |positional| data[positional] = positional.default_value }
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser/error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    class Error < ::StandardError
+      def initialize(definition, argv, message)
+        @definition = definition
+        @argv = argv
+        super(message)
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Parser
+    require_sub __FILE__
+    enable_simple_cache
+    common_constructor :definition, :argv
+
+    private
+
+    def parsed_uncached
+      raise 'Definition has no alternatives' if alternatives.empty?
+      raise first_error unless alternatives.select(&:success?).any?
+
+      alternatives_parsed(true).merge(alternatives_parsed(false))
+    end
+
+    def alternatives_parsed(error)
+      alternatives.select { |a| error == a.error? }.map(&:parsed).reverse
+                  .inject(::EacRubyUtils::Struct.new) { |a, e| a.merge(e) }
+    end
+
+    def alternatives_uncached
+      definition.alternatives
+                .map { |alternative| ::EacCli::Parser::Alternative.new(alternative, argv) }
+    end
+
+    def first_error_uncached
+      alternatives.lazy.select(&:error?).map(&:error).first
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/runner'
+require 'eac_cli/runner_with'
+require 'eac_cli/runner_with_set'
+
+class Object
+  def runner_with(*runners, &block)
+    include ::EacCli::Runner
+    enable_simple_cache
+    enable_speaker
+    runners.each do |runner|
+      include ::EacCli::RunnerWithSet.default.item_to_module(runner)
+    end
+    runner_definition(&block) if block
+  end
+
+  private
+
+  def runner_with_to_module(runner)
+    return runner if runner.is_a?(::Module)
+
+    "EacCli::RunnerWith::#{runner.to_s.camelize}".constantize
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/#{::File.basename(__FILE__, '.*')}/*.rb"].sort.each do |path|
+  require path
+end

data/sub/eac_cli/lib/eac_cli/patches.rb

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

data/sub/eac_cli/lib/eac_cli/rspec/setup.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'eac_cli/config/entry'
+require 'eac_cli/speaker'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/speaker'
+
+module EacCli
+  module Rspec
+    module Setup
+      def disable_input_request
+        disable_config_input_request
+        disable_speaker_input_request
+      end
+
+      def disable_config_input_request
+        rspec_config.before do
+          allow_any_instance_of(::EacCli::Config::Entry).to receive(:input_value) do |obj|
+            raise "Console input requested for entry (Path: #{obj.path})"
+          end
+        end
+      end
+
+      def disable_speaker_input_request
+        ::RSpec.configure do |config|
+          config.around do |example|
+            ::EacRubyUtils::Speaker.context.on(
+              ::EacCli::Speaker.new(err_out: ::StringIO.new, out_out: ::StringIO.new,
+                                    in_in: FailIfRequestInput.new)
+            ) { example.run }
+          end
+        end
+      end
+
+      class FailIfRequestInput
+        %w[gets noecho].each do |method|
+          define_method(method) do
+            raise "Input method requested: #{method}. Should not request input on RSpec."
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/rspec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_exts'
+
+module EacCli
+  module Rspec
+    require_sub __FILE__
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/after_class_methods.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'eac_cli/speaker'
+require 'eac_ruby_utils/speaker'
+
+module EacCli
+  module Runner
+    module AfterClassMethods
+      def create(*runner_context_args)
+        r = new
+        r.runner_context = ::EacCli::Runner::Context.new(r, *runner_context_args)
+        r
+      end
+
+      def run(*runner_context_args)
+        on_asserted_speaker do
+          r = create(*runner_context_args)
+          r.run_run
+          r
+        end
+      end
+
+      def runner_definition(&block)
+        @runner_definition ||= super_runner_definition
+        @runner_definition.instance_eval(&block) if block
+        @runner_definition
+      end
+
+      def super_runner_definition
+        superclass.try(:runner_definition).if_present(&:dup) || ::EacCli::Definition.new
+      end
+
+      private
+
+      def on_asserted_speaker
+        if ::EacRubyUtils::Speaker.context.optional_current
+          yield
+        else
+          ::EacRubyUtils::Speaker.context.on(::EacCli::Speaker.new) do
+            yield
+          end
+        end
+      end
+    end
+  end
+end