rice 3.0.0 → 4.0.3

data/rice/ruby_mark.hpp

@@ -5,9 +5,11 @@
 /*! This function can be specialized for a particular type to override
  *  the default behavior (which is to not mark any additional objects).
  */
-template<typename T>
-void ruby_mark(T * /* obj */)
+namespace Rice
 {
+  template<typename T>
+  void ruby_mark(T* data)
+  {
+  }
 }
-
 #endif // ruby_mark__hpp

data/rice/ruby_try_catch.hpp

@@ -1,11 +1,11 @@
 #ifndef Rice__ruby_try_catch__hpp_
 #define Rice__ruby_try_catch__hpp_
 
-#include "Exception_Base_defn.hpp"
-#include "Jump_Tag.hpp"
-#include "detail/ruby.hpp"
 #include <stdexcept>
 
+#include "detail/Jump_Tag.hpp"
+#include "Exception_defn.hpp"
+
 /*! \def RUBY_TRY
  *  \brief Start a block to catch Ruby exceptions and rethrow them.
  */
@@ -41,7 +41,7 @@
  *  \brief End a RUBY_TRY block.
  */
 #define RUBY_CATCH \
-  catch(::Rice::Exception_Base const & ex) \
+  catch(::Rice::Exception const & ex) \
   { \
     RUBY_RETHROW(ex.value()); \
   } \

data/rice/stl.hpp

@@ -0,0 +1,11 @@
+#ifndef Rice__stl__hpp_
+#define Rice__stl__hpp_
+
+#include "stl/string.hpp"
+#include "stl/complex.hpp"
+#include "stl/optional.hpp"
+#include "stl/pair.hpp"
+#include "stl/smart_ptr.hpp"
+#include "stl/vector.hpp"
+
+#endif // Rice__stl__hpp_

data/sample/callbacks/extconf.rb

@@ -1,3 +1,6 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('sample_callbacks')
 

data/sample/callbacks/sample_callbacks.cpp

@@ -1,24 +1,25 @@
-#include "rice/Data_Type.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/String.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
 namespace
 {
 
-  class CallbackHolder {
+  class CallbackHolder
+  {
     public:
 
-    void registerCallback(Rice::Object cb) {
-      callback = cb;
+    void registerCallback(Rice::Object cb)
+    {
+      callback_ = cb;
     }
 
-    Rice::Object fireCallback(Rice::String param) {
-      return callback.call("call", param);
+    Rice::Object fireCallback(Rice::String param)
+    {
+      return callback_.call("call", param);
     }
 
-    Rice::Object callback;
+    Rice::Object callback_;
   };
 
 } // namespace
@@ -26,13 +27,9 @@ namespace
 extern "C"
 void Init_sample_callbacks()
 {
-  RUBY_TRY
-  {
     define_class<CallbackHolder>("CallbackHolder")
       .define_constructor(Constructor<CallbackHolder>())
       .define_method("register_callback", &CallbackHolder::registerCallback)
       .define_method("fire_callback", &CallbackHolder::fireCallback);
-  }
-  RUBY_CATCH
 }
 

data/sample/enum/extconf.rb

@@ -1,3 +1,6 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('sample_enum')
 

data/sample/enum/sample_enum.cpp

@@ -1,5 +1,4 @@
-#include "rice/Enum.hpp"
-#include "rice/ruby_try_catch.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -13,8 +12,6 @@ enum Sample_Enum
   SE_BAZ = 100,
 };
 
-Rice::Enum<Sample_Enum> sample_enum_type;
-
 char const * description(Sample_Enum e)
 {
   switch(e)
@@ -28,27 +25,16 @@ char const * description(Sample_Enum e)
 
 } // namespace
 
-template<>
-Sample_Enum from_ruby<Sample_Enum>(Object x)
-{
-  Data_Object<Sample_Enum> d(x, sample_enum_type);
-  return *d;
-}
-
 extern "C"
 void Init_sample_enum()
 {
-  RUBY_TRY
-  {
-    sample_enum_type =
+    Rice::Enum<Sample_Enum> sample_enum_type =
       define_enum<Sample_Enum>("Sample_Enum")
       .define_value("FOO", SE_FOO)
       .define_value("BAR", SE_BAR)
       .define_value("BAZ", SE_BAZ);
-     
+
     sample_enum_type
       .define_method("description", description);
-  }
-  RUBY_CATCH
 }
 

data/sample/enum/test.rb

@@ -1,8 +1,8 @@
-require 'sample_enum'
+require_relative 'sample_enum'
 
 Sample_Enum.each { |x| p x }
 s = Sample_Enum::FOO
 puts s
 puts s.inspect
 puts s < Sample_Enum::BAR
-
+s.description

data/sample/inheritance/animals.cpp

@@ -1,43 +1,31 @@
-#include "rice/Data_Type.hpp"
-#include "rice/Constructor.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
 class Organism
 {
 public:
-  virtual ~Organism() = 0;
+  virtual ~Organism() = default;
   virtual char const * name() = 0;
 };
 
-Organism::
-~Organism()
-{
-}
-
 class Animal
   : public Organism
 {
 public:
-  virtual ~Animal() = 0;
   virtual char const * speak() = 0;
 };
 
-Animal::
-~Animal()
-{
-}
-
 class Bear
   : public Animal
 {
 public:
-  virtual char const * name()
+  char const * name() override
   {
     return "Bear";
   }
 
-  virtual char const * speak()
+  char const * speak() override
   {
     return "I'm smarter than the average bear";
   }
@@ -47,12 +35,12 @@ class Dog
   : public Animal
 {
 public:
-  virtual char const * name()
+  char const * name() override
   {
     return "Dog";
   }
 
-  virtual char const * speak()
+  char const * speak() override
   {
     return "Woof woof";
   }
@@ -62,12 +50,12 @@ class Rabbit
   : public Animal
 {
 public:
-  virtual char const * name()
+  char const * name() override
   {
     return "Rabbit";
   }
 
-  virtual char const * speak()
+  char const * speak() override
   {
     return "What's up, doc?";
   }
@@ -76,8 +64,6 @@ public:
 extern "C"
 void Init_animals(void)
 {
-  RUBY_TRY
-  {
     define_class<Organism>("Organism")
       .define_method("name", &Organism::name);
 
@@ -92,7 +78,5 @@ void Init_animals(void)
 
     define_class<Rabbit, Animal>("Rabbit")
       .define_constructor(Constructor<Rabbit>());
-  }
-  RUBY_CATCH
 }
 

data/sample/inheritance/extconf.rb

@@ -1,3 +1,6 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('animals')
 

data/sample/inheritance/test.rb

@@ -1,4 +1,4 @@
-require 'animals'
+require_relative 'animals'
 
 [ Bear, Dog, Rabbit].each do |klass|
   animal = klass.new

data/sample/map/extconf.rb

@@ -1,3 +1,6 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('map')
 

data/sample/map/map.cpp

@@ -1,5 +1,4 @@
-#include "rice/Data_Type.hpp"
-#include "rice/Constructor.hpp"
+#include <rice/rice.hpp>
 
 #include <map>
 
@@ -45,37 +44,30 @@ private:
   Value_Map map_;
 };
 
-Data_Type<Map> rb_cMap;
-
 } // namespace
 
 template<>
-Object to_ruby<Map::value_type>(Map::value_type const & p)
+struct detail::To_Ruby<Map::value_type>
 {
-  return protect(rb_assoc_new, p.first, p.second);
-}
+    static VALUE convert(Map::value_type const & pair)
+    {
+        return detail::protect(rb_assoc_new, pair.first.value(), pair.second.value());
+    }
+};
 
 #include <iostream>
 extern "C"
 void Init_map(void)
 {
-  RUBY_TRY
-  {
-    Map::iterator (Map::*begin)() = &Map::begin;
-    Map::iterator (Map::*end)() = &Map::end;
     Rice::Module rb_mStd = define_module("Std");
 
     // TODO: no delete method on the map, because I'm not sure how to
     // make delete work properly while iterating
-    rb_cMap =
+    Data_Type<Map> rb_cMap =
       define_class_under<Map>(rb_mStd, "Map")
       .define_constructor(Constructor<Map>())
       .define_method("[]", &Map::bracket)
       .define_method("[]=", &Map::bracket_equals)
-      .define_iterator(begin, end)
-      .include_module(rb_mEnumerable)
-      ;
-  }
-  RUBY_CATCH
+      .define_iterator(&Map::begin, &Map::end)
+      .include_module(rb_mEnumerable);
 }
-

data/sample/map/test.rb

@@ -1,4 +1,4 @@
-require 'map'
+require_relative 'map.so'
 m = Std::Map.new
 m[0] = 1
 m[1] = 2

data/test/embed_ruby.cpp

@@ -1,4 +1,5 @@
-#include <ruby.h>
+#include <rice/rice.hpp>
+#include <ruby/version.h>
 
 void embed_ruby()
 {
@@ -7,15 +8,27 @@ void embed_ruby()
   if (!initialized__)
   {
     int argc = 0;
-    char* argv = (char*)malloc(1);
-    argv[0] = 0;
+    char* argv = nullptr;
     char** pArgv = &argv;
 
     ruby_sysinit(&argc, &pArgv);
-    RUBY_INIT_STACK;
     ruby_init();
     ruby_init_loadpath();
 
     initialized__ = true;
+
+    // Because Ruby 3 no longer initializes the GC module when embedding, calling GC.stress 
+    // results in a crash.
+    // See https://bugs.ruby-lang.org/issues/17643
+    if (RUBY_API_VERSION_MAJOR == 3 &&
+        RUBY_API_VERSION_MINOR == 0 &&
+        RUBY_API_VERSION_TEENY == 0)
+    {
+      // do nothing
+    }
+    else
+    {
+      rb_eval_string("GC.stress = true");
+    }
   }
-}
+}

data/test/ext/t1/extconf.rb

@@ -1,2 +1,5 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('t1')

data/test/ext/t1/t1.cpp

@@ -1,7 +1,5 @@
 #include "Foo.hpp"
-
-#include "rice/Data_Type.hpp"
-#include "rice/Constructor.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 

data/test/ext/t2/extconf.rb

@@ -1,2 +1,5 @@
+require 'bundler/setup'
+require 'rice'
 require 'mkmf-rice'
+
 create_makefile('t2')

data/test/ext/t2/t2.cpp

@@ -1,5 +1,5 @@
 #include "../t1/Foo.hpp"
-#include "rice/Data_Type.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 

data/test/extconf.rb

@@ -0,0 +1,23 @@
+require 'bundler/setup'
+require 'rice'
+require 'mkmf-rice'
+require 'rbconfig'
+
+# Totally hack mkmf to make a unittest executable instead of a shared library
+target_exe = "unittest#{RbConfig::CONFIG['EXEEXT']}"
+$cleanfiles << target_exe
+
+create_makefile(target_exe) do |conf|
+  conf << "\n"
+  conf << "#{target_exe}: $(OBJS)"
+  conf << "\t$(ECHO) linking executable unittest"
+  conf << "\t-$(Q)$(RM) $(@)"
+
+  if IS_MSWIN
+    conf << "\t$(Q) $(CXX) -Fe$(@) $(OBJS) $(LIBS) $(LOCAL_LIBS) -link $(ldflags) $(LIBPATH)"
+  else
+    conf << "\t$(Q) $(CXX) -o $@ $(OBJS) $(LIBPATH) $(LOCAL_LIBS) $(LIBS)"
+  end
+
+  conf << "\n"
+end

data/test/ruby/test_callbacks_sample.rb

@@ -0,0 +1,28 @@
+$: << File.join(File.dirname(__FILE__), '..', 'sample')
+
+require 'rubygems'
+gem 'minitest'
+require 'minitest/autorun'
+require_relative '../../sample/callbacks/sample_callbacks'
+
+class CallbacksTest < Minitest::Test
+  def test_callbacks_sample_lambda
+    cb = CallbackHolder.new
+    cb.register_callback(lambda do |param|
+      "Callback got: #{param}"
+    end)
+
+    assert_equal "Callback got: Hello", cb.fire_callback("Hello")
+  end
+
+  def hello_world(param)
+    "Method got: #{param}"
+  end
+
+  def test_callbacks_sample_method
+    cb = CallbackHolder.new
+    cb.register_callback method(:hello_world)
+
+    assert_equal "Method got: Hello", cb.fire_callback("Hello")
+  end
+end

data/test/ruby/test_multiple_extensions.rb

@@ -0,0 +1,18 @@
+$: << File.join(__dir__, '..', '..', 'sample')
+
+require 'minitest'
+require 'minitest/autorun'
+
+class MultipleExtensionTest < Minitest::Test
+  def test_multiple_extensions
+    # Rinse
+    require 'map/map'
+    m = Std::Map.new
+    m[0] = 1
+
+    # And repeat
+    require 'enum/sample_enum'
+    m = Std::Map.new
+    m[0] = 1
+  end
+end

data/test/ruby/test_multiple_extensions_same_class.rb

@@ -0,0 +1,14 @@
+$: << File.join(__dir__, '..', 'ext')
+
+require 'minitest'
+require 'minitest/autorun'
+
+class MultipleExtensionsSameClassTest < Minitest::Test
+  def test_multiple_extensions_same_class
+    require 't1/t1'
+    require 't2/t2'
+
+    foo = Foo.new
+    assert_equal 42, foo.foo
+  end
+end

data/test/ruby/test_multiple_extensions_with_inheritance.rb

@@ -0,0 +1,20 @@
+$: << File.join(__dir__, '..', '..', 'sample')
+# Load a library that uses inheritance
+require 'inheritance/animals'
+
+# Then load a different library
+require 'enum/sample_enum'
+
+require 'minitest'
+require 'minitest/autorun'
+
+class MultipleExtensionTest < Minitest::Test
+  def test_multiple_extensions_with_inheritance
+
+    # And make sure we can call methods in the base class on a derived
+    # instance
+    dog = Dog.new
+    assert_equal dog.name, "Dog"
+    assert_equal dog.speak, "Woof woof"
+  end
+end

data/test/test_Address_Registration_Guard.cpp

@@ -1,6 +1,6 @@
 #include "unittest.hpp"
 #include "embed_ruby.hpp"
-#include "rice/Address_Registration_Guard.hpp"
+#include <rice/rice.hpp>
 
 using namespace Rice;
 
@@ -30,15 +30,28 @@ TESTCASE(get_address)
   ASSERT_EQUAL(&v, g.address());
 }
 
-TESTCASE(swap)
+TESTCASE(move_construct)
 {
-  VALUE v = Qnil;
-  VALUE v2 = Qnil;
-  Address_Registration_Guard g(&v);
-  Address_Registration_Guard g2(&v2);
-  g.swap(g2);
-  ASSERT_EQUAL(&v, g2.address());
-  ASSERT_EQUAL(&v2, g.address());
-  // TODO: ensure addresses are still registered
+  VALUE value = detail::to_ruby("Value 1");
+  
+  Address_Registration_Guard guard1(&value);
+  Address_Registration_Guard guard2(std::move(guard1));
+
+  ASSERT((guard1.address() == nullptr));
+  ASSERT_EQUAL(&value, guard2.address());
+}
+
+TESTCASE(move_assign)
+{
+  VALUE value1 = detail::to_ruby("Value 1");
+  VALUE value2 = detail::to_ruby("Value 2");
+
+  Address_Registration_Guard guard1(&value1);
+  Address_Registration_Guard guard2(&value2);
+
+  guard2 = std::move(guard1);
+
+  ASSERT((guard1.address() == nullptr));
+  ASSERT_EQUAL(&value1, guard2.address());
 }