eac_tools 0.119.0 → 0.121.0

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/hash_accessor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    class HashAccessor < ::EacRubyUtils::ActsAsImmutable::BaseAccessor
+      def apply(klass)
+        apply_plural(klass)
+        apply_singular(klass)
+      end
+
+      def immutable_value_get(object)
+        super || {}
+      end
+
+      def immutable_value_get_single(object, key)
+        immutable_value_get(object)[key]
+      end
+
+      def immutable_value_set(object, new_hash)
+        duplicate_object(object) { |_old_value| new_hash }
+      end
+
+      def immutable_value_set_single(object, key, value)
+        immutable_value_set(object, immutable_value_get(object).merge(key => value))
+      end
+
+      private
+
+      def apply_plural(klass)
+        accessor = self
+        klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do |*args|
+          case args.count
+          when 0 then next accessor.immutable_value_get_filtered(self)
+          when 1 then next accessor.immutable_value_set_filtered(self, args[0])
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 0..1)"
+          end
+        end
+      end
+
+      def apply_singular(klass)
+        accessor = self
+        klass.send(:define_method, name) do |*args|
+          case args.count
+          when 1 then next accessor.immutable_value_get_single(self, args[0])
+          when 2 then next accessor.immutable_value_set_single(self, *args[0..1])
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 1..2)"
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/instance_methods.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module ActsAsImmutable
+    module InstanceMethods
+      def immutable_constructor_args
+        []
+      end
+
+      private
+
+      def immutable_values_get
+        @immutable_values || {}
+      end
+
+      def immutable_values_set(new_values)
+        @immutable_values = new_values
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/set_accessor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable/enumerable_accessor'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    class SetAccessor < ::EacRubyUtils::ActsAsImmutable::EnumerableAccessor
+      INITIAL_VALUE = ::Set.new.freeze
+
+      # @param value [Object]
+      # @return [Set]
+      def immutable_value_set_assert(value)
+        return value if value.is_a?(::Set)
+        return value.to_set if value.respond_to?(:to_set)
+
+        ::Set.new(value)
+      end
+
+      # @return [Set] A empty Set.
+      def initial_value
+        INITIAL_VALUE
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/common_concern'
+require 'eac_ruby_utils/require_sub'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    ::EacRubyUtils.require_sub __FILE__
+
+    common_concern do
+      include ::EacRubyUtils::Listable
+
+      lists.add_symbol :type, :array, :boolean, :common, :hash
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_instance_method.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/introspection'
+require 'eac_ruby_utils/patches/class/common_constructor'
+require 'eac_ruby_utils/patches/module/module_parent'
+require 'eac_ruby_utils/patches/string/inflector'
+
+module EacRubyUtils
+  class ActsAsInstanceMethod
+    common_constructor :method_class
+
+    # @param sender_module [Module, nil]
+    # @return [self]
+    def setup(sender_module = nil)
+      sender_module ||= default_sender_module
+      the_setup = self
+      sender_module.define_method(method_name) do |*args, &block|
+        the_setup.method_class.new(self, *args, &block).result
+      end
+
+      self
+    end
+
+    # @return [String]
+    def method_name
+      method_class.name.demodulize.underscore.variableize
+    end
+
+    # @return [Module]
+    def default_sender_module
+      method_class.module_parent
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/arguments_consumer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'active_support/hash_with_indifferent_access'
+
+module EacRubyUtils
+  class ArgumentsConsumer
+    class << self
+      def parse(args, positional = [], options = {})
+        new(args, positional, options).data
+      end
+    end
+
+    attr_reader :positional, :default_options
+
+    def initialize(positional, default_options)
+      @positional = positional.dup.freeze
+      @default_options = default_options.dup.freeze
+    end
+
+    def parse(args)
+      Parser.new(self, args).data
+    end
+
+    class Parser
+      attr_reader :data, :arguments_consumer
+
+      def initialize(arguments_consumer, args)
+        @arguments_consumer = arguments_consumer
+        @data = ::ActiveSupport::HashWithIndifferentAccess.new
+        @options_found = false
+        arguments_consumer.positional.each { |key| data[key] = nil }
+        data.merge!(arguments_consumer.default_options)
+        args.each_with_index { |value, index| add_arg(value, index) }
+        data.freeze
+      end
+
+      private
+
+      def add_arg(value, index)
+        arg = ::Struct.new(:value, :index).new(value, index)
+        if arg.value.is_a?(::Hash)
+          add_hash_arg(arg)
+        else
+          add_positional_arg(arg)
+        end
+      end
+
+      def add_hash_arg(arg)
+        check_no_more_arguments(arg)
+        data.merge!(arg.value)
+        @options_found = true
+      end
+
+      def add_positional_arg(arg)
+        check_no_more_arguments(arg)
+        invalid_argument arg, 'No more valid positional' if
+          arg.index >= arguments_consumer.positional.count
+        data[arguments_consumer.positional[arg.index]] = arg.value
+      end
+
+      def check_no_more_arguments(arg)
+        return unless @options_found
+
+        invalid_argument arg, 'Hash already found - no more positional allowed'
+      end
+
+      def invalid_argument(arg, message)
+        raise InvalidArgumentError.new(self, arg, message)
+      end
+    end
+
+    class InvalidArgumentError < StandardError
+      def initialize(args_consumer, arg, message)
+        @args_consumer = args_consumer
+        @arg = arg
+        super("#{message} (Arg: #{arg}, Args Consumer: #{args_consumer})")
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/bit.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class Bit
+    VALID_VALUES = [0, 1].freeze
+
+    class << self
+      def assert(obj)
+        return obj if obj.is_a?(self)
+
+        new(obj.to_i)
+      end
+
+      def valid_integer?(value)
+        value.is_a?(::Integer) && VALID_VALUES.include?(value)
+      end
+
+      def validate_integer(value)
+        return value if valid_integer?(value)
+
+        raise(::ArgumentError, "Invalid bit value: #{value} (Valid: #{VALID_VALUES})")
+      end
+    end
+
+    attr_reader :value
+
+    compare_by :value
+    delegate :to_s, :zero?, to: :value
+
+    # @param value [Integer]
+    def initialize(value)
+      @value = self.class.validate_integer(value)
+    end
+
+    # @return [Boolean]
+    def one?
+      !zero?
+    end
+
+    # @return [Integer]
+    def to_i
+      value
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/bit_array.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/bit'
+require 'eac_ruby_utils/byte'
+require 'eac_ruby_utils/byte_array'
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class BitArray
+    class << self
+      def assert(obj)
+        return obj if obj.is_a?(self)
+        return new(obj) if obj.is_a?(::Enumerable)
+
+        raise "Could not convert #{obj} to #{self}"
+      end
+    end
+
+    delegate :each, :each_with_index, :to_a, :size, :count, :length, :[], :fetch, to: :values_array
+    compare_by :values_array
+
+    def initialize(values = [])
+      values.each { |value| push(value) }
+    end
+
+    def <<(value)
+      push(value)
+    end
+
+    # @return [EacRubyUtils::BitArray] +self+.
+    def push_array(other_bit_array)
+      values_array.push(*other_bit_array.to_a)
+
+      self
+    end
+
+    # @param value [EacRubyUtils::Bit]
+    # @return [EacRubyUtils::Bit]
+    def push(value)
+      values_array.push(::EacRubyUtils::Bit.assert(value))
+    end
+
+    # @return [EacRubyUtils::BitArray]
+    def reverse
+      self.class.new(values_array.reverse)
+    end
+
+    # @param big_endian [Boolean]
+    # @return [EacRubyUtils::ByteArray]
+    def to_byte_array(big_endian = false) # rubocop:disable Style/OptionalBooleanParameter
+      unless count.modulo(::EacRubyUtils::Byte::BIT_COUNT).zero?
+        raise 'Bits returned is not multile of 8'
+      end
+
+      byte_bits_enumerator.each_with_object(::EacRubyUtils::ByteArray.new) do |e, a|
+        a << ::EacRubyUtils::Byte.from_bit_array(e, big_endian)
+      end
+    end
+
+    # @return [Array<Integer>]
+    def to_int_array
+      values_array.map(&:to_i)
+    end
+
+    private
+
+    def byte_bits_enumerator
+      ::Enumerator.new do |y|
+        offset = 0
+        while offset < values_array.count
+          y.yield(values_array.slice(offset, ::EacRubyUtils::Byte::BIT_COUNT))
+          offset += ::EacRubyUtils::Byte::BIT_COUNT
+        end
+      end
+    end
+
+    def values_array
+      @values_array ||= []
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/blank_not_blank.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'singleton'
+
+module EacRubyUtils
+  # A blank string which returns +false+ for +blank?+ method.
+  class BlankNotBlank < String
+    include ::Singleton
+
+    def initialize
+      super('')
+    end
+
+    def blank?
+      false
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/boolean.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class Boolean
+    class << self
+      def parse(value)
+        return parse_string(value) if value.is_a?(::String)
+        return parse_string(value.to_s) if value.is_a?(::Symbol)
+        return parse_number(value) if value.is_a?(::Numeric)
+
+        value ? true : false
+      end
+
+      private
+
+      def parse_string(value) # rubocop:disable Naming/PredicateMethod
+        ['', 'n', 'no', 'f', 'false'].exclude?(value.strip.downcase)
+      end
+
+      def parse_number(value) # rubocop:disable Naming/PredicateMethod
+        value.zero?
+      end
+    end
+
+    attr_reader :value
+
+    def initialize(value)
+      @value = self.class.parse(value)
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/by_reference.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class ByReference
+    def initialize(&object_provider)
+      @object_provider = object_provider
+    end
+
+    def method_missing(method_name, *, &)
+      return object.send(method_name, *, &) if object.respond_to?(method_name)
+
+      super
+    end
+
+    def object
+      @object_provider.call
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      object.respond_to?(method_name, include_private)
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/byte.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/bit'
+require 'eac_ruby_utils/bit_array'
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class Byte
+    ASSEMBLY_HEXADECIMAL_PREFIX = '$'
+    BIT_COUNT = 8
+    BIT_INDEX_RANGE = (0..7)
+    VALUE_RANGE = (0..255)
+
+    class << self
+      def assert(obj)
+        return obj if obj.is_a?(self)
+
+        new(obj.to_i)
+      end
+
+      def from_bit_array(bit_array, big_endian = false) # rubocop:disable Style/OptionalBooleanParameter
+        bit_array = ::EacRubyUtils::BitArray.assert(bit_array)
+        raise ::ArgumentError, "Wrong bit array size: #{bit_array.size}" if
+        bit_array.size != BIT_COUNT
+
+        bit_array = bit_array.reverse if big_endian
+        bit_array.each_with_index.inject(new(0)) do |a, e|
+          a.bit_set(e[1], e[0])
+        end
+      end
+
+      def valid_bit_index?(value)
+        value.is_a?(::Integer) && BIT_INDEX_RANGE.include?(value)
+      end
+
+      def validate_bit_index(value)
+        return value if valid_bit_index?(value)
+
+        raise(::ArgumentError, "Invalid bit index: #{value} (Range: #{BIT_INDEX_RANGE})")
+      end
+
+      def valid_value?(value)
+        value.is_a?(::Integer) && VALUE_RANGE.include?(value)
+      end
+
+      def validate_value(value)
+        return value if valid_value?(value)
+
+        raise(::ArgumentError, "Invalid byte value: #{value} (Range: #{VALUE_RANGE})")
+      end
+    end
+
+    attr_reader :value
+
+    compare_by :value
+
+    def initialize(value)
+      self.value = value
+    end
+
+    # @param bit_index [Integer]
+    # @return [EacRubyUtils::Bit]
+    def [](bit_index)
+      bit_get(bit_index)
+    end
+
+    # @param bit_index [Integer]
+    # @return [EacRubyUtils::Bit]
+    def bit_get(bit_index)
+      self.class.validate_bit_index(bit_index)
+
+      ::EacRubyUtils::Bit.new((value & (1 << bit_index)) >> bit_index)
+    end
+
+    def bit_set(bit_index, bit_value)
+      self.class.validate_bit_index(bit_index)
+      bit = ::EacRubyUtils::Bit.assert(bit_value)
+      mask = (1 << bit_index)
+      self.class.new(bit.zero? ? value & ~mask : value | mask)
+    end
+
+    # @return [EacRubyUtils::BitArray]
+    def to_bit_array(range = BIT_INDEX_RANGE)
+      ::EacRubyUtils::BitArray.new(range.map { |bit_index| self[bit_index] })
+    end
+
+    # @return [Integer]
+    def to_i
+      value
+    end
+
+    # @return [String]
+    def to_asm_hex
+      ASSEMBLY_HEXADECIMAL_PREFIX + to_hex
+    end
+
+    # @return [String]
+    def to_hex
+      value.to_s(16).upcase.rjust(2, '0')
+    end
+
+    private
+
+    attr_writer :value
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/byte_array.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/byte'
+require 'eac_ruby_utils/patches/module/compare_by'
+
+module EacRubyUtils
+  class ByteArray
+    delegate :to_a, :size, :count, :length, :[], :fetch, :map, to: :values_array
+    compare_by :values_array
+
+    def initialize(values = [])
+      values.each { |value| push(value) }
+    end
+
+    def <<(value)
+      push(value)
+    end
+
+    # @param value [EacRubyUtils::Byte]
+    # @return [EacRubyUtils::Byte]
+    def push(value)
+      values_array.push(::EacRubyUtils::Byte.assert(value))
+    end
+
+    # @return [Array<Integer>]
+    def to_int_array
+      values_array.map(&:to_i)
+    end
+
+    private
+
+    def values_array
+      @values_array ||= []
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/common_concern/class_setup.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'memoized'
+require 'eac_ruby_utils/patches/object/if_present'
+
+module EacRubyUtils
+  class CommonConcern
+    class ClassSetup
+      include ::Memoized
+
+      attr_reader :a_class, :module_setup, :include_method
+
+      def initialize(module_setup, a_class, include_method)
+        @module_setup = module_setup
+        @a_class = a_class
+        @include_method = include_method
+      end
+
+      def run
+        %w[class_methods instance_methods after_callback].each do |suffix|
+          send("setup_#{suffix}")
+        end
+      end
+
+      def setup_class_methods
+        class_methods_module.if_present { |v| a_class.extend v }
+      end
+
+      def setup_instance_methods
+        instance_methods_module.if_present { |v| a_class.send(include_method, v) }
+      end
+
+      def setup_after_callback
+        module_setup.common_concern.after_callback.if_present do |v|
+          a_class.instance_eval(&v)
+        end
+      end
+
+      memoize def class_methods_module
+        module_setup.a_module.const_get(CLASS_METHODS_MODULE_NAME)
+      rescue NameError
+        nil
+      end
+
+      memoize def instance_methods_module
+        module_setup.a_module.const_get(INSTANCE_METHODS_MODULE_NAME)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/common_concern/module_setup.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'eac_ruby_utils/common_concern/class_setup'
+require 'memoized'
+require 'eac_ruby_utils/patches/object/if_present'
+
+module EacRubyUtils
+  class CommonConcern
+    class ModuleSetup
+      include ::Memoized
+
+      attr_reader :a_module, :common_concern
+
+      def initialize(common_concern, a_module)
+        @common_concern = common_concern
+        @a_module = a_module
+      end
+
+      def run
+        a_module.extend(::ActiveSupport::Concern)
+        include_or_prepend(:included, :include)
+        include_or_prepend(:prepended, :prepend)
+      end
+
+      private
+
+      def include_or_prepend(module_method, class_setup_method)
+        setup = self
+        a_module.send(module_method, *a_module_method_args(module_method)) do
+          ::EacRubyUtils::CommonConcern::ClassSetup.new(setup, self, class_setup_method).run
+        end
+      end
+
+      def a_module_method_args(module_method)
+        method_arity = a_module.method(module_method).arity
+        method_arity = -method_arity - 1 if method_arity.negative?
+        method_arity.times.map { |_n| a_module }
+      end
+    end
+  end
+end