avm-tools 0.97.0 → 0.101.0

data/vendor/eac_cli/lib/eac_cli/docopt_runner/context.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module EacCli
+  class DocoptRunner
+    # Provides the method context which search and call a method in self and ancestor objects.
+    module Context
+      def context(method)
+        current = self
+        while current
+          return current.send(method) if current.respond_to?(method)
+
+          current = current.respond_to?(:parent) ? current.parent : nil
+        end
+        raise "Context method \"#{method}\" not found for #{self.class}"
+      end
+    end
+  end
+end

data/vendor/eac_cli/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/vendor/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 = 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/vendor/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/vendor/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/vendor/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/vendor/eac_cli/lib/eac_cli/old_configs_bridge.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_cli/config'
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class OldConfigsBridge < ::EacCli::Config
+    ENTRY_KEY = 'core.store_passwords'
+
+    class << self
+      def new_configs_path(configs_key, options)
+        options[:storage_path] || ::File.join(ENV['HOME'], '.config', configs_key, 'settings.yml')
+      end
+    end
+
+    def initialize(configs_key, options = {})
+      options.assert_argument(::Hash, 'options')
+      envvar_node = ::EacConfig::EnvvarsNode.new
+      file_node = ::EacConfig::YamlFileNode.new(self.class.new_configs_path(configs_key, options))
+      envvar_node.load_path.push(file_node.url)
+      envvar_node.write_node = file_node
+      super(envvar_node)
+    end
+
+    def read_entry(entry_key, options = {})
+      entry(entry_key, options).value
+    end
+
+    def read_password(entry_key, options = {})
+      entry(entry_key, options.merge(noecho: true, store: store_passwords?)).value
+    end
+
+    def store_passwords?
+      read_entry(ENTRY_KEY, bool: true)
+    end
+  end
+end

data/vendor/eac_cli/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/vendor/eac_cli/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/vendor/eac_cli/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/vendor/eac_cli/lib/eac_cli/runner_with/help.rb

@@ -10,8 +10,8 @@ module EacCli
         include ::EacCli::Runner
 
         runner_definition.alt do
-          options_argument false
           bool_opt '-h', '--help', 'Show help.', usage: true
+          pos_arg :any_arg_with_help, repeat: true, optional: true, visible: false
         end
 
         set_callback :run, :before do
@@ -20,7 +20,7 @@ module EacCli
       end
 
       def help_run
-        return unless parsed.help?
+        return unless show_help?
 
         puts help_text
         raise ::EacCli::Runner::Exit
@@ -31,6 +31,10 @@ module EacCli
         r += help_extra_text if respond_to?(:help_extra_text)
         r
       end
+
+      def show_help?
+        parsed.help? && !if_respond(:run_subcommand?, false)
+      end
     end
   end
 end

data/vendor/eac_cli/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
@@ -56,7 +60,7 @@ module EacCli
       end
 
       def run_with_subcommand
-        if subcommand_name
+        if run_subcommand?
           if subcommand_runner.respond_to?(:run_run)
             subcommand_runner.run_run
           else
@@ -75,6 +79,10 @@ module EacCli
         "Method #{__method__} should be overrided in #{self.class.name}"
       end
 
+      def run_subcommand?
+        subcommand_name.present?
+      end
+
       def subcommands?
         self.class.runner_definition.subcommands?
       end

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