rrb-common 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1063be8d2fdedff9c18342214732a264e406aaf0e9f88bc3a699f3ff8a85cd
-  data.tar.gz: ebd87f1f93863dc31cc24dba6b9bd26c01aa79b263cc160c0d02bd60d461c236
+  metadata.gz: 25249c7b5e3aa642c23637cc4e3bad8ce62434a1d77962287fe7cab331d016c9
+  data.tar.gz: 7592bacd9ddfb0d7371bfd24f87a84de502e2500f7a81a5ca3f8bbd5f1d888a5
 SHA512:
-  metadata.gz: d4b29deb98f9c99c8b8af84c29b8e6c06fe30bf37810c768f4de3b5d9d74ec1af89e99d78e3dab9270a19c25d20d5da558b3b5afa996d2c4c26464d094eb77f7
-  data.tar.gz: 181a1537c93ea4708e755ac9976e9d5f3eea02c6a97854e0491538a84a52262382fc23f7e9aed59922721bbcb9c74960231fcb48a6dc486e83655ce0840344ff
+  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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rrb-common
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Patrick W.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-13 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