rdkit_chem 2019.03.3.1 → 2025.09.3.2

data/Code/RubyWrappers/BondIterators.i

@@ -0,0 +1,61 @@
+/* 
+* $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 "std_string.i"
+%include "std_vector.i"
+%include "std_map.i"
+%include "std_pair.i"
+
+%{
+#include <GraphMol/BondIterators.h>
+%}
+
+
+%rename(BondIterator) RDKit::BondIterator_;
+%rename(ConstBondIterator) RDKit::ConstBondIterator_;
+/* Equality testing operators have been overloaded, so we need to expose them in a different way */
+%rename(eq) RDKit::BondIterator_::operator==;
+%rename(ne) RDKit::BondIterator_::operator!=;
+%rename(eq) RDKit::ConstBondIterator_::operator==;
+%rename(ne) RDKit::ConstBondIterator_::operator!=;
+/* Increment and decrement operators currently necessary */
+%rename(next) RDKit::BondIterator_::operator++;
+%rename(next) RDKit::ConstBondIterator_::operator++;
+%rename(prev) RDKit::BondIterator_::operator--;
+%rename(prev) RDKit::ConstBondIterator_::operator--;
+/* A better name for the iterator's Bond object */
+%rename(getBond) RDKit::BondIterator_::operator*;
+%rename(getBond) RDKit::ConstBondIterator_::operator*; 
+
+%include <GraphMol/BondIterators.h>
+

data/Code/RubyWrappers/CMakeLists.txt

@@ -0,0 +1,67 @@
+find_package(SWIG 4.2 REQUIRED)
+include(${SWIG_USE_FILE})
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
+include_directories(${RDKit_CodeDir})
+include_directories(${Boost_INCLUDE_DIRS})
+
+SET(CMAKE_SWIG_FLAGS "")
+
+
+set(swigRDKitLibSuffix "")
+if(RDK_SWIG_STATIC AND ((NOT MSVC) OR (MSVC AND RDK_INSTALL_DLLS_MSVC)))
+  set(swigRDKitLibSuffix "_static")
+endif()
+set(swigRDKitLibList "")
+if(RDK_BUILD_AVALON_SUPPORT)
+  set(swigRDKitLibList "${swigRDKitLibList}AvalonLib;avalon_clib;")
+endif(RDK_BUILD_AVALON_SUPPORT)
+if(RDK_BUILD_INCHI_SUPPORT)
+  set(swigRDKitLibList "${swigRDKitLibList}RDInchiLib;${INCHI_LIBRARIES};")
+endif(RDK_BUILD_INCHI_SUPPORT)
+set(swigRDKitLibList "${swigRDKitLibList}"
+  "ScaffoldNetwork;MolHash;RGroupDecomposition;SubstructLibrary;"
+  "MolStandardize;FilterCatalog;Catalogs;FMCS;MolDraw2D;FileParsers;SmilesParse;"
+  "Depictor;SubstructMatch;ChemReactions;Fingerprints;ChemTransforms;"
+  "Subgraphs;GraphMol;DataStructs;Trajectory;Descriptors;"
+  "PartialCharges;MolTransforms;DistGeomHelpers;DistGeometry;"
+  "ForceFieldHelpers;ForceField;EigenSolvers;Optimizer;MolAlign;"
+  "Alignment;SimDivPickers;RDGeometryLib;RDStreams;RDGeneral;"
+  "Abbreviations;GeneralizedSubstruct;MolEnumerator;TautomerQuery;RascalMCES;"
+)
+#if(RDK_BUILD_COORDGEN_SUPPORT)
+#  set(swigRDKitLibList "${swigRDKitLibList};${RDK_COORDGEN_LIBS}")
+#endif(RDK_BUILD_COORDGEN_SUPPORT)
+if(RDK_USE_URF)
+  set(swigRDKitLibList "${swigRDKitLibList};${RDK_URF_LIBS};")
+endif(RDK_USE_URF)
+set(swigRDKitLibs "")
+foreach(swigRDKitLib ${swigRDKitLibList})
+  set(swigRDKitLibs "${swigRDKitLibs}${swigRDKitLib}${swigRDKitLibSuffix};")
+endforeach()
+set(swigRDKitLibs "${swigRDKitLibs}${Boost_SERIALIZATION_LIBRARY};")
+
+if(RDK_USE_BOOST_IOSTREAMS)
+ADD_DEFINITIONS("-DRDK_USE_BOOST_IOSTREAMS")
+if(WIN32)
+  find_package(Boost 1.56.0 COMPONENTS system iostreams REQUIRED)
+  set(swigRDKitLibs "${swigRDKitLibs}${Boost_IOSTREAMS_LIBRARY};${Boost_SYSTEM_LIBRARY};")
+
+  find_package(Boost 1.56.0 COMPONENTS zlib)
+  if(Boost_ZLIB_FOUND)
+    set(swigRDKitLibs "${swigRDKitLibs}${Boost_ZLIB_LIBRARY};")
+  endif()
+else()
+  find_package(Boost 1.56.0 COMPONENTS system iostreams REQUIRED)
+  set(swigRDKitLibs "${swigRDKitLibs}${Boost_IOSTREAMS_LIBRARY};${Boost_SYSTEM_LIBRARY};")
+endif()
+endif(RDK_USE_BOOST_IOSTREAMS)
+
+
+
+set(RDKit_Wrapper_Libs ${swigRDKitLibs})
+
+message("SUFFIX: ${swigRDKitLibSuffix}")
+message("RUBY_LIBS: ${RDKit_Wrapper_Libs}")
+
+add_subdirectory(gmwrapper)

data/Code/RubyWrappers/Canon.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/Canon.h>
+%}
+
+
+
+%include <GraphMol/Canon.h>

data/Code/RubyWrappers/ChemDraw.i

@@ -0,0 +1,81 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2025, Glysade 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 <ChemDraw/chemdraw.h>
+%}
+%ignore RDKit::v2::MolsFromChemDrawDataStream;
+%ignore RDKit::v2::MolsFromChemDrawFile;
+%ignore RDKit::v2::MolsFromChemDrawBlock;
+%rename("ChemDraw") RDKit::v2;
+%rename(CDXFormat) RDKit::v2::CDXFormat;
+%rename(ChemDrawParserParams) RDKit::v2::ChemDrawParserParams;
+
+%include <ChemDraw/chemdraw.h>
+
+%{
+std::vector<RDKit::RWMOL_SPTR> MolsFromChemDrawBlockHelper(
+ const std::string &text,
+ const RDKit::v2::ChemDrawParserParams &params=RDKit::v2::ChemDrawParserParams()) {
+  auto res = RDKit::v2::MolsFromChemDrawBlock(text, params);
+  std::vector<RDKit::RWMOL_SPTR> mols;
+  for(auto &mol: res) {
+    mols.emplace_back(mol.release());
+  }
+  return mols;
+
+}
+
+std::vector<RDKit::RWMOL_SPTR> MolsFromChemDrawFileHelper(
+ const std::string &filename,
+ const RDKit::v2::ChemDrawParserParams &params=RDKit::v2::ChemDrawParserParams()) {
+  auto res = RDKit::v2::MolsFromChemDrawFile(filename, params);
+  std::vector<RDKit::RWMOL_SPTR> mols;
+  for(auto &mol: res) {
+    mols.emplace_back(mol.release());
+  }
+  return mols;
+}
+
+%}
+
+%rename("MolsFromChemDrawBlock") MolsFromChemDrawBlockHelper;
+%rename("MolsFromChemDrawFile") MolsFromChemDrawFileHelper;
+
+std::vector<RDKit::RWMOL_SPTR> MolsFromChemDrawBlockHelper(
+ const std::string &text,
+ const RDKit::v2::ChemDrawParserParams &params=RDKit::v2::ChemDrawParserParams());
+
+std::vector<RDKit::RWMOL_SPTR> MolsFromChemDrawFileHelper(
+ const std::string &filename,
+ const RDKit::v2::ChemDrawParserParams &params=RDKit::v2::ChemDrawParserParams());

data/Code/RubyWrappers/ChemReactions.i

@@ -0,0 +1,166 @@
+/*
+* $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/RDKitBase.h>
+#include <GraphMol/Substruct/SubstructMatch.h>
+#include <vector>
+
+#include <GraphMol/ChemReactions/Reaction.h>
+#include <GraphMol/ChemReactions/ReactionRunner.h>
+#include <GraphMol/ChemReactions/ReactionParser.h>
+#include <GraphMol/ChemReactions/ReactionPickler.h>
+%}
+
+%ignore RDKit::CDXMLToChemicalReactions;
+%ignore RDKit::CDXMLFileToChemicalReactions;
+%ignore RDKit::CDXMLDataStreamToChemicalReactions;
+
+%include <GraphMol/ChemReactions/Reaction.h>
+%include <GraphMol/ChemReactions/ReactionParser.h>
+%ignore RDKit::ChemicalReaction::validate(unsigned int &,unsigned int &,bool);
+%ignore RDKit::ChemicalReaction::validate(unsigned int &,unsigned int &);
+%ignore RDKit::isMoleculeReactantOfReaction(const ChemicalReaction &r,const ROMol &,
+                                            unsigned int &);
+%ignore RDKit::isMoleculeProductOfReaction(const ChemicalReaction &r,const ROMol &,
+                                            unsigned int &);
+
+
+%newobject ReactionFromSmarts;
+%newobject ReactionFromRxnBlock;
+%newobject ReactionFromRxnFile;
+%newobject ReduceProductToSideChains;
+
+%extend RDKit::ChemicalReaction {
+static RDKit::ChemicalReaction *ReactionFromSmarts(std::string sma,bool useSmiles=false){
+  RDKit::ChemicalReaction *res=RDKit::RxnSmartsToChemicalReaction(sma,0,useSmiles);
+  if(res) res->initReactantMatchers();
+  return res;
+};
+static RDKit::ChemicalReaction *ReactionFromRxnBlock(std::string block){
+  RDKit::ChemicalReaction *res=RDKit::RxnBlockToChemicalReaction(block);
+  if(res) res->initReactantMatchers();
+  return res;
+};
+static RDKit::ChemicalReaction *ReactionFromRxnFile(std::string filename){
+  RDKit::ChemicalReaction *res=RDKit::RxnFileToChemicalReaction(filename);
+  if(res) res->initReactantMatchers();
+  return res;
+};
+static std::string ReactionToSmarts(ChemicalReaction &rxn) {
+  return RDKit::ChemicalReactionToRxnSmarts(rxn);
+}
+static std::string ReactionToRxnBlock (const ChemicalReaction &rxn) {
+  return RDKit::ChemicalReactionToRxnBlock(rxn);
+};
+/*
+static RDKit::ROMol *ReduceProductToSideChains(RDKit::ROMOL_SPTR product,
+                                               bool addDummyAtoms=true) {
+  return RDKit::reduceProductToSideChains(product, addDummyAtoms);
+};
+*/
+static RDKit::ROMol *ReduceProductToSideChains(RDKit::ROMol *product,
+                                               bool addDummyAtoms=true) {
+  RDKit::ROMOL_SPTR mol(new RDKit::ROMol(*product));
+  return RDKit::reduceProductToSideChains(mol, addDummyAtoms);
+};
+void compute2DCoordsForReaction(double spacing,
+                                  bool updateProps,
+                                  bool canonOrient,
+                                  unsigned int nFlipsPerSample,
+                                  unsigned int nSamples,
+                                  int sampleSeed,
+                                  bool permuteDeg4Nodes){
+
+       RDDepict::compute2DCoordsForReaction(*($self),
+                                  spacing,
+                                  updateProps,
+                                  canonOrient,
+                                  nFlipsPerSample,
+                                  nSamples,
+                                  sampleSeed,
+                                  permuteDeg4Nodes);
+};
+std::vector<int> ToBinary(){
+  std::string sres;
+  RDKit::ReactionPickler::pickleReaction(*($self),sres);
+  std::vector<int> res(sres.length());
+  std::copy(sres.begin(),sres.end(),res.begin());
+  return res;
+};
+static RDKit::ChemicalReaction *RxnFromBinary(std::vector<int> pkl){
+  std::string sres;
+  sres.resize(pkl.size());
+  std::copy(pkl.begin(),pkl.end(),sres.begin());
+  RDKit::ChemicalReaction *res=new RDKit::ChemicalReaction(sres);
+  return res;
+};
+
+/* A Ruby-accessible validation function */
+    std::pair<int,int> *validateReaction(bool silent=false) {
+	std::pair<int,int> *res = new std::pair<int,int>();
+	unsigned int first;
+	unsigned int second;
+	($self)->validate(first, second, silent);
+	res->first = (int) first;
+	res->second = (int) second;
+        return res;
+    };
+
+  bool validate() {
+    unsigned int nErr=0,nWarn=0;
+    bool res=$self->validate(nErr,nWarn);
+    return res;
+  };
+
+static std::vector<std::shared_ptr<ChemicalReaction>> CDXMLToChemicalReactions(
+  const std::string &block, bool sanitize=false, bool removeHs=false) {
+  auto reactions = RDKit::CDXMLToChemicalReactions(block, sanitize, removeHs);
+  std::vector<std::shared_ptr<RDKit::ChemicalReaction>> result;
+  for(auto &rxn : reactions) {
+    result.emplace_back(rxn.release());
+  }
+  return result;
+}
+
+static std::vector<std::shared_ptr<ChemicalReaction>> CDXMLFileToChemicalReactions(
+  const std::string &filename, bool sanitize=false, bool removeHs=false) {
+  auto reactions = RDKit::CDXMLFileToChemicalReactions(filename, sanitize, removeHs);
+  std::vector<std::shared_ptr<RDKit::ChemicalReaction>> result;
+  for(auto &rxn : reactions) {
+    result.emplace_back(rxn.release());
+  }
+  return result;
+}
+
+}

data/Code/RubyWrappers/ChemTransforms.i

@@ -0,0 +1,126 @@
+/*
+* $Id$
+*
+*  Copyright (c) 2011, 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/ChemTransforms/ChemTransforms.h>
+#include <GraphMol/ChemTransforms/MolFragmenter.h>
+#include <GraphMol/ChemTransforms/MolFragmenterJSONParser.h>
+#include <GraphMol/Bond.h>
+// Fixes annoying compilation namespace issue
+typedef RDKit::MatchVectType MatchVectType;
+
+// Partial binding to one overload of RDKit::fragmentOnBonds
+RDKit::ROMol *fragmentMolOnBonds(
+    const RDKit::ROMol &mol, const std::vector<int> &bondIndices,
+    bool addDummies = true,
+    const std::vector<std::pair<unsigned int, unsigned int>> *dummyLabels = nullptr,
+    std::vector<int> *nCutsPerAtom = nullptr) {
+        // Convert vector<int> to vector<unsigned int>
+        std::vector<unsigned int> uBondIndices(bondIndices.begin(), bondIndices.end());
+        std::vector<unsigned int> uNCutsPerAtom;
+        if (nCutsPerAtom) {
+            uNCutsPerAtom.insert(uNCutsPerAtom.begin(), nCutsPerAtom->begin(), nCutsPerAtom->end());
+        }
+        auto cutsPerAtomPtr = nCutsPerAtom ? &uNCutsPerAtom : nullptr;
+        // Can't handle the 5th argument of vector<BondType> as swig will not wrap vector of enum
+        return RDKit::MolFragmenter::fragmentOnBonds(mol, uBondIndices, addDummies, dummyLabels, nullptr, cutsPerAtomPtr);
+ }
+
+// Fix std::unique_ptr issue
+RDKit::ROMol * new_molzip(
+	       const RDKit::ROMol &a, const RDKit::ROMol &b,
+	       const RDKit::MolzipParams &params=RDKit::MolzipParams()) {
+  return RDKit::molzip(a, b, params).release();;
+}
+
+RDKit::ROMol * new_molzip(
+	       const RDKit::ROMol &a,
+	       const RDKit::MolzipParams &params=RDKit::MolzipParams()) {
+  return RDKit::molzip(a, params).release();
+}
+
+RDKit::ROMol * new_molzip(
+               std::vector<RDKit::ROMOL_SPTR> &mols,
+               const RDKit::MolzipParams &params=RDKit::MolzipParams()) {
+  return RDKit::molzip(mols, params).release();
+}
+%}
+
+%include "std_string.i"
+%include "std_vector.i"
+
+%newobject deleteSubstructs;
+%newobject replaceSidechains;
+%newobject replaceCores;
+%newobject MurckoDecompose;
+%template(StringMolMap) std::map<std::string,boost::shared_ptr<RDKit::ROMol> >;
+%include <GraphMol/Bond.h>
+%include <GraphMol/ChemTransforms/ChemTransforms.h>
+
+%newobject fragmentMolOnBonds;
+%newobject new_molzip;
+%ignore fragmentOnBonds;
+%ignore molzip;
+%rename("fragmentOnBonds") fragmentMolOnBonds;
+%rename("molzip") new_molzip;
+
+RDKit::ROMol *fragmentMolOnBonds(
+    const RDKit::ROMol &mol, const std::vector<int> &bondIndices,
+    bool addDummies = true,
+    const std::vector<std::pair<unsigned int, unsigned int>> *dummyLabels = nullptr,
+    std::vector<int> *nCutsPerAtom = nullptr);
+
+RDKit::ROMol * new_molzip(
+			  const RDKit::ROMol &a, const RDKit::ROMol &b,
+			  const RDKit::MolzipParams &params=RDKit::MolzipParams());
+
+RDKit::ROMol * new_molzip(
+			  const RDKit::ROMol &a,
+			  const RDKit::MolzipParams &params=RDKit::MolzipParams());
+
+
+RDKit::ROMol * new_molzip(
+                          std::vector<RDKit::ROMOL_SPTR> &mols,
+                          const RDKit::MolzipParams &params=RDKit::MolzipParams());
+
+%ignore fragmentOnSomeBonds;
+%ignore constructFragmenterAtomTypes;
+%ignore constructBRICSAtomTypes;
+%ignore constructFragmenterBondTypes;
+%ignore constructBRICSBondTypes;
+
+%newobject fragmentOnBRICSBonds;
+%template(UIntMolMap) std::map<unsigned int,boost::shared_ptr<RDKit::ROMol> >;
+%include <RDGeneral/BetterEnums.h>
+%include <GraphMol/ChemTransforms/MolFragmenter.h>
+%include <GraphMol/ChemTransforms/MolFragmenterJSONParser.h>

data/Code/RubyWrappers/Conformer.i

@@ -0,0 +1,69 @@
+/*
+* $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/Conformer.h>
+#include <GraphMol/MolTransforms/MolTransforms.h>
+#include <Geometry/point.h>
+%}
+
+// no point in wrapping something that can't be accessed
+// getAtomPos() and setAtomPos() are convenient accessors
+%ignore RDKit::Conformer::getPositions();
+%ignore RDKit::Conformer::getPositions() const;
+
+%include <GraphMol/Conformer.h>
+
+%extend RDKit::Conformer {
+   /* From MolTransforms.h */
+
+  RDGeom::Point3D computeCentroid(bool ignoreHs=true) {
+	return MolTransforms::computeCentroid(*($self), ignoreHs);
+  }
+
+  RDGeom::Transform3D *computeCanonicalTransform(const RDGeom::Point3D *center=0,
+                                                 bool normalizeCovar=false,
+                                                 bool ignoreHs=true) {
+	return MolTransforms::computeCanonicalTransform(*(self), center, normalizeCovar, ignoreHs);
+  }
+
+  void transformConformer(const RDGeom::Transform3D &trans) {
+	MolTransforms::transformConformer(*($self), trans);
+  }
+
+  void canonicalizeConformer(const RDGeom::Point3D *center=0,
+                             bool normalizeCovar=false, bool ignoreHs=true) {
+	MolTransforms::canonicalizeConformer(*($self), center, normalizeCovar, ignoreHs);
+  }
+
+}

data/Code/RubyWrappers/Descriptors.i

@@ -0,0 +1,64 @@
+/* 
+* $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/Descriptors/MolDescriptors.h>
+%}
+
+%include <GraphMol/Descriptors/MolDescriptors.h>
+%include <GraphMol/Descriptors/Lipinski.h>
+%include <GraphMol/Descriptors/MolSurf.h>
+%include <GraphMol/Descriptors/ConnectivityDescriptors.h>
+%include <GraphMol/Descriptors/MQN.h>
+
+%inline %{
+  std::pair<double,double> calcCrippenDescriptors(const RDKit::ROMol &mol,
+                                                   bool includeHs=true,bool force=false) {
+    std::pair<double,double> res;
+    RDKit::Descriptors::calcCrippenDescriptors(mol, res.first, res.second, includeHs, force);
+    return res;
+  }
+  double calcMolLogP(const RDKit::ROMol &mol){
+    double logp,mr;
+    RDKit::Descriptors::calcCrippenDescriptors(mol,logp,mr);
+    return logp;
+  }
+  double calcMolMR(const RDKit::ROMol &mol){
+    double logp,mr;
+    RDKit::Descriptors::calcCrippenDescriptors(mol,logp,mr);
+    return mr;
+  }
+
+%}
+
+