avm-tools 0.76.0 → 0.80.0

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/common_constructor.rb

@@ -61,6 +61,8 @@ module EacRubyUtils
       setup_class_attr_readers(klass)
       setup_class_attr_writers(klass)
       setup_class_initialize(klass)
+
+      klass
     end
 
     def setup_class_attr_readers(klass)
@@ -79,9 +81,14 @@ module EacRubyUtils
       klass.define_callbacks :initialize
       klass.send(:define_method, :initialize) do |*args|
         Initialize.new(common_constructor, args, self).run
+        super(*SuperArgs.new(common_constructor, args, self).result)
       end
     end
 
+    def super_args
+      options[:super_args]
+    end
+
     class Initialize
       attr_reader :common_constructor, :args, :object
 
@@ -129,5 +136,51 @@ module EacRubyUtils
           " (given #{args.count}, expected #{common_constructor.args_count})"
       end
     end
+
+    class SuperArgs
+      attr_reader :common_constructor, :args, :object
+
+      def initialize(common_constructor, args, object)
+        @common_constructor = common_constructor
+        @args = args
+        @object = object
+      end
+
+      def auto_result
+        r = []
+        sub_args.each do |name, value|
+          i = super_arg_index(name)
+          r[i] = value if i
+        end
+        r
+      end
+
+      def result
+        result_from_options || auto_result
+      end
+
+      def result_from_options
+        return unless common_constructor.super_args
+
+        object.instance_exec(&common_constructor.super_args)
+      end
+
+      def sub_args
+        common_constructor.args.each_with_index.map do |name, index|
+          [name, args[index]]
+        end.to_h
+      end
+
+      def super_arg_index(name)
+        super_method.parameters.each_with_index do |arg, index|
+          return index if arg[1] == name
+        end
+        nil
+      end
+
+      def super_method
+        object.class.superclass ? object.class.superclass.instance_method(:initialize) : nil
+      end
+    end
   end
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs.rb

@@ -11,18 +11,10 @@ module EacRubyUtils
 
       class << self
         def entry_key_to_envvar_name(entry_key)
-          path = if entry_key.is_a?(::Array)
-                   entry_key
-                 else
-                   ::EacRubyUtils::PathsHash.parse_entry_key(entry_key)
-                 end
-          path.join('_').gsub(/[^a-z0-9_]/i, '').gsub(/\A_+/, '').gsub(/_+\z/, '')
-              .gsub(/_{2,}/, '_').upcase
+          ::EacRubyUtils::Console::Configs::EntryReader.entry_key_to_envvar_name(entry_key)
         end
       end
 
-      STORE_PASSWORDS_KEY = 'core.store_passwords'
-
       attr_reader :configs
 
       def initialize(configs_key, options = {})
@@ -31,72 +23,15 @@ module EacRubyUtils
       end
 
       def read_password(entry_key, options = {})
-        options = ReadEntryOptions.new(options.merge(noecho: true))
-        if store_passwords?
-          read_entry(entry_key, options)
-        else
-          looped_entry_value_from_input(entry_key, options)
-        end
+        ::EacRubyUtils::Console::Configs::PasswordEntryReader.new(self, entry_key, options).read
       end
 
       def read_entry(entry_key, options = {})
-        options = ReadEntryOptions.new(options)
-        unless options[:noenv]
-          envvar_value = envvar_read_entry(entry_key)
-          return envvar_value if envvar_value.present?
-        end
-        stored_value = configs.read_entry(entry_key)
-        return stored_value if stored_value
-        return read_entry_from_console(entry_key, options) unless options[:noinput]
-
-        raise "No value found for entry \"#{entry_key}\"" if options[:required]
+        ::EacRubyUtils::Console::Configs::EntryReader.new(self, entry_key, options).read
       end
 
       def store_passwords?
-        read_entry(
-          STORE_PASSWORDS_KEY,
-          before_input: -> { store_password_banner },
-          validator: ->(entry_value) { %w[yes no].include?(entry_value) }
-        ) == 'yes'
-      end
-
-      protected
-
-      def envvar_read_entry(entry_key)
-        env_entry_key = self.class.entry_key_to_envvar_name(entry_key)
-        return nil unless ENV.key?(env_entry_key)
-
-        ENV.fetch(env_entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
-      end
-
-      def read_entry_from_console(entry_key, options)
-        options[:before_input].call if options[:before_input].present?
-        entry_value = looped_entry_value_from_input(entry_key, options)
-        configs.write_entry(entry_key, entry_value)
-        entry_value
-      end
-
-      def store_password_banner
-        infom 'Do you wanna to store passwords?'
-        infom "Warning: the passwords will be store in clear text in \"#{configs.storage_path}\""
-        infom 'Enter "yes" or "no"'
-      end
-
-      def looped_entry_value_from_input(entry_key, options)
-        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
+        ::EacRubyUtils::Console::Configs::StorePasswordsEntryReader.new(self) == 'yes'
       end
     end
   end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/entry_reader.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/configs/read_entry_options'
+require 'eac_ruby_utils/core_ext'
+
+module EacRubyUtils
+  module Console
+    class Configs
+      class EntryReader
+        enable_console_speaker
+
+        class << self
+          def entry_key_to_envvar_name(entry_key)
+            path = if entry_key.is_a?(::Array)
+                     entry_key
+                   else
+                     ::EacRubyUtils::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 = ::EacRubyUtils::Console::Configs::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
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/password_entry_reader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/configs/entry_reader'
+
+module EacRubyUtils
+  module Console
+    class Configs
+      class PasswordEntryReader < ::EacRubyUtils::Console::Configs::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
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/read_entry_options.rb

@@ -7,13 +7,18 @@ module EacRubyUtils
     class Configs
       class ReadEntryOptions
         enable_simple_cache
-        common_constructor :options
+        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, validator: nil
+          required: true, store: true, validator: nil
         }.freeze
 
+        delegate :to_h, to: :options
+
         def [](key)
           values.fetch(key.to_sym)
         end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/console/configs/store_passwords_entry_reader.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/console/configs/entry_reader'
+
+module EacRubyUtils
+  module Console
+    class Configs
+      class StorePasswordsEntryReader < ::EacRubyUtils::Console::Configs::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
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/command.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/hash/indifferent_access'
-require 'eac_ruby_utils/console/speaker'
-require 'eac_ruby_utils/envs/command/extra_options'
+require 'eac_ruby_utils/core_ext'
 require 'eac_ruby_utils/envs/process'
 require 'eac_ruby_utils/envs/spawn'
 require 'pp'
@@ -11,8 +9,8 @@ require 'shellwords'
 module EacRubyUtils
   module Envs
     class Command
-      include EacRubyUtils::Console::Speaker
-      include EacRubyUtils::Envs::Command::ExtraOptions
+      require_sub __FILE__, include_modules: true
+      enable_console_speaker
 
       def initialize(env, command, extra_options = {})
         @env = env
@@ -47,7 +45,7 @@ module EacRubyUtils
         c = c.map { |x| escape(x) }.join(' ') if c.is_a?(Enumerable)
         append_command_options(
           @env.command_line(
-            append_chdir(append_pipe(append_envvars(c)))
+            append_chdir(append_concat(append_envvars(c)))
           ),
           options
         )

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/command/concat.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/struct'
+
+module EacRubyUtils
+  module Envs
+    class Command
+      module Concat
+        def concat(operator, other_command)
+          duplicate_by_extra_options(concat: ::EacRubyUtils::Struct.new(
+            operator: operator, command: other_command
+          ))
+        end
+
+        def or(other_command)
+          concat('||', other_command)
+        end
+
+        def pipe(other_command)
+          concat('|', other_command)
+        end
+
+        private
+
+        def append_concat(command)
+          extra_options[:concat].if_present(command) do |v|
+            "#{command} #{v.operator} #{v.command.command}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/command/envvars.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Envs
+    class Command
+      module Envvars
+        def envvar(name, value)
+          duplicate_by_extra_options(envvars: envvars.merge(name => value))
+        end
+
+        private
+
+        def append_envvars(command)
+          e = envvars.map { |k, v| "#{Shellwords.escape(k)}=#{Shellwords.escape(v)}" }.join(' ')
+          e.present? ? "#{e} #{command}" : command
+        end
+
+        def envvars
+          extra_options[:envvars] ||= {}.with_indifferent_access
+        end
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/envs/command/extra_options.rb

@@ -12,39 +12,18 @@ module EacRubyUtils
           duplicate_by_extra_options(chdir: dir)
         end
 
-        def envvar(name, value)
-          duplicate_by_extra_options(envvars: envvars.merge(name => value))
-        end
-
         def status_result(status_code, result)
           duplicate_by_extra_options(status_results: status_results.merge(status_code => result))
         end
 
-        def pipe(other_command)
-          duplicate_by_extra_options(pipe: other_command)
-        end
-
         private
 
         attr_reader :extra_options
 
-        def envvars
-          extra_options[:envvars] ||= {}.with_indifferent_access
-        end
-
         def status_results
           extra_options[:status_results] ||= {}.with_indifferent_access
         end
 
-        def append_envvars(command)
-          e = envvars.map { |k, v| "#{Shellwords.escape(k)}=#{Shellwords.escape(v)}" }.join(' ')
-          e.present? ? "#{e} #{command}" : command
-        end
-
-        def append_pipe(command)
-          extra_options[:pipe].present? ? "#{command} | #{extra_options[:pipe].command}" : command
-        end
-
         def append_chdir(command)
           extra_options[:chdir].present? ? "(cd '#{extra_options[:chdir]}' ; #{command} )" : command
         end