rdkit_chem 2019.03.3.1 → 2025.09.3.2

data/Code/RubyWrappers/RWMol.i

@@ -0,0 +1,241 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/RWMol.h>
+#include <GraphMol/SmilesParse/SmilesParse.h>
+#include <GraphMol/SmilesParse/SmilesWrite.h>
+#include <GraphMol/FileParsers/FileParsers.h>
+#include <GraphMol/FileParsers/CDXMLParser.h>
+#include <GraphMol/FileParsers/SequenceParsers.h>
+#include <GraphMol/Bond.h>
+#include <GraphMol/FileParsers/MolFileStereochem.h>
+%}
+
+%template(RWMol_Vect) std::vector< boost::shared_ptr<RDKit::RWMol> >;
+
+// 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);
+%ignore RDKit::RWMol::addBond(Bond *bond,bool takeOwnership);
+
+%newobject RDKit::v1::SmilesToMol;
+%newobject RDKit::v1::SmartsToMol;
+%newobject RDKit::v1::MolBlockToMol;
+%newobject RDKit::v1::MolFileToMol;
+
+%shared_ptr(RDKit::RWMol)
+
+%ignore RDKit::v2::SmilesParse;
+
+%ignore RDKit::v1::CDXMLDataStreamToMols;
+%ignore RDKit::v1::CDXMLFileToMols;
+%ignore RDKit::v1::CDXMLToMols;
+
+%ignore RDKit::v2::CDXMLParser::MolsFromCDXMLDataStream;
+%ignore RDKit::v2::CDXMLParser::MolsFromCDXML;
+%ignore RDKit::v2::CDXMLParser::MolsFromCDXMLFile;
+%ignore *::MolsFromCDXMLDataStream;
+
+// Ignore strip utility function to avoid conflict with MolHash::Strip
+%ignore RDKit::strip;
+
+%include <GraphMol/FileParsers/FileParsers.h>
+%include <GraphMol/FileParsers/CDXMLParser.h>
+%include <GraphMol/SmilesParse/SmilesParse.h>
+
+
+%include <GraphMol/RWMol.h>
+
+%extend RDKit::RWMol {
+  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));
+  }
+  static RDKit::RWMOL_SPTR MolFromSmiles(const std::string &smi, const RDKit::v1::SmilesParserParams &params){
+    return RDKit::RWMOL_SPTR(RDKit::SmilesToMol(smi, params));
+  }
+  static RDKit::RWMOL_SPTR MolFromSmarts(const std::string &sma,int debugParse=0,bool mergeHs=false,
+                                         std::map<std::string,std::string> *replacements=0){
+    return RDKit::RWMOL_SPTR(RDKit::SmartsToMol(sma, debugParse, mergeHs,replacements));
+  }
+static RDKit::RWMOL_SPTR MolFromMolBlock(const std::string &molB,
+                                  bool sanitize=true,bool removeHs=true,bool strictParsing=true){
+  RDKit::RWMol *mol=RDKit::MolBlockToMol(molB,sanitize,removeHs,strictParsing);
+  return RDKit::RWMOL_SPTR(mol);
+}
+static RDKit::RWMOL_SPTR MolFromMolFile(const std::string &filename,
+                                 bool sanitize=true,bool removeHs=true,bool strictParsing=true){
+  RDKit::RWMol *mol=RDKit::MolFileToMol(filename,sanitize,removeHs,strictParsing);
+  return RDKit::RWMOL_SPTR(mol);
+}
+static RDKit::RWMOL_SPTR MolFromTPLFile(const std::string &fName,bool sanitize=true,
+                      bool skipFirstConf=false) {
+  RDKit::RWMol *mol=0;
+    mol=RDKit::TPLFileToMol(fName, sanitize, skipFirstConf);
+  return RDKit::RWMOL_SPTR(mol);
+}
+static RDKit::RWMOL_SPTR MolFromMol2File(const std::string &fName,bool sanitize=true,bool removeHs=true,
+                       RDKit::Mol2Type variant=RDKit::Mol2Type::CORINA, bool cleanupSubstructures=true) {
+  RDKit::RWMol *mol=0;
+  mol=RDKit::Mol2FileToMol(fName, sanitize, removeHs, variant, cleanupSubstructures);
+  return RDKit::RWMOL_SPTR(mol);
+}
+static RDKit::RWMOL_SPTR MolFromMol2Block(const std::string &molBlock,bool sanitize=true,bool removeHs=true,
+                        RDKit::Mol2Type variant=RDKit::Mol2Type::CORINA, bool cleanupSubstructures=true) {
+  RDKit::RWMol *mol=0;
+    mol=RDKit::Mol2BlockToMol(molBlock, sanitize, removeHs, variant, cleanupSubstructures);
+  return RDKit::RWMOL_SPTR(mol);
+}
+
+static RDKit::RWMOL_SPTR MolFromPDBBlock(const std::string &molB,
+                                         bool sanitize=true,bool removeHs=true,
+                                         unsigned int flavor=0,bool proximityBonding=true){
+  RDKit::RWMol *mol=0;
+  mol=RDKit::PDBBlockToMol(molB,sanitize,removeHs,flavor,proximityBonding);
+  return RDKit::RWMOL_SPTR(mol);
+}
+
+static RDKit::RWMOL_SPTR MolFromPDBFile(const std::string &fName,
+                                        bool sanitize=true,bool removeHs=true,
+                                        unsigned int flavor=0,bool proximityBonding=true){
+  RDKit::RWMol *mol=0;
+  mol=RDKit::PDBFileToMol(fName,sanitize,removeHs,flavor,proximityBonding);
+  return RDKit::RWMOL_SPTR(mol);
+}
+static RDKit::RWMOL_SPTR MolFromSequence(const std::string &text,
+                                  bool sanitize=true,int flavor=0){
+  RDKit::RWMol *mol=0;
+  mol=RDKit::SequenceToMol(text,sanitize,flavor);
+  return RDKit::RWMOL_SPTR(mol);
+}
+static RDKit::RWMOL_SPTR MolFromFASTA(const std::string &text,
+                                  bool sanitize=true,int flavor=0){
+  RDKit::RWMol *mol=0;
+  mol=RDKit::FASTAToMol(text,sanitize,flavor);
+  return RDKit::RWMOL_SPTR(mol);
+}
+static RDKit::RWMOL_SPTR MolFromHELM(const std::string &text,
+                                  bool sanitize=true){
+  RDKit::RWMol *mol=0;
+  mol=RDKit::HELMToMol(text,sanitize);
+  return RDKit::RWMOL_SPTR(mol);
+}
+
+static std::vector<RDKit::RWMOL_SPTR> MolsFromCDXML(const std::string &text,
+						    bool sanitize=true, bool removeHs=true){
+  auto res = RDKit::CDXMLToMols(text, sanitize, removeHs);
+  std::vector<RDKit::RWMOL_SPTR> mols;
+  for(auto &mol: res) {
+    mols.emplace_back(mol.release());
+  }
+  return mols;
+
+}
+
+static std::vector<RDKit::RWMOL_SPTR>  MolsFromCDXML(
+     const std::vector<unsigned char> &text, bool sanitize=true, bool removeHs=true) {
+    std::string str(text.begin(), text.end());
+    RDKit::v2::CDXMLParser::CDXMLParserParams params;
+    params.sanitize=sanitize;
+    params.removeHs=removeHs;
+    auto res = RDKit::v2::CDXMLParser::MolsFromCDXML(str, params);
+    std::vector<RDKit::RWMOL_SPTR> mols;
+    for(auto &mol: res) {
+      mols.emplace_back(mol.release());
+    }
+    return mols;
+}
+
+static std::vector<RDKit::RWMOL_SPTR> MolsFromCDXML(
+ const std::string &text,
+ const RDKit::v2::CDXMLParser::CDXMLParserParams &params=RDKit::v2::CDXMLParser::CDXMLParserParams()) {
+  auto res = RDKit::v2::CDXMLParser::MolsFromCDXML(text, params);
+  std::vector<RDKit::RWMOL_SPTR> mols;
+  for(auto &mol: res) {
+    mols.emplace_back(mol.release());
+  }
+  return mols;
+
+}
+
+static std::vector<RDKit::RWMOL_SPTR> MolsFromCDXMLFile(
+ const std::string &filename,
+ const RDKit::v2::CDXMLParser::CDXMLParserParams &params=RDKit::v2::CDXMLParser::CDXMLParserParams()) {
+  auto res = RDKit::v2::CDXMLParser::MolsFromCDXMLFile(filename, params);
+  std::vector<RDKit::RWMOL_SPTR> mols;
+  for(auto &mol: res) {
+    mols.emplace_back(mol.release());
+  }
+  return mols;
+}
+
+static RDKit::ROMOL_SPTR toROMol(RDKit::RWMOL_SPTR target) {
+  return RDKit::ROMOL_SPTR(target);
+}
+
+/* Methods from MolFileStereoChem.h */
+void DetectAtomStereoChemistry(const RDKit::Conformer *conf) {
+  RDKit::DetectAtomStereoChemistry(*($self), conf);
+}
+void DetectBondStereoChemistry(const RDKit::Conformer *conf) {
+  RDKit::DetectBondStereoChemistry(*($self), conf);
+}
+void ClearSingleBondDirFlags(bool onlyWedgeFlags=false) {
+ RDKit::MolOps::clearSingleBondDirFlags(*($self), onlyWedgeFlags);
+};
+void reapplyMolBlockWedging() {
+  RDKit::Chirality::reapplyMolBlockWedging(*($self));
+}
+void clearMolBlockWedgingInfo() {
+  RDKit::Chirality::clearMolBlockWedgingInfo(*($self));
+}
+void invertMolBlockWedgingInfo() {
+  RDKit::Chirality::invertMolBlockWedgingInfo(*($self));
+}
+void markUnspecifiedStereoAsUnknown(int confId) {
+  RDKit::markUnspecifiedStereoAsUnknown(*($self), confId);
+}
+
+/* From Kekulize.cpp, MolOps.h */
+void Kekulize(bool markAtomsBonds=true, unsigned int maxBackTracks=100) {
+  RDKit::MolOps::Kekulize(*($self), markAtomsBonds, maxBackTracks);
+}
+
+/* MolOps.h */
+// Renamed to sanitize() to avoid conflict with standalone sanitizeMol in MolOps.i
+void sanitize() {
+  RDKit::MolOps::sanitizeMol(*($self));
+}
+
+}

data/Code/RubyWrappers/RascalMCES.i

@@ -0,0 +1,71 @@
+/*
+*
+*  Copyright (C) 2020 Gareth Jones, Glysade LLC
+*
+*   @@ All Rights Reserved @@
+*  This file is part of the RDKit.
+*  The contents are covered by the terms of the BSD license
+*  which is included in the file license.txt, found at the root
+*  of the RDKit source tree.
+*
+*/
+
+%include "std_vector.i"
+
+%{
+#include <GraphMol/RascalMCES/RascalClusterOptions.h>
+#include <GraphMol/RascalMCES/RascalOptions.h>
+#include <GraphMol/RascalMCES/RascalResult.h>
+#include <GraphMol/RascalMCES/RascalMCES.h>
+%}
+
+
+
+%include <GraphMol/RascalMCES/RascalClusterOptions.h>
+%include <GraphMol/RascalMCES/RascalOptions.h>
+%ignore RDKit::RascalMCES::RascalResult::getMcesMol;
+%include <GraphMol/RascalMCES/RascalResult.h>
+%ignore RDKit::RascalMCES::rascalCluster;
+%ignore RDKit::RascalMCES::rascalButinaCluster;
+%include <GraphMol/RascalMCES/RascalMCES.h>
+// RascalResult_Vect removed - RascalResult lacks default constructor required by std::vector operations
+// %ignore std::vector<RDKit::RascalMCES::RascalResult>::equals;
+// %ignore std::vector<RDKit::RascalMCES::RascalResult>::vector(size_type);
+// %template(RascalResult_Vect) std::vector<RDKit::RascalMCES::RascalResult>;
+%template(Unsigned_Vect_Vect) std::vector<std::vector<unsigned int>>;
+
+// The Rascal code uses std::shared_ptr rather than boost::shared_ptr
+
+%extend RDKit::RascalMCES::RascalResult {
+	RDKit::ROMol *getMCESMol() {
+		auto shared_ptr = ($self)->getMcesMol();
+		return shared_ptr.get();
+	}
+}
+
+%inline %{
+	namespace RDKit {
+		namespace RascalMCES {
+		   class RascalApp {
+		   };
+		}
+	}
+%}
+
+
+%extend RDKit::RascalMCES::RascalApp {
+    static std::vector<std::vector<unsigned int> > RascalCluster(const std::vector<boost::shared_ptr<RDKit::ROMol> >& mols, const RDKit::RascalMCES::RascalClusterOptions& clusterOptions=RascalClusterOptions()) {
+		std::vector<std::shared_ptr<RDKit::ROMol> > rascalMolecules;
+		for (auto molIn: mols) {
+			rascalMolecules.emplace_back(new RDKit::ROMol(*molIn));
+		}
+		return RDKit::RascalMCES::rascalCluster(rascalMolecules, clusterOptions);
+	}
+    static std::vector<std::vector<unsigned int> > RascalButinaCluster(const std::vector<boost::shared_ptr<RDKit::ROMol> >& mols, const RDKit::RascalMCES::RascalClusterOptions& clusterOptions=RascalClusterOptions()) {
+		std::vector<std::shared_ptr<RDKit::ROMol> > rascalMolecules;
+		for (auto molIn: mols) {
+			rascalMolecules.emplace_back(new RDKit::ROMol(*molIn));
+		}
+		return RDKit::RascalMCES::rascalButinaCluster(rascalMolecules, clusterOptions);
+	}
+}

data/Code/RubyWrappers/ReactionFingerprints.i

@@ -0,0 +1,37 @@
+/*
+*  Copyright (c) 2018 Greg Landrum
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <DataStructs/ExplicitBitVect.h>
+#include <DataStructs/BitOps.h>
+#include <GraphMol/ChemReactions/ReactionFingerprints.h>
+%}
+
+%newobject RDKit::StructuralFingerprintChemReaction;
+%newobject RDKit::DifferenceFingerprintChemReaction;
+%include <GraphMol/ChemReactions/ReactionFingerprints.h>

data/Code/RubyWrappers/RingInfo.i

@@ -0,0 +1,40 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <map>
+#include <vector>
+#include <GraphMol/RingInfo.h>
+%}
+
+%include <GraphMol/RingInfo.h>

data/Code/RubyWrappers/Rings.i

@@ -0,0 +1,40 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/Rings.h>
+%}
+
+%template(Int_Int_Vect_Map) std::map< int, std::vector<int> > ;
+
+%include <GraphMol/Rings.h>

data/Code/RubyWrappers/SanitException.i

@@ -0,0 +1,100 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/SanitException.h>
+%}
+
+%include <GraphMol/SanitException.h>
+/* #ifdef SWIGRUBY */
+
+// support upcasting from MolSanitizeException to the other exception types so that
+// we can do something with the output of detectChemistryProblems()
+
+%exception RDKit::AtomSanitizeException::dynamic_cast(RDKit::MolSanitizeException) {
+  $action
+    if(!result) {
+      static VALUE cpperror = rb_define_class("CPPError", rb_eRuntimeError);
+      rb_raise(cpperror, "dynamic_cast exception")
+    }
+}
+
+%extend RDKit::AtomSanitizeException {
+  static RDKit::AtomSanitizeException *dynamic_cast(RDKit::MolSanitizeException *mse){
+    return dynamic_cast<RDKit::AtomSanitizeException *>(mse);
+  }
+};
+
+%exception RDKit::AtomValenceException::dynamic_cast(RDKit::MolSanitizeException) {
+  $action
+    if(!result) {
+      static VALUE cpperror = rb_define_class("CPPError", rb_eRuntimeError);
+      rb_raise(cpperror, "dynamic_cast exception")
+    }
+}
+
+%extend RDKit::AtomValenceException {
+    static RDKit::AtomValenceException *dynamic_cast(RDKit::MolSanitizeException *mse){
+        return dynamic_cast<RDKit::AtomValenceException *>(mse);
+    }
+};
+
+
+%exception RDKit::AtomKekulizeException::dynamic_cast(RDKit::MolSanitizeException) {
+  $action
+    if(!result) {
+      static VALUE cpperror = rb_define_class("CPPError", rb_eRuntimeError);
+      rb_raise(cpperror, "dynamic_cast exception")
+    }
+ }
+
+%extend RDKit::AtomKekulizeException {
+    static RDKit::AtomKekulizeException *dynamic_cast(RDKit::MolSanitizeException *mse){
+        return dynamic_cast<RDKit::AtomKekulizeException *>(mse);
+    }
+};
+
+%exception RDKit::KekulizeException::dynamic_cast(RDKit::MolSanitizeException) {
+  $action
+    if(!result) {
+      static VALUE cpperror = rb_define_class("CPPError", rb_eRuntimeError);
+      rb_raise(cpperror, "dynamic_cast exception")
+    }
+}
+
+%extend RDKit::KekulizeException {
+    static RDKit::KekulizeException *dynamic_cast(RDKit::MolSanitizeException *mse){
+        return dynamic_cast<RDKit::KekulizeException *>(mse);
+    }
+};
+/* #endif */

data/Code/RubyWrappers/ScaffoldNetwork.i

@@ -0,0 +1,28 @@
+/*
+*
+*  Copyright (c) 2019, Greg Landrum and T5 Informatics GmbH
+*  All rights reserved.
+*
+*  This file is part of the RDKit.
+*  The contents are covered by the terms of the BSD license
+*  which is included in the file license.txt, found at the root
+*  of the RDKit source tree.
+*
+*/
+%{
+#include <GraphMol/ScaffoldNetwork/ScaffoldNetwork.h>
+typedef std::vector<std::string> STR_VECT;
+typedef std::vector<unsigned> UINT_VECT;
+%}
+
+
+%template(ROMol_Vect) std::vector<boost::shared_ptr<RDKit::ROMol>>;
+%template(NetworkEdge_Vect) std::vector<RDKit::ScaffoldNetwork::NetworkEdge>;
+%include <GraphMol/ScaffoldNetwork/ScaffoldNetwork.h>
+%template(createScaffoldNetwork) RDKit::ScaffoldNetwork::createScaffoldNetwork<std::vector<boost::shared_ptr<RDKit::ROMol>>>;
+
+%extend RDKit::ScaffoldNetwork::ScaffoldNetwork {
+    unsigned int nodeCount(unsigned int nodeNumber) {
+        return $self->counts.at(nodeNumber);
+    }
+}

data/Code/RubyWrappers/SmartsWrite.i

@@ -0,0 +1,38 @@
+/* 
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+* 
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met: 
+*
+*     * Redistributions of source code must retain the above copyright 
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following 
+*       disclaimer in the documentation and/or other materials provided 
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc. 
+*       nor the names of its contributors may be used to endorse or promote 
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/SmilesParse/SmartsWrite.h>
+%}
+
+%include <GraphMol/SmilesParse/SmartsWrite.h>

data/Code/RubyWrappers/SmilesParse.i

@@ -0,0 +1,40 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/SmilesParse/SmilesParse.h>
+%}
+%ignore RDKit::v2;
+%ignore SmilesToMol;
+%ignore SmartsToMol;
+%include <GraphMol/SmilesParse/SmilesParse.h>

data/Code/RubyWrappers/SmilesWrite.i

@@ -0,0 +1,42 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2010, Novartis Institutes for BioMedical Research Inc.
+*  All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are
+* met:
+*
+*     * Redistributions of source code must retain the above copyright
+*       notice, this list of conditions and the following disclaimer.
+*     * Redistributions in binary form must reproduce the above
+*       copyright notice, this list of conditions and the following
+*       disclaimer in the documentation and/or other materials provided
+*       with the distribution.
+*     * Neither the name of Novartis Institutes for BioMedical Research Inc.
+*       nor the names of its contributors may be used to endorse or promote
+*       products derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+%{
+#include <GraphMol/SmilesParse/SmilesWrite.h>
+#include <GraphMol/SmilesParse/SmilesJSONParsers.h>
+%}
+
+%include <RDGeneral/BetterEnums.h>
+%ignore RDKit::SmilesWrite::detail::MolToSmiles;
+%include <GraphMol/SmilesParse/SmilesWrite.h>
+%include <GraphMol/SmilesParse/SmilesJSONParsers.h>