avm-tools 0.48.0 → 0.53.0

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

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/rspec/conditional.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_ruby_utils/console/speaker'
+
+module EacRubyUtils
+  module Rspec
+    class Conditional
+      include ::EacRubyUtils::Console::Speaker
+
+      def self.default
+        @default ||= new
+      end
+
+      def initialize
+        @tags = {}
+      end
+
+      def add(tag, &condition)
+        tags[tag] = condition
+      end
+
+      def configure(rspec_config)
+        tags.each do |tag, condition|
+          message = condition.call
+          if message.present?
+            warn("Excluded tag: #{tag}: #{message}")
+            rspec_config.filter_run_excluding tag
+          end
+        end
+      end
+
+      private
+
+      attr_reader :tags
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/rspec/stubbed_ssh.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_ruby_utils/envs/ssh_env'
+require 'eac_ruby_utils/patches/object/if_present'
+
+module EacRubyUtils
+  module Rspec
+    class StubbedSsh
+      DEFAULT_ENVVAR_NAME = 'STUBBED_SSH_URL'
+
+      class << self
+        def default
+          @default ||= new(DEFAULT_ENVVAR_NAME)
+        end
+      end
+
+      attr_reader :envvar_name
+
+      def initialize(envvar_name)
+        @envvar_name = envvar_name
+      end
+
+      def validate
+        return nil if provided_url.present?
+
+        "Environment variable \"#{envvar_name}\" unprovided or blank"
+      end
+
+      def validate!
+        validate.if_present { |v| raise v }
+      end
+
+      def provided_url
+        ENV[envvar_name]
+      end
+
+      def build_env
+        validate!
+        ::EacRubyUtils::Envs::SshEnv.new(provided_url)
+      end
+    end
+  end
+end

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

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/ruby/command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/envs/command'
+require 'eac_ruby_utils/ruby/on_clean_environment'
+
+module EacRubyUtils
+  module Ruby
+    # A [EacRubyUtils::Envs::Command] which runs in a clean Ruby environment.
+    class Command < ::EacRubyUtils::Envs::Command
+      def initialize(bundle_args, extra_options = {})
+        super(::EacRubyUtils::Envs.local, bundle_args, extra_options)
+      end
+
+      %w[system execute].each do |method_prefix|
+        [method_prefix, "#{method_prefix}!"].each do |method_name|
+          define_method method_name do |*args, &block|
+            ::EacRubyUtils::Ruby.on_clean_environment do
+              super(*args, &block)
+            end
+          end
+        end
+      end
+
+      protected
+
+      def duplicate(command, extra_options)
+        self.class.new(gem, command, extra_options)
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/ruby/on_clean_environment.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Ruby
+    class << self
+      # Executes a block in an environment when the variables BUNDLE* and RUBY* are removed.
+      def on_clean_environment
+        on_clean_envvars('BUNDLE', 'RUBY') { yield }
+      end
+
+      private
+
+      def on_clean_envvars(*start_with_vars)
+        old_values = envvars_starting_with(start_with_vars)
+        old_values.keys.each { |k| ENV.delete(k) }
+        yield
+      ensure
+        old_values&.each { |k, v| ENV[k] = v }
+      end
+
+      def envvars_starting_with(start_with_vars)
+        ENV.select { |k, _v| start_with_vars.any? { |var| k.start_with?(var) } }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_ruby_utils/options_consumer'
+
+module EacRubyUtils
+  # Provide a option by constant, method or options object.
+  module SettingsProvider
+    def setting_constant_name(key, fullname = false)
+      name = key.to_s.underscore.upcase
+      name = "#{self.class.name}::#{name}" if fullname
+      name
+    end
+
+    def setting_search_order
+      %w[settings_object method constant]
+    end
+
+    def settings_object
+      respond_to?(settings_object_name) ? send(settings_object_name) : {}
+    end
+
+    def settings_object_name
+      'settings'
+    end
+
+    def setting_value(key, options = {})
+      options = parse_setting_value_options(options)
+      options.order.each do |method|
+        value = send("setting_value_by_#{method}", key)
+        return value if value
+      end
+      return nil unless options.required
+
+      raise "Setting \"#{key}\" not found. Supply in #{settings_object_name}, implement a " \
+        "\"#{key}\" method or declare a #{setting_constant_name(key, true)} constant."
+    end
+
+    def setting_value_by_constant(key)
+      constant_name = setting_constant_name(key)
+      begin
+        self.class.const_get(constant_name)
+      rescue NameError
+        nil
+      end
+    end
+
+    def setting_value_by_method(key)
+      respond_to?(key) ? send(key) : nil
+    end
+
+    def setting_value_by_settings_object(key)
+      settings_object[key.to_s] || settings_object[key.to_sym]
+    end
+
+    private
+
+    def parse_setting_value_options(options)
+      r = ::EacRubyUtils::OptionsConsumer.new(options).consume_all(:required, :order, ostruct: true)
+      r.required = true if r.required.nil?
+      r.order = setting_search_order if r.order.nil?
+      r
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module SimpleCache
+    UNCACHED_METHOD_PATTERN = /\A(\s+)_uncached\z/.freeze
+
+    def method_missing(method, *args, &block)
+      uncached_method = "#{method}_uncached"
+      if respond_to?(uncached_method, true)
+        call_method_with_cache(uncached_method, args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_all = false)
+      if method.to_s.end_with?('_uncached')
+        super
+      else
+        respond_to?("#{method}_uncached", true) || super
+      end
+    end
+
+    def reset_cache
+      @cache_keys = nil
+    end
+
+    private
+
+    def call_method_with_cache(method, args, &block)
+      raise 'Não é possível realizar o cache de métodos com bloco' if block
+
+      key = ([method] + args).join('@@@')
+      cache_keys[key] = send(method, *args) unless cache_keys.key?(key)
+      cache_keys[key]
+    end
+
+    def cache_keys
+      @cache_keys ||= {}
+    end
+  end
+end

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

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

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/templates/directory.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/templates/file'
+
+module EacRubyUtils
+  module Templates
+    class Directory
+      TEMPLATE_EXTNAME = '.template'
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path.is_a?(::Pathname) ? path : ::Pathname.new(path.to_s)
+      end
+
+      def apply(variables_source, directory)
+        TemplateNode.new(self, '.', directory, variables_source).apply
+      end
+
+      def child(subpath)
+        child_path = ::File.join(path, subpath)
+        return ::EacRubyUtils::Templates::File.new(child_path) if ::File.file?(child_path)
+        return ::EacRubyUtils::Templates::Directory.new(child_path) if ::File.directory?(child_path)
+
+        raise "Child \"#{subpath}\" from \"#{path}\" not found"
+      end
+
+      def children
+        path.children.map do |path_child|
+          child(path_child.basename.to_path)
+        end
+      end
+
+      private
+
+      def apply_fs_object(source_relative, target)
+        if ::File.directory?(source_absolute(source_relative))
+          apply_directory(source_relative, target)
+        elsif ::File.file?(source_absolute(source_relative))
+        end
+      end
+
+      def source_absolute(source_relative)
+        ::File.expand_path(source_relative, path)
+      end
+
+      class TemplateNode
+        attr_reader :source_directory, :source_relative, :target_root_directory, :variables_source
+
+        def initialize(source_directory, source_relative, target_root_directory, variables_source)
+          @source_directory = source_directory
+          @source_relative = source_relative
+          @target_root_directory = target_root_directory
+          @variables_source = variables_source
+        end
+
+        def apply
+          if file?
+            apply_file
+          elsif directory?
+            apply_directory
+          else
+            raise "Unknown filesystem type: #{source_absolute}"
+          end
+        end
+
+        private
+
+        def apply_directory
+          ::FileUtils.mkdir_p(target_absolute)
+          Dir.entries(source_absolute).each do |entry|
+            child(entry).apply unless %w[. ..].include?(entry)
+          end
+        end
+
+        def apply_file
+          if ::File.extname(source_absolute) == TEMPLATE_EXTNAME
+            ::EacRubyUtils::Templates::File.new(source_absolute).apply_to_file(
+              variables_source, target_absolute
+            )
+          else
+            ::FileUtils.cp(source_absolute, target_absolute)
+          end
+        end
+
+        def child(entry)
+          TemplateNode.new(source_directory, ::File.join(source_relative, entry),
+                           target_root_directory, variables_source)
+        end
+
+        def file?
+          ::File.file?(source_absolute)
+        end
+
+        def directory?
+          ::File.directory?(source_absolute)
+        end
+
+        def source_absolute
+          ::File.expand_path(source_relative, source_directory.path)
+        end
+
+        def target_absolute
+          ::File.expand_path(source_relative, target_root_directory)
+                .gsub(/#{::Regexp.quote(TEMPLATE_EXTNAME)}\z/, '')
+        end
+      end
+    end
+  end
+end

data/vendor/gems/eac_ruby_utils/lib/eac_ruby_utils/templates/file.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/templates/variable_providers'
+
+module EacRubyUtils
+  module Templates
+    class File
+      VARIABLE_DELIMITER = ::Regexp.quote('%%')
+      VARIABLE_PATTERN = /#{VARIABLE_DELIMITER}([a-z0-9\._]*)#{VARIABLE_DELIMITER}/i.freeze
+
+      enable_simple_cache
+      common_constructor :path do
+        self.path = path.to_pathname
+      end
+
+      # +variables_provider+ A [Hash] or object which responds to +read_entry(entry_name)+.
+      def apply(variables_source)
+        variables_provider = ::EacRubyUtils::Templates::VariableProviders.build(variables_source)
+        variables.inject(content) do |a, e|
+          a.gsub(variable_pattern(e), variables_provider.variable_value(e).to_s)
+        end
+      end
+
+      def apply_to_file(variables_source, output_file_path)
+        output_file_path.to_pathname.write(apply(variables_source))
+      end
+
+      private
+
+      def variables_uncached
+        content.scan(VARIABLE_PATTERN).map(&:first).map do |name|
+          sanitize_variable_name(name)
+        end.to_set
+      end
+
+      def content_uncached
+        path.read
+      end
+
+      def sanitize_variable_name(variable_name)
+        variable_name.to_s.downcase
+      end
+
+      def variable_pattern(name)
+        /#{VARIABLE_DELIMITER}#{::Regexp.quote(name)}#{VARIABLE_DELIMITER}/i
+      end
+    end
+  end
+end