unibuf 0.1.0 → 0.1.1

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

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

@@ -72,7 +72,7 @@ module Unibuf
 
         # Numbers - with optional sign
         rule(:signed_number) do
-          str("-") >> whitespace? >> (float_token | hex_int | oct_int | dec_int)
+          (str("-") >> whitespace? >> (float_token | hex_int | oct_int | dec_int)).as(:negative)
         end
         rule(:unsigned_number) { float_token | hex_int | oct_int | dec_int }
         rule(:number) { signed_number | unsigned_number }

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

@@ -60,6 +60,7 @@ module Unibuf
           end
 
           # Process a value (polymorphic)
+          # rubocop:disable Metrics/MethodLength
           def process_value(value)
             return nil unless value
             return value.to_s if value.is_a?(String)
@@ -74,6 +75,14 @@ module Unibuf
 
             return nil unless value.respond_to?(:[])
 
+            # Handle negative numbers
+            if value[:negative]
+              inner_value = process_value(value[:negative])
+              return -inner_value if inner_value.is_a?(Numeric)
+
+              return inner_value
+            end
+
             if value[:string]
               # Single string
               extract_and_unescape_string(value[:string])
@@ -103,6 +112,7 @@ module Unibuf
               value.to_s
             end
           end
+          # rubocop:enable Metrics/MethodLength
 
           # Extract and unescape a string token
           def extract_and_unescape_string(str_token)

data/lib/unibuf/validators/type_validator.rb

@@ -61,7 +61,7 @@ module Unibuf
         def validate_message(message, schema = {})
           errors = []
 
-          message.fields_array.each do |field|
+          Array(message.fields).each do |field|
             next unless schema.key?(field.name)
 
             expected_type = schema[field.name]

data/lib/unibuf/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Unibuf
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unibuf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ronald Tse