eac_tools 0.126.1 → 0.126.2

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'memoized'
-
-module EacRubyUtils
-  class RecursiveBuilder
-    include ::Memoized
-
-    attr_reader :root, :neighbors_block
-
-    def initialize(root, &neighbors_block)
-      @root = root
-      @neighbors_block = neighbors_block
-    end
-
-    memoize def result
-      @added = []
-      @to_check = []
-      item_try_add_to_check(root)
-      while check_next_item
-        # Do nothing
-      end
-      added
-    end
-
-    private
-
-    attr_reader :added, :to_check
-
-    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 # rubocop:disable Naming/PredicateMethod
-      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

@@ -1,39 +0,0 @@
-# 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

@@ -1,93 +0,0 @@
-# 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,
-        extend: :extend,
-        include: :include,
-        prepend: :prepend
-      }.freeze
-
-      include ::EacRubyUtils::Listable
-
-      lists.add_symbol :option, :base, :include_modules, :recursive, :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
-        raise('Options :base and :recursive cannot be simultaneously present/true') if
-          base? && recursive?
-
-        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 [Boolean]
-      def recursive?
-        options.fetch(OPTION_RECURSIVE, false) ? true : false
-      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
-
-      # @return [Enumerable<EacRubyUtils::RequireSub::SubFile>]
-      def sub_files
-        @sub_files ||= Dir["#{File.dirname(file)}/#{::File.basename(file, '.*')}" \
-                           "#{'/**' if recursive?}/*.rb"]
-                         .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

@@ -1,64 +0,0 @@
-# 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
-
-      def require_file_recursively
-        require_file
-        ::EacRubyUtils::RequireSub::Base.new(path, owner.options).apply
-      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

@@ -1,11 +0,0 @@
-# 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/root_module_setup/ignore.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/class/acts_as_instance_method'
-require 'eac_ruby_utils/patches/object/to_pathname'
-require 'eac_ruby_utils/patches/pathname/basename_sub'
-require 'memoized'
-
-module EacRubyUtils
-  class RootModuleSetup
-    class Ignore
-      include ::Memoized
-
-      acts_as_instance_method
-      common_constructor :setup, :path do
-        self.path = path.to_pathname
-      end
-      delegate :loader, :root_module_directory, to: :setup
-
-      # @return [Set]
-      def result
-        target_paths.each do |target_path|
-          expect_count_increment { loader.ignore target_path }
-        end
-      end
-
-      protected
-
-      # @return [Pathname]
-      memoize def absolute_path
-        path.expand_path(root_module_directory)
-      end
-
-      # @return [Set]
-      def expect_count_increment
-        count_before = loader.send(:ignored_paths).count
-        result = yield
-        return result if result.count > count_before
-
-        raise ::ArgumentError, [
-          "Trying to ignore path \"#{path}\" did not increase the ignored paths.",
-          "Argument path: \"#{path}\"", "Target path: \"#{target_paths}\"",
-          "Ignored paths: #{result}"
-        ].join("\n")
-      end
-
-      # @return [Pathname]
-      memoize def target_paths
-        return [absolute_path] if %w[* ?].any? { |e| absolute_path.to_path.include?(e) }
-
-        r = []
-        r << absolute_path if absolute_path.directory?
-        r << [absolute_path.basename_sub { |b| "#{b.basename('.*')}.rb" }]
-        r
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/root_module_setup.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/inflector'
-require 'eac_ruby_utils/patches/module/require_sub'
-require 'zeitwerk'
-
-module EacRubyUtils
-  # @deprecated Use `EacRubyBase1::RootModuleSetup` instead.
-  class RootModuleSetup
-    require_sub __FILE__, require_mode: :kernel
-
-    DEFAULT_NAMESPACE = ::Object
-    LIB_DIRECTORY_BASENAME = 'lib'
-
-    class << self
-      # @param root_module_file [String]
-      def perform(root_module_file, &)
-        new(root_module_file, &).perform
-      end
-    end
-
-    attr_reader :block, :root_module_file
-    attr_writer :logging
-
-    # @param root_module_file [String]
-    def initialize(root_module_file, &block)
-      self.root_module_file = root_module_file
-      self.block = block
-    end
-
-    # @param enable [Boolean] `true` to enable, `false` (default) to disable.
-    # @return
-    def logging(enable)
-      @logging = enable
-    end
-
-    # @return [Boolean]
-    def logging?
-      @logging ? true : false
-    end
-
-    # @return [Module, nil]
-    def extension_for
-      dirname = ::File.dirname(relative_root_module_file)
-      return nil if ['.', '/', ''].include?(dirname)
-
-      require dirname
-      ::ActiveSupport::Inflector.constantize(dirname.camelize)
-    end
-
-    # @return [Zeitwerk::GemLoader]
-    def loader
-      @loader ||= ::Zeitwerk::Registry.loader_for_gem(
-        root_module_file,
-        namespace: namespace,
-        warn_on_extra_files: true
-      )
-    end
-
-    # @return [Module]
-    def namespace
-      extension_for || DEFAULT_NAMESPACE
-    end
-
-    # @return [void]
-    def perform
-      perform_block
-      perform_zeitwerk
-    end
-
-    # @return [String]
-    def relative_root_module_file
-      count = 0
-      current = ::File.basename(root_module_file, '.*')
-      dirname = ::File.dirname(root_module_file)
-      loop do
-        ibr if dirname == '/'
-
-        break current if ::File.basename(dirname) == LIB_DIRECTORY_BASENAME
-
-        current = ::File.join(::File.basename(dirname), current)
-        dirname = ::File.dirname(dirname)
-
-        count += 1
-      end
-    end
-
-    # @return [String]
-    def root_module_directory
-      ::File.expand_path(::File.basename(root_module_file, '.*'),
-                         ::File.dirname(root_module_file))
-    end
-
-    protected
-
-    attr_writer :block, :root_module_file
-
-    def perform_block
-      instance_eval(&block) if block
-    end
-
-    # @return [void]
-    def perform_zeitwerk
-      loader.log! if logging?
-      loader.setup
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/rspec/setup_manager'
-
-module EacRubyUtils
-  module Rspec
-    module DefaultSetup
-      common_concern
-      class_methods do
-        # @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
-end

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

@@ -1,17 +0,0 @@
-# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,27 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-# 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

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

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

@@ -1,32 +0,0 @@
-# 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