unibuf 0.1.1 → 0.1.2

data/lib/unibuf/models/capnproto/field_definition.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Capnproto
+      # Represents a Cap'n Proto field definition
+      class FieldDefinition
+        attr_reader :name, :ordinal, :type, :default_value
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @ordinal = attributes[:ordinal] || attributes["ordinal"]
+          @type = attributes[:type] || attributes["type"]
+          @default_value = attributes[:default_value] ||
+            attributes["default_value"]
+        end
+
+        # Type classification
+        def primitive_type?
+          type.is_a?(String) && PRIMITIVE_TYPES.include?(type)
+        end
+
+        def generic_type?
+          type.is_a?(Hash) && type.key?(:generic)
+        end
+
+        def user_type?
+          type.is_a?(String) && !primitive_type?
+        end
+
+        def list_type?
+          generic_type? && type[:generic] == "List"
+        end
+
+        def element_type
+          return nil unless list_type?
+
+          type[:element_type]
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Field name required" unless name
+          raise ValidationError, "Field ordinal required" unless ordinal
+          raise ValidationError, "Field type required" unless type
+
+          if ordinal.to_i.negative?
+            raise ValidationError,
+                  "Ordinal must be non-negative"
+          end
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            ordinal: ordinal,
+            type: type,
+            default_value: default_value,
+          }
+        end
+
+        PRIMITIVE_TYPES = %w[
+          Void Bool
+          Int8 Int16 Int32 Int64
+          UInt8 UInt16 UInt32 UInt64
+          Float32 Float64
+          AnyPointer
+        ].freeze
+      end
+    end
+  end
+end

data/lib/unibuf/models/capnproto/interface_definition.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Capnproto
+      # Represents a Cap'n Proto interface definition (for RPC)
+      class InterfaceDefinition
+        attr_reader :name, :methods, :annotations
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @methods = Array(attributes[:methods] || attributes["methods"])
+          @annotations = Array(
+            attributes[:annotations] || attributes["annotations"],
+          )
+        end
+
+        # Queries
+        def find_method(name)
+          methods.find { |m| m.name == name }
+        end
+
+        def method_names
+          methods.map(&:name)
+        end
+
+        def ordinals
+          methods.map(&:ordinal)
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Interface name required" unless name
+
+          if methods.empty?
+            raise ValidationError,
+                  "Interface must have at least one method"
+          end
+
+          # Check for duplicate ordinals
+          ordinal_counts = ordinals.tally
+          duplicates = ordinal_counts.select { |_ord, count| count > 1 }
+          unless duplicates.empty?
+            raise ValidationError,
+                  "Duplicate ordinals in interface '#{name}': #{duplicates.keys.join(', ')}"
+          end
+
+          methods.each(&:validate!)
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            methods: methods.map(&:to_h),
+            annotations: annotations,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/unibuf/models/capnproto/method_definition.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Capnproto
+      # Represents a Cap'n Proto method definition (RPC)
+      class MethodDefinition
+        attr_reader :name, :ordinal, :params, :results
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @ordinal = attributes[:ordinal] || attributes["ordinal"]
+          @params = Array(attributes[:params] || attributes["params"])
+          @results = Array(attributes[:results] || attributes["results"])
+        end
+
+        # Queries
+        def param_names
+          params.map { |p| p[:name] }
+        end
+
+        def result_names
+          results.map { |r| r[:name] }
+        end
+
+        def find_param(name)
+          params.find { |p| p[:name] == name }
+        end
+
+        def find_result(name)
+          results.find { |r| r[:name] == name }
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Method name required" unless name
+          raise ValidationError, "Method ordinal required" unless ordinal
+
+          if ordinal.to_i.negative?
+            raise ValidationError,
+                  "Ordinal must be non-negative"
+          end
+
+          # Validate params
+          params.each do |param|
+            unless param[:name] && param[:type]
+              raise ValidationError,
+                    "Method parameter must have name and type"
+            end
+          end
+
+          # Validate results
+          results.each do |result|
+            unless result[:name] && result[:type]
+              raise ValidationError,
+                    "Method result must have name and type"
+            end
+          end
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            ordinal: ordinal,
+            params: params,
+            results: results,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Capnproto
+      # Represents a Cap'n Proto schema (.capnp file)
+      class Schema
+        attr_reader :file_id, :usings, :structs, :enums, :interfaces,
+                    :constants
+
+        def initialize(attributes = {})
+          @file_id = attributes[:file_id] || attributes["file_id"]
+          @usings = Array(attributes[:usings] || attributes["usings"])
+          @structs = Array(attributes[:structs] || attributes["structs"])
+          @enums = Array(attributes[:enums] || attributes["enums"])
+          @interfaces = Array(
+            attributes[:interfaces] || attributes["interfaces"],
+          )
+          @constants = Array(
+            attributes[:constants] || attributes["constants"],
+          )
+        end
+
+        # Queries
+        def find_struct(name)
+          structs.find { |s| s.name == name }
+        end
+
+        def find_enum(name)
+          enums.find { |e| e.name == name }
+        end
+
+        def find_interface(name)
+          interfaces.find { |i| i.name == name }
+        end
+
+        def find_type(name)
+          find_struct(name) || find_enum(name) || find_interface(name)
+        end
+
+        def struct_names
+          structs.map(&:name)
+        end
+
+        def enum_names
+          enums.map(&:name)
+        end
+
+        def interface_names
+          interfaces.map(&:name)
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "File ID required" unless file_id
+
+          structs.each(&:validate!)
+          enums.each(&:validate!)
+          interfaces.each(&:validate!)
+
+          true
+        end
+
+        def to_h
+          {
+            file_id: file_id,
+            usings: usings,
+            structs: structs.map(&:to_h),
+            enums: enums.map(&:to_h),
+            interfaces: interfaces.map(&:to_h),
+            constants: constants,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Capnproto
+      # Represents a Cap'n Proto struct definition
+      class StructDefinition
+        attr_reader :name, :fields, :unions, :groups, :nested_structs,
+                    :nested_enums, :nested_interfaces, :annotations
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @fields = Array(attributes[:fields] || attributes["fields"])
+          @unions = Array(attributes[:unions] || attributes["unions"])
+          @groups = Array(attributes[:groups] || attributes["groups"])
+          @nested_structs = Array(
+            attributes[:nested_structs] || attributes["nested_structs"],
+          )
+          @nested_enums = Array(
+            attributes[:nested_enums] || attributes["nested_enums"],
+          )
+          @nested_interfaces = Array(
+            attributes[:nested_interfaces] || attributes["nested_interfaces"],
+          )
+          @annotations = Array(
+            attributes[:annotations] || attributes["annotations"],
+          )
+        end
+
+        # Queries
+        def find_field(name)
+          fields.find { |f| f.name == name }
+        end
+
+        def find_union(name)
+          unions.find { |u| u.name == name }
+        end
+
+        def field_names
+          fields.map(&:name)
+        end
+
+        def ordinals
+          fields.map(&:ordinal)
+        end
+
+        def max_ordinal
+          ordinals.max || -1
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Struct name required" unless name
+
+          if fields.empty? && unions.empty?
+            raise ValidationError,
+                  "Struct must have at least one field"
+          end
+
+          # Check for duplicate ordinals
+          ordinal_counts = ordinals.tally
+          duplicates = ordinal_counts.select { |_ord, count| count > 1 }
+          unless duplicates.empty?
+            raise ValidationError,
+                  "Duplicate ordinals in struct '#{name}': #{duplicates.keys.join(', ')}"
+          end
+
+          fields.each(&:validate!)
+          unions.each(&:validate!)
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            fields: fields.map(&:to_h),
+            unions: unions.map(&:to_h),
+            groups: groups.map(&:to_h),
+            nested_structs: nested_structs.map(&:to_h),
+            nested_enums: nested_enums.map(&:to_h),
+            nested_interfaces: nested_interfaces.map(&:to_h),
+            annotations: annotations,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Capnproto
+      # Represents a Cap'n Proto union definition (discriminated union)
+      class UnionDefinition
+        attr_reader :fields
+
+        def initialize(attributes = {})
+          @fields = Array(attributes[:fields] || attributes["fields"])
+        end
+
+        # Queries
+        def field_names
+          fields.map(&:name)
+        end
+
+        def ordinals
+          fields.map(&:ordinal)
+        end
+
+        def find_field(name)
+          fields.find { |f| f.name == name }
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          if fields.length < 2
+            raise ValidationError,
+                  "Union must have at least two fields"
+          end
+
+          # Check for duplicate ordinals
+          ordinal_counts = ordinals.tally
+          duplicates = ordinal_counts.select { |_ord, count| count > 1 }
+          unless duplicates.empty?
+            raise ValidationError,
+                  "Duplicate ordinals in union: #{duplicates.keys.join(', ')}"
+          end
+
+          fields.each(&:validate!)
+
+          true
+        end
+
+        def to_h
+          {
+            fields: fields.map(&:to_h),
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Flatbuffers
+      # Represents a FlatBuffers enum definition
+      class EnumDefinition
+        attr_reader :name, :type, :values, :metadata
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @type = attributes[:type] || attributes["type"] || "int"
+          @values = attributes[:values] || attributes["values"] || {}
+          @metadata = attributes[:metadata] || attributes["metadata"] || {}
+        end
+
+        # Queries
+        def find_value_by_name(value_name)
+          values[value_name]
+        end
+
+        def find_name_by_value(value)
+          values.key(value)
+        end
+
+        def value_names
+          values.keys
+        end
+
+        def value_numbers
+          values.values
+        end
+
+        # Validation
+        def valid?
+          validate!
+          true
+        rescue ValidationError
+          false
+        end
+
+        def validate!
+          raise ValidationError, "Enum name required" unless name
+
+          if values.empty?
+            raise ValidationError,
+                  "Enum must have at least one value"
+          end
+
+          # Check for duplicate values
+          if values.values.uniq.size != values.values.size
+            raise ValidationError, "Enum '#{name}' has duplicate values"
+          end
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            type: type,
+            values: values,
+            metadata: metadata,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Unibuf
+  module Models
+    module Flatbuffers
+      # Represents a field in a FlatBuffers table or struct
+      class FieldDefinition
+        attr_reader :name, :type, :default_value, :metadata
+
+        def initialize(attributes = {})
+          @name = attributes[:name] || attributes["name"]
+          @type = attributes[:type] || attributes["type"]
+          @default_value = attributes[:default_value] || attributes["default_value"]
+          @metadata = attributes[:metadata] || attributes["metadata"] || {}
+        end
+
+        # Type classification
+        def scalar?
+          SCALAR_TYPES.include?(type)
+        end
+
+        def vector?
+          type.is_a?(Hash) && type[:vector]
+        end
+
+        def user_type?
+          !scalar? && !vector?
+        end
+
+        def type_kind
+          return :vector if vector?
+          return :scalar if scalar?
+
+          # Assume user type (table, struct, enum)
+          :table
+        end
+
+        def vector_element_type
+          return nil unless vector?
+
+          type[:vector]
+        end
+
+        # Metadata queries
+        def deprecated?
+          metadata[:deprecated] == true
+        end
+
+        def required?
+          metadata[:required] == true
+        end
+
+        def id
+          metadata[:id]
+        end
+
+        # 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
+
+          true
+        end
+
+        def to_h
+          {
+            name: name,
+            type: type,
+            default_value: default_value,
+            metadata: metadata,
+          }.compact
+        end
+
+        SCALAR_TYPES = %w[
+          byte ubyte short ushort int uint long ulong
+          float double bool
+        ].freeze
+      end
+    end
+  end
+end