bitary 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 80cd57b662219349dc57edd47612599f95f5aeca086dbec30af067adb10fe587
-  data.tar.gz: dc630c61a13c74a20e3472a90f244dd995f4c7196fb6146ca15973efe02e310d
+  metadata.gz: bf08e150b62f660fa24f19420e8f9ec2b4c44a0ff88bc8466a1bc13339de1ee0
+  data.tar.gz: 5837fb427a2332f8518b8ed247edd4ea750dd63a651a3e546c8efcf783dd9daa
 SHA512:
-  metadata.gz: 9adf435f35e798c71a3a81213f408da0c178b2d3137ecae3619c84e3c95d564e060a4985d24a4746b93a0fb8e2d73fc4a209a38908c7dad25d87dfd728e575da
-  data.tar.gz: a6f136e8e5f140ad9455c14b13d94232d40bfc37e09e62b6827857888d03dacbc53fb027a9da1901dfa2d2f966144680a3e2d0a5dd57c4af563d4bd09af99326
+  metadata.gz: 564e33ae146b3590d8f41540cde48d3a15dc7536b1dd3592fc0601fc2a85010710a370a1082c0a1134a249f6102526d6b2a859950c179b1b5c59d27ad4111e50
+  data.tar.gz: 6eeeb1fd6d855b0c87cb8330ea383f3b4136701d028d2996130215a8f5f4edea632a3ca6047bac3fba0a0079d9b83818a3cc0e7fb083ab883a6257a46d3e2e83

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [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
+- addition of integer size enum
+
 ## [0.1.1] - 2024-03-26
 
 - Change root namespace to a class, instead of a module

data/README.md

@@ -2,7 +2,7 @@
 
 Ruby-based implementation of the bit array data structure.
 
-It's still under development, but as of now, it implements simple and well-optimized logic allowing you to set, unset and retrieve bits.
+It's still under development, but as of now, it implements simple and well-optimized logic allowing you to set, unset and retrieve bits (as well as some extra features, see below).
 
 ## Installation
 
@@ -24,10 +24,12 @@ Documentation still needs to be written, but here is a breakdown
 of the main capabilities brought by the current bit array implementation:
 
 ```ruby
+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: 8
+  bits_per_item: Bitary::BYTE # 8 bits
 ) # create based on some integer array
 
 bit_array_sz.bits_per_item # 64
@@ -55,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 = 64
+bit_array_ar.bits_per_item = 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.to_a # [1_099_511_627_776, 0]
-bit_array_sz.bits_per_item = 32
+bit_array_sz.bits_per_item = Bitary::INT # 32 bits
 bit_array_sz.to_a # [256, 0, 0, 0]
 ```
 

data/lib/bitary/bitwarr.rb

@@ -0,0 +1,187 @@
+# 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(&)
+      decrease_items_size(@array, Bitary::BYTE, @bpi).each(&)
+    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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Factory
+    private_class_method :new
+    @memo = {}
+
+    def self.make(name, *, **)
+      raise ArgumentError unless name.is_a?(String)
+
+      name.split('::').reduce(Bitary) do |cls, str|
+        cls.const_get(str)
+      end.new(*, **)
+    end
+
+    def self.make_memo(name, *args, **kwargs)
+      raise ArgumentError unless name.is_a?(String)
+      if @memo.key?(name.to_sym) && !args.empty? && !kwargs.empty?
+        raise ArgumentError
+      end
+
+      @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

@@ -1,11 +1,23 @@
 # frozen_string_literal: true
 
 require_relative 'handler/set'
+require_relative 'handler/unset'
+require_relative 'handler/get'
+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.2'
+  VERSION = '0.1.4'
 end

data/lib/bitary.rb

@@ -2,53 +2,28 @@
 
 require_relative 'bitary/size'
 require_relative 'bitary/version'
+require_relative 'bitary/handler'
+require_relative 'bitary/factory'
+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]
-
-    Handler::Get.new(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
-        Handler::Set.new(item).execute(
-          index: index % @bits_per_item,
-          size: item_bit_size
-        )
-      else
-        Handler::Unset.new(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)
@@ -59,105 +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] = Handler::Append.new(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.2
+  version: 0.1.4
 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,11 +24,21 @@ files:
 - README.md
 - Rakefile
 - lib/bitary.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