eac_tools 0.108.0 → 0.110.0

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/require_sub'
-
-module EacRubyUtils
-  module Fs
-    include ::EacRubyUtils::Fs::Extname
-
-    ::EacRubyUtils.require_sub __FILE__
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry/gem/dependencies.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/recursive_builder'
-
-module EacRubyUtils
-  class GemsRegistry
-    class Gem
-      module Dependencies
-        def depend_on(gem) # rubocop:disable Naming/PredicateMethod
-          dependencies.lazy.map(&:name).include?(gem.gemspec.name)
-        end
-
-        def dependencies
-          @dependencies ||= dependencies_uncached # dependencies_uncached
-        end
-
-        private
-
-        def dependencies_uncached
-          ::EacRubyUtils::RecursiveBuilder
-            .new(gemspec) { |item| gem_item_dependencies(item) }
-            .result
-        end
-
-        # @return [Array<Gem::Dependency>]
-        def gem_item_dependencies(item)
-          ::Gem::Specification.find_by_name(item.name).dependencies.select(&:runtime?)
-        rescue ::Gem::MissingSpecError
-          []
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry/gem/paths_to_require.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-require 'eac_ruby_utils/recursive_builder'
-require 'eac_ruby_utils/simple_cache'
-
-module EacRubyUtils
-  class GemsRegistry
-    class Gem
-      module PathsToRequire
-        ROOT_MODULE_REQUIRE_PATTERNS = %w[EacRubyUtils::RootModuleSetup Zeitwerk].freeze
-
-        # @return [Enumerable<Pathname>]
-        def absolute_require_paths(lib_relative_path)
-          gemspec.require_paths.lazy.map do |e|
-            ::Pathname.new(e).expand_path(gemspec.gem_dir)
-              .join("#{lib_relative_path}.rb")
-          end
-        end
-
-        # @return [String]
-        def path_to_require
-          require_root_module? ? root_module_path_to_require : direct_path_to_require
-        end
-
-        # @return [String]
-        def to_s
-          "#{self.class.name}[#{gemspec.name}]"
-        end
-
-        protected
-
-        # @return [String]
-        def direct_path_to_require
-          "#{root_module_path_to_require}/#{registry.module_suffix.underscore}"
-        end
-
-        # @return [Boolean]
-        def require_root_module?
-          absolute_require_paths(root_module_path_to_require).find do |e|
-            next false unless e.file?
-
-            content = e.read
-            ROOT_MODULE_REQUIRE_PATTERNS.any? { |e| content.include?(e) }
-          end
-        end
-
-        # @return [String]
-        def root_module_path_to_require
-          gemspec.name.gsub('-', '/')
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry/gem.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/string/inflections'
-require 'eac_ruby_utils/gems_registry/gem/dependencies'
-require 'eac_ruby_utils/gems_registry/gem/paths_to_require'
-require 'eac_ruby_utils/simple_cache'
-
-module EacRubyUtils
-  class GemsRegistry
-    class Gem
-      include ::Comparable
-      include ::EacRubyUtils::GemsRegistry::Gem::Dependencies
-      include ::EacRubyUtils::GemsRegistry::Gem::PathsToRequire
-      include ::EacRubyUtils::SimpleCache
-
-      attr_reader :registry, :gemspec
-
-      def initialize(registry, gemspec)
-        @registry = registry
-        @gemspec = gemspec
-      end
-
-      def <=>(other)
-        sd = depend_on(other)
-        od = other.depend_on(self)
-        return 1 if sd && !od
-        return -1 if od && !sd
-
-        gemspec.name <=> other.gemspec.name
-      end
-
-      def found?
-        registered_module.is_a?(::Module)
-      end
-
-      # @return [Module, nil]
-      def registered_module
-        require path_to_require
-        direct_path_to_require.camelize.constantize
-      rescue ::LoadError, ::NameError
-        nil
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/gems_registry.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubygems'
-require 'eac_ruby_utils/gems_registry/gem'
-
-module EacRubyUtils
-  # Search in each gem for a class determined by registry and run the method "register" on each
-  # found.
-  #
-  # Example:
-  # * The module suffix is `TheClass`;
-  # * A gem with name "my-lib" is being analyzed
-  # * If a require for "my/lib/the_class" is succesful the class/module `My::Lib::TheClass` will
-  #   be collected.
-  class GemsRegistry
-    attr_reader :module_suffix
-
-    def initialize(module_suffix)
-      @module_suffix = module_suffix
-    end
-
-    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
-    def registered
-      @registered ||= all_gems.select(&:found?).sort
-    end
-
-    private
-
-    # @return [Array<EacRubyUtils::GemsRegistry::Gem>]
-    def all_gems
-      ::Gem::Specification.map { |gemspec| ::EacRubyUtils::GemsRegistry::Gem.new(self, gemspec) }
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/inflector'
-
-module EacRubyUtils
-  class Inflector
-    class << self
-      VARIABLE_NAME_PATTERN = /[_a-z][_a-z0-9]*/i.freeze
-
-      # Convert a string to a variable format: first character as a lowercase letter or underscore
-      # and other as a lowercase letter, underscore or numbers.
-      # @param string [String] The source string.
-      # @param validate [Boolean] Affect the outcome when the result builded is not in a valid
-      #   variable format. If `true`, it raises a {ArgumentError}. If `false`, return `nil`.
-      # @return [String, nil]
-      # @raise [ArgumentError]
-      def variableize(string, validate = true) # rubocop:disable Style/OptionalBooleanParameter
-        r = ::ActiveSupport::Inflector.transliterate(string).gsub(/[^_a-z0-9]/i, '_')
-              .gsub(/_+/, '_').gsub(/_\z/, '').gsub(/\A_/, '').downcase
-        m = VARIABLE_NAME_PATTERN.match(r)
-        return r if m
-        return nil unless validate
-
-        raise ::ArgumentError, "Invalid variable name \"#{r}\" was generated " \
-                               "from string \"#{string}\""
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/class_methods.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'i18n'
-require_relative 'lists'
-
-module EacRubyUtils
-  module Listable
-    module ClassMethods
-      def lists
-        @lists ||= ::EacRubyUtils::Listable::Lists.new(self)
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/instance_methods.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module Listable
-    module InstanceMethods
-      LISTABLE_INSTANCE_VALUE_METHODS = %w[label description].freeze
-
-      def method_missing(name, *args, &block)
-        list, method = parse_method(name)
-        list && method ? list.instance_value(self).send(method) : super
-      end
-
-      def respond_to_missing?(name, include_all = false)
-        list, method = parse_method(name)
-        list && method ? true : super
-      end
-
-      private
-
-      def parse_method(method)
-        self.class.lists.acts_as_listable_items.each do |item, list|
-          LISTABLE_INSTANCE_VALUE_METHODS.each do |m|
-            return [list, m] if method.to_s == "#{item}_#{m}"
-          end
-        end
-        [nil, nil]
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/integer_list.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'list'
-
-module EacRubyUtils
-  module Listable
-    class IntegerList < ::EacRubyUtils::Listable::List
-      protected
-
-      def parse_labels(labels)
-        if labels.first.is_a?(Hash)
-          labels.first.to_h { |k, v| [k.to_i, v.to_s] }
-        else
-          labels.each_with_index.to_h { |v, i| [i + 1, v.to_s] }
-        end
-      end
-
-      def build_value(index, _key)
-        index + 1
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/item.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/class/common_constructor'
-require 'eac_ruby_utils/inflector'
-
-module EacRubyUtils
-  module Listable
-    class Item
-      common_constructor :list, :value, :key, :translation_required, default: [true]
-
-      def to_s
-        "I: #{list.item}, V: #{value}, K: #{key}"
-      end
-
-      def constant_name
-        ::EacRubyUtils::Inflector.variableize("#{list.item}_#{key}").upcase
-      end
-
-      def label
-        translate('label')
-      end
-
-      def description
-        translate('description')
-      end
-
-      # @return [Array] A two-item array in format `[label, value]`.
-      def to_option
-        [label, value]
-      end
-
-      def translation_required?
-        translation_required
-      end
-
-      private
-
-      def translate(translate_key)
-        full_translate_key = "#{list.i18n_key}.#{key}.#{translate_key}"
-        if !::I18n.exists?(full_translate_key) && !translation_required?
-          ''
-        else
-          ::I18n.t(full_translate_key)
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/list.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/listable/item'
-
-module EacRubyUtils
-  module Listable
-    class List
-      BLANK_VALUE = nil
-      BLANK_KEY = :__blank
-
-      attr_reader :item
-
-      def initialize(lists, item, labels)
-        @lists = lists
-        @item = item
-        @values = build_values(labels)
-        apply_constants
-      end
-
-      def blank_value
-        @blank_value ||= ::EacRubyUtils::Listable::Item.new(self, BLANK_VALUE, BLANK_KEY, false)
-      end
-
-      def each_value(&block)
-        values.each(&block)
-      end
-
-      # @return [EacRubyUtils::Listable::Item, nil]
-      def item_by_value(value)
-        @values.values.find { |item| item.value == value }
-      end
-
-      # @return [EacRubyUtils::Listable::Item]
-      def item_by_value!(value)
-        item_by_value(value) || raise(::KeyError, "Value not found: #{value}")
-      end
-
-      def values
-        @values.values.map(&:value)
-      end
-
-      def values_with_blank
-        [blank_value.value] + values
-      end
-
-      def options
-        @values.values.map(&:to_option)
-      end
-
-      def options_with_blank
-        [blank_value.to_option] + options
-      end
-
-      def method_missing(name, *args, &block)
-        list = find_list_by_method(name)
-        list || super
-      end
-
-      def respond_to_missing?(name, include_all = false)
-        find_list_by_method(name) || super
-      end
-
-      def hash_keys_validate!(hash, error_class = ::StandardError)
-        hash.each_key { |key| value_validate!(key, error_class) }
-        hash
-      end
-
-      def i18n_key
-        "eac_ruby_utils.listable.#{class_i18n_key}.#{item}"
-      end
-
-      # @return [EacRubyUtils::Listable::Item, nil]
-      def instance_value(instance)
-        v = instance.send(item)
-        return blank_value if v.blank?
-        return @values[v] if @values.key?(v)
-
-        raise "List value unkown: \"#{v}\" (Source: #{@lists.source}, Item: #{item}, Instance: " \
-              "#{instance.to_debug}, Values: #{@values.keys})"
-      end
-
-      def value_valid?(value)
-        values.include?(value)
-      end
-
-      def value_validate!(value, error_class = ::StandardError)
-        return value if value_valid?(value)
-
-        raise(error_class, "Invalid value: \"#{value}\" (Valid: #{values_to_s})")
-      end
-
-      def values_to_s
-        values.map { |v| "\"#{v}\"" }.join(', ')
-      end
-
-      private
-
-      def class_i18n_key
-        @lists.source.name.underscore.to_sym
-      end
-
-      def find_list_by_method(method)
-        @values.each_value do |v|
-          return v if method.to_s == "value_#{v.key}"
-        end
-        nil
-      end
-
-      def constants
-        labels.each_with_index.map { |v, i| ["#{item.upcase}_#{v.upcase}", values[i]] }
-      end
-
-      def apply_constants
-        @values.each_value do |v|
-          @lists.source.const_set(v.constant_name, v.value)
-        end
-      end
-
-      def build_values(labels)
-        vs = {}
-        parse_labels(labels).each do |value, key|
-          v = ::EacRubyUtils::Listable::Item.new(self, value, key)
-          vs[v.value] = v
-        end
-        vs
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/lists.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require 'active_support/core_ext/string/inflections'
-require_relative 'integer_list'
-require_relative 'string_list'
-require_relative 'symbol_list'
-
-module EacRubyUtils
-  module Listable
-    class Lists
-      attr_reader :source
-
-      def initialize(source)
-        @source = source
-      end
-
-      %w[integer string symbol].each do |list_type|
-        define_method "add_#{list_type}" do |item, *labels|
-          add(::EacRubyUtils::Listable.const_get("#{list_type}_list".camelize), item, labels)
-        end
-      end
-
-      def method_missing(name, *args, &block)
-        list = find_list_by_method(name)
-        list || super
-      end
-
-      def respond_to_missing?(name, include_all = false)
-        find_list_by_method(name) || super
-      end
-
-      def acts_as_listable_items
-        @acts_as_listable_items ||= ActiveSupport::HashWithIndifferentAccess.new
-      end
-
-      private
-
-      def add(list_class, item, labels)
-        acts_as_listable_items[item] = list_class.new(self, item, labels)
-      end
-
-      def find_list_by_method(method)
-        acts_as_listable_items.each do |item, list|
-          return list if method.to_sym == item.to_sym
-        end
-        nil
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/string_list.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'list'
-
-module EacRubyUtils
-  module Listable
-    class StringList < ::EacRubyUtils::Listable::List
-      protected
-
-      def parse_labels(labels)
-        if labels.first.is_a?(Hash)
-          labels.first.to_h { |k, v| [k.to_s, v.to_s] }
-        else
-          labels.to_h { |v| [v.to_s, v.to_s] }
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable/symbol_list.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'list'
-
-module EacRubyUtils
-  module Listable
-    class SymbolList < ::EacRubyUtils::Listable::List
-      protected
-
-      def parse_labels(labels)
-        if labels.first.is_a?(Hash)
-          labels.first.to_h { |k, v| [k.to_sym, v.to_sym] }
-        else
-          labels.to_h { |v| [v.to_sym, v.to_sym] }
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/listable.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/concern'
-Dir["#{__dir__}/#{File.basename(__FILE__, '.*')}/*.rb"].sort.each do |partial|
-  require partial
-end
-
-module EacRubyUtils
-  module Listable
-    extend ActiveSupport::Concern
-
-    included do
-      extend(ClassMethods)
-      include(InstanceMethods)
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/local_time_zone.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/object/blank'
-require 'active_support/values/time_zone'
-
-module EacRubyUtils
-  module LocalTimeZone
-    DEBIAN_CONFIG_PATH = '/etc/timezone'
-
-    class << self
-      TIMEDATECTL_TIMEZONE_LINE_PATTERN = %r{\s*Time zone:\s*(\S+/\S+)\s}.freeze
-
-      # @return [ActiveSupport::TimeZone]
-      def auto
-        %w[tz_env debian_config offset].lazy.map { |s| send("by_#{s}") }.find(&:present?)
-      end
-
-      def auto_set
-        ::Time.zone = auto
-      end
-
-      # @return [ActiveSupport::TimeZone]
-      def by_debian_config
-        path = ::Pathname.new(DEBIAN_CONFIG_PATH)
-        path.exist? ? path.read.strip.if_present { |v| ::ActiveSupport::TimeZone[v] } : nil
-      end
-
-      # @return [ActiveSupport::TimeZone]
-      def by_offset
-        ::ActiveSupport::TimeZone[::Time.now.getlocal.gmt_offset]
-      end
-
-      # @return [ActiveSupport::TimeZone]
-      def by_timedatectl
-        executable = ::EacRubyUtils::Envs.local.executable('timedatectl', '--version')
-        return nil unless executable.exist?
-
-        TIMEDATECTL_TIMEZONE_LINE_PATTERN.if_match(executable.command.execute!) { |m| m[1] }
-          .if_present { |v| ::ActiveSupport::TimeZone[v] }
-      end
-
-      # @return [ActiveSupport::TimeZone]
-      def by_tz_env
-        ENV['TZ'].presence
-      end
-    end
-  end
-end

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

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

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