rrb-common 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8830b14ecfcf37cc6afb5779915d9beeaf84a137d38ca984d832d588ca7ecc1b
-  data.tar.gz: 8b4e8eced92a7c05e6161d9886c6f11e02614d82f9c0257b5ba9342834118867
+  metadata.gz: 25249c7b5e3aa642c23637cc4e3bad8ce62434a1d77962287fe7cab331d016c9
+  data.tar.gz: 7592bacd9ddfb0d7371bfd24f87a84de502e2500f7a81a5ca3f8bbd5f1d888a5
 SHA512:
-  metadata.gz: 6b350710235c41abad111df718f214c408a4ae69b223a7fbfb4f477ea1611720ce072429e8ebc19d6aa198e3d0f5a18c10f469ef5d5e4d988b98c25781ced03d
-  data.tar.gz: 9e83c03b05779b74f959689d8b5709dc83dbcb0ec2cc6f0ce43a90a6bfc90402cd54ff2334cd5b37e007d70f7eff3b6ac4612ee73706f20c2aad8ffa95d23079
+  metadata.gz: 58a9a9da24f64061478f46982beb434b6a3e917c494bf36e437b50570593b2b05bb9870ad50bee4fb08cb82bfec4eb90e8377cae5504e513584582ce1030b6bf
+  data.tar.gz: b4810f557135b53ba88e89850d59076f24650df965ec0b497868ec41d7a47e8d47c635c6b5797c5297d994446335a479e1dad3c0f22da04c810503a571af8460

data/lib/rune/common.rb

@@ -19,7 +19,8 @@ module RuneRb
     autoload :Buffer,             'rune/core/buffer'
     autoload :Constants,          'rune/core/constants'
     autoload :Identifiable,       'rune/core/identifiable'
-    autoload :ISAAC,              'rune/core/isaac'
+    autoload :JavaISAAC,          'rune/core/java_isaac'
+    autoload :RubyISAAC,          'rune/core/ruby_isaac'
     autoload :Logging,            'rune/core/logging'
     autoload :ReadableBuffer,     'rune/core/readable_buffer'
     autoload :Unit,               'rune/core/unit'

data/lib/rune/core/constants.rb

@@ -34,4 +34,11 @@ module RuneRb::Core::Constants
   # The size of a chunk of data
   # @return [Integer]
   DATA_SIZE = DATA_BLOCK_SIZE + DATA_HEADER_SIZE
+
+  # The possible byte orders for reading/writing 24-bit integers. The integers will only be written in big or middle endian byte order.
+  # @return [Hash<Symbol, Array<Integer>>]
+  INT24_BYTE_ORDERS = {
+    BIG: [0, 1, 2].freeze,
+    LITTLE: [2, 1, 0].freeze
+  }.freeze
 end

data/lib/rune/core/readable_buffer.rb

@@ -16,11 +16,10 @@ module RuneRb::Core::ReadableBuffer
   # @param mutation [Symbol] an option mutation to apply to the read value.
   def read(type: :byte, signed: false, mutation: :STD, order: :BIG, options: nil)
     case type
-    when :bits then read_bits(options[:amount])
     when :byte then read_byte(signed:, mutation:)
     when :bytes then read_bytes(options[:amount] || 1, mutation:)
     when :short then read_short(signed:, mutation:, order:)
-    when :int24 then read_int24(signed:, mutation:, order:)
+    when :int24 then read_int24(mutation:, order:)
     when :int then read_int(signed:, mutation:, order:)
     when :long then read_long(signed:, mutation:, order:)
     when :smart then read_smart(signed:, mutation:)
@@ -51,12 +50,13 @@ module RuneRb::Core::ReadableBuffer
   end
 
   # Probably did this wrong
+  # @todo fix and test
   # @param amount [Integer] the amount of bytes to read
   # @param mutation [Symbol] an optional mutation to apply to the result.
   def read_bytes_reverse(amount, mutation)
-    @data.flip
+    @data.reverse!
     value = amount.times.each_with_object([]) { value << read_byte(signed: false, mutation:) }
-    @data.flip
+    @data.reverse!
     value
   end
 
@@ -65,8 +65,7 @@ module RuneRb::Core::ReadableBuffer
   # @param mutation [Symbol] mutation that should be applied to the byte value.
   # @return [Integer] the read byte value.
   def read_byte(mutation: :STD, signed: false)
-    directive = signed ? 'c' : 'C'
-    value = @data.slice!(0).unpack1(directive)
+    value = @data.slice!(0).unpack1(signed ? 'c' : 'C')
     mutate(value, mutation)
   end
 
@@ -75,46 +74,32 @@ module RuneRb::Core::ReadableBuffer
   # @param mutation [String] mutation that should be applied to the short value
   # @param order [Symbol] they byte order to read the short value
   def read_short(signed: false, mutation: :STD, order: :BIG)
-    directive = "#{signed ? 's' : 'S'}"
-    directive << case order
-                 when :BIG then '>'
-                 when :LITTLE then '<'
-                 else ''
-                 end
+    directive = "#{signed ? 's' : 'S'}#{case order
+                                        when :BIG then '>'
+                                        when :LITTLE then '<'
+                                        else ''
+                                        end}"
     value = @data.slice!(0..1).unpack1(directive)
     mutate(value, mutation)
   end
 
-  # Reads a 24-Bit Integer value from the {Buffer#data}
-  # @param signed [Boolean] should the value be signed.
+  # Reads a 24-Bit Unsigned Integer value from the {Buffer#data}
   # @param mutation [Symbol] mutation that should be applied to the value
   # @param order [String] they byte order to read the value
-  def read_int24(signed: false, mutation: :STD, order: :BIG)
-    unpacked = @data.slice!(0..2).unpack('C3')
+  def read_int24(mutation: :STD, order: :BIG)
+    value = 0
     case order
     when :BIG
-      if signed
-        value = (unpacked[0] << 16) | (unpacked[1] << 8) | unpacked[2]
-        unpacked[0] & 0x80 != 0 ? value - 0x10000 : value
-      else
-        (unpacked[0] << 16) | (unpacked[1] << 8) | unpacked[2]
-      end
-    when :MIDDLE
-      if signed
-        value = (unpacked[1] << 16) | (unpacked[2] << 8) | unpacked[0]
-        unpacked[1] & 0x80 != 0 ? value - 0x10000 : value
-      else
-        (unpacked[1] << 16) | (unpacked[2] << 8) | unpacked[0]
-      end
+      value |= read_byte << 16
+      value |= read_byte << 8
+      value |= read_byte(mutation:)
     when :LITTLE
-      if signed
-        value = (unpacked[2] << 16) | (unpacked[1] << 8) | unpacked[0]
-        unpacked[0] & 0x80 != 0 ? value - 0x10000 : value
-      else
-        (unpacked[2] << 16) | (unpacked[1] << 8) | unpacked[0]
-      end
-    else read_int24(signed:, mutation:, order: :BIG)
+      value |= read_byte(mutation:)
+      value |= read_byte << 8
+      value |= read_byte << 16
+    else read_int24(mutation:, order: :BIG)
     end
+    value
   end
 
   # Reads a integer value from the {Buffer#data}
@@ -144,17 +129,13 @@ module RuneRb::Core::ReadableBuffer
   # @param mutation [Symbol] mutation that should be applied to the long value
   # @param order [String] they byte order to read the long value
   def read_long(signed: false, mutation: :STD, order: :BIG)
-    case order
-    when :BIG
-      directive = signed ? 'q>' : 'Q>'
-      value = @data.slice!(0..7).unpack1(directive)
-      mutate(value, mutation)
-    when :LITTLE
-      directive = signed ? 'q<' : 'Q<'
-      value = @data.slice!(0..7).unpack1(directive)
-      mutate(value, mutation)
-    else read_long(signed:, mutation:, order: :BIG)
-    end
+    directive = "#{signed ? 'q' : 'Q'}#{case order
+                                        when :BIG then '>'
+                                        when :LITTLE then '<'
+                                        else ''
+                                        end}"
+    value = @data.slice!(0..7).unpack1(directive)
+    mutate(value, mutation)
   end
 
   # Read a smart value from the {Buffer#data}

data/lib/rune/core/{isaac.rb → ruby_isaac.rb}

@@ -1,6 +1,6 @@
 module RuneRb::Core
   # An implementation of an ISAAC cipher used to generate random numbers for message interchange.
-  class ISAAC
+  class RubyISAAC
     using RuneRb::Patches::IntegerRefinements
 
     # Called when a new ISAAC Cipher is created.
@@ -26,7 +26,7 @@ module RuneRb::Core
         @randcnt = 256
       end
       @randcnt -= 1
-      @randrsl[@randcnt].signed(:i)
+      @randrsl[@randcnt].int
     end
 
     private

data/lib/rune/patches/integer_refinements.rb

@@ -1,6 +1,55 @@
 # A module adding overflow functions to integers to mimic the behavior of Java primitive overflow behavior.
 module RuneRb::Patches::IntegerRefinements
   refine Integer do
+    def overflow(i, e = 2 ** 31)
+      f = (Math.log(e) / Math.log(2)).to_i+1
+      g = (2 ** f) - 1
+
+      if i < -e
+        i & g
+      elsif i > e - 1
+        -(-(i) & g)
+      else
+        i
+      end
+    end
+
+    def nibble
+      overflow(self.to_i & 0xf, 2 ** 4)
+    end
+
+    def byte
+      overflow(self.to_i, 2 ** 7)
+    end
+
+    def ubyte
+      overflow(self.to_i & 0xff, 2 ** 8)
+    end
+
+    def short
+      overflow(self.to_i, 2 ** 15)
+    end
+
+    def ushort
+      overflow(self.to_i & 0xffff, 2 ** 16)
+    end
+
+    def int
+      overflow(self.to_i, 2 ** 31)
+    end
+
+    def uint
+      overflow(self.to_i & 0xffffffff, 2 ** 32)
+    end
+
+    def long
+      overflow(self.to_i, 2 ** 63)
+    end
+
+    def ulong
+      overflow(self.to_i & 0xffffffffffffffff, 2 ** 64)
+    end
+
     # Returns a binary representation in the form of an array of 1's and 0's in their respective digits.
     # @return [Array] the binary representation
     def binary_representation
@@ -22,39 +71,6 @@ module RuneRb::Patches::IntegerRefinements
 
     alias_method :from_brep, :from_binary_rep
 
-    # Adjusts the value of the Integer to be unsigned.
-    # @param type [Symbol] the type of primitive the value will be returned as
-    def unsigned(type)
-      return 0 if negative?
-      case type
-      when :Byte, :byte, :b, :B then to_i > 0xFF ? 0xFF : to_i
-      when :Short, :short, :s, :S then to_i > 0xFFFF ? 0xFFFF : to_i
-      when :Integer, :Int, :int, :integer, :i, :I then to_i > 0xFFFFFFFF ? 0xFFFFFFFF : to_i
-      when :Long, :long, :l, :L then to_i > 0xFFFFFFFFFFFFFFFF ? 0xFFFFFFFFFFFFFFFF : to_i
-      else unsigned(:int)
-      end
-    end
-
-    alias_method :u, :unsigned
-
-    # Adjusts the value of the Integer to be signed.
-    # @param type [Symbol] the type of primitive the value will be returned as
-    def signed(type)
-      case type
-      when :Byte, :byte, :b, :B then adjust(:byte)
-      when :Short, :short, :s, :S then adjust(:short)
-      when :Integer, :Int, :int, :integer, :i, :I then adjust(:integer)
-      when :Long, :long, :l, :L then adjust(:long)
-      else adjust(:integer)
-      end
-    end
-
-    alias_method :s, :signed
-
-    def nibble
-      adjust(:nibble)
-    end
-
     # Returns a string with a formatted representation of the Integer as a timestamp.
     def to_ftime
       mm, ss = divmod(60)
@@ -63,61 +79,6 @@ module RuneRb::Patches::IntegerRefinements
       format('%d days, %d hours, %d minutes, and %d seconds', dd, hh, mm, ss)
     end
 
-    private
-
-    # Adjusts the integer based on the passed type
-    # @param type [Symbol] the type of adjustment to make to the integer.
-    def adjust(type)
-      case type
-      when :Byte, :byte, :b, :B
-        primitive_max = 2**7 - 1
-        primitive_min = -2**7
-      when :Short, :short, :s, :S
-        primitive_max = 2**15 - 1
-        primitive_min = -2**15
-      when :Integer, :Int, :int, :i, :I
-        primitive_max = 2**31 - 1
-        primitive_min = -2**31
-      when :Long, :long, :l, :L
-        primitive_max = 2**63 - 1
-        primitive_min = -2**63
-      when :Nibble, :nibble, :n, :N
-        primitive_max = 2**4
-        primitive_min = -2**4
-      else
-        primitive_max = 2**31 - 1
-        primitive_min = -2**31
-      end
-      self < -primitive_max ? -1 * (-self & primitive_max) : self
-      self > primitive_min ? (self & primitive_max) : self
-    end
+    alias_method :ftime, :to_ftime
   end
-end
-
-# Copyright (c) 2021, Patrick W.
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-#
-# * Neither the name of the copyright holder nor the names of its
-#   contributors may be used to endorse or promote products derived from
-#   this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rrb-common
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Patrick W.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-12 00:00:00.000000000 Z
+date: 2023-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -161,9 +161,9 @@ files:
 - lib/rune/core/buffer.rb
 - lib/rune/core/constants.rb
 - lib/rune/core/identifiable.rb
-- lib/rune/core/isaac.rb
 - lib/rune/core/logging.rb
 - lib/rune/core/readable_buffer.rb
+- lib/rune/core/ruby_isaac.rb
 - lib/rune/core/unit.rb
 - lib/rune/core/writeable_buffer.rb
 - lib/rune/patches/integer_refinements.rb