rice 4.6.1 → 4.7.0

data/rice/libc/file.ipp

@@ -1,15 +1,12 @@
 #include <exception>
 
-// Libraries sometime inherit custom exception objects from std::exception,
-// so define it for Ruby if necessary
-namespace Rice::libc
+namespace Rice::Libc
 {
   inline Class rb_cLibcFile;
 
   inline void define_libc_file()
   {
-    Module rb_mRice = define_module("Rice");
-    Module rb_mLibc = define_module_under(rb_mRice, "libc");
+    Module rb_mLibc = define_module("Libc");
     rb_cLibcFile = define_class_under<FILE>(rb_mLibc, "File");
   }
 }
@@ -23,7 +20,7 @@ namespace Rice::detail
     {
       if (!Data_Type<FILE>::is_defined())
       {
-        libc::define_libc_file();
+        Libc::define_libc_file();
       }
 
       return true;

data/rice/rice.hpp

@@ -4,8 +4,9 @@
 // Ruby
 #include "detail/ruby.hpp"
 
-// C++ headers -h has to come after Ruby on MacOS for reasons I do not understand
+// C++ headers have to come after Ruby on MacOS for reasons I do not understand
 #include <cstdio>
+#include <cstring> // For std::memset
 #include <string>
 #include <typeinfo>
 #include <typeindex>
@@ -21,22 +22,28 @@
 #include "traits/method_traits.hpp"
 #include "traits/attribute_traits.hpp"
 
+// Wrap C++ objects as Ruby objects
+#include "detail/Wrapper.hpp"
+#include "detail/Type.hpp"
+
 // Code for C++ to call Ruby
 #include "Exception.hpp"
 #include "JumpException.hpp"
 #include "JumpException.ipp"
-#include "detail/RubyFunction.hpp"
-#include "detail/RubyFunction.ipp"
+#include "detail/NativeInvoker.hpp"
+#include "detail/NativeInvoker.ipp"
 #include "detail/to_ruby.hpp"
 
 // Code for Ruby to call C++
 #include "Arg.hpp"
 #include "Return.hpp"
+#include "Function.hpp"
 #include "detail/MethodInfo.hpp"
 #include "detail/from_ruby.hpp"
+#include "detail/RubyType.hpp"
+#include "detail/Parameter.hpp"
 
 // C++ API declarations
-#include "detail/Type.hpp"
 #include "cpp_api/Encoding.hpp"
 #include "cpp_api/Identifier.hpp"
 #include "cpp_api/Identifier.ipp"
@@ -55,26 +62,28 @@
 #include "detail/NativeAttributeSet.hpp"
 #include "Data_Type.hpp"
 #include "Data_Object.hpp"
-
-// Type Conversion declarations
-#include "detail/RubyType.hpp"
 #include "detail/RubyType.ipp"
-#include "detail/Wrapper.hpp"
 
 // Registries
 #include "detail/TypeRegistry.hpp"
 #include "detail/InstanceRegistry.hpp"
 #include "detail/DefaultHandler.hpp"
 #include "detail/HandlerRegistry.hpp"
+#include "detail/ModuleRegistry.hpp"
 #include "detail/NativeRegistry.hpp"
 #include "detail/Registries.hpp"
 
 // To / From Ruby
 #include "Arg.ipp"
+#include "detail/Parameter.ipp"
 #include "Return.ipp"
+#include "Function.ipp"
 #include "Constructor.hpp"
 #include "Buffer.hpp"
+#include "Pointer.hpp"
 #include "Buffer.ipp"
+#include "Pointer.ipp"
+#include "detail/Types.ipp"
 #include "detail/to_ruby.ipp"
 #include "detail/from_ruby.ipp"
 #include "detail/Proc.hpp"
@@ -84,6 +93,7 @@
 #include "detail/InstanceRegistry.ipp"
 #include "detail/DefaultHandler.ipp"
 #include "detail/HandlerRegistry.ipp"
+#include "detail/ModuleRegistry.ipp"
 #include "detail/NativeRegistry.ipp"
 #include "detail/Registries.ipp"
 
@@ -101,6 +111,10 @@
 #include "detail/NativeFunction.ipp"
 #include "detail/NativeIterator.hpp"
 #include "detail/NativeIterator.ipp"
+#include "detail/NativeMethod.hpp"
+#include "detail/NativeMethod.ipp"
+#include "detail/NativeProc.hpp"
+#include "detail/NativeProc.ipp"
 #include "detail/NativeCallbackFFI.hpp"
 #include "detail/NativeCallbackFFI.ipp"
 #include "detail/NativeCallbackSimple.hpp"
@@ -147,8 +161,4 @@
 // For now include libc support - maybe should be separate header file someday
 #include "libc/file.hpp"
 
-// Initialize Rice
-#include "Init.hpp"
-#include "Init.ipp"
-
 #endif // Rice__hpp_

data/rice/rice_api/Arg.hpp

@@ -0,0 +1,7 @@
+#ifndef Rice_Api_Arg_hpp
+#define Rice_Api_Arg_hpp
+
+extern "C"
+void Init_Arg();
+
+#endif

data/rice/rice_api/Arg.ipp

@@ -0,0 +1,9 @@
+using namespace Rice;
+
+inline void Init_Arg()
+{
+  Module rb_mRice = define_module("Rice");
+
+  define_class_under<Arg>(rb_mRice, "Arg").
+    define_attr("name", &Arg::name, AttrAccess::Read);
+}

data/rice/rice_api/ModuleRegistry.hpp

@@ -0,0 +1,7 @@
+#ifndef Rice_Api_Module_Registry_hpp
+#define Rice_Api_Module_Registry_hpp
+
+extern "C"
+void Init_Module_Registry();
+
+#endif

data/rice/rice_api/ModuleRegistry.ipp

@@ -0,0 +1,10 @@
+using namespace Rice;
+
+extern "C"
+void Init_Module_Registry()
+{
+  Module rb_mRice = define_module("Rice");
+
+  Rice::define_class_under<detail::ModuleRegistry>(rb_mRice, "ModuleRegistry").
+    define_method("modules", &detail::ModuleRegistry::modules, Return().setValue());
+}

data/rice/rice_api/Native.hpp

@@ -0,0 +1,7 @@
+#ifndef Rice_Api_Native_Function_hpp
+#define Rice_Api_Native_Function_hpp
+
+extern "C"
+void Init_Native();
+
+#endif

data/rice/rice_api/Native.ipp

@@ -0,0 +1,52 @@
+using namespace Rice;
+
+#include <ostream>
+
+extern "C"
+inline void Init_Native()
+{
+  Module rb_mRice = define_module("Rice");
+
+  define_enum_under<detail::NativeKind>("NativeKind", rb_mRice)
+    .define_value("Function", detail::NativeKind::Function)
+    .define_value("Method", detail::NativeKind::Method)
+    .define_value("AttributeReader", detail::NativeKind::AttributeReader)
+    .define_value("AttributeWriter", detail::NativeKind::AttributeWriter)
+    .define_value("Proc", detail::NativeKind::Proc);
+
+  define_class_under<detail::Native>(rb_mRice, "Native").
+    define_method("name", &detail::Native::name).
+    define_method("kind", &detail::Native::kind).
+    define_method("return_klass", &detail::Native::returnKlass, Return().setValue()).
+    define_method("parameters", &detail::Native::parameters).
+    define_method("to_s", [](detail::Native& self) -> std::string
+      {
+        std::ostringstream stream;
+        stream << "Native";
+
+        switch (self.kind())
+        {
+          case detail::NativeKind::Function:
+            stream << "Function";
+            break;
+          case detail::NativeKind::Method:
+            stream << "Method";
+            break;
+          case detail::NativeKind::Iterator:
+            stream << "Iterator";
+            break;
+          case detail::NativeKind::AttributeReader:
+            stream << "AttributeReader";
+            break;
+          case detail::NativeKind::AttributeWriter:
+            stream << "AttributeWriter";
+            break;
+          case detail::NativeKind::Proc:
+            stream << "Proc";
+            break;
+        }
+
+        stream << "<" << self.name() << "> ";
+        return stream.str();
+      });
+}

data/rice/rice_api/NativeRegistry.hpp

@@ -0,0 +1,7 @@
+#ifndef Rice_Api_Native_Registry_hpp
+#define Rice_Api_Native_Registry_hpp
+
+extern "C"
+void Init_Native_Registry();
+
+#endif

data/rice/rice_api/NativeRegistry.ipp

@@ -0,0 +1,21 @@
+using namespace Rice;
+
+extern "C"
+inline void Init_Native_Registry()
+{
+  Module rb_mRice = define_module("Rice");
+
+  Rice::define_class_under<detail::NativeRegistry>(rb_mRice, "NativeRegistry").
+    define_method("lookup", [](detail::NativeRegistry& self, VALUE klass) -> Array
+    {
+      Array result;
+
+      const std::vector<detail::Native*> natives = self.lookup(klass);
+      for (detail::Native* native : natives)
+      {
+        result.push(native, false);
+      }
+
+      return result;
+    }, Arg("klass").setValue());
+}

data/rice/rice_api/Parameter.hpp

@@ -0,0 +1,7 @@
+#ifndef Rice_Api_Parameter_hpp
+#define Rice_Api_Parameter_hpp
+
+extern "C"
+void Init_Parameter();
+
+#endif

data/rice/rice_api/Parameter.ipp

@@ -0,0 +1,11 @@
+using namespace Rice;
+
+inline void Init_Parameter()
+{
+  Module rb_mRice = define_module("Rice");
+
+  define_class_under<detail::ParameterAbstract>(rb_mRice, "Parameter").
+    define_attr("arg", &detail::ParameterAbstract::arg).
+    define_method("klass", &detail::ParameterAbstract::klass, Return().setValue()).
+    define_method("cpp_klass", &detail::ParameterAbstract::cppTypeName);
+}

data/rice/rice_api/Registries.hpp

@@ -0,0 +1,6 @@
+#ifndef Rice_Api_Registries_hpp
+#define Rice_Api_Registries_hpp
+
+void Init_Registries();
+
+#endif

data/rice/rice_api/Registries.ipp

@@ -0,0 +1,12 @@
+using namespace Rice;
+
+inline void Init_Registries()
+{
+  Module rb_mRice = define_module("Rice");
+
+  define_class_under<detail::Registries>(rb_mRice, "Registries").
+    define_singleton_attr("instance", &detail::Registries::instance, AttrAccess::Read).
+    define_attr("modules", &detail::Registries::modules, AttrAccess::Read).
+    define_attr("natives", &detail::Registries::natives, AttrAccess::Read).
+    define_attr("types", &detail::Registries::types, AttrAccess::Read);
+}

data/rice/rice_api/TypeRegistry.hpp

@@ -0,0 +1,7 @@
+#ifndef Rice_Api_Type_Registry_hpp
+#define Rice_Api_Type_Registry_hpp
+
+extern "C"
+void Init_Type_Registry();
+
+#endif

data/rice/rice_api/TypeRegistry.ipp

@@ -0,0 +1,10 @@
+using namespace Rice;
+
+extern "C"
+void Init_Type_Registry()
+{
+  Module rb_mRice = define_module("Rice");
+
+  Rice::define_class_under<detail::TypeRegistry>(rb_mRice, "TypeRegistry").
+    define_method("klasses", &detail::TypeRegistry::klasses, Return().setValue());
+}

data/rice/stl/complex.ipp

@@ -9,12 +9,23 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cComplex;
+    }
   };
 
   template<typename T>
   class To_Ruby<std::complex<T>>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::complex<T>& data)
     {
       std::vector<VALUE> args(2);
@@ -22,12 +33,21 @@ namespace Rice::detail
       args[1] = To_Ruby<T>().convert(data.imag());
       return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class To_Ruby<std::complex<T>&>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::complex<T>& data)
     {
       std::vector<VALUE> args(2);
@@ -35,12 +55,21 @@ namespace Rice::detail
       args[1] = To_Ruby<T>().convert(data.imag());
       return protect(rb_funcallv, rb_mKernel, rb_intern("Complex"), (int)args.size(), (const VALUE*)args.data());
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<typename T>
   class From_Ruby<std::complex<T>>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))
@@ -66,6 +95,12 @@ namespace Rice::detail
   class From_Ruby<std::complex<T>&>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       switch (rb_type(value))

data/rice/stl/exception.ipp

@@ -4,14 +4,17 @@
 // so define it for Ruby if necessary
 namespace Rice::stl
 {
-  inline Class rb_cStlException;
-
-  inline void define_stl_exception()
+  inline void define_stl_exceptions()
   {
     Module rb_mStd = define_module("Std");
-    rb_cStlException = define_class_under<std::exception>(rb_mStd, "Exception", rb_eStandardError).
-                        define_constructor(Constructor<std::exception>()).
-                        define_method("message", &std::exception::what);
+
+    define_class_under<std::exception>(rb_mStd, "Exception", rb_eStandardError).
+      define_constructor(Constructor<std::exception>()).
+      define_method("message", &std::exception::what);
+
+    define_class_under<std::runtime_error>(rb_mStd, "RuntimeError", rb_eRuntimeError).
+      define_constructor(Constructor<std::runtime_error, const char*>()).
+      define_method("message", &std::runtime_error::what);
   }
 }
 
@@ -22,7 +25,17 @@ namespace Rice::detail
   {
     static bool verify()
     {
-      Rice::stl::define_stl_exception();
+      Rice::stl::define_stl_exceptions();
+      return true;
+    }
+  };
+
+  template<>
+  struct Type<std::runtime_error>
+  {
+    static bool verify()
+    {
+      Rice::stl::define_stl_exceptions();
       return true;
     }
   };

data/rice/stl/filesystem.hpp

@@ -0,0 +1,6 @@
+#ifndef Rice__stl__filesystem__hpp_
+#define Rice__stl__filesystem__hpp_
+
+#include "filesystem.ipp"
+
+#endif // Rice__stl__filesystem__hpp_

data/rice/stl/filesystem.ipp

@@ -0,0 +1,34 @@
+#include <filesystem>
+
+namespace Rice
+{
+  namespace stl
+  {
+    inline void define_filesystem_path()
+    {
+      Module rb_mStd = define_module("Std");
+      Module rb_mFileSystem = define_module_under(rb_mStd, "Filesystem");
+
+      define_class_under<std::filesystem::path>(rb_mFileSystem, "Path").
+        define_constructor(Constructor<std::filesystem::path>()).
+        define_constructor(Constructor<std::filesystem::path, std::string>());
+    }
+  }
+}
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<std::filesystem::path>
+  {
+    static bool verify()
+    {
+      if (!Data_Type<std::filesystem::path>::is_defined())
+      {
+        Rice::stl::define_filesystem_path();
+      }
+
+      return true;
+    }
+  };
+}

data/rice/stl/map.ipp

@@ -19,8 +19,7 @@ namespace Rice
       MapHelper(Data_Type<T> klass) : klass_(klass)
       {
         this->register_pair();
-        this->define_constructor();
-        this->define_copyable_methods();
+        this->define_constructors();
         this->define_capacity_methods();
         this->define_access_methods();
         this->define_comparable_methods();
@@ -37,27 +36,13 @@ namespace Rice
         define_pair<const Key_T, Mapped_T>();
       }
 
-      void define_constructor()
+      void define_constructors()
       {
         klass_.define_constructor(Constructor<T>());
-      }
 
-      void define_copyable_methods()
-      {
-        if constexpr (std::is_copy_constructible_v<Value_T>)
-        {
-          klass_.define_method("copy", [](T& map) -> T
-            {
-              return map;
-            });
-        }
-        else
+        if constexpr (std::is_copy_constructible_v<Key_T> && std::is_copy_constructible_v<Value_T>)
         {
-          klass_.define_method("copy", [](T& map) -> T
-            {
-              throw std::runtime_error("Cannot copy maps with non-copy constructible types");
-              return map;
-            });
+          klass_.define_constructor(Constructor<T, const T&>());
         }
       }
 
@@ -240,8 +225,8 @@ namespace Rice
 
     if (klassName.empty())
     {
-      std::string typeName = detail::typeName(typeid(Map_T));
-      klassName = detail::rubyClassName(typeName);
+      detail::TypeMapper<Map_T> typeMapper;
+      klassName = typeMapper.rubyName();
     }
 
     Module rb_mStd = define_module("Std");
@@ -418,6 +403,12 @@ namespace Rice
     class From_Ruby<std::map<T, U>*>
     {
     public:
+      From_Ruby() = default;
+
+      explicit From_Ruby(Arg* arg) : arg_(arg)
+      {
+      }
+
       Convertible is_convertible(VALUE value)
       {
         switch (rb_type(value))
@@ -463,6 +454,7 @@ namespace Rice
       }
 
     private:
+      Arg* arg_;
       std::map<T, U> converted_;
     };
   }

data/rice/stl/monostate.ipp

@@ -9,32 +9,62 @@ namespace Rice::detail
     {
       return true;
     }
+
+    static VALUE rubyKlass()
+    {
+      return rb_cNilClass;
+    }
   };
 
   template<>
   class To_Ruby<std::monostate>
   {
   public:
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
     VALUE convert(const std::monostate& _)
     {
       return Qnil;
     }
+
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class To_Ruby<std::monostate&>
   {
   public:
-    static VALUE convert(const std::monostate& data, bool takeOwnership = false)
+    To_Ruby() = default;
+
+    explicit To_Ruby(Return* returnInfo) : returnInfo_(returnInfo)
+    {
+    }
+
+    VALUE convert(const std::monostate& data)
     {
       return Qnil;
     }
+
+  private:
+    Return* returnInfo_ = nullptr;
   };
 
   template<>
   class From_Ruby<std::monostate>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       return value == Qnil ? Convertible::Exact : Convertible::None;
@@ -57,6 +87,12 @@ namespace Rice::detail
   class From_Ruby<std::monostate&>
   {
   public:
+    From_Ruby() = default;
+
+    explicit From_Ruby(Arg* arg)
+    {
+    }
+
     Convertible is_convertible(VALUE value)
     {
       return value == Qnil ? Convertible::Exact : Convertible::None;