eac_tools 0.3.0 → 0.4.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+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)
+      setting_value_instance(key).constant_name(fullname)
+    end
+
+    def setting_search_order
+      %w[settings_object method constant]
+    end
+
+    def settings_object
+      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

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/abstract_methods'
+
+module EacRubyUtils
+  module Speaker
+    module Receiver
+      extend ::ActiveSupport::Concern
+      extend ::EacRubyUtils::AbstractMethods
+
+      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 # rubocop:disable Rails/Exit
+      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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module Speaker
+    module Sender
+      delegate :error, :fatal_error, :info, :infom, :title, :success, :warn, to: :speaker_receiver
+
+      def infov(*args)
+        speaker_receiver.infov(*args)
+      end
+
+      delegate :out, to: :speaker_receiver
+
+      delegate :puts, to: :speaker_receiver
+
+      # Shortcut to [EacRubyUtils::Speaker.current_receiver].
+      #
+      # @return [EacRubyUtils::Speaker::Receiver]
+      def speaker_receiver
+        ::EacRubyUtils::Speaker.current_receiver
+      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

@@ -0,0 +1,16 @@
+# 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/string_delimited.rb

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

@@ -0,0 +1,63 @@
+# 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.map { |key| [key, fetch(key)] }.to_h)
+    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}?".to_sym] }
+    end
+  end
+end

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

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

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

@@ -0,0 +1,105 @@
+# 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)
+      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::SyntaxError
+        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.map { |k, v| [k.to_sym, sanitize_value(v)] }.to_h
+        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

@@ -0,0 +1,6 @@
+# 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/abstract_methods_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/abstract_methods'
+
+RSpec.describe(::EacRubyUtils::AbstractMethods) do
+  let(:base_class) do
+    the_module = described_class
+    ::Class.new do
+      include the_module
+
+      abstract_methods :method1, :method2
+    end
+  end
+  let(:base_instance) { base_class.new }
+  let(:sub_class) do
+    ::Class.new(base_class) do
+      def method1
+        'a result'
+      end
+    end
+  end
+  let(:sub_instance) { sub_class.new }
+
+  it { expect { base_instance.method1 }.to raise_error(::NoMethodError) }
+  it { expect { base_instance.method2 }.to raise_error(::NoMethodError) }
+  it { expect(sub_instance.method1).to eq('a result') }
+  it { expect { sub_instance.method2 }.to raise_error(::NoMethodError) }
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/arguments_consumer'
+
+RSpec.describe ::EacRubyUtils::ArgumentsConsumer do
+  let(:instance) { described_class.new(%i[a b c d], d: 'd_value') }
+  let(:args) { ['a_value', 'b_value', e: 'e_value'] }
+  let(:result) { instance.parse(args) }
+
+  it { expect(result).to be_a(::Hash) }
+  it { expect(result.count).to eq(5) }
+  it { expect(result.fetch(:a)).to eq('a_value') }
+  it { expect(result.fetch(:b)).to eq('b_value') }
+  it { expect(result.fetch(:c)).to eq(nil) }
+  it { expect(result.fetch(:d)).to eq('d_value') }
+  it { expect(result.fetch(:e)).to eq('e_value') }
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/bit_array'
+
+RSpec.describe ::EacRubyUtils::BitArray do
+  describe '#to_byte_array' do
+    let(:instance) { described_class.new([0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1]) }
+
+    {
+      false => [0xF0, 0xDC],
+      true => [0x0F, 0x3B]
+    }.each do |big_endian, expected_bytes|
+      context "when big-endian is #{big_endian}" do
+        let(:expected_value) { ::EacRubyUtils::ByteArray.new(expected_bytes) }
+
+        it do
+          expect(instance.to_byte_array(big_endian)).to eq(expected_value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/blank_not_blank'
+
+RSpec.describe ::EacRubyUtils::BlankNotBlank do
+  let(:instance) { described_class.instance }
+
+  it do
+    expect { described_class.new }.to raise_error(::NoMethodError)
+  end
+
+  it { expect(instance).to be_present }
+  it { expect(instance).not_to be_blank }
+  it { expect(instance).to be_truthy }
+  it { expect(instance).to eq('') }
+end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/byte'
+
+RSpec.describe ::EacRubyUtils::Byte do
+  describe '#[]' do
+    let(:instance) { described_class.new(0xDC) }
+
+    [0, 0, 1, 1, 1, 0, 1, 1].each_with_index do |bit_value, bit_index|
+      context "when bit index is #{bit_index}" do
+        it { expect(instance[bit_index].value).to eq(bit_value) }
+      end
+    end
+  end
+
+  describe '#bit_set' do
+    let(:instance) { described_class.new(0b11011100) }
+
+    {
+      0 => [0b11011100, 0b11011100, 0b11011000, 0b11010100,
+            0b11001100, 0b11011100, 0b10011100, 0b01011100],
+      1 => [0b11011101, 0b11011110, 0b11011100, 0b11011100,
+            0b11011100, 0b11111100, 0b11011100, 0b11011100]
+    }.each do |bit_value, expected_values|
+      expected_values.each_with_index do |expected_value, bit_index|
+        context "when bit index is #{bit_index} and bit value is #{bit_value}" do
+          it do
+            expect(instance.bit_set(bit_index, bit_value))
+              .to eq(described_class.new(expected_value))
+          end
+        end
+      end
+    end
+  end
+
+  describe '#from_bit_array' do
+    let(:bit_array) { [0, 0, 1, 1, 1, 0, 1, 1] }
+
+    { false => 0b11011100, true => 0b00111011 }.each do |big_endian, expected_integer|
+      context "when big-endian is #{big_endian}" do
+        let(:expected_value) { described_class.new(expected_integer) }
+
+        it do
+          expect(described_class.from_bit_array(bit_array, big_endian)).to eq(expected_value)
+        end
+      end
+    end
+
+    it do
+      expect { described_class.from_bit_array([0, 0, 1, 1, 1, 0, 1]) }
+        .to raise_error(::ArgumentError)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_concern'
+
+RSpec.describe ::EacRubyUtils::CommonConcern do
+  let(:instance) do
+    described_class.new do
+      self.valor = 'changed'
+    end
+  end
+
+  let(:stub_module) do
+    ::Module.new do
+      module ClassMethods # rubocop:disable RSpec/LeakyConstantDeclaration
+        def my_class_method
+          'class'
+        end
+      end
+
+      module InstanceMethods # rubocop:disable RSpec/LeakyConstantDeclaration
+        def my_instance_method
+          'from_module'
+        end
+      end
+    end
+  end
+
+  let(:stub_class) do
+    ::Class.new do
+      class << self
+        attr_accessor :valor
+      end
+
+      def my_instance_method
+        'from_class'
+      end
+    end
+  end
+
+  let(:stub_class_instance) { stub_class.new }
+
+  before do
+    instance.setup(stub_module)
+  end
+
+  context 'when included' do
+    before do
+      stub_class.include stub_module
+    end
+
+    it { expect(stub_class_instance.my_instance_method).to eq('from_class') }
+    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
+    it { expect(stub_class_instance.class.valor).to eq('changed') }
+  end
+
+  context 'when prepended' do
+    before do
+      stub_class.prepend stub_module
+    end
+
+    it { expect(stub_class_instance.my_instance_method).to eq('from_module') }
+    it { expect(stub_class_instance.class.my_class_method).to eq('class') }
+    it { expect(stub_class_instance.class.valor).to eq('changed') }
+  end
+end