protobug 0.1.0

data/lib/protobug/message.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require_relative "binary_encoding"
+require_relative "errors"
+require_relative "field"
+require "stringio"
+
+module Protobug
+  UNSET = Object.new
+  def UNSET.inspect
+    "<UNSET>"
+  end
+
+  def UNSET.===(other)
+    other.equal? UNSET
+  end
+  UNSET.freeze
+
+  module Message
+    def self.extended(base)
+      base.class_eval do
+        @full_name = nil
+        @fields_by_number = {}
+        @fields_by_json_name = {}
+        @fields_by_name = {}
+        @reserved_ranges = []
+        @oneofs = {}
+        extend BaseDescriptor
+        include Protobug::Message::InstanceMethods
+      end
+    end
+
+    attr_accessor :full_name
+    attr_reader :fields_by_number, :fields_by_name, :fields_by_json_name, :reserved_ranges, :oneofs
+
+    def freeze
+      fields_by_number.freeze
+      fields_by_name.freeze
+      fields_by_json_name.freeze
+      full_name.freeze
+      reserved_ranges.freeze
+      oneofs.each_value(&:freeze)
+      oneofs.freeze
+      super
+    end
+
+    def optional(number, name, **kwargs)
+      if kwargs[:cardinality] && kwargs[:cardinality] != :optional
+        raise DefinitionError,
+              "expected cardinality: :optional, got #{kwargs[:cardinality].inspect}"
+      end
+      field(number, name, cardinality: :optional, **kwargs)
+    end
+
+    def repeated(number, name, **kwargs)
+      if kwargs[:cardinality] && kwargs[:cardinality] != :repeated
+        raise DefinitionError,
+              "expected cardinality: :repeated, got #{kwargs[:cardinality].inspect}"
+      end
+      field(number, name, cardinality: :repeated, **kwargs)
+    end
+
+    def map(number, name, **kwargs)
+      if kwargs[:type] && kwargs[:type] != :map
+        raise DefinitionError,
+              "expected type: :map, got #{kwargs[:type].inspect}"
+      end
+      repeated(number, name, type: :map, **kwargs)
+    end
+
+    def required(number, name, **kwargs)
+      if kwargs[:cardinality] && kwargs[:cardinality] != :required
+        raise DefinitionError,
+              "expected cardinality: :required, got #{kwargs[:cardinality].inspect}"
+      end
+      field(number, name, cardinality: :required, **kwargs)
+    end
+
+    def reserved_range(range)
+      raise DefinitionError, "expected Range, got #{range.inspect}" unless range.is_a? Range
+
+      reserved_ranges << range
+    end
+
+    def decode_json(json, registry:, ignore_unknown_fields: false)
+      require "json"
+      hash = begin
+        JSON.parse(json, allow_blank: false, create_additions: false, allow_nan: false, allow_infinity: false)
+      rescue JSON::ParserError => e
+        raise DecodeError, "JSON failed to parse: #{e.message}"
+      end
+      raise DecodeError, "expected hash, got #{hash.inspect}" unless hash.is_a? Hash
+
+      decode_json_hash(hash, registry: registry, ignore_unknown_fields: ignore_unknown_fields)
+    end
+
+    def decode_json_hash(json, registry:, ignore_unknown_fields: false)
+      return UNSET if json.nil?
+      raise DecodeError, "expected hash for #{self} (#{full_name}), got #{json.inspect}" unless json.is_a? Hash
+
+      message = new
+
+      json.each do |key, value|
+        field = fields_by_json_name[key]
+        unless field
+          next if ignore_unknown_fields
+
+          raise(UnknownFieldError, "unknown field #{key.inspect} in #{full_name}")
+        end
+
+        if field.oneof && message.send(field.oneof) && !value.nil?
+          raise DecodeError, "multiple oneof fields set in #{full_name}: #{message.send(field.oneof)} and #{field.name}"
+        end
+
+        field.json_decode(value, message, ignore_unknown_fields, registry)
+      end
+
+      message
+    end
+
+    def decode(binary, registry:, object: new)
+      binary.binmode
+      loop do
+        header = BinaryEncoding.decode_varint(binary)
+        break if header.nil?
+
+        wire_type = header & 0b111
+        number = (header ^ wire_type) >> 3
+
+        unless number.positive?
+          raise DecodeError,
+                "unexpected field number #{number} in #{full_name || fields_by_name.inspect}"
+        end
+
+        field = fields_by_number[number]
+
+        if field
+          field.binary_decode(binary, object, registry, wire_type)
+        else
+          object.unknown_fields << [number, wire_type, BinaryEncoding.read_field_value(binary, wire_type)]
+        end
+      end
+      object
+    end
+
+    def encode(message)
+      raise EncodeError, "expected #{self}, got #{message.inspect}" unless message.is_a? self
+
+      buf = fields_by_number.each_with_object("".b) do |(_number, field), outbuf|
+        next unless message.send(field.haser)
+
+        value = message.instance_variable_get(field.ivar)
+
+        field.binary_encode(value, outbuf)
+      end
+      message.unknown_fields.each_with_object(buf) do |(number, wire_type, value), outbuf|
+        BinaryEncoding.encode_varint((number << 3) | wire_type, outbuf)
+        case wire_type
+        when 0, 5
+          BinaryEncoding.encode_varint(value, outbuf)
+        when 2
+          BinaryEncoding.encode_length(value, outbuf)
+        else
+          raise EncodeError, "unknown wire_type: #{wire_type}"
+        end
+      end
+    end
+
+    def field(number, name, type:, **kwargs)
+      field =
+        case type
+        when :message
+          Field::MessageField
+        when :enum
+          Field::EnumField
+        when :bytes
+          Field::BytesField
+        when :string
+          Field::StringField
+        when :map
+          kwargs.delete(:cardinality) if kwargs[:cardinality] == :repeated
+          Field::MapField
+        when :int64
+          Field::Int64Field
+        when :uint64
+          Field::UInt64Field
+        when :sint64
+          Field::SInt64Field
+        when :fixed64
+          Field::Fixed64Field
+        when :sfixed64
+          Field::SFixed64Field
+        when :int32
+          Field::Int32Field
+        when :uint32
+          Field::UInt32Field
+        when :sint32
+          Field::SInt32Field
+        when :fixed32
+          Field::Fixed32Field
+        when :sfixed32
+          Field::SFixed32Field
+        when :bool
+          Field::BoolField
+        when :float
+          Field::FloatField
+        when :double
+          Field::DoubleField
+        when :group
+          Field::GroupField
+        else
+          raise ArgumentError, "Unknown field type #{type.inspect}"
+        end.new(number, name, **kwargs).freeze
+
+      raise DefinitionError, "duplicate field number #{number}" if fields_by_number[number]
+
+      fields_by_number[number] = field
+      raise DefinitionError, "duplicate field name #{name}" if fields_by_name[name]
+
+      fields_by_name[name] = field
+
+      fields_by_json_name[name] = field
+      fields_by_json_name[field.json_name] = field
+
+      define_method(field.setter) do |value|
+        return instance_variable_set(field.ivar, UNSET) if value.nil? && field.optional? && field.proto3_optional?
+
+        field.validate!(value, self)
+        instance_variable_set(field.ivar, value)
+      end
+
+      define_method(name) do
+        value = instance_variable_get(field.ivar)
+        UNSET == value ? field.default : value
+      end
+
+      define_method(field.haser) do
+        value = instance_variable_get(field.ivar)
+        return false if UNSET == value
+
+        return false if (!field.optional? || !field.proto3_optional?) && !field.oneof && field.default == value
+
+        if field.repeated?
+          !value.empty?
+        else
+          true
+        end
+      end
+
+      define_method(field.clearer) do
+        instance_variable_set(field.ivar, UNSET)
+      end
+
+      field.define_adder(self) if field.repeated?
+
+      return unless field.oneof
+
+      unless oneofs[field.oneof]
+        oneofs[field.oneof] = ary = []
+        define_method(field.oneof) do
+          ary.find { |f| send(f.haser) }&.name
+        end
+      end
+      oneofs[field.oneof] << field
+    end
+
+    module InstanceMethods
+      def ==(other)
+        self.class.full_name == other.class.full_name &&
+          self.class.fields_by_name.all? do |name, _|
+            send(name) == other.send(name)
+          end
+      end
+      alias eql? ==
+
+      attr_reader :unknown_fields
+
+      def initialize
+        super
+        self.class.fields_by_name.each_value do |field|
+          instance_variable_set(field.ivar, UNSET)
+        end
+        @unknown_fields = []
+      end
+
+      def pretty_print(pp)
+        fields_with_values = self.class.fields_by_name.select do |_name, field|
+          send(field.haser)
+        end
+        pp.group 2, "#{self.class}.new(", ")" do
+          pp.breakable
+          fields_with_values.each_with_index do |(name, field), idx|
+            pp.nest 2 do
+              unless idx.zero?
+                pp.text ","
+                pp.breakable " "
+              end
+              pp.text "#{name}: "
+              pp.pp send(field.name)
+            end
+          end
+        end
+      end
+
+      def hash
+        self.class.fields_by_name.map { |name, _| send(name) }.hash
+      end
+
+      def to_text
+        fields_with_values = self.class.fields_by_name.select do |_name, field|
+          send(field.haser)
+        end
+
+        fields_with_values.map do |_name, field|
+          value = send(field.name)
+          field.to_text(value)
+        end.join("\n")
+      end
+
+      def to_proto
+        self.class.encode(self)
+      end
+
+      def as_json(print_unknown_fields: false)
+        fields_with_values = self.class.fields_by_name.select do |_name, field|
+          send(field.haser)
+        end
+
+        fields_with_values.to_h do |_name, field|
+          value = send(field.name)
+
+          [field.json_name, field.json_encode(value, print_unknown_fields: print_unknown_fields)]
+        end
+      end
+
+      def to_json(print_unknown_fields: false)
+        require "json"
+        JSON.generate(as_json(print_unknown_fields: print_unknown_fields), allow_infinity: true)
+      rescue JSON::GeneratorError => e
+        raise EncodeError, "failed to generate JSON: #{e}"
+      end
+    end
+  end
+end

data/lib/protobug/registry.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Protobug
+  class Registry
+    def initialize(&blk)
+      @registry = {}
+      return unless blk
+
+      yield self
+      freeze
+    end
+
+    def freeze
+      @registry.freeze
+      super
+    end
+
+    def register(klass)
+      unless klass.is_a? Protobug::BaseDescriptor
+        raise ArgumentError,
+              "expected Protobug::BaseDescriptor, got #{klass.inspect}"
+      end
+
+      full_name = klass.full_name
+      existing = @registry[full_name]
+      raise ArgumentError, "duplicate class #{full_name}" if existing && existing != klass
+
+      @registry[full_name] = klass
+      klass.freeze
+    end
+
+    def fetch(...)
+      @registry.fetch(...)
+    end
+  end
+end

data/lib/protobug/version.rb

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

data/lib/protobug.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "protobug/version"
+
+module Protobug
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+require_relative "protobug/base_descriptor"
+require_relative "protobug/enum"
+require_relative "protobug/message"
+require_relative "protobug/registry"
+require "date"

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: protobug
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Giddins
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2024-04-25 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- segiddins@segiddins.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- lib/protobug.rb
+- lib/protobug/base_descriptor.rb
+- lib/protobug/binary_encoding.rb
+- lib/protobug/enum.rb
+- lib/protobug/errors.rb
+- lib/protobug/field.rb
+- lib/protobug/message.rb
+- lib/protobug/registry.rb
+- lib/protobug/version.rb
+homepage: https://github.com/segiddins/protobug
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/segiddins/protobug
+  source_code_uri: https://github.com/segiddins/protobug
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key: 
+specification_version: 4
+summary: An embeddable protobuf compiler & runtime for Ruby
+test_files: []