google-protobuf 3.19.1 → 3.25.1

data/lib/google/protobuf/ffi/descriptor.rb

@@ -0,0 +1,165 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2022 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    ##
+    # Message Descriptor - Descriptor for short.
+    class Descriptor
+      attr :descriptor_pool, :msg_class
+      include Enumerable
+
+      # FFI Interface methods and setup
+      extend ::FFI::DataConverter
+      native_type ::FFI::Type::POINTER
+
+      class << self
+        prepend Google::Protobuf::Internal::TypeSafety
+        include Google::Protobuf::Internal::PointerHelper
+
+        # @param value [Descriptor] Descriptor to convert to an FFI native type
+        # @param _ [Object] Unused
+        def to_native(value, _ = nil)
+          msg_def_ptr = value.nil? ? nil : value.instance_variable_get(:@msg_def)
+          return ::FFI::Pointer::NULL if msg_def_ptr.nil?
+          raise "Underlying msg_def was null!" if msg_def_ptr.null?
+          msg_def_ptr
+        end
+
+        ##
+        # @param msg_def [::FFI::Pointer] MsgDef pointer to be wrapped
+        # @param _ [Object] Unused
+        def from_native(msg_def, _ = nil)
+          return nil if msg_def.nil? or msg_def.null?
+          file_def = Google::Protobuf::FFI.get_message_file_def msg_def
+          descriptor_from_file_def(file_def, msg_def)
+        end
+      end
+
+      def to_native
+        self.class.to_native(self)
+      end
+
+      ##
+      # Great write up of this strategy:
+      # See https://blog.appsignal.com/2018/08/07/ruby-magic-changing-the-way-ruby-creates-objects.html
+      def self.new(*arguments, &block)
+        raise "Descriptor objects may not be created from Ruby."
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        "Descriptor - (not the message class) #{name}"
+      end
+
+      def file_descriptor
+        @descriptor_pool.send(:get_file_descriptor, Google::Protobuf::FFI.get_message_file_def(@msg_def))
+      end
+
+      def name
+        @name ||= Google::Protobuf::FFI.get_message_fullname(self)
+      end
+
+      def each_oneof &block
+        n = Google::Protobuf::FFI.oneof_count(self)
+        0.upto(n-1) do |i|
+          yield(Google::Protobuf::FFI.get_oneof_by_index(self, i))
+        end
+        nil
+      end
+
+      def each &block
+        n = Google::Protobuf::FFI.field_count(self)
+        0.upto(n-1) do |i|
+          yield(Google::Protobuf::FFI.get_field_by_index(self, i))
+        end
+        nil
+      end
+
+      def lookup(name)
+        Google::Protobuf::FFI.get_field_by_name(self, name, name.size)
+      end
+
+      def lookup_oneof(name)
+        Google::Protobuf::FFI.get_oneof_by_name(self, name, name.size)
+      end
+
+      def msgclass
+        @msg_class ||= build_message_class
+      end
+
+      def options
+        @options ||= begin
+          size_ptr = ::FFI::MemoryPointer.new(:size_t, 1)
+          temporary_arena = Google::Protobuf::FFI.create_arena
+          buffer = Google::Protobuf::FFI.message_options(self, size_ptr, temporary_arena)
+          Google::Protobuf::MessageOptions.decode(buffer.read_string_length(size_ptr.read(:size_t)).force_encoding("ASCII-8BIT").freeze).send(:internal_deep_freeze)
+        end
+      end
+
+      private
+
+      extend Google::Protobuf::Internal::Convert
+
+      def initialize(msg_def, descriptor_pool)
+        @msg_def = msg_def
+        @msg_class = nil
+        @descriptor_pool = descriptor_pool
+      end
+
+      def self.private_constructor(msg_def, descriptor_pool)
+        instance = allocate
+        instance.send(:initialize, msg_def, descriptor_pool)
+        instance
+      end
+
+      def wrapper?
+        if defined? @wrapper
+          @wrapper
+        else
+          @wrapper = case Google::Protobuf::FFI.get_well_known_type self
+          when :DoubleValue, :FloatValue, :Int64Value, :UInt64Value, :Int32Value, :UInt32Value, :StringValue, :BytesValue, :BoolValue
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def self.get_message(msg, descriptor, arena)
+        return nil if msg.nil? or msg.null?
+        message = OBJECT_CACHE.get(msg.address)
+        if message.nil?
+          message = descriptor.msgclass.send(:private_constructor, arena, msg: msg)
+          message.send :internal_deep_freeze if frozen?
+        end
+        message
+      end
+
+      def pool
+        @descriptor_pool
+      end
+    end
+
+    class FFI
+      # MessageDef
+      attach_function :new_message_from_def, :upb_Message_New,                        [Descriptor, Internal::Arena], :Message
+      attach_function :field_count,          :upb_MessageDef_FieldCount,              [Descriptor], :int
+      attach_function :get_message_file_def, :upb_MessageDef_File,                    [:pointer], :FileDef
+      attach_function :get_message_fullname, :upb_MessageDef_FullName,                [Descriptor], :string
+      attach_function :get_mini_table,       :upb_MessageDef_MiniTable,               [Descriptor], MiniTable.ptr
+      attach_function :oneof_count,          :upb_MessageDef_OneofCount,              [Descriptor], :int
+      attach_function :message_options,      :Descriptor_serialized_options,          [Descriptor, :pointer, Internal::Arena], :pointer
+      attach_function :get_well_known_type,  :upb_MessageDef_WellKnownType,           [Descriptor], WellKnown
+      attach_function :message_def_syntax,   :upb_MessageDef_Syntax,                  [Descriptor], Syntax
+      attach_function :find_msg_def_by_name, :upb_MessageDef_FindByNameWithSize,      [Descriptor, :string, :size_t, :FieldDefPointer, :OneofDefPointer], :bool
+    end
+  end
+end

data/lib/google/protobuf/ffi/descriptor_pool.rb

@@ -0,0 +1,75 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2022 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    class FFI
+      # DefPool
+      attach_function :add_serialized_file,   :upb_DefPool_AddFile,            [:DefPool, :FileDescriptorProto, Status.by_ref], :FileDef
+      attach_function :free_descriptor_pool,  :upb_DefPool_Free,               [:DefPool], :void
+      attach_function :create_descriptor_pool,:upb_DefPool_New,                [], :DefPool
+      attach_function :get_extension_registry,:upb_DefPool_ExtensionRegistry,  [:DefPool],  :ExtensionRegistry
+      attach_function :lookup_enum,           :upb_DefPool_FindEnumByName,     [:DefPool, :string], EnumDescriptor
+      attach_function :lookup_extension,      :upb_DefPool_FindExtensionByName,[:DefPool, :string], FieldDescriptor
+      attach_function :lookup_msg,            :upb_DefPool_FindMessageByName,  [:DefPool, :string], Descriptor
+
+        # FileDescriptorProto
+      attach_function :parse,                 :FileDescriptorProto_parse,      [:binary_string, :size_t, Internal::Arena], :FileDescriptorProto
+    end
+    class DescriptorPool
+      attr :descriptor_pool
+      attr_accessor :descriptor_class_by_def
+
+      def initialize
+        @descriptor_pool = ::FFI::AutoPointer.new(Google::Protobuf::FFI.create_descriptor_pool, Google::Protobuf::FFI.method(:free_descriptor_pool))
+        @descriptor_class_by_def = {}
+
+        # Should always be the last expression of the initializer to avoid
+        # leaking references to this object before construction is complete.
+        Google::Protobuf::OBJECT_CACHE.try_add @descriptor_pool.address, self
+      end
+
+      def add_serialized_file(file_contents)
+        # Allocate memory sized to file_contents
+        memBuf = ::FFI::MemoryPointer.new(:char, file_contents.bytesize)
+        # Insert the data
+        memBuf.put_bytes(0, file_contents)
+        temporary_arena = Google::Protobuf::FFI.create_arena
+        file_descriptor_proto = Google::Protobuf::FFI.parse memBuf, file_contents.bytesize, temporary_arena
+        raise ArgumentError.new("Unable to parse FileDescriptorProto") if file_descriptor_proto.null?
+
+        status = Google::Protobuf::FFI::Status.new
+        file_descriptor = Google::Protobuf::FFI.add_serialized_file @descriptor_pool, file_descriptor_proto, status
+        if file_descriptor.null?
+          raise TypeError.new("Unable to build file to DescriptorPool: #{Google::Protobuf::FFI.error_message(status)}")
+        else
+          @descriptor_class_by_def[file_descriptor.address] = FileDescriptor.new file_descriptor, self
+        end
+      end
+
+      def lookup name
+        Google::Protobuf::FFI.lookup_msg(@descriptor_pool, name) ||
+          Google::Protobuf::FFI.lookup_enum(@descriptor_pool, name) ||
+          Google::Protobuf::FFI.lookup_extension(@descriptor_pool, name)
+      end
+
+      def self.generated_pool
+        @@generated_pool ||= DescriptorPool.new
+      end
+
+      private
+
+      # Implementation details below are subject to breaking changes without
+      # warning and are intended for use only within the gem.
+
+      def get_file_descriptor file_def
+        return nil if file_def.null?
+        @descriptor_class_by_def[file_def.address] ||= FileDescriptor.new(file_def, self)
+      end
+    end
+  end
+end

data/lib/google/protobuf/ffi/enum_descriptor.rb

@@ -0,0 +1,171 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2022 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    class EnumDescriptor
+      attr :descriptor_pool, :enum_def
+      include Enumerable
+
+      # FFI Interface methods and setup
+      extend ::FFI::DataConverter
+      native_type ::FFI::Type::POINTER
+
+      class << self
+        prepend Google::Protobuf::Internal::TypeSafety
+        include Google::Protobuf::Internal::PointerHelper
+
+        # @param value [EnumDescriptor] EnumDescriptor to convert to an FFI native type
+        # @param _ [Object] Unused
+        def to_native(value, _)
+          value.instance_variable_get(:@enum_def) || ::FFI::Pointer::NULL
+        end
+
+        ##
+        # @param enum_def [::FFI::Pointer] EnumDef pointer to be wrapped
+        # @param _ [Object] Unused
+        def from_native(enum_def, _)
+          return nil if enum_def.nil? or enum_def.null?
+          file_def = Google::Protobuf::FFI.get_message_file_def enum_def
+          descriptor_from_file_def(file_def, enum_def)
+        end
+      end
+
+      def self.new(*arguments, &block)
+        raise "Descriptor objects may not be created from Ruby."
+      end
+
+      def file_descriptor
+        @descriptor_pool.send(:get_file_descriptor, Google::Protobuf::FFI.get_enum_file_descriptor(self))
+      end
+
+      def name
+        Google::Protobuf::FFI.get_enum_fullname(self)
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        "#{self.class.name}: #{name}"
+      end
+
+      def lookup_name(name)
+        self.class.send(:lookup_name, self, name)
+      end
+
+      def lookup_value(number)
+        self.class.send(:lookup_value, self, number)
+      end
+
+      def each &block
+        n = Google::Protobuf::FFI.enum_value_count(self)
+        0.upto(n - 1) do |i|
+          enum_value = Google::Protobuf::FFI.enum_value_by_index(self, i)
+          yield(Google::Protobuf::FFI.enum_name(enum_value).to_sym, Google::Protobuf::FFI.enum_number(enum_value))
+        end
+        nil
+      end
+
+      def enummodule
+        if @module.nil?
+          @module = build_enum_module
+        end
+        @module
+      end
+
+      def options
+        @options ||= begin
+          size_ptr = ::FFI::MemoryPointer.new(:size_t, 1)
+          temporary_arena = Google::Protobuf::FFI.create_arena
+          buffer = Google::Protobuf::FFI.enum_options(self, size_ptr, temporary_arena)
+          Google::Protobuf::EnumOptions.decode(buffer.read_string_length(size_ptr.read(:size_t)).force_encoding("ASCII-8BIT").freeze).send(:internal_deep_freeze)
+        end
+      end
+
+      private
+
+      def initialize(enum_def, descriptor_pool)
+        @descriptor_pool = descriptor_pool
+        @enum_def = enum_def
+        @module = nil
+      end
+
+      def self.private_constructor(enum_def, descriptor_pool)
+        instance = allocate
+        instance.send(:initialize, enum_def, descriptor_pool)
+        instance
+      end
+
+      def self.lookup_value(enum_def, number)
+        enum_value = Google::Protobuf::FFI.enum_value_by_number(enum_def, number)
+        if enum_value.null?
+          nil
+        else
+          Google::Protobuf::FFI.enum_name(enum_value).to_sym
+        end
+      end
+
+      def self.lookup_name(enum_def, name)
+        enum_value = Google::Protobuf::FFI.enum_value_by_name(enum_def, name.to_s, name.size)
+        if enum_value.null?
+          nil
+        else
+          Google::Protobuf::FFI.enum_number(enum_value)
+        end
+      end
+
+      def build_enum_module
+        descriptor = self
+        dynamic_module = Module.new do
+          @descriptor = descriptor
+
+          class << self
+            attr_accessor :descriptor
+          end
+
+          def self.lookup(number)
+            descriptor.lookup_value number
+          end
+
+          def self.resolve(name)
+            descriptor.lookup_name name
+          end
+        end
+
+        self.each do |name, value|
+          if name[0] < 'A' || name[0] > 'Z'
+            if name[0] >= 'a' and name[0] <= 'z'
+              name = name[0].upcase + name[1..-1] # auto capitalize
+            else
+              warn(
+                "Enum value '#{name}' does not start with an uppercase letter " +
+                  "as is required for Ruby constants.")
+              next
+            end
+          end
+          dynamic_module.const_set(name.to_sym, value)
+        end
+        dynamic_module
+      end
+    end
+
+    class FFI
+      # EnumDescriptor
+      attach_function :get_enum_file_descriptor,  :upb_EnumDef_File,                   [EnumDescriptor], :FileDef
+      attach_function :enum_value_by_name,        :upb_EnumDef_FindValueByNameWithSize,[EnumDescriptor, :string, :size_t], :EnumValueDef
+      attach_function :enum_value_by_number,      :upb_EnumDef_FindValueByNumber,      [EnumDescriptor, :int], :EnumValueDef
+      attach_function :get_enum_fullname,         :upb_EnumDef_FullName,               [EnumDescriptor], :string
+      attach_function :enum_options,              :EnumDescriptor_serialized_options,  [EnumDescriptor, :pointer, Internal::Arena], :pointer
+      attach_function :enum_value_by_index,       :upb_EnumDef_Value,                  [EnumDescriptor, :int], :EnumValueDef
+      attach_function :enum_value_count,          :upb_EnumDef_ValueCount,             [EnumDescriptor], :int
+      attach_function :enum_name,                 :upb_EnumValueDef_Name,              [:EnumValueDef], :string
+      attach_function :enum_number,               :upb_EnumValueDef_Number,            [:EnumValueDef], :int
+    end
+  end
+end

data/lib/google/protobuf/ffi/ffi.rb

@@ -0,0 +1,213 @@
+# Protocol Buffers - Google's data interchange format
+# Copyright 2022 Google Inc.  All rights reserved.
+#
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file or at
+# https://developers.google.com/open-source/licenses/bsd
+
+module Google
+  module Protobuf
+    class FFI
+      extend ::FFI::Library
+      # Workaround for Bazel's use of symlinks + JRuby's __FILE__ and `caller`
+      # that resolves them.
+      if ENV['BAZEL'] == 'true'
+        ffi_lib ::FFI::Compiler::Loader.find 'protobuf_c_ffi', ENV['PWD']
+      else
+        ffi_lib ::FFI::Compiler::Loader.find 'protobuf_c_ffi'
+      end
+
+      ## Map
+      Upb_Map_Begin = -1
+
+      ## Encoding Status
+      Upb_Status_MaxMessage = 127
+      Upb_Encode_Deterministic = 1
+      Upb_Encode_SkipUnknown = 2
+
+      ## JSON Encoding options
+      # When set, emits 0/default values.  TODO: proto3 only?
+      Upb_JsonEncode_EmitDefaults = 1
+      # When set, use normal (snake_case) field names instead of JSON (camelCase) names.
+      Upb_JsonEncode_UseProtoNames = 2
+      # When set, emits enums as their integer values instead of as their names.
+      Upb_JsonEncode_FormatEnumsAsIntegers = 4
+
+      ## JSON Decoding options
+      Upb_JsonDecode_IgnoreUnknown = 1
+
+      typedef :pointer, :Array
+      typedef :pointer, :DefPool
+      typedef :pointer, :EnumValueDef
+      typedef :pointer, :ExtensionRegistry
+      typedef :pointer, :FieldDefPointer
+      typedef :pointer, :FileDef
+      typedef :pointer, :FileDescriptorProto
+      typedef :pointer, :Map
+      typedef :pointer, :Message    # Instances of a message
+      typedef :pointer, :OneofDefPointer
+      typedef :pointer, :binary_string
+      if ::FFI::Platform::ARCH == "aarch64"
+        typedef :u_int8_t, :uint8_t
+        typedef :u_int16_t, :uint16_t
+        typedef :u_int32_t, :uint32_t
+        typedef :u_int64_t, :uint64_t
+      end
+
+      FieldType = enum(
+        :double, 1,
+        :float,
+        :int64,
+        :uint64,
+        :int32,
+        :fixed64,
+        :fixed32,
+        :bool,
+        :string,
+        :group,
+        :message,
+        :bytes,
+        :uint32,
+        :enum,
+        :sfixed32,
+        :sfixed64,
+        :sint32,
+        :sint64
+      )
+
+      CType = enum(
+        :bool, 1,
+        :float,
+        :int32,
+        :uint32,
+        :enum,
+        :message,
+        :double,
+        :int64,
+        :uint64,
+        :string,
+        :bytes
+      )
+
+      Label = enum(
+        :optional, 1,
+        :required,
+        :repeated
+      )
+
+      Syntax = enum(
+        :Proto2, 2,
+        :Proto3
+      )
+
+      # All the different kind of well known type messages. For simplicity of check,
+      # number wrappers and string wrappers are grouped together. Make sure the
+      # order and merber of these groups are not changed.
+
+      WellKnown = enum(
+        :Unspecified,
+        :Any,
+        :FieldMask,
+        :Duration,
+        :Timestamp,
+        # number wrappers
+        :DoubleValue,
+        :FloatValue,
+        :Int64Value,
+        :UInt64Value,
+        :Int32Value,
+        :UInt32Value,
+        # string wrappers
+        :StringValue,
+        :BytesValue,
+        :BoolValue,
+        :Value,
+        :ListValue,
+        :Struct
+      )
+
+      DecodeStatus = enum(
+        :Ok,
+        :Malformed,         # Wire format was corrupt
+        :OutOfMemory,       # Arena alloc failed
+        :BadUtf8,           # String field had bad UTF-8
+        :MaxDepthExceeded,  # Exceeded UPB_DECODE_MAXDEPTH
+
+        # CheckRequired failed, but the parse otherwise succeeded.
+        :MissingRequired,
+      )
+
+      EncodeStatus = enum(
+        :Ok,
+        :OutOfMemory,       # Arena alloc failed
+        :MaxDepthExceeded,  # Exceeded UPB_DECODE_MAXDEPTH
+
+        # CheckRequired failed, but the parse otherwise succeeded.
+        :MissingRequired,
+      )
+
+      class StringView < ::FFI::Struct
+        layout :data, :pointer,
+               :size, :size_t
+      end
+
+      class MiniTable < ::FFI::Struct
+        layout :subs, :pointer,
+               :fields, :pointer,
+               :size, :uint16_t,
+               :field_count, :uint16_t,
+               :ext, :uint8_t,  # upb_ExtMode, declared as uint8_t so sizeof(ext) == 1
+               :dense_below, :uint8_t,
+               :table_mask, :uint8_t,
+               :required_count, :uint8_t  # Required fields have the lowest hasbits.
+        # To statically initialize the tables of variable length, we need a flexible
+        # array member, and we need to compile in gnu99 mode (constant initialization
+        # of flexible array members is a GNU extension, not in C99 unfortunately. */
+        #       _upb_FastTable_Entry fasttable[];
+      end
+
+      class Status < ::FFI::Struct
+        layout :ok, :bool,
+               :msg, [:char, Upb_Status_MaxMessage]
+
+        def initialize
+          super
+          FFI.clear self
+        end
+      end
+
+      class MessageValue < ::FFI::Union
+        layout :bool_val, :bool,
+               :float_val, :float,
+               :double_val, :double,
+               :int32_val, :int32_t,
+               :int64_val, :int64_t,
+               :uint32_val, :uint32_t,
+               :uint64_val,:uint64_t,
+               :map_val, :pointer,
+               :msg_val, :pointer,
+               :array_val,:pointer,
+               :str_val, StringView
+      end
+
+      class MutableMessageValue < ::FFI::Union
+        layout :map, :Map,
+               :msg, :Message,
+               :array, :Array
+      end
+
+      # Status
+      attach_function :clear,                 :upb_Status_Clear, [Status.by_ref], :void
+      attach_function :error_message,         :upb_Status_ErrorMessage, [Status.by_ref], :string
+
+      # Generic
+      attach_function :memcmp, [:pointer, :pointer, :size_t], :int
+      attach_function :memcpy, [:pointer, :pointer, :size_t], :int
+
+      # Alternatives to pre-processor macros
+      def self.decode_max_depth(i)
+        i << 16
+      end
+    end
+  end
+end