eac_tools 0.122.0 → 0.123.0

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(&)
-        values.each(&)
-      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, &)
-        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, &)
-        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"].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}
-
-      # @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

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

@@ -1,74 +0,0 @@
-# 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.t(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

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/acts_as_instance_method'
-require 'eac_ruby_utils/patches/class/common_constructor'
-require 'eac_ruby_utils/patches/module/common_concern'
-
-module EacRubyUtils
-  module MethodClass
-    common_concern do
-      ::EacRubyUtils::MethodClass::Setup.new(self)
-    end
-
-    class Setup < ::EacRubyUtils::ActsAsInstanceMethod
-      common_constructor :method_class, :static_method, :options, default: [false, {}],
-                                                                  super_args: lambda {
-                                                                    [method_class, options]
-                                                                  } do
-        perform
-      end
-
-      def perform
-        setup
-      end
-
-      def default_sender_module
-        r = super
-        r = r.singleton_class if static_method
-        r
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/patches/class/common_constructor'
-
-module EacRubyUtils
-  module ModuleAncestorsVariable
-    class Base
-      common_constructor :the_module, :method_name, :initial_value
-
-      # @param current [Object]
-      # @param other [Object]
-      # @return [Object]
-      def merge_operation(current, other)
-        current.merge(other)
-      end
-
-      # return [Hash]
-      def ancestors_variable
-        the_module.ancestors.inject(initial_value.dup) do |a, e|
-          if e.respond_to?(method_name, true)
-            merge_operation(a, e.send(method_name).send(:self_variable))
-          else
-            a
-          end
-        end
-      end
-
-      # @return [Hash]
-      def self_variable
-        @self_variable ||= initial_value.dup
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/module_ancestors_variable/hash.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/module/delegation'
-require 'eac_ruby_utils/module_ancestors_variable/base'
-require 'eac_ruby_utils/enumerables_methods'
-
-module EacRubyUtils
-  module ModuleAncestorsVariable
-    class Hash < ::EacRubyUtils::ModuleAncestorsVariable::Base
-      INITIAL_VALUE = {}.freeze
-
-      def initialize(the_module, method_name)
-        super(the_module, method_name, INITIAL_VALUE)
-      end
-
-      delegate(*::EacRubyUtils::EnumerablesMethods::HASH_READ_METHODS, to: :ancestors_variable)
-      delegate(*::EacRubyUtils::EnumerablesMethods::HASH_WRITE_METHODS, to: :self_variable)
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/module_ancestors_variable/set.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/module/delegation'
-require 'eac_ruby_utils/module_ancestors_variable/base'
-
-module EacRubyUtils
-  module ModuleAncestorsVariable
-    class Set < ::EacRubyUtils::ModuleAncestorsVariable::Base
-      INITIAL_VALUE = ::Set.new
-
-      def initialize(the_module, method_name)
-        super(the_module, method_name, INITIAL_VALUE)
-      end
-
-      delegate(*::EacRubyUtils::EnumerablesMethods::SET_READ_METHODS, to: :ancestors_variable)
-      delegate(*::EacRubyUtils::EnumerablesMethods::SET_WRITE_METHODS, to: :self_variable)
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/module_ancestors_variable.rb

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/objects_table.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/regexp_parser'
-
-module EacRubyUtils
-  class ObjectsTable
-    BY_PARSER = ::EacRubyUtils::RegexpParser.new(/\Aby_([^!?]+)(!)?\z/) do |m|
-      BY_PARSER_PARSED_STRUCT.new(m[1], "by_attribute#{'!' if m[2].present?}")
-    end
-    BY_PARSER_PARSED_STRUCT = ::Struct.new(:attribute, :method_name)
-
-    common_constructor :objects, default: [[]]
-
-    # @param name [String, Symbol]
-    # @param value [Object]
-    # @return [Object, nil]
-    def by_attribute(name, value)
-      objects.find { |e| e.send(name) == value }
-    end
-
-    # @param name [String, Symbol]
-    # @param value [Object]
-    # @return [Object]
-    def by_attribute!(name, value)
-      by_attribute(name, value) ||
-        raise(::ArgumentError, "No item found with attribute #{name}=#{value}")
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      super || BY_PARSER.parse?(method_name)
-    end
-
-    def method_missing(method_name, *, &)
-      if (parsed = BY_PARSER.parse(method_name))
-        return send(parsed.method_name, parsed.attribute, *, &)
-      end
-
-      super
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/options_consumer.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/core_ext/hash/indifferent_access'
-require 'ostruct'
-
-module EacRubyUtils
-  class OptionsConsumer
-    DEFAULT_OPTIONS = { validate: true, ostruct: false }.with_indifferent_access.freeze
-
-    def initialize(data)
-      @data = data.with_indifferent_access
-    end
-
-    def consume(key, default_value = nil, &block)
-      return default_value unless data.key?(key)
-
-      value = data.delete(key)
-      value = yield(value) if block
-      value
-    end
-
-    # If last argument is a Hash it is used a options.
-    # Options:
-    # * +validate+: validate after consume.
-    # * +ostruct+: return a [OpenStruct] instead a [Hash].
-    # @return [Hash] (Default) or [OpenStruct].
-    def consume_all(*keys)
-      options = consume_all_extract_options(keys)
-      result = consume_all_build_result(keys, options.fetch(:ostruct))
-      validate if options.fetch(:validate)
-      result
-    end
-
-    def validate
-      return if data.empty?
-
-      raise "Invalid keys: #{data.keys}"
-    end
-
-    def left_data
-      data.dup
-    end
-
-    private
-
-    attr_reader :data
-
-    def consume_all_extract_options(keys)
-      options = DEFAULT_OPTIONS
-      options = options.merge(keys.pop.with_indifferent_access) if keys.last.is_a?(Hash)
-      options
-    end
-
-    def consume_all_build_result(keys, ostruct)
-      if ostruct
-        ::OpenStruct.new(keys.index_with { |key| consume(key) }) # rubocop:disable Style/OpenStructUse
-      else
-        keys.map { |key| consume(key) }
-      end
-    end
-  end
-end