rdkit_chem 2025.09.3.2 → 2025.09.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb84e9eb9b23425a697da1935d2a58fde15b5b184f9b0f0605340577f9296f16
-  data.tar.gz: 3ba3ea75e71cf6f86d82008d297a6409494a09e152b7049077245eb641626eaf
+  metadata.gz: 3ba77bf7020186b6859a9d6eff2eda271ca1853b5e022d09a97362b090db3685
+  data.tar.gz: fc8426cf986a9c7b38490bde57fd6db7080d8df22d6f7392242e0b263b7feae0
 SHA512:
-  metadata.gz: f2001ea207f0a2e4484595d27ce3fe5f74d2e0acbf3b58caf204169a09b928542fccabf544a424653175af1e272b73378eaac81db962b26b8ff1ece82219bd43
-  data.tar.gz: 5c859291de10e2a2355068b3d57619d7e56e3c248c607b3df413d46f4e9fd29437bfc5cc1914fbb70e2daa319da2889b790b2a205c6087a2ebdaf1faffcb6cdd
+  metadata.gz: 3f245fe05a0d011ee1e2a4e80bce87f3cb4b629016671b49db3c83b234b34366af3d04533f501336b4b84dcd92b108c571925d43d3b79023bbcda53d376b563c
+  data.tar.gz: 7242f4eb9d2bb13f127277612de7f3ccb0265e7c97a2e3cc383aaf35e0a05d4a49df86780003ffe159b8bb0f180f6453d91f96290ed48a840f4de0c117bdc37a

data/Code/RubyWrappers/MolOps.i

@@ -44,23 +44,27 @@
 %newobject RDKit::MolOps::mergeQueryHs;
 %newobject RDKit::MolOps::adjustQueryProperties;
 
-%ignore RDKit::MolOps::detectChemistryProblems;
-// Ignore all native sanitizeMol overloads - we provide a custom wrapper below
+// 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>
 %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,
+      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,9 +188,18 @@ unsigned int getDefaultPickleProperties();
     return res;
   }
 
-  /* Used in the addConformer modifications described above */
-  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);
   }
 
   std::string MolToSmiles(bool doIsomericSmiles=true, bool doKekule=false, int rootedAtAtom=-1, bool canonical=true,

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/ext/rdkit_chem/extconf.rb

@@ -16,13 +16,13 @@ rescue StandardError
   nr_processors = 1
 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
-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
+# end
 
 Dir.chdir(src_dir) do
   checkout = 'git checkout c2e48f41d88ddc15c6e1f818d1c4ced70b7f20d1'
@@ -74,7 +74,7 @@ Dir.chdir build_dir do
 end
 
 # Remove compiled file, free spaces
-FileUtils.remove_dir(rdkit_dir)
+# FileUtils.remove_dir(rdkit_dir)
 
 # create a fake Makefile
 File.open(File.join(File.dirname(__FILE__), 'Makefile'), 'w+') do |makefile|

data/lib/rdkit_chem/version.rb

@@ -1,4 +1,6 @@
+# frozen_string_literal: true
+
 module RDKitChem
-  VERSION = '2025.09.3'.freeze
-  GEMVERSION = VERSION + '.2'
+  VERSION = "2025.09.3"
+  GEMVERSION = "#{VERSION}.5"
 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,18 +30,70 @@ 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
+    rw_mol = RDKitChem::RWMol.mol_from_smiles(smiles)
+
+    # Create a conformer with 3D coordinates
+    conf = RDKitChem::Conformer.new(rw_mol.get_num_atoms)
+    conf.set_atom_pos(0, RDKitChem::Point3D.new(0.0, 0.0, 0.0))
+    conf.set_atom_pos(1, RDKitChem::Point3D.new(1.5, 0.0, 0.0))
+    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.add_conf(conf, true)
+    assert(conf_id >= 0, "Conformer should be added successfully")
+
+    # Verify conformer was added
+    assert_equal(1, rw_mol.get_num_conformers)
+
+    # Access the conformer through the molecule
+    retrieved_conf = rw_mol.get_conformer(conf_id)
+    assert_not_nil(retrieved_conf)
+
+    # Verify coordinates
+    pos = retrieved_conf.get_atom_pos(0)
+    assert_in_delta(0.0, pos.x, 0.001)
+    assert_in_delta(0.0, pos.y, 0.001)
+    assert_in_delta(0.0, pos.z, 0.001)
+
+    # Force garbage collection to ensure no double-free occurs
+    GC.start
+
+    # The molecule should still be valid after GC
+    assert_equal(3, rw_mol.get_num_atoms)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdkit_chem
 version: !ruby/object:Gem::Version
-  version: 2025.09.3.2
+  version: 2025.09.3.5
 platform: ruby
 authors:
 - An Nguyen