rice 4.3.2 → 4.5.0

data/rice/detail/Type.ipp

@@ -1,12 +1,3 @@
-#include "../traits/rice_traits.hpp"
-
-#include <iosfwd>
-#include <iterator>
-#include <numeric>
-#include <regex>
-#include <sstream>
-#include <tuple>
-
 #ifdef __GNUC__
 #include <cxxabi.h>
 #include <cstdlib>
@@ -15,6 +6,19 @@
 
 namespace Rice::detail
 {
+  template<typename T>
+  bool Type<T>::verify()
+  {
+    if constexpr (std::is_fundamental_v<T>)
+    {
+      return true;
+    }
+    else
+    {
+      return Registries::instance.types.verify<T>();
+    }
+  }
+
   template<>
   struct Type<void>
   {
@@ -89,13 +93,76 @@ namespace Rice::detail
     return demangle(typeInfo.name());
   }
 
-  inline std::string makeClassName(const std::type_info& typeInfo)
+  inline std::string typeName(const std::type_index& typeIndex)
+  {
+    return demangle(typeIndex.name());
+  }
+
+  // Find text inside of < > taking into account nested groups.
+  // 
+  // Example:
+  //  
+  //   std::vector<std::vector<int>, std::allocator<std::vector, std::allocator<int>>>
+  inline std::string findGroup(std::string& string, size_t offset)
+  {
+    int depth = 0;
+
+    auto begin = string.begin() + offset;
+    auto start = begin;
+    for (auto iter = begin; iter != string.end(); iter++)
+    {
+      if (*iter == '<')
+      {
+        if (depth == 0)
+        {
+          start = iter;
+        }
+        depth++;
+      }
+      else if (*iter == '>')
+      {
+        depth--;
+        if (depth == 0)
+        {
+          // Add + 1 to include current ">" character
+          return string.substr(offset + (start - begin), 1 + (iter - start));
+        }
+        else if (depth < 0)
+        {
+          throw std::runtime_error("Unbalanced Group");
+        }
+      }
+    }
+    throw std::runtime_error("Unbalanced Group");
+  }
+
+  inline void replaceAll(std::string& string, std::regex regex, std::string replacement)
   {
-    std::string base = demangle(typeInfo.name());
+    std::smatch match;
+    while (std::regex_search(string, match, regex))
+    {
+      string = std::regex_replace(string, regex, replacement);
+    }
+  }
+
+  inline void removeGroup(std::string& string, std::regex regex)
+  {
+    std::smatch match;
+    while (std::regex_search(string, match, regex))
+    {
+      std::string group = findGroup(string, match.position());
+      group = match.str() + group;
+      string.erase(match.position(), group.length());
+    }
+  }
+
+  inline std::string makeClassName(const std::string& typeInfoName)
+  {
+    std::string base = typeInfoName;
 
     // Remove class keyword
     auto classRegex = std::regex("class +");
-    base = std::regex_replace(base, classRegex, "");
+    base = std::regex_replace(typeInfoName, classRegex, "");
 
     // Remove struct keyword
     auto structRegex = std::regex("struct +");
@@ -109,31 +176,81 @@ namespace Rice::detail
     auto stdRegex = std::regex("std::");
     base = std::regex_replace(base, stdRegex, "");
 
-    // Replace > > 
-    auto trailingAngleBracketSpaceRegex = std::regex(" >");
-    base = std::regex_replace(base, trailingAngleBracketSpaceRegex, ">");
+    // Replace basic_string with string
+    auto basicStringRegex = std::regex(R"(basic_string)");
+    replaceAll(base, basicStringRegex, "string");
+      
+    // Remove allocators
+    std::regex allocatorRegex(R"(,\s*allocator)");
+    removeGroup(base, allocatorRegex);
 
-    // Replace < and >
-    auto angleBracketRegex = std::regex("<|>");
-    base = std::regex_replace(base, angleBracketRegex, "__");
+    // Remove char_traits
+    std::regex charTraitsRegex(R"(,\s*char_traits)");
+    removeGroup(base, charTraitsRegex);
 
-    // Replace ,
-    auto commaRegex = std::regex(", *");
-    base = std::regex_replace(base, commaRegex, "_");
+    // Remove less (std::map)
+    std::regex lessRegex(R"(,\s*less)");
+    removeGroup(base, lessRegex);
 
-    // Now create a vector of strings split on whitespace
-    std::istringstream stream(base);
-    std::vector<std::string> words{ std::istream_iterator<std::string>{stream},
-                                    std::istream_iterator<std::string>{} };
+    // Remove hash (std::unordered_map)
+    std::regex hashRegex(R"(,\s*hash)");
+    removeGroup(base, hashRegex);
 
-    std::string result = std::accumulate(words.begin(), words.end(), std::string(),
-      [](const std::string& memo, const std::string& word) -> std::string
-      {
-        std::string capitalized = word;
-        capitalized[0] = toupper(capitalized[0]);
-        return memo + capitalized;
-      });
+    // Remove equal_to (std::unordered_map)
+    std::regex equalRegex(R"(,\s*equal_to)");
+    removeGroup(base, equalRegex);
+
+    // Remove spaces before pointers
+    auto ptrRegex = std::regex(R"(\s+\*)");
+    base = std::regex_replace(base, ptrRegex, "*");
+
+    // Remove __ptr64
+    std::regex ptr64Regex(R"(\s*__ptr64\s*)");
+    base = std::regex_replace(base, ptr64Regex, "");
+
+    // Replace " >" with ">"
+    auto trailingAngleBracketSpaceRegex = std::regex(R"(\s+>)");
+    replaceAll(base, trailingAngleBracketSpaceRegex, ">");
+
+    // One space after a comma (MSVC has no spaces, GCC one space)
+    auto commaSpaceRegex = std::regex(R"(,(\S))");
+    replaceAll(base, commaSpaceRegex, ", $1");
+
+    // Capitalize first letter
+    base[0] = std::toupper(base[0]);
+
+    // Replace :: with unicode U+u02F8 (Modified Letter raised colon)
+    auto colonRegex = std::regex(R"(:)");
+    replaceAll(base, colonRegex, "\uA789");
+
+    // Replace _ and capitalize the next letter
+    std::regex namespaceRegex(R"(_(\w))");
+    std::smatch namespaceMatch;
+    while (std::regex_search(base, namespaceMatch, namespaceRegex))
+    {
+      std::string replacement = namespaceMatch[1];
+      std::transform(replacement.begin(), replacement.end(), replacement.begin(), ::toupper);
+      base.replace(namespaceMatch.position(), namespaceMatch.length(), replacement);
+    }
+
+    // Replace spaces with unicode U+u00A0 (Non breaking Space)
+    auto spaceRegex = std::regex(R"(\s+)");
+    replaceAll(base, spaceRegex, "\u00A0");
+
+    // Replace < with unicode U+227A (Precedes)
+    auto lessThanRegex = std::regex("<");
+    //replaceAll(base, lessThanRegex, u8"≺");
+    replaceAll(base, lessThanRegex, "\u227A");
+
+    // Replace > with unicode U+227B (Succeeds)
+    auto greaterThanRegex = std::regex(">");
+    //replaceAll(base, greaterThanRegex, u8"≻");
+    replaceAll(base, greaterThanRegex, "\u227B");
+
+    // Replace , with Unicode Character (U+066C) - Arabic Thousands Separator
+    auto commaRegex = std::regex(R"(,\s*)");
+    replaceAll(base, commaRegex, "\u201A");
 
-    return result;
+    return base;
   }
 }

data/rice/detail/TypeRegistry.hpp

@@ -2,12 +2,10 @@
 #define Rice__TypeRegistry__hpp_
 
 #include <optional>
-#include <string>
-#include <typeindex>
-#include <typeinfo>
 #include <unordered_map>
+#include <set>
+#include <regex>
 
-#include "ruby.hpp"
 
 /* The type registry keeps track of all C++ types wrapped by Rice. When a native function returns 
    an instance of a class/struct we look up its type to verity that it has been registered. 
@@ -31,17 +29,27 @@ namespace Rice::detail
     bool isDefined();
 
     template <typename T>
-    bool verifyDefined();
+    std::pair<VALUE, rb_data_type_t*> getType();
+
+    template <typename T>
+    bool verify();
       
     template <typename T>
     std::pair<VALUE, rb_data_type_t*> figureType(const T& object);
 
+    // Validate types and throw if any types are unverified
+    void validateTypes();
+
+    // Clear unverified types. This is mostly for unit tests
+    void clearUnverifiedTypes();
+
   private:
     std::optional<std::pair<VALUE, rb_data_type_t*>> lookup(const std::type_info& typeInfo);
+    void raiseUnverifiedType(const std::string& typeName);
+
     std::unordered_map<std::type_index, std::pair<VALUE, rb_data_type_t*>> registry_{};
+    std::set<std::type_index> unverified_{};
   };
 }
 
-#include "TypeRegistry.ipp"
-
 #endif // Rice__TypeRegistry__hpp_

data/rice/detail/TypeRegistry.ipp

@@ -1,8 +1,8 @@
+#include <iostream>
 #include <stdexcept>
+#include <sstream>
+#include <typeindex>
 
-#include "ruby.hpp"
-#include "../traits/rice_traits.hpp"
-#include "Type.hpp"
 
 namespace Rice::detail
 {
@@ -13,6 +13,22 @@ namespace Rice::detail
     registry_[key] = std::pair(klass, rbType);
   }
 
+  /* Special case void. Rice defines classes using the class name not a pointer to the
+     class. Thus define_class<void> is more consistent with Rice then 
+     define_class<void*>. However, the types of void and void* are different so we need
+     this special case.
+     
+     It is possible to support define_class<void*>, but it requires changing the static
+     assertions on Data_Type and Data_Object and thus seems less desirable (and less 
+     consistent as mentioned above).*/
+  template <>
+  inline void TypeRegistry::add<void>(VALUE klass, rb_data_type_t* rbType)
+  {
+    // The special case, use void*
+    std::type_index key(typeid(void*));
+    registry_[key] = std::pair(klass, rbType);
+  }
+
   template <typename T>
   inline void TypeRegistry::remove()
   {
@@ -29,14 +45,45 @@ namespace Rice::detail
   }
 
   template <typename T>
-  inline bool TypeRegistry::verifyDefined()
+  std::pair<VALUE, rb_data_type_t*> TypeRegistry::getType()
   {
-    if (!isDefined<T>())
+    std::type_index key(typeid(T));
+    auto iter = registry_.find(key);
+    if (iter != registry_.end())
     {
-      std::string message = "Type is not defined with Rice: " + detail::typeName(typeid(T));
-      throw std::invalid_argument(message);
+      return iter->second;
+    }
+    else
+    {
+      this->raiseUnverifiedType(typeid(T).name());
+      // Make compiler happy
+      return std::make_pair(Qnil, nullptr);
+    }
+  }
+
+  // Special case void. See comment for add above.
+  template <>
+  inline bool TypeRegistry::isDefined<void>()
+  {
+    std::type_index key(typeid(void*));
+    auto iter = registry_.find(key);
+    return iter != registry_.end();
+  }
+
+  template <typename T>
+  inline bool TypeRegistry::verify()
+  {
+    if (isDefined<T>())
+    {
+      return true;
+    }
+    else
+    {
+      const std::type_info& typeInfo = typeid(T);
+      std::type_index key(typeInfo);
+      this->unverified_.insert(key);
+      return false;
     }
-    return true;
   }
 
   inline std::optional<std::pair<VALUE, rb_data_type_t*>> TypeRegistry::lookup(const std::type_info& typeInfo)
@@ -68,14 +115,60 @@ namespace Rice::detail
     // If not, then we are willing to accept an ancestor class specified by T. This is needed
     // to support Directors. Classes inherited from Directors are never actually registered
     // with Rice - and what we really want it to return the C++ class they inherit from.
-    result = lookup(typeid(T));
+    const std::type_info& typeInfo = typeid(T);
+    result = lookup(typeInfo);
     if (result)
     {
       return result.value();
     }
 
-    // Give up!
-    std::string message = "Type " + typeName(typeid(object)) + " is not registered";
-    throw std::runtime_error(message.c_str());
+    raiseUnverifiedType(detail::typeName(typeInfo));
+    // Make the compiler happy
+    return std::pair<VALUE, rb_data_type_t*>(Qnil, nullptr);
+  }
+
+  inline void TypeRegistry::validateTypes()
+  {
+    // Loop over the unverified types and delete each on that is found in the registry
+    // the registry and raise an exception for the first one that is not
+    for (auto iter = this->unverified_.begin(); iter != this->unverified_.end(); )
+    {
+      const std::type_index& typeIndex = *iter;
+      bool isDefined = this->registry_.find(typeIndex) != this->registry_.end();
+      if (isDefined)
+      {
+        iter = this->unverified_.erase(iter);
+      }
+      else
+      {
+        iter++;
+      }
+    }
+
+    if (this->unverified_.empty())
+    {
+      return;
+    }
+
+    std::stringstream stream;
+    stream << "The following types are not registered with Rice:" << "\n";
+
+    for (const std::type_index& typeIndex : this->unverified_)
+    {
+      stream << "  " << typeName(typeIndex) << "\n";
+    }
+
+    throw std::invalid_argument(stream.str());
+  }
+
+  inline void TypeRegistry::clearUnverifiedTypes()
+  {
+    this->unverified_.clear();
+  }
+
+  inline void TypeRegistry::raiseUnverifiedType(const std::string& typeName)
+  {
+    std::string message = "Type is not registered with Rice: " + typeName;
+    throw std::invalid_argument(message);
   }
 }

data/rice/detail/Wrapper.hpp

@@ -1,8 +1,6 @@
 #ifndef Rice__detail__Wrapper__hpp_
 #define Rice__detail__Wrapper__hpp_
 
-#include "ruby.hpp"
-
 namespace Rice
 {
 namespace detail
@@ -11,11 +9,16 @@ namespace detail
 class Wrapper
 {
 public:
+  Wrapper(bool isOwner = false);
   virtual ~Wrapper() = default;
   virtual void* get() = 0;
 
   void ruby_mark();
   void addKeepAlive(VALUE value);
+  void setOwner(bool value);
+
+protected:
+  bool isOwner_ = false;
 
 private:
   // We use a vector for speed and memory locality versus a set which does
@@ -31,7 +34,7 @@ template <typename T, typename Wrapper_T = void>
 VALUE wrap(VALUE klass, rb_data_type_t* rb_type, T* data, bool isOwner);
 
 template <typename T>
-T* unwrap(VALUE value, rb_data_type_t* rb_type);
+T* unwrap(VALUE value, rb_data_type_t* rb_type, bool takeOwnership);
 
 Wrapper* getWrapper(VALUE value, rb_data_type_t* rb_type);
 
@@ -43,7 +46,5 @@ Wrapper* getWrapper(VALUE value);
 } // namespace detail
 } // namespace Rice
 
-#include "Wrapper.ipp"
-
 #endif // Rice__detail__Wrapper__hpp_
 

data/rice/detail/Wrapper.ipp

@@ -1,8 +1,11 @@
 #include <memory>
-#include "InstanceRegistry.hpp"
 
 namespace Rice::detail
 {
+  inline Wrapper::Wrapper(bool isOwner): isOwner_(isOwner)
+  {
+  }
+
   inline void Wrapper::ruby_mark()
   {
     for (VALUE value : this->keepAlive_)
@@ -16,6 +19,11 @@ namespace Rice::detail
     this->keepAlive_.push_back(value);
   }
 
+  inline void Wrapper::setOwner(bool value)
+  {
+    this->isOwner_ = value;
+  }
+
   template <typename T>
   class WrapperValue : public Wrapper
   {
@@ -64,7 +72,7 @@ namespace Rice::detail
   class WrapperPointer : public Wrapper
   {
   public:
-    WrapperPointer(T* data, bool isOwner) : data_(data), isOwner_(isOwner)
+    WrapperPointer(T* data, bool isOwner) : Wrapper(isOwner), data_(data)
     {
     }
 
@@ -72,9 +80,12 @@ namespace Rice::detail
     {
       Registries::instance.instances.remove(this->get());
 
-      if (this->isOwner_)
+      if constexpr (std::is_destructible_v<T>)
       {
-        delete this->data_;
+        if (this->isOwner_)
+        {
+          delete this->data_;
+        }
       }
     }
 
@@ -85,7 +96,6 @@ namespace Rice::detail
 
   private:
     T* data_ = nullptr;
-    bool isOwner_ = false;
   };
 
   // ---- Helper Functions -------
@@ -111,12 +121,20 @@ namespace Rice::detail
       wrapper = new Wrapper_T(data);
       result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
     }
-    // Is this a pointer and it cannot copied? This is for std::unique_ptr
-    // If ruby is the owner than copy the object
+    // If ruby is the owner than copy the object if possible
     else if (isOwner)
     {
-      wrapper = new WrapperValue<T>(data);
-      result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      if constexpr (std::is_copy_constructible_v<T> || std::is_move_constructible_v<T>)
+      {
+        wrapper = new WrapperValue<T>(data);
+        result = TypedData_Wrap_Struct(klass, rb_type, wrapper);
+      }
+      else
+      {
+        std::string message = "Ruby was directed to take ownership of a C++ object but it does not have an accessible copy or move constructor. Type: " +
+          typeName(typeid(T));
+        throw std::runtime_error(message);
+      }
     }
     // Ruby is not the owner so just wrap the reference
     else
@@ -156,9 +174,11 @@ namespace Rice::detail
   };
 
   template <typename T>
-  inline T* unwrap(VALUE value, rb_data_type_t* rb_type)
+  inline T* unwrap(VALUE value, rb_data_type_t* rb_type, bool takeOwnership)
   {
     Wrapper* wrapper = getWrapper(value, rb_type);
+    if (takeOwnership)
+      wrapper->setOwner(false);
 
     if (wrapper == nullptr)
     {
@@ -179,6 +199,21 @@ namespace Rice::detail
     return wrapper;
   }
 
+  inline Wrapper* getWrapper(VALUE value)
+  {
+    // Turn off spurious warning on g++ 12
+    #if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic push
+    #pragma GCC diagnostic ignored "-Warray-bounds"
+    #endif
+
+    return RTYPEDDATA_P(value) ? static_cast<Wrapper*>(RTYPEDDATA_DATA(value)) : nullptr;
+    
+    #if defined(__GNUC__) || defined(__clang__)
+    #pragma GCC diagnostic pop
+    #endif
+  }
+
   template <typename T>
   inline void replace(VALUE value, rb_data_type_t* rb_type, T* data, bool isOwner)
   {
@@ -195,17 +230,4 @@ namespace Rice::detail
 
     Registries::instance.instances.add(data, value);
   }
-
-  inline Wrapper* getWrapper(VALUE value)
-  {
-    // Turn off spurious warning on g++ 12
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
-#endif
-    return RTYPEDDATA_P(value) ? static_cast<Wrapper*>(RTYPEDDATA_DATA(value)) : nullptr;
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#endif
-  }
 } // namespace

data/rice/detail/cpp_protect.hpp

@@ -14,8 +14,6 @@
   #error "no filesystem include found :'("
 #endif
 
-#include "Jump_Tag.hpp"
-#include "../Exception_defn.hpp"
 
 namespace Rice::detail
 {
@@ -30,13 +28,14 @@ namespace Rice::detail
     {
       try
       {
-        detail::Registries::instance.handlers.handler()->handle();
+        std::function<void()> handler = detail::Registries::instance.handlers.handler();
+        handler();
       }
       catch (::Rice::Exception const& ex)
       {
         rb_exc_raise(ex.value());
       }
-      catch (::Rice::Jump_Tag const& ex)
+      catch (::Rice::JumpException const& ex)
       {
         rb_jump_tag(ex.tag);
       }
@@ -61,11 +60,11 @@ namespace Rice::detail
       }
       catch (std::length_error const& ex)
       {
-        rb_exc_raise(rb_exc_new2(rb_eRuntimeError, ex.what()));
+        rb_exc_raise(rb_exc_new2(rb_eIndexError, ex.what()));
       }
       catch (std::out_of_range const& ex)
       {
-        rb_exc_raise(rb_exc_new2(rb_eRangeError, ex.what()));
+        rb_exc_raise(rb_exc_new2(rb_eIndexError, ex.what()));
       }
       catch (std::overflow_error const& ex)
       {

data/rice/detail/default_allocation_func.ipp

@@ -1,5 +1,3 @@
-#include "../Data_Object.hpp"
-
 namespace Rice::detail
 {
   template<typename T>

data/rice/detail/from_ruby.hpp

@@ -1,8 +1,42 @@
 #ifndef Rice__detail__from_ruby__hpp_
 #define Rice__detail__from_ruby__hpp_
 
-#include "from_ruby_defn.hpp"
-#include "from_ruby.ipp"
+namespace Rice::detail
+{
+  //! Convert a Ruby object to C++.
+  /*! If the Ruby object can be converted to an immediate value, returns a
+   *  copy of the Ruby object.  If the Ruby object is holding a C++
+   *  object and the type specified is a pointer to that type, returns a
+   *  pointer to that object.
+   *
+   *  Conversions from ruby to a pointer type are automatically generated
+   *  when a type is bound using Data_Type.  If no conversion exists an
+   *  exception is thrown.
+   *
+   *  \param T the C++ type to which to convert.
+   *  \param x the Ruby object to convert.
+   *  \return a C++ representation of the Ruby object.
+   *
+   *  Example:
+   *  \code
+   *    Object x = INT2NUM(42);
+   *    std::cout << From_Ruby<int>::convert(x);
+   *
+   *    Data_Object<Foo> foo(new Foo);
+   *    std::cout << *From_Ruby<Foo *>(foo) << std::endl;
+   *  \endcode
+   */
 
-#endif // Rice__detail__from_ruby__hpp_
+  template <typename T>
+  class From_Ruby;
 
+  enum class Convertible: uint8_t
+  {
+      None =   0b000,
+      Narrowable = 0b001,
+      Cast =   0b011,
+      Exact =  0b111,
+  };
+}
+
+#endif // Rice__detail__From_Ruby2__hpp_