bitary 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 537a58c702f90bfeade22439d4134d921df709d4d474279f29adae869ff08b0d
-  data.tar.gz: 90910632d7a7f40f89774a8d0ba2b1a6bbf04f5b281454ab18313359151f58b0
+  metadata.gz: e00e1deaf6796f8875294cb61799bc4ee1ae956c681489cee8243c9cad532224
+  data.tar.gz: 74088437d85300f562cb47011f17f9242329a0522a95878dfadce0a54803fffe
 SHA512:
-  metadata.gz: 3c65d9bcd2b757bf0a3e2d8b25b51b6a50b239e589efba142eb3c1c7539d42ac88c311361aa934f6ecf5be06c18da53c4e3c138dda801f0c89330da7c030a745
-  data.tar.gz: 10169aa8520c4d2dc4ddc92e419b77b745688c14bc08214770f9da25ed35b66d66655db37ef32daa7967119514ad3cacb618d06be5bd3c69df45e2ed435e9fb1
+  metadata.gz: 71b02ce18e1ad4decb42b8680fbcbb44cf44b9a4edb3637300aa40e1ef90825279b9b4c76e3eef24cf08b8b084cf248129f49e55dd98a191ac2223f185c3e7fb
+  data.tar.gz: a55ae4d18bd812a9d3a3ff1d6eafa263a5eb362978ed8dd47cfed2c0638927c6491f286f70f767a2cc0eeafea85704583cbee085ad450c8d533d5c086f9d8e1f

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [0.1.8] - 2024-04-01
+
+- inline bit operations to regain original perf
+
+## [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

data/lib/bitary/bitwarr.rb

@@ -7,21 +7,24 @@ class Bitary
     def initialize(initial_data, bpi: Bitary::LONG)
       @bitsize = init_bitsize(initial_data, bpi)
       @array = init_array(initial_data, @bitsize, bpi)
-      @bpi = init_bpi(initial_data, bpi)
-
-      self.bpi = bpi
+      @bpi = bpi
     end
 
     def [](bit_index) = @array[item_index(bit_index)]
-    def bit_at(index) = operate_bit_at(:get, index)
-    def bit_at!(index) = operate_bit_at!(:set, index)
-    def unbit_at!(index) = operate_bit_at!(:unset, index)
-    def to_s = @array.map { |item| to_binstr(item) }.join(' ')
 
     def []=(bit_index, value)
       @array[item_index(bit_index)] = value
     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)
+      self[index] &= ((2**@bpi) - 1 - (2**(@bpi - (index % @bpi) - 1)))
+    end
+
+    def to_s = @array.map { |item| to_binstr(item) }.join(' ')
+
     def each_byte(&proc)
       @array.each do |item|
         explode_item(item, Bitary::BYTE, @bpi, &proc)
@@ -45,17 +48,17 @@ class Bitary
 
     private
 
-    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, bitsize, bpi)
       if initial_data.is_a?(Array)
-        initial_data.clone
+        if bpi == Bitary::BYTE
+          initial_data.clone
+        else
+          increase_items_size(initial_data, bpi, Bitary::BYTE)
+        end
       else
         [0] * (bitsize / bpi.to_f).ceil
       end
@@ -69,28 +72,20 @@ class Bitary
       format("%0#{@bpi}d", item.to_s(2))
     end
 
-    def operate_bit_at(operation, index)
-      Factory
-        .make("Handler::#{operation.capitalize}", self[index])
-        .execute(
-          index: index % @bpi,
-          size: @bpi
-        )
-    end
-
-    def operate_bit_at!(operation, index)
-      self[index] = operate_bit_at(operation, index)
+    def update_items_size!(new_size)
+      @array = update_items_size(@array, new_size, @bpi)
     end
 
-    def update_items_size!(value)
-      value > @bpi ? increase_items_size!(value) : decrease_items_size!(value)
+    def update_items_size(array, new_size, bpi)
+      if new_size > bpi
+        increase_items_size(array, new_size, bpi)
+      else
+        decrease_items_size(array, new_size, bpi)
+      end
     end
 
     def append_bits(item, bpi, addend)
-      Factory.make('Handler::Append', item).execute(
-        offset: bpi,
-        value: addend
-      )
+      (item << bpi) | addend
     end
 
     def increase_items_size(array, new_size, bpi)
@@ -113,10 +108,6 @@ class Bitary
       res
     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|
         explode_item(item, new_size, bpi) do |new_item|
@@ -125,10 +116,6 @@ class Bitary
       end
     end
 
-    def decrease_items_size!(value)
-      @array = decrease_items_size(@array, value, @bpi)
-    end
-
     def explode_item(item, new_size, bpi)
       mask = (2**new_size) - 1
       (bpi / new_size).times do |i|

data/lib/bitary/version.rb

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

data/lib/bitary.rb

@@ -2,11 +2,7 @@
 
 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
@@ -15,7 +11,7 @@ class Bitary
     check_initial_data(initial_data)
     check_bpi(bpi)
 
-    @bitwarr = Factory.make('Bitwarr', initial_data, bpi:)
+    @bitwarr = Bitwarr.new(initial_data, bpi:)
   end
 
   def [](index)
@@ -27,7 +23,7 @@ class Bitary
   def []=(index, value)
     check_bit_index(index)
 
-    case Factory.make('Mapper::ObjToBit').map(value)
+    case obj_to_bit(value)
     when 0 then @bitwarr.unbit_at!(index)
     else @bitwarr.bit_at!(index)
     end
@@ -82,5 +78,20 @@ class Bitary
     raise IndexError if bit_index.negative? || bit_index >= @bitwarr.bitsize
   end
 
+  def obj_to_bit(value)
+    case !!value
+    when true then truthy_to_bit(value)
+    when false then 0
+    end
+  end
+
+  def truthy_to_bit(value)
+    value.is_a?(Integer) ? int_to_bit(value) : 1
+  end
+
+  def int_to_bit(value)
+    value.zero? ? 0 : 1
+  end
+
   alias at []
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitary
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.9
 platform: ruby
 authors:
 - Maximilien Ballesteros
@@ -25,18 +25,6 @@ files:
 - Rakefile
 - lib/bitary.rb
 - lib/bitary/bitwarr.rb
-- lib/bitary/decorator.rb
-- 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
 - lib/bitary/size.rb
 - lib/bitary/version.rb
 - sig/bitary.rbs

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

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'single_method/non_nil_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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-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,25 +0,0 @@
-# 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

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

data/lib/bitary/mapper/int_to_bit.rb

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

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

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