bitary 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bed2641b2bb380989c96dcc95710be56b64711c28723f3ca5f3f82fd7119bc7e
-  data.tar.gz: 8b7aaf05d552014d77d42707453c5c4c6d84aefb2bd5d382376cdb152ce52068
+  metadata.gz: 293fa51d8a5a4b4cda3a7a283737d0695b84cfcb55414afde3b9c5bb6f9688aa
+  data.tar.gz: 6d6541faa0fed549f62a3a1b99a293ca4422511c34527a7278ea7459683f506a
 SHA512:
-  metadata.gz: fb6ad75f7e41ef52bdd71a78ac341381671264eb86e9b90cea66d36cbdbf751ff28e0a072a1479a9474bb68e111c983bcf093936ce08b1fac60b584ec2b7e5d0
-  data.tar.gz: bb66c485748c97732da3def70727dbc822704d21e1f2aad31cf810179db6e4154e3aa0c079a3a96a203c6e7e332865e8302428fada04b30f0671f314cbd8d772
+  metadata.gz: 0a81bd80568d6b5fcb20d951f0b193f98941adafd448a896f0a68ae8c97eabecca07a34a2db1d48f4e630a64d1be165ed4efe5f370bc1aabd36f78de4a5b0e7d
+  data.tar.gz: 94f16667978d9d9be2ccf141c6539834d7f3502397db12feee83424eb0586ace151be1ca7bee960b5bc40ba0ec6e9e12c0879c74f700d1cd86c35e21f85337bb

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.1.7] - 2024-04-01
+
+- loads of refactoring and perf improvements
+- Bitary now acts as the logical layer, whereas Bitwarr acts as the business layer
+
+## [0.1.6] - 2024-03-31
+
+- enhance global perf by remove useless and heavy error handling
+
 ## [0.1.5] - 2024-03-31
 
 - enhance performance of #each_byte (4 seconds faster on average)

data/lib/bitary/bitwarr.rb

@@ -5,101 +5,73 @@ class Bitary
     attr_reader :bpi, :bitsize
 
     def initialize(initial_data, bpi: Bitary::LONG)
-      check_initial_data(initial_data)
-      check_bpi(bpi)
+      @bitsize = init_bitsize(initial_data, bpi)
+      @array = init_array(initial_data, @bitsize, bpi)
+      @bpi = init_bpi(initial_data, bpi)
 
-      @bpi = bpi
-      @bitsize = init_bitsize(initial_data)
-      @array = init_array(initial_data)
+      self.bpi = bpi
     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 [](bit_index)
-      @array[item_index(bit_index)]
-    end
+    def [](bit_index) = @array[item_index(bit_index)]
 
     def []=(bit_index, value)
-      raise ArgumentError unless value.is_a?(Integer)
-
       @array[item_index(bit_index)] = value
     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 bit_at(index) = (self[index] >> (@bpi - (index % @bpi) - 1)) & 0x1
+    def bit_at!(index) = self[index] |= 2**(@bpi - (index % @bpi) - 1)
 
     def unbit_at!(index)
-      operate_bit_at!(:unset, index)
+      self[index] &= ((2**@bpi) - 1 - (2**(@bpi - (index % @bpi) - 1)))
     end
 
-    def each_byte
+    def to_s = @array.map { |item| to_binstr(item) }.join(' ')
+
+    def each_byte(&proc)
       @array.each do |item|
-        (@bpi / Bitary::BYTE).times do |i|
-          byte = (item >> (@bpi - (Bitary::BYTE * (i + 1))))
-          yield byte
-        end
+        explode_item(item, Bitary::BYTE, @bpi, &proc)
       end
     end
 
-    def to_s
-      @array.map { |item| format("%0#{@bpi}d", item.to_s(2)) }.join(' ')
-    end
-
     def bpi=(value)
-      check_bpi(value)
+      return if value == @bpi
 
       update_items_size!(value)
-
       @bpi = value
     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
+
     private
 
-    def init_bitsize(initial_data)
-      initial_data.is_a?(Array) ? @bpi * initial_data.length : initial_data
+    def init_bpi(initial_data, bpi)
+      initial_data.is_a?(Array) ? Bitary::BYTE : bpi
+    end
+
+    def init_bitsize(initial_data, bpi)
+      initial_data.is_a?(Array) ? bpi * initial_data.length : initial_data
     end
 
-    def init_array(initial_data)
+    def init_array(initial_data, bitsize, bpi)
       if initial_data.is_a?(Array)
         initial_data.clone
       else
-        [0] * (@bitsize / @bpi.to_f).ceil
+        [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
+    def item_index(bit_index)
+      bit_index / @bpi
     end
 
-    def check_bpi(bpi)
-      raise ArgumentError unless [
-        Bitary::BYTE,
-        Bitary::SHORT,
-        Bitary::INT,
-        Bitary::LONG
-      ].include?(bpi)
+    def to_binstr(item)
+      format("%0#{@bpi}d", item.to_s(2))
     end
 
     def operate_bit_at(operation, index)
@@ -116,29 +88,31 @@ class Bitary
     end
 
     def update_items_size!(value)
-      if value > @bpi
-        increase_items_size!(value)
-      else
-        decrease_items_size!(value)
-      end
+      value > @bpi ? increase_items_size!(value) : decrease_items_size!(value)
+    end
+
+    def append_bits(item, bpi, addend)
+      (item << bpi) | addend
     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
+      res = array.each_with_object([0]) do |item, acc|
+        if processed_bits == new_size
           acc << 0
           processed_bits = 0
         end
 
-        acc[-1] = Factory.make('Handler::Append', acc[-1]).execute(
-          offset:,
-          value:
-        )
+        acc[-1] = append_bits(acc[-1], bpi, item)
+        processed_bits += bpi
+      end
+
+      while processed_bits < new_size
+        res[-1] = append_bits(res[-1], bpi, 0)
         processed_bits += bpi
       end
+
+      res
     end
 
     def increase_items_size!(value)
@@ -147,7 +121,9 @@ class Bitary
 
     def decrease_items_size(array, new_size, bpi)
       array.each_with_object([]) do |item, acc|
-        acc.concat(explode_item(item, new_size, bpi))
+        explode_item(item, new_size, bpi) do |new_item|
+          acc << new_item
+        end
       end
     end
 
@@ -156,16 +132,10 @@ class Bitary
     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)
+      (bpi / new_size).times do |i|
+        yield ((item >> (bpi - (new_size * (i + 1)))) & mask)
       end
-
-      res
     end
   end
 end

data/lib/bitary/version.rb

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

data/lib/bitary.rb

@@ -2,7 +2,6 @@
 
 require_relative 'bitary/size'
 require_relative 'bitary/version'
-require_relative 'bitary/handler'
 require_relative 'bitary/factory'
 require_relative 'bitary/bitwarr'
 require_relative 'bitary/decorator'
@@ -12,17 +11,24 @@ class Bitary
   include Size
 
   def initialize(initial_data, bpi: LONG)
-    @internal_array = Factory.make('Bitwarr', initial_data, bpi:)
+    check_initial_data(initial_data)
+    check_bpi(bpi)
+
+    @bitwarr = Factory.make('Bitwarr', initial_data, bpi:)
   end
 
   def [](index)
-    @internal_array.bit_at(index)
+    check_bit_index(index)
+
+    @bitwarr.bit_at(index)
   end
 
   def []=(index, value)
+    check_bit_index(index)
+
     case Factory.make('Mapper::ObjToBit').map(value)
-    when 0 then @internal_array.unbit_at!(index)
-    else @internal_array.bit_at!(index)
+    when 0 then @bitwarr.unbit_at!(index)
+    else @bitwarr.bit_at!(index)
     end
   end
 
@@ -35,27 +41,44 @@ class Bitary
   end
 
   def each_byte(&)
-    @internal_array.each_byte(&)
+    @bitwarr.each_byte(&)
   end
 
   def to_a
-    @internal_array.to_a
+    @bitwarr.to_a
   end
 
   def to_s
-    @internal_array.to_s
+    @bitwarr.to_s
   end
 
   def bpi=(value)
-    @internal_array.bpi = value
+    check_bpi(value)
+
+    @bitwarr.bpi = value
   end
 
   def size
-    @internal_array.bitsize
+    @bitwarr.bitsize
   end
 
   def bpi
-    @internal_array.bpi
+    @bitwarr.bpi
+  end
+
+  private
+
+  def check_initial_data(initial_data)
+    raise ArgumentError unless [Array, Integer].include?(initial_data.class)
+  end
+
+  def check_bpi(bpi)
+    raise ArgumentError unless [BYTE, SHORT, INT, LONG].include?(bpi)
+  end
+
+  def check_bit_index(bit_index)
+    raise ArgumentError unless bit_index.is_a?(Integer)
+    raise IndexError if bit_index.negative? || bit_index >= @bitwarr.bitsize
   end
 
   alias at []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitary
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - Maximilien Ballesteros
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-31 00:00:00.000000000 Z
+date: 2024-04-01 00:00:00.000000000 Z
 dependencies: []
 description: Ruby-based implementation of the bit array data structure
 email:
@@ -29,11 +29,6 @@ files:
 - lib/bitary/decorator/single_method.rb
 - lib/bitary/decorator/single_method/non_nil_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

data/lib/bitary/handler/append.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-class Bitary
-  class Handler
-    class Append < Bitary::Handler
-      def execute(**kwargs)
-        (@value << kwargs[:offset]) | kwargs[:value]
-      end
-    end
-  end
-end

data/lib/bitary/handler/get.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-class Bitary
-  class Handler
-    class Get < Bitary::Handler
-      def execute(**kwargs)
-        (@value >> (kwargs[:size] - kwargs[:index] - 1)) & 0x1
-      end
-    end
-  end
-end

data/lib/bitary/handler/set.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-class Bitary
-  class Handler
-    class Set < Bitary::Handler
-      def execute(**kwargs)
-        @value | (2**(kwargs[:size] - kwargs[:index] - 1))
-      end
-    end
-  end
-end

data/lib/bitary/handler/unset.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-class Bitary
-  class Handler
-    class Unset < Bitary::Handler
-      def execute(**kwargs)
-        size = kwargs[:size]
-        index = kwargs[:index]
-        @value & ((2**size) - 1 - (2**(size - index - 1)))
-      end
-    end
-  end
-end

data/lib/bitary/handler.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'handler/set'
-require_relative 'handler/unset'
-require_relative 'handler/get'
-require_relative 'handler/append'
-
-class Bitary
-  class Handler
-    attr_reader :value
-
-    def initialize(value)
-      @value = value
-    end
-
-    def execute(**kwargs)
-      raise NotImplementedError
-    end
-  end
-end