unibuf 0.1.0 → 0.1.2

data/lib/unibuf/models/flatbuffers/schema.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Flatbuffers
+      # Represents a FlatBuffers schema (.fbs file)
+      class Schema
+        attr_reader :namespace, :includes, :tables, :structs, :enums, :unions,
+                    :root_type, :file_identifier, :file_extension, :attributes
+
+        def initialize(attributes = {})
+          @namespace = attributes[:namespace] || attributes["namespace"]
+          @includes = Array(attributes[:includes] || attributes["includes"])
+          @tables = Array(attributes[:tables] || attributes["tables"])
+          @structs = Array(attributes[:structs] || attributes["structs"])
+          @enums = Array(attributes[:enums] || attributes["enums"])
+          @unions = Array(attributes[:unions] || attributes["unions"])
+          @root_type = attributes[:root_type] || attributes["root_type"]
+          @file_identifier = attributes[:file_identifier] || attributes["file_identifier"]
+          @file_extension = attributes[:file_extension] || attributes["file_extension"]
+          @attributes = Array(attributes[:attributes] || attributes["attributes"])
+        end
+
+        # Queries
+        def find_table(name)
+          tables.find { |t| t.name == name }
+        end
+
+        def find_struct(name)
+          structs.find { |s| s.name == name }
+        end
+
+        def find_enum(name)
+          enums.find { |e| e.name == name }
+        end
+
+        def find_union(name)
+          unions.find { |u| u.name == name }
+        end
+
+        def find_type(name)
+          find_table(name) || find_struct(name) || find_enum(name) || find_union(name)
+        end
+
+        def table_names
+          tables.map(&:name)
+        end
+
+        def struct_names
+          structs.map(&:name)
+        end
+
+        def enum_names
+          enums.map(&:name)
+        end
+
+        def union_names
+          unions.map(&:name)
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Root type required" unless root_type
+
+          unless find_table(root_type)
+            raise ValidationError,
+                  "Root type '#{root_type}' not found"
+          end
+
+          tables.each(&:validate!)
+          structs.each(&:validate!)
+          enums.each(&:validate!)
+          unions.each(&:validate!)
+
+          true
+        end
+
+        def to_h
+          {
+            namespace: namespace,
+            includes: includes,
+            tables: tables.map(&:to_h),
+            structs: structs.map(&:to_h),
+            enums: enums.map(&:to_h),
+            unions: unions.map(&:to_h),
+            root_type: root_type,
+            file_identifier: file_identifier,
+            file_extension: file_extension,
+            attributes: attributes,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/unibuf/models/flatbuffers/struct_definition.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Flatbuffers
+      # Represents a FlatBuffers struct definition
+      # Structs are fixed-size, stored inline (no vtable)
+      class StructDefinition
+        attr_reader :name, :fields, :metadata
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @fields = Array(attributes[:fields] || attributes["fields"])
+          @metadata = attributes[:metadata] || attributes["metadata"] || {}
+        end
+
+        # Queries
+        def find_field(field_name)
+          fields.find { |f| f.name == field_name }
+        end
+
+        def field_names
+          fields.map(&:name)
+        end
+
+        # Classification
+        def fixed_size?
+          # Structs are always fixed size
+          true
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Struct name required" unless name
+
+          if fields.empty?
+            raise ValidationError,
+                  "Struct must have at least one field"
+          end
+
+          # Structs cannot contain vectors or other non-scalar types
+          fields.each do |field|
+            field.validate!
+            if field.vector?
+              raise ValidationError,
+                    "Struct '#{name}' field '#{field.name}' cannot be a vector"
+            end
+          end
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            fields: fields.map(&:to_h),
+            metadata: metadata,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/unibuf/models/flatbuffers/table_definition.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Flatbuffers
+      # Represents a FlatBuffers table definition
+      class TableDefinition
+        attr_reader :name, :fields, :metadata
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @fields = Array(attributes[:fields] || attributes["fields"])
+          @metadata = attributes[:metadata] || attributes["metadata"] || {}
+        end
+
+        # Queries
+        def find_field(field_name)
+          fields.find { |f| f.name == field_name }
+        end
+
+        def field_names
+          fields.map(&:name)
+        end
+
+        def has_metadata?(key)
+          metadata.key?(key)
+        end
+
+        def get_metadata(key)
+          metadata[key]
+        end
+
+        # Classification
+        def has_vectors?
+          fields.any?(&:vector?)
+        end
+
+        def has_nested_tables?
+          fields.any? { |f| f.type_kind == :table }
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Table name required" unless name
+
+          if fields.empty?
+            raise ValidationError,
+                  "Table must have at least one field"
+          end
+
+          fields.each(&:validate!)
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            fields: fields.map(&:to_h),
+            metadata: metadata,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/unibuf/models/flatbuffers/union_definition.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Flatbuffers
+      # Represents a FlatBuffers union definition
+      # Unions represent a choice between multiple table types
+      class UnionDefinition
+        attr_reader :name, :types, :metadata
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @types = Array(attributes[:types] || attributes["types"])
+          @metadata = attributes[:metadata] || attributes["metadata"] || {}
+        end
+
+        # Queries
+        def includes_type?(type_name)
+          types.include?(type_name)
+        end
+
+        def type_count
+          types.size
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Union name required" unless name
+
+          if types.empty?
+            raise ValidationError,
+                  "Union must have at least one type"
+          end
+
+          # Check for duplicate types
+          if types.uniq.size != types.size
+            raise ValidationError, "Union '#{name}' has duplicate types"
+          end
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            types: types,
+            metadata: metadata,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/unibuf/models/message.rb

@@ -182,6 +182,16 @@ module Unibuf
         lines.join("\n")
       end
 
+      # Serialize to binary Protocol Buffer format
+      # @param schema [Models::Schema] The schema defining the message structure
+      # @param message_type [String] The message type name from schema
+      # @return [String] Binary data
+      def to_binary(schema:, message_type: nil)
+        require_relative "../serializers/binary_serializer"
+        serializer = Serializers::BinarySerializer.new(schema)
+        serializer.serialize(self, message_type: message_type)
+      end
+
       # Comparison
       def ==(other)
         return false unless other.is_a?(Message)

data/lib/unibuf/models/values/scalar_value.rb

@@ -58,8 +58,8 @@ module Unibuf
           return raw_value if boolean?
           return true if string? && %w[true t 1].include?(raw_value.downcase)
           return false if string? && %w[false f 0].include?(raw_value.downcase)
-          return true if raw_value == 1
-          return false if raw_value.zero?
+          return true if integer? && raw_value == 1
+          return false if integer? && raw_value.zero?
 
           raise TypeCoercionError,
                 "Cannot convert #{raw_value.class} to Boolean"

data/lib/unibuf/parsers/binary/wire_format_parser.rb

@@ -1,41 +1,221 @@
 # frozen_string_literal: true
 
+require "bindata"
+
 module Unibuf
   module Parsers
     module Binary
       # Binary Protocol Buffer wire format parser
-      # Requires bindata gem for implementation
-      #
-      # TODO: Implement wire format parsing using bindata
+      # Implements Protocol Buffers binary encoding specification
       # Reference: https://protobuf.dev/programming-guides/encoding/
       class WireFormatParser
         attr_reader :schema
 
+        # Wire types
+        WIRE_TYPE_VARINT = 0
+        WIRE_TYPE_64BIT = 1
+        WIRE_TYPE_LENGTH_DELIMITED = 2
+        WIRE_TYPE_START_GROUP = 3  # Deprecated
+        WIRE_TYPE_END_GROUP = 4    # Deprecated
+        WIRE_TYPE_32BIT = 5
+
         def initialize(schema)
           @schema = schema
         end
 
-        def parse(binary_data)
-          raise NotImplementedError, <<~MSG
-            Binary Protocol Buffer parsing not yet implemented.
+        # Parse binary Protocol Buffer data
+        # @param binary_data [String] Binary data
+        # @return [Models::Message] Parsed message
+        def parse(binary_data, message_type: nil)
+          raise ArgumentError, "Binary data cannot be nil" if binary_data.nil?
+
+          if binary_data.empty?
+            raise ArgumentError,
+                  "Binary data cannot be empty"
+          end
+
+          # Find message definition
+          msg_def = find_message_definition(message_type)
+          unless msg_def
+            raise ArgumentError,
+                  "Message type required or schema must have exactly one message"
+          end
+
+          begin
+            # Parse fields from binary
+            fields = parse_fields(binary_data, msg_def)
+
+            # Build Message model
+            Models::Message.new("fields" => fields)
+          rescue EOFError => e
+            raise ParseError, "Unexpected end of data: #{e.message}"
+          end
+        end
+
+        def parse_file(path, message_type: nil)
+          parse(File.binread(path), message_type: message_type)
+        end
+
+        private
 
-            This feature requires:
-            1. bindata gem integration
-            2. Wire format decoder
-            3. Schema-driven field extraction
-            4. Type deserialization
+        def find_message_definition(type_name)
+          return schema.messages.first if type_name.nil? && schema.messages.size == 1
+
+          schema.find_message(type_name)
+        end
+
+        def parse_fields(data, msg_def)
+          fields = []
+          io = StringIO.new(data)
+          io.set_encoding(Encoding::BINARY)
+
+          until io.eof?
+            begin
+              # Read field tag
+              tag = read_varint(io)
+              field_number = tag >> 3
+              wire_type = tag & 0x7
+
+              # Find field definition
+              field_def = msg_def.find_field_by_number(field_number)
+              next unless field_def # Skip unknown fields
+
+              # Parse field value based on wire type
+              value = parse_field_value(io, wire_type, field_def)
+
+              fields << {
+                "name" => field_def.name,
+                "value" => value,
+              }
+            rescue EOFError => e
+              raise ParseError, "Incomplete field data: #{e.message}"
+            end
+          end
+
+          fields
+        end
 
-            Current implementation: Text format only
-            Roadmap: Binary support in v2.0.0
+        def parse_field_value(io, wire_type, field_def)
+          case wire_type
+          when WIRE_TYPE_VARINT
+            parse_varint_value(io, field_def)
+          when WIRE_TYPE_64BIT
+            parse_64bit_value(io, field_def)
+          when WIRE_TYPE_LENGTH_DELIMITED
+            parse_length_delimited_value(io, field_def)
+          when WIRE_TYPE_32BIT
+            parse_32bit_value(io, field_def)
+          else
+            raise ParseError, "Unsupported wire type: #{wire_type}"
+          end
+        end
+
+        def parse_varint_value(io, field_def)
+          value = read_varint(io)
+
+          case field_def.type
+          when "bool"
+            value != 0
+          when "int32", "int64", "uint32", "uint64"
+            value
+          when "sint32"
+            decode_zigzag_32(value)
+          when "sint64"
+            decode_zigzag_64(value)
+          else
+            value
+          end
+        end
+
+        def parse_64bit_value(io, field_def)
+          bytes = io.read(8)
+          unless bytes && bytes.bytesize == 8
+            raise ParseError,
+                  "Unexpected EOF reading 64-bit value"
+          end
+
+          case field_def.type
+          when "fixed64"
+            bytes.unpack1("Q<")
+          when "sfixed64"
+            bytes.unpack1("q<")
+          when "double"
+            bytes.unpack1("E")
+          else
+            bytes.unpack1("Q<")
+          end
+        end
+
+        def parse_32bit_value(io, field_def)
+          bytes = io.read(4)
+          unless bytes && bytes.bytesize == 4
+            raise ParseError,
+                  "Unexpected EOF reading 32-bit value"
+          end
+
+          case field_def.type
+          when "fixed32"
+            bytes.unpack1("L<")
+          when "sfixed32"
+            bytes.unpack1("l<")
+          when "float"
+            bytes.unpack1("e")
+          else
+            bytes.unpack1("L<")
+          end
+        end
+
+        def parse_length_delimited_value(io, field_def)
+          length = read_varint(io)
+          bytes = io.read(length)
+          unless bytes && bytes.bytesize == length
+            raise ParseError,
+                  "Unexpected EOF reading length-delimited value"
+          end
+
+          case field_def.type
+          when "string"
+            bytes.force_encoding(Encoding::UTF_8)
+          when "bytes"
+            bytes
+          else
+            # Embedded message
+            nested_msg_def = schema.find_message(field_def.type)
+            if nested_msg_def
+              nested_fields = parse_fields(bytes, nested_msg_def)
+              { "fields" => nested_fields }
+            else
+              bytes
+            end
+          end
+        end
+
+        # Read varint (variable-length integer)
+        def read_varint(io)
+          result = 0
+          shift = 0
+
+          loop do
+            byte = io.readbyte
+            result |= (byte & 0x7F) << shift
+            break if byte.nobits?(0x80)
+
+            shift += 7
+            raise ParseError, "Varint too long" if shift >= 64
+          end
+
+          result
+        rescue EOFError => e
+          raise ParseError, "Unexpected EOF reading varint: #{e.message}"
+        end
 
-            For now, use text format:
-              Unibuf.parse_textproto(text_content)
-              Unibuf.parse_textproto_file("file.txtpb")
-          MSG
+        # Decode ZigZag encoding for signed integers
+        def decode_zigzag_32(value)
+          (value >> 1) ^ -(value & 1)
         end
 
-        def parse_file(path)
-          parse(File.binread(path))
+        def decode_zigzag_64(value)
+          (value >> 1) ^ -(value & 1)
         end
       end
     end