rrb 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41791058f4c6b1f6c6295182df8f1edae27a3aa6e89655bc11530863d7d136b5
-  data.tar.gz: 5457ead97de7f07f2bb09bdbd3254eaf6dc4ded42b08943f9fba860ad0af9149
+  metadata.gz: 5fa8cdaebd91d028bc2a93d59e00c45c7d61090f4fb8547b224ed2d78aa7fea9
+  data.tar.gz: 69968f16213b56e75f9a96e18a1d5f2a56c187a783820de396c2453398657a9d
 SHA512:
-  metadata.gz: d1f5a2425a35ab452d24442399c31ea3e3bb1acb20dba030e6cc85458e929b6199de6074e02132f313f843fc3169af7c282038e2605f196dabe3e2221d32291c
-  data.tar.gz: 5f39f2186da44056283a23921b252b30efbb27a0c0dd3ada6b0f1875f4e8ecd30d8a45e36c1c7a740b058698cf92f977649eeef789494cc793877851b77b473e
+  metadata.gz: 91e576b8fbf50b633175d3084f18a7abd5d0b24ab1a71a951e4144d889de7078ae66fc7bace3f8aeb384b793d67b11805dbf536cfcf13da1b42325298bd1345c
+  data.tar.gz: '09dcd69d25de941f26dd0551276b45170bbd8464675a95ddeb6dbed6adb145aabc536549db28cff504f049c2fc5b7f55e8603dc48652a0a2b5c7e6144c28dfff'

data/lib/rrb/io/buffer.rb

@@ -0,0 +1,134 @@
+# The IO module provides objects, modules, and functions to handle input/output operations.
+module RuneRb::IO
+
+  # A Buffer object encapsulates a string of binary data and dynamically includes functions to interact with that data depending on the modestring.
+  class Buffer
+    include RuneRb::Utils::Logging
+
+    # @return [Boolean] is {bit_access} enabled?
+    attr_reader :bit_access
+
+    # @return [String] the access mode.
+    attr_reader :mode
+
+    # @return [String] the data.
+    attr_reader :data
+
+    # Construct a new instance of {Buffer}.
+    # @param modestring [String] the mode for the buffer. ['r', 'w']
+    # @param data [String] the data.
+    # @return [Buffer] the created instance.
+    def initialize(modestring, data: '')
+      raise "Invalid mode-string for Buffer! Expecting: r, rn, w, rw Got: #{modestring}" unless /(?i)r|n|w/.match?(modestring)
+
+      @data = data
+      @mode = modestring
+
+      enable_readable if /(?i)r/.match?(modestring)
+      enable_writeable if /(?i)w/.match?(modestring)
+      enable_native_readable if /(?i)n/.match?(modestring)
+
+      self
+    end
+
+    # The length of the underlying data.
+    # @return [Integer]
+    def length
+      @data.length
+    end
+
+    alias size length
+
+    # Fetches a snapshot of the message payload content.
+    # @return [String] a snapshot of the payload
+    def peek
+      @data.force_encoding(Encoding::BINARY)
+    end
+
+    alias snapshot peek
+
+    # Push data directly to the {Buffer#data} object.
+    # @param data [String] the data to write.
+    def push(data = '')
+      @data.concat(data) unless data.empty?
+    end
+
+    alias << push
+
+    def inspect
+      if @mode.include?('w')
+        "[BufferMode:] #{@mode} || [BodyLength:] #{@data.length} || [BitAccess:] #{@bit_access} || [Payload:] #{hex}"
+      else
+        "[BufferMode:] #{@mode} || [BodyLength:] #{@data.length} || [Payload:] #{hex}"
+      end
+    end
+
+    # @return [String] hex representation of the buffer's data.
+    def hex
+      res = ''
+      peek.each_byte { res << "#{_1 < 16 ? '0' : ''}#{_1.to_s(16)} " }
+      res.strip
+    end
+
+    private
+
+    # Enables Writeable functions for the Message.
+    def enable_writeable
+      @bit_access = false
+      @bit_position = 0
+      singleton_class.include(RuneRb::IO::Writeable)
+    end
+
+    # Enables Readable functions for the Message.
+    def enable_readable
+      singleton_class.include(RuneRb::IO::Readable)
+    end
+
+    # Enables Native reading functions for the Message.
+    def enable_native_readable
+      singleton_class.include(RuneRb::IO::NativeReadable)
+    end
+
+    # Mutates the value according to the passed mutation
+    # @param value [Integer] the value to mutate
+    # @param mutation [Symbol] the mutation to apply to the value.
+    def mutate(value, mutation)
+      case mutation
+      when :STD then value
+      when :ADD then value += 128
+      when :NEG then value = -value
+      when :SUB then value -= 128
+      else mutate(value, :STD)
+      end
+      value
+    end
+  end
+end
+
+# Copyright (c) 2022, 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.

data/lib/rrb/io/message.rb

@@ -0,0 +1,125 @@
+# The IO module provides objects, modules, and functions to handle input/output operations.
+module RuneRb::IO
+
+  # Represents a composable/decomposable network message that is either sent or received via a TCPSocket.
+  class Message
+    include RuneRb::Utils::Logging
+
+    # @return [Struct] the header for the message.
+    attr :header
+
+    # @return [Buffer] the access mode for the message.
+    attr :body
+
+    # Models the heading of a protocol data unit received from a peer socket.
+    # @param op_code [Integer] the Operation Code of the data unit
+    # @param length [Integer] the length of data unit's payload, excluding the header.
+    # @param type [Symbol] the type of header of the data unit.
+    # @return [Struct]
+    Header = Struct.new(:op_code, :length, :type) do
+
+      # Generates a binary string representation of the {Header} object.
+      # @return [String, NilClass] binary representation of the header.
+      def compile_header
+        case self.type
+        when :FIXED then [self.op_code].pack('C') # Fixed packet lengths are known by both the client and server, so no length packing is necesssary
+        when :RAW then ''
+        when :VARIABLE_SHORT then [self.op_code, self.length].pack('Cn') # Variable Short packet lengths fall into the range of a short type and can be packed as such
+        when :VARIABLE_BYTE # Variable Byte packet lengths fall into the range of a byte type and can be packed as such
+          if self.length.nonzero? && self.length.positive?
+            [self.op_code, self.length].pack('Cc')
+          elsif self.length.nonzero? && self.length.negative?
+            self.type = :FIXED
+            compile_header
+          end
+        else compile_header
+        end
+      end
+
+      def inspect
+        "[Header]: [OpCode]: #{self.op_code} || [Length]: #{self.length}"
+      end
+    end
+
+    # Called when a new Message is created
+    # @param op_code [Integer] the message's operation code.
+    # @param type [Symbol] the message type. [:VARIABLE_BYTE, :VARIABLE_SHORT, :FIXED]
+    # @param body [String, RuneRb::Network::Buffer] an optional body payload for the message.
+    # @return [Message] the instance created.
+    def initialize(op_code: -1, type: :FIXED, body: RuneRb::IO::Buffer.new('rw'))
+      @header = Header.new(op_code, 0, type)
+      @body = case body
+              when RuneRb::IO::Buffer then body
+              when String then RuneRb::IO::Buffer.new('r', data: body)
+              else raise "Invalid body type for message! Expecting: Buffer, String Got: #{body.class}"
+              end
+      update_length
+
+      self
+    end
+
+    # Compiles the {Message} into a string of binary data.
+    # @return [String] binary representation of the message.
+    def compile
+      @header.compile_header + @body.snapshot
+    end
+
+    def inspect
+      "#{@header.inspect} || #{@body.inspect}"
+    end
+
+    # @abstract parses the message object.
+    def parse(_session); end
+
+    # Read data from the {Message#body}
+    # @param type [Symbol] the type of data to read
+    # @param signed [Boolean] should the value be signed
+    # @param mutation [Symbol] the mutation that should be applied to the data
+    # @param order [String] the byte order to read the data in.
+    def read(type: :byte, signed: false, mutation: :STD, order: 'BIG')
+      @body.read(type: type, signed: signed, mutation: mutation, order: order)
+    end
+
+    # Write data to the {Message#body}
+    def write(value, type: :byte, mutation: :STD, order: 'BIG', options: {})
+      @body.write(value, type: type, mutation: mutation, order: order, options: options)
+      update_length
+      self
+    end
+
+    private
+
+    # Updates the length of the <@header>
+    def update_length
+      @header.length = @body.length
+    end
+  end
+end
+
+# Copyright (c) 2022, 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.

data/lib/rrb/io/native_readable.rb

@@ -0,0 +1,123 @@
+# The IO module provides objects, modules, and functions to handle input/output operations.
+module RuneRb::IO
+
+  # Provides functions to read integer values from a string-based buffer using native ruby methods.
+  module NativeReadable
+    # Read a byte value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the byte value.
+    def read_byte(mutation: :STD, signed: false)
+      mutate(@data.slice!(0)&.unpack1(signed ? 'c' : 'C') || 0, mutation)
+    end
+
+    # Reads a short value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the short value
+    # @param order [String] they byte order to read the short value
+    def read_short(signed: false, mutation: :STD, order: 'BIG')
+      val = 0
+      case order
+      when 'BIG'
+        val += mutate(@data.slice!(0..1).unpack1(signed ? 's>' : 'S>'), mutation)
+      when 'LITTLE'
+        val += mutate(@data.slice!(0..1).unpack1(signed ? 's<' : 'S<'), mutation)
+      else read_short(signed: signed, mutation: mutation, order: 'BIG')
+      end
+      val
+    end
+
+    # Reads a medium value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the medium value
+    # @param order [String] they byte order to read the medium value
+    def read_medium(signed: false, mutation: :STD, order: 'BIG')
+      val = 0
+      case order
+      when 'BIG'
+        val += read_byte(signed: signed) << 16
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed, mutation: mutation)
+      when 'MIDDLE'
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 16
+      when 'LITTLE'
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed) << 16
+      else read_medium(signed: signed, mutation: mutation, order: 'BIG')
+      end
+      val
+    end
+
+    # Reads a integer value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the integer value
+    # @param order [String] they byte order to read the integer value
+    def read_int(signed: false, mutation: :STD, order: 'BIG')
+      val = 0
+      case order
+      when 'BIG'
+        val += mutate(@data.slice!(0..3).unpack1(signed ? 'i>' : 'I>'), mutation)
+      when 'MIDDLE'
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 24
+        val += read_byte(signed: signed) << 16
+        return val
+      when 'INVERSE_MIDDLE'
+        val += read_byte(signed: signed) << 16
+        val += read_byte(signed: signed) << 24
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 8
+        return val
+      when 'LITTLE'
+        val += mutate(@data.slice!(0..3).unpack1(signed ? 'i<' : 'I<'), mutation)
+      else read_int(signed: signed, mutation: mutation, order: 'BIG')
+      end
+      val
+    end
+
+    # Reads a long value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] 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'
+        mutate(@data.slice!(0..7).unpack1(signed ? 'q>' : 'Q>'), mutation)
+      when 'LITTLE'
+        mutate(@data.slice!(0..7).unpack1(signed ? 'q<' : 'Q<'), mutation)
+      else read_long(signed: signed, mutation: mutation, order: 'BIG')
+      end
+    end
+  end
+end
+
+# Copyright (c) 2022, 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.

data/lib/rrb/io/readable.rb

@@ -0,0 +1,199 @@
+# The IO module of the Rune.rb framework provides objects, modules, and functions to handle input/output operations.
+module RuneRb::IO
+
+  # Provides functions for reading integer values from a string-based buffer.
+  module Readable
+    using RuneRb::Patches::IntegerRefinements
+
+    # Read data from the payload according to the option parameter.
+    # @param type [Symbol] the type of database to read
+    # @param mutation [Symbol] an option mutation to apply to the read value.
+    def read(type: :byte, signed: false, mutation: :STD, order: 'BIG', options: {})
+      return unless RuneRb::IO::Validation.validate(self, 'read', { bit_access: @bit_access, mutation: mutation, order: order })
+
+      case type
+      when :bits then read_bits(options[:amount])
+      when :byte then read_byte(signed: signed, mutation: mutation)
+      when :bytes then read_bytes(options[:amount] || 1, mutation: mutation)
+      when :short then read_short(signed: signed, mutation: mutation, order: order)
+      when :medium then read_medium(signed: signed, mutation: mutation, order: order)
+      when :int then read_int(signed: signed, mutation: mutation, order: order)
+      when :long then read_long(signed: signed, mutation: mutation, order: order)
+      when :smart then read_smart(signed: signed, mutation: mutation)
+      when :string then read_string
+      when :reverse_bytes then read_bytes_reverse(options[:amount] || 1, mutation: mutation)
+      else raise "Unrecognized read type! #{type}"
+      end
+    end
+
+    private
+
+    # Read multiple bytes from the {Buffer#data}
+    # @param amount [Integer] the amount of bytes to read
+    # @param mutation [Symbol] the mutation to apply to read bytes.
+    def read_bytes(amount, mutation)
+      amount.times.each_with_object([]) { |_idx, arr| arr << read_byte(signed: false, mutation: mutation) }
+    end
+
+    # Probably did this wrong
+    # @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.reverse
+      value = read_bytes(amount, mutation)
+      @data.reverse
+      value
+    end
+
+    # Read a byte value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the byte value.
+    def read_byte(mutation: :STD, signed: false)
+      val = mutate(@data.slice!(0)&.unpack1(signed ? 'c' : 'C') || 0, mutation)
+      signed ? val.signed(:byte) : val.unsigned(:byte)
+    end
+
+    # Reads a short value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the short value
+    # @param order [String] they byte order to read the short value
+    def read_short(signed: false, mutation: :STD, order: 'BIG')
+      val = 0
+      case order
+      when 'BIG'
+        val += read_byte(signed: signed) << 8
+        val += read_byte(mutation: mutation, signed: signed)
+      when 'LITTLE'
+        val += read_byte(mutation: mutation, signed: signed)
+        val += read_byte(signed: signed) << 8
+      else read_short(signed: signed, mutation: mutation, order: 'BIG')
+      end
+      val
+    end
+
+    # Reads a medium value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the medium value
+    # @param order [String] they byte order to read the medium value
+    def read_medium(signed: false, mutation: :STD, order: 'BIG')
+      val = 0
+      case order
+      when 'BIG'
+        val += read_byte(signed: signed) << 16
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed, mutation: mutation)
+      when 'MIDDLE'
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 16
+      when 'LITTLE'
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed) << 16
+      else read_medium(signed: signed, mutation: mutation, order: 'BIG')
+      end
+      val
+    end
+
+    # Reads a integer value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the integer value
+    # @param order [String] they byte order to read the integer value
+    def read_int(signed: false, mutation: :STD, order: 'BIG')
+      val = 0
+      case order
+      when 'BIG'
+        val += read_byte(signed: signed) << 24
+        val += read_byte(signed: signed) << 16
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed, mutation: mutation)
+      when 'MIDDLE'
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 24
+        val += read_byte(signed: signed) << 16
+      when 'INVERSE_MIDDLE'
+        val += read_byte(signed: signed) << 16
+        val += read_byte(signed: signed) << 24
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 8
+      when 'LITTLE'
+        val += read_byte(signed: signed, mutation: mutation)
+        val += read_byte(signed: signed) << 8
+        val += read_byte(signed: signed) << 16
+        val += read_byte(signed: signed) << 24
+      else read_int(signed: signed, mutation:mutation, order: 'BIG')
+      end
+      val
+    end
+
+    # Reads a long value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] 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')
+      val = 0
+      case order
+      when 'BIG'
+        (RuneRb::IO::BYTE_SIZE * 7).downto(0) { |div| ((div % 8).zero? and div.positive?) ? val |= read_byte(signed: signed) << div : next }
+        val += read_byte(signed: signed, mutation: mutation)
+      when 'LITTLE'
+        val += read_byte(signed: signed, mutation: mutation)
+        (0).upto(RuneRb::IO::BYTE_SIZE * 7) { |div| ((div % 8).zero? and div.positive?) ? val |= read_byte(signed: signed) << div: next }
+      else read_long(signed: signed, mutation: mutation, order: 'BIG')
+      end
+      val
+    end
+
+    # Read a smart value from the {Buffer#data}
+    # @param signed [Boolean] should the value be signed.
+    # @param mutation [String] mutation that should be applied to the long value
+    def read_smart(signed: false, mutation: :STD)
+      val = peek.slice(0).unpack1(signed ? 'c' : 'C')
+      case signed
+      when true then val < 128 ? read_byte(mutation: mutation, signed: signed) - 64 : read_short(mutation: mutation, signed: signed, order: 'BIG') - 49_152
+      when false then val < 128 ? read_byte(mutation: mutation, signed: signed) : read_short(mutation: mutation, signed: signed, order: 'BIG') - 32_768
+      end
+    end
+
+    # Reads a string from the {Buffer#data}
+    # @return [String] the resulting string.
+    def read_string
+      val = ''
+      while (res = read_byte; res != 10)
+        break if res == "\n"
+
+        val << res
+      end
+      val
+    end
+  end
+end
+
+# Copyright (c) 2022, 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.