rice 1.3.2 → 1.4.0

data/Doxyfile

@@ -23,7 +23,7 @@ PROJECT_NAME           = Rice
 # This could be handy for archiving the generated documentation or 
 # if some version control system is used.
 
-PROJECT_NUMBER         = 1.3.2
+PROJECT_NUMBER         = 1.4.0
 
 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
 # base path where the generated documentation will be put. 

data/README

@@ -695,6 +695,12 @@ can be used as expected:
   t.hello("goodnight", "moon")
 \endcode
 
+This will also work with Constructors:
+
+\code
+  .define_constructor(Constructor<SomeClass, int, int>(),
+      ( Arg("arg1") = 1, Arg("otherArg") = 12 );
+\endcode
 
 \section director Director
 
@@ -822,6 +828,43 @@ Rice::Data_Type::define_director, then define methods pointing to the proxy obje
 You must use the Rice::Director proxy class in the Constructor line, this allows proper
 object construction / destruction of the types in question.
 
+\section implicit_cast Implicit Casting
+
+There are times when a library exposes classes that while unrelated are
+built to be interchangeable across the library. One example of this,
+taken from Ogre, are the Degree and Radian classes. When a given method
+takes a Radian, you're free to pass in a Degree, and vice versa. 
+
+Rice cannot automatically figure out if this kind of functionality is
+possible in a given library but it does have a simple API for defining
+these relationships: Rice::define_implicit_cast<From, To>().
+
+\code
+class Degree { ... };
+class Radian { ... };
+
+extern "C"
+void Init_implicit() {
+  define_class<Degree>()
+    ...;
+  define_class<Radian>()
+    ...;
+
+  define_implicit_cast<Degree, Radian>();
+  define_implicit_cast<Radian, Degree>();
+}
+\endcode
+
+This support is still being fleshed out and has a few requirements for
+proper use:
+
+\li The two types must be bound in Rice before defining the cast.
+\li The classes must have constructors that take the other type.
+\li This feature cannot be used with fundamental types yet.
+
+To see a full example of this feature, please check out
+test/test_Data_Type.cpp.
+
 \section motivation Motivation
 
 There are a number of common problems when writing C or C++ extensions

data/Rakefile

@@ -1,7 +1,7 @@
+$: << File.expand_path(File.dirname(__FILE__))
 require 'rake/gempackagetask'
 require 'rake/contrib/sshpublisher'
 require 'yaml'
-require 'rubyforge'
 require 'ruby/lib/version'
 
 PROJECT_NAME = "rice"

data/extconf.rb

@@ -26,9 +26,11 @@ with_ruby = File.join(Config::CONFIG["bindir"], Config::CONFIG["RUBY_INSTALL_NAM
 other_opts = ""
 env = ""
 
+arch = Config::CONFIG["arch"].split("-")[0]
+
 if RUBY_PLATFORM =~ /darwin10/
   other_opts = "--disable-dependency-tracking"
-  env = "ARCHFLAGS='-arch x86_64'"
+  env = "ARCHFLAGS='-arch #{arch}'"
 elsif RUBY_PLATFORM =~ /darwin9/
   env = "ARCHFLAGS='-arch #{`uname -p`.chomp}'"
 end

data/rice/Data_Type.ipp

@@ -121,7 +121,8 @@ template<typename T>
 template<typename Constructor_T>
 inline Rice::Data_Type<T> & Rice::Data_Type<T>::
 define_constructor(
-    Constructor_T constructor)
+    Constructor_T /* constructor */,
+    Arguments* arguments)
 {
   check_is_bound();
 
@@ -129,11 +130,28 @@ define_constructor(
   rb_define_alloc_func(
       static_cast<VALUE>(*this),
       detail::default_allocation_func<T>);
-  define_method("initialize", &Constructor_T::construct);
+  define_method(
+      "initialize", 
+      &Constructor_T::construct,
+      arguments
+      );
 
   return *this;
 }
 
+template<typename T>
+template<typename Constructor_T>
+inline Rice::Data_Type<T> & Rice::Data_Type<T>::
+define_constructor(
+    Constructor_T constructor,
+    Arg const& arg)
+{
+  Arguments* args = new Arguments();
+  args->add(arg);
+  return define_constructor(constructor, args);
+}
+
+
 template<typename T>
 template<typename Director_T>
 inline Rice::Data_Type<T>& Rice::Data_Type<T>::
@@ -177,7 +195,7 @@ from_ruby(Object x)
 
   VALUE ancestors = rb_mod_ancestors(klass.value());
 
-  int earliest = RARRAY_LEN(ancestors) + 1;
+  long earliest = RARRAY_LEN(ancestors) + 1;
 
   int index;
   VALUE indexFound;
@@ -312,4 +330,36 @@ define_class(
   return Data_Type<T>::template bind<Base_T>(c);
 }
 
+template<typename From_T, typename To_T>
+inline void 
+Rice::define_implicit_cast()
+{
+  // As Rice currently expects only one entry into
+  // this list for a given klass VALUE, we need to get
+  // the current caster for From_T and insert in our
+  // new caster as the head of the caster list
+
+  Class from_class = Data_Type<From_T>::klass().value();
+  Class to_class = Data_Type<To_T>::klass().value();
+
+  detail::Abstract_Caster* from_caster = 
+    Data_Type<From_T>::caster_.release();
+
+  detail::Abstract_Caster* new_caster = 
+    new detail::Implicit_Caster<To_T, From_T>(from_caster, to_class);
+
+  // Insert our new caster into the list for the from class
+  Data_Type_Base::casters().erase(from_class);
+  Data_Type_Base::casters().insert(
+    std::make_pair(
+      from_class,
+      new_caster
+    )
+  );
+
+  // And make sure the from_class has direct access to the
+  // updated caster list
+  Data_Type<From_T>::caster_.reset(new_caster);
+}
+
 #endif // Rice__Data_Type__ipp_

data/rice/Data_Type_defn.hpp

@@ -39,7 +39,6 @@ public:
   // Must be public to workaround gcc 3.3
   typedef std::map<VALUE, detail::Abstract_Caster *> Casters;
 
-protected:
   virtual detail::Abstract_Caster * caster() const = 0;
 
   static Casters & casters();
@@ -93,6 +92,15 @@ template<typename T, typename Base_T>
 Rice::Data_Type<T> define_class(
     char const * name);
 
+//! Define an implicit conversion rule between two types.
+/*! Given two types, which can be custom types already 
+ *  wrapped into Rice or fundamental C++ types, this
+ *  tells Rice that the two types can be used interchangably.
+ *  \param From_T The type to convert from
+ *  \param To_T The type to convert to
+ */
+template<typename From_T, typename To_T>
+void define_implicit_cast();
 
 //! A mechanism for binding ruby types to C++ types.
 /*! This class binds run-time types (Ruby VALUEs) to compile-time types
@@ -151,7 +159,13 @@ public:
    */
   template<typename Constructor_T>
   Data_Type<T> & define_constructor(
-      Constructor_T constructor);
+      Constructor_T constructor,
+      Arguments * arguments = 0);
+
+  template<typename Constructor_T>
+  Data_Type<T> & define_constructor(
+      Constructor_T constructor,
+      Arg const& arg);
 
   //! Register a Director class for this class.
   /*! For any class that uses Rice::Director to enable polymorphism
@@ -188,6 +202,10 @@ public:
    */
   static bool is_bound();
 
+  virtual detail::Abstract_Caster * caster() const;
+
+  static std::auto_ptr<detail::Abstract_Caster> caster_;
+
 protected:
   //! Bind a Data_Type to a VALUE.
   /*! Throws an exception if the Data_Type is already bound to a
@@ -221,12 +239,9 @@ private:
   template<typename T_>
   friend class Data_Type;
 
-  virtual detail::Abstract_Caster * caster() const;
-
   static void check_is_bound();
 
   static VALUE klass_;
-  static std::auto_ptr<detail::Abstract_Caster> caster_;
 
   typedef std::set<Data_Type<T> *> Instances;
 

data/rice/config.hpp

@@ -2,19 +2,19 @@
 /* rice/config.hpp.in.  Generated from configure.ac by autoheader.  */
 
 /* Define to 1 if you have the <env.h> header file. */
-#define HAVE_ENV_H 1
+/* #undef HAVE_ENV_H */
 
 /* Define to 1 if you have the <node.h> header file. */
-#define HAVE_NODE_H 1
+/* #undef HAVE_NODE_H */
 
 /* Define to 1 if you have the <ruby.h> header file. */
 #define HAVE_RUBY_H 1
 
 /* Define to 1 if you have the <ruby/node.h> header file. */
-#define HAVE_RUBY_NODE_H 1
+/* #undef HAVE_RUBY_NODE_H */
 
 /* Define to 1 if you have the <version.h> header file. */
-#define HAVE_VERSION_H 1
+/* #undef HAVE_VERSION_H */
 
 /* Name of package */
 #define PACKAGE "rice"
@@ -35,7 +35,7 @@
 #define PACKAGE_VERSION "1.1"
 
 /* Define this macro to use ruby/node.h */
-#define REALLY_HAVE_RUBY_NODE_H 
+/* #undef REALLY_HAVE_RUBY_NODE_H */
 
 /* Version number of package */
 #define VERSION "1.1"

data/rice/detail/Caster.hpp

@@ -56,6 +56,46 @@ private:
   Module type_;
 };
 
+template<typename To_T, typename From_T>
+class Implicit_Caster
+  : public Abstract_Caster
+{
+public:
+  Implicit_Caster(Abstract_Caster * base_caster, Module type)
+    : base_caster_(base_caster)
+    , type_(type)
+  {
+  }
+
+protected:
+  virtual void * cast_to_base(void * derived, Module type) const
+  {
+    if(type.value() == type_.value())
+    {
+      return new To_T( *static_cast<From_T*>(derived) );
+    }
+    else
+    {
+      if(base_caster_)
+      {
+        return base_caster_->cast_to_base(derived, type);
+      }
+      else
+      {
+        std::string s = "bad cast. No implicit caster found for ";
+        s += type_.name().str();
+        throw std::runtime_error(s);
+      }
+    }
+  }
+
+private:
+  Abstract_Caster * base_caster_;
+  Module type_;
+};
+
+
+
 } // detail
 
 } // Rice

data/rice/detail/ruby_version_code.hpp

@@ -1,6 +1,6 @@
 #ifndef Rice__detail__ruby_version_code__hpp
 #define Rice__detail__ruby_version_code__hpp
 
-#define RICE__RUBY_VERSION_CODE 187
+#define RICE__RUBY_VERSION_CODE 192
 
 #endif // Rice__detail__ruby_version_code__hpp

data/rice/detail/to_ruby.ipp

@@ -7,8 +7,7 @@ convert(T const & x)
 {
   if(Data_Type<T>::is_bound())
   {
-    Data_Object<T> obj(&const_cast<T&>(x));
-    return obj;
+    return Rice::Data_Object<T >(new T(x), Rice::Data_Type<T >::klass());
   }
   else
   {

data/rice/ruby_mark.hpp

@@ -6,7 +6,7 @@
  *  the default behavior (which is to not mark any additional objects).
  */
 template<typename T>
-void ruby_mark(T * obj)
+void ruby_mark(T * /* obj */)
 {
 }
 

data/ruby/lib/mkmf-rice.rb.in

@@ -190,7 +190,7 @@ class RiceMakefileCreator
     end
 
     def puts(*strings)
-      print(*strings.map { |s| "#{s}\n" })
+      print(*strings.flatten.map { |s| "#{s}\n" })
     end
 
     def close

data/ruby/lib/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "1.3.2"
+  VERSION = "1.4.0"
 end

data/sample/enum/test.rb

@@ -1,3 +1,4 @@
+$: << "."
 require 'sample_enum'
 
 Sample_Enum.each { |x| p x }

data/test/Makefile.am

@@ -46,6 +46,7 @@ unittest_SOURCES = \
 	test_Hash.cpp \
 	test_Identifier.cpp \
 	test_Jump_Tag.cpp \
+	test_Memory_Management.cpp \
 	test_Module.cpp \
 	test_Object.cpp \
 	test_String.cpp \
@@ -60,6 +61,7 @@ vm_unittest_SOURCES = \
 
 AM_CPPFLAGS = \
 	-I.. \
+	$(RUBY_CFLAGS)
 	$(RUBY_CPPFLAGS)
 
 AM_CXXLAGS = \

data/test/Makefile.in

@@ -54,10 +54,10 @@ am_unittest_OBJECTS = unittest.$(OBJEXT) \
 	test_Director.$(OBJEXT) test_Enum.$(OBJEXT) \
 	test_Exception.$(OBJEXT) test_Hash.$(OBJEXT) \
 	test_Identifier.$(OBJEXT) test_Jump_Tag.$(OBJEXT) \
-	test_Module.$(OBJEXT) test_Object.$(OBJEXT) \
-	test_String.$(OBJEXT) test_Struct.$(OBJEXT) \
-	test_Symbol.$(OBJEXT) test_To_From_Ruby.$(OBJEXT) \
-	test_global_functions.$(OBJEXT)
+	test_Memory_Management.$(OBJEXT) test_Module.$(OBJEXT) \
+	test_Object.$(OBJEXT) test_String.$(OBJEXT) \
+	test_Struct.$(OBJEXT) test_Symbol.$(OBJEXT) \
+	test_To_From_Ruby.$(OBJEXT) test_global_functions.$(OBJEXT)
 unittest_OBJECTS = $(am_unittest_OBJECTS)
 unittest_LDADD = $(LDADD)
 am_vm_unittest_OBJECTS = unittest.$(OBJEXT) test_VM.$(OBJEXT)
@@ -237,6 +237,7 @@ unittest_SOURCES = \
 	test_Hash.cpp \
 	test_Identifier.cpp \
 	test_Jump_Tag.cpp \
+	test_Memory_Management.cpp \
 	test_Module.cpp \
 	test_Object.cpp \
 	test_String.cpp \
@@ -251,7 +252,7 @@ vm_unittest_SOURCES = \
 
 AM_CPPFLAGS = \
 	-I.. \
-	$(RUBY_CPPFLAGS)
+	$(RUBY_CFLAGS)
 
 AM_CXXLAGS = \
 	$(RUBY_CXXFLAGS)
@@ -324,6 +325,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_Hash.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_Identifier.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_Jump_Tag.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_Memory_Management.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_Module.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_Object.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test_String.Po@am__quote@
@@ -720,6 +722,7 @@ check: run_multiple_extensions_same_class_test
 
 run_multiple_extensions_same_class_test:
 	$(RUBY) test_multiple_extensions_same_class.rb
+	$(RUBY_CPPFLAGS)
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
 .NOEXPORT:

data/test/test_Constructor.cpp

@@ -65,63 +65,64 @@ TESTCASE(non_default_constructor)
   ASSERT_EQUAL(42, o->i());
 }
 
-/*
 namespace
 {
+  int withArgsX;
+  float withArgsY;
+  bool withArgsYes;
+
   class WithDefaultArgs
   {
     public:
       WithDefaultArgs(int x, float y = 2.0, bool yes = false)
       {
-        x_ = x;
-        y_ = y;
-        yes_ = yes;
+        withArgsX = x;
+        withArgsY = y;
+        withArgsYes = yes;
       }
+  };
 
-      WithDefaultArgs(int x = 14) {
-        x_ = x;
-        y_ = 1.0;
-        yes_ = false;
+  int withArgX;
+  class WithOneArg
+  {
+    public:
+      WithOneArg(int x = 14) {
+        withArgX = x;
       }
-
-      int getX() { return x_; }
-      float getY() { return y_; }
-      bool getYes() { return yes_; }
-
-    private:
-
-      int x_;
-      float y_;
-      bool yes_;
   };
 }
 
 TESTCASE(constructor_supports_default_arguments)
 {
   Class klass = define_class<WithDefaultArgs>("WithDefaultArgs").
-    define_constructor(Constructor<WithDefaultArgs, int, float, bool>(
-          ( Arg("x"), Arg("y") = (float)2.0, Arg("yes") = (bool)false )));
-
-  Data_Object<WithDefaultArgs> obj;
-
-  obj= klass.call("new", 4);
-  ASSERT_EQUAL(4, obj->getX());
-  ASSERT_EQUAL(2.0, obj->getY());
-  ASSERT_EQUAL(false, obj->getYes());
-
-  obj= klass.call("new", 5, 3.0);
-  ASSERT_EQUAL(5, obj->getX());
-  ASSERT_EQUAL(3.0, obj->getY());
-  ASSERT_EQUAL(false, obj->getYes());
-
-  obj= klass.call("new", 7, 12.0, true);
-  ASSERT_EQUAL(7, obj->getX());
-  ASSERT_EQUAL(12.0, obj->getY());
-  ASSERT_EQUAL(true, obj->getYes());
+    define_constructor(Constructor<WithDefaultArgs, int, float, bool>(),
+          ( Arg("x"), Arg("y") = (float)2.0, Arg("yes") = (bool)false ));
+
+  klass.call("new", 4);
+  ASSERT_EQUAL(4, withArgsX);
+  ASSERT_EQUAL(2.0, withArgsY);
+  ASSERT_EQUAL(false, withArgsYes);
+
+  klass.call("new", 5, 3.0);
+  ASSERT_EQUAL(5, withArgsX);
+  ASSERT_EQUAL(3.0, withArgsY);
+  ASSERT_EQUAL(false, withArgsYes);
+
+  klass.call("new", 7, 12.0, true);
+  ASSERT_EQUAL(7, withArgsX);
+  ASSERT_EQUAL(12.0, withArgsY);
+  ASSERT_EQUAL(true, withArgsYes);
 }
 
 TESTCASE(constructor_supports_single_default_argument)
 {
+  Class klass = define_class<WithOneArg>("WithOneArg").
+    define_constructor(Constructor<WithOneArg, int>(),
+          ( Arg("x") = 14 ));
+
+  klass.call("new");
+  ASSERT_EQUAL(14, withArgX);
 
+  klass.call("new", 6);
+  ASSERT_EQUAL(6, withArgX);
 }
-*/

data/test/test_Data_Type.cpp

@@ -2,6 +2,7 @@
 #include "rice/Data_Type.hpp"
 #include "rice/Exception.hpp"
 #include "rice/Constructor.hpp"
+#include "rice/global_function.hpp"
 
 using namespace Rice;
 
@@ -119,3 +120,229 @@ TESTCASE(no_super_in_constructor_still_works)
   ASSERT_EQUAL(INT2NUM(8), handler.call("process").value());
 }
 */
+
+/**
+ * Implicit Casting across unrelated types
+ *
+ * Two ways of defining if types are implicitly castable
+ *
+ * 1) operator
+ * 2) constructor 
+ */
+
+/**
+ * Examples here taken from Ogre's Math library.
+ * This uses the constructor method of casting types.
+ */
+namespace 
+{
+  const int degree2Radians = (3.14 / 180.0);
+  const int radian2Degrees = (180.0 / 3.14);
+
+  class Radian;
+
+  class Degree
+  {
+    public:
+      explicit Degree(float d) : val_(d) {}
+      Degree(const Radian& r);
+
+      float valueDegrees() const { return val_; }
+      float valueRadians() const { return val_ * degree2Radians; }
+
+    private:
+      float val_;
+  };
+
+  class Radian
+  {
+    public:
+      explicit Radian(float r) : val_(r) {} 
+      Radian(const Degree& d) : val_(d.valueRadians()) {}
+
+      float valueRadians() const { return val_; }
+      float valueDegrees() const { return val_ * radian2Degrees; }
+
+    private:
+      float val_;
+  };
+
+  // Due to circular dependencies, need to define some
+  // methods down here
+  Degree::Degree(const Radian& r)
+  {
+    val_ = r.valueDegrees();
+  }
+
+  /**
+   * And now some methods that work w/ the above two classes
+   */
+  bool isAcute(Degree degree) {
+    return degree.valueDegrees() < 90;
+  }
+
+  bool isObtuse(Radian radian) {
+    return radian.valueDegrees() > 90 && radian.valueDegrees() <= 180;
+  }
+
+  bool isRight(Degree* degree) {
+    return degree->valueDegrees() == 90;
+  }
+}
+
+TESTCASE(can_define_implicit_type_conversions_across_wrapped_types)
+{
+  define_class<Degree>("Degree")
+    .define_constructor(Constructor<Degree, float>());
+
+  define_class<Radian>("Radian")
+    .define_constructor(Constructor<Radian, float>());
+
+  define_implicit_cast<Degree, Radian>();
+  define_implicit_cast<Radian, Degree>();
+
+  define_global_function("is_acute", &isAcute);
+  define_global_function("is_obtuse", &isObtuse);
+  define_global_function("is_right", &isRight);
+
+  Module m = define_module("TestingModule");
+  Object result;
+
+  // ACUTE
+  result = m.instance_eval("is_acute(Degree.new(75))");
+  ASSERT(from_ruby<bool>(result.value()));
+
+  result = m.instance_eval("is_acute(Radian.new(2.0))");
+  ASSERT(!from_ruby<bool>(result.value()));
+
+  // OBTUSE
+  result = m.instance_eval("is_obtuse(Degree.new(75))");
+  ASSERT(!from_ruby<bool>(result.value()));
+
+  result = m.instance_eval("is_obtuse(Radian.new(2.0))");
+  ASSERT(from_ruby<bool>(result.value()));
+
+  // RIGHT
+  result = m.instance_eval("is_right(Degree.new(90))");
+  ASSERT(from_ruby<bool>(result.value()));
+
+  result = m.instance_eval("is_right(Radian.new(2.0))");
+  ASSERT(!from_ruby<bool>(result.value()));
+}
+
+namespace {
+  class Explicit
+  {
+    public:
+      Explicit(float v) {
+        value = v;
+      }
+
+      Explicit(const Degree &d) {
+        value = d.valueDegrees();
+      }
+
+      float getValue() { return value; }
+
+    private:
+      float value;
+  };
+
+  float getExplicitValue(Explicit* v) {
+    return v->getValue();
+  }
+}
+
+TESTCASE(supports_multiple_implicit_conversions_for_a_type)
+{
+  define_class<Degree>("Degree")
+    .define_constructor(Constructor<Degree, float>());
+
+  define_class<Radian>("Radian")
+    .define_constructor(Constructor<Radian, float>());
+
+  define_class<Explicit>("Explicit")
+    .define_constructor(Constructor<Explicit, float>());
+
+  define_global_function("is_obtuse", &isObtuse);
+  define_global_function("explicit_value", &getExplicitValue);
+
+  define_implicit_cast<Radian, Degree>();
+  define_implicit_cast<Degree, Radian>();
+  define_implicit_cast<Degree, Explicit>();
+
+  Module m = define_module("TestingModule");
+  Object result;
+
+  result = m.instance_eval("is_obtuse(Degree.new(75))");
+  ASSERT(!from_ruby<bool>(result.value()));
+
+  result = m.instance_eval("explicit_value(Degree.new(75))");
+  ASSERT_EQUAL(75.0, from_ruby<float>(result.value()));
+}
+
+/**
+ * Sample taken and modified from boost::python::implicit:
+ * http://www.boost.org/doc/libs/1_41_0/libs/python/doc/v2/implicit.html
+ *
+ * This is the operator version of casting and shows that this works for
+ * base types as well as defined types
+ */
+/*
+namespace {
+  struct Real
+  {
+    Real(int x)
+      : v(x)
+    {}
+
+    operator int() const
+    {
+      return v;
+    }
+
+    int v;
+  };
+
+  int realValue(Real const& x)
+  {
+    return x.v;
+  }
+
+  Real makeReal(int n)
+  {
+    return Real(n);
+  }
+}
+
+TESTCASE(can_define_implicit_type_conversions_to_base_types)
+{
+  define_class<Real>("Real")
+    .define_constructor(Constructor<Real, int>());
+
+  // Define the conversion rules
+  define_implicit_cast<Real, int>();
+  define_implicit_cast<int, Real>();
+
+  define_global_function("real_value", &realValue);
+  define_global_function("make_real", &makeReal);
+
+  Module m = define_module("TestingModule");
+
+  // As Real object
+  Object result = m.instance_eval("real_value( Real.new(4) )");
+  ASSERT_EQUAL(4, from_ruby<int>(result.value()));
+
+  // As fixnum (int)
+  result = m.instance_eval("real_value(4)");
+  ASSERT_EQUAL(4, from_ruby<int>(result.value()));
+
+  // As Real object
+  result = m.instance_eval("r = make_real( Real.new(6) ); real_value(r)");
+  ASSERT_EQUAL(6, from_ruby<int>(result.value()));
+
+  // As fixnum (int)
+  result = m.instance_eval("r = make_real(6); real_value(r)");
+  ASSERT_EQUAL(6, from_ruby<int>(result.value()));
+}
+*/

data/test/test_Memory_Management.cpp

@@ -0,0 +1,50 @@
+#include "unittest.hpp"
+#include "rice/String.hpp"
+#include "rice/Class.hpp"
+#include "rice/global_function.hpp"
+
+using namespace Rice;
+
+TESTSUITE(Memory_Management);
+
+SETUP(Memory_Management)
+{
+  ruby_init();
+}
+
+namespace
+{
+  class TestClass {
+    double tmp;
+    public:
+      TestClass() {tmp=0;}
+
+      double getTmp() {
+        return tmp;
+      }
+
+      void setTmp(double x) {
+        tmp = x;
+      }
+  };
+
+  TestClass returnTestClass() {
+    TestClass x = TestClass();
+    x.setTmp(8);
+    return x;
+  }
+}
+
+TESTCASE(allows_copy_contructors_to_work)
+{
+  define_class<TestClass>("TestClass")
+    .define_method("tmp=", &TestClass::setTmp)
+    .define_method("tmp", &TestClass::getTmp);
+
+  define_global_function("return_test_class", &returnTestClass);
+
+  Module m = define_module("TestingModule");
+
+  Object result = m.instance_eval("return_test_class.tmp");
+  ASSERT_EQUAL(8.0, from_ruby<double>(result.value()));
+}

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 3
-  - 2
-  version: 1.3.2
+  - 4
+  - 0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Paul Brannan
@@ -15,13 +15,14 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-06 00:00:00 -04:00
+date: 2010-08-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rubyforge
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
@@ -230,6 +231,7 @@ files:
 - test/test_Hash.cpp
 - test/test_Identifier.cpp
 - test/test_Jump_Tag.cpp
+- test/test_Memory_Management.cpp
 - test/test_Module.cpp
 - test/test_Object.cpp
 - test/test_String.cpp
@@ -246,6 +248,7 @@ files:
 - test/ext/t1/t1.cpp
 - test/ext/t2/extconf.rb
 - test/ext/t2/t2.cpp
+- test/test_rice.rb
 has_rdoc: true
 homepage: http://rice.rubyforge.org/
 licenses: []
@@ -256,6 +259,7 @@ rdoc_options: []
 require_paths: 
 - ruby/lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -263,6 +267,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -272,7 +277,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: rice
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Ruby Interface for C++ Extensions