avm-tools 0.48.0 → 0.53.0

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/filesystem_cache'
+
+module EacRubyUtils
+  class << self
+    def fs_cache
+      @fs_cache ||= ::EacRubyUtils::FilesystemCache.new(::Dir.tmpdir, 'eac_ruby_utils', '.cache')
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+Dir["#{__dir__}/#{::File.basename(__FILE__, '.*')}/*.rb"].sort.each do |partial|
+  require partial
+end
+
+module EacRubyUtils
+  module Listable
+    extend ActiveSupport::Concern
+
+    included do
+      extend(ClassMethods)
+      include(InstanceMethods)
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/class_methods.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'i18n'
+require_relative 'lists'
+
+module EacRubyUtils
+  module Listable
+    module ClassMethods
+      def lists
+        @lists ||= ::EacRubyUtils::Listable::Lists.new(self)
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/instance_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Listable
+    module InstanceMethods
+      LISTABLE_INSTANCE_VALUE_METHODS = %w[label description].freeze
+
+      def method_missing(name, *args, &block)
+        list, method = parse_method(name)
+        list && method ? list.instance_value(self).send(method) : super
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        list, method = parse_method(name)
+        list && method ? true : super
+      end
+
+      private
+
+      def parse_method(method)
+        self.class.lists.acts_as_listable_items.each do |item, list|
+          LISTABLE_INSTANCE_VALUE_METHODS.each do |m|
+            return [list, m] if method.to_s == "#{item}_#{m}"
+          end
+        end
+        [nil, nil]
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/integer_list.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+
+module EacRubyUtils
+  module Listable
+    class IntegerList < ::EacRubyUtils::Listable::List
+      protected
+
+      def parse_labels(labels)
+        if labels.first.is_a?(Hash)
+          Hash[labels.first.map { |k, v| [k.to_i, v.to_s] }]
+        else
+          Hash[labels.each_with_index.map { |v, i| [i + 1, v.to_s] }]
+        end
+      end
+
+      def build_value(index, _key)
+        index + 1
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/list.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Listable
+    class List
+      attr_reader :item
+
+      def initialize(lists, item, labels)
+        @lists = lists
+        @item = item
+        @values = build_values(labels)
+        apply_constants
+      end
+
+      def each_value(&block)
+        values.each(&block)
+      end
+
+      def values
+        @values.values.map(&:value)
+      end
+
+      def options
+        @values.values.map { |v| [v.label, v.value] }
+      end
+
+      def method_missing(name, *args, &block)
+        list = find_list_by_method(name)
+        list || super
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        find_list_by_method(name) || super
+      end
+
+      def i18n_key
+        "eac_ruby_utils.listable.#{class_i18n_key}.#{item}"
+      end
+
+      def instance_value(instance)
+        v = instance.send(item)
+        return @values[v] if @values.key?(v)
+
+        raise "List value unkown: #{v} (Source: #{@lists.source}, Item: #{item})"
+      end
+
+      def value_valid?(value)
+        values.include?(value)
+      end
+
+      def value_validate!(value, error_class = ::StandardError)
+        value_valid?(value) ||
+          raise(error_class, "Invalid value: \"#{value}\" (Valid: #{values_to_s})")
+      end
+
+      def values_to_s
+        values.map { |v| "\"#{v}\"" }.join(', ')
+      end
+
+      private
+
+      def class_i18n_key
+        @lists.source.name.underscore.to_sym
+      end
+
+      def find_list_by_method(method)
+        @values.values.each do |v|
+          return v if method.to_s == "value_#{v.key}"
+        end
+        nil
+      end
+
+      def constants
+        labels.each_with_index.map { |v, i| ["#{item.upcase}_#{v.upcase}", values[i]] }
+      end
+
+      def apply_constants
+        @values.values.each do |v|
+          @lists.source.const_set(v.constant_name, v.value)
+        end
+      end
+
+      def build_values(labels)
+        vs = {}
+        parse_labels(labels).each do |value, key|
+          v = Value.new(self, value, key)
+          vs[v.value] = v
+        end
+        vs
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/lists.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/string/inflections'
+require_relative 'integer_list'
+require_relative 'string_list'
+require_relative 'symbol_list'
+
+module EacRubyUtils
+  module Listable
+    class Lists
+      attr_reader :source
+
+      def initialize(source)
+        @source = source
+      end
+
+      %w[integer string symbol].each do |list_type|
+        define_method "add_#{list_type}" do |item, *labels|
+          add(::EacRubyUtils::Listable.const_get("#{list_type}_list".camelize), item, labels)
+        end
+      end
+
+      def method_missing(name, *args, &block)
+        list = find_list_by_method(name)
+        list || super
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        find_list_by_method(name) || super
+      end
+
+      def acts_as_listable_items
+        @acts_as_listable_items ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      private
+
+      def add(list_class, item, labels)
+        check_acts_as_listable_new_item(item)
+        acts_as_listable_items[item] = list_class.new(self, item, labels)
+      end
+
+      def check_acts_as_listable_new_item(item)
+        return unless acts_as_listable_items.key?(item)
+
+        raise "Item já adicionado anteriormente: #{item} em #{self} " \
+          "(#{acts_as_listable_items.keys})"
+      end
+
+      def find_list_by_method(method)
+        acts_as_listable_items.each do |item, list|
+          return list if method.to_sym == item.to_sym
+        end
+        nil
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/string_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+
+module EacRubyUtils
+  module Listable
+    class StringList < ::EacRubyUtils::Listable::List
+      protected
+
+      def parse_labels(labels)
+        if labels.first.is_a?(Hash)
+          Hash[labels.first.map { |k, v| [k.to_s, v.to_s] }]
+        else
+          Hash[labels.map { |v| [v.to_s, v.to_s] }]
+        end
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/symbol_list.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'list'
+
+module EacRubyUtils
+  module Listable
+    class SymbolList < ::EacRubyUtils::Listable::List
+      protected
+
+      def parse_labels(labels)
+        if labels.first.is_a?(Hash)
+          Hash[labels.first.map { |k, v| [k.to_sym, v.to_sym] }]
+        else
+          Hash[labels.map { |v| [v.to_sym, v.to_sym] }]
+        end
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/listable/value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Listable
+    class Value
+      attr_reader :value, :key
+
+      def initialize(list, value, key)
+        @list = list
+        @value = value
+        @key = key
+      end
+
+      def to_s
+        "I: #{@list.item}, V: #{@value}, K: #{@key}"
+      end
+
+      def constant_name
+        "#{@list.item}_#{@key}".gsub(/[^a-z0-9_]/, '_').gsub(/_+/, '_')
+                               .gsub(/(?:\A_|_\z)/, '').upcase
+      end
+
+      def label
+        translate('label')
+      end
+
+      def description
+        translate('description')
+      end
+
+      private
+
+      def translate(translate_key)
+        ::I18n.t("#{@list.i18n_key}.#{@key}.#{translate_key}")
+      end
+    end
+  end
+end

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