unibuf 0.1.1 → 0.1.2

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

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+
+require_relative "../../models/capnproto/schema"
+require_relative "../../models/capnproto/struct_definition"
+require_relative "../../models/capnproto/field_definition"
+require_relative "../../models/capnproto/enum_definition"
+require_relative "../../models/capnproto/interface_definition"
+require_relative "../../models/capnproto/method_definition"
+require_relative "../../models/capnproto/union_definition"
+
+module Unibuf
+  module Parsers
+    module Capnproto
+      # Processor to transform Cap'n Proto AST to Schema models
+      class Processor
+        class << self
+          def process(ast)
+            return Models::Capnproto::Schema.new unless ast
+
+            elements = Array(ast)
+
+            attributes = {
+              file_id: extract_file_id(elements),
+              usings: extract_usings(elements),
+              structs: extract_structs(elements),
+              enums: extract_enums(elements),
+              interfaces: extract_interfaces(elements),
+              constants: extract_constants(elements),
+            }
+
+            Models::Capnproto::Schema.new(attributes)
+          end
+
+          private
+
+          def extract_file_id(elements)
+            file_id_element = elements.find { |el| el.key?(:file_id) }
+            return nil unless file_id_element
+
+            file_id_element[:file_id][:number].to_s
+          end
+
+          def extract_usings(elements)
+            elements.select { |el| el.key?(:using) }.map do |el|
+              {
+                alias: el[:using][:alias][:identifier].to_s,
+                import_path: el[:using][:import_path][:string].to_s,
+              }
+            end
+          end
+
+          def extract_structs(elements)
+            elements.select { |el| el.key?(:struct) }.map do |el|
+              process_struct(el[:struct])
+            end
+          end
+
+          def extract_enums(elements)
+            elements.select { |el| el.key?(:enum) }.map do |el|
+              process_enum(el[:enum])
+            end
+          end
+
+          def extract_interfaces(elements)
+            elements.select { |el| el.key?(:interface) }.map do |el|
+              process_interface(el[:interface])
+            end
+          end
+
+          def extract_constants(elements)
+            elements.select { |el| el.key?(:const) }.map do |el|
+              process_const(el[:const])
+            end
+          end
+
+          def process_struct(struct_data)
+            name = struct_data[:struct_name][:identifier].to_s
+            body = struct_data[:body]
+            annotations = extract_annotations(struct_data[:annotation])
+
+            fields = extract_struct_fields(body)
+            unions = extract_unions(body)
+            groups = extract_groups(body)
+            nested_structs = extract_nested_structs(body)
+            nested_enums = extract_nested_enums(body)
+            nested_interfaces = extract_nested_interfaces(body)
+
+            Models::Capnproto::StructDefinition.new(
+              name: name,
+              fields: fields,
+              unions: unions,
+              groups: groups,
+              nested_structs: nested_structs,
+              nested_enums: nested_enums,
+              nested_interfaces: nested_interfaces,
+              annotations: annotations,
+            )
+          end
+
+          def extract_struct_fields(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:field)
+            end.map do |el|
+              process_field(el[:field])
+            end
+          end
+
+          def extract_unions(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:union)
+            end.map do |el|
+              process_union(el[:union])
+            end
+          end
+
+          def extract_groups(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:group)
+            end.map do |el|
+              process_group(el[:group])
+            end
+          end
+
+          def extract_nested_structs(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:nested_struct)
+            end.map do |el|
+              process_struct(el[:nested_struct])
+            end
+          end
+
+          def extract_nested_enums(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:nested_enum)
+            end.map do |el|
+              process_enum(el[:nested_enum])
+            end
+          end
+
+          def extract_nested_interfaces(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:nested_interface)
+            end.map do |el|
+              process_interface(el[:nested_interface])
+            end
+          end
+
+          def process_field(field_data)
+            name = field_data[:name][:identifier].to_s
+            ordinal = field_data[:ordinal][:number].to_s.to_i
+            type = process_field_type(field_data[:type])
+            default_value = process_default_value(field_data[:default])
+
+            Models::Capnproto::FieldDefinition.new(
+              name: name,
+              ordinal: ordinal,
+              type: type,
+              default_value: default_value,
+            )
+          end
+
+          def process_field_type(type_data)
+            if type_data[:generic]
+              # Generic type: List(T)
+              {
+                generic: "List",
+                element_type: process_field_type(type_data[:generic][:element_type]),
+              }
+            elsif type_data[:primitive_type]
+              type_data[:primitive_type].to_s
+            else
+              type_data[:user_type][:identifier].to_s
+            end
+          end
+
+          def process_default_value(default_data)
+            return nil unless default_data
+
+            if default_data[:number]
+              val = default_data[:number].to_s
+              val.include?(".") ? val.to_f : val.to_i
+            elsif default_data[:bool]
+              default_data[:bool].to_s == "true"
+            elsif default_data[:string]
+              default_data[:string].to_s
+            end
+          end
+
+          def process_union(union_data)
+            fields = extract_struct_fields(union_data[:fields])
+
+            Models::Capnproto::UnionDefinition.new(
+              fields: fields,
+            )
+          end
+
+          def process_group(group_data)
+            name = group_data[:name][:identifier].to_s
+            ordinal = group_data[:ordinal][:number].to_s.to_i
+            fields = extract_struct_fields(group_data[:fields])
+
+            {
+              name: name,
+              ordinal: ordinal,
+              fields: fields.map(&:to_h),
+            }
+          end
+
+          def process_enum(enum_data)
+            name = enum_data[:enum_name][:identifier].to_s
+            annotations = extract_annotations(enum_data[:annotation])
+            values = {}
+
+            Array(enum_data[:values]).each do |val_el|
+              next unless val_el.respond_to?(:key?)
+
+              val_name = val_el[:name][:identifier].to_s
+              val_ordinal = val_el[:ordinal][:number].to_s.to_i
+
+              values[val_name] = val_ordinal
+            end
+
+            Models::Capnproto::EnumDefinition.new(
+              name: name,
+              values: values,
+              annotations: annotations,
+            )
+          end
+
+          def process_interface(interface_data)
+            name = interface_data[:interface_name][:identifier].to_s
+            annotations = extract_annotations(interface_data[:annotation])
+            body = interface_data[:body]
+
+            methods = extract_methods(body)
+
+            Models::Capnproto::InterfaceDefinition.new(
+              name: name,
+              methods: methods,
+              annotations: annotations,
+            )
+          end
+
+          def extract_methods(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:method)
+            end.map do |el|
+              process_method(el[:method])
+            end
+          end
+
+          def process_method(method_data)
+            name = method_data[:name][:identifier].to_s
+            ordinal = method_data[:ordinal][:number].to_s.to_i
+            params = extract_params(method_data[:params])
+            results = extract_params(method_data[:results])
+
+            Models::Capnproto::MethodDefinition.new(
+              name: name,
+              ordinal: ordinal,
+              params: params,
+              results: results,
+            )
+          end
+
+          def extract_params(params_data)
+            return [] unless params_data
+
+            Array(params_data).select do |el|
+              el.respond_to?(:key?) && el.key?(:param)
+            end.map do |el|
+              param = el[:param]
+              {
+                name: param[:name][:identifier].to_s,
+                type: process_field_type(param[:type]),
+              }
+            end
+          end
+
+          def process_const(const_data)
+            {
+              name: const_data[:name][:identifier].to_s,
+              type: process_field_type(const_data[:type]),
+              value: process_const_value(const_data[:value]),
+            }
+          end
+
+          def process_const_value(value_data)
+            if value_data[:number]
+              val = value_data[:number].to_s
+              val.include?(".") ? val.to_f : val.to_i
+            elsif value_data[:bool]
+              value_data[:bool].to_s == "true"
+            elsif value_data[:string]
+              value_data[:string].to_s
+            elsif value_data[:ref]
+              value_data[:ref][:identifier].to_s
+            end
+          end
+
+          def extract_annotations(annotation_data)
+            return [] unless annotation_data
+
+            Array(annotation_data).map do |ann|
+              name = ann[:annotation][:identifier].to_s
+              value = if ann[:value]
+                        process_annotation_value(ann[:value])
+                      else
+                        true
+                      end
+
+              { name: name, value: value }
+            end
+          end
+
+          def process_annotation_value(value_data)
+            if value_data[:number]
+              val = value_data[:number].to_s
+              val.include?(".") ? val.to_f : val.to_i
+            elsif value_data[:bool]
+              value_data[:bool].to_s == "true"
+            elsif value_data[:string]
+              value_data[:string].to_s
+            elsif value_data[:identifier]
+              value_data[:identifier].to_s
+            else
+              value_data.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Parsers
+    module Capnproto
+      # Reader for Cap'n Proto binary segments
+      # Cap'n Proto uses word-aligned (8-byte) segments for memory management
+      class SegmentReader
+        WORD_SIZE = 8 # Cap'n Proto uses 8-byte words
+
+        attr_reader :segments, :segment_count
+
+        # Initialize with binary data
+        # @param data [String] Binary data to read
+        def initialize(data)
+          @data = data
+          @segments = []
+          @segment_count = 0
+          parse_segments
+        end
+
+        # Read a word (8 bytes) from a segment at given offset
+        # @param segment_id [Integer] Segment index
+        # @param word_offset [Integer] Word offset within segment
+        # @return [Integer] 64-bit word value
+        def read_word(segment_id, word_offset)
+          if segment_id >= @segment_count
+            raise ArgumentError,
+                  "Invalid segment ID"
+          end
+          raise ArgumentError, "Invalid word offset" if word_offset.negative?
+
+          segment = @segments[segment_id]
+          byte_offset = word_offset * WORD_SIZE
+
+          if byte_offset + WORD_SIZE > segment.size
+            raise ArgumentError,
+                  "Offset out of bounds"
+          end
+
+          # Read 8 bytes as little-endian 64-bit unsigned integer
+          segment[byte_offset, WORD_SIZE].unpack1("Q<")
+        end
+
+        # Read multiple words from a segment
+        # @param segment_id [Integer] Segment index
+        # @param word_offset [Integer] Starting word offset
+        # @param count [Integer] Number of words to read
+        # @return [Array<Integer>] Array of word values
+        def read_words(segment_id, word_offset, count)
+          (0...count).map { |i| read_word(segment_id, word_offset + i) }
+        end
+
+        # Read bytes from a segment
+        # @param segment_id [Integer] Segment index
+        # @param byte_offset [Integer] Byte offset within segment
+        # @param length [Integer] Number of bytes to read
+        # @return [String] Binary data
+        def read_bytes(segment_id, byte_offset, length)
+          if segment_id >= @segment_count
+            raise ArgumentError,
+                  "Invalid segment ID"
+          end
+
+          segment = @segments[segment_id]
+          if byte_offset + length > segment.size
+            raise ArgumentError,
+                  "Offset out of bounds"
+          end
+
+          segment[byte_offset, length]
+        end
+
+        # Get segment size in words
+        # @param segment_id [Integer] Segment index
+        # @return [Integer] Size in words
+        def segment_size(segment_id)
+          if segment_id >= @segment_count
+            raise ArgumentError,
+                  "Invalid segment ID"
+          end
+
+          @segments[segment_id].size / WORD_SIZE
+        end
+
+        # Check if a segment exists
+        # @param segment_id [Integer] Segment index
+        # @return [Boolean]
+        def segment_exists?(segment_id)
+          segment_id >= 0 && segment_id < @segment_count
+        end
+
+        private
+
+        def parse_segments
+          return if @data.nil? || @data.empty?
+
+          # Read segment count (first 4 bytes as little-endian 32-bit integer)
+          # Segment count: (N + 1) where N is in the first 4 bytes
+          segment_count_minus_one = @data[0, 4].unpack1("L<")
+          @segment_count = segment_count_minus_one + 1
+
+          # Read segment sizes (each is a 4-byte little-endian integer)
+          # Segment sizes start at byte 4
+          offset = 4
+          segment_sizes = []
+
+          @segment_count.times do
+            size = @data[offset, 4].unpack1("L<")
+            segment_sizes << size
+            offset += 4
+          end
+
+          # Align to 8-byte boundary after segment table
+          # Header size is 4 + (segment_count * 4) = 4 * (1 + segment_count)
+          # If segment count is ODD, header is divisible by 8 (no padding needed)
+          # If segment count is EVEN, header needs 4 bytes padding to align to 8
+          offset += 4 unless @segment_count.odd?
+
+          # Read each segment
+          segment_sizes.each do |size_in_words|
+            size_in_bytes = size_in_words * WORD_SIZE
+            segment_data = @data[offset, size_in_bytes]
+            @segments << segment_data
+            offset += size_in_bytes
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require_relative "segment_reader"
+require_relative "pointer_decoder"
+
+module Unibuf
+  module Parsers
+    module Capnproto
+      # Reader for Cap'n Proto struct data
+      # Structs have two sections: data (inline primitives) and pointers
+      class StructReader
+        attr_reader :segment_reader, :segment_id, :word_offset, :data_words,
+                    :pointer_words
+
+        # Initialize struct reader
+        # @param segment_reader [SegmentReader] Segment reader
+        # @param segment_id [Integer] Segment containing the struct
+        # @param word_offset [Integer] Word offset of struct start
+        # @param data_words [Integer] Number of data words
+        # @param pointer_words [Integer] Number of pointer words
+        def initialize(segment_reader, segment_id, word_offset, data_words,
+pointer_words)
+          @segment_reader = segment_reader
+          @segment_id = segment_id
+          @word_offset = word_offset
+          @data_words = data_words
+          @pointer_words = pointer_words
+        end
+
+        # Read a primitive field from data section
+        # @param word_index [Integer] Word index in data section
+        # @param bit_offset [Integer] Bit offset within word (0-63)
+        # @param bit_width [Integer] Width in bits
+        # @return [Integer] Field value
+        def read_data_field(word_index, bit_offset = 0, bit_width = 64)
+          return 0 if word_index >= @data_words
+
+          word = @segment_reader.read_word(@segment_id,
+                                           @word_offset + word_index)
+
+          # Extract bits
+          mask = (1 << bit_width) - 1
+          (word >> bit_offset) & mask
+        end
+
+        # Read an 8-bit integer
+        # @param word_index [Integer] Word index
+        # @param byte_offset [Integer] Byte offset within word (0-7)
+        # @return [Integer]
+        def read_int8(word_index, byte_offset = 0)
+          value = read_data_field(word_index, byte_offset * 8, 8)
+          # Convert to signed
+          value >= 128 ? value - 256 : value
+        end
+
+        # Read an unsigned 8-bit integer
+        # @param word_index [Integer] Word index
+        # @param byte_offset [Integer] Byte offset within word (0-7)
+        # @return [Integer]
+        def read_uint8(word_index, byte_offset = 0)
+          read_data_field(word_index, byte_offset * 8, 8)
+        end
+
+        # Read a 16-bit integer
+        # @param word_index [Integer] Word index
+        # @param half_word_offset [Integer] Half-word offset (0-3)
+        # @return [Integer]
+        def read_int16(word_index, half_word_offset = 0)
+          value = read_data_field(word_index, half_word_offset * 16, 16)
+          # Convert to signed
+          value >= 32768 ? value - 65536 : value
+        end
+
+        # Read an unsigned 16-bit integer
+        # @param word_index [Integer] Word index
+        # @param half_word_offset [Integer] Half-word offset (0-3)
+        # @return [Integer]
+        def read_uint16(word_index, half_word_offset = 0)
+          read_data_field(word_index, half_word_offset * 16, 16)
+        end
+
+        # Read a 32-bit integer
+        # @param word_index [Integer] Word index
+        # @param dword_offset [Integer] Double-word offset (0-1)
+        # @return [Integer]
+        def read_int32(word_index, dword_offset = 0)
+          value = read_data_field(word_index, dword_offset * 32, 32)
+          # Convert to signed
+          value >= 2147483648 ? value - 4294967296 : value
+        end
+
+        # Read an unsigned 32-bit integer
+        # @param word_index [Integer] Word index
+        # @param dword_offset [Integer] Double-word offset (0-1)
+        # @return [Integer]
+        def read_uint32(word_index, dword_offset = 0)
+          read_data_field(word_index, dword_offset * 32, 32)
+        end
+
+        # Read a 64-bit integer
+        # @param word_index [Integer] Word index
+        # @return [Integer]
+        def read_int64(word_index)
+          value = read_data_field(word_index, 0, 64)
+          # Convert to signed
+          value >= 9223372036854775808 ? value - 18446744073709551616 : value
+        end
+
+        # Read an unsigned 64-bit integer
+        # @param word_index [Integer] Word index
+        # @return [Integer]
+        def read_uint64(word_index)
+          read_data_field(word_index, 0, 64)
+        end
+
+        # Read a 32-bit float
+        # @param word_index [Integer] Word index
+        # @param dword_offset [Integer] Double-word offset (0-1)
+        # @return [Float]
+        def read_float32(word_index, dword_offset = 0)
+          bits = read_uint32(word_index, dword_offset)
+          [bits].pack("L").unpack1("f")
+        end
+
+        # Read a 64-bit float
+        # @param word_index [Integer] Word index
+        # @return [Float]
+        def read_float64(word_index)
+          bits = read_uint64(word_index)
+          [bits].pack("Q").unpack1("d")
+        end
+
+        # Read a boolean
+        # @param word_index [Integer] Word index
+        # @param bit_offset [Integer] Bit offset within word
+        # @return [Boolean]
+        def read_bool(word_index, bit_offset = 0)
+          read_data_field(word_index, bit_offset, 1) == 1
+        end
+
+        # Read a pointer from pointer section
+        # @param pointer_index [Integer] Pointer index in pointer section
+        # @return [Hash, nil] Decoded pointer or nil
+        def read_pointer(pointer_index)
+          return nil if pointer_index >= @pointer_words
+
+          pointer_word_offset = @word_offset + @data_words + pointer_index
+          pointer_word = @segment_reader.read_word(@segment_id,
+                                                   pointer_word_offset)
+
+          return nil if pointer_word.zero?
+
+          PointerDecoder.decode(pointer_word)
+        end
+
+        # Follow a pointer to get the target location
+        # @param pointer_index [Integer] Pointer index
+        # @return [Hash, nil] Target location info or nil
+        def follow_pointer(pointer_index)
+          pointer = read_pointer(pointer_index)
+          return nil unless pointer
+          return nil if pointer[:type] == :null
+
+          case pointer[:type]
+          when :struct
+            # Struct pointer points relative to its own position
+            pointer_position = @word_offset + @data_words + pointer_index
+            target_offset = pointer_position + 1 + pointer[:offset]
+            {
+              type: :struct,
+              segment_id: @segment_id,
+              word_offset: target_offset,
+              data_words: pointer[:data_words],
+              pointer_words: pointer[:pointer_words],
+            }
+          when :list
+            # List pointer points relative to its own position
+            pointer_position = @word_offset + @data_words + pointer_index
+            target_offset = pointer_position + 1 + pointer[:offset]
+            {
+              type: :list,
+              segment_id: @segment_id,
+              word_offset: target_offset,
+              element_size: pointer[:element_size],
+              element_count: pointer[:element_count],
+            }
+          when :far
+            # Far pointer points to another segment
+            {
+              type: :far,
+              segment_id: pointer[:segment_id],
+              word_offset: pointer[:offset],
+            }
+          end
+        end
+      end
+    end
+  end
+end