ruby-bindgen 1.0.0

data/lib/ruby-bindgen/generators/ffi/library.erb

@@ -0,0 +1,39 @@
+extend FFI::Library
+
+def self.library_names
+  <%= @library_names %>
+end
+
+def self.library_versions
+  <%= @library_versions.sort.reverse %>
+end
+
+def self.search_names
+  result = Array.new
+  self.library_names.each do |name|
+    result << "lib#{name}"
+    self.library_versions.each do |version|
+      case RbConfig::CONFIG['host_os']
+        when /darwin|mac os/
+          result << "lib#{name}.#{version}"
+        when /mingw/
+          result << "lib#{name}-#{version}"
+        when /mswin/
+          result << "#{name}_#{version}"
+        else
+          result << "lib#{name}.so.#{version}"
+      end
+    end
+  end
+  result
+end
+
+<% if @library_search_path -%>
+if ENV['<%= @library_search_path %>']
+  ffi_lib self.search_names.map { |name| File.join(ENV['<%= @library_search_path %>'], name) } + self.search_names
+else
+  ffi_lib self.search_names
+end
+<% else -%>
+ffi_lib self.search_names
+<% end -%>

data/lib/ruby-bindgen/generators/ffi/project.erb

@@ -0,0 +1,18 @@
+# Generated by ruby-bindgen (<%= RubyBindgen::VERSION %>)
+
+require 'ffi'
+
+<% module_parts.each_with_index do |part, i| -%>
+<%= "  " * i %>module <%= part %>
+<% end -%>
+<%= library %>
+<% (module_parts.length - 1).downto(0) do |i| -%>
+<%= "  " * i %>end
+<% end -%>
+
+<% if version_file -%>
+require_relative '<%= version_file %>'
+<% end -%>
+<% files.each do |file| -%>
+require_relative '<%= file %>'
+<% end -%>

data/lib/ruby-bindgen/generators/ffi/struct.erb

@@ -0,0 +1,6 @@
+
+class <%= cursor.ruby_name %> < FFI::Struct
+<%- if cursor.find_by_kind(false, :cursor_field_decl).count > 0 -%>
+  layout <%= children %>
+<%- end -%>
+end

data/lib/ruby-bindgen/generators/ffi/translation_unit.erb

@@ -0,0 +1,9 @@
+# Generated by ruby-bindgen (<%= RubyBindgen::VERSION %>)
+
+<% module_parts.each_with_index do |part, i| -%>
+<%= "  " * i %>module <%= part %>
+<% end -%>
+<%= content %>
+<% (module_parts.length - 1).downto(0) do |i| -%>
+<%= "  " * i %>end
+<% end -%>

data/lib/ruby-bindgen/generators/ffi/typedef_decl.erb

@@ -0,0 +1 @@
+typedef <%= figure_ffi_type(cursor.underlying_type, :typedef) %>, :<%= cursor.ruby_name %>

data/lib/ruby-bindgen/generators/ffi/union.erb

@@ -0,0 +1,6 @@
+
+class <%= cursor.ruby_name %> < FFI::Union
+<%- if cursor.find_by_kind(false, :cursor_field_decl).count > 0 -%>
+  layout <%= children %>
+<%- end -%>
+end

data/lib/ruby-bindgen/generators/ffi/variable.erb

@@ -0,0 +1 @@
+attach_variable :<%= cursor.ruby_name %>, :<%= cursor.spelling %>, <%= figure_ffi_type(cursor.type)%>

data/lib/ruby-bindgen/generators/ffi/version.erb

@@ -0,0 +1,9 @@
+# Generated by ruby-bindgen (<%= RubyBindgen::VERSION %>)
+
+<% module_parts.each_with_index do |part, i| -%>
+<%= "  " * i %>module <%= part %>
+<% end -%>
+<%= method_body %>
+<% (module_parts.length - 1).downto(0) do |i| -%>
+<%= "  " * i %>end
+<% end -%>

data/lib/ruby-bindgen/generators/ffi/version_method.erb

@@ -0,0 +1,5 @@
+def self.<%= method_name %>
+  # Return the runtime library version as an integer.
+  # Example: 90602 for version 9.6.2
+  raise NotImplementedError, "Implement <%= method_name %> to return the runtime library version number"
+end

data/lib/ruby-bindgen/generators/generator.rb

@@ -0,0 +1,52 @@
+require 'erb'
+
+module RubyBindgen
+  module Generators
+    class Generator
+      attr_reader :inputter, :outputter, :config
+
+      def initialize(inputter, outputter, config)
+        @inputter = inputter
+        @outputter = outputter
+        @config = config
+        @project = config[:project]&.gsub(/-/, '_')
+      end
+
+      def project
+        @project
+      end
+
+      def generate
+        raise NotImplementedError
+      end
+
+      def render_template(template, local_variables = {})
+        template_path = File.join(self.class.template_dir, "#{template}.erb")
+        template_content = File.read(template_path)
+        template = ERB.new(template_content, :trim_mode => '-')
+        template.filename = template_path # This allows debase to stop at breakpoints in templates!
+        b = self.binding
+        local_variables.each do |key, value|
+          b.local_variable_set(key, value)
+        end
+        template.result(b)
+      end
+
+      # Check whether a cursor originates from the translation unit's main file.
+      # This intentionally uses libclang file-object equality rather than comparing
+      # raw file-name strings. Cursor locations only expose the file path string,
+      # so we resolve that path back through `translation_unit.file(...)` and let
+      # libclang compare the resulting file objects.
+      def translation_unit_file?(cursor)
+        file_name = cursor.file_location.file
+        translation_unit_file = cursor.translation_unit.file
+        file = file_name && cursor.translation_unit.file(file_name)
+        file && translation_unit_file && file == translation_unit_file
+      end
+
+      def self.template_dir
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/ruby-bindgen/generators/rice/auto_generated_base_class.erb

@@ -0,0 +1,5 @@
+<%- if under -%>
+Rice::Data_Type<<%= base_spelling %>> <%= cruby_name %> = <%= base_template.spelling %>_instantiate<<%= template_arguments %>>(<%= under.cruby_name %>, "<%= ruby_name %>");
+<%- else -%>
+Rice::Data_Type<<%= base_spelling %>> <%= cruby_name %> = <%= base_template.spelling %>_instantiate<<%= template_arguments %>>(Rice::Module(rb_cObject), "<%= ruby_name %>");
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/class.erb

@@ -0,0 +1,31 @@
+<%- if has_incomplete_classes -%>
+<%# Split: define class, define incomplete inner classes, then add methods -%>
+<%= auto_generated_base -%>
+<%- if under && base -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class_under<<%= cpp_type %>, <%= base %>>(<%= under.cruby_name %>, "<%= ruby_class_name %>");
+<%- elsif under -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class_under<<%= cpp_type %>>(<%= under.cruby_name %>, "<%= ruby_class_name %>");
+<%- elsif base -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class<<%= cpp_type %>, <%= base %>>("<%= ruby_class_name %>");
+<%- else -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class<<%= cpp_type %>>("<%= ruby_class_name %>");
+<%- end -%>
+
+<%= incomplete_classes -%>
+<%- unless children == ";" -%>
+
+<%= cursor.cruby_name %><%= children -%>
+<%- end -%>
+<%- else -%>
+<%# No incomplete classes - single statement -%>
+<%= auto_generated_base -%>
+<%- if under && base -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class_under<<%= cpp_type %>, <%= base %>>(<%= under.cruby_name %>, "<%= ruby_class_name %>")<%= children -%>
+<%- elsif under -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class_under<<%= cpp_type %>>(<%= under.cruby_name %>, "<%= ruby_class_name %>")<%= children -%>
+<%- elsif base -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class<<%= cpp_type %>, <%= base %>>("<%= ruby_class_name %>")<%= children -%>
+<%- else -%>
+Rice::Data_Type<<%= cpp_type %>> <%= cursor.cruby_name %> = define_class<<%= cpp_type %>>("<%= ruby_class_name %>")<%= children -%>
+<%- end -%>
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/class_template.erb

@@ -0,0 +1,9 @@
+template<<%= template_signature %>>
+inline Rice::Data_Type<<%= fully_qualified_type %>> <%= cursor.spelling %>_instantiate(Rice::Module parent, const char* name)
+{
+<%- if base_spelling -%>
+  return Rice::define_class_under<<%= fully_qualified_type %>, <%= base_spelling %>>(parent, name)<%= children %>
+<%- else -%>
+  return Rice::define_class_under<<%= fully_qualified_type %>>(parent, name)<%= children %>
+<%- end -%>
+}

data/lib/ruby-bindgen/generators/rice/class_template_specialization.erb

@@ -0,0 +1,10 @@
+<%- var_name = defined?(cruby_name) ? cruby_name : cursor.cruby_name -%>
+<%- # Use typedef/using name if cursor is a typedef, otherwise generate from template -%>
+<%- raw_name = if cursor.kind == :cursor_typedef_decl || cursor.kind == :cursor_type_alias_decl
+                 cursor.spelling.camelize
+               else
+                 template_specialization.gsub(/<.*>/, "").split("::").last.camelize + template_arguments.split(",").map(&:strip).map { |t| t.gsub(/[^a-zA-Z0-9]/, " ").split.map(&:capitalize).join }.join
+               end -%>
+<%- ruby_class_name = @namer.apply_rename_types(raw_name) -%>
+<%- parent_module = under ? under.cruby_name : "Rice::Module(rb_cObject)" -%>
+Rice::Data_Type<<%= template_specialization %>> <%= var_name %> = <%= cursor_template.spelling %>_instantiate<<%= template_arguments %>>(<%= parent_module %>, "<%= ruby_class_name %>");

data/lib/ruby-bindgen/generators/rice/constant.erb

@@ -0,0 +1,9 @@
+<%- if cursor.semantic_parent.kind == :cursor_translation_unit ||
+       cursor.semantic_parent.kind == :cursor_namespace ||
+       cursor.semantic_parent.anonymous? -%>
+<%= cursor.semantic_parent.cruby_name %>.define_constant("<%= name %>", <%= qualified_name %>);
+<%- elsif cursor.kind == :cursor_macro_definition -%>
+Class(rb_cObject).define_constant("<%= name %>", <%= qualified_name %>);
+<%- else -%>
+define_constant("<%= name %>", <%= qualified_name %>)
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/constructor.erb

@@ -0,0 +1 @@
+define_constructor(Constructor<<%= signature %>>()<%= args.empty? ? ")" : ",\n  #{args.join(", ")})" %>

data/lib/ruby-bindgen/generators/rice/conversion_function.erb

@@ -0,0 +1,4 @@
+define_method("<%= ruby_name %>", [](<%= is_const ? "const " : "" %><%= qualified_parent %>& self) -> <%= result_type %>
+{
+  return static_cast<<%= result_type %>>(self);
+})

data/lib/ruby-bindgen/generators/rice/cxx_iterator_method.erb

@@ -0,0 +1 @@
+<%= is_template && signature && !signature.empty? ? "template " : "" %>define_iterator<%= signature %>(&<%= qualified_parent %>::<%= begin_method %>, &<%= qualified_parent %>::<%= end_method %>, "<%= name %>")

data/lib/ruby-bindgen/generators/rice/cxx_method.erb

@@ -0,0 +1,6 @@
+<%- all_args = return_buffer ? (args + ["ReturnBuffer()"]) : args -%>
+<%- if cursor.static? -%>
+<%= is_template && signature && !signature.empty? ? "template " : "" %>define_singleton_function<%= signature %>("<%= name %>", <%= RubyBindgen::Generators::Rice::FunctionPointer.format(cursor, "#{qualified_parent}::#{cursor.spelling}", signature) %><%= all_args.empty? ? ")" : ",\n  #{all_args.join(", ")})" %>
+<%- else -%>
+<%= is_template && signature && !signature.empty? ? "template " : "" %>define_method<%= signature %>("<%= name %>", &<%= qualified_parent %>::<%= cursor.spelling %><%= all_args.empty? ? ")" : ",\n  #{all_args.join(", ")})" %>
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/enum_constant_decl.erb

@@ -0,0 +1,7 @@
+<%- if anonymous_class_scope -%>
+define_constant("<%= cursor.spelling.upcase_first  %>", (int)<%= qualified_name %>)
+<%- elsif anonymous_parent -%>
+<%= owner_cruby_name %>.define_constant("<%= cursor.spelling.upcase_first %>", (int)<%= qualified_name %>);
+<%- else -%>
+define_value("<%= cursor.spelling %>", <%= value_name %>)
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/enum_decl.erb

@@ -0,0 +1,6 @@
+<%- if cursor.anonymous? -%>
+<%- elsif under -%>
+Enum<<%= cursor.qualified_display_name %>> <%= cursor.cruby_name %> = define_enum_under<<%= cursor.qualified_display_name %>>("<%= cursor.ruby_name %>", <%= under.cruby_name %>)<%= children -%>
+<%- else -%>
+Enum<<%= cursor.qualified_display_name %>> <%= cursor.cruby_name %> = define_enum<<%= cursor.qualified_display_name %>>("<%= cursor.ruby_name %>")<%= children -%>
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/field_decl.erb

@@ -0,0 +1,8 @@
+<% decl = cursor.type.declaration -%>
+<% if cursor.type.const_qualified? || cursor.type.is_a?(::FFI::Clang::Types::Array) -%>
+define_attr("<%= cursor.ruby_name %>", &<%= qualified_parent %>::<%= cursor.spelling %>, Rice::AttrAccess::Read)
+<% elsif decl.copy_assignable? -%>
+define_attr("<%= cursor.ruby_name %>", &<%= qualified_parent %>::<%= cursor.spelling %>)
+<% else -%>
+define_attr("<%= cursor.ruby_name %>", &<%= qualified_parent %>::<%= cursor.spelling %>, Rice::AttrAccess::Read)
+<% end -%>

data/lib/ruby-bindgen/generators/rice/function.erb

@@ -0,0 +1,6 @@
+<%- all_args = return_buffer ? (args + ["ReturnBuffer()"]) : args -%>
+<%- if under -%>
+<%= under.cruby_name %>.define_module_function<%= signature %>("<%= name %>", <%= RubyBindgen::Generators::Rice::FunctionPointer.format(cursor, cursor.qualified_name, signature) %><%= all_args.empty? ? ")" : ",\n  #{all_args.join(", ")})" %>;
+<%- else -%>
+define_global_function<%= signature %>("<%= name %>", <%= RubyBindgen::Generators::Rice::FunctionPointer.format(cursor, cursor.qualified_name, signature) %><%= all_args.empty? ? ")" : ",\n  #{all_args.join(", ")})" %>;
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/function_pointer.rb

@@ -0,0 +1,68 @@
+module RubyBindgen
+  module Generators
+    class Rice
+      # Build the C++ pointer-to-function expression Rice needs to bind a
+      # method or free function. Most compilers can resolve `&Foo::bar`
+      # against the surrounding template-deduced signature even when `bar`
+      # is overloaded, but MSVC cannot, so when the name refers to an
+      # overload set we wrap the address in a `static_cast` whose target
+      # type *is* the signature:
+      #
+      #   non-overloaded:  &Foo::bar
+      #   overloaded MSVC: static_cast<void(int, float)>(&Foo::bar)
+      class FunctionPointer
+        # Returns the address-of expression for `cursor`, optionally wrapped
+        # in a disambiguating `static_cast`.
+        def self.format(cursor, qualified_name, signature)
+          reference = "&#{qualified_name}"
+          return reference unless cast_required?(cursor, signature)
+  
+          "static_cast<#{signature[1...-1]}>(#{reference})"
+        end
+  
+        # True when `cursor` shares its spelling with another overload
+        # candidate in the same semantic parent — i.e. when MSVC would need
+        # the cast to pick which overload `&qualified_name` refers to.
+        def self.cast_required?(cursor, signature)
+          return false unless signature
+          return false unless cursor.kind == :cursor_function || cursor.static?
+  
+          parent = cursor.semantic_parent
+          return false unless parent
+  
+          overload_count = 0
+          parent.each(false) do |sibling, _|
+            next unless overload_candidate?(cursor, sibling)
+  
+            overload_count += 1
+            return true if overload_count > 1
+          end
+  
+          false
+        end
+        private_class_method :cast_required?
+  
+        # A sibling counts as another overload of `cursor` only if the
+        # spellings match AND the kinds are compatible. Free functions
+        # collide with other free functions and function templates; static
+        # methods collide with other methods (any static-ness) and method
+        # templates. Non-static methods are excluded — they're addressed
+        # as `&Class::method` and Rice dispatches them through a different
+        # path that doesn't need disambiguation here.
+        def self.overload_candidate?(cursor, sibling)
+          return false unless sibling.spelling == cursor.spelling
+  
+          case cursor.kind
+          when :cursor_function
+            [:cursor_function, :cursor_function_template].include?(sibling.kind)
+          when :cursor_cxx_method
+            cursor.static? && [:cursor_cxx_method, :cursor_function_template].include?(sibling.kind)
+          else
+            false
+          end
+        end
+        private_class_method :overload_candidate?
+      end
+    end
+  end
+end

data/lib/ruby-bindgen/generators/rice/incomplete_class.erb

@@ -0,0 +1,3 @@
+<%# Template for forward-declared (incomplete) inner classes -%>
+<%# These need to be registered with Rice so that types like Ptr<Impl> work -%>
+Rice::Data_Type<<%= cursor.qualified_name %>> <%= cursor.cruby_name %> = define_class_under<<%= cursor.qualified_name %>>(<%= under.cruby_name %>, "<%= @namer.apply_rename_types(cursor.spelling, cursor.spelling.camelize) %>");

data/lib/ruby-bindgen/generators/rice/iterator_alias.erb

@@ -0,0 +1 @@
+Rice::detail::protect(rb_alias, <%= cruby_name %>, rb_intern("each"), rb_intern("each_const"));

data/lib/ruby-bindgen/generators/rice/iterator_collector.rb

@@ -0,0 +1,159 @@
+require 'set'
+
+module RubyBindgen
+  module Generators
+    class Rice
+      # Tracks iterator-related state across one translation-unit visit:
+      #
+      #   * Which Ruby iterator names a class exposes (each, each_const,
+      #     each_reverse, each_reverse_const). Drives the each_const-only
+      #     `alias each each_const` emission.
+      #   * Which custom iterator types still need a generated
+      #     `std::iterator_traits` specialization (for iterators that don't
+      #     specialize std::iterator_traits themselves), de-duplicated
+      #     across the multiple begin/rbegin callsites that hit the same
+      #     iterator type.
+      #
+      # `record(cursor)` is the single entry point per iterator method.
+      # `clear` resets between translation units.
+      class IteratorCollector
+        # Inferred traits for one custom iterator. The hash key under which
+        # this is stored is the iterator's qualified name; we don't repeat
+        # it here. Consumed directly by the ERB template.
+        Inference = Data.define(:value_type, :is_const)
+  
+        # Returns the qualified-name → Inference map of iterators that need
+        # a generated std::iterator_traits specialization.
+        attr_reader :incomplete_iterators
+  
+        def initialize
+          @incomplete_iterators = {}
+          @iterator_names_by_class = Hash.new { |h, k| h[k] = Set.new }
+        end
+  
+        def clear
+          @incomplete_iterators.clear
+          @iterator_names_by_class.clear
+        end
+  
+        # Record an iterator method on its parent class. Returns the Ruby
+        # iterator name to render (e.g. "each", "each_const") or nil for
+        # variants we deliberately skip:
+        #
+        #   * cbegin/crbegin — would emit a duplicate each_const /
+        #     each_reverse_const since C++ allows them on non-const
+        #     receivers but Ruby has no const distinction.
+        #   * end/cend/rend/crend — handled implicitly by Rice's
+        #     define_iterator.
+        def record(cursor)
+          ruby_name = ruby_iterator_name(cursor)
+          return nil unless ruby_name
+  
+          @iterator_names_by_class[cursor.semantic_parent.cruby_name] << ruby_name
+          record_traits_if_needed(cursor.result_type)
+          ruby_name
+        end
+  
+        # True when `cruby_name` exposes only const iteration. The caller
+        # emits an `alias each each_const` so Ruby code can iterate without
+        # spelling the const variant.
+        def each_const_only?(cruby_name)
+          names = @iterator_names_by_class[cruby_name]
+          names.include?("each_const") && !names.include?("each")
+        end
+  
+        private
+  
+        def ruby_iterator_name(cursor)
+          case cursor.spelling
+          when "begin"  then cursor.const? ? "each_const"         : "each"
+          when "rbegin" then cursor.const? ? "each_reverse_const" : "each_reverse"
+          end
+        end
+  
+        def record_traits_if_needed(iterator_type)
+          inference = infer_traits(iterator_type)
+          return unless inference
+  
+          # Key by qualified iterator name so the same iterator hit via
+          # different begin/rbegin callsites gets one specialization.
+          @incomplete_iterators[iterator_type.declaration.qualified_name] = inference
+        end
+  
+        # Returns an Inference if `iterator_type` needs a generated
+        # std::iterator_traits specialization, or nil if it doesn't.
+        # Inputs that already declare the full trait set, that live in
+        # `std::`, or whose value type can't be recovered are left alone.
+        def infer_traits(iterator_type)
+          decl = iterator_type.declaration
+          return nil if decl.kind == :cursor_no_decl_found
+          return nil if decl.qualified_name&.start_with?('std::')
+  
+          # If the type is reached through a typedef (e.g.
+          # `typedef SparseMatConstIterator_<uchar> SparseMatConstIterator`)
+          # walk to the underlying class so trait/operator lookup hits
+          # the actual class members rather than the typedef cursor.
+          if decl.kind == :cursor_typedef_decl || decl.kind == :cursor_type_alias_decl
+            underlying = iterator_type.canonical.declaration
+            decl = underlying if underlying.kind != :cursor_no_decl_found
+          end
+  
+          return nil if traits_already_complete?(decl)
+  
+          value_type = infer_value_type(decl)
+          return nil unless value_type
+  
+          Inference.new(
+            value_type: value_type_qualified_name(value_type),
+            is_const: value_type.const_qualified?
+          )
+        end
+  
+        REQUIRED_TRAITS = %w[
+          value_type
+          reference
+          pointer
+          difference_type
+          iterator_category
+        ].freeze
+        private_constant :REQUIRED_TRAITS
+  
+        def traits_already_complete?(decl)
+          present = Set.new
+          decl.each(false) do |child, _|
+            next unless child.kind == :cursor_type_alias_decl ||
+                        child.kind == :cursor_typedef_decl
+            present << child.spelling if REQUIRED_TRAITS.include?(child.spelling)
+          end
+          present.size == REQUIRED_TRAITS.size
+        end
+  
+        # Recursive iteration so inherited operator* on a base class is
+        # found. Iterators without operator* (e.g. OpenCV's
+        # SparseMatConstIterator which exposes node()) cannot have traits
+        # inferred and must be skipped via the symbols config.
+        def infer_value_type(decl)
+          decl.each do |child, _|
+            next unless child.kind == :cursor_cxx_method &&
+                        child.spelling == "operator*"
+            # non_reference_type is a no-op on non-references, so this
+            # handles `T`, `T &`, and `const T &` uniformly.
+            return child.result_type.non_reference_type
+          end
+          nil
+        end
+  
+        # Prefer the value type's qualified name from its declaration;
+        # fall back to the unqualified spelling for primitives (no decl).
+        def value_type_qualified_name(value_type)
+          decl = value_type.declaration
+          if decl && decl.kind != :cursor_no_decl_found
+            decl.qualified_name
+          else
+            value_type.unqualified_type.spelling
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby-bindgen/generators/rice/namespace.erb

@@ -0,0 +1,5 @@
+<%- if under -%>
+Module <%= cursor.cruby_name %> = define_module_under(<%= under.cruby_name %>, "<%= cursor.ruby_name %>");
+<%- else -%>
+Module <%= cursor.cruby_name %> = define_module("<%= cursor.ruby_name %>");
+<%- end -%>

data/lib/ruby-bindgen/generators/rice/non_member_operator_binary.erb

@@ -0,0 +1,4 @@
+define_method("<%= ruby_name %>", [](<%= arg0_type %> self, <%= arg1_type %> other) -> <%= result_type %>
+{
+  <%= return_stmt %>
+})

data/lib/ruby-bindgen/generators/rice/non_member_operator_inspect.erb

@@ -0,0 +1,6 @@
+define_method("inspect", [](<%= arg_type %> self) -> std::string
+{
+  std::ostringstream stream;
+  stream << self;
+  return stream.str();
+})

data/lib/ruby-bindgen/generators/rice/non_member_operator_unary.erb

@@ -0,0 +1,4 @@
+define_method("<%= ruby_name %>", [](<%= arg0_type %> self) -> <%= result_type %>
+{
+  return <%= op_symbol %>self;
+})

data/lib/ruby-bindgen/generators/rice/operator[].erb

@@ -0,0 +1,4 @@
+define_method("[]=", [](<%= qualified_parent %>&self, <%= index_type %> <%= index_name %>, <%= value_type %> value)
+{
+    self[<%= index_name %>] = value;
+})

data/lib/ruby-bindgen/generators/rice/project.cpp.erb

@@ -0,0 +1,18 @@
+// Generated by ruby-bindgen (<%= RubyBindgen::VERSION %>)
+
+#include "<%= project_header %>"
+
+<% init_names.keys.each do |init_name| -%>
+#include "<%= init_name %>"
+<% end -%>
+
+extern "C"
+void <%= init_name %>()
+{
+  return Rice::detail::cpp_protect([]
+  {
+  <% init_names.values.each do |init_function| -%>
+    <%= init_function %>();
+  <% end -%>
+});
+}

data/lib/ruby-bindgen/generators/rice/project.hpp.erb

@@ -0,0 +1,13 @@
+// Generated by ruby-bindgen (<%= RubyBindgen::VERSION %>)
+
+#pragma once
+
+#include <rice/rice.hpp>
+
+extern "C"
+#if defined(_WIN32)
+__declspec(dllexport)
+#else
+__attribute__((visibility("default")))
+#endif
+void <%= init_name %>();