eac_tools 0.105.1 → 0.105.2

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

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

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

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

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

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

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

@@ -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,30 @@
+# 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, default: [false],
+                                                        super_args: -> { [method_class] } 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

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

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

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

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

@@ -0,0 +1,41 @@
+# 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, *arguments, &block)
+      if (parsed = BY_PARSER.parse(method_name))
+        return send(parsed.method_name, parsed.attribute, *arguments, &block)
+      end
+
+      super
+    end
+  end
+end

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

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patch_module.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/common_concern'
+
+module EacRubyUtils
+  module PatchModule
+    common_concern
+
+    class_methods do
+      delegate :patch_module, to: :'::EacRubyUtils::PatchModule'
+    end
+
+    class << self
+      def patch_module(target, patch)
+        return if target.included_modules.include?(patch)
+
+        target.send(:include, patch)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/addressable/uri/query_value.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'addressable'
+
+module Addressable
+  class URI
+    # @return [ActiveSupport:HashWithIndifferentAccess]
+    def hash_query_values
+      (query_values || {}).with_indifferent_access
+    end
+
+    def query_value(*args)
+      if args.one?
+        query_value_get(*args)
+      elsif args.count == 2
+        query_value_set(*args)
+      else
+        raise ::ArgumentError, "#{object.class}.#{__method__}: wrong number of arguments " \
+                               "(given #{args.count}, expected 1..2)"
+      end
+    end
+
+    private
+
+    def query_value_get(name)
+      hash_query_values[name]
+    end
+
+    def query_value_set(name, value)
+      new_query_values = hash_query_values
+      new_query_values[name] = value
+      self.query_values = new_query_values
+
+      self
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/addressable/uri.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/addressable.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/class/abstract.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_abstract'
+
+class Class
+  def abstract?
+    ::EacRubyUtils::ActsAsAbstract.abstract?(self)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/class/common_constructor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_constructor'
+
+class Class
+  def common_constructor(...)
+    ::EacRubyUtils::CommonConstructor.new(...).setup_class(self)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/class/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_module(self, ::EacRubyUtils::MethodClass)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/class/self_included_modules.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Class
+  def self_included_modules
+    ancestors.take_while { |a| a != superclass }.select { |ancestor| ancestor.instance_of?(Module) }
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/class/settings_provider.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch_module'
+require 'eac_ruby_utils/settings_provider'
+
+class Class
+  def enable_settings_provider
+    ::EacRubyUtils.patch_module(self, ::EacRubyUtils::SettingsProvider)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/class/static_method_class.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/static_method_class'
+
+class Module
+  def enable_static_method_class
+    ::EacRubyUtils.patch_module(self, ::EacRubyUtils::StaticMethodClass)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/class.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+EacRubyUtils.require_sub(__FILE__)