bitary 0.1.3 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc3397b948d902fe5cba56205955a01b7ad9f0d5d6eb7a1bf74984005f693114
-  data.tar.gz: af6673d27575273094dc34a4c67c67fbaa603de8a4e04375b0719e247f8cbcd9
+  metadata.gz: 0a3a73becac006670efcdd4a87b36aee0c3c9bc48c50f5cf48d68e47e1e7cad3
+  data.tar.gz: e398cc62cdbfc33cf1f48146b59fe655f832b33d59caf8556a7898df1ef4e20d
 SHA512:
-  metadata.gz: e44836498539b643e9b75ead2d63c9b91beda96008bc11d5e10a3b354d67ad4f604b1ceee4740665c60a7eeca7ca898e3f05b22aa48d2845f10fa71914a22998
-  data.tar.gz: 2cc01a7ba3ab7463ab64283fb6e4f82ab8dab61865595f93bbea1efdbf966463008faf2d9dab42f8e304e1f9e6bfa57d597b7d1826ef8521e7f480d2749403f1
+  metadata.gz: 5f6d8328faf7a368daf44fc5dafedcfc4456369d2ae48b7a2e3736ad48bea686d76444b3fdd8c7c8d6b34774906e7544cf61cd78905350cfb60c94205916d832
+  data.tar.gz: 86f6f32038489a43a9dc18613c536110af4e7aed65e228f2d763f6c472037aba0518ba382566bbe6edeec3ff76491584971c6a0bad64f4efe5dc1d68e443bca4

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.1.4] - 2024-03-31
+
+- more refactoring of Bitary class
+- fix issue in getting/setting bits when size is not % 8 
+
+## [0.1.3] - 2024-03-29
+
+- fix some missing require statements
+- further refactoring of Bitary class
+
 ## [0.1.2] - 2024-03-29
 
 - internal refactoring of the Bitary class

data/README.md

@@ -29,11 +29,11 @@ require 'bitary'
 bit_array_sz = Bitary.new(128) # give an explicit size. Defaults to 64 bits used per item
 bit_array_ar = Bitary.new(
   [255, 10, 20],
-  bits_per_item: Bitary::Size::BYTE # 8 bits
+  bpi: Bitary::BYTE # 8 bits
 ) # create based on some integer array
 
-bit_array_sz.bits_per_item # 64
-bit_array_ar.bits_per_item # 8
+bit_array_sz.bpi # 64
+bit_array_ar.bpi # 8
 
 bit_array_ar.size # 128
 bit_array_ar.size # 24
@@ -57,13 +57,13 @@ bit_array_ar.to_a # [127, 10, 20]
 bit_array_ar.to_s # "01111111 00001010 00010100"
 
 # increase/decrease bits used per item
-bit_array_ar.bits_per_item = Bitary::Size::LONG # 64 bits
+bit_array_ar.bpi = Bitary::LONG # 64 bits
 bit_array_ar.to_a # [8_325_652]
 bit_array_ar.to_s # "0000000000000000000000000000000000000000011111110000101000010100"
 
-bit_array_sz.bits_per_item # 64
+bit_array_sz.bpi # 64
 bit_array_sz.to_a # [1_099_511_627_776, 0]
-bit_array_sz.bits_per_item = Bitary::Size::INT # 32 bits
+bit_array_sz.bpi = Bitary::INT # 32 bits
 bit_array_sz.to_a # [256, 0, 0, 0]
 ```
 

data/lib/bitary/bitwarr.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Bitwarr
+    attr_reader :bpi
+
+    def initialize(initial_data, bpi: Bitary::LONG)
+      check_initial_data(initial_data)
+      check_bpi(bpi)
+
+      @bpi = bpi
+      @bitsize = init_bitsize(initial_data)
+      @array = init_array(initial_data)
+    end
+
+    def method_missing(method, *, &)
+      @array.respond_to?(method) ? @array.send(method, *, &) : super
+    end
+
+    def respond_to_missing?(method, include_all = false)
+      @array.respond_to?(method, include_all) || super
+    end
+
+    def bitsize(bit_index = nil)
+      if bit_index.nil?
+        @bitsize
+      else
+        check_bit_index(bit_index)
+
+        last_index = @array.length - 1
+        if item_index(bit_index) == last_index
+          @bitsize - (last_index * @bpi)
+        else
+          @bpi
+        end
+      end
+    end
+
+    def [](bit_index)
+      @array[item_index(bit_index)]
+    end
+
+    def []=(bit_index, value)
+      raise ArgumentError unless value.is_a?(Integer)
+
+      @array[item_index(bit_index)] = value
+    end
+
+    def relative_bit_index(bit_index)
+      check_bit_index(bit_index)
+
+      bit_index % @bpi
+    end
+
+    def item_index(bit_index)
+      check_bit_index(bit_index)
+
+      bit_index / @bpi
+    end
+
+    def bit_at(index)
+      operate_bit_at(:get, index)
+    end
+
+    def bit_at!(index)
+      operate_bit_at!(:set, index)
+    end
+
+    def unbit_at!(index)
+      operate_bit_at!(:unset, index)
+    end
+
+    def each_byte
+      @array.each do |item|
+        (@bpi / Bitary::BYTE).times do |i|
+          byte = (item >> (@bpi - (Bitary::BYTE * (i + 1))))
+          yield byte
+        end
+      end
+    end
+
+    def to_s
+      @array.map { |item| format("%0#{@bpi}d", item.to_s(2)) }.join(' ')
+    end
+
+    def bpi=(value)
+      check_bpi(value)
+
+      update_items_size!(value)
+
+      @bpi = value
+    end
+
+    private
+
+    def init_bitsize(initial_data)
+      initial_data.is_a?(Array) ? @bpi * initial_data.length : initial_data
+    end
+
+    def init_array(initial_data)
+      if initial_data.is_a?(Array)
+        initial_data.clone
+      else
+        [0] * (@bitsize / @bpi.to_f).ceil
+      end
+    end
+
+    def check_initial_data(initial_data)
+      raise ArgumentError unless [Array, Integer].include?(initial_data.class)
+    end
+
+    def check_bit_index(bit_index)
+      raise ArgumentError unless bit_index.is_a?(Integer)
+      raise IndexError if bit_index.negative? || bit_index >= @bitsize
+    end
+
+    def check_bpi(bpi)
+      raise ArgumentError unless [
+        Bitary::BYTE,
+        Bitary::SHORT,
+        Bitary::INT,
+        Bitary::LONG
+      ].include?(bpi)
+    end
+
+    def operate_bit_at(operation, index)
+      Factory
+        .make("Handler::#{operation.capitalize}", self[index])
+        .execute(
+          index: relative_bit_index(index),
+          size: @bpi
+        )
+    end
+
+    def operate_bit_at!(operation, index)
+      self[index] = operate_bit_at(operation, index)
+    end
+
+    def update_items_size!(value)
+      if value > @bpi
+        increase_items_size!(value)
+      else
+        decrease_items_size!(value)
+      end
+    end
+
+    def increase_items_size(array, new_size, bpi)
+      processed_bits = 0
+      array.each_with_object([0]) do |value, acc|
+        offset = bpi
+        if processed_bits >= new_size
+          offset = 0
+          acc << 0
+          processed_bits = 0
+        end
+
+        acc[-1] = Factory.make('Handler::Append', acc[-1]).execute(
+          offset:,
+          value:
+        )
+        processed_bits += bpi
+      end
+    end
+
+    def increase_items_size!(value)
+      @array = increase_items_size(@array, value, @bpi)
+    end
+
+    def decrease_items_size(array, new_size, bpi)
+      array.each_with_object([]) do |item, acc|
+        acc.concat(explode_item(item, new_size, bpi))
+      end
+    end
+
+    def decrease_items_size!(value)
+      @array = decrease_items_size(@array, value, @bpi)
+    end
+
+    def explode_item(item, new_size, bpi)
+      res = []
+      offset = bpi
+      mask = (2**new_size) - 1
+
+      while offset.positive?
+        offset -= new_size
+        res << ((item >> offset) & mask)
+      end
+
+      res
+    end
+  end
+end

data/lib/bitary/decorator/kwargs_validator.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Decorator
+    class KwargsValidator < Bitary::Decorator
+      SPEC_KEYS = %i[required default type predicate].freeze
+
+      def initialize(wrappee, spec)
+        super(wrappee) { |method| spec.key?(method) }
+        @spec = check_spec(@wrappee, spec)
+      end
+
+      protected
+
+      def precall(method, *, **)
+        super(method, *, **check_kwargs(@spec, method, **))
+      end
+
+      private
+
+      def check_spec(wrappee, spec)
+        raise ArgumentError unless spec.is_a?(Hash)
+
+        spec.each do |method, method_spec|
+          check_spec_method(wrappee, method)
+          check_spec_method_value(method_spec)
+        end
+      end
+
+      def check_kwargs(spec, method, **kwargs)
+        check_unexpected_user_kwargs(kwargs, spec[method])
+        check_kwargs_against_spec(kwargs, spec[method])
+      end
+
+      def check_spec_method(wrappee, method)
+        raise ArgumentError unless wrappee.respond_to?(method)
+      end
+
+      def check_spec_method_value(method_spec)
+        raise ArgumentError unless method_spec.is_a?(Hash)
+
+        method_spec.each_value do |arg_spec|
+          raise ArgumentError unless arg_spec.is_a?(Hash)
+
+          check_arg_spec(arg_spec)
+        end
+      end
+
+      def check_arg_spec(arg_spec)
+        raise ArgumentError unless arg_spec.keys.all? do |spec_key|
+          SPEC_KEYS.include?(spec_key)
+        end
+
+        arg_spec.each do |spec_key, spec_value|
+          check_arg_spec_entry(spec_key, spec_value)
+        end
+
+        return unless arg_spec.key?(:required) && arg_spec[:required]
+        raise ArgumentError if arg_spec.key?(:default)
+      end
+
+      def check_arg_spec_entry(key, value)
+        case key
+        when :required then check_required(value)
+        when :default then check_default(value)
+        when :type then check_type(value)
+        when :predicate then check_predicate(value)
+        end
+      end
+
+      def check_required(value)
+        raise ArgumentError unless [true, false].include?(value)
+      end
+
+      def check_default(value)
+        # NOTHING TODO
+      end
+
+      def check_type(value)
+        raise ArgumentError unless value.is_a?(Class)
+      end
+
+      def check_predicate(value)
+        raise ArgumentError unless value.is_a?(Hash)
+
+        check_predicate_keys(value)
+        check_predicate_values(value)
+      end
+
+      def check_predicate_keys(value)
+        available_keys = %i[callback error]
+
+        raise ArgumentError unless value.keys.all? do |key|
+          available_keys.include?(key)
+        end
+
+        raise KeyError unless value.key?(:callback) && value.key?(:error)
+      end
+
+      def check_predicate_values(value)
+        raise ArgumentError unless value[:callback].is_a?(Proc)
+        raise ArgumentError unless value[:error].is_a?(Class)
+        raise ArgumentError unless value[:error] < Exception
+      end
+
+      def check_unexpected_user_kwargs(user_kwargs, method_spec)
+        raise ArgumentError unless user_kwargs.keys.all? do |key|
+          method_spec.include?(key)
+        end
+      end
+
+      def check_kwargs_against_spec(user_kwargs, method_spec)
+        predicates = []
+
+        parsed_kwargs = method_spec.reduce({}) do |acc, entry|
+          kwarg_name, kwarg_spec = entry
+          loaded_spec = load_spec(kwarg_spec)
+
+          validate_required(user_kwargs, loaded_spec, kwarg_name)
+          validate_type(user_kwargs, loaded_spec, kwarg_name)
+          predicates << loaded_spec[:predicate]
+
+          acc.merge(
+            kwarg_name => compute_value(user_kwargs, loaded_spec, kwarg_name)
+          )
+        end
+
+        predicates.each do |predicate|
+          validate_predicate(parsed_kwargs, predicate)
+        end
+
+        parsed_kwargs
+      end
+
+      def load_spec(kwarg_spec)
+        {
+          required: kwarg_spec[:required] || false,
+          default: kwarg_spec[:default],
+          type: kwarg_spec[:type] || Object,
+          predicate: kwarg_spec[:predicate] || {
+            callback: ->(_value) { true },
+            error: ArgumentError
+          }
+        }
+      end
+
+      def validate_required(user_kwargs, spec, expected_key)
+        return unless spec[:required]
+
+        raise KeyError unless user_kwargs.key?(expected_key)
+      end
+
+      def validate_type(user_kwargs, spec, expected_key)
+        return unless user_kwargs.key?(expected_key)
+
+        raise ArgumentError unless user_kwargs[expected_key].is_a?(spec[:type])
+      end
+
+      def validate_predicate(parsed_kwargs, predicate)
+        return if predicate[:callback].call(**parsed_kwargs)
+
+        raise predicate[:error]
+      end
+
+      def compute_value(user_kwargs, spec, expected_key)
+        if user_kwargs.key?(expected_key)
+          user_kwargs[expected_key]
+        else
+          spec[:default]
+        end
+      end
+    end
+  end
+end

data/lib/bitary/decorator/single_method/non_nil_enforcer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Decorator
+    class SingleMethod < Bitary::Decorator
+      class NonNilEnforcer < Bitary::Decorator::SingleMethod
+        protected
+
+        def postcall(resp)
+          (resp.nil? and raise TypeError) || resp
+        end
+      end
+    end
+  end
+end

data/lib/bitary/decorator/single_method/truthy_enforcer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Decorator
+    class SingleMethod < Bitary::Decorator
+      class TruthyEnforcer < Bitary::Decorator::SingleMethod
+        protected
+
+        def postcall(resp)
+          resp or raise TypeError
+        end
+      end
+    end
+  end
+end

data/lib/bitary/decorator/single_method.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'single_method/non_nil_enforcer'
+require_relative 'single_method/truthy_enforcer'
+
+class Bitary
+  class Decorator
+    class SingleMethod < Bitary::Decorator
+      def initialize(wrappee, method)
+        super(wrappee) { |meth| meth == method }
+        check_method(wrappee, method)
+      end
+
+      private
+
+      def check_method(wrappee, method)
+        raise ArgumentError unless method.is_a?(Symbol)
+        raise NoMethodError unless wrappee.respond_to?(method)
+      end
+    end
+  end
+end

data/lib/bitary/decorator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'decorator/kwargs_validator'
+require_relative 'decorator/single_method'
+
+class Bitary
+  class Decorator
+    def initialize(wrappee, &proc)
+      @wrappee = wrappee
+      @predicate = proc || ->(_method) { true }
+    end
+
+    def method_missing(method, *, **, &)
+      if @wrappee.respond_to?(method)
+        if @predicate.call(method)
+          args, kwargs = precall(method, *, **)
+          resp = @wrappee.send(method, *args, **kwargs, &)
+          postcall(resp)
+        else
+          @wrappee.send(method, *, **, &)
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_all = false)
+      @wrappee.respond_to?(method, include_all) || super
+    end
+
+    def wrappee
+      res = @wrappee
+      res = res.wrappee while res.respond_to?(:wrappee)
+      res
+    end
+
+    protected
+
+    def precall(_method, *args, **kwargs)
+      [args, kwargs]
+    end
+
+    def postcall(resp)
+      resp
+    end
+  end
+end

data/lib/bitary/factory.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'deptainer'
-
 class Bitary
   class Factory
     private_class_method :new
-    @container = Deptainer.new
+    @memo = {}
 
     def self.make(name, *, **)
       raise ArgumentError unless name.is_a?(String)
@@ -17,11 +15,11 @@ class Bitary
 
     def self.make_memo(name, *args, **kwargs)
       raise ArgumentError unless name.is_a?(String)
-      if @container.has?(name.to_sym) && !args.empty? && !kwargs.empty?
+      if @memo.key?(name.to_sym) && !args.empty? && !kwargs.empty?
         raise ArgumentError
       end
 
-      @container[name.to_sym] ||= make(name, *args, **kwargs)
+      @memo[name.to_sym] ||= make(name, *args, **kwargs)
     end
   end
 end

data/lib/bitary/handler/append.rb

@@ -3,17 +3,19 @@
 class Bitary
   class Handler
     class Append < Bitary::Handler
-      def execute(**kwargs)
-        raise ArgumentError unless kwargs.all? do |key, _value|
-          %i[offset value].include?(key)
-        end
-
-        offset = kwargs[:offset] or raise KeyError
-        value = kwargs[:value] or raise KeyError
-        raise ArgumentError unless offset.is_a?(Integer)
-        raise ArgumentError unless value.is_a?(Integer)
+      SPEC = {
+        offset: {
+          required: true,
+          type: Integer
+        },
+        value: {
+          required: true,
+          type: Integer
+        }
+      }.freeze
 
-        (@value << offset) | value
+      def execute(**kwargs)
+        (@value << kwargs[:offset]) | kwargs[:value]
       end
     end
   end

data/lib/bitary/handler/get.rb

@@ -3,19 +3,25 @@
 class Bitary
   class Handler
     class Get < Bitary::Handler
-      def execute(**kwargs)
-        raise ArgumentError unless kwargs.all? do |key, _value|
-          %i[index size].include?(key)
-        end
-
-        index = kwargs[:index] or raise KeyError
-        size = kwargs[:size] or raise KeyError
-        raise ArgumentError unless index.is_a?(Integer)
-        raise ArgumentError unless size.is_a?(Integer)
+      SPEC = {
+        index: {
+          required: true,
+          type: Integer,
+          predicate: {
+            callback: lambda do |**kwargs|
+              kwargs[:index] >= 0 && kwargs[:index] < kwargs[:size]
+            end,
+            error: IndexError
+          }
+        },
+        size: {
+          required: true,
+          type: Integer
+        }
+      }.freeze
 
-        raise IndexError if index.negative? || index >= size
-
-        (@value >> (size - index - 1)) & 0x1
+      def execute(**kwargs)
+        (@value >> (kwargs[:size] - kwargs[:index] - 1)) & 0x1
       end
     end
   end

data/lib/bitary/handler/set.rb

@@ -3,19 +3,25 @@
 class Bitary
   class Handler
     class Set < Bitary::Handler
-      def execute(**kwargs)
-        raise ArgumentError unless kwargs.all? do |key, _value|
-          %i[index size].include?(key)
-        end
-
-        index = kwargs[:index] or raise KeyError
-        size = kwargs[:size] or raise KeyError
-        raise ArgumentError unless index.is_a?(Integer)
-        raise ArgumentError unless size.is_a?(Integer)
+      SPEC = {
+        index: {
+          required: true,
+          type: Integer,
+          predicate: {
+            callback: lambda do |**kwargs|
+              kwargs[:index] >= 0 && kwargs[:index] < kwargs[:size]
+            end,
+            error: IndexError
+          }
+        },
+        size: {
+          required: true,
+          type: Integer
+        }
+      }.freeze
 
-        raise IndexError if index.negative? || index >= size
-
-        @value | (2**(size - index - 1))
+      def execute(**kwargs)
+        @value | (2**(kwargs[:size] - kwargs[:index] - 1))
       end
     end
   end

data/lib/bitary/handler/unset.rb

@@ -3,19 +3,28 @@
 class Bitary
   class Handler
     class Unset < Bitary::Handler
-      def execute(**kwargs)
-        raise ArgumentError unless kwargs.all? do |key, _value|
-          %i[index size].include?(key)
-        end
-
-        index = kwargs[:index] or raise KeyError
-        size = kwargs[:size] or raise KeyError
-        raise ArgumentError unless index.is_a?(Integer)
-        raise ArgumentError unless size.is_a?(Integer)
+      SPEC = {
+        index: {
+          required: true,
+          type: Integer,
+          predicate: {
+            callback: lambda do |**kwargs|
+              kwargs[:index] >= 0 && kwargs[:index] < kwargs[:size]
+            end,
+            error: IndexError
+          }
+        },
+        size: {
+          required: true,
+          type: Integer
+        }
+      }.freeze
 
-        raise IndexError if index.negative? || index >= size
+      def execute(**kwargs)
+        mask =
+          (2**kwargs[:size]) - 1 - (2**(kwargs[:size] - kwargs[:index] - 1))
 
-        @value & (((2**size) - 1) - (2**(size - index - 1)))
+        @value & mask
       end
     end
   end

data/lib/bitary/handler.rb

@@ -7,8 +7,17 @@ require_relative 'handler/append'
 
 class Bitary
   class Handler
+    SPEC = {}.freeze
+
     attr_reader :value
 
+    def self.new(*arg, **kwargs)
+      Decorator::SingleMethod::KwargsValidator.new(
+        super,
+        { execute: self::SPEC }
+      )
+    end
+
     def initialize(value)
       raise ArgumentError unless value.is_a?(Integer)
 

data/lib/bitary/mapper/int_to_bit.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Mapper
+    class IntToBit < Bitary::Mapper
+      def map(value)
+        if value.is_a?(Integer)
+          value.zero? ? 0 : 1
+        else
+          1
+        end
+      end
+    end
+  end
+end

data/lib/bitary/mapper/obj_to_bit.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Mapper
+    class ObjToBit < Bitary::Mapper
+      def map(value)
+        case !!value
+        when true then IntToBit.new.map(value)
+        when false then 0
+        end
+      end
+    end
+  end
+end

data/lib/bitary/mapper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'mapper/int_to_bit'
+require_relative 'mapper/obj_to_bit'
+
+class Bitary
+  class Mapper
+    def self.new(*arg, **kwargs)
+      Decorator::SingleMethod::NonNilEnforcer.new(super, :map)
+    end
+
+    def map(value)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/bitary/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Bitary
-  VERSION = '0.1.3'
+  VERSION = '0.1.5'
 end

data/lib/bitary.rb

@@ -4,54 +4,26 @@ require_relative 'bitary/size'
 require_relative 'bitary/version'
 require_relative 'bitary/handler'
 require_relative 'bitary/factory'
-require_relative 'bitary/deptainer'
+require_relative 'bitary/bitwarr'
+require_relative 'bitary/decorator'
+require_relative 'bitary/mapper'
 
 class Bitary
   include Size
 
-  attr_reader :size, :bits_per_item
-
-  def initialize(initial_data, bits_per_item: LONG)
-    raise ArgumentError unless [BYTE, SHORT, INT, LONG].include?(bits_per_item)
-
-    @size = init_size(initial_data, bits_per_item)
-    @internal_array = init_internal_array(initial_data, @size, bits_per_item)
-    @bits_per_item = bits_per_item
+  def initialize(initial_data, bpi: LONG)
+    @internal_array = Bitwarr.new(initial_data, bpi:)
   end
 
   def [](index)
-    raise IndexError if index.negative? || index >= @size
-
-    item_index = compute_item_index(index)
-    item_bit_size = compute_item_bit_size(item_index)
-    item = @internal_array[item_index]
-
-    Factory.make('Handler::Get', item).execute(
-      index: index % @bits_per_item,
-      size: item_bit_size
-    )
+    @internal_array.bit_at(index)
   end
 
   def []=(index, value)
-    raise IndexError if index.negative? || index >= @size
-
-    bit = map_to_bit(value)
-    item_index = compute_item_index(index)
-    item_bit_size = compute_item_bit_size(item_index)
-    item = @internal_array[item_index]
-
-    @internal_array[item_index] =
-      if bit == 1
-        Factory.make('Handler::Set', item).execute(
-          index: index % @bits_per_item,
-          size: item_bit_size
-        )
-      else
-        Factory.make('Handler::Unset', item).execute(
-          index: index % @bits_per_item,
-          size: item_bit_size
-        )
-      end
+    case Mapper::ObjToBit.new.map(value)
+    when 0 then @internal_array.unbit_at!(index)
+    else @internal_array.bit_at!(index)
+    end
   end
 
   def set(index)
@@ -62,108 +34,28 @@ class Bitary
     self[index] = 0
   end
 
-  def each_byte(&proc)
-    res = decrease_items_size(@internal_array, BYTE, @bits_per_item)
-    proc ? res.each { |byte| proc.call(byte) } : res.each
+  def each_byte(&)
+    @internal_array.each_byte(&)
   end
 
   def to_a
-    @internal_array.clone
+    @internal_array.to_a
   end
 
   def to_s
-    @internal_array.map do |item|
-      format("%0#{@bits_per_item}d", item.to_s(2))
-    end.join(' ')
-  end
-
-  def bits_per_item=(value)
-    raise ArgumentError unless [BYTE, SHORT, INT, LONG].include?(value)
-
-    @internal_array =
-      if value > @bits_per_item
-        increase_items_size(@internal_array, value, @bits_per_item)
-      else
-        decrease_items_size(@internal_array, value, @bits_per_item)
-      end
-
-    @bits_per_item = value
-  end
-
-  private
-
-  def init_size(initial_data, bits_per_item)
-    if initial_data.is_a?(Array)
-      bits_per_item * initial_data.length
-    else
-      initial_data
-    end
+    @internal_array.to_s
   end
 
-  def init_internal_array(initial_data, size, bits_per_item)
-    res = [0] * (size / bits_per_item.to_f).ceil
-    initial_data.is_a?(Array) ? initial_data.clone : res
+  def bpi=(value)
+    @internal_array.bpi = value
   end
 
-  def map_to_bit(value)
-    if value
-      if value.is_a?(Integer)
-        value.zero? ? 0 : 1
-      else
-        1
-      end
-    else
-      0
-    end
+  def size
+    @internal_array.bitsize
   end
 
-  def compute_item_bit_size(index)
-    if index == @internal_array.length - 1
-      size - ((@internal_array.length - 1) * @bits_per_item)
-    else
-      @bits_per_item
-    end
-  end
-
-  def compute_item_index(index)
-    index / @bits_per_item
-  end
-
-  def increase_items_size(array, new_size, bpi)
-    processed_bits = 0
-    array.each_with_object([0]) do |value, acc|
-      offset = bpi
-      if processed_bits >= new_size
-        offset = 0
-        acc << 0
-        processed_bits = 0
-      end
-
-      acc[-1] = Factory.make('Handler::Append', acc[-1]).execute(
-        offset:,
-        value:
-      )
-      processed_bits += bpi
-    end
-  end
-
-  def decrease_items_size(array, new_size, bpi)
-    array.each_with_object([]) do |item, acc|
-      acc.concat(explode_item(item, new_size, bpi))
-    end
-  end
-
-  def explode_item(item, new_size, bpi)
-    res = []
-    offset = bpi
-    mask = (2**new_size) - 1
-
-    while offset.positive?
-      offset -= new_size
-      res << ((item >> offset) & mask)
-    end
-
-    res
+  def bpi
+    @internal_array.bpi
   end
 
   alias at []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitary
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Maximilien Ballesteros
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-29 00:00:00.000000000 Z
+date: 2024-03-31 00:00:00.000000000 Z
 dependencies: []
 description: Ruby-based implementation of the bit array data structure
 email:
@@ -24,13 +24,21 @@ files:
 - README.md
 - Rakefile
 - lib/bitary.rb
-- lib/bitary/deptainer.rb
+- lib/bitary/bitwarr.rb
+- lib/bitary/decorator.rb
+- lib/bitary/decorator/kwargs_validator.rb
+- lib/bitary/decorator/single_method.rb
+- lib/bitary/decorator/single_method/non_nil_enforcer.rb
+- lib/bitary/decorator/single_method/truthy_enforcer.rb
 - lib/bitary/factory.rb
 - lib/bitary/handler.rb
 - lib/bitary/handler/append.rb
 - lib/bitary/handler/get.rb
 - lib/bitary/handler/set.rb
 - lib/bitary/handler/unset.rb
+- lib/bitary/mapper.rb
+- lib/bitary/mapper/int_to_bit.rb
+- lib/bitary/mapper/obj_to_bit.rb
 - lib/bitary/size.rb
 - lib/bitary/version.rb
 - sig/bitary.rbs

data/lib/bitary/deptainer.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class Bitary
-  class Deptainer
-    def initialize
-      @store = {}
-    end
-
-    def [](key)
-      raise ArgumentError unless key.is_a?(Symbol)
-
-      @store[key]
-    end
-
-    def []=(key, value)
-      raise ArgumentError unless key.is_a?(Symbol)
-
-      @store[key] = value
-    end
-
-    def has?(key)
-      raise ArgumentError unless key.is_a?(Symbol)
-
-      @store.key?(key)
-    end
-  end
-end