rice 4.5.0 → 4.6.0

data/lib/make_rice_headers.rb

@@ -0,0 +1,79 @@
+require 'stringio'
+
+LINE_ENDING = "\n"
+RICE_INCLUDE_REGEX = %r{#include "(.*)"}
+OTHER_INCLUDE_REGEX = %r{#include <(.*)>}
+
+RICE_HEADER_GUARD_1 = %r{#ifndef Rice__}
+RICE_HEADER_GUARD_2 = %r{#define Rice__}
+RICE_HEADER_GUARD_3 = %r{#endif\s*//\s*Rice__}
+SHARED_METHODS_REGEX = %r{#include "((?:cpp_api\/)?shared_methods.hpp)"}
+
+def load_file(relative_path)
+  content = File.read(relative_path, mode: 'rb')
+
+  # Special case shared_methods.hpp which if requested we want to
+  # merge into the current file
+  match = content.match(SHARED_METHODS_REGEX)
+  if match
+    shared_path = File.join(File.dirname(relative_path), match[1])
+    content.gsub!(SHARED_METHODS_REGEX, File.read(shared_path, mode: 'rb'))
+  end
+
+  content
+end
+
+def strip_includes(content)
+  content.lines.find_all do |line|
+    !line.match(RICE_INCLUDE_REGEX)
+  end.join
+end
+
+def add_include(path, stream)
+  basename = File.basename(path)
+  basename_no_ext = File.basename(path, ".*")
+
+  stream << "\n" << "// =========   #{File.basename(path)}   =========" << "\n"
+
+  load_file(path).each_line do |line|
+    if match = line.match(RICE_INCLUDE_REGEX)
+      # Check for related includes, ie., Object.hpp, Object_defn.hpp and Object.ipp
+      sub_include = File.basename(match[1])
+      if ["#{basename_no_ext}_defn.hpp", "#{basename_no_ext}.ipp"].include?(sub_include)
+        sub_include_path = File.join(File.dirname(path), match[1])
+        stream << "\n" << "// ---------   #{File.basename(sub_include_path)}   ---------" << "\n"
+        stream << strip_includes(load_file(sub_include_path))
+      end
+    elsif line.match(RICE_HEADER_GUARD_1) || line.match(RICE_HEADER_GUARD_2) || line.match(RICE_HEADER_GUARD_3)
+      # Skip the header guard
+    else
+      # Include the line in the output
+      stream << line
+    end
+  end
+end
+
+def combine_headers(filename)
+  stream = StringIO.new
+
+  load_file("rice/#{filename}").each_line do |line|
+    if matches = line.match(RICE_INCLUDE_REGEX)
+      path = File.join("rice", matches[1])
+      add_include(path, stream)
+    else
+      stream << line
+    end
+  end
+
+  File.open("include/rice/#{filename}", 'wb') do |file|
+    file << stream.string
+  end
+end
+
+puts "Building rice.hpp"
+combine_headers('rice.hpp')
+
+puts "Building stl.hpp"
+combine_headers('stl.hpp')
+
+puts "Success"

data/lib/mkmf-rice.rb

@@ -1,4 +1,8 @@
 require 'mkmf'
+require 'rice/version'
+
+major, minor, patch = Rice::VERSION.split(".")
+$CXXFLAGS += " -DRICE_VERSION_MAJOR=#{major} -DRICE_VERSION_MINOR=#{minor} -DRICE_VERSION_PATCH=#{patch}"
 
 IS_MSWIN = /mswin/ =~ RUBY_PLATFORM
 IS_MINGW = /mingw/ =~ RUBY_PLATFORM

data/lib/rice/version.rb

@@ -0,0 +1,3 @@
+module Rice
+  VERSION = "4.6.0"
+end

data/lib/rice.rb

@@ -0,0 +1 @@
+require_relative "rice/version"

data/lib/rubygems/builder.rb

@@ -0,0 +1,11 @@
+class Gem::Ext::Builder
+	alias :builder_for_original :builder_for
+	def builder_for(extension)
+		case extension
+			when /CMakeLists.txt/ then
+				Gem::Ext::CmakeBuilder.new
+			else
+				builder_for_original(extension)
+		end
+	end
+end

data/lib/rubygems/cmake_builder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# This builder creates extensions defined using CMake. Its is invoked if a Gem's spec file
+# sets the `extension` property to a string that contains `CMakeLists.txt`.
+#
+# In general, CMake projects are built in two steps:
+#
+#  * configure
+#  * build
+#
+# The builder follow this convention. First it runs a configuration step and then it runs a build step.
+#
+# CMake projects can be quite configurable - it is likely you will want to specify options when
+# installing a gem. To pass options to CMake specify them after `--` in the gem install command. For example:
+#
+#   gem install <gem_name> -- --preset <preset_name>
+#
+# Note that options are ONLY sent to the configure step - it is not currently possible to specify
+# options for the build step. If this becomes and issue then the CMake builder can be updated to
+# support build options.
+#
+# Useful options to know are:
+#
+#  -G to specify a generator (-G Ninja is recommended)
+#  -D<CMAKE_VARIABLE> to set a CMake variable (for example -DCMAKE_BUILD_TYPE=Release)
+#  --preset <preset_name> to use a preset
+#
+# If the Gem author provides presets, via CMakePresets.json file, you will likely want to us use one of them.
+# If not, then you may wish to specify a generator (Ninja is recommended since it can build projects in parallel
+# versus a Make generator which build ins serial and thus is *much* slower).
+
+require "fileutils"
+
+class Gem::Ext::CmakeBuilder
+  attr_accessor :runner, :profile
+
+  def initialize
+    @runner = self.class.method(:run)
+    @profile = :release
+  end
+
+  def build(extension, gem_dir, results, args = [], lib_dir = nil, cmake_dir = Dir.pwd, target_rbconfig = Gem.target_rbconfig)
+    if target_rbconfig.path
+      warn "--target-rbconfig is not yet supported for CMake extensions. Ignoring"
+    end
+
+    # Make sure lib dir is set
+    lib_dir ||= File.join(gem_dir, "lib")
+
+    # Figure the build dir
+    build_dir = File.join(cmake_dir, "build")
+
+    # Check if the gem defined presets
+    check_presets(cmake_dir, args)
+
+    # Configure
+    configure(cmake_dir, build_dir, lib_dir, args, results)
+
+    # Compile
+    compile(cmake_dir, build_dir, args, results)
+
+    results
+  end
+
+  def configure(cmake_dir, build_dir, lib_dir, args, results)
+    cmd = ["cmake",
+           cmake_dir,
+           "-B #{build_dir}",
+           "-DCMAKE_RUNTIME_OUTPUT_DIRECTORY=#{lib_dir}", # Windows
+           "-DCMAKE_LIBRARY_OUTPUT_DIRECTORY=#{lib_dir}", # Not Windows
+           *Gem::Command.build_args,
+           *args]
+
+    runner.call(cmd, results, "cmake", cmake_dir)
+  end
+
+  def compile(cmake_dir, build_dir, args, results)
+    cmd = ["cmake",
+           "--build",
+           build_dir.to_s,
+           "--config",
+           @profile.to_s]
+    runner.call(cmd, results, "cmake", cmake_dir)
+  end
+
+  private
+
+  def check_presets(cmake_dir, args)
+    # Return if the user specified a preset
+    return unless args.grep(/--preset/i).empty?
+
+    cmd = ["cmake",
+           "--list-presets"]
+
+    begin
+      require "open3"
+      build_env = { "SOURCE_DATE_EPOCH" => Gem.source_date_epoch_string }
+      stdout, _, _ = Open3.capture3(build_env, *cmd, chdir: cmake_dir)
+      message = <<~EOS
+        The gem author provided a list of presets that can be used to build the gem. To use a preset specify it on the command line:
+
+          gem install <gem_name> -- --preset <preset_name>
+
+        #{stdout}
+      EOS
+
+      STDOUT << message << "\n"
+      STDOUT.flush
+    rescue Gem::InstallError
+      # Do nothing, CMakePresets.json was not included in the Gem
+    end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,9 @@
+# Create RubyGems hook so we can replace the default CMakeBuilder with our own version
+Gem.pre_install do |installer|
+  extensions = installer.package&.spec&.extensions
+  if extensions && extensions.grep(/CMakeLists/)
+    require_relative 'rubygems/builder'
+    require_relative 'rubygems/cmake_builder'
+  end
+  true
+end

data/rice/Arg.hpp

@@ -55,7 +55,7 @@ namespace Rice
     /*! \return the type saved to this Arg
      */
     template<typename Arg_Type>
-    Arg_Type& defaultValue();
+    Arg_Type defaultValue();
 
     //! Tell the receiving object to keep this argument alive
     //! until the receiving object is freed.
@@ -81,6 +81,10 @@ namespace Rice
     virtual Arg& takeOwnership();
     bool isOwner();
 
+    //! Is the parameter a C style array
+    virtual Arg& setArray();
+    bool isArray();
+
   public:
     std::string name;
     int32_t position = -1;
@@ -92,6 +96,8 @@ namespace Rice
     bool isKeepAlive_ = false;
     bool isOwner_ = false;
     bool isOpaque_ = false;
+    bool isArray_ = false;
+
   };
 } // Rice
 

data/rice/Arg.ipp

@@ -21,9 +21,9 @@ namespace Rice
   /*! \return the type saved to this Arg
     */
   template<typename Arg_Type>
-  inline Arg_Type& Arg::defaultValue()
+  inline Arg_Type Arg::defaultValue()
   {
-    return std::any_cast<Arg_Type&>(this->defaultValue_);
+    return std::any_cast<Arg_Type>(this->defaultValue_);
   }
 
   inline Arg& Arg::keepAlive()
@@ -70,5 +70,14 @@ namespace Rice
     return this->isOwner_;
   }
 
+  inline Arg& Arg::setArray()
+  {
+    this->isArray_ = true;
+    return *this;
+  }
 
+  inline bool Arg::isArray()
+  {
+    return this->isArray_;
+  }
 } // Rice

data/rice/Buffer.hpp

@@ -0,0 +1,123 @@
+#ifndef Rice__Buffer__hpp_
+#define Rice__Buffer__hpp_
+
+namespace Rice
+{
+  template<typename T>
+  class Buffer
+  {
+  public:
+    using type = T;
+
+    Buffer(T* pointer);
+    Buffer(T* pointer, size_t size);
+    Buffer(VALUE value);
+
+    ~Buffer();
+
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    T* ptr();
+    T& reference();
+    void release();
+
+    size_t size() const;
+    void setSize(size_t value);
+
+    // Ruby API
+  //  VALUE toString() const;
+
+    VALUE bytes() const;
+    VALUE bytes(size_t count) const;
+
+    Array toArray() const;
+    Array toArray(size_t count) const;
+
+    T get(size_t index) const;
+    void set(size_t index, T value);
+
+    bool isOwner() const;
+    void setOwner(bool value);
+
+  private:
+    void fromRubyType(VALUE value);
+    void fromDataType(VALUE value);
+
+    bool m_owner = false;
+    size_t m_size = 0;
+    // std::unique_ptr would be greate but std::unique_ptr<void> isn't allowed
+    T* m_buffer = nullptr;
+  };
+
+  template<typename T>
+  class Buffer<T*>
+  {
+  public:
+    using type = T*;
+
+    Buffer(T** pointer);
+    Buffer(T** pointer, size_t size);
+    Buffer(VALUE value);
+
+    ~Buffer();
+
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    const Buffer<T>& operator[](size_t index);
+
+    T** ptr();
+    void release();
+
+    size_t size() const;
+    void setSize(size_t value);
+
+    // Ruby API
+   // VALUE toString() const;
+
+    VALUE bytes() const;
+    VALUE bytes(size_t count) const;
+
+    Array toArray() const;
+    Array toArray(size_t count) const;
+
+    void setOwner(bool value);
+    bool isOwner() const;
+
+  private:
+    bool m_owner = false;
+    size_t m_size = 0;
+    T** m_outer = nullptr;
+    std::vector<Buffer<T>> m_inner;
+  };
+
+  template<>
+  class Buffer<void>
+  {
+  public:
+    Buffer(void* pointer);
+    Buffer(const Buffer& other) = delete;
+    Buffer(Buffer&& other);
+
+    Buffer& operator=(const Buffer& other) = delete;
+    Buffer& operator=(Buffer&& other);
+
+    void* ptr();
+
+  private:
+    void* m_buffer = nullptr;
+  };
+
+  template<typename T>
+  Data_Type<Buffer<T>> define_buffer(std::string klassName = "");
+
+  void define_fundamental_buffer_types();
+}
+#endif // Rice__Buffer__hpp_