unibuf 0.1.0

data/lib/unibuf/models/field_definition.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    # Represents a field definition from a Proto3 schema
+    # Used for type checking and validation
+    class FieldDefinition
+      attr_reader :name, :type, :number, :label, :options
+
+      # Map types are stored as special attributes
+      attr_reader :key_type, :value_type
+
+      def initialize(attributes = {})
+        @name = attributes[:name] || attributes["name"]
+        @type = attributes[:type] || attributes["type"]
+        @number = attributes[:number] || attributes["number"]
+        @label = attributes[:label] || attributes["label"]
+        @options = attributes[:options] || attributes["options"] || {}
+
+        # For map fields
+        @key_type = attributes[:key_type] || attributes["key_type"]
+        @value_type = attributes[:value_type] || attributes["value_type"]
+      end
+
+      # Type queries - MECE
+      def repeated?
+        label == "repeated"
+      end
+
+      def optional?
+        label == "optional" || label.nil?
+      end
+
+      def required?
+        label == "required"
+      end
+
+      def map?
+        !key_type.nil? && !value_type.nil?
+      end
+
+      def message_type?
+        !scalar_type? && !map?
+      end
+
+      def scalar_type?
+        SCALAR_TYPES.include?(type)
+      end
+
+      # Scalar types from Protocol Buffers
+      SCALAR_TYPES = %w[
+        double float int32 int64 uint32 uint64
+        sint32 sint64 fixed32 fixed64 sfixed32 sfixed64
+        bool string bytes
+      ].freeze
+
+      # Validation
+      def valid?
+        validate!
+        true
+      rescue ValidationError
+        false
+      end
+
+      def validate!
+        raise ValidationError, "Field name required" unless name
+        raise ValidationError, "Field type required" unless type
+        raise ValidationError, "Field number required" unless number
+
+        unless number.positive?
+          raise ValidationError,
+                "Field number must be positive"
+        end
+
+        true
+      end
+
+      def valid_value?(value)
+        return true if value.nil? && optional?
+
+        case type
+        when "string"
+          value.is_a?(String)
+        when "int32", "sint32", "sfixed32"
+          value.is_a?(Integer) && value >= -2**31 && value < 2**31
+        when "int64", "sint64", "sfixed64"
+          value.is_a?(Integer) && value >= -2**63 && value < 2**63
+        when "uint32", "fixed32"
+          value.is_a?(Integer) && value >= 0 && value < 2**32
+        when "uint64", "fixed64"
+          value.is_a?(Integer) && value >= 0 && value < 2**64
+        when "float", "double"
+          value.is_a?(Numeric)
+        when "bool"
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        when "bytes"
+          value.is_a?(String)
+        else
+          # Message type - allow hash or Message object
+          value.is_a?(Hash) || value.is_a?(Message)
+        end
+      end
+
+      # Transformation
+      def to_h
+        hash = {
+          name: name,
+          type: type,
+          number: number,
+        }
+        hash[:label] = label if label
+        hash[:key_type] = key_type if key_type
+        hash[:value_type] = value_type if value_type
+        hash[:options] = options unless options.empty?
+        hash
+      end
+    end
+  end
+end

data/lib/unibuf/models/message.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require_relative "field"
+
+module Unibuf
+  module Models
+    # Represents a Protocol Buffer message
+    # Rich domain model with comprehensive behavior
+    class Message
+      attr_reader :fields
+
+      def initialize(attributes = {})
+        fields_data = attributes["fields"] || attributes[:fields] || []
+        @fields = Array(fields_data).map do |field_data|
+          field_data.is_a?(Field) ? field_data : Field.new(field_data)
+        end
+      end
+
+      # Factory method from hash
+      def self.from_hash(hash)
+        new(hash)
+      end
+
+      # Classification - MECE principle
+      def nested?
+        fields_array.any?(&:message_field?)
+      end
+
+      def repeated_fields?
+        # Check if any field name appears multiple times
+        field_names = fields_array.map(&:name)
+        field_names.uniq.size != field_names.size
+      end
+
+      def maps?
+        fields_array.any?(&:map_field?)
+      end
+
+      def scalar_only?
+        fields_array.all?(&:scalar_field?)
+      end
+
+      def empty?
+        fields_array.empty?
+      end
+
+      def complete?
+        # Message is complete if it has at least one field
+        !empty?
+      end
+
+      # Query methods
+      def find_field(name)
+        fields_array.find { |f| f.name == name }
+      end
+
+      def find_fields(name)
+        fields_array.select { |f| f.name == name }
+      end
+
+      def field_names
+        fields_array.map(&:name).uniq
+      end
+
+      def field_count
+        fields_array.size
+      end
+
+      def repeated_field_names
+        field_names.select { |name| find_fields(name).size > 1 }
+      end
+
+      def map_fields
+        fields_array.select(&:map_field?)
+      end
+
+      def nested_messages
+        fields_array.select(&:message_field?).map(&:as_message)
+      end
+
+      # Traversal methods (Milestone 3)
+      def traverse_depth_first(&block)
+        return enum_for(:traverse_depth_first) unless block
+
+        fields_array.each do |field|
+          yield field
+          if field.message_field?
+            field.as_message.traverse_depth_first(&block)
+          end
+        end
+      end
+
+      def traverse_breadth_first
+        return enum_for(:traverse_breadth_first) unless block_given?
+
+        queue = fields_array.dup
+
+        until queue.empty?
+          field = queue.shift
+          yield field
+
+          if field.message_field?
+            queue.concat(field.as_message.fields_array)
+          end
+        end
+      end
+
+      def all_fields_recursive
+        traverse_depth_first.to_a
+      end
+
+      def depth
+        return 0 if empty?
+        return 0 unless nested?
+
+        nested_messages.map { |msg| msg.depth + 1 }.max
+      end
+
+      # Validation methods (Milestone 3)
+      def valid?
+        validate!
+        true
+      rescue ValidationError
+        false
+      end
+
+      def validate!
+        validation_errors.each do |error|
+          raise ValidationError, error
+        end
+        true
+      end
+
+      def validation_errors
+        errors = []
+
+        fields_array.each do |field|
+          # Check for nil values
+          errors << "Field '#{field.name}' has nil value" if field.value.nil?
+
+          # Validate nested messages
+          if field.message_field?
+            begin
+              field.as_message.validate!
+            rescue ValidationError => e
+              errors << "Nested message '#{field.name}': #{e.message}"
+            end
+          end
+        end
+
+        errors
+      end
+
+      # Transformation methods
+      def to_h
+        {
+          "fields" => fields_array.map do |field|
+            {
+              "name" => field.name,
+              "value" => field.value,
+            }
+          end,
+        }
+      end
+
+      def to_json(*args)
+        require "json"
+        to_h.to_json(*args)
+      end
+
+      def to_yaml
+        require "yaml"
+        to_h.to_yaml
+      end
+
+      # Serialize to textproto format
+      def to_textproto(indent: 0)
+        lines = fields_array.map do |field|
+          field.to_textproto(indent: indent)
+        end
+
+        lines.join("\n")
+      end
+
+      # Comparison
+      def ==(other)
+        return false unless other.is_a?(Message)
+
+        fields_array == other.send(:fields_array)
+      end
+
+      def hash
+        fields_array.hash
+      end
+
+      protected
+
+      def fields_array
+        @fields || []
+      end
+    end
+  end
+end

data/lib/unibuf/models/message_definition.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    # Represents a message type definition from a .proto schema
+    # Used for schema-based validation of textproto files
+    class MessageDefinition
+      attr_reader :name, :fields, :nested_messages, :nested_enums
+
+      def initialize(attributes = {})
+        @name = attributes[:name] || attributes["name"]
+        @fields = Array(attributes[:fields] || attributes["fields"])
+        @nested_messages = Array(attributes[:nested_messages] || attributes["nested_messages"])
+        @nested_enums = Array(attributes[:nested_enums] || attributes["nested_enums"])
+      end
+
+      # Queries
+      def find_field(name)
+        fields.find { |f| f.name == name }
+      end
+
+      def find_field_by_number(number)
+        fields.find { |f| f.number == number }
+      end
+
+      def find_nested_message(name)
+        nested_messages.find { |m| m.name == name }
+      end
+
+      def find_nested_enum(name)
+        nested_enums.find { |e| e.name == name }
+      end
+
+      def field_names
+        fields.map(&:name)
+      end
+
+      def field_numbers
+        fields.map(&:number)
+      end
+
+      # Classification
+      def has_repeated_fields?
+        fields.any?(&:repeated?)
+      end
+
+      def has_nested_messages?
+        nested_messages.any?
+      end
+
+      def has_maps?
+        fields.any?(&:map?)
+      end
+
+      # Validation
+      def valid?
+        validate!
+        true
+      rescue ValidationError
+        false
+      end
+
+      def validate!
+        raise ValidationError, "Message name required" unless name
+
+        # Check for duplicate field numbers
+        numbers = field_numbers
+        duplicates = numbers.select { |n| numbers.count(n) > 1 }.uniq
+        if duplicates.any?
+          raise ValidationError,
+                "Duplicate field numbers: #{duplicates.join(', ')}"
+        end
+
+        # Validate all fields
+        fields.each(&:validate!)
+
+        # Validate nested messages
+        nested_messages.each(&:validate!)
+        nested_enums.each(&:validate!)
+
+        true
+      end
+
+      def valid_field_value?(field_name, value)
+        field_def = find_field(field_name)
+        return false unless field_def
+
+        field_def.valid_value?(value)
+      end
+
+      # Transformation
+      def to_h
+        {
+          name: name,
+          fields: fields.map(&:to_h),
+          nested_messages: nested_messages.map(&:to_h),
+          nested_enums: nested_enums.map(&:to_h),
+        }
+      end
+    end
+  end
+end

data/lib/unibuf/models/schema.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    # Represents a Protocol Buffer schema (.proto file)
+    class Schema
+      attr_reader :syntax, :package, :imports, :messages, :enums
+
+      def initialize(attributes = {})
+        @syntax = attributes[:syntax] || attributes["syntax"] || "proto3"
+        @package = attributes[:package] || attributes["package"]
+        @imports = Array(attributes[:imports] || attributes["imports"])
+        @messages = Array(attributes[:messages] || attributes["messages"])
+        @enums = Array(attributes[:enums] || attributes["enums"])
+      end
+
+      # Queries
+      def find_message(name)
+        messages.find { |msg| msg.name == name }
+      end
+
+      def find_enum(name)
+        enums.find { |enum| enum.name == name }
+      end
+
+      def message_names
+        messages.map(&:name)
+      end
+
+      def enum_names
+        enums.map(&:name)
+      end
+
+      # Validation
+      def valid?
+        validate!
+        true
+      rescue ValidationError
+        false
+      end
+
+      def validate!
+        raise ValidationError, "Syntax must be proto3" unless syntax == "proto3"
+
+        messages.each(&:validate!)
+        enums.each(&:validate!)
+
+        true
+      end
+
+      # Find type (message or enum)
+      def find_type(name)
+        find_message(name) || find_enum(name)
+      end
+
+      def to_h
+        {
+          syntax: syntax,
+          package: package,
+          imports: imports,
+          messages: messages.map(&:to_h),
+          enums: enums.map(&:to_h),
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Values
+      # Base class for all value types in Protocol Buffer messages
+      # Follows Open/Closed principle - open for extension, closed for modification
+      class BaseValue
+        attr_reader :raw_value
+
+        def initialize(raw_value)
+          @raw_value = raw_value
+          validate!
+        end
+
+        # Type identification - MECE classification
+        def scalar?
+          false
+        end
+
+        def message?
+          false
+        end
+
+        def list?
+          false
+        end
+
+        def map?
+          false
+        end
+
+        # Serialization - template method pattern
+        def to_textproto(indent: 0)
+          raise NotImplementedError, "Subclasses must implement to_textproto"
+        end
+
+        # Validation - template method pattern
+        def validate!
+          # Subclasses can override for specific validation
+          true
+        end
+
+        # Equality
+        def ==(other)
+          return false unless other.is_a?(self.class)
+
+          raw_value == other.raw_value
+        end
+
+        def hash
+          [self.class, raw_value].hash
+        end
+
+        # Factory method - creates appropriate value type
+        def self.from_raw(raw_value)
+          case raw_value
+          when Hash
+            if raw_value.key?("fields")
+              MessageValue.new(raw_value)
+            elsif raw_value.key?("key") && raw_value.key?("value")
+              MapValue.new(raw_value)
+            else
+              raise InvalidValueError,
+                    "Unknown hash structure: #{raw_value.keys}"
+            end
+          when Array
+            ListValue.new(raw_value)
+          when String, Integer, Float, TrueClass, FalseClass, NilClass
+            ScalarValue.new(raw_value)
+          else
+            raise InvalidValueError, "Unknown value type: #{raw_value.class}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "base_value"
+
+module Unibuf
+  module Models
+    module Values
+      # Represents a list/array value (repeated fields)
+      # Provides array-like interface with type safety
+      class ListValue < BaseValue
+        def list?
+          true
+        end
+
+        # Array-like interface
+        def size
+          items.size
+        end
+
+        def empty?
+          items.empty?
+        end
+
+        def [](index)
+          items[index]
+        end
+
+        def each(&)
+          items.each(&)
+        end
+
+        def map(&)
+          items.map(&)
+        end
+
+        def select(&)
+          items.select(&)
+        end
+
+        def first
+          items.first
+        end
+
+        def last
+          items.last
+        end
+
+        # Type checking
+        def homogeneous?
+          return true if items.empty?
+
+          first_type = items.first.class
+          items.all?(first_type)
+        end
+
+        def all_scalars?
+          items.all? do |item|
+            item.is_a?(String) || item.is_a?(Numeric) || item.is_a?(TrueClass) || item.is_a?(FalseClass)
+          end
+        end
+
+        def all_messages?
+          items.all? { |item| item.is_a?(Hash) && item.key?("fields") }
+        end
+
+        # Serialization
+        def to_textproto(indent: 0)
+          return "[]" if empty?
+
+          if all_scalars? && size < 5
+            # Short inline format for small scalar lists
+            formatted = items.map { |item| format_item(item) }
+            "[#{formatted.join(', ')}]"
+          else
+            # Multi-line format for complex or large lists
+            indent_str = "  " * indent
+            formatted = items.map { |item| format_item(item) }
+            "[\n#{indent_str}  #{formatted.join(",\n#{indent_str}  ")}\n#{indent_str}]"
+          end
+        end
+
+        # Validation
+        def validate!
+          unless raw_value.is_a?(Array)
+            raise InvalidValueError,
+                  "ListValue requires array, got #{raw_value.class}"
+          end
+
+          true
+        end
+
+        private
+
+        def items
+          @items ||= Array(raw_value)
+        end
+
+        def format_item(item)
+          case item
+          when String
+            "\"#{item.gsub('\\', '\\\\').gsub('"', '\"')}\""
+          when Numeric, TrueClass, FalseClass
+            item.to_s
+          when Hash
+            msg = Models::Message.new(item)
+            msg.to_textproto
+          else
+            item.to_s
+          end
+        end
+      end
+    end
+  end
+end