avm-tools 0.99.1 → 0.102.2

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
-require 'eac_cli/patches/module/speaker'
 
 module EacCli
   class OldConfigs

data/vendor/eac_cli/lib/eac_cli/old_configs/entry_reader.rb

@@ -70,8 +70,8 @@ module EacCli
       end
 
       def entry_value_from_input(entry_key, options)
-        entry_value = request_input("Value for entry \"#{entry_key}\"",
-                                    options.request_input_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

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/runner/after_class_methods.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'eac_cli/speaker'
+require 'eac_ruby_utils/speaker'
+
 module EacCli
   module Runner
     module AfterClassMethods
@@ -10,9 +13,11 @@ module EacCli
       end
 
       def run(*runner_context_args)
-        r = create(*runner_context_args)
-        r.run_run
-        r
+        on_asserted_speaker do
+          r = create(*runner_context_args)
+          r.run_run
+          r
+        end
       end
 
       def runner_definition(&block)
@@ -24,6 +29,18 @@ module EacCli
       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

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

@@ -60,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
@@ -79,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/speaker.rb

@@ -1,26 +1,26 @@
 # 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__
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/speaker/receiver'
 
 module EacCli
-  # https://github.com/fazibear/colorize
-  module Speaker
-    def on_speaker_node(&block)
-      ::EacCli::Speaker.on_node(&block)
+  class Speaker
+    require_sub __FILE__, include_modules: true
+    include ::EacRubyUtils::Speaker::Receiver
+
+    common_constructor :options, default: [{}] do
+      self.options = self.class.lists.option.hash_keys_validate!(options)
     end
 
     def puts(string = '')
       string.to_s.each_line do |line|
-        current_node.stderr.puts(current_node.stderr_line_prefix.to_s + line)
+        err_out.puts(err_line_prefix.to_s + line)
       end
     end
 
     def out(string = '')
-      current_node.stdout.write(string.to_s)
+      out_out.write(string.to_s)
     end
 
     def fatal_error(string)
@@ -52,7 +52,7 @@ module EacCli
     #   +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 = {})
+    def input(question, options = {})
       bool, list, noecho = options.to_options_consumer.consume_all(:bool, :list, :noecho)
       if list
         request_from_list(question, list, noecho)
@@ -110,22 +110,18 @@ module EacCli
     end
 
     def request_string(question, noecho)
-      current_node.stderr.write "#{question}: ".to_s.yellow
+      err_out.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 = in_in.noecho(&:gets).chomp.strip
+      err_out.write("\n")
       r
     end
 
     def request_string_echo
-      current_node.stdin.gets.chomp.strip
-    end
-
-    def current_node
-      ::EacCli::Speaker.current_node
+      in_in.gets.chomp.strip
     end
   end
 end

data/vendor/eac_cli/lib/eac_cli/speaker/_constants.rb

@@ -4,7 +4,7 @@ require 'eac_ruby_utils/by_reference'
 
 module EacCli
   # https://github.com/fazibear/colorize
-  module Speaker
+  class Speaker
     STDERR = ::EacRubyUtils::ByReference.new { $stderr }
     STDIN = ::EacRubyUtils::ByReference.new { $stdin }
     STDOUT = ::EacRubyUtils::ByReference.new { $stdout }

data/vendor/eac_cli/lib/eac_cli/speaker/list.rb

@@ -4,7 +4,7 @@ require 'active_support/hash_with_indifferent_access'
 require 'ostruct'
 
 module EacCli
-  module Speaker
+  class Speaker
     class List
       class << self
         def build(list)

data/vendor/eac_cli/lib/eac_cli/speaker/options.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  class Speaker
+    module Options
+      common_concern do
+        enable_listable
+        lists.add_symbol :option, :out_out, :err_out, :in_in, :parent, :err_line_prefix
+      end
+
+      def err_out
+        option(OPTION_ERR_OUT, ::EacCli::Speaker::STDERR)
+      end
+
+      def out_out
+        option(OPTION_OUT_OUT, ::EacCli::Speaker::STDOUT)
+      end
+
+      def in_in
+        option(OPTION_IN_IN, ::EacCli::Speaker::STDIN)
+      end
+
+      def err_line_prefix
+        option(OPTION_ERR_LINE_PREFIX, '')
+      end
+
+      def parent
+        options[OPTION_PARENT]
+      end
+
+      def option(key, default)
+        options[key] || parent.if_present(default) { |v| v.send(__METHOD__) }
+      end
+    end
+  end
+end

data/vendor/eac_cli/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.17.0'
+  VERSION = '0.20.2'
 end

data/vendor/eac_cli/spec/lib/eac_cli/speaker_spec.rb

@@ -3,23 +3,19 @@
 require 'eac_cli/speaker'
 
 RSpec.describe ::EacCli::Speaker do
-  let(:instance) do
-    r = ::Object.new
-    r.extend(described_class)
-    r
-  end
+  let(:instance) { described_class.new }
 
-  describe '#request_input' do
+  describe '#input' do
     it 'recover value from hash list' do
       allow(instance).to receive(:request_string).and_return('opt1')
       list = { opt1: 'value1', opt2: 'value2' }
-      expect(instance.request_input('Question', list: list)).to eq('value1')
+      expect(instance.input('Question', list: list)).to eq('value1')
     end
 
     it 'recover value from array list' do
       allow(instance).to receive(:request_string).and_return('OPT1')
       list = %w[opt1 opt2]
-      expect(instance.request_input('Question', list: list)).to eq('opt1')
+      expect(instance.input('Question', list: list)).to eq('opt1')
     end
 
     {
@@ -28,7 +24,7 @@ RSpec.describe ::EacCli::Speaker do
       context "when bool: true and input is \"#{input}\"" do
         it "return #{expected}" do
           allow(instance).to receive(:request_string).and_return(input)
-          expect(instance.request_input('Question', bool: true)).to eq(expected)
+          expect(instance.input('Question', bool: true)).to eq(expected)
         end
       end
     end

data/vendor/eac_config/lib/eac_config/entry.rb

@@ -22,7 +22,13 @@ module EacConfig
       node_entry.if_present(&:value)
     end
 
-    delegate :value=, to: :root_node
+    def value=(a_value)
+      write_node.self_entry(path).value = a_value
+    end
+
+    def write_node
+      root_node.write_node || root_node
+    end
 
     private
 

data/vendor/eac_config/lib/eac_config/envvars_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'eac_config/node'
+require 'eac_ruby_utils/core_ext'
+
+module EacConfig
+  # A node that read/write entries from environment variables.
+  class EnvvarsNode
+    require_sub __FILE__
+    include ::EacConfig::Node
+
+    URI = ::Addressable::URI.parse('self://envvars')
+
+    class << self
+      def from_uri(uri)
+        return new if uri == URI
+      end
+    end
+
+    def url
+      URI
+    end
+  end
+end

data/vendor/eac_config/lib/eac_config/envvars_node/entry.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'eac_config/entry_path'
+require 'eac_config/node_entry'
+require 'eac_ruby_utils/blank_not_blank'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/yaml'
+
+module EacConfig
+  class EnvvarsNode
+    class Entry < ::EacConfig::NodeEntry
+      class << self
+        def entry_path_to_envvar_name(path)
+          ::EacConfig::EntryPath.assert(path).parts.join('_').gsub(/[^a-z0-9_]/i, '')
+                                .gsub(/\A_+/, '').gsub(/_+\z/, '').gsub(/_{2,}/, '_').upcase
+        end
+
+        def from_value(string)
+          return nil if string.nil?
+          return ::EacRubyUtils::Yaml.load(string) if string.start_with?('---')
+
+          string
+        end
+
+        def to_value(object)
+          return nil if object.nil?
+          return object if object.is_a?(String)
+
+          ::EacRubyUtils::Yaml.dump(object)
+        end
+      end
+
+      enable_simple_cache
+
+      def found?
+        ENV.key?(envvar_name)
+      end
+
+      def value
+        self.class.from_value(ENV[envvar_name])
+      end
+
+      def value=(a_value)
+        ENV[envvar_name] = self.class.to_value(a_value)
+      end
+
+      private
+
+      def envvar_name_uncached
+        self.class.entry_path_to_envvar_name(path)
+      end
+    end
+  end
+end