rice 4.5.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 92005bd0a63d8dbc92dead037df25df0e79ed3fe58dcd4f6f60179b5790160f4
-  data.tar.gz: 29bf823a8e24fc33775481f9ec0cbbf727e8a81ab6879201e852378c17bbb896
+  metadata.gz: 0415303e9003a2751cb4fcf3488f068359a805ed3a3df83010aa6ca032c504c9
+  data.tar.gz: 895d2ce47c9daa951362c7854e3bf228a3d88c3efd04a0d79f0a8acc898c6cec
 SHA512:
-  metadata.gz: 37095af3336e4d2b15833df29eea5eef7d845fc02677f21e442c4ab9493c3bea9498afe559cdc3d2702bfa5300405f903a426c878e6a473ca7021dbe0c9e19e9
-  data.tar.gz: d38cea1597a125fce293b522973e237fee46042248345e65871a839ce20620b0b1ffb931002ef0c51557cea1783e242052f3b395be1c765296d8b960df5f559b
+  metadata.gz: 3ee378cf6732ec73edd4ea33c47f58c87a996b380b019edeb3b2f279e4576924de79529ddfc086898e6d3d0f713859d8363ace294f3a621848e1d401a477b10d
+  data.tar.gz: 3d9834d152b559902cd378d4d00de32efbffc06ab8e5104bd895ae4f96848de2e0b42536b212cb83e154d1eb503cb9eefc2a4dad0b27a510b9fa1da5d40a9b9a

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+## 4.6.0 (2025-06-09)
+Rice 4.6 is a major release that adds significant new functionality based on wrapping the OpenCV library, including:
+
+* Add a new Buffer class to provide Ruby API support for pointers sent to or returned by C++
+* Support C style out parameters
+* Support C style arrays
+* Rewrite keyword arguments
+* Rewrite default value handling allowing the removal of a lot of boilerplate
+* Add support for std::multimap
+* Add support for std::set
+* Add support for std::tuple
+* Add support for smart pointers (shared_ptr, unique_ptr) to fundamental types (void, int, etc)
+* Improve std::variant support
+* Update is_convertible documentation
+* Fix missing version.rb file in gemspec
+* Add C++ preprocessor defines for Rice version
+* Include Rice::VERSION in published gem
+* Moved auto-generated C++ STL classes (std::vector, std::map, etc.) from the module Rice::Std module to Std module
+* Make Rice const aware to improve overload method support
+* Improve error messages when Rice cannot determine what overloaded method to call
+* Improve handling of unbound Data_Type instances to avoid crashes when initializing global static variables of type Data_Type<T>
+* Make Enums more useful by adding coerce method to enable stringing together bitwise operators - for example Season::Winter | Season::Spring | Season::Summer.
+
 ## 4.5 (2025-02-09)
 Rice 4.5 is a major release that adds significant new functionality, including:
 

data/CMakeLists.txt

@@ -0,0 +1,31 @@
+cmake_minimum_required (VERSION 3.26)
+
+project(Rice)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# For older versions of CMake can use include("./FindRuby.cmake")
+find_package("Ruby")
+
+if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
+    set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<IF:$<AND:$<C_COMPILER_ID:MSVC>,$<CXX_COMPILER_ID:MSVC>>,$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>,$<$<CONFIG:Debug,RelWithDebInfo>:ProgramDatabase>>")
+    add_compile_definitions(-D_CRT_SECURE_NO_DEPRECATE -D_CRT_NONSTDC_NO_DEPRECATE)
+    add_compile_options(/bigobj /utf-8)
+    # The default of /EHsc crashes Ruby when calling longjmp with optimizations on (/O2)
+    string(REGEX REPLACE "/EHsc" "/EHs" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    add_compile_definitions(-D_CRT_SECURE_NO_WARNINGS)
+elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    add_compile_options(-ftemplate-backtrace-limit=0)
+    # https://github.com/doxygen/doxygen/issues/9269#issuecomment-1094975328
+    #add_compile_options(unittest PRIVATE -Wa,-mbig-obj)
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Og")
+endif ()
+
+# Include sub-projects.
+add_subdirectory ("test")
+add_subdirectory ("sample/callbacks")
+add_subdirectory ("sample/enum")
+add_subdirectory ("sample/inheritance")
+add_subdirectory ("sample/map")

data/CMakePresets.json

@@ -0,0 +1,75 @@
+{
+    "version": 3,
+    "configurePresets": [
+        {
+            "name": "windows-base",
+            "hidden": true,
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "installDir": "${sourceDir}/out/install/${presetName}",
+            "cacheVariables": {
+                "CMAKE_C_COMPILER": "cl.exe",
+                "CMAKE_CXX_COMPILER": "cl.exe"
+            },
+            "condition": {
+                "type": "equals",
+                "lhs": "${hostSystemName}",
+                "rhs": "Windows"
+            }
+        },
+        {
+            "name": "x64-debug",
+            "displayName": "MSVC++ Debug",
+            "inherits": "windows-base",
+            "architecture": {
+                "value": "x64",
+                "strategy": "external"
+            },
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug"
+            }
+        },
+      {
+        "name": "x64-release",
+        "displayName": "x64 Release",
+        "inherits": "x64-debug",
+        "cacheVariables": {
+          "CMAKE_BUILD_TYPE": "Release"
+        }
+      },
+      {
+        "name": "linux-default",
+        "displayName": "Linux Debug",
+        "description": "Sets Ninja generator, compilers, build and install directory, debug build type",
+        "generator": "Ninja",
+        "binaryDir": "${sourceDir}/out/build/${presetName}",
+        "cacheVariables": {
+          "CMAKE_BUILD_TYPE": "Debug",
+          "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
+        },
+        "vendor": {
+          "microsoft.com/VisualStudioSettings/CMake/1.0": {
+            "hostOS": [ "Linux" ]
+          },
+          "microsoft.com/VisualStudioRemoteSettings/CMake/1.0": {
+            "sourceDir": "$env{HOME}/.vs/$ms{projectDirName}"
+          }
+        }
+      },
+      {
+        "name": "x64_debug_clang",
+        "displayName": "Clang Debug",
+        "description": "Target Windows (64-bit) with the Visual Studio development environment. (Debug)",
+        "inherits": "windows-base",
+        "architecture": {
+          "value": "x64",
+          "strategy": "external"
+        },
+        "cacheVariables": {
+          "CMAKE_BUILD_TYPE": "Debug",
+          "CMAKE_C_COMPILER": "clang.exe",
+          "CMAKE_CXX_COMPILER": "clang.exe"
+        }
+      }
+    ]
+}

data/COPYING

@@ -1,5 +1,6 @@
-Copyright (C) 2020 Jason Roelofs <jasongroelofs@gmail.com>
-  Paul Brannan <curlypaul924@gmail.com>,
+Copyright (C) 2025 Jason Roelofs <jasongroelofs@gmail.com>
+                   Paul Brannan <curlypaul924@gmail.com>,
+                   Charlie Savage
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

data/FindRuby.cmake

@@ -0,0 +1,437 @@
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file LICENSE.rst or https://cmake.org/licensing for details.
+
+#[=======================================================================[.rst:
+FindRuby
+--------
+
+This module determines if Ruby is installed and finds the locations of its
+include files and libraries. Ruby 1.8 through 3.4 are supported.
+
+The minimum required version of Ruby can be specified using the
+standard syntax, e.g.
+
+.. code-block:: cmake
+
+  find_package(Ruby 3.2.6 EXACT REQUIRED)
+  # OR
+  find_package(Ruby 3.2)
+
+Virtual environments, such as RVM or RBENV, are supported.
+
+Result Variables
+^^^^^^^^^^^^^^^^
+
+This module will set the following variables in your project:
+
+``Ruby_FOUND``
+  set to true if ruby was found successfully
+``Ruby_EXECUTABLE``
+  full path to the ruby binary
+``Ruby_INCLUDE_DIRS``
+  include dirs to be used when using the ruby library
+``Ruby_LIBRARIES``
+  .. versionadded:: 3.18
+    libraries needed to use ruby from C.
+``Ruby_VERSION``
+  the version of ruby which was found, e.g. "3.2.6"
+``Ruby_VERSION_MAJOR``
+  Ruby major version.
+``Ruby_VERSION_MINOR``
+  Ruby minor version.
+``Ruby_VERSION_PATCH``
+  Ruby patch version.
+
+.. versionchanged:: 3.18
+  Previous versions of CMake used the ``RUBY_`` prefix for all variables.
+
+.. deprecated:: 4.0
+  The following variables are deprecated.  See policy :policy:`CMP0185`.
+
+  ``RUBY_EXECUTABLE``
+    same as ``Ruby_EXECUTABLE``.
+  ``RUBY_INCLUDE_DIRS``
+    same as ``Ruby_INCLUDE_DIRS``.
+  ``RUBY_INCLUDE_PATH``
+    same as ``Ruby_INCLUDE_DIRS``.
+  ``RUBY_LIBRARY``
+    same as ``Ruby_LIBRARY``.
+  ``RUBY_VERSION``
+    same as ``Ruby_VERSION``.
+  ``RUBY_FOUND``
+    same as ``Ruby_FOUND``.
+
+Hints
+^^^^^
+
+``Ruby_FIND_VIRTUALENV``
+  .. versionadded:: 3.18
+
+  This variable defines the handling of virtual environments.
+  It can be left empty or be set to one of the following values:
+
+  * ``FIRST``: Virtual Ruby environments are searched for first,
+               then the system Ruby installation.
+               This is the default.
+  * ``ONLY``: Only virtual environments are searched
+  * ``STANDARD``: Only the system Ruby installation is searched.
+
+  Virtual environments may be provided by:
+
+  ``rvm``
+    Requires that the ``MY_RUBY_HOME`` environment environment is defined.
+
+  ``rbenv``
+    Requires that ``rbenv`` is installed in ``~/.rbenv/bin``
+    or that the ``RBENV_ROOT`` environment variable is defined.
+#]=======================================================================]
+
+# Uncomment the following line to get debug output for this file
+# set(CMAKE_MESSAGE_LOG_LEVEL DEBUG)
+
+# Determine the list of possible names of the ruby executable depending
+# on which version of ruby is required
+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 3.4
+if (NOT Ruby_FIND_VERSION_EXACT)
+  foreach (_ruby_version RANGE 34 18 -1)
+    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} ruby${_ruby_major_version}${_ruby_minor_version})
+  endforeach ()
+endif ()
+
+# Virtual environment handling
+if (DEFINED Ruby_FIND_VIRTUALENV AND NOT Ruby_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY|STANDARD)$")
+  message(AUTHOR_WARNING "FindRuby: ${Ruby_FIND_VIRTUALENV}: invalid value for 'Ruby_FIND_VIRTUALENV'. 'FIRST', 'ONLY' or 'STANDARD' expected. 'FIRST' will be used instead.")
+  set(Ruby_FIND_VIRTUALENV "FIRST")
+elseif (NOT DEFINED Ruby_FIND_VIRTUALENV)
+  # Default is to search for virtual environments first
+  set(Ruby_FIND_VIRTUALENV "FIRST")
+endif ()
+
+# Validate the found Ruby interpreter to make sure that it is
+# callable and that its version matches the requested version
+function(_RUBY_VALIDATE_INTERPRETER result_var path)
+  # Get the interpreter version
+  execute_process(COMMAND "${path}" -e "puts RUBY_VERSION"
+                  RESULT_VARIABLE result
+                  OUTPUT_VARIABLE version
+                  ERROR_QUIET
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  if (NOT result EQUAL 0)
+    set(_Ruby_Interpreter_REASON_FAILURE "Cannot use the interpreter \"${path}\"")
+    set(${result_var} FALSE PARENT_SCOPE)
+    return()
+  endif ()
+
+  if (Ruby_FIND_VERSION)
+    if (Ruby_FIND_VERSION_EXACT AND NOT version VERSION_EQUAL Ruby_FIND_VERSION)
+      message(DEBUG "Incorrect Ruby found. Requested: ${Ruby_FIND_VERSION}. Found: ${version}. Path: \"${path}\"")
+      set(${result_var} FALSE PARENT_SCOPE)
+      return()
+    elseif (version VERSION_LESS Ruby_FIND_VERSION)
+      message(DEBUG "Ruby version is too old. Minimum: ${Ruby_FIND_VERSION}. Found: ${version}. Path: \"${path}\"")
+      set(${result_var} FALSE PARENT_SCOPE)
+      return()
+    endif ()
+  endif ()
+
+  # Found valid Ruby interpreter!
+  set(${result_var} TRUE PARENT_SCOPE)
+endfunction()
+
+# Query Ruby RBConfig module for the specified variable (_RUBY_CONFIG_VAR)
+function(_RUBY_CONFIG_VAR RBVAR OUTVAR)
+  execute_process(COMMAND ${Ruby_EXECUTABLE} -r rbconfig -e "print RbConfig::CONFIG['${RBVAR}']"
+                  RESULT_VARIABLE _Ruby_SUCCESS
+                  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()
+
+# Check for RVM virtual environments
+function(_RUBY_CHECK_RVM)
+  if (NOT DEFINED ENV{MY_RUBY_HOME})
+    return()
+  endif ()
+
+  find_program(Ruby_EXECUTABLE
+               NAMES ${_Ruby_POSSIBLE_EXECUTABLE_NAMES}
+               NAMES_PER_DIR
+               PATHS ENV MY_RUBY_HOME
+               PATH_SUFFIXES bin Scripts
+               VALIDATOR _RUBY_VALIDATE_INTERPRETER
+               NO_CMAKE_PATH
+               NO_CMAKE_ENVIRONMENT_PATH
+               NO_SYSTEM_ENVIRONMENT_PATH
+               NO_CMAKE_SYSTEM_PATH)
+
+  if (Ruby_EXECUTABLE)
+    set(Ruby_ENV "RVM" CACHE INTERNAL "Ruby environment")
+  endif ()
+endfunction()
+
+# Check for RBENV virtual environments
+function(_RUBY_CHECK_RBENV)
+  find_program(Ruby_RBENV_EXECUTABLE
+               NAMES rbenv
+               NAMES_PER_DIR
+               PATHS "$ENV{HOME}/.rbenv/bin/rbenv" ENV RBENV_ROOT
+               PATH_SUFFIXES bin Scripts
+               NO_CACHE
+               NO_CMAKE_PATH
+               NO_CMAKE_ENVIRONMENT_PATH
+               NO_CMAKE_SYSTEM_PATH)
+
+  execute_process(COMMAND "${Ruby_RBENV_EXECUTABLE}" "which" "ruby"
+                  RESULT_VARIABLE result
+                  OUTPUT_VARIABLE ruby_exe
+                  ERROR_QUIET
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if (NOT result EQUAL 0)
+    return()
+  endif ()
+  cmake_path(GET ruby_exe PARENT_PATH ruby_dir)
+
+  find_program(Ruby_EXECUTABLE
+               NAMES ruby
+               NAMES_PER_DIR
+               PATHS ${ruby_dir}
+               VALIDATOR _RUBY_VALIDATE_INTERPRETER
+               NO_DEFAULT_PATH)
+
+  if (Ruby_EXECUTABLE)
+    set(Ruby_ENV "RBENV" CACHE INTERNAL "Ruby environment")
+  endif ()
+endfunction()
+
+# Check system installed Ruby
+function(_RUBY_CHECK_SYSTEM)
+  find_program(Ruby_EXECUTABLE
+               NAMES ${_Ruby_POSSIBLE_EXECUTABLE_NAMES}
+               NAMES_PER_DIR
+               VALIDATOR _RUBY_VALIDATE_INTERPRETER)
+
+  if (Ruby_EXECUTABLE)
+    set(Ruby_ENV "Standard" CACHE INTERNAL "Ruby environment")
+  endif ()
+endfunction()
+
+# Find Ruby
+if (NOT Ruby_EXECUTABLE AND Ruby_FIND_VIRTUALENV MATCHES "^(FIRST|ONLY)$")
+  # First check for RVM virtual environments
+  _RUBY_CHECK_RVM()
+  # Second check for RBENV virtual environments
+  if (NOT Ruby_EXECUTABLE)
+    _RUBY_CHECK_RBENV()
+  endif ()
+endif ()
+
+# Fallback to system installed Ruby
+if (NOT Ruby_EXECUTABLE AND NOT Ruby_FIND_VIRTUALENV STREQUAL "ONLY")
+  _RUBY_CHECK_SYSTEM()
+endif ()
+
+# We found a new Ruby or a Ruby that is different than the last one we found.
+# So reload a number of variables by querying the Ruby interpreter.
+if (Ruby_EXECUTABLE AND NOT Ruby_EXECUTABLE STREQUAL "${_Ruby_EXECUTABLE_LAST_QUERIED}")
+  # query the ruby version
+  _RUBY_CONFIG_VAR("MAJOR" Ruby_VERSION_MAJOR)
+  _RUBY_CONFIG_VAR("MINOR" Ruby_VERSION_MINOR)
+  _RUBY_CONFIG_VAR("TEENY" Ruby_VERSION_PATCH)
+
+  # query the different directories
+  _RUBY_CONFIG_VAR("archdir" Ruby_ARCH_DIR)
+  _RUBY_CONFIG_VAR("arch" Ruby_ARCH)
+  _RUBY_CONFIG_VAR("rubyhdrdir" Ruby_HDR_DIR)
+  _RUBY_CONFIG_VAR("rubyarchhdrdir" Ruby_ARCHHDR_DIR)
+  _RUBY_CONFIG_VAR("libdir" _Ruby_POSSIBLE_LIB_DIR)
+  _RUBY_CONFIG_VAR("rubylibdir" Ruby_RUBY_LIB_DIR)
+
+  # site_ruby
+  _RUBY_CONFIG_VAR("sitearchdir" Ruby_SITEARCH_DIR)
+  _RUBY_CONFIG_VAR("sitelibdir" Ruby_SITELIB_DIR)
+
+  # vendor_ruby available ?
+  execute_process(COMMAND ${Ruby_EXECUTABLE} -r vendor-specific -e "print 'true'"
+                  OUTPUT_VARIABLE Ruby_HAS_VENDOR_RUBY ERROR_QUIET)
+
+  if (Ruby_HAS_VENDOR_RUBY)
+    _RUBY_CONFIG_VAR("vendorlibdir" Ruby_VENDORLIB_DIR)
+    _RUBY_CONFIG_VAR("vendorarchdir" Ruby_VENDORARCH_DIR)
+  endif ()
+
+  # save the results in the cache so we don't have to run ruby the next time again
+  set(_Ruby_EXECUTABLE_LAST_QUERIED "${Ruby_EXECUTABLE}" CACHE INTERNAL "The ruby executable last queried for version and path info")
+  set(Ruby_VERSION_MAJOR ${Ruby_VERSION_MAJOR} CACHE PATH "The Ruby major version" FORCE)
+  set(Ruby_VERSION_MINOR ${Ruby_VERSION_MINOR} CACHE PATH "The Ruby minor version" FORCE)
+  set(Ruby_VERSION_PATCH ${Ruby_VERSION_PATCH} CACHE PATH "The Ruby patch version" FORCE)
+  set(Ruby_ARCH_DIR ${Ruby_ARCH_DIR} CACHE PATH "The Ruby arch dir" FORCE)
+  set(Ruby_HDR_DIR ${Ruby_HDR_DIR} CACHE PATH "The Ruby header dir (1.9+)" FORCE)
+  set(Ruby_ARCHHDR_DIR ${Ruby_ARCHHDR_DIR} CACHE PATH "The Ruby arch header dir (2.0+)" FORCE)
+  set(_Ruby_POSSIBLE_LIB_DIR ${_Ruby_POSSIBLE_LIB_DIR} CACHE PATH "The Ruby lib dir" FORCE)
+  set(Ruby_RUBY_LIB_DIR ${Ruby_RUBY_LIB_DIR} CACHE PATH "The Ruby ruby-lib dir" FORCE)
+  set(Ruby_SITEARCH_DIR ${Ruby_SITEARCH_DIR} CACHE PATH "The Ruby site arch dir" FORCE)
+  set(Ruby_SITELIB_DIR ${Ruby_SITELIB_DIR} CACHE PATH "The Ruby site lib dir" FORCE)
+  set(Ruby_HAS_VENDOR_RUBY ${Ruby_HAS_VENDOR_RUBY} CACHE BOOL "Vendor Ruby is available" FORCE)
+  set(Ruby_VENDORARCH_DIR ${Ruby_VENDORARCH_DIR} CACHE PATH "The Ruby vendor arch dir" FORCE)
+  set(Ruby_VENDORLIB_DIR ${Ruby_VENDORLIB_DIR} CACHE PATH "The Ruby vendor lib dir" FORCE)
+
+  mark_as_advanced(
+      Ruby_ARCH_DIR
+      Ruby_ARCH
+      Ruby_HDR_DIR
+      Ruby_ARCHHDR_DIR
+      _Ruby_POSSIBLE_LIB_DIR
+      Ruby_RUBY_LIB_DIR
+      Ruby_SITEARCH_DIR
+      Ruby_SITELIB_DIR
+      Ruby_HAS_VENDOR_RUBY
+      Ruby_VENDORARCH_DIR
+      Ruby_VENDORLIB_DIR
+      Ruby_VERSION_MAJOR
+      Ruby_VERSION_MINOR
+      Ruby_VERSION_PATCH
+      )
+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-1])" "\\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}")
+  set(_Ruby_VERSION_NODOT_ZERO_PATCH "${Ruby_VERSION_MAJOR}${Ruby_VERSION_MINOR}0")
+  set(_Ruby_VERSION_SHORT "${Ruby_VERSION_MAJOR}.${Ruby_VERSION_MINOR}")
+  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.
+find_path(Ruby_INCLUDE_DIR
+          NAMES ruby.h
+          HINTS
+          ${Ruby_HDR_DIR}
+          ${Ruby_ARCH_DIR}
+          /usr/lib/ruby/${_Ruby_VERSION_SHORT}/i586-linux-gnu/
+          )
+
+set(Ruby_INCLUDE_DIRS ${Ruby_INCLUDE_DIR})
+
+# if ruby > 1.8 is required or if ruby > 1.8 was found, search for the config.h dir
+if (Ruby_FIND_VERSION VERSION_GREATER_EQUAL "1.9" OR Ruby_VERSION VERSION_GREATER_EQUAL "1.9" OR Ruby_HDR_DIR)
+  find_path(Ruby_CONFIG_INCLUDE_DIR
+            NAMES ruby/config.h config.h
+            HINTS
+            ${Ruby_HDR_DIR}/${Ruby_ARCH}
+            ${Ruby_ARCH_DIR}
+            ${Ruby_ARCHHDR_DIR}
+            )
+
+  set(Ruby_INCLUDE_DIRS ${Ruby_INCLUDE_DIRS} ${Ruby_CONFIG_INCLUDE_DIR})
+endif ()
+
+# Determine the list of possible names for the ruby library
+set(_Ruby_POSSIBLE_LIB_NAMES
+    ruby
+    ruby-static
+    ruby-${Ruby_VERSION}
+    ruby${_Ruby_VERSION_NODOT}
+    ruby${_Ruby_VERSION_NODOT_ZERO_PATCH}
+    ruby-${_Ruby_VERSION_SHORT}
+    ruby${_Ruby_VERSION_SHORT}
+    ruby${_Ruby_VERSION_SHORT_NODOT}
+    )
+
+if (WIN32)
+  set(_Ruby_POSSIBLE_RUNTIMES "ucrt;msvcrt;vcruntime140;vcruntime140_1;vcruntime${MSVC_TOOLSET_VERSION}")
+  set(_Ruby_POSSIBLE_VERSION_SUFFIXES "${_Ruby_VERSION_NODOT};${_Ruby_VERSION_NODOT_ZERO_PATCH}")
+
+  if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(_Ruby_POSSIBLE_ARCH_PREFIXES "libx64-;x64-")
+  else ()
+    set(_Ruby_POSSIBLE_ARCH_PREFIXES "lib")
+  endif ()
+
+  foreach (_Ruby_RUNTIME ${_Ruby_POSSIBLE_RUNTIMES})
+    foreach (_Ruby_VERSION_SUFFIX ${_Ruby_POSSIBLE_VERSION_SUFFIXES})
+      foreach (_Ruby_ARCH_PREFIX ${_Ruby_POSSIBLE_ARCH_PREFIXES})
+        list(APPEND _Ruby_POSSIBLE_LIB_NAMES
+             "${_Ruby_ARCH_PREFIX}${_Ruby_RUNTIME}-ruby${_Ruby_VERSION_SUFFIX}"
+             "${_Ruby_ARCH_PREFIX}${_Ruby_RUNTIME}-ruby${_Ruby_VERSION_SUFFIX}-static")
+      endforeach ()
+    endforeach ()
+  endforeach ()
+endif ()
+
+find_library(Ruby_LIBRARY NAMES ${_Ruby_POSSIBLE_LIB_NAMES} HINTS ${_Ruby_POSSIBLE_LIB_DIR})
+
+set(_Ruby_REQUIRED_VARS Ruby_EXECUTABLE Ruby_INCLUDE_DIR Ruby_LIBRARY)
+if (_Ruby_VERSION_SHORT_NODOT GREATER 18)
+  list(APPEND _Ruby_REQUIRED_VARS Ruby_CONFIG_INCLUDE_DIR)
+endif ()
+
+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_POSSIBLE_LIB_NAMES: ${_Ruby_POSSIBLE_LIB_NAMES}")
+message(DEBUG "Ruby_FIND_VIRTUALENV=${Ruby_FIND_VIRTUALENV}")
+message(DEBUG "Ruby_ENV: ${Ruby_ENV}")
+message(DEBUG "Found Ruby_VERSION: \"${Ruby_VERSION}\"")
+message(DEBUG "Ruby_EXECUTABLE: ${Ruby_EXECUTABLE}")
+message(DEBUG "Ruby_LIBRARY: ${Ruby_LIBRARY}")
+message(DEBUG "Ruby_INCLUDE_DIR: ${Ruby_INCLUDE_DIR}")
+message(DEBUG "Ruby_CONFIG_INCLUDE_DIR: ${Ruby_CONFIG_INCLUDE_DIR}")
+message(DEBUG "Ruby_HDR_DIR: ${Ruby_HDR_DIR}")
+message(DEBUG "Ruby_ARCH_DIR: ${Ruby_ARCH_DIR}")
+message(DEBUG "--------------------")
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(Ruby REQUIRED_VARS ${_Ruby_REQUIRED_VARS}
+                                  VERSION_VAR Ruby_VERSION)
+
+if (Ruby_FOUND)
+  set(Ruby_LIBRARIES ${Ruby_LIBRARY})
+endif ()
+
+mark_as_advanced(
+    Ruby_EXECUTABLE
+    Ruby_LIBRARY
+    Ruby_INCLUDE_DIR
+    Ruby_CONFIG_INCLUDE_DIR
+    )

data/Rakefile

@@ -90,7 +90,7 @@ FileUtils.mkdir_p(include_dir) #unless File.exists?('include')
 desc "Update rice header files"
 task :headers do
   FileUtils.rm_rf(File.join(include_dir, "rice", "*"))
-  path = File.join(__dir__, 'make_rice_headers.rb')
+  path = File.join(__dir__, 'lib', 'make_rice_headers.rb')
   # Execute make_rice_headers.rb
   run_command(Gem.ruby, path)
 end
@@ -98,9 +98,10 @@ end
 # ---------  Documentation  --------------
 desc "Build the documentation"
 task :doc do
-  cd "doc" do
-    sh "make clean html"
-  end
+  build_dir = File.expand_path(File.join("doc", "_build"))
+  FileUtils.rm_r(build_dir, secure: true)
+  cmd = ["sphinx-build", "--builder", "html", "doc", build_dir]
+  sh *cmd
 end
 
 task :default => :test