Replaced private ruby methods with internal c functions

1 files changed, 383 insertions, 145 deletions

diff --git a/src/ruby/ext/grpc/rb_compression_options.c b/src/ruby/ext/grpc/rb_compression_options.c
index 66ba8fb84a..2d3be4c7d0 100644
--- a/src/ruby/ext/grpc/rb_compression_options.c
+++ b/src/ruby/ext/grpc/rb_compression_options.c
@@ -48,7 +48,10 @@
 static VALUE grpc_rb_cCompressionOptions = Qnil;
 
 /* grpc_rb_compression_options wraps a grpc_compression_options.
- * Note that ruby objects of this type don't carry any state in other
+ * It can be used to get the channel argument key-values for specific
+ * compression settings. */
+
+/* Note that ruby objects of this type don't carry any state in other
  * Ruby objects and don't have a mark for GC. */
 typedef struct grpc_rb_compression_options {
   /* The actual compression options that's being wrapped */
@@ -120,107 +123,242 @@ VALUE grpc_rb_compression_options_disable_compression_algorithm_internal(
 
 /* Provides a bitset as a ruby number that is suitable to pass to
  * the GRPC core as a channel argument to enable compression algorithms. */
-VALUE grpc_rb_compression_options_get_enabled_algorithms_bitset(VALUE self) {
-  grpc_rb_compression_options *wrapper = NULL;
+/* Gets the compression internal enum value of a compression level given its
+ * name. */
+grpc_compression_level grpc_rb_compression_options_level_name_to_value_internal(
+    VALUE level_name) {
+  VALUE none_symbol = Qnil;
+  VALUE low_symbol = Qnil;
+  VALUE medium_symbol = Qnil;
+  VALUE high_symbol = Qnil;
+
+  Check_Type(level_name, T_SYMBOL);
+
+  /* Ruby symbols that correspond to names of valid compression levels */
+  none_symbol =
+      rb_const_get(grpc_rb_cCompressionOptions, rb_intern("COMPRESS_NONE_SYM"));
+  low_symbol =
+      rb_const_get(grpc_rb_cCompressionOptions, rb_intern("COMPRESS_LOW_SYM"));
+  medium_symbol = rb_const_get(grpc_rb_cCompressionOptions,
+                               rb_intern("COMPRESS_MEDIUM_SYM"));
+  high_symbol =
+      rb_const_get(grpc_rb_cCompressionOptions, rb_intern("COMPRESS_HIGH_SYM"));
 
-  TypedData_Get_Struct(self, grpc_rb_compression_options,
-                       &grpc_rb_compression_options_data_type, wrapper);
-  return INT2NUM((int)wrapper->wrapped->enabled_algorithms_bitset);
+  /* Check the compression level of the name passed in, and see which macro
+   * from the GRPC core header files match. */
+  if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, none_symbol)) != 0) {
+    return GRPC_COMPRESS_LEVEL_NONE;
+  } else if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, low_symbol)) !=
+             0) {
+    return GRPC_COMPRESS_LEVEL_LOW;
+  } else if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, medium_symbol)) !=
+             0) {
+    return GRPC_COMPRESS_LEVEL_MED;
+  } else if (RTEST(rb_funcall(level_name, rb_intern("=="), 1, high_symbol)) !=
+             0) {
+    return GRPC_COMPRESS_LEVEL_HIGH;
+  } else {
+    rb_raise(rb_eArgError,
+             "Unrecognized compression level name."
+             "Valid compression level names are none, low, medium, and high.");
+  }
 }
 
-void grpc_rb_compression_options_set_default_level_helper(
-    grpc_compression_options *compression_options,
-    grpc_compression_level level) {
-  compression_options->default_level.is_set |= 1;
-  compression_options->default_level.level = level;
+/*  Wrapper over grpc_rb_compression_options_level_name_to_value available for
+ * use or testing.
+ * Raises an exception for unrecognized level names. */
+VALUE grpc_rb_compression_options_level_name_to_value(VALUE self,
+                                                      VALUE level_name) {
+  return INT2NUM((int)grpc_rb_compression_options_level_name_to_value_internal(
+      level_name));
 }
 
 /* Sets the default compression level, given the name of a compression level.
  * Throws an error if no algorithm matched. */
-VALUE grpc_rb_compression_options_set_default_level(VALUE self,
-                                                    VALUE new_level) {
-  char *level_name = NULL;
-  grpc_rb_compression_options *wrapper = NULL;
-  long name_len = 0;
-  VALUE ruby_str = Qnil;
-
-  TypedData_Get_Struct(self, grpc_rb_compression_options,
-                       &grpc_rb_compression_options_data_type, wrapper);
-
-  /* Take both string and symbol parameters */
-  ruby_str = rb_funcall(new_level, rb_intern("to_s"), 0);
-
-  level_name = RSTRING_PTR(ruby_str);
-  name_len = RSTRING_LEN(ruby_str);
-
-  /* Check the compression level of the name passed in, and see which macro
-   * from the GRPC core header files match. */
-  if (strncmp(level_name, "none", name_len) == 0) {
-    grpc_rb_compression_options_set_default_level_helper(
-        wrapper->wrapped, GRPC_COMPRESS_LEVEL_NONE);
-  } else if (strncmp(level_name, "low", name_len) == 0) {
-    grpc_rb_compression_options_set_default_level_helper(
-        wrapper->wrapped, GRPC_COMPRESS_LEVEL_LOW);
-  } else if (strncmp(level_name, "medium", name_len) == 0) {
-    grpc_rb_compression_options_set_default_level_helper(
-        wrapper->wrapped, GRPC_COMPRESS_LEVEL_MED);
-  } else if (strncmp(level_name, "high", name_len) == 0) {
-    grpc_rb_compression_options_set_default_level_helper(
-        wrapper->wrapped, GRPC_COMPRESS_LEVEL_HIGH);
-  } else {
-    rb_raise(rb_eNameError,
-             "Invalid compression level name. Supported levels: none, low, "
-             "medium, high");
-  }
-
-  return Qnil;
+void grpc_rb_compression_options_set_default_level(
+    grpc_compression_options *options, VALUE new_level_name) {
+  options->default_level.level =
+      grpc_rb_compression_options_level_name_to_value_internal(new_level_name);
+  options->default_level.is_set = 1;
 }
 
 /* Gets the internal value of a compression algorithm suitable as the value
  * in a GRPC core channel arguments hash.
+ * algorithm_value is an out parameter.
  * Raises an error if the name of the algorithm passed in is invalid. */
-void grpc_rb_compression_options_get_internal_value_of_algorithm(
-    VALUE algorithm_name, grpc_compression_algorithm *compression_algorithm) {
-  VALUE ruby_str = Qnil;
+void grpc_rb_compression_options_algorithm_name_to_value_internal(
+    grpc_compression_algorithm *algorithm_value, VALUE algorithm_name) {
   char *name_str = NULL;
   long name_len = 0;
+  VALUE algorithm_name_as_string = Qnil;
 
-  /* Accept ruby symbol and string parameters. */
-  ruby_str = rb_funcall(algorithm_name, rb_intern("to_s"), 0);
-  name_str = RSTRING_PTR(ruby_str);
-  name_len = RSTRING_LEN(ruby_str);
+  Check_Type(algorithm_name, T_SYMBOL);
+
+  /* Convert the algorithm symbol to a ruby string, so that we can get the
+   * correct C string out of it. */
+  algorithm_name_as_string = rb_funcall(algorithm_name, rb_intern("to_s"), 0);
+
+  name_str = RSTRING_PTR(algorithm_name_as_string);
+  name_len = RSTRING_LEN(algorithm_name_as_string);
 
   /* Raise an error if the name isn't recognized as a compression algorithm by
    * the algorithm parse function
    * in GRPC core. */
-  if (!grpc_compression_algorithm_parse(name_str, name_len,
-                                        compression_algorithm)) {
-    rb_raise(rb_eNameError,
-             "Invalid compression algorithm name.");
+  if (!grpc_compression_algorithm_parse(name_str, name_len, algorithm_value)) {
+    rb_raise(rb_eNameError, "Invalid compression algorithm name: %s",
+             StringValueCStr(algorithm_name_as_string));
   }
 }
 
+/* Wrapper around algorithm_name_to_value_internal function available for use or
+ * testing. */
+VALUE grpc_rb_compression_options_algorithm_name_to_value(
+    VALUE self, VALUE algorithm_name) {
+  grpc_compression_algorithm algorithm_value;
+  grpc_rb_compression_options_algorithm_name_to_value_internal(&algorithm_value,
+                                                               algorithm_name);
+
+  return INT2NUM((int)algorithm_value);
+}
+
+/* Indicates whether a given algorithm is enabled on this instance, given the
+ * readable algorithm name. */
+VALUE grpc_rb_compression_options_is_algorithm_enabled(VALUE self,
+                                                       VALUE algorithm_name) {
+  grpc_rb_compression_options *wrapper = NULL;
+  grpc_compression_algorithm internal_algorithm_value;
+
+  TypedData_Get_Struct(self, grpc_rb_compression_options,
+                       &grpc_rb_compression_options_data_type, wrapper);
+  grpc_rb_compression_options_algorithm_name_to_value_internal(
+      &internal_algorithm_value, algorithm_name);
+
+  if (grpc_compression_options_is_algorithm_enabled(wrapper->wrapped,
+                                                    internal_algorithm_value)) {
+    return Qtrue;
+  }
+  return Qfalse;
+}
+
 /* Sets the default algorithm to the name of the algorithm passed in.
  * Raises an error if the name is not a valid compression algorithm name. */
-VALUE grpc_rb_compression_options_set_default_algorithm(VALUE self,
-                                                        VALUE algorithm_name) {
+void grpc_rb_compression_options_set_default_algorithm(
+    grpc_compression_options *options, VALUE algorithm_name) {
+  grpc_rb_compression_options_algorithm_name_to_value_internal(
+      &options->default_algorithm.algorithm, algorithm_name);
+  options->default_algorithm.is_set = 1;
+}
+
+/* Disables an algorithm on the current instance, given the name of an
+ * algorithm.
+ * Fails if the algorithm name is invalid. */
+void grpc_rb_compression_options_disable_algorithm(
+    grpc_compression_options *compression_options, VALUE algorithm_name) {
+  grpc_compression_algorithm internal_algorithm_value;
+
+  grpc_rb_compression_options_algorithm_name_to_value_internal(
+      &internal_algorithm_value, algorithm_name);
+  grpc_compression_options_disable_algorithm(compression_options,
+                                             internal_algorithm_value);
+}
+
+/* Provides a ruby hash of GRPC core channel argument key-values that
+ * correspond to the compression settings on this instance. */
+VALUE grpc_rb_compression_options_to_hash(VALUE self) {
   grpc_rb_compression_options *wrapper = NULL;
+  grpc_compression_options *compression_options = NULL;
+  VALUE channel_arg_hash = rb_hash_new();
+  VALUE key = Qnil;
+  VALUE value = Qnil;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
                        &grpc_rb_compression_options_data_type, wrapper);
+  compression_options = wrapper->wrapped;
 
-  grpc_rb_compression_options_get_internal_value_of_algorithm(
-      algorithm_name, &wrapper->wrapped->default_algorithm.algorithm);
-  wrapper->wrapped->default_algorithm.is_set |= 1;
+  /* Add key-value pairs to the new Ruby hash. It can be used
+   * as GRPC core channel arguments. */
+  if (compression_options->default_level.is_set) {
+    key = rb_str_new2(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL);
+    value = INT2NUM((int)compression_options->default_level.level);
+    rb_hash_aset(channel_arg_hash, key, value);
+  }
 
-  return Qnil;
+  if (compression_options->default_algorithm.is_set) {
+    key = rb_str_new2(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM);
+    value = INT2NUM((int)compression_options->default_algorithm.algorithm);
+    rb_hash_aset(channel_arg_hash, key, value);
+  }
+
+  key = rb_str_new2(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET);
+  value = INT2NUM((int)compression_options->enabled_algorithms_bitset);
+  rb_hash_aset(channel_arg_hash, key, value);
+
+  return channel_arg_hash;
+}
+
+/* Converts an internal enum level value to a readable level name.
+ * Fails if the level value is invalid. */
+VALUE grpc_rb_compression_options_level_value_to_name_internal(
+    grpc_compression_level compression_value) {
+  switch (compression_value) {
+    case GRPC_COMPRESS_LEVEL_NONE:
+      return rb_const_get(grpc_rb_cCompressionOptions,
+                          rb_intern("COMPRESS_NONE_SYM"));
+    case GRPC_COMPRESS_LEVEL_LOW:
+      return rb_const_get(grpc_rb_cCompressionOptions,
+                          rb_intern("COMPRESS_LOW_SYM"));
+    case GRPC_COMPRESS_LEVEL_MED:
+      return rb_const_get(grpc_rb_cCompressionOptions,
+                          rb_intern("COMPRESS_MEDIUM_SYM"));
+    case GRPC_COMPRESS_LEVEL_HIGH:
+      return rb_const_get(grpc_rb_cCompressionOptions,
+                          rb_intern("COMPRESS_HIGH_SYM"));
+    default:
+      rb_raise(
+          rb_eArgError,
+          "Failed to convert compression level value to name for value: %d",
+          (int)compression_value);
+  }
+}
+
+/* Wrapper of internal method that makes it available for use and testing. */
+VALUE grpc_rb_compression_options_level_value_to_name(VALUE self,
+                                                      VALUE compression_value) {
+  Check_Type(compression_value, T_FIXNUM);
+  return grpc_rb_compression_options_level_value_to_name_internal(
+      (grpc_compression_level)NUM2INT(compression_value));
+}
+
+/* Converts an algorithm internal enum value to a readable name.
+ * Fails if the enum value is invalid. */
+VALUE grpc_rb_compression_options_algorithm_value_to_name_internal(
+    grpc_compression_algorithm internal_value) {
+  char *algorithm_name = NULL;
+
+  if (!grpc_compression_algorithm_name(internal_value, &algorithm_name)) {
+    rb_raise(rb_eArgError, "Failed to convert algorithm value to name");
+  }
+
+  return ID2SYM(rb_intern(algorithm_name));
+}
+
+/* Wrapper of algorithm_to_name internal function available for ues and testing.
+ */
+VALUE grpc_rb_compression_options_algorithm_value_to_name(
+    VALUE self, VALUE algorithm_value) {
+  grpc_compression_algorithm algorithm_internal_value;
+  algorithm_internal_value =
+      (grpc_compression_algorithm)NUM2INT(algorithm_value);
+
+  return grpc_rb_compression_options_algorithm_value_to_name_internal(
+      algorithm_internal_value);
 }
 
 /* Gets the internal value of the default compression level that is to be passed
- * to the
- * the GRPC core as a channel argument value.
+ * to the GRPC core as a channel argument value.
  * A nil return value means that it hasn't been set. */
-VALUE grpc_rb_compression_options_default_algorithm_internal_value(VALUE self) {
+VALUE grpc_rb_compression_options_get_default_algorithm_internal_value(
+    VALUE self) {
   grpc_rb_compression_options *wrapper = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
@@ -228,15 +366,27 @@ VALUE grpc_rb_compression_options_default_algorithm_internal_value(VALUE self) {
 
   if (wrapper->wrapped->default_algorithm.is_set) {
     return INT2NUM(wrapper->wrapped->default_algorithm.algorithm);
-  } else {
-    return Qnil;
   }
+  return Qnil;
 }
 
-/* Gets the internal value of the default compression level that is to be passed
- * to the GRPC core as a channel argument value.
- * A nil return value means that it hasn't been set. */
-VALUE grpc_rb_compression_options_default_level_internal_value(VALUE self) {
+/* Gets the readable name of the default algorithm if one has been set.
+ * Returns nil if no algorithm has been set. */
+VALUE grpc_rb_compression_options_get_default_algorithm(VALUE self) {
+  VALUE algorithm_value =
+      grpc_rb_compression_options_get_default_algorithm_internal_value(self);
+
+  if (RTEST(algorithm_value)) {
+    return grpc_rb_compression_options_algorithm_value_to_name(self,
+                                                               algorithm_value);
+  }
+
+  return Qnil;
+}
+
+/* Gets the internal enum value of the default algorithm if one has been set.
+ * Returns nil if no default algorithm has been set. */
+VALUE grpc_rb_compression_options_get_default_level_internal_value(VALUE self) {
   grpc_rb_compression_options *wrapper = NULL;
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
@@ -244,64 +394,121 @@ VALUE grpc_rb_compression_options_default_level_internal_value(VALUE self) {
 
   if (wrapper->wrapped->default_level.is_set) {
     return INT2NUM((int)wrapper->wrapped->default_level.level);
-  } else {
-    return Qnil;
   }
+  return Qnil;
 }
 
-/* Disables compression algorithms by their names. Raises an error if an unkown
- * name was passed. */
-VALUE grpc_rb_compression_options_disable_algorithms(int argc, VALUE *argv,
-                                                     VALUE self) {
-  VALUE algorithm_names = Qnil;
-  VALUE ruby_str = Qnil;
-  grpc_compression_algorithm internal_algorithm_value;
+/* Gets the internal value of the default compression level that is to be passed
+ * to the GRPC core as a channel argument value.
+ * A nil return value means that it hasn't been set. */
+VALUE grpc_rb_compression_options_get_default_level(VALUE self) {
+  grpc_compression_level internal_value;
+  VALUE ruby_value =
+      grpc_rb_compression_options_get_default_level_internal_value(self);
+
+  if (RTEST(ruby_value)) {
+    internal_value = (grpc_compression_level)NUM2INT(ruby_value);
+    return grpc_rb_compression_options_level_value_to_name_internal(
+        internal_value);
+  }
+
+  return Qnil;
+}
 
-  /* read variadic argument list of names into the algorithm_name ruby array. */
-  rb_scan_args(argc, argv, "0*", &algorithm_names);
+/* Gets a list of the disabled algorithms as readable names.
+ * Returns an empty list of no algorithms have been disabled. */
+VALUE grpc_rb_compression_options_get_disabled_algorithms(VALUE self) {
+  VALUE disabled_algorithms = rb_ary_new();
+  grpc_compression_algorithm internal_value;
+  grpc_rb_compression_options *wrapper = NULL;
+
+  TypedData_Get_Struct(self, grpc_rb_compression_options,
+                       &grpc_rb_compression_options_data_type, wrapper);
 
-  for (int i = 0; i < RARRAY_LEN(algorithm_names); i++) {
-    ruby_str =
-        rb_funcall(rb_ary_entry(algorithm_names, i), rb_intern("to_s"), 0);
-    grpc_rb_compression_options_get_internal_value_of_algorithm(
-        ruby_str, &internal_algorithm_value);
-    rb_funcall(self, rb_intern("disable_algorithm_internal"), 1,
-               LONG2NUM((long)internal_algorithm_value));
+  for (internal_value = GRPC_COMPRESS_NONE;
+       internal_value < GRPC_COMPRESS_ALGORITHMS_COUNT; internal_value++) {
+    if (!grpc_compression_options_is_algorithm_enabled(wrapper->wrapped,
+                                                       internal_value)) {
+      rb_ary_push(disabled_algorithms,
+                  grpc_rb_compression_options_algorithm_value_to_name_internal(
+                      internal_value));
+    }
   }
+  return disabled_algorithms;
+}
 
-  return Qnil;
+/* Provides a bitset as a ruby number that is suitable to pass to
+ * the GRPC core as a channel argument to enable compression algorithms. */
+VALUE grpc_rb_compression_options_get_enabled_algorithms_bitset(VALUE self) {
+  grpc_rb_compression_options *wrapper = NULL;
+
+  TypedData_Get_Struct(self, grpc_rb_compression_options,
+                       &grpc_rb_compression_options_data_type, wrapper);
+  return INT2NUM((int)wrapper->wrapped->enabled_algorithms_bitset);
 }
 
-/* Provides a ruby hash of GRPC core channel argument key-values that
- * correspond to the compression settings on this instance. */
-VALUE grpc_rb_compression_options_to_hash(VALUE self) {
+/* Initializes the compression options wrapper.
+ * Takes an optional hash parameter.
+ *
+ * Example call-seq:
+ *   options = CompressionOptions.new(
+ *     default_level: :none,
+ *     disabled_algorithms: [:gzip]
+ *   )
+ *   channel_arg hash = Hash.new[...]
+ *   channel_arg_hash_with_compression_options = channel_arg_hash.merge(options)
+ */
+VALUE grpc_rb_compression_options_init(int argc, VALUE *argv, VALUE self) {
   grpc_rb_compression_options *wrapper = NULL;
-  grpc_compression_options *compression_options = NULL;
-  VALUE channel_arg_hash = rb_funcall(rb_cHash, rb_intern("new"), 0);
+  VALUE default_algorithm = Qnil;
+  VALUE default_level = Qnil;
+  VALUE disabled_algorithms = Qnil;
+  VALUE algorithm_name = Qnil;
+  VALUE hash_arg = Qnil;
+
+  rb_scan_args(argc, argv, "01", &hash_arg);
+
+  /* Check if the hash parameter was passed, or if invalid arguments were
+   * passed. */
+  if (hash_arg == Qnil) {
+    return self;
+  } else if (TYPE(hash_arg) != T_HASH || argc > 1) {
+    rb_raise(rb_eArgError,
+             "Invalid arguments. Expecting optional hash parameter");
+  }
 
   TypedData_Get_Struct(self, grpc_rb_compression_options,
                        &grpc_rb_compression_options_data_type, wrapper);
-  compression_options = wrapper->wrapped;
 
-  /* Add key-value pairs to the new Ruby hash. It can be used
-   * as GRPC core channel arguments. */
-  if (compression_options->default_level.is_set) {
-    rb_funcall(channel_arg_hash, rb_intern("[]="), 2,
-               rb_str_new2(GRPC_COMPRESSION_CHANNEL_DEFAULT_LEVEL),
-               INT2NUM((int)compression_options->default_level.level));
+  /* Set the default algorithm if one was chosen. */
+  default_algorithm =
+      rb_hash_aref(hash_arg, ID2SYM(rb_intern("default_algorithm")));
+  if (default_algorithm != Qnil) {
+    grpc_rb_compression_options_set_default_algorithm(wrapper->wrapped,
+                                                      default_algorithm);
   }
 
-  if (compression_options->default_algorithm.is_set) {
-    rb_funcall(channel_arg_hash, rb_intern("[]="), 2,
-               rb_str_new2(GRPC_COMPRESSION_CHANNEL_DEFAULT_ALGORITHM),
-               INT2NUM((int)compression_options->default_algorithm.algorithm));
+  /* Set the default level if one was chosen. */
+  default_level = rb_hash_aref(hash_arg, ID2SYM(rb_intern("default_level")));
+  if (default_level != Qnil) {
+    grpc_rb_compression_options_set_default_level(wrapper->wrapped,
+                                                  default_level);
   }
 
-  rb_funcall(channel_arg_hash, rb_intern("[]="), 2,
-             rb_str_new2(GRPC_COMPRESSION_CHANNEL_ENABLED_ALGORITHMS_BITSET),
-             INT2NUM((int)compression_options->enabled_algorithms_bitset));
+  /* Set the disabled algorithms if any were chosen. */
+  disabled_algorithms =
+      rb_hash_aref(hash_arg, ID2SYM(rb_intern("disabled_algorithms")));
+  if (disabled_algorithms != Qnil) {
+    Check_Type(disabled_algorithms, T_ARRAY);
+
+    for (int i = 0; i < RARRAY_LEN(disabled_algorithms); i++) {
+      algorithm_name = rb_ary_entry(disabled_algorithms, i);
+      grpc_rb_compression_options_disable_algorithm(wrapper->wrapped,
+                                                    algorithm_name);
+    }
+  }
 
-  return channel_arg_hash;
+  return self;
 }
 
 void Init_grpc_compression_options() {
@@ -312,40 +519,71 @@ void Init_grpc_compression_options() {
   rb_define_alloc_func(grpc_rb_cCompressionOptions,
                        grpc_rb_compression_options_alloc);
 
-  /* Private method for disabling algorithms by a variadic list of names. */
-  rb_define_private_method(grpc_rb_cCompressionOptions, "disable_algorithms",
-                           grpc_rb_compression_options_disable_algorithms, -1);
-  /* Private method for disabling an algorithm by its enum value. */
-  rb_define_private_method(
-      grpc_rb_cCompressionOptions, "disable_algorithm_internal",
-      grpc_rb_compression_options_disable_compression_algorithm_internal, 1);
-
-  /* Private method for getting the bitset of enabled algorithms. */
-  rb_define_private_method(
-      grpc_rb_cCompressionOptions, "enabled_algorithms_bitset",
-      grpc_rb_compression_options_get_enabled_algorithms_bitset, 0);
-
-  /* Private method for setting the default algorithm by name. */
-  rb_define_private_method(grpc_rb_cCompressionOptions, "set_default_algorithm",
-                           grpc_rb_compression_options_set_default_algorithm,
-                           1);
-  /* Private method for getting the internal enum value of the default
-   * algorithm. */
-  rb_define_private_method(
+  /* Initializes the ruby wrapper. #new method takes an optional hash argument.
+   */
+  rb_define_method(grpc_rb_cCompressionOptions, "initialize",
+                   grpc_rb_compression_options_init, -1);
+
+  /* Gets the bitset of enabled algorithms. */
+  rb_define_method(grpc_rb_cCompressionOptions, "enabled_algorithms_bitset",
+                   grpc_rb_compression_options_get_enabled_algorithms_bitset,
+                   0);
+
+  /* Methods for getting the default algorithm, default level, and disabled
+   * algorithms as readable names. */
+  rb_define_method(grpc_rb_cCompressionOptions, "default_algorithm",
+                   grpc_rb_compression_options_get_default_algorithm, 0);
+  rb_define_method(grpc_rb_cCompressionOptions, "default_level",
+                   grpc_rb_compression_options_get_default_level, 0);
+  rb_define_method(grpc_rb_cCompressionOptions, "disabled_algorithms",
+                   grpc_rb_compression_options_get_disabled_algorithms, 0);
+
+  /* Methods for getting the internal enum default algorithm and level enum
+   * values of an instance. */
+  rb_define_method(
       grpc_rb_cCompressionOptions, "default_algorithm_internal_value",
-      grpc_rb_compression_options_default_algorithm_internal_value, 0);
-
-  /* Private method for setting the default compression level by name. */
-  rb_define_private_method(grpc_rb_cCompressionOptions, "set_default_level",
-                           grpc_rb_compression_options_set_default_level, 1);
-
-  /* Private method for getting the internal enum value of the default level. */
-  rb_define_private_method(
-      grpc_rb_cCompressionOptions, "default_level_internal_value",
-      grpc_rb_compression_options_default_level_internal_value, 0);
-
-  /* Public method for returning a hash of the compression settings suitable
+      grpc_rb_compression_options_get_default_algorithm_internal_value, 0);
+  rb_define_method(grpc_rb_cCompressionOptions, "default_level_internal_value",
+                   grpc_rb_compression_options_get_default_level_internal_value,
+                   0);
+
+  /* Determines whether or not an algorithm is enabled, given a readable
+   * algorithm name.*/
+  rb_define_method(grpc_rb_cCompressionOptions, "is_algorithm_enabled",
+                   grpc_rb_compression_options_is_algorithm_enabled, 1);
+
+  /* Methods for converting to and from algorithm enum values and their readable
+   * names. */
+  rb_define_singleton_method(
+      grpc_rb_cCompressionOptions, "algorithm_name_to_value",
+      grpc_rb_compression_options_algorithm_name_to_value, 1);
+  rb_define_singleton_method(
+      grpc_rb_cCompressionOptions, "algorithm_value_to_name",
+      grpc_rb_compression_options_algorithm_value_to_name, 1);
+
+  /* Methods for converting to and from compression level enum values and their
+   * readable names. */
+  rb_define_singleton_method(grpc_rb_cCompressionOptions, "level_name_to_value",
+                             grpc_rb_compression_options_level_name_to_value,
+                             1);
+  rb_define_singleton_method(grpc_rb_cCompressionOptions, "level_value_to_name",
+                             grpc_rb_compression_options_level_value_to_name,
+                             1);
+
+  /* Provides a hash of the compression settings suitable
    * for passing to server or channel args. */
   rb_define_method(grpc_rb_cCompressionOptions, "to_hash",
                    grpc_rb_compression_options_to_hash, 0);
+  rb_define_alias(grpc_rb_cCompressionOptions, "to_channel_arg_hash",
+                  "to_hash");
+
+  /* Ruby symbols for the names of the different compression levels. */
+  rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_NONE_SYM",
+                  ID2SYM(rb_intern("none")));
+  rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_LOW_SYM",
+                  ID2SYM(rb_intern("low")));
+  rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_MEDIUM_SYM",
+                  ID2SYM(rb_intern("medium")));
+  rb_define_const(grpc_rb_cCompressionOptions, "COMPRESS_HIGH_SYM",
+                  ID2SYM(rb_intern("high")));
 }