bitary 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf08e150b62f660fa24f19420e8f9ec2b4c44a0ff88bc8466a1bc13339de1ee0
-  data.tar.gz: 5837fb427a2332f8518b8ed247edd4ea750dd63a651a3e546c8efcf783dd9daa
+  metadata.gz: bed2641b2bb380989c96dcc95710be56b64711c28723f3ca5f3f82fd7119bc7e
+  data.tar.gz: 8b7aaf05d552014d77d42707453c5c4c6d84aefb2bd5d382376cdb152ce52068
 SHA512:
-  metadata.gz: 564e33ae146b3590d8f41540cde48d3a15dc7536b1dd3592fc0601fc2a85010710a370a1082c0a1134a249f6102526d6b2a859950c179b1b5c59d27ad4111e50
-  data.tar.gz: 6eeeb1fd6d855b0c87cb8330ea383f3b4136701d028d2996130215a8f5f4edea632a3ca6047bac3fba0a0079d9b83818a3cc0e7fb083ab883a6257a46d3e2e83
+  metadata.gz: fb6ad75f7e41ef52bdd71a78ac341381671264eb86e9b90cea66d36cbdbf751ff28e0a072a1479a9474bb68e111c983bcf093936ce08b1fac60b584ec2b7e5d0
+  data.tar.gz: bb66c485748c97732da3def70727dbc822704d21e1f2aad31cf810179db6e4154e3aa0c079a3a96a203c6e7e332865e8302428fada04b30f0671f314cbd8d772

data/.rubocop.yml

@@ -1,5 +1,7 @@
 AllCops:
   NewCops: enable
+  Exclude:
+    - 'bin/**/*'
 
 Style/Documentation:
   Enabled: false

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.1.5] - 2024-03-31
+
+- enhance performance of #each_byte (4 seconds faster on average)
+
+## [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

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::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::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::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

@@ -2,7 +2,7 @@
 
 class Bitary
   class Bitwarr
-    attr_reader :bpi
+    attr_reader :bpi, :bitsize
 
     def initialize(initial_data, bpi: Bitary::LONG)
       check_initial_data(initial_data)
@@ -21,21 +21,6 @@ class Bitary
       @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
@@ -46,12 +31,6 @@ class Bitary
       @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)
 
@@ -70,8 +49,13 @@ class Bitary
       operate_bit_at!(:unset, index)
     end
 
-    def each_byte(&)
-      decrease_items_size(@array, Bitary::BYTE, @bpi).each(&)
+    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
@@ -122,7 +106,7 @@ class Bitary
       Factory
         .make("Handler::#{operation.capitalize}", self[index])
         .execute(
-          index: relative_bit_index(index),
+          index: index % @bpi,
           size: @bpi
         )
     end

data/lib/bitary/decorator/single_method.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'single_method/non_nil_enforcer'
-require_relative 'single_method/truthy_enforcer'
 
 class Bitary
   class Decorator

data/lib/bitary/decorator.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'decorator/kwargs_validator'
 require_relative 'decorator/single_method'
 
 class Bitary

data/lib/bitary/handler/append.rb

@@ -3,17 +3,6 @@
 class Bitary
   class Handler
     class Append < Bitary::Handler
-      SPEC = {
-        offset: {
-          required: true,
-          type: Integer
-        },
-        value: {
-          required: true,
-          type: Integer
-        }
-      }.freeze
-
       def execute(**kwargs)
         (@value << kwargs[:offset]) | kwargs[:value]
       end

data/lib/bitary/handler/get.rb

@@ -3,23 +3,6 @@
 class Bitary
   class Handler
     class Get < Bitary::Handler
-      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
-
       def execute(**kwargs)
         (@value >> (kwargs[:size] - kwargs[:index] - 1)) & 0x1
       end

data/lib/bitary/handler/set.rb

@@ -3,23 +3,6 @@
 class Bitary
   class Handler
     class Set < Bitary::Handler
-      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
-
       def execute(**kwargs)
         @value | (2**(kwargs[:size] - kwargs[:index] - 1))
       end

data/lib/bitary/handler/unset.rb

@@ -3,28 +3,10 @@
 class Bitary
   class Handler
     class Unset < Bitary::Handler
-      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
-
       def execute(**kwargs)
-        mask =
-          (2**kwargs[:size]) - 1 - (2**(kwargs[:size] - kwargs[:index] - 1))
-
-        @value & mask
+        size = kwargs[:size]
+        index = kwargs[:index]
+        @value & ((2**size) - 1 - (2**(size - index - 1)))
       end
     end
   end

data/lib/bitary/handler.rb

@@ -7,20 +7,9 @@ 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)
-
       @value = value
     end
 

data/lib/bitary/version.rb

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

data/lib/bitary.rb

@@ -12,7 +12,7 @@ class Bitary
   include Size
 
   def initialize(initial_data, bpi: LONG)
-    @internal_array = Bitwarr.new(initial_data, bpi:)
+    @internal_array = Factory.make('Bitwarr', initial_data, bpi:)
   end
 
   def [](index)
@@ -20,7 +20,7 @@ class Bitary
   end
 
   def []=(index, value)
-    case Mapper::ObjToBit.new.map(value)
+    case Factory.make('Mapper::ObjToBit').map(value)
     when 0 then @internal_array.unbit_at!(index)
     else @internal_array.bit_at!(index)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitary
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Maximilien Ballesteros
@@ -26,10 +26,8 @@ files:
 - 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

data/lib/bitary/decorator/kwargs_validator.rb

@@ -1,174 +0,0 @@
-# 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/truthy_enforcer.rb

@@ -1,15 +0,0 @@
-# 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