eac_ruby_utils 0.88.0 → 0.89.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a3e785240ca74c309c1666c6cabbfd0d4b1533ee2fea2739272efe8925679bf
-  data.tar.gz: 76439955c6da58c19943e07fca3a8768e539d57b2684bd89d46ff64c64ed7f55
+  metadata.gz: e93445e91d5ebd5045f85aacc525da520bfdabf6ca97087296cf98fc37b78af9
+  data.tar.gz: 807b4d9838d1b990aa0152bce0c24d3fae4189b92ad07575b6ea26ec9dd7c3a6
 SHA512:
-  metadata.gz: c9700725a581ac9903843337f2ee962ec8f932e5f2aabfa448affca8ad306096857400273d6571e5c30886cbb17b120e7f5836bddbbcfcc3dc2ddba583473ee7
-  data.tar.gz: 1d11cbb29b0835442f20e05a326e17162a9ad1d9753af22e9f1e36ccfc956c87973e9a72bfa2880cf54d3f4257cb3909e97d08c511cc656cb8979f5580a50643
+  metadata.gz: f33fdf6f0aad6e64d072074a396a58c51b9116827aa91847025a4c91cc880e6af8311b34b3dbfdbd55b15fb9612cdba211da853895b4b2182b07229e82c84bd4
+  data.tar.gz: 03c783a9676f370fe1b4d629fdcc227d759c4e7fe37335c8fe15c15e63234f836d8b2a6bf95e389d948210f6cd9880ce261814e8a52644263e9ac7b4c6b144ed

data/lib/eac_ruby_utils/bit.rb

@@ -0,0 +1,46 @@
+# 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/lib/eac_ruby_utils/bit_array.rb

@@ -0,0 +1,74 @@
+# 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
+
+    # @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)
+      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/lib/eac_ruby_utils/byte.rb

@@ -0,0 +1,93 @@
+# 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
+    BIT_COUNT = 8
+    BIT_INDEX_RANGE = (0..7).freeze
+    VALUE_RANGE = (0..255).freeze
+
+    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)
+        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
+
+    def to_bit_array
+      BIT_INDEX_RANGE.map { |bit_index| self[bit_index] }
+    end
+
+    # @return [Integer]
+    def to_i
+      value
+    end
+
+    private
+
+    attr_writer :value
+  end
+end

data/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, 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/lib/eac_ruby_utils/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eac_ruby_utils
 version: !ruby/object:Gem::Version
-  version: 0.88.0
+  version: 0.89.0
 platform: ruby
 authors:
 - Esquilo Azul Company
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-03 00:00:00.000000000 Z
+date: 2022-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -102,9 +102,13 @@ files:
 - lib/eac_ruby_utils.rb
 - lib/eac_ruby_utils/abstract_methods.rb
 - lib/eac_ruby_utils/arguments_consumer.rb
+- lib/eac_ruby_utils/bit.rb
+- lib/eac_ruby_utils/bit_array.rb
 - lib/eac_ruby_utils/blank_not_blank.rb
 - lib/eac_ruby_utils/boolean.rb
 - lib/eac_ruby_utils/by_reference.rb
+- lib/eac_ruby_utils/byte.rb
+- lib/eac_ruby_utils/byte_array.rb
 - lib/eac_ruby_utils/common_concern.rb
 - lib/eac_ruby_utils/common_concern/class_setup.rb
 - lib/eac_ruby_utils/common_concern/module_setup.rb