eac_tools 0.105.1 → 0.105.2

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  # @param suffix [String]
+  # @return [Pathname]
+  def basename_sub(suffix = '')
+    new_basename = basename(suffix)
+    new_basename = yield(new_basename) if block_given?
+    parent.join(new_basename)
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  # Indicate if +self+ is child of +parent_path+.
+  #
+  # @return [Boolean]
+  def child_of?(parent_path)
+    self_parts = expand_path.each_filename.to_a
+    parent_parts = parent_path.expand_path.each_filename.to_a
+    return false if self_parts == parent_parts
+
+    parent_parts.zip(self_parts).all? { |x, y| x == y }
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Pathname
+  # @return +block.call(self)+ if +self+ exists, +default_value+ otherwise.
+  def if_exist(default_value = nil)
+    return default_value unless exist?
+
+    block_given? ? yield(self) : self
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  # Execute .mkpath and return +self+.
+  # @return [Pathname]
+  def mkpath_s
+    mkpath
+    self
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  # Apply .parent n times.
+  # @return [Pathname]
+  def parent_n(n) # rubocop:disable Naming/MethodParameterName
+    n.times.inject(self) { |a, _e| a.parent }
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  def readlink_r
+    r = self
+    r = r.readlink while r.symlink?
+    r
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+class Pathname
+  # A .glob that raises a ::RuntimeError if +self+ is not a directory.
+  # @return [Pathname]
+  def reqdir_glob(*args)
+    raise "\"#{self}\" is not a directory" unless directory?
+
+    glob(*args)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/pathname.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/regexp/if_match.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Regexp
+  # If +self+ matches +string+ returns +block.call(Match result) or only Match result if block is
+  # not provided.
+  # If +self+ does not match +string+ raises a +ArgumentError+ if +required+ is truthy or return
+  # +nil+ otherwise.
+  def if_match(string, required = true, &block) # rubocop:disable Style/OptionalBooleanParameter
+    m = match(string)
+    if m
+      block ? block.call(m) : m
+    elsif required
+      raise(::ArgumentError, "Pattern \"#{self}\" does not match string \"#{string}\"")
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/regexp_parser'
+
+class Regexp
+  # @return [::EacRubyUtils::RegexpParser]
+  def to_parser(&block)
+    ::EacRubyUtils::RegexpParser.new(self, &block)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/regexp.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/string/delimited.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/string_delimited'
+
+class String
+  # @return [EacRubyUtils::StringDelimited]
+  def delimited(begin_delimiter, end_delimiter)
+    ::EacRubyUtils::StringDelimited.new(self, begin_delimiter, end_delimiter)
+  end
+
+  %w[inner outer without_inner without_outer].each do |method_suffix|
+    define_method "delimited_#{method_suffix}" do |begin_delimiter, end_delimiter|
+      delimited(begin_delimiter, end_delimiter).send(method_suffix)
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/inflector'
+
+class String
+  # Shortcut to `EacRubyUtils::Inflector.variableize(self, ...)`.
+  # @see EacRubyUtils::Inflector.variableize
+  def variableize(validate = true) # rubocop:disable Style/OptionalBooleanParameter
+    ::EacRubyUtils::Inflector.variableize(self, validate)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/string.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/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 # 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

@@ -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,82 @@
+# 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, :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/root_module_setup/ignore.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/acts_as_instance_method'
+require 'eac_ruby_utils/patches/object/to_pathname'
+require 'eac_ruby_utils/patches/module/simple_cache'
+require 'eac_ruby_utils/patches/pathname/basename_sub'
+
+module EacRubyUtils
+  class RootModuleSetup
+    class Ignore
+      acts_as_instance_method
+      enable_simple_cache
+      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]
+      def absolute_path_uncached
+        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]
+      def target_paths_uncached
+        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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'eac_ruby_utils/patches/module/require_sub'
+require 'zeitwerk'
+
+module EacRubyUtils
+  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, &block)
+        new(root_module_file, &block).perform
+      end
+    end
+
+    attr_reader :block, :root_module_file
+
+    # @param root_module_file [String]
+    def initialize(root_module_file, &block)
+      self.root_module_file = root_module_file
+      self.block = block
+    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.setup
+    end
+  end
+end

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

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

@@ -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