avm-tools 0.50.0 → 0.54.1

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/fs/traversable.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/fs/traverser'
+
+module EacRubyUtils
+  module Fs
+    module Traversable
+      PROP_METHOD_PREFIX = 'traverser_'
+      BOOLEAN_PROPS = %i[hidden_directories recursive sort].freeze
+      PATH_PROPS = %i[check_directory check_file].freeze
+
+      class << self
+        def prop_method_name(prop)
+          "#{PROP_METHOD_PREFIX}#{prop}"
+        end
+      end
+
+      PATH_PROPS.each do |method|
+        define_method(::EacRubyUtils::Fs::Traversable.prop_method_name(method)) do |_path|
+          nil
+        end
+      end
+
+      BOOLEAN_PROPS.each do |method|
+        define_method(::EacRubyUtils::Fs::Traversable.prop_method_name(method)) do
+          false
+        end
+
+        define_method("#{::EacRubyUtils::Fs::Traversable.prop_method_name(method)}?") do
+          send(method_name)
+        end
+      end
+
+      def traverser_check_path(path)
+        traverser_new.check_path(path)
+      end
+
+      def traverser_new
+        r = ::EacRubyUtils::Fs::Traverser.new
+        (BOOLEAN_PROPS + PATH_PROPS).each do |prop|
+          r.send("#{prop}=", method(::EacRubyUtils::Fs::Traversable.prop_method_name(prop)))
+        end
+        r
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/fs/traverser.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Fs
+    class Traverser
+      attr_accessor :check_directory, :check_file, :recursive, :hidden_directories, :sort
+
+      def check_path(path)
+        path = ::Pathname.new(path.to_s) unless path.is_a?(::Pathname)
+        internal_check_path(path, 0)
+      end
+
+      def hidden_directories?
+        boolean_value(hidden_directories)
+      end
+
+      def recursive?
+        boolean_value(recursive)
+      end
+
+      def sort?
+        boolean_value(sort)
+      end
+
+      private
+
+      def boolean_value(source_value)
+        source_value = source_value.call if source_value.respond_to?(:call)
+        source_value ? true : false
+      end
+
+      def each_child(dir, &block)
+        if sort?
+          dir.each_child.sort_by { |p| [p.to_s] }.each(&block)
+        else
+          dir.each_child(&block)
+        end
+      end
+
+      def process_directory?(level)
+        level.zero? || recursive?
+      end
+
+      def inner_check_directory(dir, level)
+        return unless process_directory?(level)
+
+        user_check_directory(dir)
+        each_child(dir) do |e|
+          next unless !e.basename.to_s.start_with?('.') || hidden_directories?
+
+          internal_check_path(e, level + 1)
+        end
+      end
+
+      def internal_check_path(path, level)
+        if path.file?
+          user_check_file(path)
+        elsif path.directory?
+          inner_check_directory(path, level)
+        else
+          raise "Unknown filesystem object: #{path}"
+        end
+      end
+
+      def user_check_file(path)
+        check_file&.call(path)
+      end
+
+      def user_check_directory(path)
+        check_directory&.call(path)
+      end
+    end
+  end
+end

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