google-protobuf 4.28.2 → 4.30.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50f7cd8abfe74257e6fa183325ec76d6590fa2e650139a7e8c06be67b1a37265
-  data.tar.gz: f19365b4373475b2c7d7570aceaa993cb0718fe37525ca392df3a2629dc48f85
+  metadata.gz: b5125cc8af8296e8ccc158044588e8aa997acb0a4dfc12b8f70207c4b6e0e312
+  data.tar.gz: 9aaaeb8e9c9b0ced47d7c14a5d3d2da37e43c6b12fd32177d87fa055b59426d0
 SHA512:
-  metadata.gz: cb6543ae37709a2a1e57498a2c4125bf1f8dca38efb0e80ca65389e34ef2a9b7613a5a57923d485f4dc0011bfe37a538480d1e2e999eb0f84945a10bef561c10
-  data.tar.gz: 051b5e72dc158ecb34e8a0627be5e7efe17245f1c6be5487d8c04ff746701138a62439e479633c0479f722c62d694b6ca5f32f06193e341f8067759c187aa578
+  metadata.gz: cc4490fe009fdf955ac03163cde61170975faba127c6987819321d6c45ef9d20823f44d25b883881c5bb2faab630c01e8a0519a20466abc624d018a759a73b33
+  data.tar.gz: 7b2364e5c5a7056df7684eed5be81b03f4806a53e8f8f9e381f879b8c11e640e191ab72e1abbf7db56f1aae8e299d4f260b2138367f657911542ad87174f031a

data/ext/google/protobuf_c/convert.c

@@ -112,16 +112,9 @@ VALUE Convert_CheckStringUtf8(VALUE str) {
     // not mean that it is *valid* UTF-8.  We have to check separately
     // whether it is valid.
     if (rb_enc_str_coderange(str) == ENC_CODERANGE_BROKEN) {
-      // TODO: For now
-      // we only warn for this case.  We will remove the warning and throw an
-      // exception below in the 30.x release
-
-      rb_warn(
-          "String is invalid UTF-8. This will be an error in a future "
-          "version.");
-      // VALUE exc = rb_const_get_at(
-      //     rb_cEncoding, rb_intern("InvalidByteSequenceError"));
-      // rb_raise(exc, "String is invalid UTF-8");
+      VALUE exc = rb_const_get_at(
+          rb_cEncoding, rb_intern("InvalidByteSequenceError"));
+      rb_raise(exc, "String is invalid UTF-8");
     }
   } else {
     // Note: this will not duplicate underlying string data unless

data/ext/google/protobuf_c/defs.c

@@ -7,7 +7,6 @@
 
 #include <ctype.h>
 #include <errno.h>
-#include <ruby/version.h>
 
 #include "convert.h"
 #include "message.h"
@@ -147,8 +146,8 @@ VALUE DescriptorPool_add_serialized_file(VALUE _self,
  * call-seq:
  *     DescriptorPool.lookup(name) => descriptor
  *
- * Finds a Descriptor, EnumDescriptor or FieldDescriptor by name and returns it,
- * or nil if none exists with the given name.
+ * Finds a Descriptor, EnumDescriptor, FieldDescriptor or ServiceDescriptor by
+ * name and returns it, or nil if none exists with the given name.
  */
 static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
   DescriptorPool* self = ruby_to_DescriptorPool(_self);
@@ -452,6 +451,27 @@ static VALUE Descriptor_options(VALUE _self) {
   return message_options;
 }
 
+/*
+ * call-seq:
+ *     Descriptor.to_proto => DescriptorProto
+ *
+ * Returns the `DescriptorProto` of this `Descriptor`.
+ */
+static VALUE Descriptor_to_proto(VALUE _self) {
+  Descriptor* self = ruby_to_Descriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_DescriptorProto* proto =
+      upb_MessageDef_ToProto(self->msgdef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_DescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::DescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void Descriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "Descriptor", rb_cObject);
   rb_define_alloc_func(klass, Descriptor_alloc);
@@ -464,6 +484,7 @@ static void Descriptor_register(VALUE module) {
   rb_define_method(klass, "name", Descriptor_name, 0);
   rb_define_method(klass, "file_descriptor", Descriptor_file_descriptor, 0);
   rb_define_method(klass, "options", Descriptor_options, 0);
+  rb_define_method(klass, "to_proto", Descriptor_to_proto, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cDescriptor);
   cDescriptor = klass;
@@ -559,12 +580,37 @@ static VALUE FileDescriptor_options(VALUE _self) {
   return file_options;
 }
 
+/*
+ * call-seq:
+ *     FileDescriptor.to_proto => FileDescriptorProto
+ *
+ * Returns the `FileDescriptorProto` of this `FileDescriptor`.
+ */
+static VALUE FileDescriptor_to_proto(VALUE _self) {
+  FileDescriptor* self = ruby_to_FileDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_FileDescriptorProto* file_proto =
+      upb_FileDef_ToProto(self->filedef, arena);
+
+  size_t size;
+  const char* serialized =
+      google_protobuf_FileDescriptorProto_serialize(file_proto, arena, &size);
+
+  VALUE file_proto_class =
+      rb_path2class("Google::Protobuf::FileDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, file_proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void FileDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "FileDescriptor", rb_cObject);
   rb_define_alloc_func(klass, FileDescriptor_alloc);
   rb_define_method(klass, "initialize", FileDescriptor_initialize, 3);
   rb_define_method(klass, "name", FileDescriptor_name, 0);
   rb_define_method(klass, "options", FileDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", FileDescriptor_to_proto, 0);
   rb_gc_register_address(&cFileDescriptor);
   cFileDescriptor = klass;
 }
@@ -957,6 +1003,27 @@ static VALUE FieldDescriptor_options(VALUE _self) {
   return field_options;
 }
 
+/*
+ * call-seq:
+ *     FieldDescriptor.to_proto => FieldDescriptorProto
+ *
+ * Returns the `FieldDescriptorProto` of this `FieldDescriptor`.
+ */
+static VALUE FieldDescriptor_to_proto(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_FieldDescriptorProto* proto =
+      upb_FieldDef_ToProto(self->fielddef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_FieldDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::FieldDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void FieldDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "FieldDescriptor", rb_cObject);
   rb_define_alloc_func(klass, FieldDescriptor_alloc);
@@ -976,6 +1043,7 @@ static void FieldDescriptor_register(VALUE module) {
   rb_define_method(klass, "get", FieldDescriptor_get, 1);
   rb_define_method(klass, "set", FieldDescriptor_set, 2);
   rb_define_method(klass, "options", FieldDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", FieldDescriptor_to_proto, 0);
   rb_gc_register_address(&cFieldDescriptor);
   cFieldDescriptor = klass;
 }
@@ -1094,6 +1162,27 @@ static VALUE OneOfDescriptor_options(VALUE _self) {
   return oneof_options;
 }
 
+/*
+ * call-seq:
+ *     OneofDescriptor.to_proto => OneofDescriptorProto
+ *
+ * Returns the `OneofDescriptorProto` of this `OneofDescriptor`.
+ */
+static VALUE OneOfDescriptor_to_proto(VALUE _self) {
+  OneofDescriptor* self = ruby_to_OneofDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_OneofDescriptorProto* proto =
+      upb_OneofDef_ToProto(self->oneofdef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_OneofDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::OneofDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void OneofDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "OneofDescriptor", rb_cObject);
   rb_define_alloc_func(klass, OneofDescriptor_alloc);
@@ -1101,6 +1190,7 @@ static void OneofDescriptor_register(VALUE module) {
   rb_define_method(klass, "name", OneofDescriptor_name, 0);
   rb_define_method(klass, "each", OneofDescriptor_each, 0);
   rb_define_method(klass, "options", OneOfDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", OneOfDescriptor_to_proto, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cOneofDescriptor);
   cOneofDescriptor = klass;
@@ -1299,6 +1389,29 @@ static VALUE EnumDescriptor_options(VALUE _self) {
   return enum_options;
 }
 
+/*
+ * call-seq:
+ *     EnumDescriptor.to_proto => EnumDescriptorProto
+ *
+ * Returns the `EnumDescriptorProto` of this `EnumDescriptor`.
+ */
+static VALUE EnumDescriptor_to_proto(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_EnumDescriptorProto* proto =
+      upb_EnumDef_ToProto(self->enumdef, arena);
+
+  size_t size;
+  const char* serialized =
+      google_protobuf_EnumDescriptorProto_serialize(proto, arena, &size);
+
+  VALUE proto_class = rb_path2class("Google::Protobuf::EnumDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void EnumDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "EnumDescriptor", rb_cObject);
   rb_define_alloc_func(klass, EnumDescriptor_alloc);
@@ -1311,6 +1424,7 @@ static void EnumDescriptor_register(VALUE module) {
   rb_define_method(klass, "file_descriptor", EnumDescriptor_file_descriptor, 0);
   rb_define_method(klass, "is_closed?", EnumDescriptor_is_closed, 0);
   rb_define_method(klass, "options", EnumDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", EnumDescriptor_to_proto, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cEnumDescriptor);
   cEnumDescriptor = klass;
@@ -1439,6 +1553,27 @@ static VALUE ServiceDescriptor_options(VALUE _self) {
   return service_options;
 }
 
+/*
+ * call-seq:
+ *     ServiceDescriptor.to_proto => ServiceDescriptorProto
+ *
+ * Returns the `ServiceDescriptorProto` of this `ServiceDescriptor`.
+ */
+static VALUE ServiceDescriptor_to_proto(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_ServiceDescriptorProto* proto =
+      upb_ServiceDef_ToProto(self->servicedef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_ServiceDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::ServiceDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 static void ServiceDescriptor_register(VALUE module) {
   VALUE klass = rb_define_class_under(module, "ServiceDescriptor", rb_cObject);
   rb_define_alloc_func(klass, ServiceDescriptor_alloc);
@@ -1448,6 +1583,7 @@ static void ServiceDescriptor_register(VALUE module) {
   rb_define_method(klass, "file_descriptor", ServiceDescriptor_file_descriptor,
                    0);
   rb_define_method(klass, "options", ServiceDescriptor_options, 0);
+  rb_define_method(klass, "to_proto", ServiceDescriptor_to_proto, 0);
   rb_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cServiceDescriptor);
   cServiceDescriptor = klass;
@@ -1581,6 +1717,27 @@ static VALUE MethodDescriptor_client_streaming(VALUE _self) {
   return upb_MethodDef_ClientStreaming(self->methoddef) ? Qtrue : Qfalse;
 }
 
+/*
+ * call-seq:
+ *     MethodDescriptor.to_proto => MethodDescriptorProto
+ *
+ * Returns the `MethodDescriptorProto` of this `MethodDescriptor`.
+ */
+static VALUE MethodDescriptor_to_proto(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  upb_Arena* arena = upb_Arena_New();
+  google_protobuf_MethodDescriptorProto* proto =
+      upb_MethodDef_ToProto(self->methoddef, arena);
+  size_t size;
+  const char* serialized =
+      google_protobuf_MethodDescriptorProto_serialize(proto, arena, &size);
+  VALUE proto_class = rb_path2class("Google::Protobuf::MethodDescriptorProto");
+  VALUE proto_rb =
+      Message_decode_bytes(size, serialized, 0, proto_class, false);
+  upb_Arena_Free(arena);
+  return proto_rb;
+}
+
 /*
  * call-seq:
  *      MethodDescriptor.server_streaming => bool
@@ -1604,6 +1761,7 @@ static void MethodDescriptor_register(VALUE module) {
                    0);
   rb_define_method(klass, "server_streaming", MethodDescriptor_server_streaming,
                    0);
+  rb_define_method(klass, "to_proto", MethodDescriptor_to_proto, 0);
   rb_gc_register_address(&cMethodDescriptor);
   cMethodDescriptor = klass;
 }

data/ext/google/protobuf_c/extconf.rb

@@ -6,6 +6,18 @@ ext_name = "google/protobuf_c"
 
 dir_config(ext_name)
 
+if ENV["CC"]
+  RbConfig::CONFIG["CC"] = RbConfig::MAKEFILE_CONFIG["CC"] = ENV["CC"]
+end
+
+if ENV["CXX"]
+  RbConfig::CONFIG["CXX"] = RbConfig::MAKEFILE_CONFIG["CXX"] = ENV["CXX"]
+end
+
+if ENV["LD"]
+  RbConfig::CONFIG["LD"] = RbConfig::MAKEFILE_CONFIG["LD"] = ENV["LD"]
+end
+
 if RUBY_PLATFORM =~ /darwin/ || RUBY_PLATFORM =~ /linux/ || RUBY_PLATFORM =~ /freebsd/
   $CFLAGS += " -std=gnu99 -O3 -DNDEBUG -fvisibility=hidden -Wall -Wsign-compare -Wno-declaration-after-statement"
 else

data/ext/google/protobuf_c/glue.c

@@ -26,6 +26,15 @@ char* EnumDescriptor_serialized_options(const upb_EnumDef* enumdef,
   return serialized;
 }
 
+char* EnumDescriptor_serialized_to_proto(const upb_EnumDef* enumdef,
+                                         size_t* size, upb_Arena* arena) {
+  const google_protobuf_EnumDescriptorProto* file_proto =
+      upb_EnumDef_ToProto(enumdef, arena);
+  char* serialized =
+      google_protobuf_EnumDescriptorProto_serialize(file_proto, arena, size);
+  return serialized;
+}
+
 char* FileDescriptor_serialized_options(const upb_FileDef* filedef,
                                         size_t* size, upb_Arena* arena) {
   const google_protobuf_FileOptions* opts = upb_FileDef_Options(filedef);
@@ -33,6 +42,15 @@ char* FileDescriptor_serialized_options(const upb_FileDef* filedef,
   return serialized;
 }
 
+char* FileDescriptor_serialized_to_proto(const upb_FileDef* filedef,
+                                         size_t* size, upb_Arena* arena) {
+  const google_protobuf_FileDescriptorProto* file_proto =
+      upb_FileDef_ToProto(filedef, arena);
+  char* serialized =
+      google_protobuf_FileDescriptorProto_serialize(file_proto, arena, size);
+  return serialized;
+}
+
 char* Descriptor_serialized_options(const upb_MessageDef* msgdef, size_t* size,
                                     upb_Arena* arena) {
   const google_protobuf_MessageOptions* opts = upb_MessageDef_Options(msgdef);
@@ -41,6 +59,15 @@ char* Descriptor_serialized_options(const upb_MessageDef* msgdef, size_t* size,
   return serialized;
 }
 
+char* Descriptor_serialized_to_proto(const upb_MessageDef* msgdef, size_t* size,
+                                     upb_Arena* arena) {
+  const google_protobuf_DescriptorProto* proto =
+      upb_MessageDef_ToProto(msgdef, arena);
+  char* serialized =
+      google_protobuf_DescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
 char* OneOfDescriptor_serialized_options(const upb_OneofDef* oneofdef,
                                          size_t* size, upb_Arena* arena) {
   const google_protobuf_OneofOptions* opts = upb_OneofDef_Options(oneofdef);
@@ -48,6 +75,15 @@ char* OneOfDescriptor_serialized_options(const upb_OneofDef* oneofdef,
   return serialized;
 }
 
+char* OneOfDescriptor_serialized_to_proto(const upb_OneofDef* oneofdef,
+                                          size_t* size, upb_Arena* arena) {
+  const google_protobuf_OneofDescriptorProto* proto =
+      upb_OneofDef_ToProto(oneofdef, arena);
+  char* serialized =
+      google_protobuf_OneofDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
 char* FieldDescriptor_serialized_options(const upb_FieldDef* fielddef,
                                          size_t* size, upb_Arena* arena) {
   const google_protobuf_FieldOptions* opts = upb_FieldDef_Options(fielddef);
@@ -55,6 +91,15 @@ char* FieldDescriptor_serialized_options(const upb_FieldDef* fielddef,
   return serialized;
 }
 
+char* FieldDescriptor_serialized_to_proto(const upb_FieldDef* fieldef,
+                                          size_t* size, upb_Arena* arena) {
+  const google_protobuf_FieldDescriptorProto* proto =
+      upb_FieldDef_ToProto(fieldef, arena);
+  char* serialized =
+      google_protobuf_FieldDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
 char* ServiceDescriptor_serialized_options(const upb_ServiceDef* servicedef,
                                            size_t* size, upb_Arena* arena) {
   const google_protobuf_ServiceOptions* opts =
@@ -64,9 +109,27 @@ char* ServiceDescriptor_serialized_options(const upb_ServiceDef* servicedef,
   return serialized;
 }
 
+char* ServiceDescriptor_serialized_to_proto(const upb_ServiceDef* servicedef,
+                                            size_t* size, upb_Arena* arena) {
+  const google_protobuf_ServiceDescriptorProto* proto =
+      upb_ServiceDef_ToProto(servicedef, arena);
+  char* serialized =
+      google_protobuf_ServiceDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}
+
 char* MethodDescriptor_serialized_options(const upb_MethodDef* methoddef,
                                           size_t* size, upb_Arena* arena) {
   const google_protobuf_MethodOptions* opts = upb_MethodDef_Options(methoddef);
   char* serialized = google_protobuf_MethodOptions_serialize(opts, arena, size);
   return serialized;
 }
+
+char* MethodDescriptor_serialized_to_proto(const upb_MethodDef* methodef,
+                                           size_t* size, upb_Arena* arena) {
+  const google_protobuf_MethodDescriptorProto* proto =
+      upb_MethodDef_ToProto(methodef, arena);
+  char* serialized =
+      google_protobuf_MethodDescriptorProto_serialize(proto, arena, size);
+  return serialized;
+}

data/ext/google/protobuf_c/message.c

@@ -362,7 +362,8 @@ static VALUE Message_field_accessor(VALUE _self, const upb_FieldDef* f,
       if (!upb_FieldDef_HasPresence(f)) {
         rb_raise(rb_eRuntimeError, "Field does not have presence.");
       }
-      return upb_Message_HasFieldByDef(Message_Get(_self, NULL), f);
+      return upb_Message_HasFieldByDef(Message_Get(_self, NULL), f) ? Qtrue
+                                                                    : Qfalse;
     case METHOD_WRAPPER_GETTER: {
       Message* self = ruby_to_Message(_self);
       if (upb_Message_HasFieldByDef(self->msg, f)) {
@@ -1038,11 +1039,18 @@ static VALUE Message_decode_json(int argc, VALUE* argv, VALUE klass) {
 
   upb_Status_Clear(&status);
   const upb_DefPool* pool = upb_FileDef_Pool(upb_MessageDef_File(msg->msgdef));
-  if (!upb_JsonDecode(RSTRING_PTR(data), RSTRING_LEN(data),
-                      (upb_Message*)msg->msg, msg->msgdef, pool, options,
-                      Arena_get(msg->arena), &status)) {
-    rb_raise(cParseError, "Error occurred during parsing: %s",
-             upb_Status_ErrorMessage(&status));
+
+  int result = upb_JsonDecodeDetectingNonconformance(
+      RSTRING_PTR(data), RSTRING_LEN(data), (upb_Message*)msg->msg,
+      msg->msgdef, pool, options, Arena_get(msg->arena), &status);
+
+  switch (result) {
+    case kUpb_JsonDecodeResult_Ok:
+      break;
+    case kUpb_JsonDecodeResult_Error:
+      rb_raise(cParseError, "Error occurred during parsing: %s",
+               upb_Status_ErrorMessage(&status));
+      break;
   }
 
   return msg_rb;

data/ext/google/protobuf_c/protobuf.c

@@ -7,8 +7,6 @@
 
 #include "protobuf.h"
 
-#include <ruby/version.h>
-
 #include "defs.h"
 #include "map.h"
 #include "message.h"
@@ -288,7 +286,8 @@ VALUE ObjectCache_Get(const void *key) {
 static VALUE Google_Protobuf_discard_unknown(VALUE self, VALUE msg_rb) {
   const upb_MessageDef *m;
   upb_Message *msg = Message_GetMutable(msg_rb, &m);
-  if (!upb_Message_DiscardUnknown(msg, m, 128)) {
+  const upb_DefPool* ext_pool = upb_FileDef_Pool(upb_MessageDef_File(m));
+  if (!upb_Message_DiscardUnknown(msg, m, ext_pool, 128)) {
     rb_raise(rb_eRuntimeError, "Messages nested too deeply.");
   }