Add support for To_Ruby<T&> for types missing it - this is driven by supporting rvalues in Object#call and in Constructor.

Author: cfis

test/test_Proc.cpp

@@ -59,6 +59,16 @@ TESTCASE(SquareProc)
   ASSERT_EQUAL(81, detail::From_Ruby<int>().convert(result));
 }
 
+TESTCASE(SquareProcLvalueToRuby)
+{
+  auto proc = square;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((proc))>;
+
+  VALUE value = detail::To_Ruby<To_Ruby_T>().convert(proc);
+  Object result(value);
+  ASSERT_EQUAL(81, detail::From_Ruby<int>().convert(result.call("call", 9)));
+}
+
 TESTCASE(SquareWithBlock)
 {
   Module m = define_module("TestingModuleMakeBlock");
@@ -97,4 +107,4 @@ TESTCASE(SquareWithProc)
 
   Object result = m.module_eval(code);
   ASSERT_EQUAL(16, detail::From_Ruby<int>().convert(result));
-}
+}

test/test_Reference.cpp

@@ -117,7 +117,7 @@ TESTCASE(double_reference_object)
 TESTCASE(float_reference_object)
 {
   Module m = define_module("Testing");
-
+  define_reference<float>();
   std::string code = R"(ref = Rice::Reference≺float≻.new(1.25)
                         ref.value)";
   Object result = m.module_eval(code);

test/test_Stl_Optional.cpp

@@ -67,6 +67,15 @@ TESTCASE(OptionalReturn)
   ASSERT(result.is_nil());
 }
 
+TESTCASE(NulloptToRubyReference)
+{
+  const std::nullopt_t& nullopt = std::nullopt;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((nullopt))>;
+
+  VALUE result = detail::To_Ruby<To_Ruby_T>().convert(nullopt);
+  ASSERT_EQUAL(Qnil, result);
+}
+
 TESTCASE(OptionalArgument)
 {
   Module m = define_module("Testing");

test/test_Stl_Reference_Wrapper.cpp

@@ -75,6 +75,17 @@ TESTCASE(Return)
   ASSERT_EQUAL("A ref wrapped string", detail::From_Ruby<std::string>().convert(result));
 }
 
+TESTCASE(LvalueToRuby)
+{
+  MyClass instance;
+  std::reference_wrapper<MyClass> wrapper = std::ref(instance);
+  const std::reference_wrapper<MyClass>& ref = wrapper;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((ref))>;
+
+  VALUE result = detail::To_Ruby<To_Ruby_T>().convert(ref);
+  ASSERT_EQUAL(&instance, detail::unwrap<MyClass>(result, Data_Type<MyClass>::ruby_data_type(), false));
+}
+
 TESTCASE(Argument)
 {
   Module m = define_module("Testing");

test/test_Stl_Vector.cpp

@@ -83,6 +83,17 @@ TESTCASE(StringVectorData)
   ASSERT_EQUAL("World", detail::From_Ruby<std::string>().convert(array[1].value()).c_str());
 }
 
+TESTCASE(VectorBoolReferenceLvalueToRuby)
+{
+  std::vector<bool> values{ true };
+  auto reference = values[0];
+  const auto& ref = reference;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((ref))>;
+
+  VALUE result = detail::To_Ruby<To_Ruby_T>().convert(ref);
+  ASSERT_EQUAL(Qtrue, result);
+}
+
 TESTCASE(Constructors)
 {
   Module m = define_module("Testing");

test/test_To_Ruby.cpp

@@ -26,6 +26,14 @@ TESTCASE(object_to_ruby)
   ASSERT_EQUAL(o.value(), detail::to_ruby(o));
 }
 
+TESTCASE(nullptr_lvalue_to_ruby)
+{
+  const std::nullptr_t& value = nullptr;
+  using To_Ruby_T = detail::remove_cv_recursive_t<decltype((value))>;
+
+  ASSERT_EQUAL(Qnil, detail::To_Ruby<To_Ruby_T>().convert(value));
+}
+
 TESTCASE(short_to_ruby)
 {
 #undef min