avm-tools 0.72.0 → 0.75.1

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/runner.rb

@@ -10,6 +10,7 @@ module EacRubyBase0
       include ::EacCli::DefaultRunner
       runner_definition do
         bool_opt '-q', '--quiet', 'Quiet mode.'
+        bool_opt '-I', '--no-input', 'Fail if a input is requested.'
         subcommands
         alt do
           bool_opt '-V', '--version', 'Show version.'
@@ -20,6 +21,7 @@ module EacRubyBase0
     def run
       on_speaker_node do |node|
         node.stderr = ::StringIO.new if options.fetch('--quiet')
+        node.stdin = FailIfRequestInput.new if options.fetch('--no-input')
         if options.fetch('--version')
           show_version
         else
@@ -35,5 +37,15 @@ module EacRubyBase0
     def show_version
       out("#{application_version}\n")
     end
+
+    class FailIfRequestInput
+      enable_console_speaker
+
+      %w[gets noecho].each do |method|
+        define_method(method) do
+          raise "Input method requested (\"#{method}\") and option --no-input is set"
+        end
+      end
+    end
   end
 end

data/vendor/eac_ruby_base0/lib/eac_ruby_base0/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyBase0
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/blank_not_blank.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'singleton'
+
+module EacRubyUtils
+  # A blank string which returns +false+ for +blank?+ method.
+  class BlankNotBlank < String
+    include ::Singleton
+
+    def initialize
+      super('')
+    end
+
+    def blank?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/blank_not_blank'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/paths_hash'
+
+module EacRubyUtils
+  class Configs
+    class Base
+      enable_simple_cache
+
+      common_constructor :data, default: [{}] do
+        self.data = ::EacRubyUtils::PathsHash.new(data)
+      end
+
+      def []=(entry_key, entry_value)
+        write(entry_key, entry_value)
+      end
+
+      def [](entry_key)
+        read(entry_key)
+      end
+
+      def clear
+        replace({})
+      end
+
+      def read(entry_key)
+        return nil unless data.key?(entry_key)
+
+        data.fetch(entry_key).if_present(::EacRubyUtils::BlankNotBlank.instance)
+      end
+
+      def replace(new_data)
+        self.data = ::EacRubyUtils::PathsHash.new(new_data)
+      end
+
+      def write(entry_key, entry_value)
+        data[entry_key] = entry_value
+      end
+    end
+  end
+end

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

@@ -1,27 +1,18 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string'
+require 'eac_ruby_utils/configs/base'
 require 'yaml'
-require 'eac_ruby_utils/patches/hash/sym_keys_hash'
-require 'eac_ruby_utils/paths_hash'
-require 'eac_ruby_utils/simple_cache'
 
 module EacRubyUtils
   class Configs
-    class File
-      include ::EacRubyUtils::SimpleCache
-
+    class File < ::EacRubyUtils::Configs::Base
       attr_reader :path, :options
 
       # Valid options: [:autosave]
       def initialize(path, options = {})
         @path = path
         @options = options.to_sym_keys_hash.freeze
-        load
-      end
-
-      def clear
-        self.data = ::EacRubyUtils::PathsHash.new({})
+        super(raw_data_from_file)
       end
 
       def save
@@ -30,37 +21,27 @@ module EacRubyUtils
       end
 
       def load
-        self.data = if ::File.exist?(path) && ::File.size(path).positive?
-                      ::EacRubyUtils::PathsHash.new(YAML.load_file(path))
-                    else
-                      {}
-                    end
-      end
-
-      def []=(entry_key, entry_value)
-        write(entry_key, entry_value)
+        replace(raw_data_from_file)
       end
 
       def write(entry_key, entry_value)
-        data[entry_key] = entry_value
+        super
         save if autosave?
       end
 
-      def [](entry_key)
-        read(entry_key)
-      end
-
-      def read(entry_key)
-        data[entry_key]
-      end
-
       def autosave?
         options[:autosave] ? true : false
       end
 
       private
 
-      attr_accessor :data
+      def raw_data_from_file
+        if ::File.exist?(path) && ::File.size(path).positive?
+          ::YAML.load_file(path)
+        else
+          {}
+        end
+      end
     end
   end
 end

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

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/common_constructor'
 require 'eac_ruby_utils/configs'
-require 'eac_ruby_utils/console/speaker'
-require 'eac_ruby_utils/options_consumer'
-require 'eac_ruby_utils/patches/object/asserts'
-require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/core_ext'
 
 module EacRubyUtils
   module Console
     class Configs
-      include ::EacRubyUtils::Console::Speaker
+      require_sub __FILE__
+      enable_console_speaker
 
       class << self
         def entry_key_to_envvar_name(entry_key)
@@ -34,7 +31,7 @@ module EacRubyUtils
       end
 
       def read_password(entry_key, options = {})
-        options = options.merge(noecho: true)
+        options = ReadEntryOptions.new(options.merge(noecho: true))
         if store_passwords?
           read_entry(entry_key, options)
         else
@@ -66,7 +63,10 @@ module EacRubyUtils
       protected
 
       def envvar_read_entry(entry_key)
-        ENV[self.class.entry_key_to_envvar_name(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)
@@ -98,38 +98,6 @@ module EacRubyUtils
         warn('Entered value is blank') if entry_value.blank?
         entry_value
       end
-
-      class ReadEntryOptions
-        include ::EacRubyUtils::SimpleCache
-        ::EacRubyUtils::CommonConstructor.new(:options).setup_class(self)
-
-        DEFAULT_VALUES = {
-          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
-          required: true, validator: nil
-        }.freeze
-
-        def [](key)
-          values.fetch(key.to_sym)
-        end
-
-        def request_input_options
-          values.slice(:bool, :list, :noecho)
-        end
-
-        private
-
-        def values_uncached
-          consumer = ::EacRubyUtils::OptionsConsumer.new(options)
-          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
 end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacRubyUtils
+  module Console
+    class Configs
+      class ReadEntryOptions
+        enable_simple_cache
+        common_constructor :options
+
+        DEFAULT_VALUES = {
+          before_input: nil, bool: false, list: false, noecho: false, noenv: false, noinput: false,
+          required: true, validator: nil
+        }.freeze
+
+        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
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/fs/clearable_directory.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'pathname'
+
+module EacRubyUtils
+  module Fs
+    class ClearableDirectory < ::Pathname
+      CLEARABLE_BASENAME = '.clearable_directory'
+
+      def clear
+        validate_clearable
+        directory? ? clear_directory : clear_no_directory
+        mkpath
+        ::FileUtils.touch(clearable_note_file.to_path)
+        self
+      end
+
+      def clearable?
+        clearable_negate_message ? true : false
+      end
+
+      def clearable_negate_message
+        return if !exist? || empty?
+        return "Path \"#{self}\" exists, is not empty and is not a directory" unless directory?
+        return if clearable_note_file.exist?
+
+        "Directory \"#{self}\" is not empty and does not have a #{CLEARABLE_BASENAME} file"
+      end
+
+      def clearable_note_file
+        join(CLEARABLE_BASENAME)
+      end
+
+      def validate_clearable
+        message = clearable_negate_message
+        raise message if message
+      end
+
+      private
+
+      def clear_directory
+        children.each do |child|
+          if child.directory?
+            child.rmtree
+          elsif child.file?
+            child.unlink
+          end
+        end
+      end
+
+      def clear_no_directory
+        ::FileUtils.rm_rf(to_path)
+      end
+    end
+  end
+end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/paths_hash.rb

@@ -1,21 +1,25 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/object'
-require 'eac_ruby_utils/patches/object/asserts'
+require 'eac_ruby_utils/core_ext'
 
 module EacRubyUtils
   class PathsHash
+    require_sub __FILE__
+
     class << self
       def parse_entry_key(entry_key)
         r = entry_key.to_s.strip
-        raise EntryKeyError, 'Entry key cannot start or end with dot' if
+        raise ::EacRubyUtils::PathsHash::EntryKeyError, 'Entry key cannot start or end with dot' if
         r.start_with?('.') || r.end_with?('.')
 
         r = r.split('.').map(&:strip)
-        raise EntryKeyError, "Entry key \"#{entry_key}\" is empty" if r.empty?
+        if r.empty?
+          raise ::EacRubyUtils::PathsHash::EntryKeyError, "Entry key \"#{entry_key}\" is empty"
+        end
         return r.map(&:to_sym) unless r.any?(&:blank?)
 
-        raise EntryKeyError, "Entry key \"#{entry_key}\" has at least one blank part"
+        raise ::EacRubyUtils::PathsHash::EntryKeyError,
+              "Entry key \"#{entry_key}\" has at least one blank part"
       end
     end
 
@@ -26,68 +30,27 @@ module EacRubyUtils
     end
 
     def [](entry_key)
-      root.read_entry(self.class.parse_entry_key(entry_key), [])
+      root.read_entry(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     end
 
     def []=(entry_key, entry_value)
-      root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
+      root.write_entry(
+        ::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key), entry_value
+      )
     end
 
-    delegate :to_h, to: :root
-
-    private
-
-    attr_reader :data
-
-    class EntryKeyError < StandardError
+    def fetch(entry_key)
+      root.fetch(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
     end
 
-    class Node
-      def initialize(source_hash)
-        source_hash.assert_argument(Hash, 'source_hash')
-        @data = source_hash.map { |k, v| [k.to_sym, v.is_a?(Hash) ? Node.new(v) : v] }.to_h
-      end
-
-      def to_h
-        data.map { |k, v| [k, v.is_a?(Node) ? v.to_h : v] }.to_h
-      end
-
-      def read_entry(path, current)
-        validate_path(path, current)
-        node_key = path.shift
-        node = data[node_key]
-        return (node.is_a?(Node) ? node.to_h : node) if path.empty?
-        return nil if node.blank?
-        return node.read_entry(path, current + [node_key]) if node.is_a?(Node)
-
-        raise(EntryKeyError,
-              "Path #{current.join(',')} is not a Node and path continues (#{current + path})")
-      end
-
-      def write_entry(path, value, current)
-        validate_path(path, current)
-        node_key = path.shift
-        write_entry_value(path, node_key, value, current)
-      end
-
-      private
+    def key?(entry_key)
+      root.entry?(::EacRubyUtils::PathsHash::PathSearch.parse_entry_key(entry_key))
+    end
 
-      def write_entry_value(path, node_key, value, current)
-        if path.empty?
-          data[node_key] = value.is_a?(Hash) ? Node.new(value) : value
-        else
-          data[node_key] = Node.new({}) unless data[node_key].is_a?(Node)
-          data[node_key].write_entry(path, value, current + [node_key])
-        end
-      end
+    delegate :to_h, to: :root
 
-      def validate_path(path, current)
-        path.assert_argument(Array, 'path')
-        current.assert_argument(Array, 'current')
-        raise EntryKeyError, 'Path is empty' if path.empty?
-      end
+    private
 
-      attr_reader :data
-    end
+    attr_reader :data
   end
 end