eac_tools 0.97.1 → 0.97.2

data/sub/eac_ruby_utils/lib/eac_ruby_utils/rspec/setup_manager.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/gems_registry'
+require 'eac_ruby_utils/patches/object/if_respond'
+require 'eac_ruby_utils/patches/object/to_pathname'
+
+module EacRubyUtils
+  module Rspec
+    class SetupManager
+      GEMS_REGISTRY_SUFFIX = 'Rspec::Setup'
+
+      class << self
+        def create(app_root_path, rspec_config = nil)
+          if rspec_config
+            new(app_root_path, rspec_config)
+          else
+            ::RSpec.configure { |new_rspec_config| new(app_root_path, new_rspec_config) }
+          end
+        end
+      end
+
+      attr_reader :app_root_path, :rspec_config
+
+      def initialize(app_root_path, rspec_config)
+        @app_root_path = app_root_path.to_pathname
+        @rspec_config = rspec_config
+        include_registry
+      end
+
+      # @return [EacRubyUtils::GemsRegistry]
+      def gems_registry
+        @gems_registry ||= ::EacRubyUtils::GemsRegistry.new(GEMS_REGISTRY_SUFFIX)
+      end
+
+      protected
+
+      def include_registry
+        gems_registry.registered.each do |gem|
+          include_gem_registered(gem.registered_module)
+        end
+      end
+
+      # @param gem [EacRubyUtils::GemsRegistry::Gem]
+      def include_gem_registered(registered_module)
+        extend(registered_module)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/rspec/stub_speaker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/speaker/receiver'
+
+module EacRubyUtils
+  module Rspec
+    class StubSpeaker
+      include ::EacRubyUtils::Speaker::Receiver
+
+      def error(_string); end
+
+      def fatal_error(string)
+        error(string)
+        raise('Fatal error')
+      end
+
+      # @see EacRubyUtils::Speaker::Sender.input
+      def input(_question, _options = {})
+        raise 'Input requested'
+      end
+
+      def info(_string); end
+
+      def infom(_string); end
+
+      def infov(*_args); end
+
+      def out(_string = ''); end
+
+      def puts(_string = ''); end
+
+      def success(_string); end
+
+      def title(_string); end
+
+      def warn(_string); end
+    end
+  end
+end

data/sub/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/sub/eac_ruby_utils/lib/eac_ruby_utils/ruby/command.rb

@@ -0,0 +1,32 @@
+# 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 = {})
+        host_env = extra_options.delete(:host_env)
+        super(host_env || ::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/sub/eac_ruby_utils/lib/eac_ruby_utils/ruby/on_clean_environment.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'bundler'
+require 'eac_ruby_utils/ruby/on_replace_objects'
+
+module EacRubyUtils
+  module Ruby
+    class << self
+      # Executes a block in an environment when the variables BUNDLE* and RUBY* are removed.
+      def on_clean_environment(&block)
+        OnCleanEnvironment.new(&block).perform
+      end
+
+      class OnCleanEnvironment
+        ENVVARS_PREFIXES_TO_CLEAN = %w[BUNDLE RUBY].freeze
+
+        attr_reader :block, :original_env
+
+        def initialize(&block)
+          @block = block
+          @original_env = ::ENV.to_h
+        end
+
+        # @return [Array<String>]
+        def envvars_prefixes_to_clean
+          ENVVARS_PREFIXES_TO_CLEAN
+        end
+
+        def perform
+          bundler_with_unbundled_env do
+            on_clean_envvars
+          end
+        end
+
+        private
+
+        def bundler_with_unbundled_env(&block)
+          with_bundler_modified do
+            ::Bundler.send(bundler_with_env_method_name, &block)
+          end
+        end
+
+        def bundler_with_env_method_name
+          if ::Bundler.respond_to?(:with_unbundled_env)
+            :with_unbundled_env
+          else
+            :with_clean_env
+          end
+        end
+
+        def clean_env
+          r = original_env.dup
+          r.delete_if { |k, _| envvars_prefixes_to_clean.any? { |prefix| k.start_with?(prefix) } }
+          r
+        end
+
+        def on_clean_envvars
+          ::Bundler.send('with_env', clean_env) { block.call }
+        end
+
+        def with_bundler_modified(&block)
+          cloned_env = original_env.dup
+          ::EacRubyUtils::Ruby.on_replace_objects do |replacer|
+            replacer.replace_self_method(::Bundler, :original_env) { cloned_env }
+            block.call
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/ruby/on_replace_objects/replace_instance_method.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'eac_ruby_utils/ruby/on_replace_objects/replace_instance_method'
+
+module EacRubyUtils
+  module Ruby
+    class OnReplaceObjects
+      class ReplaceInstanceMethod
+        attr_reader :a_module, :method_new_block, :original_method
+
+        def initialize(a_module, method_name, &method_new_block)
+          @a_module = a_module
+          @original_method = a_module.instance_method(method_name)
+          @method_new_block = method_new_block
+        end
+
+        def apply
+          a_module.define_method(method_name, &method_new_block)
+
+          self
+        end
+
+        def method_name
+          original_method.name
+        end
+
+        def restore
+          a_module.define_method(method_name, original_method)
+
+          self
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/ruby/on_replace_objects.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'eac_ruby_utils/ruby/on_replace_objects/replace_instance_method'
+
+module EacRubyUtils
+  module Ruby
+    class << self
+      def on_replace_objects
+        replacer = OnReplaceObjects.new
+        replacer.on_replacement do
+          yield(replacer)
+        end
+      end
+    end
+
+    class OnReplaceObjects
+      def on_replacement(&block)
+        clear_replacements
+        block.call(self)
+      ensure
+        restore_replacements
+      end
+
+      def replace_instance_method(a_module, method_name, &block)
+        add_replacement(__method__, a_module, method_name, &block)
+      end
+
+      def replace_self_method(object, method_name, &block)
+        add_replacement(:replace_instance_method, object.singleton_class, method_name, &block)
+      end
+
+      private
+
+      def add_replacement(method_name, *args, &block)
+        @replacements << replacement_class(method_name).new(*args, &block).apply
+      end
+
+      def replacement_class(method_name)
+        self.class.const_get(::ActiveSupport::Inflector.camelize(method_name))
+      end
+
+      def clear_replacements
+        @replacements = []
+      end
+
+      def restore_replacements
+        @replacements.reverse.each(&:restore)
+      end
+    end
+  end
+end

data/sub/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/sub/eac_ruby_utils/lib/eac_ruby_utils/settings_provider/setting_value.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_ruby_utils/listable'
+require 'eac_ruby_utils/simple_cache'
+require 'eac_ruby_utils/struct'
+
+module EacRubyUtils
+  module SettingsProvider
+    class SettingValue
+      include ::EacRubyUtils::Listable
+      include ::EacRubyUtils::SimpleCache
+
+      attr_reader :source, :key, :options
+
+      lists.add_symbol :option, :default, :order, :required
+
+      def initialize(source, key, options)
+        @source = source
+        @key = key
+        @options = options
+      end
+
+      def constant_name(fullname = false) # rubocop:disable Style/OptionalBooleanParameter
+        name = key.to_s.underscore.upcase
+        name = "#{source.class.name}::#{name}" if fullname
+        name
+      end
+
+      def value
+        parsed_options.order.each do |method|
+          return send("value_by_#{method}") if send("value_by_#{method}?")
+        end
+        return parsed_options.default if parsed_options.respond_to?(OPTION_DEFAULT)
+        return nil unless parsed_options.required
+
+        raise_key_not_found
+      end
+
+      def value_by_constant
+        source.class.const_get(constant_name)
+      end
+
+      def value_by_constant?
+        source.class.const_defined?(constant_name)
+      end
+
+      def value_by_method
+        source.send(key)
+      end
+
+      def value_by_method?
+        source.respond_to?(key, true)
+      end
+
+      def value_by_settings_object
+        source.settings_object.fetch(key)
+      end
+
+      def value_by_settings_object?
+        source.settings_object.key?(key)
+      end
+
+      private
+
+      def parsed_options_uncached
+        r = self.class.lists.option.hash_keys_validate!(options.symbolize_keys)
+        r[:required] = true unless r.key?(OPTION_REQUIRED)
+        r[:order] = source.setting_search_order if r[OPTION_ORDER].nil?
+        ::EacRubyUtils::Struct.new(r)
+      end
+
+      def raise_key_not_found
+        raise "Setting \"#{key}\" not found. Supply in #{source.settings_object_name}, implement " \
+              "a \"#{key}\" method or declare a #{constant_name(true)} constant."
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/settings_provider.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+require 'eac_ruby_utils/require_sub'
+
+module EacRubyUtils
+  # Provide a option by constant, method or options object.
+  module SettingsProvider
+    ::EacRubyUtils.require_sub __FILE__, base: self
+
+    def setting_constant_name(key, fullname = false) # rubocop:disable Style/OptionalBooleanParameter
+      setting_value_instance(key).constant_name(fullname)
+    end
+
+    def setting_search_order
+      %w[settings_object method constant]
+    end
+
+    # return [ActiveSupport::HashWithIndifferentAccess]
+    def settings_object
+      ActiveSupport::HashWithIndifferentAccess.new(
+        respond_to?(settings_object_name) ? send(settings_object_name) : {}
+      )
+    end
+
+    def settings_object_name
+      'settings'
+    end
+
+    def setting_value(key, options = {})
+      setting_value_instance(key, options).value
+    end
+
+    def setting_value_by_constant(key)
+      setting_value_instance(key).value_by_constant
+    end
+
+    def setting_value_by_method(key)
+      setting_value_instance(key).value_by_method
+    end
+
+    def setting_value_by_settings_object(key)
+      setting_value_instance(key).value_by_settings_object
+    end
+
+    def setting_value_instance(key, options = {})
+      ::EacRubyUtils::SettingsProvider::SettingValue.new(self, key, options)
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/simple_cache.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module SimpleCache
+    UNCACHED_METHOD_NAME_SUFFIX = '_uncached'
+    UNCACHED_METHOD_PATTERN = /
+      \A(\s+)_#{::Regexp.quote(UNCACHED_METHOD_NAME_SUFFIX)}([\!\?]?)\z
+    /x.freeze
+
+    class << self
+      def uncached_method_name(method_name)
+        method_name = method_name.to_s
+        end_mark = nil
+        if %w[! ?].any? { |mark| method_name.end_with?(mark) }
+          end_mark = method_name[-1]
+          method_name = method_name[0..-2]
+        end
+        "#{method_name}#{UNCACHED_METHOD_NAME_SUFFIX}#{end_mark}"
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if respond_to?(uncached_method_name(method), true)
+        call_method_with_cache(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(*keys)
+      if keys.any?
+        keys.each { |key| cache_keys.delete(sanitize_cache_key(key)) }
+      else
+        @cache_keys = nil
+      end
+    end
+
+    def sanitize_cache_key(key)
+      key.to_s.to_sym
+    end
+
+    protected
+
+    def uncached_method_name(original_method_name)
+      ::EacRubyUtils::SimpleCache.uncached_method_name(original_method_name)
+    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('@@@')
+      unless cache_keys.key?(sanitize_cache_key(key))
+        uncached_value = call_uncached_method(method, args)
+        cache_keys[sanitize_cache_key(key)] = uncached_value
+      end
+      cache_keys[sanitize_cache_key(key)]
+    end
+
+    def call_uncached_method(method, args)
+      send(uncached_method_name(method), *args)
+    end
+
+    def cache_keys
+      @cache_keys ||= {}
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/speaker/receiver.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_abstract'
+
+module EacRubyUtils
+  module Speaker
+    module Receiver
+      extend ::ActiveSupport::Concern
+      extend ::EacRubyUtils::ActsAsAbstract
+
+      module ClassMethods
+        def on(*args, &block)
+          ::EacRubyUtils::Speaker.context.on(new(*args), &block)
+        end
+      end
+
+      def error(_string)
+        raise_abstract_method(__method__)
+      end
+
+      def fatal_error(string)
+        error(string)
+        ::Kernel.exit 1
+      end
+
+      # @see EacRubyUtils::Speaker::Sender.input
+      def input(_question, _options = {})
+        raise_abstract_method(__method__)
+      end
+
+      def info(_string)
+        raise_abstract_method(__method__)
+      end
+
+      def infom(_string)
+        raise_abstract_method(__method__)
+      end
+
+      def infov(*_args)
+        raise_abstract_method(__method__)
+      end
+
+      def out(_string = '')
+        raise_abstract_method(__method__)
+      end
+
+      def puts(_string = '')
+        raise_abstract_method(__method__)
+      end
+
+      def success(_string)
+        raise_abstract_method(__method__)
+      end
+
+      def title(_string)
+        raise_abstract_method(__method__)
+      end
+
+      def warn(_string)
+        raise_abstract_method(__method__)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/speaker/sender.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/compact'
+
+module EacRubyUtils
+  module Speaker
+    module Sender
+      delegate :error, :fatal_error, :info, :infom, :infov, :out, :puts, :title, :success, :warn,
+               to: :speaker_receiver
+
+      # Shortcut to [EacRubyUtils::Speaker.current_receiver].
+      #
+      # @return [EacRubyUtils::Speaker::Receiver]
+      def speaker_receiver
+        ::EacRubyUtils::Speaker.current_receiver
+      end
+
+      # @param attributes [Enumerable<Symbol>] Attributes for +EacRubyUtils::Compact.new+.
+      # @return [self]
+      def compact_infov(*attributes)
+        ::EacRubyUtils::Compact.new(self, attributes).to_h.each do |k, v|
+          infov k, v
+        end
+
+        self
+      end
+
+      # Options:
+      #   +bool+ ([Boolean], default: +false+): requires a answer "yes" or "no".
+      #   +list+ ([Hash] or [Array], default: +nil+): requires a answer from a list.
+      #   +noecho+ ([Boolean], default: +false+): does not output answer.
+      def input(question, options = {})
+        speaker_receiver.input(question, options)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/speaker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/contextualizable'
+
+module EacRubyUtils
+  module Speaker
+    include ::EacRubyUtils::Contextualizable
+
+    class << self
+      # @return [EacRubyUtils::Speaker::Receiver]
+      def current_receiver
+        context.current
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/static_method_class.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/method_class'
+require 'eac_ruby_utils/patches/module/common_concern'
+
+module EacRubyUtils
+  module StaticMethodClass
+    common_concern do
+      ::EacRubyUtils::MethodClass::Setup.new(self, true)
+    end
+  end
+end