rice 4.7.1 → 4.8.0

data/test/test_Stl_Vector.cpp

@@ -18,7 +18,7 @@ TEARDOWN(Vector)
 {
   rb_gc_start();
 }
-/*
+
 namespace
 {
   class MyClass
@@ -65,7 +65,7 @@ TESTCASE(StringVector)
   result = vec.call("last");
   ASSERT_EQUAL("four", detail::From_Ruby<std::string>().convert(result));
 }
-*/
+
 TESTCASE(StringVectorData)
 {
   Module m = define_module("Testing");
@@ -282,24 +282,24 @@ TESTCASE(Slice)
 
   Array result = vec.call("[]", 3, 1);
   std::vector<std::int32_t> slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(1, slice.size());
+  ASSERT_EQUAL(1u, slice.size());
   ASSERT_EQUAL(10, slice[0]);
 
   result = vec.call("[]", 3, 2);
   slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(2, slice.size());
+  ASSERT_EQUAL(2u, slice.size());
   ASSERT_EQUAL(10, slice[0]);
   ASSERT_EQUAL(11, slice[1]);
 
   result = vec.call("[]", 4, 10);
   slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(2, slice.size());
+  ASSERT_EQUAL(2u, slice.size());
   ASSERT_EQUAL(11, slice[0]);
   ASSERT_EQUAL(12, slice[1]);
 
   result = vec.call("[]", -1, 2);
   slice = result.to_vector<int32_t>();
-  ASSERT_EQUAL(1, slice.size());
+  ASSERT_EQUAL(1u, slice.size());
   ASSERT_EQUAL(12, slice[0]);
 }
 
@@ -528,7 +528,7 @@ TESTCASE(NotDefaultConstructable)
   ASSERT_EQUAL(Qnil, result.value());
 
   result = vec.call("length");
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 }
 
 TESTCASE(NotPrintable)
@@ -591,16 +591,47 @@ TESTCASE(Comparable)
 
   Object result = vec.call("delete", Comparable(1));
   Comparable comparable = detail::From_Ruby<Comparable>().convert(result);
-  ASSERT_EQUAL(1, comparable.value_);
+  ASSERT_EQUAL(1u, comparable.value_);
 
   result = vec.call("length");
-  ASSERT_EQUAL(2, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(2u, detail::From_Ruby<size_t>().convert(result));
 
   result = vec.call("include?", Comparable(2));
   ASSERT_EQUAL(Qtrue, result.value());
 
   result = vec.call("index", Comparable(3));
-  ASSERT_EQUAL(1, detail::From_Ruby<size_t>().convert(result.value()));
+  ASSERT_EQUAL(1u, detail::From_Ruby<size_t>().convert(result.value()));
+}
+
+TESTCASE(ComparableEqual)
+{
+  define_class<Comparable>("IsComparable").
+    define_constructor(Constructor<Comparable, uint32_t>());
+
+  Comparable comparable1a(1);
+  Comparable comparable1b(1);
+  Comparable comparable2(2);
+
+  Class c = define_vector<Comparable>("ComparableVector");
+
+  Object vec1 = c.call("new");
+  Object vec2 = c.call("new");
+  Object vec3 = c.call("new");
+
+  Object result = vec1.call("eql?", vec2);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  vec1.call("push", comparable1a);
+  result = vec1.call("==", vec2);
+  ASSERT_EQUAL(Qfalse, result.value());
+
+  vec2.call("push", comparable1b);
+  result = vec1.call("==", vec2);
+  ASSERT_EQUAL(Qtrue, result.value());
+
+  vec3.call("push", comparable2);
+  result = vec1.call("==", vec3);
+  ASSERT_EQUAL(Qfalse, result.value());
 }
 
 namespace
@@ -612,7 +643,7 @@ namespace
     {
     };
 
-    std::string operator==(const ComparableButNotBool& other)
+    std::string operator==(const ComparableButNotBool&)
     {
       return "not a boolean";
     }
@@ -658,7 +689,7 @@ TESTCASE(DefaultConstructable)
   ASSERT_EQUAL(Qnil, result.value());
 
   result = vec.call("length");
-  ASSERT_EQUAL(0, detail::From_Ruby<size_t>().convert(result));
+  ASSERT_EQUAL(0u, detail::From_Ruby<size_t>().convert(result));
 }
 
 TESTCASE(Printable)
@@ -798,7 +829,7 @@ TESTCASE(ToArray)
                         vector.to_a)";
 
   Array array = m.module_eval(code);
-  ASSERT_EQUAL(3u, array.size());
+  ASSERT_EQUAL(3, array.size());
 
   ASSERT_EQUAL("abc", detail::From_Ruby<std::string>().convert(array[0].value()));
   ASSERT_EQUAL("def", detail::From_Ruby<std::string>().convert(array[1].value()));
@@ -842,17 +873,17 @@ TESTCASE(ArrayToVector)
   std::string code = "array_to_vector([7, 9, 1_000_000], [49.0, 78.0, 999.0], %w[one two three])";
   m.module_eval(code);
 
-  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(3u, ints.size());
   ASSERT_EQUAL(7, ints[0]);
   ASSERT_EQUAL(9, ints[1]);
   ASSERT_EQUAL(1'000'000, ints[2]);
 
-  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(3u, floats.size());
   ASSERT_EQUAL(49.0, floats[0]);
   ASSERT_EQUAL(78.0, floats[1]);
   ASSERT_EQUAL(999.0, floats[2]);
 
-  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL(3u, strings.size());
   ASSERT_EQUAL("one", strings[0]);
   ASSERT_EQUAL("two", strings[1]);
   ASSERT_EQUAL("three", strings[2]);
@@ -867,17 +898,17 @@ TESTCASE(ArrayToVectorRefs)
   std::string code = "array_to_vector_refs([8, 10, 1_000_001], [50.0, 79.0, 1_000.0], %w[eleven twelve thirteen])";
   m.module_eval(code);
 
-  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(3u, ints.size());
   ASSERT_EQUAL(8, ints[0]);
   ASSERT_EQUAL(10, ints[1]);
   ASSERT_EQUAL(1'000'001, ints[2]);
 
-  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(3u, floats.size());
   ASSERT_EQUAL(50.0, floats[0]);
   ASSERT_EQUAL(79.0, floats[1]);
   ASSERT_EQUAL(1'000.0, floats[2]);
 
-  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL(3u, strings.size());
   ASSERT_EQUAL("eleven", strings[0]);
   ASSERT_EQUAL("twelve", strings[1]);
   ASSERT_EQUAL("thirteen", strings[2]);
@@ -892,17 +923,17 @@ TESTCASE(ArrayToVectorPointers)
   std::string code = "array_to_vector_pointers([9, 11, 1_000_002], [51.0, 80.0, 1_001.0], %w[fourteen fifteen sixteen])";
   m.module_eval(code);
 
-  ASSERT_EQUAL(3, ints.size());
+  ASSERT_EQUAL(3u, ints.size());
   ASSERT_EQUAL(9, ints[0]);
   ASSERT_EQUAL(11, ints[1]);
   ASSERT_EQUAL(1'000'002, ints[2]);
 
-  ASSERT_EQUAL(3, floats.size());
+  ASSERT_EQUAL(3u, floats.size());
   ASSERT_EQUAL(51.0, floats[0]);
   ASSERT_EQUAL(80.0, floats[1]);
   ASSERT_EQUAL(1'001.0, floats[2]);
 
-  ASSERT_EQUAL(3, strings.size());
+  ASSERT_EQUAL(3u, strings.size());
   ASSERT_EQUAL("fourteen", strings[0]);
   ASSERT_EQUAL("fifteen", strings[1]);
   ASSERT_EQUAL("sixteen", strings[2]);
@@ -962,11 +993,11 @@ namespace
     static inline std::vector<std::string> instance_{ "one", "two", "three" };
   };
 
-  std::ostream& operator<<(std::ostream& stream, const std::vector<std::string>& vector)
+ /* std::ostream& operator<<(std::ostream& stream, const std::vector<std::string>& vector)
   {
-    stream << "Vector";
+    stream << vector;
     return stream;
-  }
+  }*/
 
   void createFactoryClass()
   {
@@ -1104,7 +1135,7 @@ TESTCASE(StringPointerVector)
 
   Module m(rb_mKernel);
   Data_Object<std::vector<std::string*>> vec = m.call("vector_of_string_pointers");
-  ASSERT_EQUAL(2, vec->size());
+  ASSERT_EQUAL(2u, vec->size());
 
   std::string expected("Hello");
   std::string* actual = (*vec)[0];
@@ -1149,7 +1180,7 @@ TESTCASE(MyClass2PointerVector)
 
   Module m(rb_mKernel);
   Data_Object<std::vector<MyClass2*>> result = m.call("vector_of_myclass2_pointers");
-  ASSERT_EQUAL(1, result->size());
+  ASSERT_EQUAL(1u, result->size());
 
  MyClass2* pMyClass = (*result)[0];
  ASSERT_EQUAL("Hello MyClass2", pMyClass->name);
@@ -1157,17 +1188,17 @@ TESTCASE(MyClass2PointerVector)
 
 namespace
 {
-  bool typeCheckValue(std::vector<std::string> vec)
+  bool typeCheckValue(std::vector<std::string>)
   {
     return true;
   }
 
-  bool typeCheckRef(std::vector<std::string>& vec)
+  bool typeCheckRef(std::vector<std::string>&)
   {
     return true;
   }
 
-  bool typeCheckPtr(std::vector<std::string>* vec)
+  bool typeCheckPtr(std::vector<std::string>*)
   {
     return true;
   }

data/test/test_String.cpp

@@ -118,10 +118,12 @@ TESTCASE(intern)
  */
 
 namespace {
-  void testStringArg(Object self, String string) {
+  void testStringArg(Object, String)
+  {
   }
 }
 
-TESTCASE(use_string_in_wrapped_function) {
+TESTCASE(use_string_in_wrapped_function)
+{
   define_global_function("test_string_arg", &testStringArg);
 }

data/test/test_Struct.cpp

@@ -192,7 +192,7 @@ TESTCASE(instance_swap)
  */
 
 namespace {
-  void testStructArg(Object self, Struct string) {
+  void testStructArg(Object, Struct) {
   }
 }
 

data/test/test_Symbol.cpp

@@ -76,7 +76,7 @@ TESTCASE(to_id)
 
 namespace
 {
-  void testSymbolArg(Object self, Symbol string)
+  void testSymbolArg(Object, Symbol)
   {
   }
 }

data/test/test_To_Ruby.cpp

@@ -28,6 +28,7 @@ TESTCASE(object_to_ruby)
 
 TESTCASE(short_to_ruby)
 {
+#undef min
   ASSERT_EQUAL(INT2NUM(0), detail::to_ruby((short)0));
   ASSERT_EQUAL(INT2NUM(-1), detail::to_ruby((short)-1));
   ASSERT_EQUAL(INT2NUM(1), detail::to_ruby((short)1));

data/test/test_Type.cpp

@@ -41,83 +41,84 @@ TESTCASE(FindGroup)
 {
   std::string name = "class std::vector<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >";
 
-  detail::TypeMapper<int> typeMapper;
-  std::string group = typeMapper.findGroup(name, 0);
+  detail::TypeIndexParser parser(typeid(int), true);
+
+  std::string group = parser.findGroup(name, 0);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2>, class std::allocator<class cv::Vec<unsigned char, 2> > >", group.c_str());
 
-  group = typeMapper.findGroup(name, 18);
+  group = parser.findGroup(name, 18);
   ASSERT_EQUAL("<unsigned char, 2>", group.c_str());
   
-  group = typeMapper.findGroup(name, 49);
+  group = parser.findGroup(name, 49);
   ASSERT_EQUAL("<class cv::Vec<unsigned char, 2> >", group.c_str());
 
   ASSERT_EXCEPTION_CHECK(
     std::runtime_error,
-    typeMapper.findGroup(name, 48),
+    parser.findGroup(name, 48),
       ASSERT_EQUAL("Unbalanced Group", ex.what())
   );
 }
 
 TESTCASE(SimplifiedName)
 {
-  detail::TypeMapper<char*> typeMapper1;
-  std::string className = typeMapper1.simplifiedName();
+  detail::TypeIndexParser typeIndexParser1(typeid(char*));
+  std::string className = typeIndexParser1.simplifiedName();
   ASSERT_EQUAL("char*", className.c_str());
 
-  detail::TypeMapper<char**> typeMapper2;
-  className = typeMapper2.simplifiedName();
+  detail::TypeIndexParser typeIndexParser2(typeid(char**));
+  className = typeIndexParser2.simplifiedName();
   ASSERT_EQUAL("char**", className.c_str());
 
-  detail::TypeMapper<double> typeMapper3;
-  className = typeMapper3.simplifiedName();
+  detail::TypeIndexParser typeIndexParser3(typeid(double));
+  className = typeIndexParser3.simplifiedName();
   ASSERT_EQUAL("double", className.c_str());
 
-  detail::TypeMapper<double*> typeMapper4;
-  className = typeMapper4.simplifiedName();
+  detail::TypeIndexParser typeIndexParser4(typeid(double*));
+  className = typeIndexParser4.simplifiedName();
   ASSERT_EQUAL("double*", className.c_str());
 
-  detail::TypeMapper<std::string> typeMapper5;
-  className = typeMapper5.simplifiedName();
+  detail::TypeIndexParser typeIndexParser5(typeid(std::string));
+  className = typeIndexParser5.simplifiedName();
   ASSERT_EQUAL("std::string", className.c_str());
 
-  detail::TypeMapper<std::wstring> typeMapper6;
-  className = typeMapper6.simplifiedName();
+  detail::TypeIndexParser typeIndexParser6(typeid(std::wstring));
+  className = typeIndexParser6.simplifiedName();
   ASSERT_EQUAL("std::wstring", className.c_str());
 
-  detail::TypeMapper<std::vector<std::string>> typeMapper7;
-  className = typeMapper7.simplifiedName();
+  detail::TypeIndexParser typeIndexParser7(typeid(std::vector<std::string>));
+  className = typeIndexParser7.simplifiedName();
   ASSERT_EQUAL("std::vector<std::string>", className.c_str());
 
-  detail::TypeMapper<std::vector<std::wstring>> typeMapper8;
-  className = typeMapper8.simplifiedName();
+  detail::TypeIndexParser typeIndexParser8(typeid(std::vector<std::wstring>));
+  className = typeIndexParser8.simplifiedName();
   ASSERT_EQUAL("std::vector<std::wstring>", className.c_str());
 
-  detail::TypeMapper<std::vector<double*>> typeMapper9;
-  className = typeMapper9.simplifiedName();
+  detail::TypeIndexParser typeIndexParser9(typeid(std::vector<double*>));
+  className = typeIndexParser9.simplifiedName();
   ASSERT_EQUAL("std::vector<double*>", className.c_str());
 
-  detail::TypeMapper<std::vector<double**>> typeMapper10;
-  className = typeMapper10.simplifiedName();
+  detail::TypeIndexParser typeIndexParser10(typeid(std::vector<double**>));
+  className = typeIndexParser10.simplifiedName();
   ASSERT_EQUAL("std::vector<double**>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Vec1> typeMapper11;
-  className = typeMapper11.simplifiedName();
+  detail::TypeIndexParser typeIndexParser11(typeid(Outer::Inner::Vec1));
+  className = typeIndexParser11.simplifiedName();
   ASSERT_EQUAL("std::vector<std::complex<float>>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Vec2> typeMapper12;
-  className = typeMapper12.simplifiedName();
+  detail::TypeIndexParser typeIndexParser12(typeid(Outer::Inner::Vec2));
+  className = typeIndexParser12.simplifiedName();
   ASSERT_EQUAL("std::vector<unsigned char*>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Vec3> typeMapper13;
-  className = typeMapper13.simplifiedName();
+  detail::TypeIndexParser typeIndexParser13(typeid(Outer::Inner::Vec3));
+  className = typeIndexParser13.simplifiedName();
   ASSERT_EQUAL("std::vector<Outer::Inner::SomeClass>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::Map1> typeMapper14;
-  className = typeMapper14.simplifiedName();
+  detail::TypeIndexParser typeIndexParser14(typeid(Outer::Inner::Map1));
+  className = typeIndexParser14.simplifiedName();
   ASSERT_EQUAL("std::map<std::string, std::vector<std::complex<float>>>", className.c_str());
 
-  detail::TypeMapper<Outer::Inner::UnorderedMap1> typeMapper15;
-  className = typeMapper15.simplifiedName();
+  detail::TypeIndexParser typeIndexParser15(typeid(Outer::Inner::UnorderedMap1));
+  className = typeIndexParser15.simplifiedName();
   ASSERT_EQUAL("std::unordered_map<std::string, std::complex<float>>", className.c_str());
 }
 

data/test/test_global_functions.cpp

@@ -75,7 +75,7 @@ TESTCASE(int_kw_arg_invalid)
   ASSERT_EXCEPTION_CHECK(
     Exception,
     m.instance_eval(code),
-    ASSERT_EQUAL("Unknown keyword: wrong", ex.what())
+    ASSERT_EQUAL("Missing argument. Name: value. Index: 0.", ex.what())
   );
 }
 

data/test/unittest.cpp

@@ -68,7 +68,7 @@ run(Test_Result & result)
       std::cout << ".";
     }
     catch(Assertion_Failed const & ex)
-    {
+      {
       std::cout << "F";
       result.add_failure(Failure(name(), it->name(), ex.what()));
     }

data/test/unittest.hpp

@@ -268,11 +268,11 @@ void assert_in_delta(
   T const& expected,
   U const& actual,
   V const& delta,
-  std::string const& s_t,
-  std::string const& s_u,
-  std::string const& s_delta,
-  std::string const& file,
-  size_t line)
+  std::string const&,
+  std::string const&,
+  std::string const&,
+  std::string const&,
+  size_t)
 {
   // Negative deltas don't make sense; treat as failure for clarity.
   if (delta < 0)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 4.7.1
+  version: 4.8.0
 platform: ruby
 authors:
 - Paul Brannan
@@ -79,11 +79,13 @@ files:
 - Rakefile
 - bin/rice-doc.rb
 - bin/rice-rbs.rb
+- include/rice/api.hpp
 - include/rice/rice.hpp
 - include/rice/stl.hpp
 - lib/mkmf-rice.rb
 - lib/rice.rb
 - lib/rice/doc.rb
+- lib/rice/doc/config.rb
 - lib/rice/doc/cpp_reference.rb
 - lib/rice/doc/doxygen.rb
 - lib/rice/doc/mkdocs.rb
@@ -118,14 +120,15 @@ files:
 - rice/Enum.ipp
 - rice/Exception.hpp
 - rice/Exception.ipp
-- rice/Function.hpp
-- rice/Function.ipp
 - rice/JumpException.hpp
 - rice/JumpException.ipp
 - rice/MemoryView.hpp
 - rice/MemoryView.ipp
+- rice/NoGVL.hpp
 - rice/Pointer.hpp
 - rice/Pointer.ipp
+- rice/Reference.hpp
+- rice/Reference.ipp
 - rice/Return.hpp
 - rice/Return.ipp
 - rice/api.hpp
@@ -158,8 +161,6 @@ files:
 - rice/detail/HandlerRegistry.ipp
 - rice/detail/InstanceRegistry.hpp
 - rice/detail/InstanceRegistry.ipp
-- rice/detail/MethodInfo.hpp
-- rice/detail/MethodInfo.ipp
 - rice/detail/ModuleRegistry.hpp
 - rice/detail/ModuleRegistry.ipp
 - rice/detail/Native.hpp
@@ -168,10 +169,8 @@ files:
 - rice/detail/NativeAttributeGet.ipp
 - rice/detail/NativeAttributeSet.hpp
 - rice/detail/NativeAttributeSet.ipp
-- rice/detail/NativeCallbackFFI.hpp
-- rice/detail/NativeCallbackFFI.ipp
-- rice/detail/NativeCallbackSimple.hpp
-- rice/detail/NativeCallbackSimple.ipp
+- rice/detail/NativeCallback.hpp
+- rice/detail/NativeCallback.ipp
 - rice/detail/NativeFunction.hpp
 - rice/detail/NativeFunction.ipp
 - rice/detail/NativeInvoker.hpp
@@ -308,6 +307,7 @@ files:
 - test/test_Overloads.cpp
 - test/test_Ownership.cpp
 - test/test_Proc.cpp
+- test/test_Reference.cpp
 - test/test_Self.cpp
 - test/test_Stl_Exception.cpp
 - test/test_Stl_Map.cpp
@@ -357,7 +357,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.2
 specification_version: 4
 summary: Ruby Interface for C++ Extensions
 test_files: []

data/rice/Function.hpp

@@ -1,17 +0,0 @@
-#ifndef Rice__Function__hpp_
-#define Rice__Function__hpp_
-
-namespace Rice
-{
-  class Function
-  {
-  public:
-    Function& setNoGvl();
-    bool isNoGvl() const;
-
-  private:
-    bool isNoGvl_ = false;
-  };
-} // Rice
-
-#endif // Rice__Function__hpp_

data/rice/Function.ipp

@@ -1,13 +0,0 @@
-namespace Rice
-{
-  inline Function& Function::setNoGvl()
-  {
-    this->isNoGvl_ = true;
-    return *this;
-  }
-
-  inline bool Function::isNoGvl() const
-  {
-    return this->isNoGvl_;
-  }
-}  // Rice

data/rice/detail/MethodInfo.hpp

@@ -1,48 +0,0 @@
-#ifndef Rice__MethodInfo__hpp_
-#define Rice__MethodInfo__hpp_
-
-#include <vector>
-
-namespace Rice
-{
-  class MethodInfo
-  {
-  public:
-    MethodInfo() = default;
-
-    template <typename...Arg_Ts>
-    MethodInfo(size_t argCount, const Arg_Ts&...args);
-
-    /**
-      * Add a defined Arg to this list of Arguments
-      */
-    void addArg(const Arg& arg);
-
-    /**
-      * Get argument by position
-      */
-    Arg* arg(size_t pos);
-
-    /**
-      * Get argument by name
-      */
-    Arg* arg(std::string name);
-
-    int argCount();
-    Return* returnInfo();
-    Function* function();
-
-    // Iterator support
-    std::vector<Arg>::iterator begin();
-    std::vector<Arg>::iterator end();
-
-  private:
-    template <typename Arg_T>
-    void processArg(const Arg_T& arg);
-
-    std::vector<Arg> args_;
-    Return returnInfo_;
-    Function function_;
-  };
-}
-#endif // Rice__MethodInfo__hpp_