eac_tools 0.90.0 → 0.90.1

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require 'eac_ruby_utils/require_sub'
-
-module EacRubyUtils
-  # Provide a option by constant, method or options object.
-  module SettingsProvider
-    ::EacRubyUtils.require_sub __FILE__, base: self
-
-    def setting_constant_name(key, fullname = false) # rubocop:disable Style/OptionalBooleanParameter
-      setting_value_instance(key).constant_name(fullname)
-    end
-
-    def setting_search_order
-      %w[settings_object method constant]
-    end
-
-    # return [ActiveSupport::HashWithIndifferentAccess]
-    def settings_object
-      ActiveSupport::HashWithIndifferentAccess.new(
-        respond_to?(settings_object_name) ? send(settings_object_name) : {}
-      )
-    end
-
-    def settings_object_name
-      'settings'
-    end
-
-    def setting_value(key, options = {})
-      setting_value_instance(key, options).value
-    end
-
-    def setting_value_by_constant(key)
-      setting_value_instance(key).value_by_constant
-    end
-
-    def setting_value_by_method(key)
-      setting_value_instance(key).value_by_method
-    end
-
-    def setting_value_by_settings_object(key)
-      setting_value_instance(key).value_by_settings_object
-    end
-
-    def setting_value_instance(key, options = {})
-      ::EacRubyUtils::SettingsProvider::SettingValue.new(self, key, options)
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  module SimpleCache
-    UNCACHED_METHOD_NAME_SUFFIX = '_uncached'
-    UNCACHED_METHOD_PATTERN = /
-      \A(\s+)_#{::Regexp.quote(UNCACHED_METHOD_NAME_SUFFIX)}([\!\?]?)\z
-    /x.freeze
-
-    class << self
-      def uncached_method_name(method_name)
-        method_name = method_name.to_s
-        end_mark = nil
-        if %w[! ?].any? { |mark| method_name.end_with?(mark) }
-          end_mark = method_name[-1]
-          method_name = method_name[0..-2]
-        end
-        "#{method_name}#{UNCACHED_METHOD_NAME_SUFFIX}#{end_mark}"
-      end
-    end
-
-    def method_missing(method, *args, &block)
-      if respond_to?(uncached_method_name(method), true)
-        call_method_with_cache(method, args, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method, include_all = false)
-      if method.to_s.end_with?('_uncached')
-        super
-      else
-        respond_to?("#{method}_uncached", true) || super
-      end
-    end
-
-    def reset_cache(*keys)
-      if keys.any?
-        keys.each { |key| cache_keys.delete(sanitize_cache_key(key)) }
-      else
-        @cache_keys = nil
-      end
-    end
-
-    def sanitize_cache_key(key)
-      key.to_s.to_sym
-    end
-
-    protected
-
-    def uncached_method_name(original_method_name)
-      ::EacRubyUtils::SimpleCache.uncached_method_name(original_method_name)
-    end
-
-    private
-
-    def call_method_with_cache(method, args, &block)
-      raise 'Não é possível realizar o cache de métodos com bloco' if block
-
-      key = ([method] + args).join('@@@')
-      unless cache_keys.key?(sanitize_cache_key(key))
-        uncached_value = call_uncached_method(method, args)
-        cache_keys[sanitize_cache_key(key)] = uncached_value
-      end
-      cache_keys[sanitize_cache_key(key)]
-    end
-
-    def call_uncached_method(method, args)
-      send(uncached_method_name(method), *args)
-    end
-
-    def cache_keys
-      @cache_keys ||= {}
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/speaker/receiver.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/acts_as_abstract'
-
-module EacRubyUtils
-  module Speaker
-    module Receiver
-      extend ::ActiveSupport::Concern
-      extend ::EacRubyUtils::ActsAsAbstract
-
-      module ClassMethods
-        def on(*args, &block)
-          ::EacRubyUtils::Speaker.context.on(new(*args), &block)
-        end
-      end
-
-      def error(_string)
-        raise_abstract_method(__method__)
-      end
-
-      def fatal_error(string)
-        error(string)
-        ::Kernel.exit 1
-      end
-
-      # @see EacRubyUtils::Speaker::Sender.input
-      def input(_question, _options = {})
-        raise_abstract_method(__method__)
-      end
-
-      def info(_string)
-        raise_abstract_method(__method__)
-      end
-
-      def infom(_string)
-        raise_abstract_method(__method__)
-      end
-
-      def infov(*_args)
-        raise_abstract_method(__method__)
-      end
-
-      def out(_string = '')
-        raise_abstract_method(__method__)
-      end
-
-      def puts(_string = '')
-        raise_abstract_method(__method__)
-      end
-
-      def success(_string)
-        raise_abstract_method(__method__)
-      end
-
-      def title(_string)
-        raise_abstract_method(__method__)
-      end
-
-      def warn(_string)
-        raise_abstract_method(__method__)
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/speaker/sender.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/compact'
-
-module EacRubyUtils
-  module Speaker
-    module Sender
-      delegate :error, :fatal_error, :info, :infom, :infov, :out, :puts, :title, :success, :warn,
-               to: :speaker_receiver
-
-      # Shortcut to [EacRubyUtils::Speaker.current_receiver].
-      #
-      # @return [EacRubyUtils::Speaker::Receiver]
-      def speaker_receiver
-        ::EacRubyUtils::Speaker.current_receiver
-      end
-
-      # @param attributes [Enumerable<Symbol>] Attributes for +EacRubyUtils::Compact.new+.
-      # @return [self]
-      def compact_infov(*attributes)
-        ::EacRubyUtils::Compact.new(self, attributes).to_h.each do |k, v|
-          infov k, v
-        end
-
-        self
-      end
-
-      # Options:
-      #   +bool+ ([Boolean], default: +false+): requires a answer "yes" or "no".
-      #   +list+ ([Hash] or [Array], default: +nil+): requires a answer from a list.
-      #   +noecho+ ([Boolean], default: +false+): does not output answer.
-      def input(question, options = {})
-        speaker_receiver.input(question, options)
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/contextualizable'
-
-module EacRubyUtils
-  module Speaker
-    include ::EacRubyUtils::Contextualizable
-
-    class << self
-      # @return [EacRubyUtils::Speaker::Receiver]
-      def current_receiver
-        context.current
-      end
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/method_class'
-require 'eac_ruby_utils/patches/module/common_concern'
-
-module EacRubyUtils
-  module StaticMethodClass
-    common_concern do
-      ::EacRubyUtils::MethodClass::Setup.new(self, true)
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/string_delimited.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  class StringDelimited
-    attr_reader :string, :begin_delimiter, :end_delimiter
-
-    def initialize(string, begin_delimiter, end_delimiter)
-      @string = string
-      @begin_delimiter = begin_delimiter
-      @end_delimiter = end_delimiter
-    end
-
-    def inner
-      between_indexes(content_index, end_index).to_s
-    end
-
-    def outer
-      between_indexes(begin_index, after_end_index).to_s
-    end
-
-    def without_inner
-      without_join(
-        between_indexes(sos_index, content_index), between_indexes(end_index, eos_index)
-      )
-    end
-
-    def without_outer
-      without_join(
-        between_indexes(sos_index, begin_index),
-        between_indexes(after_end_index, eos_index)
-      )
-    end
-
-    private
-
-    def after_end_index
-      end_index.if_present { |v| v + end_delimiter.length }
-    end
-
-    def begin_index
-      string.index(begin_delimiter)
-    end
-
-    def between_indexes(a_begin_index, a_end_index)
-      a_begin_index && a_end_index ? string[a_begin_index, a_end_index - a_begin_index] : nil
-    end
-
-    def content_index
-      begin_index.if_present { |v| v + begin_delimiter.length }
-    end
-
-    def without_join(*strings)
-      return string if strings.any?(&:nil?)
-
-      strings.join
-    end
-
-    def end_index
-      content_index.if_present { |_v| string.index(end_delimiter, content_index) }
-    end
-
-    def sos_index
-      0
-    end
-
-    def eos_index
-      string.length
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/struct.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'active_support/hash_with_indifferent_access'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/object/blank'
-
-module EacRubyUtils
-  class Struct
-    def initialize(initial_data = {})
-      self.data = initial_data.symbolize_keys
-    end
-
-    def [](key)
-      key, bool = parse_key(key)
-      bool ? self[key].present? : data[key]
-    end
-
-    def fetch(key)
-      key, bool = parse_key(key)
-      bool ? fetch(key).present? : data.fetch(key)
-    end
-
-    def merge(other)
-      other = self.class.new(other) unless other.is_a?(self.class)
-      self.class.new(to_h.merge(other.to_h))
-    end
-
-    def method_missing(method_name, *arguments, &block)
-      property_method?(method_name) ? fetch(method_name) : super
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      property_method?(method_name) || super
-    end
-
-    def slice_fetch(*keys)
-      self.class.new(keys.index_with { |key| fetch(key) })
-    end
-
-    def to_h
-      data.dup
-    end
-
-    delegate :to_s, to: :data
-
-    private
-
-    attr_accessor :data
-
-    def parse_key(key)
-      m = /\A(.+)\?\z/.match(key.to_s)
-      [(m ? m[1] : key.to_s).to_sym, m ? true : false]
-    end
-
-    def property_method?(key)
-      property_methods.include?(key.to_sym)
-    end
-
-    def property_methods
-      data.keys.flat_map { |k| [k.to_sym, :"#{k}?"] }
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/unimplemented_method_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  class UnimplementedMethodError < ::StandardError
-  end
-end

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

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/wildcards.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module EacRubyUtils
-  # The `Wildcards` class provides pattern matching with wildcards using regular expressions.
-  class Wildcards
-    # Initializes a new instance of the `Wildcards` class with the specified pattern.
-    #
-    # @param pattern [String] The pattern to match against.
-    def initialize(pattern)
-      @pattern = pattern
-    end
-
-    # Matches the given string against the pattern.
-    #
-    # @param string [String] The string to match.
-    # @return [Boolean] Returns `true` if the string matches the pattern, otherwise `false`.
-    delegate :match?, to: :regex
-
-    private
-
-    # @return [Regexp]
-    def regex
-      ::Regexp.new("^#{::Regexp.escape(@pattern).gsub('\*', '.*').gsub('\?', '.?')}$")
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/yaml.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require 'date'
-require 'yaml'
-
-module EacRubyUtils
-  # A safe YAML loader/dumper with common types included.
-  class Yaml
-    class << self
-      DEFAULT_PERMITTED_CLASSES = [::Array, ::Date, ::DateTime, ::FalseClass, ::Hash, ::NilClass,
-                                   ::Numeric, ::String, ::Symbol, ::Time, ::TrueClass].freeze
-
-      def dump(object)
-        ::YAML.dump(sanitize(object))
-      end
-
-      def dump_file(path, object)
-        ::File.write(path.to_s, dump(object))
-      end
-
-      def load(string)
-        ::YAML.safe_load(string, permitted_classes: permitted_classes)
-      end
-
-      def load_file(path)
-        load(::File.read(path.to_s))
-      end
-
-      def permitted_classes
-        DEFAULT_PERMITTED_CLASSES
-      end
-
-      def sanitize(object)
-        Sanitizer.new(object).result
-      end
-
-      def yaml?(object)
-        return false unless object.is_a?(::String)
-        return false unless object.start_with?('---')
-
-        load(object)
-        true
-      rescue ::Psych::Exception
-        false
-      end
-
-      class Sanitizer
-        attr_reader :source
-
-        RESULT_TYPES = %w[permitted enumerableable hashable].freeze
-
-        def initialize(source)
-          @source = source
-        end
-
-        def result
-          RESULT_TYPES.each do |type|
-            return send("result_#{type}") if send("result_#{type}?")
-          end
-
-          source.to_s
-        end
-
-        private
-
-        def result_enumerableable?
-          source.respond_to?(:to_a) && !source.is_a?(::Hash)
-        end
-
-        def result_enumerableable
-          source.to_a.map { |child| sanitize_value(child) }
-        end
-
-        def result_hashable?
-          source.respond_to?(:to_h)
-        end
-
-        def result_hashable
-          source.to_h.to_h { |k, v| [k.to_sym, sanitize_value(v)] }
-        end
-
-        def result_nil?
-          source.nil?
-        end
-
-        def result_nil
-          nil
-        end
-
-        def result_permitted?
-          (::EacRubyUtils::Yaml.permitted_classes - [::Array, ::Hash])
-            .any? { |klass| source.is_a?(klass) }
-        end
-
-        def result_permitted
-          source
-        end
-
-        def sanitize_value(value)
-          self.class.new(value).result
-        end
-      end
-    end
-  end
-end

data/sub/eac_ruby_utils/lib/eac_ruby_utils.rb

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

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/acts_as_abstract_spec.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/acts_as_abstract'
-require 'eac_ruby_utils/unimplemented_method_error'
-
-RSpec.describe(EacRubyUtils::ActsAsAbstract) do
-  let(:base_class) do
-    the_module = described_class
-    Class.new do
-      include the_module
-
-      abstract_methods :method1, :method2
-
-      def method3
-        'base result'
-      end
-    end
-  end
-  let(:sub_class) do
-    Class.new(base_class) do
-      def method1
-        'a result'
-      end
-
-      def method4
-        'sub result'
-      end
-    end
-  end
-
-  class << self
-    def specs_for_target(test_target, instances_hash)
-      describe "##{test_target}" do
-        specs_for_instances(test_target, instances_hash)
-      end
-    end
-
-    def specs_for_instances(test_target, instances_hash)
-      instances_hash.each do |instance_name, expected_values|
-        context "when instance is \"#{instance_name}\"" do
-          let(:instance) { send("#{instance_name}_class").new }
-
-          specs_for_methods_values(test_target, expected_values)
-        end
-      end
-    end
-
-    def specs_for_methods_values(test_target, expected_values)
-      expected_values.each_with_index do |expected_value, method_index|
-        method_name = "method#{method_index + 1}"
-        context "when method is \"#{method_name}\"" do
-          send("specs_for_#{test_target}", method_name, expected_value)
-        end
-      end
-    end
-
-    def specs_for_abstract_method(method_name, expected_value)
-      it { expect(instance.abstract_method?(method_name)).to eq(expected_value) }
-    end
-
-    def specs_for_method_missing(method_name, expected_value)
-      if expected_value.is_a?(Class) && expected_value < Exception
-        it do
-          expect { instance.send(method_name) }.to raise_error(expected_value)
-        end
-      else
-        it do
-          expect(instance.send(method_name)).to eq(expected_value)
-        end
-      end
-    end
-
-    def specs_for_respond_to_missing(method_name, expected_value)
-      it { expect(instance.respond_to?(method_name)).to eq(expected_value) }
-    end
-  end
-  {
-    abstract_method: {
-      base: [true, true, false, false],
-      sub: [false, true, false, false]
-    },
-    method_missing: {
-      base: [EacRubyUtils::UnimplementedMethodError, EacRubyUtils::UnimplementedMethodError,
-             'base result', NoMethodError],
-      sub: ['a result', EacRubyUtils::UnimplementedMethodError, 'base result', 'sub result']
-    },
-    respond_to_missing: {
-      base: [true, true, true, false],
-      sub: [true, true, true, true]
-    }
-  }.each do |test_target, instances_hash|
-    specs_for_target(test_target, instances_hash)
-  end
-end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/acts_as_immutable/array_accessor_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/acts_as_immutable'
-
-RSpec.describe EacRubyUtils::ActsAsImmutable::ArrayAccessor do
-  let(:stub_class) do
-    Class.new do
-      include EacRubyUtils::ActsAsImmutable
-
-      immutable_accessor :array_attr, type: :array
-    end
-  end
-
-  let(:initial_instance) { stub_class.new }
-
-  it do
-    expect(initial_instance.array_attrs).to eq([])
-  end
-
-  context 'when array_attr pushs for' do
-    let(:change1_instance) { initial_instance.array_attr('A') }
-
-    it { expect(change1_instance).to be_a(initial_instance.class) }
-    it { expect(change1_instance.object_id).not_to eq(initial_instance.object_id) }
-    it { expect(change1_instance.array_attrs).to eq(%w[A]) }
-
-    context 'when array_attrs sets for' do
-      let(:change2_instance) { initial_instance.array_attrs(%w[B]) }
-
-      it { expect(change2_instance).to be_a(initial_instance.class) }
-      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
-      it { expect(change2_instance.array_attrs).to eq(%w[B]) }
-    end
-
-    context 'when array_attrs sets for a non array' do
-      let(:change2_instance) { initial_instance.array_attrs('B') }
-
-      it { expect(change2_instance).to be_a(initial_instance.class) }
-      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
-      it { expect(change2_instance.array_attrs).to eq(%w[B]) }
-    end
-  end
-end