eac_tools 0.89.0 → 0.90.0

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/time/required_zone.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/local_time_zone'
+
+class Time
+  class << self
+    def required_zone
+      zone || ::EacRubyUtils::LocalTimeZone.auto || raise('No zone set or discovered')
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/time.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+EacRubyUtils.require_sub __FILE__

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches.rb

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/recursive_builder.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/simple_cache'
+
+module EacRubyUtils
+  class RecursiveBuilder
+    include ::EacRubyUtils::SimpleCache
+
+    attr_reader :root, :neighbors_block
+
+    def initialize(root, &neighbors_block)
+      @root = root
+      @neighbors_block = neighbors_block
+    end
+
+    private
+
+    attr_reader :added, :to_check
+
+    def result_uncached
+      @added = []
+      @to_check = []
+      item_try_add_to_check(root)
+      while check_next_item
+        # Do nothing
+      end
+      added
+    end
+
+    def item_try_add_to_check(item)
+      to_check << item unless item_added?(item)
+    end
+
+    def item_added?(item)
+      added.include?(item) || to_check.include?(item)
+    end
+
+    def check_next_item
+      return false unless to_check.any?
+
+      item = to_check.shift
+      added << item
+      item_neighborhs(item).each { |sub_item| item_try_add_to_check(sub_item) }
+      true
+    end
+
+    def item_neighborhs(item)
+      neighbors_block.call(item)
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/regexp_parser.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class RegexpParser
+    attr_reader :pattern, :builder_proc
+
+    def initialize(pattern, &builder_proc)
+      @pattern = pattern
+      @builder_proc = builder_proc
+    end
+
+    def parse(string)
+      internal_parse(string)[1]
+    end
+
+    def parse!(string)
+      match, result = internal_parse(string)
+      return result if match
+
+      raise ::ArgumentError, "String \"#{string}\" does not match pattern \"#{pattern}\""
+    end
+
+    # @return [Boolean]
+    def parse?(string)
+      internal_parse(string).first
+    end
+
+    private
+
+    def internal_parse(string)
+      m = pattern.match(string)
+      if m
+        [true, builder_proc ? builder_proc.call(m) : m]
+      else
+        [false, nil]
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/require_sub/base.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/listable'
+require 'eac_ruby_utils/require_sub/sub_file'
+
+module EacRubyUtils
+  module RequireSub
+    class Base
+      INCLUDE_MODULES_MAP = {
+        nil => nil,
+        false => nil,
+        true => :include,
+        include: :include,
+        prepend: :prepend
+      }.freeze
+
+      include ::EacRubyUtils::Listable
+      lists.add_symbol :option, :base, :include_modules, :require_dependency, :require_mode
+      lists.add_symbol :require_mode, :active_support, :autoload, :kernel
+
+      attr_reader :file, :options
+
+      def initialize(file, options = {})
+        @file = file
+        @options = self.class.lists.option.hash_keys_validate!(options)
+        return unless options[OPTION_REQUIRE_MODE]
+
+        self.class.lists.require_mode.value_validate!(options[OPTION_REQUIRE_MODE])
+      end
+
+      # @return [Boolean]
+      def active_support_require?
+        options[OPTION_REQUIRE_DEPENDENCY] ? true : false
+      end
+
+      def apply
+        require_sub_files
+        include_modules
+      end
+
+      def base
+        options[OPTION_BASE] || raise('Option :base not setted')
+      end
+
+      def base?
+        options[OPTION_BASE] ? true : false
+      end
+
+      def include_modules
+        sub_files.each(&:include_module)
+      end
+
+      def include_or_prepend_method
+        return INCLUDE_MODULES_MAP.fetch(options[OPTION_INCLUDE_MODULES]) if
+        INCLUDE_MODULES_MAP.key?(options[OPTION_INCLUDE_MODULES])
+
+        raise ::ArgumentError, "Invalid value for 'options[OPTION_INCLUDE_MODULES]': " \
+                               "\"#{options[OPTION_INCLUDE_MODULES]}\""
+      end
+
+      # @return [Symbol]
+      def require_mode
+        return options[OPTION_REQUIRE_MODE] if options[OPTION_REQUIRE_MODE]
+        return REQUIRE_MODE_ACTIVE_SUPPORT if active_support_require?
+        return REQUIRE_MODE_AUTOLOAD if base?
+
+        REQUIRE_MODE_KERNEL
+      end
+
+      def require_sub_files
+        sub_files.each(&:require_file)
+      end
+
+      def sub_files
+        @sub_files ||= Dir["#{File.dirname(file)}/#{::File.basename(file, '.*')}/*.rb"].sort
+                         .map { |path| ::EacRubyUtils::RequireSub::SubFile.new(self, path) }
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/require_sub/sub_file.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'active_support/dependencies'
+require 'active_support/inflector'
+
+module EacRubyUtils
+  module RequireSub
+    class SubFile
+      attr_reader :owner, :path
+
+      def initialize(owner, path)
+        @owner = owner
+        @path = path
+      end
+
+      def base_constant
+        return nil unless owner.base?
+
+        owner.base.const_get(constant_name)
+      rescue ::NameError
+        nil
+      end
+
+      def constant_name
+        ::ActiveSupport::Inflector.camelize(::File.basename(path, '.rb'))
+      end
+
+      def include_module
+        return unless module?
+
+        owner.include_or_prepend_method.if_present do |v|
+          owner.base.send(v, base_constant)
+        end
+      end
+
+      def module?
+        base_constant.is_a?(::Module) && !base_constant.is_a?(::Class)
+      end
+
+      def require_file
+        send("#{owner.require_mode}_require")
+      end
+
+      private
+
+      def active_support_require
+        ::Kernel.require_dependency(path)
+      end
+
+      def autoload_require
+        owner.base.autoload ::ActiveSupport::Inflector.camelize(::File.basename(path, '.*')), path
+      end
+
+      def kernel_require
+        ::Kernel.require(path)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/require_sub.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub/base'
+
+module EacRubyUtils
+  class << self
+    def require_sub(file, options = {})
+      ::EacRubyUtils::RequireSub::Base.new(file, options).apply
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/rspec/setup_manager'
+
+module EacRubyUtils
+  module Rspec
+    class << self
+      # @return [EacRubyUtils::Rspec::SetupManager]
+      def default_setup
+        @default_setup ||
+          raise("Default instance was not set. Use #{self.class.name}.default_setup_create")
+      end
+
+      # @return [EacRubyUtils::Rspec::SetupManager]
+      def default_setup_create(app_root_path, rspec_config = nil)
+        @default_setup = ::EacRubyUtils::Rspec::SetupManager.create(app_root_path, rspec_config)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/rspec/setup/conditionals.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Rspec
+    module Setup
+      module Conditionals
+        def conditional(tag, &condition)
+          message = condition.call
+          return if message.blank?
+
+          puts("[WARN] Excluded tag: #{tag}: #{message}")
+          rspec_config.filter_run_excluding tag
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Rspec
+    module Setup
+      module SetupManager
+        # @return [Pathname]
+        delegate :app_root_path, to: :setup_manager
+
+        # @return [EacRubyUtils::Rspec::SetupManager]
+        def setup_manager
+          ::RSpec.configuration.setup_manager
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/rspec/stub_speaker'
+require 'eac_ruby_utils/speaker'
+
+module EacRubyUtils
+  module Rspec
+    module Setup
+      require_sub __FILE__
+
+      def self.extended(obj)
+        obj.extend(::EacRubyUtils::Rspec::Setup::Conditionals)
+        obj.rspec_config.add_setting :setup_manager
+        obj.rspec_config.setup_manager = obj
+        obj.rspec_config.include(::EacRubyUtils::Rspec::Setup::SetupManager)
+      end
+
+      # @return [self]
+      def stub_eac_speaker
+        ::EacRubyUtils::Speaker.context.push(::EacRubyUtils::Rspec::StubSpeaker.new)
+
+        self
+      end
+    end
+  end
+end

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