capnp 0.0.1

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

@@ -0,0 +1,62 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+class Capnp::Message
+  extend T::Sig
+  extend T::Helpers
+  abstract!
+
+  sig { abstract.params(id: Integer).returns(Capnp::Segment) }
+  def segment(id)
+  end
+
+  sig { returns(Capnp::Reference) }
+  def root
+    segment(0).to_reference
+  end
+
+  # Takes a reference to a far pointer and returns a reference to the word(s) it targets
+  sig { params(far_pointer_ref: Capnp::Reference).returns(T.nilable([Capnp::Reference, T::Boolean])) }
+  private def dereference_far_pointer(far_pointer_ref)
+    # Grab lower and upper 32 bits of the pointer as signed integers
+    pointer_data = far_pointer_ref.read_bytes(0, Capnp::WORD_SIZE)
+    offset_words, segment_id = T.cast(pointer_data.unpack("L<L<"), [Integer, Integer])
+
+    # Return if the pointer is not a far pointer
+    return nil unless (offset_words & 0b11) == 2
+
+    # Get a reference to the targeted word(s)
+    target_offset = (offset_words >> 3) * Capnp::WORD_SIZE
+    single_far_pointer = (offset_words & 0b100).zero?
+    target_size = single_far_pointer ? 8 : 16
+    segment = segment(segment_id)
+
+    # TODO: Reconsider this check
+    raise Capnp::Error.new("Invalid offset #{target_offset} for segment #{segment_id} in far pointer") if segment.size <= target_offset + target_size
+
+    [segment.to_reference.offset_position(target_offset), single_far_pointer]
+  end
+
+  sig { params(pointer_ref: Capnp::Reference).returns([Capnp::Reference, T.nilable(Capnp::Reference)]) }
+  def dereference_pointer(pointer_ref)
+    target_ref, single_far_pointer = dereference_far_pointer(pointer_ref)
+
+    # Return if the pointer is not a far pointer
+    return pointer_ref, nil if target_ref.nil?
+
+    # Check if the target is a single far pointer
+    # If so, the first word is the new pointer
+    return target_ref, nil if single_far_pointer
+
+    # The first word is a far pointer to a block of content
+    content_ref, single_far_pointer = dereference_far_pointer(target_ref)
+    raise Capnp::Error.new("First word of double far pointer is not a far pointer") if content_ref.nil?
+    raise Capnp::Error.new("Double far pointer pointing to another double far pointer") unless single_far_pointer
+
+    # The second word is the new pointer
+    target_ref = target_ref.offset_position(Capnp::WORD_SIZE)
+    [target_ref, content_ref]
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "message"
+
+class Capnp::StreamMessage < Capnp::Message
+  extend T::Sig
+
+  sig { params(buffer: Capnp::SliceableBuffer).void }
+  def initialize(buffer)
+    # Extract number of segments
+    number_of_segments = buffer.read_u32(0) + 1
+
+    # Calculate size of the message header
+    offset = 4 * (number_of_segments + 1)
+    offset += 4 if number_of_segments.even?
+
+    # Check that the buffer is large enough for all segment sizes
+    raise Capnp::Error.new("Not enough segment sizes provided") if buffer.size <= offset
+
+    # Create segments
+    segments = (1..number_of_segments).map do |ix|
+      # Get segment size in bytes
+      segment_size = buffer.read_u32(ix * 4) * Capnp::WORD_SIZE
+
+      # Check that the buffer is large enough for the segment
+      raise Capnp::Error.new("Buffer smaller than provided segment sizes") if buffer.size < offset + segment_size
+
+      # Create segment
+      slice = buffer.slice(offset, segment_size)
+      segment = Capnp::Segment.new(self, slice)
+
+      offset += segment_size
+      segment
+    end
+
+    @segments = T.let(segments, T::Array[Capnp::Segment])
+  end
+
+  sig { returns(T::Array[Capnp::Segment]) }
+  attr_reader :segments
+
+  sig { override.params(id: Integer).returns(Capnp::Segment) }
+  def segment(id)
+    segment = @segments[id]
+    raise Capnp::Error.new("Unknown Segment ID #{id}") if segment.nil?
+    segment
+  end
+end

data/lib/capnp/runtime/reference.rb

@@ -0,0 +1,100 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "buffer/buffer"
+
+class Capnp::Reference
+  extend T::Sig
+
+  sig { params(segment: Capnp::Segment, position: Integer).void }
+  def initialize(segment, position)
+    @segment = segment
+    @position = position
+  end
+
+  EMPTY = T.let(
+    Capnp::Reference.new(
+      Capnp::FlatMessage.new(Capnp::StringBuffer.new("")).segment(0),
+      0
+    ),
+    Capnp::Reference
+  )
+
+  NULL_POINTER = T.let(
+    Capnp::Reference.new(
+      Capnp::FlatMessage.new(Capnp::StringBuffer.new("\x00\x00\x00\x00\x00\x00\x00\x00")).segment(0),
+      0
+    ),
+    Capnp::Reference
+  )
+
+  sig { returns(Capnp::Segment) }
+  attr_reader :segment
+
+  sig { returns(Integer) }
+  attr_reader :position
+
+  sig { overridable.params(offset: Integer).returns(Capnp::Reference) }
+  def offset_position(offset) = self.class.new(@segment, @position + offset)
+
+  sig { params(offset: Integer, length: Integer).returns(String) }
+  def read_string(offset, length)
+    @segment.read_string(@position + offset, length)
+  end
+
+  sig { params(offset: Integer, length: Integer).returns(String) }
+  def read_bytes(offset, length)
+    @segment.read_bytes(@position + offset, length)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_u8(offset)
+    @segment.read_u8(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_u16(offset)
+    @segment.read_u16(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_u32(offset)
+    @segment.read_u32(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_u64(offset)
+    @segment.read_u64(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_s8(offset)
+    @segment.read_s8(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_s16(offset)
+    @segment.read_s16(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_s32(offset)
+    @segment.read_s32(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Integer) }
+  def read_s64(offset)
+    @segment.read_s64(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Float) }
+  def read_f32(offset)
+    @segment.read_f32(@position + offset)
+  end
+
+  sig { params(offset: Integer).returns(Float) }
+  def read_f64(offset)
+    @segment.read_f64(@position + offset)
+  end
+end

data/lib/capnp/runtime/segment.rb

@@ -0,0 +1,89 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+class Capnp::Segment
+  extend T::Sig
+
+  include Capnp::Buffer
+
+  sig { params(message: Capnp::Message, buffer: Capnp::Buffer).void }
+  def initialize(message, buffer)
+    @message = message
+    @buffer = buffer
+  end
+
+  sig { returns(Capnp::Message) }
+  attr_reader :message
+
+  sig { override.params(offset: Integer, length: Integer).returns(String) }
+  def read_string(offset, length)
+    @buffer.read_string(offset, length)
+  end
+
+  sig { override.params(offset: Integer, length: Integer).returns(String) }
+  def read_bytes(offset, length)
+    @buffer.read_bytes(offset, length)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u8(offset)
+    @buffer.read_u8(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u16(offset)
+    @buffer.read_u16(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u32(offset)
+    @buffer.read_u32(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_u64(offset)
+    @buffer.read_u64(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s8(offset)
+    @buffer.read_s8(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s16(offset)
+    @buffer.read_s16(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s32(offset)
+    @buffer.read_s32(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Integer) }
+  def read_s64(offset)
+    @buffer.read_s64(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Float) }
+  def read_f32(offset)
+    @buffer.read_f32(offset)
+  end
+
+  sig { override.params(offset: Integer).returns(Float) }
+  def read_f64(offset)
+    @buffer.read_f64(offset)
+  end
+
+  sig { override.returns(Integer) }
+  def size
+    @buffer.size
+  end
+
+  sig { returns(Capnp::Reference) }
+  def to_reference
+    Capnp::Reference.new(self, 0)
+  end
+end

data/lib/capnp/runtime/struct.rb

@@ -0,0 +1,159 @@
+# typed: strict
+
+require "sorbet-runtime"
+
+class Capnp::Struct
+  extend T::Sig
+  extend T::Helpers
+
+  abstract!
+
+  sig { params(data: Capnp::Reference, data_size: Integer, pointers: Capnp::Reference, pointers_size: Integer).void }
+  def initialize(data, data_size, pointers, pointers_size)
+    @data = data
+    @data_size = data_size
+    @pointers = pointers
+    @pointers_size = pointers_size
+  end
+
+  sig do
+    params(pointer_ref: Capnp::Reference)
+      .returns([Integer, Integer, Integer])
+  end
+  def self.decode_pointer(pointer_ref)
+    # Fetch pointer data from buffer
+    data = pointer_ref.read_bytes(0, Capnp::WORD_SIZE)
+    parts = T.cast(data.unpack("l<S<S<"), [Integer, Integer, Integer])
+
+    # Check the type of the pointer
+    pointer_type = parts[0] & 0b11
+    raise Capnp::Error.new("Pointer has type #{pointer_type}") unless pointer_type == 0
+
+    # Shift offset to remove type bits
+    parts[0] >>= 2
+
+    parts
+  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)
+
+    # Decode the pointer
+    offset_words, data_words, pointers_words = decode_pointer(pointer_ref)
+
+    # Check for empty struct
+    return new(Capnp::Reference::EMPTY, 0, Capnp::Reference::EMPTY, 0) if offset_words == -1
+
+    # Check for NULL pointer
+    return nil if offset_words.zero? && data_words.zero? && pointers_words.zero?
+
+    # Extract data section
+    data_size = data_words * Capnp::WORD_SIZE
+    if content_ref.nil?
+      data_offset = (offset_words + 1) * Capnp::WORD_SIZE
+      data_ref = pointer_ref.offset_position(data_offset)
+    else
+      data_ref = content_ref
+    end
+
+    # Extract pointers section
+    pointers_size = pointers_words * Capnp::WORD_SIZE
+    pointers_ref = data_ref.offset_position(data_size)
+
+    new(data_ref, data_size, pointers_ref, pointers_size)
+  end
+
+  sig { abstract.returns(Object) }
+  def to_obj
+  end
+
+  private
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_u8(offset, default)
+    (offset >= @data_size) ? default : (@data.read_u8(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_u16(offset, default)
+    (offset >= @data_size) ? default : (@data.read_u16(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_u32(offset, default)
+    (offset >= @data_size) ? default : (@data.read_u32(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_u64(offset, default)
+    (offset >= @data_size) ? default : (@data.read_u64(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_s8(offset, default)
+    (offset >= @data_size) ? default : (@data.read_s8(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_s16(offset, default)
+    (offset >= @data_size) ? default : (@data.read_s16(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_s32(offset, default)
+    (offset >= @data_size) ? default : (@data.read_s32(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Integer).returns(Integer) }
+  def read_s64(offset, default)
+    (offset >= @data_size) ? default : (@data.read_s64(offset) ^ default)
+  end
+
+  sig { params(offset: Integer, default: Float).returns(Float) }
+  def read_f32(offset, default)
+    if offset >= @data_size
+      # The float is not in the data buffer
+      default
+
+    elsif default.zero?
+      # The float is in the data buffer and there is no default value
+      @data.read_f32(offset)
+
+    else
+      # The float is in the data buffer and there is a default value
+      default_int = [default].pack("e").unpack1("L<")
+      value = @data.read_u32(offset)
+      [value ^ default_int].pack("L<").unpack1("e")
+    end
+  end
+
+  sig { params(offset: Integer, default: Float).returns(Float) }
+  def read_f64(offset, default)
+    if offset >= @data_size
+      # The float is not in the data buffer
+      default
+
+    elsif default.zero?
+      # The float is in the data buffer and there is no default value
+      @data.read_f64(offset)
+
+    else
+      # The float is in the data buffer and there is a default value
+      default_int = [default].pack("E").unpack1("Q<")
+      value = @data.read_u64(offset)
+      [value ^ default_int].pack("Q<").unpack1("E")
+    end
+  end
+
+  sig { params(ix: Integer).returns(Capnp::Reference) }
+  def read_pointer(ix)
+    offset = ix * Capnp::WORD_SIZE
+
+    # The pointer is not in the pointer buffer
+    return Capnp::Reference::NULL_POINTER if offset >= @pointers_size
+
+    @pointers.offset_position(offset)
+  end
+end

data/lib/capnp/runtime.rb

@@ -0,0 +1,3 @@
+# typed: strict
+
+Dir.glob(File.join(__dir__, "runtime", "**", "*.rb")) { |file| require file }

data/lib/capnp/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Capnp
+  VERSION = "0.0.1"
+end

data/lib/capnp.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "sorbet-runtime"
+require_relative "capnp/version"
+require_relative "capnp/runtime"
+
+module Capnp
+  extend T::Sig
+
+  WORD_SIZE = 8
+
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,200 @@
+--- !ruby/object:Gem::Specification
+name: capnp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jack Moran
+autorequire:
+bindir: bin
+cert_chain: []
+date: 1980-01-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.22'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-lcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description:
+email:
+- jack@earth.co.nz
+executables:
+- capnpc-ruby
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/capnpc-ruby
+- lib/capnp.rb
+- lib/capnp/generator.rb
+- lib/capnp/generator/generator.rb
+- lib/capnp/generator/schema.capnp.rb
+- lib/capnp/runtime.rb
+- lib/capnp/runtime/buffer/buffer.rb
+- lib/capnp/runtime/buffer/io_buffer.rb
+- lib/capnp/runtime/buffer/sliceable_buffer.rb
+- lib/capnp/runtime/buffer/string_buffer.rb
+- lib/capnp/runtime/list/buffer/data.rb
+- lib/capnp/runtime/list/buffer/list.rb
+- lib/capnp/runtime/list/buffer/numeric.rb
+- lib/capnp/runtime/list/buffer/string.rb
+- lib/capnp/runtime/list/buffer/struct.rb
+- lib/capnp/runtime/list/list.rb
+- lib/capnp/runtime/list/object/list.rb
+- lib/capnp/runtime/list/object/string.rb
+- lib/capnp/runtime/list/string.rb
+- lib/capnp/runtime/message/flat_message.rb
+- lib/capnp/runtime/message/message.rb
+- lib/capnp/runtime/message/stream_message.rb
+- lib/capnp/runtime/reference.rb
+- lib/capnp/runtime/segment.rb
+- lib/capnp/runtime/struct.rb
+- lib/capnp/version.rb
+homepage: https://github.com/jasmoran/capnproto-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/jasmoran/capnproto-ruby
+  source_code_uri: https://github.com/jasmoran/capnproto-ruby
+  changelog_uri: https://github.com/jasmoran/capnproto-ruby/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.22
+signing_key:
+specification_version: 4
+summary: Ruby support for the Cap'n Proto data interchange format
+test_files: []