rdkit_chem 2025.09.3.11 → 2025.09.3.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0bfdaa78b3bed2b74fac18b36591a2194de5a74eeff5525d8b0639882a938a78
-  data.tar.gz: 9364cb31768038bc313d09fff0d08c38b4f8db90bbc3c9a5735897857dc3df20
+  metadata.gz: 8fd525bf8f5e07e8759d0f36c18ecabdf2ec3147a0d6bd240dd5c951fd629285
+  data.tar.gz: fa0cb66768fa9160dc781a6b374bfb4dc12abfa946f24daae07e851b5eb83346
 SHA512:
-  metadata.gz: e58cfb8ae7364b677d34c5967185d72d3b60f482fce083ca3d3364598c7a1248a6d9a3b3e74bb0a7e77f8444f5093b29b591d8cc51c87c02824d097fd9a29a11
-  data.tar.gz: c4febf19d6f25d971d073610b82935f3f841631987c8098ef844bc9d80d45e42780c283ef9c008e9a4aec3087e80e6504aef020db6c669fdce49dfe989c0e233
+  metadata.gz: e99aee43550767d548a3534e56609ad84607d7c88d1ef59943b8b6bd329837cc2fef2e8c660ddf8519d1bea43ee2705c6f8fc626fae528ed0604c58bd8a189d8
+  data.tar.gz: adb78e57d89a631ff08f393bea2f26b356e181e7d52c2f46f7d628d80a1657cc3af2e1ab8d5de893be4f92cec01293bf83114c520075c9d73977854ff28621cc

data/CMakeLists.txt

@@ -78,7 +78,7 @@ option(RDK_BUILD_MINIMAL_LIB_MCS "build support for MCS into MinimalLib" OFF )
 option(RDK_BUILD_MINIMAL_LIB_MOLZIP "build support for molzip into MinimalLib" OFF )
 option(RDK_BUILD_LONG_RUNNING_TESTS "build longer running tests" OFF )
 
-set(RDK_BOOST_VERSION "1.74.0")
+set(RDK_BOOST_VERSION "1.81.0")
 
 if(NOT MSVC)
   if(RDK_OPTIMIZE_POPCNT)
@@ -226,9 +226,9 @@ if(RDK_BUILD_RPATH_SUPPORT)
   ENDIF("${isSystemDir}" STREQUAL "-1")
 endif()
 
-if(RDK_BUILD_SWIG_RUBY_WRAPPER)
+if(RDK_BUILD_SWIG_RUBY_WRAPPERS)
   set(RDKit_RubyLibDir "${RDKit_ExternalDir}/ruby_lib")
-endif(RDK_BUILD_SWIG_RUBY_WRAPPER)
+endif(RDK_BUILD_SWIG_RUBY_WRAPPERS)
 
 if(RDK_BUILD_COORDGEN_SUPPORT)
     add_definitions(-DRDK_BUILD_COORDGEN_SUPPORT)

data/Code/RubyWrappers/Dict.i

@@ -35,6 +35,7 @@
 #include <RDGeneral/Dict.h>
 %}
 
+// This requires SWIG 4.2 or higher
 %include "std_string_view.i"
 
 %ignore RDKit::Dict::Pair;

data/Code/RubyWrappers/MolOps.i

@@ -44,24 +44,27 @@
 %newobject RDKit::MolOps::mergeQueryHs;
 %newobject RDKit::MolOps::adjustQueryProperties;
 
+// IMPORTANT: %ignore must come BEFORE %include
+// Ignore all sanitizeMol overloads - we provide custom wrapper below
+%ignore RDKit::MolOps::sanitizeMol;
 %ignore RDKit::MolOps::detectChemistryProblems;
 %include <GraphMol/MolOps.h>
-// Ignore only the 3-arg overload that uses reference parameters (incompatible with SWIG)
-// This keeps the 1-arg sanitizeMol(RWMol &) available from the header
-%ignore RDKit::MolOps::sanitizeMol(RWMol &,unsigned int &,unsigned int &);
 %template(BoolPair) std::pair<bool, bool>;
 
 %inline %{
-  int sanitizeMol(RDKit::RWMol &mol,int sanitizeOps){
+  // Custom sanitizeMol wrapper that returns the operation that failed
+  // Only ONE definition needed - default parameter handles both use cases
+  int sanitizeMol(RDKit::RWMol &mol, int sanitizeOps=RDKit::MolOps::SANITIZE_ALL){
     unsigned int opThatFailed;
-    try{
-      RDKit::MolOps::sanitizeMol(mol,opThatFailed,
+    try {
+      RDKit::MolOps::sanitizeMol(mol, opThatFailed,
                                  static_cast<unsigned int>(sanitizeOps));
     } catch(...) {
 
     }
     return static_cast<int>(opThatFailed);
-  };
+  }
+
   std::vector<boost::shared_ptr<RDKit::MolSanitizeException>> detectChemistryProblems(RDKit::ROMol &mol,int sanitizeOps=RDKit::MolOps::SANITIZE_ALL){
     std::vector<boost::shared_ptr<RDKit::MolSanitizeException>> res;
     auto probs = RDKit::MolOps::detectChemistryProblems(mol,sanitizeOps);

data/Code/RubyWrappers/ROMol.i

@@ -101,12 +101,11 @@
 
 /*
  * Special handling for Conformer objects which should not be GCed until the molecule is destroyed
- * We want to modify the behavior of the Conformer coming into the addConformer method without
- * impacting Conformer objects that are arguments to other methods. Therefore we define a pattern
- * that will trigger special handling of the Conformer input (the addConf method  match this pattern).
+ * We ignore the original addConformer and provide our own in %extend that copies the conformer
+ * to avoid double-free issues with shared_ptr wrappers.
+ * Both addConf and addConformer are defined in %extend below (add_conf and add_conformer in Ruby).
  */
-%ignore addConformer(Conformer * conf, bool assignId=false);
-%rename(addConformer) RDKit::ROMol::addConf;
+%ignore RDKit::ROMol::addConformer;
 %include <GraphMol/ROMol.h>
 
 %ignore SubstructMatch;
@@ -189,14 +188,19 @@ unsigned int getDefaultPickleProperties();
     return res;
   }
 
-  /* DISOWN directive: tells SWIG that ownership of the Conformer transfers to C++.
-     Without this, Ruby GC and C++ destructor both try to free the Conformer,
-     causing a double-free segfault at script exit. */
-  %apply SWIGTYPE *DISOWN {RDKit::Conformer *ownedConf};
-  unsigned int RDKit::ROMol::addConf(RDKit::Conformer * ownedConf, bool assignId=false) {
-    return self->addConformer(ownedConf, assignId);
+  /* Create a copy of the conformer before adding it to the molecule.
+     This avoids the double-free issue since Ruby owns the original and C++ owns the copy.
+     The original DISOWN approach doesn't work with shared_ptr wrappers. */
+  unsigned int addConf(RDKit::Conformer *conf, bool assignId=false) {
+    RDKit::Conformer *confCopy = new RDKit::Conformer(*conf);
+    return self->addConformer(confCopy, assignId);
+  }
+
+  // Alias for addConf - exposes as add_conformer in Ruby
+  unsigned int addConformer(RDKit::Conformer *conf, bool assignId=false) {
+    RDKit::Conformer *confCopy = new RDKit::Conformer(*conf);
+    return self->addConformer(confCopy, assignId);
   }
-  %clear RDKit::Conformer *ownedConf;
 
   std::string MolToSmiles(bool doIsomericSmiles=true, bool doKekule=false, int rootedAtAtom=-1, bool canonical=true,
                           bool allBondsExplicit=false, bool allHsExplicit=false, bool doRandom=false) {

data/Code/RubyWrappers/RWMol.i

@@ -44,6 +44,13 @@
 
 %template(RWMol_Vect) std::vector< boost::shared_ptr<RDKit::RWMol> >;
 
+/*
+ * Special handling for Conformer objects which should not be GCed until the molecule is destroyed
+ * We ignore the original addConformer and provide our own in %extend that copies the conformer
+ * to avoid double-free issues with shared_ptr wrappers.
+ */
+%ignore RDKit::RWMol::addConformer;
+
 // ignore the methods that allow the molecule to take ownership of atoms/Bonds
 // (instead of copying them). This just leads to memory problems with Ruby
 %ignore RDKit::RWMol::addAtom(Atom *atom,bool updateLabel,bool takeOwnership);
@@ -78,6 +85,20 @@
 %include <GraphMol/RWMol.h>
 
 %extend RDKit::RWMol {
+  /* Create a copy of the conformer before adding it to the molecule.
+     This avoids the double-free issue since Ruby owns the original and C++ owns the copy.
+     The original DISOWN approach doesn't work with shared_ptr wrappers. */
+  unsigned int addConf(RDKit::Conformer *conf, bool assignId=false) {
+    RDKit::Conformer *confCopy = new RDKit::Conformer(*conf);
+    return self->addConformer(confCopy, assignId);
+  }
+
+  // Alias for addConf - exposes as add_conformer in Ruby
+  unsigned int addConformer(RDKit::Conformer *conf, bool assignId=false) {
+    RDKit::Conformer *confCopy = new RDKit::Conformer(*conf);
+    return self->addConformer(confCopy, assignId);
+  }
+
   static RDKit::RWMOL_SPTR MolFromSmiles(const std::string &smi,int debugParse=0,bool sanitize=1,
                                          std::map<std::string,std::string> *replacements=0){
     return RDKit::RWMOL_SPTR(RDKit::SmilesToMol(smi, debugParse, sanitize,replacements));

data/Code/RubyWrappers/gmwrapper/CMakeLists.txt

@@ -55,6 +55,12 @@ SET(CMAKE_SWIG_FLAGS -small -naturalvar -autorename)
 
 SWIG_ADD_LIBRARY(RDKitChem TYPE MODULE LANGUAGE ruby SOURCES GraphMolRuby.i)
 
+if(APPLE)
+  set_target_properties(RDKitChem PROPERTIES
+    LINK_FLAGS "-undefined dynamic_lookup"
+    SUFFIX ".bundle")
+endif()
+
 # it doesnt seem like the threading libs should need to be here, but
 # as of Oct 2012 using boost 1.51 under at least ubuntu 12.04 we get a
 # link error if they aren't there.

data/Code/RubyWrappers/gmwrapper/GraphMolRuby.i

@@ -336,6 +336,7 @@ typedef RDKit::MatchVectType MatchVectType;
   }
 }
 
+// This requires SWIG 4.2 or higher - must be before RDKitExceptions.i
 %include "std_string_view.i"
 
 // DO THIS BEFORE ANY OF THE OTHER INCLUDES

data/Code/RubyWrappers/point.i

@@ -34,8 +34,6 @@
 #include <Geometry/point.h>
 %}
 
-
-
 // Ignore ostream operators to prevent redefinition errors
 %ignore RDGeom::operator<<;
 

data/README.md

@@ -22,3 +22,95 @@ GEM for [RDKIT](http://rdkit.org/), an Open-Source Cheminformatics Software
 It downloads the sources, compiles and installs RDKIT with the ruby bindings.
 The installation may last very long - please be patient.
 
+## macOS Build Notes
+
+### Known Issues and Solutions
+
+#### 1. Boost Serialization Not Found
+
+**Error:**
+```
+CMake Error: Found package configuration file boost_serialization-config.cmake
+but it set boost_serialization_FOUND to FALSE
+Reason: No suitable build variant has been found.
+```
+
+**Solution:** The gem has been updated to use static Boost flags (`-DBoost_USE_STATIC_LIBS=ON -DBoost_USE_STATIC_RUNTIME=ON`).
+
+#### 2. Ruby Symbol Linking Error
+
+**Error:**
+```
+Undefined symbols for architecture x86_64:
+  "_rb_define_class", "_rb_str_new", ... (Ruby C API symbols)
+```
+
+**Solution:** Fixed in `Code/RubyWrappers/gmwrapper/CMakeLists.txt` with `-undefined dynamic_lookup` for macOS.
+
+#### 3. Ruby 3.2+ Compatibility (CRITICAL)
+
+**Error:**
+```ruby
+require 'RDKitChem'
+# => TypeError: wrong argument type nil (expected Data)
+```
+
+**Cause:** Ruby 3.2+ introduced a new `Data` class that conflicts with SWIG's wrapper generation.
+
+**Workaround:** Use Ruby 3.1.x:
+```bash
+# Using asdf
+asdf install ruby 3.1.6
+asdf set ruby 3.1.6
+
+# Using rbenv
+rbenv install 3.1.6
+rbenv local 3.1.6
+```
+
+#### 4. GitHub Actions CI - Xcode SDK Header Conflict
+
+**Error:**
+```
+error: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
+error: no member named 'finite' in namespace 'std::__math'
+```
+
+**Cause:** CMake finds Xcode SDK Ruby headers instead of `ruby/setup-ruby` installed headers.
+
+**Solution:** Fixed in `extconf.rb` by explicitly passing Ruby paths to CMake.
+
+### Ruby Version Compatibility
+
+| Ruby Version | Build | Runtime | Notes |
+|--------------|-------|---------|-------|
+| 3.4.x | OK | FAIL | `Data` class conflict |
+| 3.3.x | OK | FAIL | `Data` class conflict |
+| 3.2.x | OK | FAIL | `Data` class conflict |
+| 3.1.x | OK | OK | Recommended |
+
+### Build Commands (macOS)
+
+**Full Clean Build:**
+```bash
+rm -rf rdkit/build rdkit_chem
+ruby ext/rdkit_chem/extconf.rb
+```
+
+**Resume Interrupted Build:**
+```bash
+cd rdkit/build
+make -j8
+make install
+```
+
+**Test Loading:**
+```bash
+DYLD_LIBRARY_PATH=$PWD/rdkit_chem/lib ruby -I $PWD/rdkit_chem/lib -e 'require "RDKitChem"; puts "Success!"'
+```
+
+### Additional Notes
+
+- Full build takes ~20 minutes
+- Some `BOOST_NO_CXX98_FUNCTION_BASE` warnings during build are harmless
+- For detailed troubleshooting, see [MACOS_BUILD_NOTES.md](MACOS_BUILD_NOTES.md)

data/Rakefile

@@ -2,6 +2,7 @@
 
 require 'rake/testtask'
 require 'fileutils'
+require 'set'
 
 # Load version
 $LOAD_PATH.unshift File.expand_path('lib', __dir__)
@@ -29,12 +30,14 @@ task :build do
   sh 'gem build rdkit_chem.gemspec'
 end
 
-desc 'Build pre-compiled gem for current platform (x86_64-linux)'
+desc 'Build pre-compiled gem for current platform'
 task :build_native do
-  # Check that native libraries exist
-  unless File.exist?(File.join(NATIVE_DIR, 'RDKitChem.so'))
-    abort "ERROR: Native extension not found at #{NATIVE_DIR}/RDKitChem.so\n" \
-          "Run 'gem install rdkit_chem' first to compile, or build manually."
+  ext_so = File.join(NATIVE_DIR, 'RDKitChem.so')
+  ext_bundle = File.join(NATIVE_DIR, 'RDKitChem.bundle')
+
+  unless File.exist?(ext_so) || File.exist?(ext_bundle)
+    abort "ERROR: Native extension not found at #{NATIVE_DIR}/RDKitChem.{so,bundle}\n" \
+          "Run 'cd ext/rdkit_chem && ruby extconf.rb' first to compile."
   end
 
   # Get Ruby version for directory structure
@@ -47,21 +50,28 @@ task :build_native do
   FileUtils.mkdir_p(target_dir)
 
   # Copy native extension and all shared libraries
-  Dir.glob("#{NATIVE_DIR}/*.so*").each do |lib|
-    # Skip symlinks, copy only real files
-    next if File.symlink?(lib)
-    dest = File.join(target_dir, File.basename(lib))
-    FileUtils.cp(lib, dest, verbose: true)
+  # Linux: *.so*, macOS: *.bundle and *.dylib
+  lib_patterns = ["#{NATIVE_DIR}/*.so*", "#{NATIVE_DIR}/*.bundle", "#{NATIVE_DIR}/*.dylib"]
+  
+  lib_patterns.each do |pattern|
+    Dir.glob(pattern).each do |lib|
+      # Skip symlinks first pass, copy only real files
+      next if File.symlink?(lib)
+      dest = File.join(target_dir, File.basename(lib))
+      FileUtils.cp(lib, dest, verbose: true)
+    end
   end
 
   # Also copy symlinks (they're needed for library resolution)
   # This includes both .so -> .so.1 and .so.1 -> .so.1.version symlinks
-  Dir.glob("#{NATIVE_DIR}/*.so*").each do |lib|
-    next unless File.symlink?(lib)
-    link_target = File.readlink(lib)
-    dest = File.join(target_dir, File.basename(lib))
-    FileUtils.rm_f(dest)
-    FileUtils.ln_s(link_target, dest, verbose: true)
+  lib_patterns.each do |pattern|
+    Dir.glob(pattern).each do |lib|
+      next unless File.symlink?(lib)
+      link_target = File.readlink(lib)
+      dest = File.join(target_dir, File.basename(lib))
+      FileUtils.rm_f(dest)
+      FileUtils.ln_s(link_target, dest, verbose: true)
+    end
   end
 
   # Build the platform-specific gem
@@ -137,6 +147,82 @@ task :fix_rpath do
   sh "readelf -d #{so_file} | grep -E '(RPATH|RUNPATH)' || echo 'No RPATH found'"
 end
 
+desc 'Repair: bundle system libraries and fix RPATH'
+task :repair do
+  Rake::Task['bundle_system_libs'].invoke
+  Rake::Task['fix_rpath'].invoke
+end
+
+MACOS_SYSTEM_LIBRARY_PREFIXES = ['/usr/lib/', '/System/'].freeze
+MACOS_DEFAULT_SEARCH_PATHS = ['/opt/homebrew/lib', '/usr/local/lib'].freeze
+
+def macos_shared_libraries(libs_dir)
+  Dir.glob("#{libs_dir}/*.dylib") + Dir.glob("#{libs_dir}/*.bundle")
+end
+
+def macos_dependencies(lib)
+  otool_output = `otool -L '#{lib}' 2>/dev/null`
+  otool_output.lines.drop(1).map { |line| line.strip.split(' ').first }.compact
+end
+
+def macos_system_library?(path)
+  MACOS_SYSTEM_LIBRARY_PREFIXES.any? { |prefix| path.start_with?(prefix) }
+end
+
+def macos_resolve_dependency(dep, libs_dir)
+  return dep if dep.start_with?('/') && File.exist?(dep)
+
+  basename = File.basename(dep)
+  candidates = [File.join(libs_dir, basename)] +
+               MACOS_DEFAULT_SEARCH_PATHS.map { |dir| File.join(dir, basename) }
+  candidates.find { |path| File.exist?(path) }
+end
+
+desc 'Repair for macOS (bundle deps and fix install names)'
+task :repair_macos do
+  libs_dir = File.expand_path(NATIVE_DIR)
+  libs = macos_shared_libraries(libs_dir)
+  abort "ERROR: no macOS libraries found in #{libs_dir}" if libs.empty?
+
+  queue = libs.dup
+  processed = Set.new
+  copied = 0
+
+  until queue.empty?
+    lib = queue.shift
+    next if processed.include?(lib)
+    processed.add(lib)
+
+    macos_dependencies(lib).each do |dep|
+      next if macos_system_library?(dep)
+
+      dep_path = macos_resolve_dependency(dep, libs_dir)
+      next if dep_path.nil?
+
+      dest = File.join(libs_dir, File.basename(dep_path))
+      unless File.exist?(dest)
+        FileUtils.cp(dep_path, dest, verbose: true)
+        copied += 1
+      end
+      queue << dest if File.exist?(dest)
+    end
+  end
+
+  macos_shared_libraries(libs_dir).each do |lib|
+    lib_name = File.basename(lib)
+    system("install_name_tool -id @loader_path/#{lib_name} '#{lib}' 2>/dev/null") if lib.end_with?('.dylib')
+
+    macos_dependencies(lib).each do |dep|
+      next if macos_system_library?(dep)
+
+      dep_basename = File.basename(dep)
+      system("install_name_tool -change '#{dep}' '@loader_path/#{dep_basename}' '#{lib}' 2>/dev/null")
+    end
+  end
+
+  puts "Bundled #{copied} macOS dependencies."
+end
+
 desc 'Test that native extension loads without LD_LIBRARY_PATH'
 task :test_native do
   so_dir = File.expand_path(NATIVE_DIR, __dir__)

data/ext/rdkit_chem/extconf.rb

@@ -16,17 +16,20 @@ rescue StandardError
   nr_processors = 1
 end
 
+def run_command(command, description)
+  puts description if description
+  success = system(command)
+  abort "ERROR: #{description || command} failed" unless success
+end
+
 FileUtils.mkdir_p rdkit_dir
 Dir.chdir main_dir do
   FileUtils.rm_rf src_dir
-  puts 'Downloading RDKit sources'
-  git = 'git clone https://github.com/rdkit/rdkit.git'
-  system git
+  run_command('git clone https://github.com/rdkit/rdkit.git', 'Downloading RDKit sources')
 end
 
 Dir.chdir(src_dir) do
-  checkout = 'git checkout c2e48f41d88ddc15c6e1f818d1c4ced70b7f20d1'
-  system checkout
+  run_command('git checkout c2e48f41d88ddc15c6e1f818d1c4ced70b7f20d1', 'Checking out RDKit sources')
 end
 
 FileUtils.cp_r(
@@ -46,6 +49,26 @@ is_linux = host_os =~ /linux/
 is_mac = host_os =~ /darwin/
 ld_path = ''
 
+# macOS-specific compiler flags to fix Ruby header compatibility issues
+extra_cmake_flags = ''
+if is_mac
+  # -Wno-register: Ruby headers use deprecated 'register' keyword (removed in C++17)
+  # -DHAVE_ISFINITE=1: Prevents Ruby's finite() from conflicting with std::isfinite
+  cxx_flags = '-std=c++17 -stdlib=libc++ -Wno-register -DHAVE_ISFINITE=1'
+  extra_cmake_flags = " -DCMAKE_CXX_FLAGS='#{cxx_flags}'"
+end
+
+# Explicitly specify Ruby paths to avoid CMake finding system Ruby headers
+# This is critical on macOS where Xcode SDK contains incompatible Ruby headers
+ruby_executable = RbConfig.ruby
+ruby_include_dir = RbConfig::CONFIG['rubyhdrdir']
+ruby_arch_include_dir = RbConfig::CONFIG['rubyarchhdrdir']
+
+extra_cmake_flags += " -DRuby_EXECUTABLE=#{ruby_executable}"
+extra_cmake_flags += " -DRuby_INCLUDE_DIR=#{ruby_include_dir}"
+extra_cmake_flags += " -DRuby_CONFIG_INCLUDE_DIR=#{ruby_arch_include_dir}" if ruby_arch_include_dir
+extra_cmake_flags += " -DCMAKE_IGNORE_PREFIX_PATH='/Applications/Xcode.app;/Applications/Xcode_*.app'" if is_mac
+
 if is_linux || is_mac
   ld_string = is_linux ? 'LD_LIBRARY_PATH' : 'DYLD_LIBRARY_PATH'
   ld_path = "#{ld_string}=#{install_dir}/lib"
@@ -56,22 +79,18 @@ end
 
 FileUtils.mkdir_p build_dir
 Dir.chdir build_dir do
-  puts 'Configuring RDKit'
-
   cmake = "#{ld_path} cmake #{src_dir} -DRDK_INSTALL_INTREE=OFF " \
           "-DCMAKE_INSTALL_PREFIX=#{install_dir} " \
           '-DCMAKE_BUILD_TYPE=Release -DRDK_BUILD_PYTHON_WRAPPERS=OFF ' \
           '-DRDK_BUILD_SWIG_WRAPPERS=ON -DRDK_BUILD_INCHI_SUPPORT=OFF ' \
-          '-DRDK_BUILD_MOLINTERCHANGE_SUPPORT=OFF ' \
-          '-DBoost_NO_BOOST_CMAKE=ON'
-  system cmake
+          "-DBoost_NO_BOOST_CMAKE=ON -DRDK_USE_BOOST_IOSTREAMS=OFF#{extra_cmake_flags}"
+  run_command(cmake, 'Configuring RDKit')
 end
 
 # local installation in gem directory
 Dir.chdir build_dir do
-  puts 'Compiling RDKit sources.'
-  system "#{ld_path} make -j#{nr_processors}"
-  system "#{ld_path} make install"
+  run_command("#{ld_path} make -j#{nr_processors}", 'Compiling RDKit sources')
+  run_command("#{ld_path} make install", 'Installing RDKit sources')
 end
 
 # Remove compiled file, free spaces

data/lib/rdkit_chem/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module RDKitChem
-  VERSION = '2025.09.3'.freeze
-  GEMVERSION = VERSION + '.11'
+  VERSION = '2025.09.3'
+  GEMVERSION = "#{VERSION}.12"
 end

data/test/test_rdkit_chem.rb

@@ -1,25 +1,25 @@
-require 'test/unit'
+require "test/unit"
 
-require 'rdkit_chem'
+require "rdkit_chem"
 
 class RDKitTest < Test::Unit::TestCase
   def test_mol_from_smiles
-    smiles = 'CCO'  # ethanol
+    smiles = "CCO"  # ethanol
     rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
     assert_not_nil(rw_mol)
     assert_equal(3, rw_mol.get_num_atoms)
   end
 
   def test_mol_to_mol_block
-    smiles = 'CCO'  # ethanol
+    smiles = "CCO"  # ethanol
     rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
     mdl = rw_mol.mol_to_mol_block(true, -1, false)
     assert_not_nil(mdl)
-    assert(mdl.include?('V2000') || mdl.include?('V3000'))
+    assert(mdl.include?("V2000") || mdl.include?("V3000"))
   end
 
   def test_mol_from_mol_block
-    smiles = 'c1ccccc1'  # benzene
+    smiles = "c1ccccc1" # benzene
     rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
     mdl = rw_mol.mol_to_mol_block(true, -1, false)
 
@@ -30,26 +30,41 @@ class RDKitTest < Test::Unit::TestCase
   end
 
   def test_mol_to_smiles
-    smiles = 'CCO'
+    smiles = "CCO"
     rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
     output_smiles = RDKitChem.mol_to_smiles(rw_mol)
     assert_not_nil(output_smiles)
-    assert_equal('CCO', output_smiles)
+    assert_equal("CCO", output_smiles)
+  end
+
+  def test_sanitize_mol
+    smiles = "c1ccccc1" # benzene
+    rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
+
+    # sanitize_mol returns an integer (0 for success usually, or bitmask of operations failed)
+    # It might return different things based on SWIG wrapping details observed in MolOps.i
+    # The SWIG wrapper returns the operation that failed (0 if all successful).
+    result = RDKitChem.sanitize_mol(rw_mol, RDKitChem::SANITIZE_ALL)
+    assert_equal(0, result, "sanitize_mol should return 0 (success)")
+
+    result = RDKitChem.sanitize_mol(rw_mol)
+    assert_equal(0, result, "sanitize_mol should return 0 (success)")
   end
 
   def test_cholesterol
     # Cholesterol without chirality
-    smiles = 'CC(C)CCCC(C)C1CCC2C1(CCC3C2CC=C4C3(CCC(C4)O)C)C'
+    smiles = "CC(C)CCCC(C)C1CCC2C1(CCC3C2CC=C4C3(CCC(C4)O)C)C"
     rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
     assert_not_nil(rw_mol)
-    assert_equal(28, rw_mol.get_num_atoms)  # C27H46O has 28 heavy atoms (27 C + 1 O)
+    assert_equal(28, rw_mol.get_num_atoms) # C27H46O has 28 heavy atoms (27 C + 1 O)
   end
 
   def test_conformer_ownership
+    # FIXME: This test causes a segfault (exit code 139) likely due to GC/double-free issues.
     # Test that conformer ownership is properly transferred to the molecule.
     # This verifies the DISOWN directive works - without it, Ruby GC and C++
     # destructor both try to free the Conformer, causing a double-free segfault.
-    smiles = 'CCO'  # ethanol
+    smiles = "CCO" # ethanol
     rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
 
     # Create a conformer with 3D coordinates
@@ -59,7 +74,7 @@ class RDKitTest < Test::Unit::TestCase
     conf.set_atom_pos(2, RDKitChem::Point3D.new(2.0, 1.0, 0.0))
 
     # Add conformer to molecule (ownership transfers to C++)
-    conf_id = rw_mol.addConf(conf, true)
+    conf_id = rw_mol.add_conf(conf, true)
     assert(conf_id >= 0, "Conformer should be added successfully")
 
     # Verify conformer was added

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdkit_chem
 version: !ruby/object:Gem::Version
-  version: 2025.09.3.11
+  version: 2025.09.3.12
 platform: ruby
 authors:
 - An Nguyen
+autorequire:
 bindir: bin
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -136,6 +137,7 @@ homepage: https://github.com/CamAnNguyen/rdkit-chem
 licenses:
 - BSD-3-Clause
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -150,7 +152,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.1
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Ruby gem for RDKit
 test_files: