unibuf 0.1.0 → 0.1.2

data/lib/unibuf/parsers/capnproto/binary_parser.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require_relative "segment_reader"
+require_relative "pointer_decoder"
+require_relative "struct_reader"
+require_relative "list_reader"
+
+module Unibuf
+  module Parsers
+    module Capnproto
+      # Parser for Cap'n Proto binary format
+      # Coordinates segment reading, pointer following, and data extraction
+      class BinaryParser
+        attr_reader :schema, :segment_reader
+
+        # Initialize with schema
+        # @param schema [Models::Capnproto::Schema] Cap'n Proto schema
+        def initialize(schema)
+          @schema = schema
+          @segment_reader = nil
+        end
+
+        # Parse binary data
+        # @param data [String] Binary data
+        # @param root_type [String, nil] Root struct type name
+        # @return [Hash] Parsed data
+        def parse(data, root_type: nil)
+          @segment_reader = SegmentReader.new(data)
+
+          # Root object is at segment 0, word 0
+          # First word is a pointer to the root struct
+          root_pointer_word = @segment_reader.read_word(0, 0)
+          root_pointer = PointerDecoder.decode(root_pointer_word)
+
+          unless root_pointer[:type] == :struct
+            raise ParseError,
+                  "Invalid root pointer"
+          end
+
+          # Follow pointer to root struct
+          root_struct_offset = 1 + root_pointer[:offset]
+          root_struct = StructReader.new(
+            @segment_reader,
+            0,
+            root_struct_offset,
+            root_pointer[:data_words],
+            root_pointer[:pointer_words],
+          )
+
+          # Determine root type from schema if not provided
+          root_type ||= @schema.structs.first&.name
+          raise ParseError, "No root type specified" unless root_type
+
+          struct_def = @schema.find_struct(root_type)
+          unless struct_def
+            raise ParseError,
+                  "Struct type not found: #{root_type}"
+          end
+
+          parse_struct(root_struct, struct_def)
+        end
+
+        private
+
+        # Parse a struct according to its definition
+        # @param struct_reader [StructReader] Struct reader
+        # @param struct_def [Models::Capnproto::StructDefinition] Struct definition
+        # @return [Hash] Parsed data
+        def parse_struct(struct_reader, struct_def)
+          result = {}
+
+          struct_def.fields.each do |field|
+            result[field.name.to_sym] =
+              parse_field(struct_reader, field, struct_def)
+          end
+
+          result
+        end
+
+        # Parse a field
+        # @param struct_reader [StructReader] Struct reader
+        # @param field [Models::Capnproto::FieldDefinition] Field definition
+        # @param struct_def [Models::Capnproto::StructDefinition] Parent struct definition
+        # @return [Object] Field value
+        def parse_field(struct_reader, field, struct_def)
+          if field.primitive_type?
+            parse_primitive_field(struct_reader, field)
+          elsif field.list_type?
+            parse_list_field(struct_reader, field, struct_def)
+          elsif text_or_data_type?(field)
+            parse_text_or_data_field(struct_reader, field, struct_def)
+          elsif field.user_type?
+            parse_user_type_field(struct_reader, field, struct_def)
+          end
+        end
+
+        # Parse a primitive field
+        def parse_primitive_field(struct_reader, field)
+          ordinal = field.ordinal
+          type = field.type
+
+          # Calculate word and offset based on type
+          case type
+          when "Bool"
+            struct_reader.read_bool(ordinal / 64, ordinal % 64)
+          when "Int8"
+            struct_reader.read_int8(ordinal / 8, ordinal % 8)
+          when "UInt8"
+            struct_reader.read_uint8(ordinal / 8, ordinal % 8)
+          when "Int16"
+            struct_reader.read_int16(ordinal / 4, ordinal % 4)
+          when "UInt16"
+            struct_reader.read_uint16(ordinal / 4, ordinal % 4)
+          when "Int32"
+            struct_reader.read_int32(ordinal / 2, ordinal % 2)
+          when "UInt32"
+            struct_reader.read_uint32(ordinal / 2, ordinal % 2)
+          when "Int64"
+            struct_reader.read_int64(ordinal)
+          when "UInt64"
+            struct_reader.read_uint64(ordinal)
+          when "Float32"
+            struct_reader.read_float32(ordinal / 2, ordinal % 2)
+          when "Float64"
+            struct_reader.read_float64(ordinal)
+          when "Void"
+            nil
+          else
+            field.default_value
+          end
+        end
+
+        # Parse a list field
+        def parse_list_field(struct_reader, field, struct_def)
+          # Get pointer index - count non-primitive fields before this one
+          pointer_index = get_pointer_index(field, struct_def)
+
+          target = struct_reader.follow_pointer(pointer_index)
+          return nil unless target && target[:type] == :list
+
+          list_reader = ListReader.new(
+            @segment_reader,
+            target[:segment_id],
+            target[:word_offset],
+            target[:element_size],
+            target[:element_count],
+          )
+
+          element_type = field.element_type
+
+          # Check if element is Text or Data
+          if element_type == "Text"
+            return list_reader.read_text
+          elsif element_type == "Data"
+            return list_reader.read_data
+          end
+
+          # Parse list elements
+          (0...list_reader.length).map do |i|
+            if primitive_type?(element_type)
+              type_symbol = type_to_symbol(element_type)
+              list_reader.read_primitive(i, type_symbol)
+            else
+              # Struct element
+              element_struct_def = @schema.find_struct(element_type)
+              if element_struct_def
+                element_struct = list_reader.read_struct(i)
+                parse_struct(element_struct, element_struct_def)
+              end
+            end
+          end
+        end
+
+        # Parse a user-defined type field (struct, enum, etc.)
+        def parse_user_type_field(struct_reader, field, struct_def)
+          # Check if it's an enum
+          enum_def = @schema.find_enum(field.type)
+          if enum_def
+            # Enums are stored as UInt16 in data section
+            value = struct_reader.read_uint16(field.ordinal / 4,
+                                              field.ordinal % 4)
+            # Find enum name by value
+            enum_def.find_name_by_ordinal(value) || value
+          else
+            # It's a struct - use pointer index
+            pointer_index = get_pointer_index(field, struct_def)
+
+            target = struct_reader.follow_pointer(pointer_index)
+            return nil unless target && target[:type] == :struct
+
+            nested_struct = StructReader.new(
+              @segment_reader,
+              target[:segment_id],
+              target[:word_offset],
+              target[:data_words],
+              target[:pointer_words],
+            )
+
+            nested_struct_def = @schema.find_struct(field.type)
+            return nil unless nested_struct_def
+
+            parse_struct(nested_struct, nested_struct_def)
+          end
+        end
+
+        # Parse Text or Data field (special pointer types)
+        def parse_text_or_data_field(struct_reader, field, struct_def)
+          # Get pointer index
+          pointer_index = get_pointer_index(field, struct_def)
+
+          target = struct_reader.follow_pointer(pointer_index)
+          return nil unless target && target[:type] == :list
+
+          list_reader = ListReader.new(
+            @segment_reader,
+            target[:segment_id],
+            target[:word_offset],
+            target[:element_size],
+            target[:element_count],
+          )
+
+          if field.type == "Text"
+            list_reader.read_text
+          else
+            list_reader.read_data
+          end
+        end
+
+        # Get pointer index for a field
+        # Count non-primitive fields before this one
+        def get_pointer_index(field, struct_def)
+          struct_def.fields.take_while do |f|
+            f != field
+          end.count { |f| !f.primitive_type? }
+        end
+
+        # Check if field is Text or Data type
+        def text_or_data_type?(field)
+          ["Text", "Data"].include?(field.type)
+        end
+
+        # Check if type is primitive
+        def primitive_type?(type)
+          Models::Capnproto::FieldDefinition::PRIMITIVE_TYPES.include?(type)
+        end
+
+        # Convert type string to symbol for list reading
+        def type_to_symbol(type)
+          case type
+          when "Int8" then :int8
+          when "UInt8" then :uint8
+          when "Int16" then :int16
+          when "UInt16" then :uint16
+          when "Int32" then :int32
+          when "UInt32" then :uint32
+          when "Int64" then :int64
+          when "UInt64" then :uint64
+          when "Float32" then :float32
+          when "Float64" then :float64
+          when "Bool" then :bool
+          else :uint64
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unibuf/parsers/capnproto/grammar.rb

@@ -0,0 +1,272 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Unibuf
+  module Parsers
+    module Capnproto
+      # Parslet grammar for parsing Cap'n Proto schema definitions
+      # Reference: https://capnproto.org/language.html
+      class Grammar < Parslet::Parser
+        # ===== Lexical Elements =====
+
+        # Whitespace and comments
+        rule(:space) { match['\s'].repeat(1) }
+        rule(:space?) { space.maybe }
+        rule(:newline) { str("\n") }
+
+        # Comments (# style, different from Proto3)
+        rule(:line_comment) do
+          str("#") >> (newline.absent? >> any).repeat >> newline.maybe
+        end
+        rule(:comment) { line_comment }
+
+        rule(:whitespace) { (space | comment).repeat(1) }
+        rule(:whitespace?) { (space | comment).repeat }
+
+        # Identifiers
+        rule(:letter) { match["a-zA-Z_"] }
+        rule(:digit) { match["0-9"] }
+        rule(:identifier) do
+          (letter >> (letter | digit).repeat).as(:identifier)
+        end
+
+        # Strings
+        rule(:string_content) { (str('"').absent? >> any).repeat }
+        rule(:string_literal) do
+          str('"') >> string_content.as(:string) >> str('"')
+        end
+
+        # Numbers (including hex for file IDs)
+        rule(:hex_digit) { match["0-9a-fA-F"] }
+        rule(:hex_number) do
+          str("0x") >> hex_digit.repeat(1)
+        end
+        rule(:decimal_number) do
+          match["+-"].maybe >> digit.repeat(1) >>
+            (str(".") >> digit.repeat(1)).maybe
+        end
+        rule(:number) { (hex_number | decimal_number).as(:number) }
+
+        # Boolean literals
+        rule(:bool_literal) do
+          (str("true") | str("false")).as(:bool)
+        end
+
+        # ===== File-Level Elements =====
+
+        # File ID: @0x...;
+        rule(:file_id) do
+          str("@") >> hex_number.as(:number) >> whitespace? >> str(";")
+        end
+
+        # using declaration: using Foo = import "foo.capnp";
+        rule(:using_stmt) do
+          str("using") >> whitespace >>
+            identifier.as(:alias) >> whitespace? >>
+            str("=") >> whitespace? >>
+            str("import") >> whitespace >>
+            string_literal.as(:import_path) >> whitespace? >>
+            str(";")
+        end
+
+        # Annotation: $annotation or $annotation(value)
+        rule(:annotation_value) do
+          str("(") >> whitespace? >>
+            (number | bool_literal | string_literal | identifier).as(:value) >>
+            whitespace? >> str(")")
+        end
+
+        rule(:annotation) do
+          str("$") >> identifier.as(:annotation) >>
+            annotation_value.maybe
+        end
+
+        # ===== Type System =====
+
+        # Primitive types
+        rule(:primitive_type) do
+          (str("Void") | str("Bool") |
+           str("Int8") | str("Int16") | str("Int32") | str("Int64") |
+           str("UInt8") | str("UInt16") | str("UInt32") | str("UInt64") |
+           str("Float32") | str("Float64") |
+           str("Text") | str("Data") |
+           str("AnyPointer")).as(:primitive_type)
+        end
+
+        # Generic type: List(T)
+        rule(:generic_type) do
+          str("List") >> whitespace? >>
+            str("(") >> whitespace? >>
+            field_type.as(:element_type) >>
+            whitespace? >> str(")")
+        end
+
+        # Field type
+        rule(:field_type) do
+          generic_type.as(:generic) |
+            primitive_type |
+            identifier.as(:user_type)
+        end
+
+        # ===== Struct Definition =====
+
+        # Field definition: name @ordinal :Type;
+        rule(:field_def) do
+          identifier.as(:name) >> whitespace? >>
+            str("@") >> number.as(:ordinal) >> whitespace? >>
+            str(":") >> whitespace? >>
+            field_type.as(:type) >>
+            (whitespace? >> str("=") >> whitespace? >>
+             (number | bool_literal | string_literal).as(:default)).maybe >>
+            whitespace? >> str(";")
+        end
+
+        # Union within struct: union { field1 @0 :Text; field2 @1 :Int32; }
+        rule(:union_body) do
+          (field_def.as(:field) | whitespace).repeat
+        end
+
+        rule(:union_def) do
+          str("union") >> whitespace? >>
+            str("{") >> whitespace? >>
+            union_body.as(:fields) >> whitespace? >>
+            str("}")
+        end
+
+        # Group: group { field @0 :Text; }
+        rule(:group_body) do
+          (field_def.as(:field) | whitespace).repeat
+        end
+
+        rule(:group_def) do
+          identifier.as(:name) >> whitespace? >>
+            str("@") >> number.as(:ordinal) >> whitespace? >>
+            str(":group") >> whitespace? >>
+            str("{") >> whitespace? >>
+            group_body.as(:fields) >> whitespace? >>
+            str("}")
+        end
+
+        # Struct body
+        rule(:struct_element) do
+          field_def.as(:field) |
+            union_def.as(:union) |
+            group_def.as(:group) |
+            struct_def.as(:nested_struct) |
+            enum_def.as(:nested_enum) |
+            interface_def.as(:nested_interface) |
+            whitespace
+        end
+
+        rule(:struct_body) do
+          struct_element.repeat
+        end
+
+        rule(:struct_def) do
+          (annotation.as(:annotation) >> whitespace?).repeat >>
+            str("struct") >> whitespace >>
+            identifier.as(:struct_name) >> whitespace? >>
+            str("{") >> whitespace? >>
+            struct_body.as(:body) >> whitespace? >>
+            str("}")
+        end
+
+        # ===== Enum Definition =====
+
+        # Enum value: name @ordinal;
+        rule(:enum_value) do
+          identifier.as(:name) >> whitespace? >>
+            str("@") >> number.as(:ordinal) >> whitespace? >>
+            str(";") >> whitespace?
+        end
+
+        rule(:enum_def) do
+          (annotation.as(:annotation) >> whitespace?).repeat >>
+            str("enum") >> whitespace >>
+            identifier.as(:enum_name) >> whitespace? >>
+            str("{") >> whitespace? >>
+            enum_value.repeat(1).as(:values) >> whitespace? >>
+            str("}")
+        end
+
+        # ===== Interface Definition (RPC) =====
+
+        # Method parameter: name :Type
+        rule(:param) do
+          identifier.as(:name) >> whitespace? >>
+            str(":") >> whitespace? >>
+            field_type.as(:type)
+        end
+
+        rule(:param_list) do
+          (param.as(:param) >>
+           (whitespace? >> str(",") >> whitespace? >>
+            param.as(:param)).repeat).maybe
+        end
+
+        # Method definition: methodName @ordinal (params) -> (results);
+        rule(:method_def) do
+          identifier.as(:name) >> whitespace? >>
+            str("@") >> number.as(:ordinal) >> whitespace? >>
+            str("(") >> whitespace? >>
+            param_list.as(:params) >> whitespace? >>
+            str(")") >> whitespace? >>
+            (str("->") >> whitespace? >>
+             str("(") >> whitespace? >>
+             param_list.as(:results) >> whitespace? >>
+             str(")")).maybe >> whitespace? >>
+            str(";")
+        end
+
+        rule(:interface_body) do
+          (method_def.as(:method) | whitespace).repeat
+        end
+
+        rule(:interface_def) do
+          (annotation.as(:annotation) >> whitespace?).repeat >>
+            str("interface") >> whitespace >>
+            identifier.as(:interface_name) >> whitespace? >>
+            str("{") >> whitespace? >>
+            interface_body.as(:body) >> whitespace? >>
+            str("}")
+        end
+
+        # ===== Const Definition =====
+
+        rule(:const_value) do
+          number | bool_literal | string_literal | identifier.as(:ref)
+        end
+
+        rule(:const_def) do
+          str("const") >> whitespace >>
+            identifier.as(:name) >> whitespace? >>
+            str(":") >> whitespace? >>
+            field_type.as(:type) >> whitespace? >>
+            str("=") >> whitespace? >>
+            const_value.as(:value) >> whitespace? >>
+            str(";")
+        end
+
+        # ===== Top-Level Elements =====
+
+        rule(:capnp_element) do
+          file_id.as(:file_id) |
+            using_stmt.as(:using) |
+            const_def.as(:const) |
+            struct_def.as(:struct) |
+            enum_def.as(:enum) |
+            interface_def.as(:interface) |
+            whitespace
+        end
+
+        # Cap'n Proto file
+        rule(:capnp_file) do
+          whitespace? >> capnp_element.repeat >> whitespace?
+        end
+
+        root(:capnp_file)
+      end
+    end
+  end
+end