eac_tools 0.125.0 → 0.126.1

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
+  class << self
+    def patch_module(*)
+      ::EacRubyUtils::PatchModule.perform(*)
+    end
+  end
+
+  module PatchModule
+    class << self
+      def perform(target, patch)
+        return if target.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/acts_as_instance_method.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_instance_method'
+
+class Class
+  # @param options [Hash]
+  # @return [EacRubyUtils::ActsAsInstanceMethod]
+  def acts_as_instance_method(**options)
+    ::EacRubyUtils::ActsAsInstanceMethod.new(self, options).setup
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_static_method'
+
+class Class
+  # @param options [Hash]
+  # @return [EacRubyUtils::ActsAsStaticMethod]
+  def acts_as_static_method(**options)
+    ::EacRubyUtils::ActsAsStaticMethod.new(self, options).setup
+  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,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_instance_method'
+
+class Class
+  # @deprecated Use {#acts_as_instance_method} instead.
+  def enable_method_class
+    acts_as_instance_method
+  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,12 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/class/acts_as_static_method'
+
+class Class
+  # @return [EacRubyUtils::ActsAsStaticMethod]
+  # @deprecated Use {#acts_as_static_method} instead.
+  def enable_static_method_class
+    ::EacRubyUtils::ActsAsStaticMethod.new(self).setup
+    acts_as_static_method
+  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__)

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerable/boolean_combinations.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Enumerable
+  # Produces a array with values's all combinations.
+  #
+  # Example:
+  #   %i[a b].boolean_combinations
+  #   => [[], [:a], [:b], [:a, :b]]
+  #
+  # @return [Array]
+  def bool_array_combs
+    bool_combs([], method(:bool_array_combs_new_comb))
+  end
+
+  # Produces a hash with values's all combinations.
+  #
+  # Example:
+  #   %i[a b].boolean_combinations
+  #   => [{a: false, b: false}, {a: false, b: true}, {a: true, b: false}, {a: true, b: true}]
+  #
+  # @return [Hash]
+  def bool_hash_combs
+    bool_combs({}, method(:bool_hash_combs_new_comb))
+  end
+
+  private
+
+  def bool_combs(empty_value, new_comb_method)
+    head = [empty_value]
+    r = inject(head) do |a, value|
+      new_comb_method.call(value, a)
+    end
+    r == head ? [] : r
+  end
+
+  def bool_array_combs_new_comb(value, combs)
+    combs + combs.map { |c| c + [value] }
+  end
+
+  def bool_hash_combs_new_comb(value, combs)
+    combs.flat_map do |comb|
+      [false, true].map { |bool_value| comb.dup.merge(value => bool_value) }
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerable.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/enumerator/current.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Enumerator
+  def current(default_value = nil)
+    peek
+  rescue ::StopIteration
+    default_value
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator/stopped.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Enumerator
+  def ongoing?
+    !stopped?
+  end
+
+  def stopped?
+    peek
+    false
+  rescue ::StopIteration
+    true
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/enumerator.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/hash/if_key.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+
+class Hash
+  # @return +block.call(fetch(key))+ if +self+ has the key +key+, +default_value+ otherwise.
+  def if_key(key, default_value = nil)
+    return default_value unless key?(key)
+
+    block_given? ? yield(fetch(key)) : fetch(key)
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/options_consumer'
+
+class Hash
+  # Returns an <tt>EacRubyUtils::OptionsConsumer</tt> out of its receiver.
+  def to_options_consumer
+    ::EacRubyUtils::OptionsConsumer.new(self)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/sym_keys_hash.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Hash
+  def to_sym_keys_hash
+    each_with_object({}) do |(key, value), memo|
+      symbol_key = key.respond_to?(:to_sym) ? key.to_sym : key.to_s.to_sym
+      memo[symbol_key] = value
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/hash/to_struct.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/struct'
+
+class Hash
+  # Returns an <tt>EacRubyUtils::Struct</tt> out of its receiver.
+  def to_struct
+    ::EacRubyUtils::Struct.new(self)
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir["#{File.dirname(__FILE__)}/#{File.basename(__FILE__, '.*')}/*.rb"].each do |path|
+  require path
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/integer/rjust_zero.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils'
+
+class Integer
+  RJUST_ZERO_STRING = '0'
+
+  # @param size [Integer]
+  # @return [String]
+  def rjust_zero(size)
+    to_s.rjust(size, RJUST_ZERO_STRING)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/integer.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/kernel/ibr.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kernel
+  # Raise exception with text "Invalid branch reached".
+  def ibr(message = nil)
+    s = "Invalid branch reached (Called in #{caller.first})"
+    s += ": #{message}" if message
+    raise s
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/kernel/nyi.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kernel
+  # Raise exception with text "Not yet implemented".
+  def nyi(message = nil)
+    s = "Not yet implemented (Called in #{caller.first})"
+    s += ": #{message}" if message
+    raise s
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/kernel.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/module/abstract_methods.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/acts_as_abstract'
+
+class Module
+  # @deprecated Use {#acts_as_abstract} instead.
+  def enable_abstract_methods(*methods)
+    acts_as_abstract(*methods)
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_abstract'
+
+class Module
+  # Include [EacRubyUtils::ActsAsAbstract] and perform EacRubyUtils::ActsAsAbstract.abstract_methods
+  # on parameter +methods+.
+  # @param methods [Array<Symbol>]
+  # @return [void]
+  def acts_as_abstract(*methods)
+    include ::EacRubyUtils::ActsAsAbstract
+
+    abstract_methods(*methods)
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch_module'
+require 'eac_ruby_utils/acts_as_immutable'
+
+class Module
+  def acts_as_immutable
+    ::EacRubyUtils.patch_module(self, ::EacRubyUtils::ActsAsImmutable)
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_concern'
+
+class Module
+  def common_concern(&)
+    ::EacRubyUtils::CommonConcern.new(&).setup(self)
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/compare_by'
+
+class Module
+  def compare_by(*fields)
+    ::EacRubyUtils::CompareBy.new(fields).apply(self)
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch_module'
+require 'eac_ruby_utils/contextualizable'
+
+class Module
+  # Patches module with [EacRubyUtils::Contextualizable].
+  def enable_context
+    ::EacRubyUtils.patch_module(self, ::EacRubyUtils::Contextualizable)
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/patch_self'
+require 'memoized'
+
+class Module
+  def enable_memoized
+    patch_self(::Memoized)
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/locales/module_i18n_translate'
+
+class Module
+  def i18n_translate(entry_suffix, values = {})
+    ::EacRubyUtils::Locales::ModuleI18nTranslate.new(self, entry_suffix, values).result
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch_module'
+require 'eac_ruby_utils/acts_as_immutable'
+
+class Module
+  # @deprecated Use {#acts_as_immutable} instead.
+  def enable_immutable
+    ::EacRubyUtils.patch_module(self, ::EacRubyUtils::ActsAsImmutable)
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch_module'
+require 'eac_ruby_utils/listable'
+
+class Module
+  def enable_listable
+    ::EacRubyUtils.patch_module(self, ::EacRubyUtils::Listable)
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/introspection'
+
+Module.alias_method :module_parent, :parent unless Module.method_defined?(:module_parent)

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

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

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+class Module
+  def require_sub(file_path, options = {})
+    ::EacRubyUtils.require_sub(file_path, { base: self }.merge(options))
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/patch_self'
+require 'eac_ruby_utils/simple_cache'
+
+class Module
+  def enable_simple_cache
+    patch_self(::EacRubyUtils::SimpleCache)
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/speaker/sender'
+
+class Module
+  def enable_speaker
+    include ::EacRubyUtils::Speaker::Sender
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/module.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/object/asserts.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Object
+  # Raises a ArgumentError if +self+ is not a +klass+.
+  #
+  # @return +self+
+  def assert_argument(klass, argument_name = 'unknown_argument_name')
+    return self if is_a?(klass)
+
+    raise ::ArgumentError,
+          "Argument \"#{argument_name}\" is not a #{klass}" \
+          "(Actual class: #{self.class}, actual value: #{self})"
+  end
+
+  # Raises a ArgumentError if +self.count+ is not equal to +count+.
+  #
+  # @return +self+
+  def assert_count(count, argument_name = 'unknown_argument_name')
+    return self if self.count == count
+
+    raise ::ArgumentError,
+          "Argument \"#{argument_name}\" has wrong elements count" \
+          "(Actual: #{self.count}, Required: #{count})"
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/compact'
+
+class Object
+  # If +self+ is a Proc, return the value of +.call+. If not, return +self+.
+  # @return [Object]
+  def call_if_proc
+    is_a?(::Proc) ? call : self
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/compact'
+
+class Object
+  # @return [EacRubyUtils::Compact]
+  def to_compact(*attributes)
+    ::EacRubyUtils::Compact.new(self, attributes)
+  end
+
+  # @return [Array]
+  def compact_to_a(*attributes)
+    to_compact(*attributes).to_a
+  end
+
+  # @return [Hash]
+  def compact_to_h(*attributes)
+    to_compact(*attributes).to_h
+  end
+end