unibuf 0.1.0

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative "base_value"
+
+module Unibuf
+  module Models
+    module Values
+      # Represents a map/dictionary value (key-value pairs)
+      # Provides hash-like interface with type safety
+      class MapValue < BaseValue
+        def map?
+          true
+        end
+
+        # Hash-like interface
+        def key
+          raw_value["key"]
+        end
+
+        def value
+          raw_value["value"]
+        end
+
+        def to_h
+          { key => value }
+        end
+
+        # Type checking
+        def key_type
+          key.class
+        end
+
+        def value_type
+          value.class
+        end
+
+        def scalar_value?
+          !value.is_a?(Hash) && !value.is_a?(Array)
+        end
+
+        def message_value?
+          value.is_a?(Hash) && value.key?("fields")
+        end
+
+        # Serialization
+        def to_textproto(indent: 0)
+          indent_str = "  " * indent
+          key_str = format_value(key)
+          val_str = format_value(value)
+
+          "{\n" \
+            "#{indent_str}  key: #{key_str}\n" \
+            "#{indent_str}  value: #{val_str}\n" \
+            "#{indent_str}}"
+        end
+
+        # Validation
+        def validate!
+          unless raw_value.is_a?(Hash)
+            raise InvalidValueError,
+                  "MapValue requires hash, got #{raw_value.class}"
+          end
+          unless raw_value.key?("key") && raw_value.key?("value")
+            raise InvalidValueError, "MapValue requires 'key' and 'value' keys"
+          end
+
+          true
+        end
+
+        # Comparison
+        def ==(other)
+          return false unless other.is_a?(MapValue)
+
+          key == other.key && value == other.value
+        end
+
+        def hash
+          [self.class, key, value].hash
+        end
+
+        private
+
+        def format_value(val)
+          case val
+          when String
+            "\"#{val.gsub('\\', '\\\\').gsub('"', '\"')}\""
+          when Numeric, TrueClass, FalseClass
+            val.to_s
+          when Hash
+            if val.key?("fields")
+              msg = Models::Message.new(val)
+              "{\n#{msg.to_textproto(indent: 1)}\n}"
+            else
+              val.to_s
+            end
+          else
+            val.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "base_value"
+
+module Unibuf
+  module Models
+    module Values
+      # Represents a nested message value
+      # Delegates to Message model for message-specific behavior
+      class MessageValue < BaseValue
+        attr_reader :message
+
+        def initialize(raw_value)
+          super
+          @message = Message.new(raw_value)
+        end
+
+        def message?
+          true
+        end
+
+        # Delegation to message
+        def fields
+          message.fields
+        end
+
+        def field_count
+          message.field_count
+        end
+
+        def find_field(name)
+          message.find_field(name)
+        end
+
+        def field_names
+          message.field_names
+        end
+
+        # Serialization - delegates to message
+        def to_textproto(indent: 0)
+          indent_str = "  " * indent
+          nested_content = message.to_textproto(indent: indent + 1)
+          "{\n#{nested_content}\n#{indent_str}}"
+        end
+
+        # Validation
+        def validate!
+          unless raw_value.is_a?(Hash) && raw_value.key?("fields")
+            raise InvalidValueError,
+                  "MessageValue requires hash with 'fields' key"
+          end
+
+          message.validate! if message.respond_to?(:validate!)
+          true
+        end
+
+        # Deep equality
+        def ==(other)
+          return false unless other.is_a?(MessageValue)
+
+          message == other.message
+        end
+
+        def hash
+          [self.class, message].hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "base_value"
+
+module Unibuf
+  module Models
+    module Values
+      # Scalar value types: string, integer, float, boolean
+      # Immutable value object with type coercion
+      class ScalarValue < BaseValue
+        def scalar?
+          true
+        end
+
+        # Type queries - MECE
+        def string?
+          raw_value.is_a?(String)
+        end
+
+        def integer?
+          raw_value.is_a?(Integer)
+        end
+
+        def float?
+          raw_value.is_a?(Float)
+        end
+
+        def boolean?
+          raw_value.is_a?(TrueClass) || raw_value.is_a?(FalseClass)
+        end
+
+        def nil?
+          raw_value.nil?
+        end
+
+        # Type coercion with validation
+        def as_string
+          raw_value.to_s
+        end
+
+        def as_integer
+          return raw_value if integer?
+          return raw_value.to_i if string? && raw_value.match?(/^-?\d+$/)
+
+          raise TypeCoercionError,
+                "Cannot convert #{raw_value.class} to Integer"
+        end
+
+        def as_float
+          return raw_value if float?
+          return raw_value.to_f if integer?
+          return raw_value.to_f if string? && raw_value.match?(/^-?\d+\.?\d*$/)
+
+          raise TypeCoercionError, "Cannot convert #{raw_value.class} to Float"
+        end
+
+        def as_boolean
+          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?
+
+          raise TypeCoercionError,
+                "Cannot convert #{raw_value.class} to Boolean"
+        end
+
+        # Serialization
+        def to_textproto(indent: 0)
+          format_scalar(raw_value)
+        end
+
+        # Validation
+        def validate!
+          unless [String, Integer, Float, TrueClass, FalseClass,
+                  NilClass].any? do |t|
+            raw_value.is_a?(t)
+          end
+            raise InvalidValueError, "Invalid scalar type: #{raw_value.class}"
+          end
+
+          true
+        end
+
+        private
+
+        def format_scalar(value)
+          case value
+          when String
+            escape_string(value)
+          when Integer, Float
+            value.to_s
+          when TrueClass, FalseClass
+            value.to_s
+          when NilClass
+            '""'
+          else
+            value.to_s
+          end
+        end
+
+        def escape_string(str)
+          escaped = str.gsub("\\", "\\\\")
+            .gsub('"', '\"')
+            .gsub("\n", '\\n')
+            .gsub("\t", '\\t')
+            .gsub("\r", '\\r')
+          "\"#{escaped}\""
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Parsers
+    module Binary
+      # Binary Protocol Buffer wire format parser
+      # Requires bindata gem for implementation
+      #
+      # TODO: Implement wire format parsing using bindata
+      # Reference: https://protobuf.dev/programming-guides/encoding/
+      class WireFormatParser
+        attr_reader :schema
+
+        def initialize(schema)
+          @schema = schema
+        end
+
+        def parse(binary_data)
+          raise NotImplementedError, <<~MSG
+            Binary Protocol Buffer parsing not yet implemented.
+
+            This feature requires:
+            1. bindata gem integration
+            2. Wire format decoder
+            3. Schema-driven field extraction
+            4. Type deserialization
+
+            Current implementation: Text format only
+            Roadmap: Binary support in v2.0.0
+
+            For now, use text format:
+              Unibuf.parse_textproto(text_content)
+              Unibuf.parse_textproto_file("file.txtpb")
+          MSG
+        end
+
+        def parse_file(path)
+          parse(File.binread(path))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Unibuf
+  module Parsers
+    module Proto3
+      # Parslet grammar for parsing Proto3 schema definitions
+      # Reference: https://protobuf.dev/reference/protobuf/proto3-spec/
+      class Grammar < Parslet::Parser
+        # ===== Lexical Elements =====
+
+        # Whitespace and comments
+        rule(:space) { match['\s'].repeat(1) }
+        rule(:space?) { space.maybe }
+        rule(:newline) { str("\n") }
+
+        # Comments (// and /* */)
+        rule(:line_comment) do
+          str("//") >> (newline.absent? >> any).repeat >> newline.maybe
+        end
+        rule(:block_comment) do
+          str("/*") >> (str("*/").absent? >> any).repeat >> str("*/")
+        end
+        rule(:comment) { line_comment | block_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
+        rule(:number) { (match["+-"].maybe >> digit.repeat(1)).as(:number) }
+
+        # ===== Syntax Elements =====
+
+        # Syntax declaration: syntax = "proto3";
+        rule(:syntax_stmt) do
+          str("syntax") >> whitespace? >> str("=") >> whitespace? >>
+            string_literal.as(:syntax_version) >> whitespace? >> str(";")
+        end
+
+        # Package declaration: package google.fonts;
+        rule(:package_stmt) do
+          str("package") >> whitespace? >>
+            identifier.as(:package) >>
+            (str(".") >> identifier).repeat >> whitespace? >> str(";")
+        end
+
+        # Import statement: import "other.proto";
+        rule(:import_stmt) do
+          str("import") >> whitespace? >>
+            string_literal.as(:import) >> whitespace? >> str(";")
+        end
+
+        # Field types
+        rule(:scalar_type) do
+          (str("double") | str("float") | str("int32") | str("int64") |
+           str("uint32") | str("uint64") | str("sint32") | str("sint64") |
+           str("fixed32") | str("fixed64") | str("sfixed32") | str("sfixed64") |
+           str("bool") | str("string") | str("bytes")).as(:scalar_type)
+        end
+
+        rule(:message_type) { identifier.as(:message_type) }
+        rule(:field_type) { scalar_type | message_type }
+
+        # Field definition: string name = 1;
+        rule(:field_def) do
+          (str("repeated") >> whitespace).maybe.as(:repeated) >>
+            field_type.as(:type) >> whitespace >>
+            identifier.as(:name) >> whitespace? >>
+            str("=") >> whitespace? >>
+            number.as(:field_number) >> whitespace? >>
+            str(";")
+        end
+
+        # Map field: map<string, int32> mapping = 1;
+        rule(:map_field) do
+          str("map") >> whitespace? >> str("<") >> whitespace? >>
+            field_type.as(:key_type) >> whitespace? >>
+            str(",") >> whitespace? >>
+            field_type.as(:value_type) >> whitespace? >>
+            str(">") >> whitespace >>
+            identifier.as(:name) >> whitespace? >>
+            str("=") >> whitespace? >>
+            number.as(:field_number) >> whitespace? >>
+            str(";")
+        end
+
+        # Message definition
+        rule(:message_body) do
+          (field_def.as(:field) | map_field.as(:map_field) | message_def.as(:nested_message) | whitespace).repeat
+        end
+
+        rule(:message_def) do
+          str("message") >> whitespace >>
+            identifier.as(:message_name) >> whitespace? >>
+            str("{") >> whitespace? >>
+            message_body.as(:body) >> whitespace? >>
+            str("}")
+        end
+
+        # Enum definition
+        rule(:enum_value) do
+          identifier.as(:name) >> whitespace? >>
+            str("=") >> whitespace? >>
+            number.as(:value) >> whitespace? >>
+            str(";")
+        end
+
+        rule(:enum_def) do
+          str("enum") >> whitespace >>
+            identifier.as(:enum_name) >> whitespace? >>
+            str("{") >> whitespace? >>
+            enum_value.repeat.as(:values) >> whitespace? >>
+            str("}")
+        end
+
+        # Top-level elements
+        rule(:proto_element) do
+          syntax_stmt.as(:syntax) |
+            package_stmt.as(:package) |
+            import_stmt.as(:import) |
+            message_def.as(:message) |
+            enum_def.as(:enum) |
+            whitespace
+        end
+
+        # Proto file
+        rule(:proto_file) do
+          whitespace? >> proto_element.repeat >> whitespace?
+        end
+
+        root(:proto_file)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative "../../models/schema"
+require_relative "../../models/message_definition"
+require_relative "../../models/field_definition"
+require_relative "../../models/enum_definition"
+
+module Unibuf
+  module Parsers
+    module Proto3
+      # Processor to transform Proto3 AST to Schema models
+      class Processor
+        class << self
+          def process(ast)
+            return Models::Schema.new unless ast
+
+            elements = Array(ast)
+
+            attributes = {
+              syntax: extract_syntax(elements),
+              package: extract_package(elements),
+              imports: extract_imports(elements),
+              messages: extract_messages(elements),
+              enums: extract_enums(elements),
+            }
+
+            Models::Schema.new(attributes)
+          end
+
+          private
+
+          def extract_syntax(elements)
+            syntax_element = elements.find { |el| el.key?(:syntax) }
+            return "proto3" unless syntax_element
+
+            syntax_element[:syntax][:syntax_version][:string].to_s
+          end
+
+          def extract_package(elements)
+            pkg_element = elements.find { |el| el.key?(:package) }
+            return nil unless pkg_element
+
+            # Package is array of identifiers: [{:package=>{:identifier=>"google"}}, {:identifier=>"fonts"}]
+            pkg_parts = Array(pkg_element[:package])
+            names = pkg_parts.filter_map do |part|
+              if part[:package]
+                part[:package][:identifier].to_s
+              elsif part[:identifier]
+                part[:identifier].to_s
+              end
+            end
+
+            names.join(".")
+          end
+
+          def extract_imports(elements)
+            elements.select { |el| el.key?(:import) }.map do |el|
+              el[:import][:import][:string].to_s
+            end
+          end
+
+          def extract_messages(elements)
+            elements.select { |el| el.key?(:message) }.map do |el|
+              process_message(el[:message])
+            end
+          end
+
+          def extract_enums(elements)
+            elements.select { |el| el.key?(:enum) }.map do |el|
+              process_enum(el[:enum])
+            end
+          end
+
+          def process_message(msg_data)
+            name = msg_data[:message_name][:identifier].to_s
+            body = msg_data[:body]
+
+            fields = extract_fields(body)
+            nested_messages = extract_nested_messages(body)
+            nested_enums = extract_nested_enums(body)
+
+            Models::MessageDefinition.new(
+              name: name,
+              fields: fields,
+              nested_messages: nested_messages,
+              nested_enums: nested_enums,
+            )
+          end
+
+          def extract_fields(body)
+            return [] unless body
+
+            result = []
+
+            # Extract regular fields
+            Array(body).each do |el|
+              if el.respond_to?(:key?) && el.key?(:field)
+                result << process_field(el[:field])
+              elsif el.respond_to?(:key?) && el.key?(:map_field)
+                result << process_map_field(el[:map_field])
+              end
+            end
+
+            result
+          end
+
+          def extract_nested_messages(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:nested_message)
+            end.map do |el|
+              process_message(el[:nested_message])
+            end
+          end
+
+          def extract_nested_enums(body)
+            return [] unless body
+
+            Array(body).select do |el|
+              el.respond_to?(:key?) && el.key?(:enum)
+            end.map do |el|
+              process_enum(el[:enum])
+            end
+          end
+
+          def process_field(field_data)
+            type_info = field_data[:type]
+            type = if type_info[:scalar_type]
+                     type_info[:scalar_type].to_s
+                   else
+                     type_info[:message_type][:identifier].to_s
+                   end
+
+            Models::FieldDefinition.new(
+              name: field_data[:name][:identifier].to_s,
+              type: type,
+              number: field_data[:field_number][:number].to_s.to_i,
+              label: field_data[:repeated] ? "repeated" : nil,
+            )
+          end
+
+          def process_map_field(map_data)
+            key_type_info = map_data[:key_type]
+            key_type = if key_type_info[:scalar_type]
+                         key_type_info[:scalar_type].to_s
+                       else
+                         key_type_info[:message_type][:identifier].to_s
+                       end
+
+            value_type_info = map_data[:value_type]
+            value_type = if value_type_info[:scalar_type]
+                           value_type_info[:scalar_type].to_s
+                         else
+                           value_type_info[:message_type][:identifier].to_s
+                         end
+
+            Models::FieldDefinition.new(
+              name: map_data[:name][:identifier].to_s,
+              type: "map",
+              number: map_data[:field_number][:number].to_s.to_i,
+              key_type: key_type,
+              value_type: value_type,
+            )
+          end
+
+          def process_enum(enum_data)
+            name = enum_data[:enum_name][:identifier].to_s
+            values = {}
+
+            Array(enum_data[:values]).each do |val|
+              next unless val.respond_to?(:key?) && val.key?(:name)
+
+              val_name = val[:name][:identifier].to_s
+              val_num = val[:value][:number].to_s.to_i
+              values[val_name] = val_num
+            end
+
+            Models::EnumDefinition.new(
+              name: name,
+              values: values,
+            )
+          end
+        end
+      end
+    end
+  end
+end