rrb 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fa8cdaebd91d028bc2a93d59e00c45c7d61090f4fb8547b224ed2d78aa7fea9
-  data.tar.gz: 69968f16213b56e75f9a96e18a1d5f2a56c187a783820de396c2453398657a9d
+  metadata.gz: aff2ff620677328d8da0ff0b455bdfbe02d27d5dd581799c21e782fc6e6f5cca
+  data.tar.gz: 2ca970bb43d6977c7a460dbc1f4b5792d2698ea98a53bba4e90e8a0ed152fa38
 SHA512:
-  metadata.gz: 91e576b8fbf50b633175d3084f18a7abd5d0b24ab1a71a951e4144d889de7078ae66fc7bace3f8aeb384b793d67b11805dbf536cfcf13da1b42325298bd1345c
-  data.tar.gz: '09dcd69d25de941f26dd0551276b45170bbd8464675a95ddeb6dbed6adb145aabc536549db28cff504f049c2fc5b7f55e8603dc48652a0a2b5c7e6144c28dfff'
+  metadata.gz: 6a498fc882576d04b55ac092d440191f7a00efeaaa3651f048731d6f72c506ada61491ebc7f4665e6e779c7e333edb27062b736d490840868265b3239237dcfb
+  data.tar.gz: c41876eea5064a79bfedacdf6988fcdec61ccc97a87ed078f239a849dcaab06083337e7f243e23782293cbdb427e9e6af071a873c2138b3dd092cc2af0b504a1

data/lib/rrb/io/message.rb

@@ -5,9 +5,11 @@ module RuneRb::IO
   class Message
     include RuneRb::Utils::Logging
 
+    # @!attribute [r] header
     # @return [Struct] the header for the message.
     attr :header
 
+    # @!attribute [r] body
     # @return [Buffer] the access mode for the message.
     attr :body
 
@@ -75,13 +77,19 @@ module RuneRb::IO
     # @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')
+    # @param order [Symbol] 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: {})
+    # @param value [Integer] the value
+    # @param type [Symbol] the type of data to write
+    # @param mutation [Symbol] the mutation that should be applied to the data
+    # @param order [Symbol] the byte order to write  data in
+    # @param options [Hash] options for the write operation.
+    # @return [RuneRb::IO::Message]
+    def write(value, type: :byte, mutation: :STD, order: :BIG, options: {})
       @body.write(value, type: type, mutation: mutation, order: order, options: options)
       update_length
       self

data/lib/rrb/io/native_readable.rb

@@ -5,90 +5,95 @@ module RuneRb::IO
   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.
+    # @param mutation [Symbol] mutation that should be applied to the byte value.
+    # @return [Integer]
     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')
+    # @param mutation [Symbol] mutation that should be applied to the short value
+    # @param order [Symbol] they byte order to read the short value
+    # @return [Integer]
+    def read_short(signed: false, mutation: :STD, order: :BIG)
       val = 0
       case order
-      when 'BIG'
+      when :BIG
         val += mutate(@data.slice!(0..1).unpack1(signed ? 's>' : 'S>'), mutation)
-      when 'LITTLE'
+      when :LITTLE
         val += mutate(@data.slice!(0..1).unpack1(signed ? 's<' : 'S<'), mutation)
-      else read_short(signed: signed, mutation: mutation, order: 'BIG')
+      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')
+    # @param mutation [Symbol] mutation that should be applied to the medium value
+    # @param order [Symbol] they byte order to read the medium value
+    # @return [Integer]
+    def read_medium(signed: false, mutation: :STD, order: :BIG)
       val = 0
       case order
-      when 'BIG'
+      when :BIG
         val += read_byte(signed: signed) << 16
         val += read_byte(signed: signed) << 8
         val += read_byte(signed: signed, mutation: mutation)
-      when 'MIDDLE'
+      when :MIDDLE
         val += read_byte(signed: signed) << 8
         val += read_byte(signed: signed, mutation: mutation)
         val += read_byte(signed: signed) << 16
-      when 'LITTLE'
+      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')
+      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')
+    # @param mutation [Symbol] mutation that should be applied to the integer value
+    # @param order [Symbol] they byte order to read the integer value
+    # @return [Integer]
+    def read_int(signed: false, mutation: :STD, order: :BIG)
       val = 0
       case order
-      when 'BIG'
+      when :BIG
         val += mutate(@data.slice!(0..3).unpack1(signed ? 'i>' : 'I>'), mutation)
-      when 'MIDDLE'
+      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'
+      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'
+      when :LITTLE
         val += mutate(@data.slice!(0..3).unpack1(signed ? 'i<' : 'I<'), mutation)
-      else read_int(signed: signed, mutation: mutation, order: 'BIG')
+      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')
+    # @param mutation [Symbol] mutation that should be applied to the long value
+    # @param order [Symbol] they byte order to read the long value
+    # @return [Integer]
+    def read_long(signed: false, mutation: :STD, order: :BIG)
       case order
-      when 'BIG'
+      when :BIG
         mutate(@data.slice!(0..7).unpack1(signed ? 'q>' : 'Q>'), mutation)
-      when 'LITTLE'
+      when :LITTLE
         mutate(@data.slice!(0..7).unpack1(signed ? 'q<' : 'Q<'), mutation)
-      else read_long(signed: signed, mutation: mutation, order: 'BIG')
+      else read_long(signed: signed, mutation: mutation, order: :BIG)
       end
     end
   end

data/lib/rrb/io/readable.rb

@@ -8,11 +8,10 @@ module RuneRb::IO
     # 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: {})
+    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)
@@ -22,7 +21,7 @@ module RuneRb::IO
       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}"
+      else raise TypeError, "Unrecognized read type! Expected: [byte bytes short medium int long smart string reverse_bytes] | Received: #{type}"
       end
     end
 
@@ -31,6 +30,7 @@ module RuneRb::IO
     # 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.
+    # @return [Array]
     def read_bytes(amount, mutation)
       amount.times.each_with_object([]) { |_idx, arr| arr << read_byte(signed: false, mutation: mutation) }
     end
@@ -38,6 +38,7 @@ module RuneRb::IO
     # Probably did this wrong
     # @param amount [Integer] the amount of bytes to read
     # @param mutation [Symbol] an optional mutation to apply to the result.
+    # @return [Array]
     def read_bytes_reverse(amount, mutation)
       @data.reverse
       value = read_bytes(amount, mutation)
@@ -47,7 +48,8 @@ module RuneRb::IO
 
     # 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.
+    # @param mutation [Symbol] mutation that should be applied to the byte value.
+    # @return [Integer]
     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)
@@ -55,104 +57,110 @@ module RuneRb::IO
 
     # 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')
+    # @param mutation [Symbol] mutation that should be applied to the short value
+    # @param order [Symbol] they byte order to read the short value
+    # @return [Integer]
+    def read_short(signed: false, mutation: :STD, order: :BIG)
       val = 0
       case order
-      when 'BIG'
+      when :BIG
         val += read_byte(signed: signed) << 8
         val += read_byte(mutation: mutation, signed: signed)
-      when 'LITTLE'
+      when :LITTLE
         val += read_byte(mutation: mutation, signed: signed)
         val += read_byte(signed: signed) << 8
-      else read_short(signed: signed, mutation: mutation, order: 'BIG')
+      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')
+    # @param mutation [Symbol] mutation that should be applied to the medium value
+    # @param order [Symbol] they byte order to read the medium value
+    # @return [Integer]
+    def read_medium(signed: false, mutation: :STD, order: :BIG)
       val = 0
       case order
-      when 'BIG'
+      when :BIG
         val += read_byte(signed: signed) << 16
         val += read_byte(signed: signed) << 8
         val += read_byte(signed: signed, mutation: mutation)
-      when 'MIDDLE'
+      when :MIDDLE
         val += read_byte(signed: signed) << 8
         val += read_byte(signed: signed, mutation: mutation)
         val += read_byte(signed: signed) << 16
-      when 'LITTLE'
+      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')
+      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')
+    # @param mutation [Symbol] mutation that should be applied to the integer value
+    # @param order [Symbol] they byte order to read the integer value
+    # @return [Integer]
+    def read_int(signed: false, mutation: :STD, order: :BIG)
       val = 0
       case order
-      when 'BIG'
+      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'
+      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'
+      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'
+      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')
+      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')
+    # @param mutation [Symbol] mutation that should be applied to the long value
+    # @param order [Symbol] they byte order to read the long value
+    # @return [Integer]
+    def read_long(signed: false, mutation: :STD, order: :BIG)
       val = 0
       case order
-      when 'BIG'
+      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'
+      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')
+      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
+    # @param mutation [Symbol] mutation that should be applied to the long value
+    # @return [Integer]
     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
+      if signed
+        val < 128 ? read_byte(mutation: mutation, signed: signed) - 64 : read_short(mutation: mutation, signed: signed, order: :BIG) - 49_152
+      else
+        val < 128 ? read_byte(mutation: mutation, signed: signed) : read_short(mutation: mutation, signed: signed, order: :BIG) - 32_768
       end
     end
 

data/lib/rrb/io/validation.rb

@@ -66,7 +66,7 @@ module RuneRb::IO
       # Validates the byte order to read for the operation
       # @param order [String] the order in which to read bytes in the operation.
       def valid_order?(order)
-        unless RuneRb::IO::BYTE_ORDERS.match?(order)
+        unless RuneRb::IO::BYTE_ORDERS.include?(order)
           err "Unrecognized byte order! #{order}"
           return false
         end

data/lib/rrb/io/writeable.rb

@@ -5,7 +5,11 @@ module RuneRb::IO
     # Write data to the payload.
     # @param type [Symbol] the type of value to write.
     # @param value [Integer, String, Message, Array] the value to write.
-    def write(value, type: :byte, mutation: :STD, order: 'BIG', options: {})
+    # @param mutation [Symbol] mutation that should be applied to the data.
+    # @param order [Symbol] the order to write the data in
+    # @param options [Hash] options for the operation
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
+    def write(value, type: :byte, mutation: :STD, order: :BIG, options: {})
       return unless RuneRb::IO::Validation.validate(self, 'write', { mutation: mutation, order: order })
 
       case type
@@ -29,144 +33,166 @@ module RuneRb::IO
     # Enables or Disables bit writing by setting the {Buffer#bit_access} variable.
     def switch_access
       @bit_access = !@bit_access
+      self
     end
 
+    # Completes bit access.
     def finish_access
       @bit_position = (@bit_position + 7) / 8
       switch_access
+      self
     end
 
     private
 
     # Write a byte value to the payload.
     # @param value [Integer] the byte value to write.
-    # @param mutation [String] mutations made to the byte.
+    # @param mutation [Symbol] mutations made to the byte.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
     def write_byte(value, mutation: :STD)
       @data.concat([mutate(value, mutation)].pack('C'))
+      self
     end
 
     # Write a short value to the payload.
     # @param value [Integer] the short value to write.
-    # @param mutation [String] the type of byte to write.
-    # @param order [String] the order in which bytes will be written.
-    def write_short(value, mutation: :STD, order: 'BIG')
+    # @param mutation [Symbol] the type of byte to write.
+    # @param order [Symbol] the order in which bytes will be written.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
+    def write_short(value, mutation: :STD, order: :BIG)
       case order
-      when 'BIG'
+      when :BIG
         write_byte(value >> 8)
         write_byte(value, mutation: mutation)
-      when 'LITTLE'
+      when :LITTLE
         write_byte(value, mutation: mutation)
         write_byte(value >> 8)
       else raise "Unrecognized bit order: #{order}"
       end
+      self
     end
 
     # Write a medium value to the payload.
     # @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_medium(value, mutation: :STD, order: 'BIG')
+    # @param mutation [Symbol] the mutation made to the byte.
+    # @param order [Symbol] the order in which bytes will be written.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
+    def write_medium(value, mutation: :STD, order: :BIG)
       case order
-      when 'BIG'
+      when :BIG
         write_byte(value >> 16)
         write_byte(value >> 8)
         write_byte(value, mutation: mutation)
-      when 'MIDDLE'
+      when :MIDDLE
         write_byte(value >> 8)
         write_byte(value, mutation: mutation)
         write_byte(value >> 16)
-      when 'LITTLE'
+      when :LITTLE
         write_byte(value, mutation: mutation)
         write_byte(value >> 8)
         write_byte(value >> 16)
       else raise "Unrecognized bit order: #{order}"
       end
+      self
     end
 
     # Write a integer value to the payload.
     # @param value [Integer] the integer value to write.
-    # @param mutation [String] the type of byte to write.
-    # @param order [String] the order in which bytes will be written.
-    def write_int(value, mutation: :STD, order: 'BIG')
+    # @param mutation [Symbol] the type of byte to write.
+    # @param order [Symbol] the order in which bytes will be written.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
+    def write_int(value, mutation: :STD, order: :BIG)
       case order
-      when 'BIG'
+      when :BIG
         write_byte(value >> 24)
         write_byte(value >> 16)
         write_byte(value >> 8)
         write_byte(value, mutation: mutation)
-      when 'MIDDLE'
+      when :MIDDLE
         write_byte(value >> 8)
         write_byte(value, mutation: mutation)
         write_byte(value >> 24)
         write_byte(value >> 16)
-      when 'INVERSE_MIDDLE'
+      when :INVERSE_MIDDLE
         write_byte(value >> 16)
         write_byte(value >> 24)
         write_byte(value, mutation: mutation)
         write_byte(value >> 8)
-      when 'LITTLE'
+      when :LITTLE
         write_byte(value, mutation: mutation)
         write_byte(value >> 8)
         write_byte(value >> 16)
         write_byte(value >> 24)
       else raise "Unrecognized bit order: #{order}"
       end
+      self
     end
 
     # Write a long value to the payload.
     # @param value [Integer] the long value to write.
-    # @param mutation [String] the type of byte to write.
-    # @param order [String] the order in which bytes will be written.
-    def write_long(value, mutation: :STD, order: 'BIG')
+    # @param mutation [Symbol] the type of byte to write.
+    # @param order [Symbol] the order in which bytes will be written.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
+    def write_long(value, mutation: :STD, order: :BIG)
       case order
-      when 'BIG'
+      when :BIG
         (RuneRb::IO::BYTE_SIZE * 7).downto(0) { |div| ((div % 8).zero? and div.positive?) ? write_byte(value >> div) : next }
         write_byte(value, mutation: mutation)
-      when 'LITTLE'
+      when :LITTLE
         write_byte(value, mutation: mutation)
         (0).upto(RuneRb::IO::BYTE_SIZE * 7) { |div| ((div % 8).zero? and div.positive?) ? write_byte(value >> div) : next }
       else raise "Unrecognized bit order: #{order}"
       end
+      self
     end
 
     # Write a string value to the payload. This will be escaped/terminated with a \n[10] value.
     # @param string [String] the byte to write to the payload.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
     def write_string(string)
       @data.concat(string.force_encoding(Encoding::BINARY))
       write_byte(10)
+      self
     end
 
     # Write a 'smart' value to the payload.
     #
     # @param value [Integer] the smart value to write.
-    # @param mutation [String] an optional mutation to apply to the written smart value.
+    # @param mutation [Symbol] an optional mutation to apply to the written smart value.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
     def write_smart(value, mutation: :STD, signed: false)
-      case signed
-      when true
+      if signed
         value > 128 ? write_byte(value, mutation: mutation) + 64 : write_short(value, mutation: mutation) + 49_152
-      when false
+      else
         value > 128 ? write_byte(value, mutation: mutation) : write_short(value, mutation: mutation) + 32_768
       end
+      self
     end
 
     # Writes multiple bytes to the payload.
     # @param values [String, Array, RuneRb::IO::Buffer] the values whose bytes will be written.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
     def write_bytes(values)
       case values
       when Array then values.each { |byte| write_byte(byte.to_i) }
       when RuneRb::IO::Message then @data.concat(values.body.data)
       when RuneRb::IO::Buffer then @data.concat(values.data)
       when String then @data.concat(values)
+      else raise TypeError, "Invalid type for operation! Expecting: [Array, Message, Buffer, String] | Received: #{values.class}"
       end
+      self
     end
 
     # Write a collection of bytes in reverse. *Not sure if I did this right.
     # @param values [Array, String] the values to write.
+    # @return [RuneRb::IO::Message, RuneRb::IO::Writeable]
     def write_reverse_bytes(values)
       case values
       when Array then write(values.reverse, type: :bytes)
       when String then write(values.bytes.reverse, type: :bytes)
+      else raise TypeError, "Invalid type for operation! Expecting: [Array, String] | Received: #{values.class}"
       end
+      self
     end
 
     # Write a single bit with a value of 1 or 0 depending on the flag parameter.

data/lib/rrb/patches/integer.rb

@@ -2,8 +2,10 @@
 module RuneRb::Patches::IntegerRefinements
 
   refine Integer do
+
     # Adjusts the value of the Integer to be unsigned.
     # @param type [Symbol] the type of primitive the value will be returned as
+    # @return [Integer, RuneRb::Patches::IntegerRefinements]
     def unsigned(type)
       return 0 if negative?
 
@@ -20,6 +22,7 @@ module RuneRb::Patches::IntegerRefinements
 
     # Adjusts the value of the Integer to be signed.
     # @param type [Symbol] the type of primitive the value will be returned as
+    # @return [Integer, RuneRb::Patches::IntegerRefinements]
     def signed(type)
       case type
       when :Byte, :byte, :b, :B then adjust(:byte)
@@ -32,11 +35,14 @@ module RuneRb::Patches::IntegerRefinements
 
     alias_method :s, :signed
 
+    # The first 4 bits of the integer.
+    # @return [Integer, RuneRb::Patches::IntegerRefinements]
     def nibble
       adjust(:nibble)
     end
 
     # Returns a string with a formatted representation of the Integer as a timestamp.
+    # @return [String] the formatted time.
     def to_ftime
       mm, ss = divmod(60)
       hh, mm = mm.divmod(60)
@@ -48,6 +54,7 @@ module RuneRb::Patches::IntegerRefinements
 
     # Adjusts the integer based on the passed type
     # @param type [Symbol] the type of adjustment to make to the integer.
+    # @return [Integer, RunRb::Patches::IntegerRefinements]
     def adjust(type)
       case type
       when :Byte, :byte, :b, :B

data/lib/rrb/utils/controller.rb

@@ -12,33 +12,25 @@ module RuneRb::Utils
     using RuneRb::Patches::IntegerRefinements
 
     include RuneRb::Utils::Logging
-
     include Singleton
 
     # @!attribute [r] sessions
     # @return [Hash] a collection of sessions.
     attr :sessions
 
-    # @!attribute [r] servers
-    # @return [Hash] a collection of server objects and signatures.
-    attr :servers
-
-    # @!attribute [r] worlds
-    # @return [Array] a map of World instances.
-    attr :worlds
-
     # Constructs a new Controller object
     def initialize
-      @worlds = {}
       @start = { time: Process.clock_gettime(Process::CLOCK_MONOTONIC), stamp: Time.now }
+      @pids = { gateway: nil, world: nil, controller: Process.pid }
+      super()
     end
 
     def autorun
       # Setup signal trapping
       setup_trapping
 
-      # Deploy server process
-      deploy_server
+      # Deploy gateway process
+      deploy_gateway
 
       # Deploy Game world
       deploy_world
@@ -51,8 +43,9 @@ module RuneRb::Utils
 
     # Logs information about the worlds, servers, and session states.
     def about
-      log COLORS.cyan("[Server]:\n#{@server_pid.nil? ? COLORS.green.bold(@server_pid) : COLORS.red.bold('nil')}")
-      log COLORS.cyan("[World]:\n#{@world_pid.nil? ? COLORS.green.bold(@world_pid) : COLORS.red.bold('nil')}")
+      log COLORS.cyan.bold("[Controller]: #{@pids[:controller]}"),
+          COLORS.magenta.bold("[Server]: #{@pids[:gateway].nil? ? COLORS.red.bold('nil') : COLORS.green.bold(@pids[:gateway])}"),
+          COLORS.yellow.bold("[World]: #{@pids[:world].nil? ? COLORS.red.bold('nil') : COLORS.green.bold(@pids[:world])}")
     end
 
     # Deploy a console session.
@@ -60,25 +53,25 @@ module RuneRb::Utils
       Pry.start(self)
     end
 
-    # Deploys a single TCP Socket Server.
-    # @return [Integer, NilClass] the process ID for the server process.
-    def deploy_server
-      @server_pid ||= Process.fork { RuneRb::Network::Server.instance.autorun }
+    # Construct a singleton instance of the {RuneRb::Network::Gateway} in a forked process.
+    # @return [Integer, NilClass] the process ID for the gateway process.
+    def deploy_gateway
+      # @pids[:gateway] ||= Process.fork { RuneRb::Network::Gateway.instance.autorun }
     end
 
-    # Deploys a single instance of {RuneRb::Game::World::Instance}
-    # @return [Integer, NilClass] the constructed World
+    # Construct a singleton instance of {RuneRb::Game::World::Instance} in a forked process.
+    # @return [Integer, NilClass] the process ID for the world process.
     def deploy_world
-      @world_pid ||= Process.fork { RuneRb::Game::World::Instance.instance }
+      # @pids[:world] ||= Process.fork { RuneRb::Game::World::Instance.instance }
     end
 
     # Stop all server instances and close all connected sessions.
     def shutdown(graceful: true)
       # Kill server process
-      Process.kill(graceful ? 'INT' : 'TERM', @server_pid) unless @server_pid.nil?
+      Process.kill(graceful ? 'INT' : 'TERM', @pids[:gateway]) unless @pids[:gateway].nil?
 
       # Kill World processes
-      Process.kill(graceful ? 'INT' : 'TERM', @world_pid) unless @world_pid.nil?
+      Process.kill(graceful ? 'INT' : 'TERM', @pids[:world]) unless @pids[:world].nil?
 
       # Log up-time
       log! COLORS.blue.bold("Total Controller Up-time: #{up_time.to_i.to_ftime}")

data/lib/rrb.rb

@@ -24,17 +24,18 @@ module RuneRb
   module IO
     # Acceptable byte orders in which multi-byte values can be read.
     # @return [Array] the orders.
-    BYTE_ORDERS = /(?i)\bBIG|MIDDLE|INVERSE_MIDDLE|LITTLE/.freeze
+    BYTE_ORDERS = %i[BIG MIDDLE INVERSE_MIDDLE LITTLE].freeze
 
     # The size of a byte
     # @type [Integer] the size
     BYTE_SIZE = 8
 
     # Valid byte mutations
-    # @return [Hash]
+    # @return [Array]
     BYTE_MUTATIONS = %i[ADD NEG SUB STD].freeze
 
     # Types that can be read.
+    # @return [Array]
     RW_TYPES = %i[bits bit byte bytes medium int long reverse_bytes short smart string].freeze
 
     # Bit masks for bit packing

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rrb
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Patrick W.