avm-tools 0.116.1 → 0.117.1

data/sub/eac_ruby_utils/lib/eac_ruby_utils/locales/from_all_gems.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/locales/from_gem'
+::EacRubyUtils::Locales::FromGem.include_all

data/sub/eac_ruby_utils/lib/eac_ruby_utils/locales/from_gem.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'i18n'
+require 'eac_ruby_utils/patches/class/common_constructor'
+require 'eac_ruby_utils/patches/object/to_pathname'
+
+module EacRubyUtils
+  module Locales
+    class FromGem
+      class << self
+        def include_all(i18n_obj = nil)
+          ::Gem::Specification.each { |gemspec| new(gemspec, i18n_obj).include }
+        end
+      end
+
+      LOCALES_DIR_SUBPATH = 'locale'
+      LOCALES_FILES_GLOB_PATTERNS = %w[*.yaml *.yml].freeze
+
+      common_constructor :gemspec, :i18n_obj, default: [nil] do
+        self.i18n_obj ||= ::I18n
+      end
+
+      # @return [Boolean]
+      delegate :exist?, to: :path
+
+      # @return [Pathname, nil]
+      def include
+        return nil unless exist?
+
+        ::I18n.load_path += paths_to_load.map(&:to_path)
+        path
+      end
+
+      # @return [Pathname]
+      def path
+        gemspec.gem_dir.to_pathname.join(LOCALES_DIR_SUBPATH)
+      end
+
+      # @return [Pathname]
+      def paths_to_load
+        return [] unless exist?
+
+        LOCALES_FILES_GLOB_PATTERNS.inject([]) { |a, e| a + path.glob(e) }
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/locales/module_i18n_translate.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/string/inflections'
+require 'eac_ruby_utils/common_constructor'
+require 'i18n'
+
+module EacRubyUtils
+  module Locales
+    class ModuleI18nTranslate
+      TRANSLATE_LOCALE_KEY = :__locale
+
+      common_constructor :the_module, :entry_suffix, :values, default: [{}]
+
+      def ancestor_i18n_translate(ancestor)
+        t = self.class.new(ancestor, entry_suffix, values)
+        t.exists? ? t.i18n_translate : nil
+      end
+
+      def ancestors_i18n_translate
+        the_module.ancestors.lazy.map { |v| ancestor_i18n_translate(v) }.find(&:present?)
+      end
+
+      def exists?
+        ::I18n.exists?(i18n_key)
+      end
+
+      def i18n_key
+        "#{module_entry_prefix}.#{entry_suffix}"
+      end
+
+      def i18n_options
+        values.except(TRANSLATE_LOCALE_KEY)
+      end
+
+      def i18n_translate
+        ::I18n.translate(i18n_key, i18n_options)
+      end
+
+      def locale
+        values[TRANSLATE_LOCALE_KEY]
+      end
+
+      def module_entry_prefix
+        the_module.name.underscore.gsub('/', '.')
+      end
+
+      def on_locale(&block)
+        if locale.present?
+          on_present_locale(&block)
+        else
+          block.call
+        end
+      end
+
+      def result
+        on_locale do
+          ancestors_i18n_translate || i18n_translate
+        end
+      end
+
+      private
+
+      def on_present_locale(&block)
+        old_locale = ::I18n.locale
+        begin
+          ::I18n.locale = locale
+          block.call
+        ensure
+          ::I18n.locale = old_locale
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/locales.rb

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/method_class.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/introspection'
+require 'eac_ruby_utils/patches/class/common_constructor'
+require 'eac_ruby_utils/patches/module/common_concern'
+require 'eac_ruby_utils/patches/string/inflector'
+
+module EacRubyUtils
+  module MethodClass
+    common_concern do
+      ::EacRubyUtils::MethodClass::Setup.new(self)
+    end
+
+    class Setup
+      common_constructor :method_class do
+        perform
+      end
+
+      def perform
+        the_setup = self
+        sender_module.define_method(method_name) do |*args, &block|
+          the_setup.method_class.new(self, *args, &block).result
+        end
+      end
+
+      def method_name
+        method_class.name.demodulize.underscore.variableize
+      end
+
+      def sender_module
+        method_class.module_parent
+      end
+    end
+  end
+end

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

@@ -1,32 +1,9 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/string/inflections'
-require 'i18n'
+require 'eac_ruby_utils/locales/module_i18n_translate'
 
 class Module
-  TRANSLATE_LOCALE_KEY = :__locale
-
   def i18n_translate(entry_suffix, values = {})
-    on_i18n_locale(values.delete(TRANSLATE_LOCALE_KEY)) do
-      ::I18n.translate(i18n_translate_entry_full(entry_suffix), values)
-    end
-  end
-
-  def i18n_translate_entry_full(entry_suffix)
-    "#{i18n_translate_entry_self_prefix}.#{entry_suffix}"
-  end
-
-  def i18n_translate_entry_self_prefix
-    name.underscore.gsub('/', '.')
-  end
-
-  def on_i18n_locale(locale)
-    old_locale = ::I18n.locale
-    begin
-      ::I18n.locale = locale
-      yield
-    ensure
-      ::I18n.locale = old_locale
-    end
+    ::EacRubyUtils::Locales::ModuleI18nTranslate.new(self, entry_suffix, values).result
   end
 end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/method_class'
+
+class Module
+  def enable_method_class
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::MethodClass)
+  end
+end

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

@@ -1,6 +1,12 @@
 # frozen_string_literal: true
 
 class Object
+  def pretty_debug
+    STDERR.write(pretty_inspect)
+
+    self
+  end
+
   def print_debug
     STDERR.write(to_debug + "\n")
 

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/inflector'
+require 'active_support/dependencies'
 require 'eac_ruby_utils/listable'
 
 module EacRubyUtils
@@ -11,6 +12,14 @@ module EacRubyUtils
   end
 
   class RequireSub
+    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
 
@@ -26,56 +35,100 @@ module EacRubyUtils
       include_modules
     end
 
-    private
+    def base
+      options[OPTION_BASE] || raise('Option :base not setted')
+    end
 
-    def active_support_require(path)
-      return false unless options[OPTION_REQUIRE_DEPENDENCY]
+    def base?
+      options[OPTION_BASE] ? true : false
+    end
 
-      ::Kernel.require_dependency(path)
-      true
+    def include_modules
+      sub_files.each(&:include_module)
     end
 
-    def autoload_require(path)
-      return false unless base?
+    def include_or_prepend_method
+      return INCLUDE_MODULES_MAP.fetch(options[OPTION_INCLUDE_MODULES]) if
+        INCLUDE_MODULES_MAP.key?(options[OPTION_INCLUDE_MODULES])
 
-      basename = ::File.basename(path, '.*')
-      return false if basename.start_with?('_')
+      raise ::ArgumentError, "Invalid value for 'options[OPTION_INCLUDE_MODULES]':" \
+         " \"#{options[OPTION_INCLUDE_MODULES]}\""
+    end
 
-      base.autoload ::ActiveSupport::Inflector.camelize(basename), path
-      true
+    def require_sub_files
+      sub_files.each(&:require_file)
     end
 
-    def include_modules
-      return unless options[OPTION_INCLUDE_MODULES]
+    def sub_files
+      @sub_files ||= Dir["#{File.dirname(file)}/#{::File.basename(file, '.*')}/*.rb"].sort
+                       .map { |path| SubFile.new(self, path) }
+    end
 
-      base.constants.each do |constant_name|
-        constant = base.const_get(constant_name)
-        next unless constant.is_a?(::Module) && !constant.is_a?(::Class)
+    class SubFile
+      attr_reader :owner, :path
 
-        base.include(constant)
+      def initialize(owner, path)
+        @owner = owner
+        @path = path
       end
-    end
 
-    def base
-      options[OPTION_BASE] || raise('Option :base not setted')
-    end
+      def base_constant
+        return nil unless owner.base?
 
-    def base?
-      options[OPTION_BASE] ? true : false
-    end
+        owner.base.const_get(constant_name)
+      rescue ::NameError
+        nil
+      end
 
-    def kernel_require(path)
-      ::Kernel.require(path)
-    end
+      def constant_name
+        ::ActiveSupport::Inflector.camelize(::File.basename(path, '.rb'))
+      end
 
-    def require_sub_files
-      Dir["#{File.dirname(file)}/#{::File.basename(file, '.*')}/*.rb"].sort.each do |path|
-        require_sub_file(path)
+      def include_module
+        return unless module?
+
+        owner.include_or_prepend_method.if_present do |v|
+          owner.base.send(v, base_constant)
+        end
+      end
+
+      def include_or_prepend_method
+        return :include if owner.options[OPTION_INCLUDE_MODULES]
+        return :prepend if owner.options[OPTION_PREPEND_MODULES]
+
+        nil
+      end
+
+      def module?
+        base_constant.is_a?(::Module) && !base_constant.is_a?(::Class)
+      end
+
+      def require_file
+        active_support_require || autoload_require || kernel_require
+      end
+
+      private
+
+      def active_support_require
+        return false unless owner.options[OPTION_REQUIRE_DEPENDENCY]
+
+        ::Kernel.require_dependency(path)
+        true
       end
-    end
 
-    def require_sub_file(path)
-      active_support_require(path) || autoload_require(path) || kernel_require(path)
+      def autoload_require
+        return false unless owner.base?
+
+        basename = ::File.basename(path, '.*')
+        return false if basename.start_with?('_')
+
+        owner.base.autoload ::ActiveSupport::Inflector.camelize(basename), path
+        true
+      end
+
+      def kernel_require
+        ::Kernel.require(path)
+      end
     end
   end
 end

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

@@ -12,7 +12,7 @@ module EacRubyUtils
 
       def on_clean_envvars(*start_with_vars)
         old_values = envvars_starting_with(start_with_vars)
-        old_values.keys.each { |k| ENV.delete(k) }
+        old_values.each_key { |k| ENV.delete(k) }
         yield
       ensure
         old_values&.each { |k, v| ENV[k] = v }

data/sub/eac_ruby_utils/lib/eac_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  VERSION = '0.92.1'
+  VERSION = '0.95.1'
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/fs/temp_spec.rb

@@ -4,7 +4,7 @@ require 'eac_ruby_utils/fs/temp'
 
 RSpec.describe ::EacRubyUtils::Fs::Temp do
   describe '#on_file' do
-    it do
+    it do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
       temp_path = nil
       described_class.on_file do |path|
         temp_path = path
@@ -15,7 +15,7 @@ RSpec.describe ::EacRubyUtils::Fs::Temp do
       expect(temp_path).not_to exist
     end
 
-    it 'not fail if already removed' do
+    it 'not fail if already removed' do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
       temp_path = nil
       described_class.on_file do |path|
         temp_path = path
@@ -29,7 +29,7 @@ RSpec.describe ::EacRubyUtils::Fs::Temp do
   end
 
   describe '#on_directory' do
-    it do
+    it do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
       temp_path = nil
       described_class.on_directory do |path|
         temp_path = path
@@ -38,7 +38,7 @@ RSpec.describe ::EacRubyUtils::Fs::Temp do
       expect(temp_path).not_to exist
     end
 
-    it 'not fail if already removed' do
+    it 'not fail if already removed' do # rubocop:disable RSpec/ExampleLength, RSpec/MultipleExpectations
       temp_path = nil
       described_class.on_directory do |path|
         temp_path = path