avm-tools 0.50.0 → 0.51.0

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/on_clean_ruby_environment.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/ruby/on_clean_environment'
+
+module EacRubyUtils
+  class << self
+    # <b>DEPRECATED:</b> Please use <tt>EacRubyUtils::Ruby.on_clean_environment</tt> instead.
+    def on_clean_ruby_environment(*args, &block)
+      ::EacRubyUtils::Ruby.on_clean_environment(*args, &block)
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/options_consumer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'ostruct'
+
+module EacRubyUtils
+  class OptionsConsumer
+    DEFAULT_OPTIONS = { validate: true, ostruct: false }.with_indifferent_access.freeze
+
+    def initialize(data)
+      @data = data.with_indifferent_access
+    end
+
+    def consume(key, default_value = nil, &block)
+      return default_value unless data.key?(key)
+
+      value = data.delete(key)
+      value = yield(value) if block
+      value
+    end
+
+    # If last argument is a Hash it is used a options.
+    # Options:
+    # * +validate+: validate after consume.
+    # * +ostruct+: return a [OpenStruct] instead a [Hash].
+    # @return [Hash] (Default) or [OpenStruct].
+    def consume_all(*keys)
+      options = consume_all_extract_options(keys)
+      result = consume_all_build_result(keys, options.fetch(:ostruct))
+      validate if options.fetch(:validate)
+      result
+    end
+
+    def validate
+      return if data.empty?
+
+      raise "Invalid keys: #{data.keys}"
+    end
+
+    def left_data
+      data.dup
+    end
+
+    private
+
+    attr_reader :data
+
+    def consume_all_extract_options(keys)
+      options = DEFAULT_OPTIONS
+      options = options.merge(keys.pop.with_indifferent_access) if keys.last.is_a?(Hash)
+      options
+    end
+
+    def consume_all_build_result(keys, ostruct)
+      if ostruct
+        ::OpenStruct.new(keys.map { |key| [key, consume(key)] }.to_h)
+      else
+        keys.map { |key| consume(key) }
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patch.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class << self
+    def patch(target, patch)
+      return if target.included_modules.include?(patch)
+
+      target.send(:include, patch)
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches.rb

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/class.rb

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/class/common_constructor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_constructor'
+
+class Class
+  def common_constructor(*args, &block)
+    ::EacRubyUtils::CommonConstructor.new(*args, &block).setup_class(self)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerable.rb

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerable/boolean_combinations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Enumerable
+  # Produces a array with values's all combinations.
+  #
+  # Example:
+  #   %i[a b].boolean_combinations
+  #   => [[], [:a], [:b], [:a, :b]]
+  #
+  # @return [Array]
+  def bool_array_combs
+    bool_combs([], method(:bool_array_combs_new_comb))
+  end
+
+  # Produces a hash with values's all combinations.
+  #
+  # Example:
+  #   %i[a b].boolean_combinations
+  #   => [{a: false, b: false}, {a: false, b: true}, {a: true, b: false}, {a: true, b: true}]
+  #
+  # @return [Hash]
+  def bool_hash_combs
+    bool_combs({}, method(:bool_hash_combs_new_comb))
+  end
+
+  private
+
+  def bool_combs(empty_value, new_comb_method)
+    head = [empty_value]
+    r = inject(head) do |a, value|
+      new_comb_method.call(value, a)
+    end
+    r == head ? [] : r
+  end
+
+  def bool_array_combs_new_comb(value, combs)
+    combs + combs.map { |c| c + [value] }
+  end
+
+  def bool_hash_combs_new_comb(value, combs)
+    combs.flat_map do |comb|
+      [false, true].map { |bool_value| comb.dup.merge(value => bool_value) }
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/hash.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/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/options_consumer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/options_consumer'
+
+class Hash
+  # Returns an <tt>EacRubyUtils::OptionsConsumer</tt> out of its receiver.
+  def to_options_consumer
+    ::EacRubyUtils::OptionsConsumer.new(self)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/sym_keys_hash.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Hash
+  def to_sym_keys_hash
+    each_with_object({}) do |(key, value), memo|
+      symbol_key = key.respond_to?(:to_sym) ? key.to_sym : key.to_s.to_sym
+      memo[symbol_key] = value
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/module.rb

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/module/common_concern.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_concern'
+require 'eac_ruby_utils/console/speaker'
+
+class Module
+  def common_concern(&after_callback)
+    ::EacRubyUtils::CommonConcern.new(&after_callback).setup(self)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/module/console_speaker.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/console/speaker'
+
+class Module
+  def enable_console_speaker
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::Console::Speaker)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/module/listable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/listable'
+
+class Module
+  def enable_listable
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::Listable)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/module/patch.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+
+class Module
+  def patch(patch_module)
+    ::EacRubyUtils.patch(self, patch_module)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/module/require_sub.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+class Module
+  def require_sub(file_path, options = {})
+    ::EacRubyUtils.require_sub(file_path, { base: self }.merge(options))
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/module/simple_cache.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/simple_cache'
+
+class Module
+  def enable_simple_cache
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::SimpleCache)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/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/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/object/asserts.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Object
+  # Raises a ArgumentError if +self+ is not a +klass+.
+  #
+  # @return +self+
+  def assert_argument(klass, argument_name = 'unknown_argument_name')
+    return self if is_a?(klass)
+
+    raise ::ArgumentError,
+          "Argument \"#{argument_name}\" is not a #{klass}" \
+          "(Actual class: #{self.class}, actual value: #{self})"
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/object/if_present.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+class Object
+  # @return +block.call(self)+ if +self+ is present, +default_value+ otherwise.
+  def if_present(default_value = nil)
+    return default_value if blank?
+
+    block_given? ? yield(self) : self
+  end
+
+  # @return +yield+ if +self+ is blank.
+  def if_blank
+    return yield if blank? && block_given?
+
+    self
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/object/template.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_ruby_utils/templates/searcher'
+
+class Object
+  class << self
+    def template
+      @template ||= ::EacRubyUtils::Templates::Searcher.default.template(name.underscore)
+    end
+  end
+
+  def template
+    self.class.template
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/object/to_pathname.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'pathname'
+
+class Object
+  # Convert +self+ to String and then to Pathname. Return nil if +self+ is +blank?+.
+  #
+  # @return [Pathname]
+  def to_pathname
+    return self if is_a?(::Pathname)
+
+    to_s.blank? ? nil : ::Pathname.new(to_s)
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/pathname.rb

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/pathname/basename_sub.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  def basename_sub
+    parent.join(yield(basename))
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/regexp.rb

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/regexp/if_match.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Regexp
+  # If +self+ matches +string+ returns +block.call(Match result) or only Match result if block is
+  # not provided.
+  # If +self+ does not match +string+ raises a +ArgumentError+ if +required+ is truthy or return
+  # +nil+ otherwise.
+  def if_match(string, required = true, &block)
+    m = match(string)
+    if m
+      block ? block.call(m) : m
+    elsif required
+      raise(::ArgumentError, "Pattern \"#{self}\" does not match string \"#{string}\"")
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/time.rb

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/time/default_time_zone_set.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/time/local_time_zone'
+
+::Time.zone = ::Time.local_time_zone

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/patches/time/local_time_zone.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/time/zones'
+require 'eac_ruby_utils/envs'
+
+class Time
+  class << self
+    TIMEDATECTL_TIMEZONE_LINE_PATTERN = %r{\s*Time zone:\s*(\S+/\S+)\s}.freeze
+
+    def local_time_zone
+      local_time_zone_by_timedatectl || local_time_zone_by_offset
+    end
+
+    def local_time_zone_by_timedatectl
+      executable = ::EacRubyUtils::Envs.local.executable('timedatectl', '--version')
+      return nil unless executable.exist?
+
+      TIMEDATECTL_TIMEZONE_LINE_PATTERN.if_match(executable.command.execute!) { |m| m[1] }
+    end
+
+    def local_time_zone_by_offset
+      ::ActiveSupport::TimeZone[::Time.now.getlocal.gmt_offset].name
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+require 'eac_ruby_utils/patches/object/asserts'
+
+module EacRubyUtils
+  class PathsHash
+    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
+        r.start_with?('.') || r.end_with?('.')
+
+        r = r.split('.').map(&:strip)
+        raise EntryKeyError, "Entry key \"#{entry_key}\" is empty" if r.empty?
+        return r.map(&:to_sym) unless r.any?(&:blank?)
+
+        raise EntryKeyError, "Entry key \"#{entry_key}\" has at least one blank part"
+      end
+    end
+
+    attr_reader :root
+
+    def initialize(source_hash = {})
+      @root = Node.new(source_hash)
+    end
+
+    def [](entry_key)
+      root.read_entry(self.class.parse_entry_key(entry_key), [])
+    end
+
+    def []=(entry_key, entry_value)
+      root.write_entry(self.class.parse_entry_key(entry_key), entry_value, [])
+    end
+
+    delegate :to_h, to: :root
+
+    private
+
+    attr_reader :data
+
+    class EntryKeyError < StandardError
+    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 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
+
+      def validate_path(path, current)
+        path.assert_argument(Array, 'path')
+        current.assert_argument(Array, 'current')
+        raise EntryKeyError, 'Path is empty' if path.empty?
+      end
+
+      attr_reader :data
+    end
+  end
+end