avm-tools 0.109.0 → 0.112.0

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

@@ -1,47 +0,0 @@
-# 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/eac_ruby_utils/lib/eac_ruby_utils/fs/traverser.rb

@@ -1,72 +0,0 @@
-# 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)
-        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/eac_ruby_utils/lib/eac_ruby_utils/fs.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-
-module EacRubyUtils
-  module Fs
-    ::EacRubyUtils.require_sub __FILE__
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/gems_registry/gem.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-require 'eac_ruby_utils/recursive_builder'
-require 'eac_ruby_utils/simple_cache'
-
-module EacRubyUtils
-  class GemsRegistry
-    class Gem
-      include ::Comparable
-      include ::EacRubyUtils::SimpleCache
-
-      attr_reader :registry, :gemspec
-
-      def initialize(registry, gemspec)
-        @registry = registry
-        @gemspec = gemspec
-      end
-
-      def depend_on(gem)
-        dependencies.lazy.map(&:name).include?(gem.gemspec.name)
-      end
-
-      def dependencies
-        @dependencies ||= dependencies_uncached # dependencies_uncached
-      end
-
-      def <=>(other)
-        sd = depend_on(other)
-        od = other.depend_on(self)
-        return 1 if sd && !od
-        return -1 if od && !sd
-
-        gemspec.name <=> other.gemspec.name
-      end
-
-      def found?
-        lib_file_found? && registered_module.is_a?(::Module)
-      end
-
-      def lib_file_found?
-        gemspec.require_paths.any? do |require_path|
-          ::Pathname.new(require_path).expand_path(gemspec.gem_dir).join(path_to_require + '.rb')
-                    .file?
-        end
-      end
-
-      def registered_module
-        return nil unless lib_file_found?
-
-        require path_to_require
-        path_to_require.classify.constantize
-      end
-
-      # @return [String]
-      def path_to_require
-        gemspec.name.gsub('-', '/') + '/' + registry.module_suffix.underscore
-      end
-
-      private
-
-      def dependencies_uncached
-        ::EacRubyUtils::RecursiveBuilder
-          .new(gemspec) { |item| gem_item_dependencies(item) }
-          .result
-      end
-
-      def gem_item_dependencies(item)
-        ::Gem::Specification.find_by_name(item.name).dependencies
-      rescue ::Gem::MissingSpecError
-        []
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/gems_registry.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'eac_ruby_utils/gems_registry/gem'
-
-module EacRubyUtils
-  # Search in each gem for a class determined by registry and run the method "register" on each
-  # found.
-  #
-  # Example:
-  # * The module suffix is `TheClass`;
-  # * A gem with name "my-lib" is being analyzed
-  # * If a require for "my/lib/the_class" is succesful the class/module `My::Lib::TheClass` will
-  #   be collected.
-  class GemsRegistry
-    attr_reader :module_suffix
-
-    def initialize(module_suffix)
-      @module_suffix = module_suffix
-    end
-
-    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
-    def registered
-      @registered ||= all_gems.select(&:found?)
-    end
-
-    private
-
-    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
-    def all_gems
-      ::Gem::Specification.map { |gemspec| ::EacRubyUtils::GemsRegistry::Gem.new(self, gemspec) }
-                          .sort
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/array_accessor.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/inflector'
-require 'eac_ruby_utils/immutable/base_accessor'
-require 'eac_ruby_utils/patches/class/common_constructor'
-
-module EacRubyUtils
-  module Immutable
-    class ArrayAccessor < ::EacRubyUtils::Immutable::BaseAccessor
-      def apply(klass)
-        accessor = self
-        klass.send(:define_method, name) do |value|
-          accessor.immutable_value_set(self, value)
-        end
-
-        klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do
-          accessor.immutable_value_get(self)
-        end
-      end
-
-      def immutable_value_get(object)
-        super || []
-      end
-
-      def immutable_value_set(object, value)
-        duplicate_object(object) do |old_value|
-          (old_value || []) + [value]
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/base_accessor.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Immutable
-    class BaseAccessor
-      common_constructor :name do
-        self.name = name.to_sym
-      end
-
-      def duplicate_object(object)
-        accessor_new_value = yield(immutable_value_get(object))
-        new_values = object.send(:immutable_values_get).merge(name => accessor_new_value)
-        r = object.class.new(*object.immutable_constructor_args)
-        r.send(:immutable_values_set, new_values)
-        r
-      end
-
-      def immutable_value_get(object)
-        object.send(:immutable_values_get)[name]
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/boolean_accessor.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/immutable/common_accessor'
-require 'eac_ruby_utils/patches/class/common_constructor'
-
-module EacRubyUtils
-  module Immutable
-    class BooleanAccessor < ::EacRubyUtils::Immutable::CommonAccessor
-      def apply(klass)
-        super
-        accessor = self
-        klass.send(:define_method, "#{name}?") { send(accessor.name) }
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/class_methods.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Immutable
-    module ClassMethods
-      def immutable_accessor(*accessors)
-        options = accessors.extract_options!
-        options[:type] ||= const_get('TYPE_COMMON')
-        accessors.each do |name|
-          class_name = options.fetch(:type).to_s.camelize + 'Accessor'
-          ::EacRubyUtils::Immutable.const_get(class_name).new(name).apply(self)
-        end
-      end
-
-      private
-
-      def imutable_single_accessor(name, options); end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/common_accessor.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/immutable/base_accessor'
-require 'eac_ruby_utils/patches/class/common_constructor'
-
-module EacRubyUtils
-  module Immutable
-    class CommonAccessor < ::EacRubyUtils::Immutable::BaseAccessor
-      def apply(klass)
-        accessor = self
-        klass.send(:define_method, name) do |*args|
-          case args.count
-          when 0 then next accessor.immutable_value_get(self)
-          when 1 then next accessor.immutable_value_set(self, args.first)
-          else
-            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 0..1)"
-          end
-        end
-      end
-
-      def immutable_value_get(object)
-        object.send(:immutable_values_get)[name]
-      end
-
-      def immutable_value_set(object, value)
-        duplicate_object(object) { |_old_value| value }
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/hash_accessor.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/immutable/base_accessor'
-require 'eac_ruby_utils/patches/class/common_constructor'
-
-module EacRubyUtils
-  module Immutable
-    class HashAccessor < ::EacRubyUtils::Immutable::BaseAccessor
-      def apply(klass)
-        apply_get(klass)
-        apply_set(klass)
-      end
-
-      def immutable_value_get(object)
-        super || {}
-      end
-
-      def immutable_value_set(object, key, value)
-        duplicate_object(object) do |old_value|
-          (old_value || {}).merge(key => value)
-        end
-      end
-
-      private
-
-      def apply_get(klass)
-        accessor = self
-        klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do
-          accessor.immutable_value_get(self)
-        end
-      end
-
-      def apply_set(klass)
-        accessor = self
-        klass.send(:define_method, name) do |*args|
-          case args.count
-          when 1 then next accessor.immutable_value_get(self, args[0])
-          when 2 then next accessor.immutable_value_set(self, *args[0..1])
-          else
-            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 1..2)"
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable/instance_methods.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Immutable
-    module InstanceMethods
-      def immutable_constructor_args
-        []
-      end
-
-      private
-
-      def immutable_values_get
-        @immutable_values || {}
-      end
-
-      def immutable_values_set(new_values)
-        @immutable_values = new_values
-      end
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/immutable.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/module/common_concern'
-require 'eac_ruby_utils/require_sub'
-
-module EacRubyUtils
-  module Immutable
-    ::EacRubyUtils.require_sub __FILE__
-
-    common_concern do
-      include ::EacRubyUtils::Listable
-      lists.add_symbol :type, :array, :boolean, :common, :hash
-    end
-  end
-end

data/vendor/eac_ruby_utils/lib/eac_ruby_utils/inflector.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/inflector'
-
-module EacRubyUtils
-  class Inflector
-    class << self
-      VARIABLE_NAME_PATTERN = /[_a-z][_a-z0-9]*/i.freeze
-
-      # Convert a string to a variable format: first character as a lowercase letter or underscore
-      # and other as a lowercase letter, underscore or numbers.
-      # @param string [String] The source string.
-      # @param validate [Boolean] Affect the outcome when the result builded is not in a valid
-      #   variable format. If `true`, it raises a {ArgumentError}. If `false`, return `nil`.
-      # @return [String, nil]
-      # @raise [ArgumentError]
-      def variableize(string, validate = true)
-        r = ::ActiveSupport::Inflector.transliterate(string).gsub(/[^_a-z0-9]/i, '_')
-                                      .gsub(/_+/, '_').gsub(/_\z/, '').gsub(/\A_/, '').downcase
-        m = VARIABLE_NAME_PATTERN.match(r)
-        return r if m
-        return nil unless validate
-
-        raise ::ArgumentError, "Invalid variable name \"#{r}\" was generated " \
-          "from string \"#{string}\""
-      end
-    end
-  end
-end

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

@@ -1,14 +0,0 @@
-# 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/eac_ruby_utils/lib/eac_ruby_utils/listable/instance_methods.rb

@@ -1,30 +0,0 @@
-# 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/eac_ruby_utils/lib/eac_ruby_utils/listable/integer_list.rb

@@ -1,23 +0,0 @@
-# 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/eac_ruby_utils/lib/eac_ruby_utils/listable/list.rb

@@ -1,99 +0,0 @@
-# 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 hash_keys_validate!(hash, error_class = ::StandardError)
-        hash.keys.each { |key| value_validate!(key, error_class) }
-        hash
-      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)
-        return value if 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