ehbrs-tools 0.3.0

data/vendor/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/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/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/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/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/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/eac_ruby_utils/lib/eac_ruby_utils/templates/directory.rb

@@ -0,0 +1,104 @@
+# 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
+      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
+
+      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/eac_ruby_utils/lib/eac_ruby_utils/templates/file.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/indifferent_access'
+require 'eac_ruby_utils/simple_cache'
+
+module EacRubyUtils
+  module Templates
+    class File
+      include ::EacRubyUtils::SimpleCache
+
+      VARIABLE_DELIMITER = ::Regexp.quote('%%')
+      VARIABLE_PATTERN = /#{VARIABLE_DELIMITER}([a-z0-9\._]*)#{VARIABLE_DELIMITER}/i.freeze
+
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      # +variables_provider+ A [Hash] or object which responds to +read_entry(entry_name)+.
+      def apply(variables_source)
+        variables_provider = build_variables_provider(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)
+        ::File.write(output_file_path, 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
+        ::File.read(path)
+      end
+
+      def sanitize_variable_name(variable_name)
+        variable_name.to_s.downcase
+      end
+
+      def build_variables_provider(variables_source)
+        return HashVariablesProvider.new(variables_source) if variables_source.is_a?(::Hash)
+        return EntriesReaderVariablesProvider.new(variables_source) if
+        variables_source.respond_to?(:read_entry)
+
+        raise "Variables provider not found for #{variables_source}"
+      end
+
+      def variable_pattern(name)
+        /#{VARIABLE_DELIMITER}#{::Regexp.quote(name)}#{VARIABLE_DELIMITER}/i
+      end
+
+      class BaseVariablesProvider
+        attr_reader :source
+
+        def initialize(source)
+          @source = source
+        end
+
+        def variable_value(name)
+          return variable_fetch(name) if variable_exist?(name)
+
+          raise VariableNotFoundError, "Variable \"#{name}\" not found in #{source}"
+        end
+      end
+
+      class HashVariablesProvider < BaseVariablesProvider
+        def initialize(source)
+          super(source.with_indifferent_access)
+        end
+
+        def variable_exist?(name)
+          source.key?(name)
+        end
+
+        def variable_fetch(name)
+          source.fetch(name)
+        end
+      end
+
+      class EntriesReaderVariablesProvider < BaseVariablesProvider
+        def variable_exist?(_name)
+          true
+        end
+
+        def variable_fetch(name)
+          source.read_entry(name)
+        end
+      end
+
+      class VariableNotFoundError < StandardError; end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'eac_ruby_utils/templates/directory'
+require 'eac_ruby_utils/templates/file'
+
+module EacRubyUtils
+  module Templates
+    class Searcher
+      class << self
+        def default
+          @default ||= new
+        end
+      end
+
+      def template(subpath, required = true)
+        path = template_path(subpath)
+        if path.blank?
+          return nil unless required
+
+          raise_template_not_found(subpath)
+        end
+        return ::EacRubyUtils::Templates::File.new(path) if ::File.file?(path)
+        return ::EacRubyUtils::Templates::Directory.new(path) if ::File.directory?(path)
+
+        raise 'Invalid branching'
+      end
+
+      # @return The absolute path of template if found, +nil+ otherwise.
+      def template_path(subpath)
+        included_paths.each do |included_path|
+          r = search_template_in_included_path(included_path, subpath)
+          return r if r
+        end
+        nil
+      end
+
+      def included_paths
+        @included_paths ||= ::Set.new
+      end
+
+      private
+
+      def raise_template_not_found(subpath)
+        raise "Template not found for subpath \"#{subpath}\"" \
+          " (Included paths: #{included_paths.to_a.join(::File::PATH_SEPARATOR)})"
+      end
+
+      def search_template_in_included_path(included_path, subpath)
+        path = ::File.join(included_path, subpath)
+        ::File.exist?(path) ? path : nil
+      end
+    end
+  end
+end