capnp 0.0.1

data/lib/capnp/generator.rb

@@ -0,0 +1,4 @@
+# typed: strict
+
+require_relative "runtime"
+require_relative "generator/generator"

data/lib/capnp/runtime/buffer/buffer.rb

@@ -0,0 +1,62 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Capnp::Buffer
+  extend T::Sig
+  extend T::Helpers
+  interface!
+
+  sig { abstract.params(offset: Integer, length: Integer).returns(String) }
+  def read_string(offset, length)
+  end
+
+  sig { abstract.params(offset: Integer, length: Integer).returns(String) }
+  def read_bytes(offset, length)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_u8(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_u16(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_u32(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_u64(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_s8(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_s16(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_s32(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Integer) }
+  def read_s64(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Float) }
+  def read_f32(offset)
+  end
+
+  sig { abstract.params(offset: Integer).returns(Float) }
+  def read_f64(offset)
+  end
+
+  sig { abstract.returns(Integer) }
+  def size
+  end
+end

data/lib/capnp/runtime/buffer/io_buffer.rb

@@ -0,0 +1,85 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "sliceable_buffer"
+
+class Capnp::IOBuffer
+  extend T::Sig
+  include Capnp::SliceableBuffer
+
+  sig { params(buffer: IO::Buffer).void }
+  def initialize(buffer)
+    @buffer = buffer
+  end
+
+  sig { override.params(offset: Integer, length: Integer).returns(T.self_type) }
+  def slice(offset, length)
+    self.class.new(@buffer.slice(offset, length))
+  end
+
+  sig { override.params(offset: Integer, length: Integer).returns(String) }
+  def read_string(offset, length)
+    @buffer.get_string(offset, length, Encoding::UTF_8)
+  end
+
+  sig { override.params(offset: Integer, length: Integer).returns(String) }
+  def read_bytes(offset, length)
+    @buffer.get_string(offset, length, Encoding::BINARY)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u8(offset)
+    T.cast(@buffer.get_value(:U8, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u16(offset)
+    T.cast(@buffer.get_value(:u16, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u32(offset)
+    T.cast(@buffer.get_value(:u32, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u64(offset)
+    T.cast(@buffer.get_value(:u64, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s8(offset)
+    T.cast(@buffer.get_value(:S8, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s16(offset)
+    T.cast(@buffer.get_value(:s16, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s32(offset)
+    T.cast(@buffer.get_value(:s32, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s64(offset)
+    T.cast(@buffer.get_value(:s64, offset), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Float) }
+  def read_f32(offset)
+    T.cast(@buffer.get_value(:f32, offset), Float)
+  end
+
+  sig { override.params(offset: Integer).returns(Float) }
+  def read_f64(offset)
+    T.cast(@buffer.get_value(:f64, offset), Float)
+  end
+
+  sig { override.returns(Integer) }
+  def size
+    @buffer.size
+  end
+end

data/lib/capnp/runtime/buffer/sliceable_buffer.rb

@@ -0,0 +1,16 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Capnp::SliceableBuffer
+  extend T::Sig
+  extend T::Helpers
+  interface!
+
+  include Capnp::Buffer
+
+  sig { abstract.params(offset: Integer, length: Integer).returns(T.self_type) }
+  def slice(offset, length)
+  end
+end

data/lib/capnp/runtime/buffer/string_buffer.rb

@@ -0,0 +1,88 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "sliceable_buffer"
+
+class Capnp::StringBuffer
+  extend T::Sig
+
+  include Capnp::SliceableBuffer
+
+  sig { params(buffer: String).void }
+  def initialize(buffer)
+    @buffer = T.let(buffer.encode(Encoding::BINARY), String)
+  end
+
+  sig { override.params(offset: Integer, length: Integer).returns(T.self_type) }
+  def slice(offset, length)
+    self.class.new(read_bytes(offset, length))
+  end
+
+  sig { override.returns(Integer) }
+  def size
+    @buffer.bytesize
+  end
+
+  sig { override.params(offset: Integer, length: Integer).returns(String) }
+  def read_string(offset, length)
+    read_bytes(offset, length).encode!(Encoding::UTF_8)
+  end
+
+  sig { override.params(offset: Integer, length: Integer).returns(String) }
+  def read_bytes(offset, length)
+    slice = @buffer.byteslice(offset, length)
+    raise Capnp::Error.new("Offset+length exceeds data size") if slice.nil? || slice.bytesize != length
+    slice
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u8(offset)
+    T.cast(read_bytes(offset, 1).unpack1("C"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u16(offset)
+    T.cast(read_bytes(offset, 2).unpack1("S<"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u32(offset)
+    T.cast(read_bytes(offset, 4).unpack1("L<"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u64(offset)
+    T.cast(read_bytes(offset, 8).unpack1("Q<"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s8(offset)
+    T.cast(read_bytes(offset, 1).unpack1("c"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s16(offset)
+    T.cast(read_bytes(offset, 2).unpack1("s<"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s32(offset)
+    T.cast(read_bytes(offset, 4).unpack1("l<"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s64(offset)
+    T.cast(read_bytes(offset, 8).unpack1("q<"), Integer)
+  end
+
+  sig { override.params(offset: Integer).returns(Float) }
+  def read_f32(offset)
+    T.cast(read_bytes(offset, 4).unpack1("e"), Float)
+  end
+
+  sig { override.params(offset: Integer).returns(Float) }
+  def read_f64(offset)
+    T.cast(read_bytes(offset, 8).unpack1("E"), Float)
+  end
+end

data/lib/capnp/runtime/list/buffer/data.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "list"
+
+class Capnp::Data < Capnp::BufferList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { returns(String) }
+  def value = @data.read_bytes(0, @length)
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_u8(ix)
+  end
+
+  sig { override.returns(Object) }
+  def to_obj = value
+end

data/lib/capnp/runtime/list/buffer/list.rb

@@ -0,0 +1,100 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "../list"
+
+class Capnp::BufferList
+  include Capnp::List
+  extend T::Sig
+  extend T::Generic
+  extend T::Helpers
+
+  abstract!
+
+  Elem = type_member(:out)
+
+  private_class_method :new
+
+  sig do
+    params(
+      data: Capnp::Reference,
+      length: Integer,
+      element_type: Integer,
+      element_size: Integer,
+      data_words: Integer,
+      pointer_words: Integer
+    ).void
+  end
+  def initialize(data, length, element_type, element_size, data_words, pointer_words)
+    @data = data
+    @length = length
+    @element_type = element_type
+    @element_size = element_size
+    @data_words = data_words
+    @pointer_words = pointer_words
+  end
+
+  sig { params(pointer_ref: Capnp::Reference).returns(T.nilable(T.attached_class)) }
+  def self.from_pointer(pointer_ref)
+    # Process far pointers
+    pointer_ref, content_ref = pointer_ref.segment.message.dereference_pointer(pointer_ref)
+
+    # Grab lower 32 bits as offset and upper 32 bits as size
+    pointer_data = pointer_ref.read_bytes(0, Capnp::WORD_SIZE)
+    offset_part, size_part = T.cast(pointer_data.unpack("l<L<"), [Integer, Integer])
+
+    # Check for NULL pointer
+    return nil if offset_part.zero? && size_part.zero?
+
+    # Check this is a list pointer
+    pointer_type = offset_part & 0b11
+    raise Capnp::Error.new("List pointer has type #{pointer_type}") unless pointer_type == 1
+
+    # Determine the length of the list
+    length = size_part >> 3
+
+    # Determine the size of the data section and individual elements
+    element_type = size_part & 0b111
+    element_size = case element_type
+    # Void type elements
+    when 0 then 0
+    # Bit type elements
+    when 1 then 1
+    # Integer type elements
+    when 2, 3, 4, 5 then 1 << (element_type - 2)
+    # Pointer type elements
+    when 6 then Capnp::WORD_SIZE
+    # Composite type elements
+    else
+      0 # (Set below)
+    end
+
+    # Extract data section
+    if content_ref.nil?
+      data_offset = ((offset_part >> 2) + 1) * Capnp::WORD_SIZE
+      data_ref = pointer_ref.offset_position(data_offset)
+    else
+      data_ref = content_ref
+    end
+
+    # Fetch tag for composite type elements
+    data_words = 0
+    pointers_words = 0
+    if element_type == 7
+      # Decode tag as a struct pointer
+      length, data_words, pointers_words = Capnp::Struct.decode_pointer(data_ref)
+      data_ref = data_ref.offset_position(Capnp::WORD_SIZE)
+
+      # Calculate element size
+      element_size = (data_words + pointers_words) * Capnp::WORD_SIZE
+    end
+
+    new(data_ref, length, element_type, element_size, data_words, pointers_words)
+  end
+
+  sig { override.returns(Integer) }
+  attr_reader :length
+
+  sig { returns(Integer) }
+  attr_reader :element_type
+end

data/lib/capnp/runtime/list/buffer/numeric.rb

@@ -0,0 +1,103 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "list"
+
+class Capnp::NumericList < Capnp::BufferList
+  abstract!
+
+  Elem = type_member(:out)
+
+  sig { override.returns(Object) }
+  def to_obj = to_a
+end
+
+class Capnp::U8List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_u8(ix)
+  end
+end
+
+class Capnp::U16List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_u16(ix * 2)
+  end
+end
+
+class Capnp::U32List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_u32(ix * 4)
+  end
+end
+
+class Capnp::U64List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_u64(ix * 8)
+  end
+end
+
+class Capnp::S8List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_s8(ix)
+  end
+end
+
+class Capnp::S16List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_s16(ix * 2)
+  end
+end
+
+class Capnp::S32List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_s32(ix * 4)
+  end
+end
+
+class Capnp::S64List < Capnp::NumericList
+  Elem = type_member { {fixed: Integer} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_s64(ix * 8)
+  end
+end
+
+class Capnp::F32List < Capnp::NumericList
+  Elem = type_member { {fixed: Float} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_f32(ix * 4)
+  end
+end
+
+class Capnp::F64List < Capnp::NumericList
+  Elem = type_member { {fixed: Float} }
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_f64(ix * 8)
+  end
+end

data/lib/capnp/runtime/list/buffer/string.rb

@@ -0,0 +1,19 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "list"
+require_relative "../string"
+
+class Capnp::BufferString < Capnp::BufferList
+  include Capnp::String
+
+  Elem = type_member { {fixed: String} }
+
+  sig { override.returns(String) }
+  def to_s = @data.read_string(0, @length - 1)
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    @data.read_string(ix, 1)
+  end
+end

data/lib/capnp/runtime/list/buffer/struct.rb

@@ -0,0 +1,47 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "list"
+
+class Capnp::StructList < Capnp::BufferList
+  abstract!
+
+  Elem = type_member { {upper: Capnp::Struct} }
+
+  sig { abstract.returns(T::Class[Elem]) }
+  def element_class
+  end
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+    case @element_type
+      # Void type elements
+    when 0 then element_class.new(Capnp::Reference::EMPTY, 0, Capnp::Reference::EMPTY, 0)
+
+      # Bit type elements
+    when 1 then raise "Bit lists may not be decoded as structs"
+
+      # Integer type elements
+    when 2, 3, 4, 5
+      data_offset = ix * @element_size
+      element_class.new(@data.offset_position(data_offset), @element_size, Capnp::Reference::EMPTY, 0)
+
+      # Pointer type elements
+    when 6
+      data_offset = ix * @element_size
+      element_class.new(Capnp::Reference::EMPTY, 0, @data.offset_position(data_offset), @element_size)
+
+      # Composite type elements
+    else
+      data_offset = ix * @element_size
+      data_size = @data_words * Capnp::WORD_SIZE
+      data_ref = @data.offset_position(data_offset)
+      pointers_size = @pointer_words * Capnp::WORD_SIZE
+      pointers_ref = @data.offset_position(data_offset + data_size)
+      element_class.new(data_ref, data_size, pointers_ref, pointers_size)
+    end
+  end
+
+  sig { override.returns(Object) }
+  def to_obj = map(&:to_obj)
+end

data/lib/capnp/runtime/list/list.rb

@@ -0,0 +1,42 @@
+# typed: strict
+
+require "sorbet-runtime"
+
+module Capnp::List
+  include Kernel
+  include Enumerable
+  extend T::Sig
+  extend T::Generic
+  extend T::Helpers
+
+  abstract!
+
+  Elem = type_member(:out)
+
+  sig { abstract.returns(Integer) }
+  def length
+  end
+
+  # Get a single element at the given index
+  # THE INDEX MUST BE IN RANGE.
+  sig { abstract.params(ix: Integer).returns(Elem) }
+  private def get(ix)
+  end
+
+  sig { params(ix: Integer).returns(T.nilable(Elem)) }
+  def [](ix)
+    return if ix < 0 || ix >= length
+    get(ix)
+  end
+
+  sig { override.params(blk: T.proc.params(arg0: Elem).returns(BasicObject)).void }
+  def each(&blk)
+    length.times do |ix|
+      blk.call(get(ix))
+    end
+  end
+
+  sig { abstract.returns(Object) }
+  def to_obj
+  end
+end

data/lib/capnp/runtime/list/object/list.rb

@@ -0,0 +1,26 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "../list"
+
+class Capnp::ObjectList
+  include Capnp::List
+  extend T::Sig
+  extend T::Generic
+
+  Elem = type_member(:out)
+
+  sig { params(array: T::Array[Elem]).void }
+  def initialize(array)
+    @array = array
+  end
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix) = @array.fetch(ix)
+
+  sig { override.returns(Integer) }
+  def length = @array.length
+
+  sig { override.returns(Object) }
+  def to_obj = @array
+end

data/lib/capnp/runtime/list/object/string.rb

@@ -0,0 +1,26 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "../string"
+
+class Capnp::ObjectString
+  include Capnp::String
+  extend T::Sig
+  extend T::Generic
+
+  Elem = type_member { {fixed: String} }
+
+  sig { params(string: String).void }
+  def initialize(string)
+    @string = T.let(string.freeze, String)
+  end
+
+  sig { override.returns(String) }
+  def to_s = @string
+
+  sig { override.params(ix: Integer).returns(Elem) }
+  private def get(ix) = T.must(@string[ix])
+
+  sig { override.returns(Integer) }
+  def length = @string.length
+end

data/lib/capnp/runtime/list/string.rb

@@ -0,0 +1,22 @@
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "list"
+
+module Capnp::String
+  include Capnp::List
+  extend T::Sig
+  extend T::Generic
+  extend T::Helpers
+
+  abstract!
+
+  Elem = type_member { {fixed: String} }
+
+  sig { abstract.returns(String) }
+  def to_s
+  end
+
+  sig { override.returns(Object) }
+  def to_obj = to_s
+end

data/lib/capnp/runtime/message/flat_message.rb

@@ -0,0 +1,21 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "message"
+require_relative "../segment"
+
+class Capnp::FlatMessage < Capnp::Message
+  extend T::Sig
+
+  sig { params(segment: Capnp::Buffer).void }
+  def initialize(segment)
+    @segment = T.let(Capnp::Segment.new(self, segment), Capnp::Segment)
+  end
+
+  sig { override.params(id: Integer).returns(Capnp::Segment) }
+  def segment(id)
+    raise Capnp::Error.new("Unknown Segment ID #{id}") unless id.zero?
+    @segment
+  end
+end