rice 4.9.1 → 4.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6482695048d122782acef1d7ee310c47c85cff57eb39c8740db46013a4af0e87
-  data.tar.gz: a4b3c772ac9d5baff75ad80dbc404dde8a3fc67c821836203dfdcef948877091
+  metadata.gz: bfec1a3dda6cae1e2a2e4ead3b3d6d856487a6d214ec89a2aa7c32cab9debf24
+  data.tar.gz: 2bb3f7480a0ffcaee70ccc15ea7410c764a67b0b6d229300264570b1e58f8b59
 SHA512:
-  metadata.gz: 553618d580f7734d23a0c0278636fe725f48cacd68572fa9d6cee828fed68b2af84cda1fecdad4bb65633ada077bf4b34a703e2bd25173bd4f3ae0de91c54c26
-  data.tar.gz: '0368ac5a1d1d957ab8a94dcec8a25c6e5cc539930848db9f78077c6006b86a6d81299af839ab1daed52fab9ce743496cebcff6e3698483961c0fc6cc2bef82b4'
+  metadata.gz: a6e7edb4a1332104c7e2a0bf616919ceef92fb4d87bbca650898c1a8e705df20f54a02a78372a1a9b66b499c6d1e4a47ed75e8a2e20ebbe57cbfa0c6cd9a953d
+  data.tar.gz: 9ea2f5c76ccbb2d4a8e62ead7a796ad700ef77d07cf0c2fbc59b8c7626068225900009a861a654b95dd8476c80ba1e041c46b43f2969318479a28b12f7dc8678

data/CHANGELOG.md

@@ -1,5 +1,54 @@
 # Changelog
 
+## 4.10.0 (2026-02-07)
+
+Enhancements:
+* Ruby 4.0 support
+* Support incomplete types (PIMPL/opaque handle patterns). Rice now uses `typeid(T*)` for forward-declared types that are never fully defined.
+* Support `noexcept` functions, static members, and static member functions
+* Support for `Buffer<void*>` and `Pointer<void*>`
+* Add `std::function`. Ruby procs, lambdas, and blocks can be wrapped in `std::function` objects and passed to C++ methods. C++ functions returning `std::function` are automatically wrapped.
+* Add `std::ostream`, `std::ostringstream`, and `std::ofstream`. Ruby can write to C++ streams and pass them to C++ functions. Standard streams are exposed as `Std::COUT` and `Std::CERR`.
+* Support verifying arrays of non-fundamental types (e.g., `MyClass[2]`)
+* Delegate method calls for smart pointers to their wrapped objects via method_missing?
+
+Internal:
+* Refactor type handling by merging `TypeMapper` into `TypeDetail` and simplifying class hierarchy
+* Greatly simplify define_attr
+
+Incompatible Changes:
+* `Address_Registration_Guard` has been replaced by `Pin`. If you are using `Address_Registration_Guard`
+  to protect Ruby VALUEs from garbage collection, update your code to use `Pin` instead:
+
+  Before:
+  ```cpp
+  VALUE value_;
+  Address_Registration_Guard guard_;
+  MyClass() : value_(rb_str_new2("test")), guard_(&value_) {}
+  ```
+
+  After:
+  ```cpp
+  Pin pin_;
+  MyClass() : pin_(rb_str_new2("test")) {}
+  VALUE getValue() { return pin_.get(); }
+  ```
+
+  `Pin` is self-contained and provides `get()` and `set()` methods to access the pinned VALUE.
+
+* Rice converts Ruby blocks to procs. Thus if you have a method that expects a block, you must add
+  a VALUE parameter and tell Rice it is a value. For example:
+
+  ```cpp
+  define_method("my_method", [](VALUE self, VALUE proc)
+  {
+  }, Arg("proc").setValue())
+  ```
+
+  Think of this as similar to how you would capture a block in Ruby using the &block syntax.
+
+* The `Data_Type<T>::define()` method has been removed. See the [Class Templates](bindings/class_templates.md) documentation for the recommended approach.
+
 ## 4.9.1 (2026-01-04)
 This release focuses on improving memory management for STL containers and attribute setters.
 

data/FindRuby.cmake

@@ -12,12 +12,14 @@ Finds Ruby installation and the locations of its include files and libraries:
   find_package(Ruby [<version>] [COMPONENTS <components>...] [...])
 
 Ruby is a general-purpose programming language.  This module supports Ruby
-1.8 through 3.4.  Virtual environments, such as RVM or RBENV, are also
+2.0 through 4.0.  Virtual environments, such as RVM or RBENV, are also
 supported.
 
 Components
 ^^^^^^^^^^
 
+.. versionadded:: 4.3
+
 This module supports the following components:
 
 ``Interpreter``
@@ -32,6 +34,8 @@ are searched for.
 Imported Targets
 ^^^^^^^^^^^^^^^^
 
+.. versionadded:: 4.3
+
 This module defines the following :prop_tgt:`IMPORTED` targets:
 
 ``Ruby::Interpreter``
@@ -171,14 +175,16 @@ endif()
 set(_Ruby_POSSIBLE_EXECUTABLE_NAMES ruby)
 
 # If the user has not specified a Ruby version, create a list of Ruby versions
-# to check going from 1.8 to 4.0
+# to search (newest to oldest). Based on https://www.ruby-lang.org/en/downloads/releases/
 if (NOT Ruby_FIND_VERSION_EXACT)
-  foreach (_ruby_version RANGE 40 18 -1)
+  set(_Ruby_SUPPORTED_VERSIONS 40 34 33 32)
+  set(_Ruby_UNSUPPORTED_VERSIONS 31 30 27 26 25 24 23 22 21 20)
+  foreach (_ruby_version IN LISTS _Ruby_SUPPORTED_VERSIONS _Ruby_UNSUPPORTED_VERSIONS)
     string(SUBSTRING "${_ruby_version}" 0 1 _ruby_major_version)
     string(SUBSTRING "${_ruby_version}" 1 1 _ruby_minor_version)
     # Append both rubyX.Y and rubyXY (eg: ruby3.4 ruby34)
-    list(APPEND _Ruby_POSSIBLE_EXECUTABLE_NAMES 
-         ruby${_ruby_major_version}.${_ruby_minor_version} 
+    list(APPEND _Ruby_POSSIBLE_EXECUTABLE_NAMES
+         ruby${_ruby_major_version}.${_ruby_minor_version}
          ruby${_ruby_major_version}${_ruby_minor_version})
   endforeach ()
 endif ()
@@ -231,14 +237,6 @@ function(_RUBY_CONFIG_VAR RBVAR OUTVAR)
                   OUTPUT_VARIABLE _Ruby_OUTPUT
                   ERROR_QUIET)
 
-  # Config was deprecated in Ruby 1.9 and then removed in Ruby 2 - so this is for ancient code
-  if (_Ruby_SUCCESS OR _Ruby_OUTPUT STREQUAL "")
-    execute_process(COMMAND "${Ruby_EXECUTABLE}" -r rbconfig -e "print Config::CONFIG['${RBVAR}']"
-                    RESULT_VARIABLE _Ruby_SUCCESS
-                    OUTPUT_VARIABLE _Ruby_OUTPUT
-                    ERROR_QUIET)
-  endif ()
-
   set(${OUTVAR} "${_Ruby_OUTPUT}" PARENT_SCOPE)
 endfunction()
 
@@ -315,7 +313,7 @@ function(_RUBY_CHECK_BREW)
     return()
   endif ()
 
-  MESSAGE(DEBUG "Found brew at: ${_BREW_EXECUTABLE}")
+  message(DEBUG "Found brew at: ${_BREW_EXECUTABLE}")
 
   # Query Homebrew for the prefix of the 'ruby' formula.
   # If Ruby is not installed via Homebrew, this will fail.
@@ -326,7 +324,7 @@ function(_RUBY_CHECK_BREW)
           ERROR_QUIET
           OUTPUT_STRIP_TRAILING_WHITESPACE
   )
-  MESSAGE(DEBUG "Ruby BREW is: ${_Ruby_BREW_DIR}")
+  message(DEBUG "Ruby BREW is: ${_Ruby_BREW_DIR}")
 
   if (NOT _Ruby_BREW_RESULT EQUAL 0 OR _Ruby_BREW_DIR STREQUAL "")
     # No 'ruby' formula installed in Homebrew
@@ -427,7 +425,7 @@ if (Ruby_EXECUTABLE AND NOT Ruby_EXECUTABLE STREQUAL "${_Ruby_EXECUTABLE_LAST_QU
   set(Ruby_ARCHHDR_DIR ${Ruby_ARCHHDR_DIR} CACHE INTERNAL "The Ruby arch header dir (2.0+)" FORCE)
   set(_Ruby_POSSIBLE_LIB_DIR ${_Ruby_POSSIBLE_LIB_DIR} CACHE INTERNAL "The Ruby lib dir" FORCE)
   set(Ruby_RUBY_LIB_DIR ${Ruby_RUBY_LIB_DIR} CACHE INTERNAL "The Ruby ruby-lib dir" FORCE)
-  set(_Ruby_SO_NAME ${_Ruby_SO_NAME} CACHE PATH "The Ruby shared library name" FORCE)
+  set(_Ruby_SO_NAME ${_Ruby_SO_NAME} CACHE STRING "The Ruby shared library name" FORCE)
   set(_Ruby_DLEXT ${_Ruby_DLEXT} CACHE STRING "Ruby extensions extension" FORCE)
   set(Ruby_SITEARCH_DIR ${Ruby_SITEARCH_DIR} CACHE INTERNAL "The Ruby site arch dir" FORCE)
   set(Ruby_SITELIB_DIR ${Ruby_SITELIB_DIR} CACHE INTERNAL "The Ruby site lib dir" FORCE)
@@ -455,30 +453,6 @@ if (Ruby_EXECUTABLE AND NOT Ruby_EXECUTABLE STREQUAL "${_Ruby_EXECUTABLE_LAST_QU
   )
 endif ()
 
-# In case Ruby_EXECUTABLE could not be executed (e.g. cross compiling)
-# try to detect which version we found. This is not too good.
-if (Ruby_EXECUTABLE AND NOT Ruby_VERSION_MAJOR)
-  # by default assume 1.8.0
-  set(Ruby_VERSION_MAJOR 1)
-  set(Ruby_VERSION_MINOR 8)
-  set(Ruby_VERSION_PATCH 0)
-  # check whether we found 1.9.x
-  if (${Ruby_EXECUTABLE} MATCHES "ruby1\\.?9")
-    set(Ruby_VERSION_MAJOR 1)
-    set(Ruby_VERSION_MINOR 9)
-  endif ()
-  # check whether we found 2.[0-7].x
-  if (${Ruby_EXECUTABLE} MATCHES "ruby2")
-    set(Ruby_VERSION_MAJOR 2)
-    string(REGEX REPLACE ${Ruby_EXECUTABLE} "ruby2\\.?([0-7])" "\\1" Ruby_VERSION_MINOR)
-  endif ()
-  # check whether we found 3.[0-1].x
-  if (${Ruby_EXECUTABLE} MATCHES "ruby3")
-    set(Ruby_VERSION_MAJOR 3)
-    string(REGEX REPLACE ${Ruby_EXECUTABLE} "ruby3\\.?([0-4])" "\\1" Ruby_VERSION_MINOR)
-  endif ()
-endif ()
-
 if (Ruby_VERSION_MAJOR)
   set(Ruby_VERSION "${Ruby_VERSION_MAJOR}.${Ruby_VERSION_MINOR}.${Ruby_VERSION_PATCH}")
   set(_Ruby_VERSION_NODOT "${Ruby_VERSION_MAJOR}${Ruby_VERSION_MINOR}${Ruby_VERSION_PATCH}")
@@ -487,9 +461,6 @@ if (Ruby_VERSION_MAJOR)
   set(_Ruby_VERSION_SHORT_NODOT "${Ruby_VERSION_MAJOR}${Ruby_VERSION_MINOR}")
 endif ()
 
-# FIXME: Currently we require both the interpreter and development components to be found
-# in order to use either.  See issue #20474.
-
 # Save CMAKE_FIND_FRAMEWORK
 set(_Ruby_CMAKE_FIND_FRAMEWORK_ORIGINAL ${CMAKE_FIND_FRAMEWORK})
 
@@ -516,7 +487,7 @@ set(CMAKE_FIND_FRAMEWORK ${_Ruby_CMAKE_FIND_FRAMEWORK_ORIGINAL})
 message(DEBUG "--------FindRuby.cmake debug------------")
 message(DEBUG "_Ruby_POSSIBLE_EXECUTABLE_NAMES: ${_Ruby_POSSIBLE_EXECUTABLE_NAMES}")
 message(DEBUG "_Ruby_POSSIBLE_LIB_DIR: ${_Ruby_POSSIBLE_LIB_DIR}")
-message(DEBUG "Ruby_LIBRUBY_SO: ${_Ruby_SO_NAME}")
+message(DEBUG "_Ruby_SO_NAME: ${_Ruby_SO_NAME}")
 message(DEBUG "_Ruby_DLEXT: ${_Ruby_DLEXT}")
 message(DEBUG "Ruby_FIND_VIRTUALENV=${Ruby_FIND_VIRTUALENV}")
 message(DEBUG "Ruby_ENV: ${Ruby_ENV}")
@@ -558,7 +529,12 @@ foreach (component IN LISTS Ruby_FIND_COMPONENTS)
 endforeach ()
 
 # Set component found flags
-set(Ruby_Interpreter_FOUND ${Ruby_EXECUTABLE})
+if (Ruby_EXECUTABLE)
+  set(Ruby_Interpreter_FOUND TRUE)
+else ()
+  set(Ruby_Interpreter_FOUND FALSE)
+endif ()
+
 if (Ruby_INCLUDE_DIR AND Ruby_CONFIG_INCLUDE_DIR AND (Ruby_LIBRARY OR NOT WIN32))
   set(Ruby_Development_FOUND TRUE)
 else ()