rdkit_chem 2025.09.3.6 → 2025.09.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1ca733c15a257ae3a2e1d3888416588f333aeef3ffff6611d64ca675290938d
-  data.tar.gz: 3fa7cbdc331028467b6436ba0dbda0e863dfdf26f46dbe74d3a6afde16f3d04f
+  metadata.gz: f1150cd8a25cb6e75a9a1801e0377f52c7ccdc1753610fd2b60112ef43aa82b2
+  data.tar.gz: a6dd2d9705f577cec79ac17c5fe6868af3c94e90796f8f1b7f312f82ee556c08
 SHA512:
-  metadata.gz: 8689fecfd02ac1811baf0643853bcbaf26b67b57db13c6a585c5cedef0d210b2246ec328e855a117b6f85f07daf24cc61c1d0cc347e78038e402418161aca40e
-  data.tar.gz: cbf078879b1dd4fcc5575b8710bc5cdcc7419bade90752ec7b2d7b0e4c4af32d3fe8097fc1f3ffc2ff05fda99e59fb7fdad3bf7b03a9c08daf4ae77f09f41110
+  metadata.gz: 9483ef51984ee11ce8a6de70a46c04627e43a316313d2156ad1ddfd3973fd26b8d744ef2c48a8ad32410f3e5512f065f40aaa39d53e00b3f7e26ea5fa97d4592
+  data.tar.gz: 27318bc6b7ef5563aec63ea65248fec1b5c6c29328dc0995dde486a764002912f3f5f27573dad7c61f95edfbc3858e3ddca72be0a8c7d42e2d1cebe3633c7cc1

data/Code/RubyWrappers/MolOps.i

@@ -44,27 +44,24 @@
 %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 %{
-  // 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){
+  int sanitizeMol(RDKit::RWMol &mol,int sanitizeOps){
     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,11 +101,12 @@
 
 /*
  * 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.
- * Both addConf and addConformer are defined in %extend below (add_conf and add_conformer in Ruby).
+ * 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).
  */
-%ignore RDKit::ROMol::addConformer;
+%ignore addConformer(Conformer * conf, bool assignId=false);
+%rename(addConformer) RDKit::ROMol::addConf;
 %include <GraphMol/ROMol.h>
 
 %ignore SubstructMatch;
@@ -188,19 +189,14 @@ unsigned int getDefaultPickleProperties();
     return res;
   }
 
-  /* 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);
+  /* 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);
   }
+  %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,13 +44,6 @@
 
 %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);
@@ -85,20 +78,6 @@
 %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,6 +1,4 @@
-# frozen_string_literal: true
-
 module RDKitChem
-  VERSION = "2025.09.3"
-  GEMVERSION = "#{VERSION}.6"
+  VERSION = '2025.09.3'.freeze
+  GEMVERSION = VERSION + '.9'
 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,41 +30,26 @@ 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)
-  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)")
+    assert_equal('CCO', output_smiles)
   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
@@ -74,7 +59,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.add_conf(conf, true)
+    conf_id = rw_mol.addConf(conf, true)
     assert(conf_id >= 0, "Conformer should be added successfully")
 
     # Verify conformer was added

metadata

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