google-protobuf 3.25.5-x86-linux → 4.29.1-x86-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ac081ad3cea69498cc62542d51bee76920e378824d78009f315ce7af6be9923
-  data.tar.gz: 840ab046c1c67627268dd6bf56b2cd5be4aa7f80b4d66546181cf9f0ac97f9ab
+  metadata.gz: ebb3e4e741e4105faf7de470a788fb10a4da63afe0fdd5ab6e22444d7f529d2a
+  data.tar.gz: 82ecf28b30f570d58e214a5c9bc6818b02a83050d9e23ab9b56813aab82f9a0b
 SHA512:
-  metadata.gz: b64fea6efa5c3a3ea446adbeb213aa6d47881867f65b63a54f6c277240c15074441db7c353078c51e5d47047fc1b0947bd8260c89865bfe397a7cd4ba66935d7
-  data.tar.gz: 8ab8790db6d588c5b9d0a9166fe99153c80db0d1ce23e3fe641c834507ec58d224ebb62655ff2383939b6d0759fbae314287c93bdc4ef307ecb8b7ca1455bd60
+  metadata.gz: 2d25851ea3c8d18d8ebc77102863884cc16a2ccb449f48aa98439e8fb3dbc14c590350a31103c064689d82ba69a0d1d3b60464975f0e4d8c2f3d35b7f1b96b38
+  data.tar.gz: d2c02c9717aa8f5d411ef58adf6c513cd7291810e1c1c1bdc692dfd8b8ca43fba6efddcdc1b5c9e60db5f48b2131bca5ceb2dc42e4a0282d8c369a3119a60e53

data/ext/google/protobuf_c/convert.c

@@ -104,6 +104,41 @@ unknownval:
   rb_raise(rb_eRangeError, "Unknown symbol value for enum field '%s'.", name);
 }
 
+VALUE Convert_CheckStringUtf8(VALUE str) {
+  VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
+
+  if (rb_obj_encoding(str) == utf8) {
+    // Note: Just because a string is marked as having UTF-8 encoding does
+    // 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");
+    }
+  } else {
+    // Note: this will not duplicate underlying string data unless
+    // necessary.
+    //
+    // This will throw an exception if the conversion cannot be performed:
+    // - Encoding::UndefinedConversionError if certain characters cannot be
+    //   converted to UTF-8.
+    // - Encoding::InvalidByteSequenceError if certain characters were invalid
+    //   in the source encoding.
+    str = rb_str_encode(str, utf8, 0, Qnil);
+    PBRUBY_ASSERT(rb_enc_str_coderange(str) != ENC_CODERANGE_BROKEN);
+  }
+
+  return str;
+}
+
 upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
                                    TypeInfo type_info, upb_Arena* arena) {
   upb_MessageValue ret;
@@ -137,29 +172,18 @@ upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
       }
       break;
     }
-    case kUpb_CType_String: {
-      VALUE utf8 = rb_enc_from_encoding(rb_utf8_encoding());
+    case kUpb_CType_String:
       if (rb_obj_class(value) == rb_cSymbol) {
         value = rb_funcall(value, rb_intern("to_s"), 0);
-      } else if (rb_obj_class(value) != rb_cString) {
+      } else if (!rb_obj_is_kind_of(value, rb_cString)) {
         rb_raise(cTypeError,
                  "Invalid argument for string field '%s' (given %s).", name,
                  rb_class2name(CLASS_OF(value)));
       }
 
-      if (rb_obj_encoding(value) != utf8) {
-        // Note: this will not duplicate underlying string data unless
-        // necessary.
-        value = rb_str_encode(value, utf8, 0, Qnil);
-
-        if (rb_enc_str_coderange(value) == ENC_CODERANGE_BROKEN) {
-          rb_raise(rb_eEncodingError, "String is invalid UTF-8");
-        }
-      }
-
+      value = Convert_CheckStringUtf8(value);
       ret.str_val = Convert_StringData(value, arena);
       break;
-    }
     case kUpb_CType_Bytes: {
       VALUE bytes = rb_enc_from_encoding(rb_ascii8bit_encoding());
       if (rb_obj_class(value) != rb_cString) {
@@ -204,11 +228,13 @@ upb_MessageValue Convert_RubyToUpb(VALUE value, const char* name,
           ret.uint64_val = NUM2ULL(value);
           break;
         default:
-          break;
+          rb_raise(cTypeError, "Convert_RubyToUpb(): Unexpected type %d",
+                   (int)type_info.type);
       }
       break;
     default:
-      break;
+      rb_raise(cTypeError,
+                "Convert_RubyToUpb(): Unexpected type %d", (int)type_info.type);
   }
 
   return ret;
@@ -296,7 +322,8 @@ bool Msgval_IsEqual(upb_MessageValue val1, upb_MessageValue val2,
   if (upb_Status_IsOk(&status)) {
     return return_value;
   } else {
-    rb_raise(rb_eRuntimeError, upb_Status_ErrorMessage(&status));
+    rb_raise(rb_eRuntimeError, "Msgval_IsEqual(): %s",
+             upb_Status_ErrorMessage(&status));
   }
 }
 
@@ -309,6 +336,7 @@ uint64_t Msgval_GetHash(upb_MessageValue val, TypeInfo type_info,
   if (upb_Status_IsOk(&status)) {
     return return_value;
   } else {
-    rb_raise(rb_eRuntimeError, upb_Status_ErrorMessage(&status));
+    rb_raise(rb_eRuntimeError, "Msgval_GetHash(): %s",
+             upb_Status_ErrorMessage(&status));
   }
 }

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"
@@ -23,6 +22,9 @@ static VALUE get_enumdef_obj(VALUE descriptor_pool, const upb_EnumDef* def);
 static VALUE get_fielddef_obj(VALUE descriptor_pool, const upb_FieldDef* def);
 static VALUE get_filedef_obj(VALUE descriptor_pool, const upb_FileDef* def);
 static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_OneofDef* def);
+static VALUE get_servicedef_obj(VALUE descriptor_pool,
+                                const upb_ServiceDef* def);
+static VALUE get_methoddef_obj(VALUE descriptor_pool, const upb_MethodDef* def);
 
 // A distinct object that is not accessible from Ruby.  We use this as a
 // constructor argument to enforce that certain objects cannot be created from
@@ -153,6 +155,7 @@ static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
   const upb_MessageDef* msgdef;
   const upb_EnumDef* enumdef;
   const upb_FieldDef* fielddef;
+  const upb_ServiceDef* servicedef;
 
   msgdef = upb_DefPool_FindMessageByName(self->symtab, name_str);
   if (msgdef) {
@@ -169,6 +172,11 @@ static VALUE DescriptorPool_lookup(VALUE _self, VALUE name) {
     return get_enumdef_obj(_self, enumdef);
   }
 
+  servicedef = upb_DefPool_FindServiceByName(self->symtab, name_str);
+  if (servicedef) {
+    return get_servicedef_obj(_self, servicedef);
+  }
+
   return Qnil;
 }
 
@@ -257,7 +265,20 @@ static VALUE decode_options(VALUE self, const char* option_type, int size,
   VALUE desc_rb = get_msgdef_obj(descriptor_pool, msgdef);
   const Descriptor* desc = ruby_to_Descriptor(desc_rb);
 
-  options_rb = Message_decode_bytes(size, bytes, 0, desc->klass, true);
+  options_rb = Message_decode_bytes(size, bytes, 0, desc->klass, false);
+
+  // Strip features from the options proto to keep it internal.
+  const upb_MessageDef* decoded_desc = NULL;
+  upb_Message* options = Message_GetMutable(options_rb, &decoded_desc);
+  PBRUBY_ASSERT(options != NULL);
+  PBRUBY_ASSERT(decoded_desc == msgdef);
+  const upb_FieldDef* field =
+      upb_MessageDef_FindFieldByName(decoded_desc, "features");
+  PBRUBY_ASSERT(field != NULL);
+  upb_Message_ClearFieldByDef(options, field);
+
+  Message_freeze(options_rb);
+
   rb_ivar_set(self, options_instancevar_interned, options_rb);
   return options_rb;
 }
@@ -489,7 +510,7 @@ static VALUE FileDescriptor_alloc(VALUE klass) {
  * call-seq:
  *     FileDescriptor.new => file
  *
- * Returns a new file descriptor. The syntax must be set before it's passed
+ * Returns a new file descriptor. May
  * to a builder.
  */
 static VALUE FileDescriptor_initialize(VALUE _self, VALUE cookie,
@@ -519,28 +540,6 @@ static VALUE FileDescriptor_name(VALUE _self) {
   return name == NULL ? Qnil : rb_str_new2(name);
 }
 
-/*
- * call-seq:
- *     FileDescriptor.syntax => syntax
- *
- * Returns this file descriptors syntax.
- *
- * Valid syntax versions are:
- *     :proto2 or :proto3.
- */
-static VALUE FileDescriptor_syntax(VALUE _self) {
-  FileDescriptor* self = ruby_to_FileDescriptor(_self);
-
-  switch (upb_FileDef_Syntax(self->filedef)) {
-    case kUpb_Syntax_Proto3:
-      return ID2SYM(rb_intern("proto3"));
-    case kUpb_Syntax_Proto2:
-      return ID2SYM(rb_intern("proto2"));
-    default:
-      return Qnil;
-  }
-}
-
 /*
  * call-seq:
  *     FileDescriptor.options => options
@@ -564,7 +563,6 @@ static void FileDescriptor_register(VALUE module) {
   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, "syntax", FileDescriptor_syntax, 0);
   rb_define_method(klass, "options", FileDescriptor_options, 0);
   rb_gc_register_address(&cFileDescriptor);
   cFileDescriptor = klass;
@@ -727,7 +725,7 @@ static VALUE FieldDescriptor__type(VALUE _self) {
 static VALUE FieldDescriptor_default(VALUE _self) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_FieldDef* f = self->fielddef;
-  upb_MessageValue default_val = {0};
+  upb_MessageValue default_val = upb_MessageValue_Zero();
   if (upb_FieldDef_IsSubMessage(f)) {
     return Qnil;
   } else if (!upb_FieldDef_IsRepeated(f)) {
@@ -736,6 +734,28 @@ static VALUE FieldDescriptor_default(VALUE _self) {
   return Convert_UpbToRuby(default_val, TypeInfo_get(self->fielddef), Qnil);
 }
 
+/*
+ * call-seq:
+ *     FieldDescriptor.has_presence? => bool
+ *
+ * Returns whether this field tracks presence.
+ */
+static VALUE FieldDescriptor_has_presence(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_HasPresence(self->fielddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *     FieldDescriptor.is_packed? => bool
+ *
+ * Returns whether this is a repeated field that uses packed encoding.
+ */
+static VALUE FieldDescriptor_is_packed(VALUE _self) {
+  FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
+  return upb_FieldDef_IsPacked(self->fielddef) ? Qtrue : Qfalse;
+}
+
 /*
  * call-seq:
  *     FieldDescriptor.json_name => json_name
@@ -862,7 +882,7 @@ static VALUE FieldDescriptor_get(VALUE _self, VALUE msg_rb) {
 static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_MessageDef* m;
-  const upb_MessageDef* msg = Message_Get(msg_rb, &m);
+  const upb_Message* msg = Message_Get(msg_rb, &m);
 
   if (m != upb_FieldDef_ContainingType(self->fielddef)) {
     rb_raise(cTypeError, "has method called on wrong message type");
@@ -882,7 +902,7 @@ static VALUE FieldDescriptor_has(VALUE _self, VALUE msg_rb) {
 static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_MessageDef* m;
-  upb_MessageDef* msg = Message_GetMutable(msg_rb, &m);
+  upb_Message* msg = Message_GetMutable(msg_rb, &m);
 
   if (m != upb_FieldDef_ContainingType(self->fielddef)) {
     rb_raise(cTypeError, "has method called on wrong message type");
@@ -903,7 +923,7 @@ static VALUE FieldDescriptor_clear(VALUE _self, VALUE msg_rb) {
 static VALUE FieldDescriptor_set(VALUE _self, VALUE msg_rb, VALUE value) {
   FieldDescriptor* self = ruby_to_FieldDescriptor(_self);
   const upb_MessageDef* m;
-  upb_MessageDef* msg = Message_GetMutable(msg_rb, &m);
+  upb_Message* msg = Message_GetMutable(msg_rb, &m);
   upb_Arena* arena = Arena_get(Message_GetArena(msg_rb));
   upb_MessageValue msgval;
 
@@ -943,6 +963,8 @@ static void FieldDescriptor_register(VALUE module) {
   rb_define_method(klass, "name", FieldDescriptor_name, 0);
   rb_define_method(klass, "type", FieldDescriptor__type, 0);
   rb_define_method(klass, "default", FieldDescriptor_default, 0);
+  rb_define_method(klass, "has_presence?", FieldDescriptor_has_presence, 0);
+  rb_define_method(klass, "is_packed?", FieldDescriptor_is_packed, 0);
   rb_define_method(klass, "json_name", FieldDescriptor_json_name, 0);
   rb_define_method(klass, "label", FieldDescriptor_label, 0);
   rb_define_method(klass, "number", FieldDescriptor_number, 0);
@@ -1163,6 +1185,17 @@ static VALUE EnumDescriptor_file_descriptor(VALUE _self) {
                          upb_EnumDef_File(self->enumdef));
 }
 
+/*
+ * call-seq:
+ *     EnumDescriptor.is_closed? => bool
+ *
+ * Returns whether this enum is open or closed.
+ */
+static VALUE EnumDescriptor_is_closed(VALUE _self) {
+  EnumDescriptor* self = ruby_to_EnumDescriptor(_self);
+  return upb_EnumDef_IsClosed(self->enumdef) ? Qtrue : Qfalse;
+}
+
 /*
  * call-seq:
  *     EnumDescriptor.name => name
@@ -1275,12 +1308,305 @@ static void EnumDescriptor_register(VALUE module) {
   rb_define_method(klass, "each", EnumDescriptor_each, 0);
   rb_define_method(klass, "enummodule", EnumDescriptor_enummodule, 0);
   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_include_module(klass, rb_mEnumerable);
   rb_gc_register_address(&cEnumDescriptor);
   cEnumDescriptor = klass;
 }
 
+// -----------------------------------------------------------------------------
+// ServiceDescriptor
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  const upb_ServiceDef* servicedef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  VALUE module;           // begins as nil
+  VALUE descriptor_pool;  // Owns the upb_ServiceDef.
+} ServiceDescriptor;
+
+static VALUE cServiceDescriptor = Qnil;
+
+static void ServiceDescriptor_mark(void* _self) {
+  ServiceDescriptor* self = _self;
+  rb_gc_mark(self->module);
+  rb_gc_mark(self->descriptor_pool);
+}
+
+static const rb_data_type_t ServiceDescriptor_type = {
+    "Google::Protobuf::ServicDescriptor",
+    {ServiceDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static ServiceDescriptor* ruby_to_ServiceDescriptor(VALUE val) {
+  ServiceDescriptor* ret;
+  TypedData_Get_Struct(val, ServiceDescriptor, &ServiceDescriptor_type, ret);
+  return ret;
+}
+
+static VALUE ServiceDescriptor_alloc(VALUE klass) {
+  ServiceDescriptor* self = ALLOC(ServiceDescriptor);
+  VALUE ret = TypedData_Wrap_Struct(klass, &ServiceDescriptor_type, self);
+  self->servicedef = NULL;
+  self->module = Qnil;
+  self->descriptor_pool = Qnil;
+  return ret;
+}
+
+/*
+ * call-seq:
+ *    ServiceDescriptor.new(c_only_cookie, ptr) => ServiceDescriptor
+ *
+ * Creates a descriptor wrapper object.  May only be called from C.
+ */
+static VALUE ServiceDescriptor_initialize(VALUE _self, VALUE cookie,
+                                          VALUE descriptor_pool, VALUE ptr) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
+  self->servicedef = (const upb_ServiceDef*)NUM2ULL(ptr);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *     ServiceDescriptor.name => name
+ *
+ * Returns the name of this service.
+ */
+static VALUE ServiceDescriptor_name(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  return rb_str_maybe_null(upb_ServiceDef_FullName(self->servicedef));
+}
+
+/*
+ * call-seq:
+ *    ServiceDescriptor.file_descriptor
+ *
+ * Returns the FileDescriptor object this service belongs to.
+ */
+static VALUE ServiceDescriptor_file_descriptor(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  return get_filedef_obj(self->descriptor_pool,
+                         upb_ServiceDef_File(self->servicedef));
+}
+
+/*
+ * call-seq:
+ *     ServiceDescriptor.each(&block)
+ *
+ * Iterates over methods in this service, yielding to the block on each one.
+ */
+static VALUE ServiceDescriptor_each(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+
+  int n = upb_ServiceDef_MethodCount(self->servicedef);
+  for (int i = 0; i < n; i++) {
+    const upb_MethodDef* method = upb_ServiceDef_Method(self->servicedef, i);
+    VALUE obj = get_methoddef_obj(self->descriptor_pool, method);
+    rb_yield(obj);
+  }
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *     ServiceDescriptor.options => options
+ *
+ * Returns the `ServiceOptions` for this `ServiceDescriptor`.
+ */
+static VALUE ServiceDescriptor_options(VALUE _self) {
+  ServiceDescriptor* self = ruby_to_ServiceDescriptor(_self);
+  const google_protobuf_ServiceOptions* opts =
+      upb_ServiceDef_Options(self->servicedef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized =
+      google_protobuf_ServiceOptions_serialize(opts, arena, &size);
+  VALUE service_options = decode_options(_self, "ServiceOptions", size,
+                                         serialized, self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return service_options;
+}
+
+static void ServiceDescriptor_register(VALUE module) {
+  VALUE klass = rb_define_class_under(module, "ServiceDescriptor", rb_cObject);
+  rb_define_alloc_func(klass, ServiceDescriptor_alloc);
+  rb_define_method(klass, "initialize", ServiceDescriptor_initialize, 3);
+  rb_define_method(klass, "name", ServiceDescriptor_name, 0);
+  rb_define_method(klass, "each", ServiceDescriptor_each, 0);
+  rb_define_method(klass, "file_descriptor", ServiceDescriptor_file_descriptor,
+                   0);
+  rb_define_method(klass, "options", ServiceDescriptor_options, 0);
+  rb_include_module(klass, rb_mEnumerable);
+  rb_gc_register_address(&cServiceDescriptor);
+  cServiceDescriptor = klass;
+}
+
+// -----------------------------------------------------------------------------
+// MethodDescriptor
+// -----------------------------------------------------------------------------
+
+typedef struct {
+  const upb_MethodDef* methoddef;
+  // IMPORTANT: WB_PROTECTED objects must only use the RB_OBJ_WRITE()
+  // macro to update VALUE references, as to trigger write barriers.
+  VALUE module;           // begins as nil
+  VALUE descriptor_pool;  // Owns the upb_MethodDef.
+} MethodDescriptor;
+
+static VALUE cMethodDescriptor = Qnil;
+
+static void MethodDescriptor_mark(void* _self) {
+  MethodDescriptor* self = _self;
+  rb_gc_mark(self->module);
+  rb_gc_mark(self->descriptor_pool);
+}
+
+static const rb_data_type_t MethodDescriptor_type = {
+    "Google::Protobuf::MethodDescriptor",
+    {MethodDescriptor_mark, RUBY_DEFAULT_FREE, NULL},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
+};
+
+static MethodDescriptor* ruby_to_MethodDescriptor(VALUE val) {
+  MethodDescriptor* ret;
+  TypedData_Get_Struct(val, MethodDescriptor, &MethodDescriptor_type, ret);
+  return ret;
+}
+
+static VALUE MethodDescriptor_alloc(VALUE klass) {
+  MethodDescriptor* self = ALLOC(MethodDescriptor);
+  VALUE ret = TypedData_Wrap_Struct(klass, &MethodDescriptor_type, self);
+  self->methoddef = NULL;
+  self->module = Qnil;
+  self->descriptor_pool = Qnil;
+  return ret;
+}
+
+/*
+ * call-seq:
+ *    MethodDescriptor.new(c_only_cookie, ptr) => MethodDescriptor
+ *
+ * Creates a descriptor wrapper object.  May only be called from C.
+ */
+static VALUE MethodDescriptor_initialize(VALUE _self, VALUE cookie,
+                                         VALUE descriptor_pool, VALUE ptr) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+
+  if (cookie != c_only_cookie) {
+    rb_raise(rb_eRuntimeError,
+             "Descriptor objects may not be created from Ruby.");
+  }
+
+  RB_OBJ_WRITE(_self, &self->descriptor_pool, descriptor_pool);
+  self->methoddef = (const upb_MethodDef*)NUM2ULL(ptr);
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ *     MethodDescriptor.name => name
+ *
+ * Returns the name of this method
+ */
+static VALUE MethodDescriptor_name(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return rb_str_maybe_null(upb_MethodDef_Name(self->methoddef));
+}
+
+/*
+ * call-seq:
+ *     MethodDescriptor.options => options
+ *
+ * Returns the `MethodOptions` for this `MethodDescriptor`.
+ */
+static VALUE MethodDescriptor_options(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  const google_protobuf_MethodOptions* opts =
+      upb_MethodDef_Options(self->methoddef);
+  upb_Arena* arena = upb_Arena_New();
+  size_t size;
+  char* serialized =
+      google_protobuf_MethodOptions_serialize(opts, arena, &size);
+  VALUE method_options = decode_options(_self, "MethodOptions", size,
+                                        serialized, self->descriptor_pool);
+  upb_Arena_Free(arena);
+  return method_options;
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.input_type => Descriptor
+ *
+ * Returns the `Descriptor` for the request message type of this method
+ */
+static VALUE MethodDescriptor_input_type(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  const upb_MessageDef* type = upb_MethodDef_InputType(self->methoddef);
+  return get_msgdef_obj(self->descriptor_pool, type);
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.output_type => Descriptor
+ *
+ * Returns the `Descriptor` for the response message type of this method
+ */
+static VALUE MethodDescriptor_output_type(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  const upb_MessageDef* type = upb_MethodDef_OutputType(self->methoddef);
+  return get_msgdef_obj(self->descriptor_pool, type);
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.client_streaming => bool
+ *
+ * Returns whether or not this is a streaming request method
+ */
+static VALUE MethodDescriptor_client_streaming(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return upb_MethodDef_ClientStreaming(self->methoddef) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *      MethodDescriptor.server_streaming => bool
+ *
+ * Returns whether or not this is a streaming response method
+ */
+static VALUE MethodDescriptor_server_streaming(VALUE _self) {
+  MethodDescriptor* self = ruby_to_MethodDescriptor(_self);
+  return upb_MethodDef_ServerStreaming(self->methoddef) ? Qtrue : Qfalse;
+}
+
+static void MethodDescriptor_register(VALUE module) {
+  VALUE klass = rb_define_class_under(module, "MethodDescriptor", rb_cObject);
+  rb_define_alloc_func(klass, MethodDescriptor_alloc);
+  rb_define_method(klass, "initialize", MethodDescriptor_initialize, 3);
+  rb_define_method(klass, "name", MethodDescriptor_name, 0);
+  rb_define_method(klass, "options", MethodDescriptor_options, 0);
+  rb_define_method(klass, "input_type", MethodDescriptor_input_type, 0);
+  rb_define_method(klass, "output_type", MethodDescriptor_output_type, 0);
+  rb_define_method(klass, "client_streaming", MethodDescriptor_client_streaming,
+                   0);
+  rb_define_method(klass, "server_streaming", MethodDescriptor_server_streaming,
+                   0);
+  rb_gc_register_address(&cMethodDescriptor);
+  cMethodDescriptor = klass;
+}
+
 static VALUE get_def_obj(VALUE _descriptor_pool, const void* ptr, VALUE klass) {
   DescriptorPool* descriptor_pool = ruby_to_DescriptorPool(_descriptor_pool);
   VALUE key = ULL2NUM((intptr_t)ptr);
@@ -1322,6 +1648,16 @@ static VALUE get_oneofdef_obj(VALUE descriptor_pool, const upb_OneofDef* def) {
   return get_def_obj(descriptor_pool, def, cOneofDescriptor);
 }
 
+static VALUE get_servicedef_obj(VALUE descriptor_pool,
+                                const upb_ServiceDef* def) {
+  return get_def_obj(descriptor_pool, def, cServiceDescriptor);
+}
+
+static VALUE get_methoddef_obj(VALUE descriptor_pool,
+                               const upb_MethodDef* def) {
+  return get_def_obj(descriptor_pool, def, cMethodDescriptor);
+}
+
 // -----------------------------------------------------------------------------
 // Shared functions
 // -----------------------------------------------------------------------------
@@ -1397,6 +1733,8 @@ void Defs_register(VALUE module) {
   FieldDescriptor_register(module);
   OneofDescriptor_register(module);
   EnumDescriptor_register(module);
+  ServiceDescriptor_register(module);
+  MethodDescriptor_register(module);
 
   rb_gc_register_address(&c_only_cookie);
   c_only_cookie = rb_class_new_instance(0, NULL, rb_cObject);

data/ext/google/protobuf_c/extconf.rb

@@ -22,7 +22,7 @@ $INCFLAGS += " -I$(srcdir)/third_party/utf8_range"
 
 $srcs = ["protobuf.c", "convert.c", "defs.c", "message.c",
          "repeated_field.c", "map.c", "ruby-upb.c", "wrap_memcpy.c",
-         "naive.c", "range2-neon.c", "range2-sse.c", "shared_convert.c",
+         "utf8_range.c", "shared_convert.c",
          "shared_message.c"]
 
 create_makefile(ext_name)

data/ext/google/protobuf_c/glue.c

@@ -54,3 +54,19 @@ char* FieldDescriptor_serialized_options(const upb_FieldDef* fielddef,
   char* serialized = google_protobuf_FieldOptions_serialize(opts, arena, size);
   return serialized;
 }
+
+char* ServiceDescriptor_serialized_options(const upb_ServiceDef* servicedef,
+                                           size_t* size, upb_Arena* arena) {
+  const google_protobuf_ServiceOptions* opts =
+      upb_ServiceDef_Options(servicedef);
+  char* serialized =
+      google_protobuf_ServiceOptions_serialize(opts, 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;
+}