rrb-common 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e1063be8d2fdedff9c18342214732a264e406aaf0e9f88bc3a699f3ff8a85cd
-  data.tar.gz: ebd87f1f93863dc31cc24dba6b9bd26c01aa79b263cc160c0d02bd60d461c236
+  metadata.gz: 0ce1791f92b3956911a84c638f8c6b55b1dc41b250321f0ee14a3aa2e70771d0
+  data.tar.gz: 1d80809c5a7633e2f379a3c6df03ad0cd278d127775a2ad76fae52c31f4ae534
 SHA512:
-  metadata.gz: d4b29deb98f9c99c8b8af84c29b8e6c06fe30bf37810c768f4de3b5d9d74ec1af89e99d78e3dab9270a19c25d20d5da558b3b5afa996d2c4c26464d094eb77f7
-  data.tar.gz: 181a1537c93ea4708e755ac9976e9d5f3eea02c6a97854e0491538a84a52262382fc23f7e9aed59922721bbcb9c74960231fcb48a6dc486e83655ce0840344ff
+  metadata.gz: 59abbc5acfb4daad674f5555d23adf9714987a448fbc6c051aee422977672206550973039df89f85dd27adc31b872763b3c700983022bf91333fe46232d7af0b
+  data.tar.gz: af50e56189702d9c4820ec9a78e04ec0a4dc042a825ff7015d736938dd6119610d75df3e16792d7329eb2c7cc46f3dc8359fcdc8e2179ff96ec6cc7ceca94819

data/lib/rune/cache/archive.rb

@@ -0,0 +1,63 @@
+module RuneRb::Cache
+  # An archive of data in the Cache.
+  class Archive
+    include RuneRb::Core::Logging
+
+    # @!attribute [r] entries
+    # @return [Array<Hash>] the entries in the archive
+    attr_reader :entries
+
+    # Constructs a new CacheArchive
+    # @param entries [Array<Hash>] the entries in the archive
+    def initialize(entries)
+      @entries = entries
+    end
+
+    # Decodes an archive from the specified buffer.
+    # @param buffer [RuneRb::Core::Buffer] the buffer to decode
+    def self.decode(buffer)
+      extracted_size = buffer.read(type: :int24)
+      size = buffer.read(type: :int24)
+      extracted = false
+
+      if size != extracted_size
+        data = buffer.data.slice!(0..size)
+        data = StringIO.new(data)
+        decompressor = RBzip2.default_adapter::Decompressor.new(data)
+        buffer = RuneRb::Core::Buffer.new(mode: 'r')
+        buffer << decompressor.read
+        extracted = true
+      end
+
+      entry_count = buffer.read(type: :short)
+      identifiers = Array.new(entry_count)
+      extracted_sizes = Array.new(entry_count)
+      sizes = Array.new(entry_count)
+
+      entry_count.times do |i|
+        identifiers[i] = buffer.read(type: :int)
+        extracted_sizes[i] = buffer.read(type: :int24)
+        sizes[i] = buffer.read(type: :int24)
+      end
+
+      entries = Array.new(entry_count)
+      entry_count.times do |entry|
+        entry_buffer = RuneRb::Core::Buffer.new(mode: 'r')
+
+        if extracted == false
+          data = buffer.data.slice!(0..sizes[entry])
+          data = StringIO.new(data)
+          decompressor = RBzip2.default_adapter::Decompressor.new(data)
+          entry_buffer << decompressor.read
+        else
+          data = buffer.data.slice!(0..extracted_sizes[entry])
+          entry_buffer << data 
+        end
+
+        entries[entry] = { id: identifiers[entry], buffer: entry_buffer }
+      end
+
+      RuneRb::Cache::Archive.new(entries)
+    end
+  end
+end

data/lib/rune/cache/constants.rb

@@ -0,0 +1,21 @@
+module RuneRb::Cache::Constants
+  # The number of archives in the cache.
+  # @return [Integer]
+  ARCHIVE_COUNT = 0x9
+
+  # The size of a single index
+  # @return [Integer]
+  INDEX_SIZE = 0x6
+
+  # The size of a single data header
+  # @return [Integer]
+  HEADER_SIZE = 0x8
+
+  # The size of a chunk of data
+  # @return [Integer]
+  CHUNK_SIZE = 512
+
+  # The size of a single data block
+  # @return [Integer]
+  BLOCK_SIZE = HEADER_SIZE + CHUNK_SIZE;
+end

data/lib/rune/cache/file_system.rb

@@ -0,0 +1,182 @@
+module RuneRb::Cache
+  class FileSystem
+    include RuneRb::Core::Logging
+
+    # @attribute [r] cache
+    # @return [Hash<FileDescriptor, RuneRb::Cache::Archive>] a map of decoded archives.
+    attr_reader :cache
+
+    # @attribute [r] crc_table
+    # @return [RuneRb::Core::Buffer] the CRC table for the cache.
+    attr_reader :crc_table
+
+    # @attribute [r] crc
+    # @return [Array<Integer>] the CRC values for the cache.
+    attr_reader :crc
+
+    # @attribute [r] indicies
+    # @return [Array<StringIO>] the indicies for the cache.
+    attr_reader :indicies
+
+    # @attribute [r] data_file
+    # @return [StringIO] the data file for the cache.
+    attr_reader :data_file
+
+    # Constructs a new FileSystem instance.
+    # @param path [String] the path to the cache.
+    def initialize(path)
+      @indicies = Array.new
+      @crc_table = RuneRb::Core::Buffer.new(mode: 'r')
+      @crc = Array.new
+      @cache = Hash.new
+      @data_file = StringIO.new
+      read_layout(path)
+    end
+
+    # Retrieves an {RuneRb::Cache::Archive} by the specified {FileDescriptor}.
+    # @param type [Integer] the file type.
+    # @param file [Integer] the file identifier.
+    def archive(type, file)
+      descriptor = FileDescriptor.new(type, file)
+      cached = @cache[descriptor]
+      
+      if cached == nil
+        file = cache_file(descriptor)
+        cached = RuneRb::Cache::Archive.decode(file)
+        @cache[descriptor] = cached
+      end
+      
+      cached
+    end
+
+    # Retrieves a {RuneRb::Core::Buffer} that corresponds to the specified {FileDescriptor} in the cache.
+    # @param descriptor [FileDescriptor] the descriptor to retrieve.
+    # @raise [RuntimeError] if a Chunk id does not match what is expected during cache file read.
+    # @raise [RuntimeError] if a type does not match descriptor type during cache file read.
+    # @raise [RuntimeError] if a file identifier does not match descriptor file identifier during cache file read.
+    # @return [RuneRb::Core::Buffer] the buffer containing data that corresponds to the specified descriptor.
+    def cache_file(descriptor)
+      index = index_for(descriptor)
+      buffer = RuneRb::Core::Buffer.new(mode: 'r')
+      
+      position = index.block * RuneRb::Cache::BLOCK_SIZE
+      read = 0
+      size = index.size
+      blocks = size / RuneRb::Cache::CHUNK_SIZE
+
+      if size % RuneRb::Cache::CHUNK_SIZE != 0
+        blocks += 1
+      end
+
+      info "Reading #{blocks} blocks from position #{position}."
+
+      blocks.times do |i|
+        @data_file.seek(position)
+        header = @data_file.read
+        header_data = header.unpack('C*')
+      
+        position += RuneRb::Cache::HEADER_SIZE
+        
+        next_file     = header_data[0] << 8 | header_data[1]
+        current_chunk = header_data[2] << 8 | header_data[3]
+        next_block    = header_data[4] << 16 | header_data[5] << 8 | header_data[6]
+        next_type     = header_data[7]
+
+        raise "Chunk id mismatch! (Current #{current_chunk}, Expected #{i})" if current_chunk != i
+
+        chunk_size = size - read
+        chunk_size = RuneRb::Cache::CHUNK_SIZE if chunk_size > RuneRb::Cache::CHUNK_SIZE
+
+        @data_file.seek(position)
+        buffer << @data_file.read
+
+        read += chunk_size
+        position = next_block * RuneRb::Cache::BLOCK_SIZE
+
+        if size > read
+          raise "Next type (#{next_type}) does not match descriptor type (#{descriptor.type + 1})." if next_type != descriptor.type + 1
+          raise "Next file (#{next_file}) does not match descriptor file (#{descriptor.file})." if next_file != descriptor.file
+        end
+      end
+
+      info "Read #{buffer.length} from cache."
+
+      buffer
+    end
+
+    def index_for(descriptor)
+      idx = descriptor.type
+      raise "Index out of bounds. (#{idx})" if idx < 0 || idx >= @indicies.length
+
+      buffer = String.new
+      idx_file = @indicies[idx]
+      position = descriptor.file * RuneRb::Cache::INDEX_SIZE
+      info "Reading index from position #{position}"
+
+      if position >= 0 && (idx_file.length >= (position + RuneRb::Cache::INDEX_SIZE))
+        idx_file.seek(position, IO::SEEK_CUR)
+        buffer << idx_file.read
+      else
+        raise "Could not find index file at position #{position}."
+      end
+
+      info " Length: #{buffer.length}, Index data: #{buffer.bytes}"
+
+      RuneRb::Cache::Index.decode(buffer)
+    end
+    
+    def close
+      @indicies.each(&:close)
+      @data_file.close
+    end
+
+    # The number of index files in the cache.
+    # @return [Integer] the number of index files in the cache.
+    def cache_count
+      @indicies.length
+    end
+
+    # The number of files in a cache.
+    # @param cache [Integer] the cache to check.
+    def file_count(cache)
+      (@indicies[cache].size / RuneRb::Core::INDEX_SIZE) - 1
+    end
+
+    # Reads the layout of the cache from the specified path.
+    # @param path [String] the path to the cache directory.
+    # @raise [RuntimeError] if the cache archive is not found.
+    def read_layout(path)
+      raise "Cache archive not found. Please install them into the #{path} directory."  unless check_for_archives(path)
+
+      # Find how many index files exist
+      count = 0.upto(255).each do |i|
+        break i unless File.exist?(File.join(path, "main_file_cache.idx#{i}"))
+      end
+
+      # Gather file objects
+      @data_file = File.open(File.join(path, "main_file_cache.dat"), "r")
+
+      count.times do |i|
+        data = File.read("#{path}/main_file_cache.idx#{i}")
+        @indicies[i] = StringIO.new(data)
+      end
+    end
+
+    # Checks for the existence of cache archives in a path.
+    # @param path [String] the path to the cache directory.
+    def check_for_archives(path)
+      return false if path.nil?
+      return false unless File.directory?(path)
+      return false unless File.exist?(path)
+      return false unless File.readable?(path)
+      return false if Dir.empty?(path)
+      true
+    end
+
+    FileDescriptor = Struct.new(:type, :file) do
+      def equals(other)
+        other.file == file && other.type == type
+      end
+    end
+  end
+end

data/lib/rune/cache/index.rb

@@ -0,0 +1,37 @@
+module RuneRb::Cache
+  # An instance of a {CacheIndex} points to a file in the `main_file_cache.dat` file.
+  class Index
+    include RuneRb::Core::Logging
+
+    # @!attribute [r] size
+    # @return [Integer] the size of the file.
+    # @note This attribute is read-only.
+    attr_reader :size
+
+    # @!attribute [r] block
+    # @return [Integer] the block of the file.
+    # @note This attribute is read-only.
+    attr_reader :block
+    
+    # Constructs a new Cache Index given the block size and identifier.
+    # @param size [Integer] the size of the block file
+    # @param block [Integer] the first block of the file
+    def initialize(size, block)
+      @size = size
+      @block = block
+    end
+
+    # Decodes a buffer into an index.
+    # @param buffer [String] the buffer to decode.
+    def self.decode(buffer)
+      #raise "Unexpected buffer length. Buffer #{buffer.bytesize}, Expected: #{RuneRb::Core::INDEX_SIZE}" unless buffer.bytesize == RuneRb::Core::INDEX_SIZE
+
+      bytes = buffer.unpack('C*')
+      size =  bytes[0] << 16 | bytes[1] << 8 | bytes[2]
+      block = bytes[3] << 16 | bytes[4] << 8 | bytes[5]
+      info "Decoded index: size: #{size}, block: #{block}"
+
+      RuneRb::Cache::Index.new(size, block)
+    end
+  end
+end

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'
@@ -34,6 +35,15 @@ module RuneRb
     autoload :SetRefinements,     'rune/patches/set_refinements'
   end
 
+  module Cache
+    autoload :Archive,            'rune/cache/archive'
+    autoload :Constants,          'rune/cache/constants'
+    autoload :FileSystem,         'rune/cache/file_system'
+    autoload :Index,              'rune/cache/index'
+
+    include RuneRb::Cache::Constants
+  end
+
   # The Logger utility for the RuneRb framework.
   # @return [Console::Logger] the logger instance.
   def self.logger

data/lib/rune/core/buffer.rb

@@ -3,6 +3,11 @@ module RuneRb::Core
   # A Buffer encapsulates raw data in a String instance. Depending on the mode, the buffer can be read from or written to.
   class Buffer
 
+    # @!attribute [r] data
+    # @return [String] the data contained in the buffer.
+    # @note This attribute is read-only.
+    attr_reader :data
+
     # Constructs a new Buffer instance.
     # @param mode [String] the mode of the buffer.
     def initialize(mode: 'rw')

data/lib/rune/core/constants.rb

@@ -19,6 +19,10 @@ module RuneRb::Core::Constants
   # @return [Array<Integer>]
   BIT_MASK_OUT = (0...32).collect { (1 << _1) - 1 }.freeze
 
+  # The number of archives in the cache.
+  # @return [Integer]
+  ARCHIVE_COUNT = 0x9
+
   # The size of a single index
   # @return [Integer]
   INDEX_SIZE = 0x6
@@ -34,4 +38,11 @@ module RuneRb::Core::Constants
   # The size of a chunk of data
   # @return [Integer]
   DATA_SIZE = DATA_BLOCK_SIZE + DATA_HEADER_SIZE
-end
+
+  # 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.
@@ -10,11 +10,7 @@ module RuneRb::Core
       @cc = 0
       @mm = []
       @randrsl = Array.new(256, 0)
-
-      seed.each_with_index do |element, i|
-        @randrsl[i] = element
-      end
-
+      seed.each_with_index { |element, i| @randrsl[i] = element }
       randinit
     end
 

data/lib/rune/core/writeable_buffer.rb

@@ -52,18 +52,14 @@ module RuneRb::Core::WriteableBuffer
   # @param value [Integer] the medium value to write.
   # @param mutation [String] the mutation made to the byte.
   # @param order [String] the order in which bytes will be written.
-  def write_int24(value, mutation: :STD, signed: false, order: :BIG)
+  def write_int24(value, mutation: :STD, order: :BIG)
     case order
     when :BIG
       write_byte(value >> 16)
       write_byte(value >> 8)
-      write_byte(value, mutation: mutation, signed: signed)
-    when :MIDDLE
-      write_byte(value >> 8)
-      write_byte(value, mutation: mutation, signed: signed)
-      write_byte(value >> 16)
+      write_byte(value, mutation: mutation)
     when :LITTLE
-      write_byte(value, mutation: mutation, signed: signed)
+      write_byte(value, mutation: mutation)
       write_byte(value >> 8)
       write_byte(value >> 16)
     else raise "Unrecognized byte order: #{order}"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rrb-common
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - Patrick W.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-13 00:00:00.000000000 Z
+date: 2024-04-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: rbzip2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: dotenv
   requirement: !ruby/object:Gem::Requirement
@@ -156,14 +170,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/rune/cache/archive.rb
+- lib/rune/cache/constants.rb
+- lib/rune/cache/file_system.rb
+- lib/rune/cache/index.rb
 - lib/rune/common.rb
 - lib/rune/core/archive.rb
 - 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
@@ -187,7 +205,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Common utilities for RuneRb.