roblox-opencode 1.0.0

package/vendor/rbxutil/buffer-util/Buffer.test.luau

@@ -0,0 +1,25 @@
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local Test = require(ServerScriptService.TestRunner.Test)
+
+-- local BufferReader = require(script.Parent.BufferReader)
+-- local BufferWriter = require(script.Parent.BufferWriter)
+
+return function(ctx: Test.TestContext)
+	ctx:Describe("Some test", function()
+		ctx:Test("1 + 1 == 2", function()
+			ctx:Expect(1 + 1):ToBe(2)
+		end)
+		ctx:Test("1 + 1 != 3", function()
+			ctx:Expect(1 + 1):Not():ToBe(3)
+		end)
+		ctx:Describe("Nested group", function()
+			ctx:Test("true == true", function()
+				ctx:Expect(true):ToBe(true)
+				ctx:Expect(function()
+					return 32
+				end):ToBe(32)
+			end)
+		end)
+	end)
+end

package/vendor/rbxutil/buffer-util/BufferReader.luau

@@ -0,0 +1,228 @@
+--!native
+
+local BufferWriter = require(script.Parent.BufferWriter)
+local DataTypeBuffer = require(script.Parent.DataTypeBuffer)
+local Types = require(script.Parent.Types)
+
+--[=[
+	@class BufferReader
+	
+	A BufferReader is an abstraction wrapper for `buffer` objects
+	that provides a convenient way of reading out data from buffers.
+]=]
+local BufferReader = {}
+BufferReader.__index = BufferReader
+
+function BufferReader.new(buf: string | buffer | Types.BufferWriter): Types.BufferReader
+	if typeof(buf) == "string" then
+		return BufferReader.fromString(buf)
+	elseif typeof(buf) == "buffer" then
+		return BufferReader.fromBuffer(buf)
+	elseif typeof(buf) == "table" and getmetatable(buf :: any) == BufferWriter then
+		return BufferReader.fromBuffer(buf:GetBuffer())
+	end
+
+	error(`expected string or buffer; got {typeof(buf)}`)
+end
+
+function BufferReader.fromBuffer(buf: buffer)
+	local self = setmetatable({
+		_buffer = buf,
+		_size = buffer.len(buf),
+		_cursor = 0,
+	}, BufferReader)
+
+	return self
+end
+
+function BufferReader.fromString(str: string)
+	return BufferReader.fromBuffer(buffer.fromstring(str))
+end
+
+function BufferReader:_assertSize(desiredSize: number)
+	if desiredSize > self._size then
+		error(`cursor out of bounds`, 3)
+	end
+end
+
+--[=[
+	Read a signed 8-bit integer from the buffer.
+]=]
+function BufferReader:ReadInt8(): number
+	self:_assertSize(self._cursor + 1)
+	local n = buffer.readi8(self._buffer, self._cursor)
+	self._cursor += 1
+	return n
+end
+
+--[=[
+	Read an unsigned 8-bit integer from the buffer.
+]=]
+function BufferReader:ReadUInt8(): number
+	self:_assertSize(self._cursor + 1)
+	local n = buffer.readu8(self._buffer, self._cursor)
+	self._cursor += 1
+	return n
+end
+
+--[=[
+	Read a signed 16-bit integer from the buffer.
+]=]
+function BufferReader:ReadInt16(): number
+	self:_assertSize(self._cursor + 2)
+	local n = buffer.readi16(self._buffer, self._cursor)
+	self._cursor += 2
+	return n
+end
+
+--[=[
+	Read an unsigned 16-bit integer from the buffer.
+]=]
+function BufferReader:ReadUInt16(): number
+	self:_assertSize(self._cursor + 2)
+	local n = buffer.readu16(self._buffer, self._cursor)
+	self._cursor += 2
+	return n
+end
+
+--[=[
+	Read a signed 32-bit integer from the buffer.
+]=]
+function BufferReader:ReadInt32(): number
+	self:_assertSize(self._cursor + 4)
+	local n = buffer.readi32(self._buffer, self._cursor)
+	self._cursor += 4
+	return n
+end
+
+--[=[
+	Read an unsigned 32-bit integer from the buffer.
+]=]
+function BufferReader:ReadUInt32(): number
+	self:_assertSize(self._cursor + 4)
+	local n = buffer.readu32(self._buffer, self._cursor)
+	self._cursor += 4
+	return n
+end
+
+--[=[
+	Read a 32-bit single-precision float from the buffer.
+]=]
+function BufferReader:ReadFloat32(): number
+	self:_assertSize(self._cursor + 4)
+	local n = buffer.readf32(self._buffer, self._cursor)
+	self._cursor += 4
+	return n
+end
+
+--[=[
+	Read a 64-bit double-precision float from the buffer.
+]=]
+function BufferReader:ReadFloat64(): number
+	self:_assertSize(self._cursor + 8)
+	local n = buffer.readf64(self._buffer, self._cursor)
+	self._cursor += 8
+	return n
+end
+
+--[=[
+	Read a boolean from the buffer.
+]=]
+function BufferReader:ReadBool(): boolean
+	local n = self:ReadUInt8()
+	return n == 1
+end
+
+--[=[
+	Read a string from the buffer.
+	
+	:::info
+	This assumes the string was written using the `BufferWriter:WriteString()`
+	method, which stores an extra integer to mark the size of the string.
+	:::
+]=]
+function BufferReader:ReadString(): string
+	local strLen = self:ReadUInt32()
+	self:_assertSize(self._cursor + strLen)
+	local s = buffer.readstring(self._buffer, self._cursor, strLen)
+	self._cursor += strLen
+	return s
+end
+
+--[=[
+	Read a string from the buffer.
+	
+	:::info
+	This assumes the string was written using the `BufferWriter:WriteStringRaw()`.
+	:::
+]=]
+function BufferReader:ReadStringRaw(length: number): string
+	length = math.max(0, math.floor(length))
+	self:_assertSize(self._cursor + length)
+	local s = buffer.readstring(self._buffer, self._cursor, length)
+	self._cursor += length
+	return s
+end
+
+--[=[
+	Read a DataType from the buffer.
+
+	```lua
+	local cframe = reader:ReadDataType(CFrame)
+	```
+]=]
+function BufferReader:ReadDataType<T>(dataType: T): T
+	local name = DataTypeBuffer.DataTypesToString[dataType]
+	if not name then
+		error("unsupported data type", 2)
+	end
+
+	local readWrite = DataTypeBuffer.ReadWrite[name]
+	return readWrite.read(self)
+end
+
+--[=[
+	Sets the position of the cursor.
+]=]
+function BufferReader:SetCursor(position: number)
+	position = math.floor(position)
+	if position < 0 or position > self._size then
+		error(`cursor position {position} out of range [0, {self._size}]`, 3)
+	end
+
+	self._cursor = position
+end
+
+--[=[
+	Returns the position of the cursor.
+]=]
+function BufferReader:GetCursor(): number
+	return self._cursor
+end
+
+--[=[
+	Resets the position of the cursor.
+]=]
+function BufferReader:ResetCursor()
+	self._cursor = 0
+end
+
+--[=[
+	Returns the size of the buffer.
+]=]
+function BufferReader:GetSize(): number
+	return self._size
+end
+
+--[=[
+	Returns the `buffer` object.
+]=]
+function BufferReader:GetBuffer(): buffer
+	return self._buffer
+end
+
+function BufferReader:__tostring()
+	return "BufferReader"
+end
+
+return BufferReader

package/vendor/rbxutil/buffer-util/BufferWriter.luau

@@ -0,0 +1,269 @@
+--!native
+
+local MAX_SIZE = 1073741824
+
+local DataTypeBuffer = require(script.Parent.DataTypeBuffer)
+local Types = require(script.Parent.Types)
+
+--[=[
+	@class BufferWriter
+	
+	A BufferWriter is an abstraction wrapper for `buffer` objects
+	that provides a convenient way of writing data to buffers.
+
+	The internal buffer is automatically resized to fit the data
+	that is being written.
+]=]
+local BufferWriter = {}
+BufferWriter.__index = BufferWriter
+
+function BufferWriter.new(initialSize: number?): Types.BufferWriter
+	local size = if typeof(initialSize) == "number" then math.clamp(initialSize, 0, MAX_SIZE) else 0
+
+	local self = setmetatable({
+		_buffer = buffer.create(size),
+		_cursor = 0,
+		_size = 0,
+	}, BufferWriter)
+
+	return self
+end
+
+function BufferWriter:_resizeUpTo(desiredSize: number)
+	if desiredSize > MAX_SIZE then
+		error(`cannot resize buffer to {desiredSize} bytes (max size: {MAX_SIZE} bytes)`, 3)
+	end
+
+	self._size = math.max(self._size, desiredSize)
+
+	if desiredSize <= buffer.len(self._buffer) then
+		return
+	end
+
+	local newSize = desiredSize
+
+	local powerOfTwo = math.log(desiredSize, 2)
+	if math.floor(powerOfTwo) ~= powerOfTwo then
+		newSize = 2 ^ (math.floor(powerOfTwo) + 1)
+	end
+
+	local oldBuffer = self._buffer
+	local newBuffer = buffer.create(newSize)
+
+	buffer.copy(newBuffer, 0, oldBuffer, 0)
+
+	self._buffer = newBuffer
+end
+
+--[=[
+	Write a signed 8-bit integer to the buffer.
+]=]
+function BufferWriter:WriteInt8(int8: number)
+	self:_resizeUpTo(self._cursor + 1)
+	buffer.writei8(self._buffer, self._cursor, int8)
+	self._cursor += 1
+end
+
+--[=[
+	Write an unsigned 8-bit integer to the buffer.
+]=]
+function BufferWriter:WriteUInt8(uint8: number)
+	self:_resizeUpTo(self._cursor + 1)
+	buffer.writeu8(self._buffer, self._cursor, uint8)
+	self._cursor += 1
+end
+
+--[=[
+	Write a signed 16-bit integer to the buffer.
+]=]
+function BufferWriter:WriteInt16(int16: number)
+	self:_resizeUpTo(self._cursor + 2)
+	buffer.writei16(self._buffer, self._cursor, int16)
+	self._cursor += 2
+end
+
+--[=[
+	Write an unsigned 16-bit integer to the buffer.
+]=]
+function BufferWriter:WriteUInt16(uint16: number)
+	self:_resizeUpTo(self._cursor + 2)
+	buffer.writeu16(self._buffer, self._cursor, uint16)
+	self._cursor += 2
+end
+
+--[=[
+	Write a signed 32-bit integer to the buffer.
+]=]
+function BufferWriter:WriteInt32(int32: number)
+	self:_resizeUpTo(self._cursor + 4)
+	buffer.writei32(self._buffer, self._cursor, int32)
+	self._cursor += 4
+end
+
+--[=[
+	Write an unsigned 32-bit integer to the buffer.
+]=]
+function BufferWriter:WriteUInt32(uint32: number)
+	self:_resizeUpTo(self._cursor + 4)
+	buffer.writeu32(self._buffer, self._cursor, uint32)
+	self._cursor += 4
+end
+
+--[=[
+	Write a 32-bit single-precision float to the buffer.
+]=]
+function BufferWriter:WriteFloat32(f32: number)
+	self:_resizeUpTo(self._cursor + 4)
+	buffer.writef32(self._buffer, self._cursor, f32)
+	self._cursor += 4
+end
+
+--[=[
+	Write a 64-bit double-precision float to the buffer.
+]=]
+function BufferWriter:WriteFloat64(f64: number)
+	self:_resizeUpTo(self._cursor + 8)
+	buffer.writef64(self._buffer, self._cursor, f64)
+	self._cursor += 8
+end
+
+--[=[
+	Write a boolean to the buffer.
+]=]
+function BufferWriter:WriteBool(bool: boolean)
+	self:WriteUInt8(if bool then 1 else 0)
+end
+
+--[=[
+	Write a string to the buffer. An optional `length` argument can
+	be provided to limit the number of bytes read from the string.
+
+	:::info
+	An extra 32-bit integer is stored before the string to mark the
+	length of the string. If the length of the string is always
+	known, it is more memory-efficient to use `WriteStringRaw`.
+	:::
+]=]
+function BufferWriter:WriteString(str: string, length: number?)
+	local len = if length then math.min(#str, length) else #str
+	local size = len + 4
+	self:_resizeUpTo(self._cursor + size)
+	buffer.writeu32(self._buffer, self._cursor, len)
+	buffer.writestring(self._buffer, self._cursor + 4, str, length)
+	self._cursor += size
+end
+
+--[=[
+	Write a string to the buffer. An optional `length` argument can
+	be provided to limit the number of bytes read from the string.
+
+	:::info
+	The length of the string must be known to the reader in order to
+	read this string from the buffer, as the length of the string is
+	not stored in the buffer. For strings of dynamic/unknown length,
+	use `WriteString` instead.
+	:::
+]=]
+function BufferWriter:WriteStringRaw(str: string, length: number?)
+	local len = if length then math.min(#str, length) else #str
+	self:_resizeUpTo(self._cursor + len)
+	buffer.writestring(self._buffer, self._cursor, str, length)
+	self._cursor += len
+end
+
+--[=[
+	Write a DataType to the buffer.
+
+	```lua
+	writer:WriteDataType(CFrame.new(0, 10, 5))
+	```
+]=]
+function BufferWriter:WriteDataType(value: any)
+	local t = typeof(value)
+	local readWrite = DataTypeBuffer.ReadWrite[t]
+	if not readWrite then
+		error(`unsupported data type "{t}"`, 2)
+	end
+	readWrite.write(self, value)
+end
+
+--[=[
+	Shrinks the capacity of the buffer to the current data size.
+]=]
+function BufferWriter:Shrink()
+	if self._size == buffer.len(self._buffer) then
+		return
+	end
+
+	local oldBuffer = self._buffer
+	local newBuffer = buffer.create(self._size)
+
+	buffer.copy(newBuffer, 0, oldBuffer, 0, self._size)
+
+	self._buffer = newBuffer
+end
+
+--[=[
+	Returns the current data size of the buffer. This is _not_ necessarily
+	equal to the capacity of the buffer.
+]=]
+function BufferWriter:GetSize(): number
+	return self._size
+end
+
+--[=[
+	Returns the current capacity of the buffer. This is the length of the
+	internal buffer, which is usually not the same as the length of the stored
+	data.
+
+	The buffer capacity automatically grows as data is added.
+]=]
+function BufferWriter:GetCapacity(): number
+	return buffer.len(self._buffer)
+end
+
+--[=[
+	Sets the position of the cursor.
+]=]
+function BufferWriter:SetCursor(position: number)
+	position = math.floor(position)
+	if position < 0 or position > self._size then
+		error(`cursor position {position} out of range [0, {self._size}]`, 3)
+	end
+
+	self._cursor = position
+end
+
+--[=[
+	Gets the position of the cursor.
+]=]
+function BufferWriter:GetCursor(): number
+	return self._cursor
+end
+
+--[=[
+	Resets the position of the cursor.
+]=]
+function BufferWriter:ResetCursor()
+	self._cursor = 0
+end
+
+--[=[
+	Returns the `buffer` object.
+]=]
+function BufferWriter:GetBuffer(): buffer
+	return self._buffer
+end
+
+--[=[
+	Returns the string version of the internal buffer.
+]=]
+function BufferWriter:ToString(): string
+	return buffer.tostring(self._buffer)
+end
+
+function BufferWriter:__tostring()
+	return "BufferWriter"
+end
+
+return BufferWriter