rdkit_chem 2019.03.3.1 → 2025.09.3.2

data/Code/RubyWrappers/StereoGroup.i

@@ -0,0 +1,16 @@
+/*
+*
+*  Copyright (c) 2018, Greg Landrum
+*  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/StereoGroup.h>
+%}
+
+%include <GraphMol/StereoGroup.h>

data/Code/RubyWrappers/Streams.i

@@ -0,0 +1,67 @@
+
+/*
+ *  Copyright (c) 2019, 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 <../RDStreams/streams.h>
+#include <sstream>
+%}
+
+// We just need to pass the pointers around here
+%nodefaultctor istream;
+%nodefaultdtor istream;
+%nodefaultctor filtering_istream;
+%nodefaultdtor filtering_istream;
+
+namespace std {
+class istream;
+}
+
+#ifdef RDK_USE_BOOST_IOSTREAMS
+%extend RDKit::gzstream {
+    std::istream* _GetStream() { return (std::istream*)$self; }
+    std::string Dump() {
+      std::ostringstream stream;
+      std::copy(std::istreambuf_iterator<char>(*$self),
+                std::istreambuf_iterator<char>(),
+                std::ostreambuf_iterator<char>(stream));
+
+      return stream.str();
+    }
+}
+#endif
+
+%include <../RDStreams/streams.h>
+

data/Code/RubyWrappers/Subgraphs.i

@@ -0,0 +1,53 @@
+/*
+* $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/Subgraphs/Subgraphs.h>
+#include <GraphMol/Subgraphs/SubgraphUtils.h>
+%}
+
+%include <GraphMol/Subgraphs/Subgraphs.h>
+%inline %{
+  std::vector<int> calcPathDiscriminators(RDKit::ROMol &mol,RDKit::PATH_TYPE &path){
+    std::vector<int> res(3);
+    RDKit::Subgraphs::DiscrimTuple tpl=RDKit::Subgraphs::calcPathDiscriminators(mol,path);
+    res[0]=std::get<0>(tpl);
+    res[1]=std::get<1>(tpl);
+    res[2]=std::get<2>(tpl);
+    return res;
+  }
+%}
+
+%ignore calcPathDiscriminators;
+%newobject pathToSubmol;
+%include <GraphMol/Subgraphs/SubgraphUtils.h>

data/Code/RubyWrappers/Subset.i

@@ -0,0 +1,75 @@
+/*
+*
+*  Copyright (C) 2025 and other RDKit contributors
+*
+*   @@ 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/Subset.h>
+%}
+
+%ignore RDKit::copyMolSubset;
+%include <GraphMol/Subset.h>
+
+%{
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+			   const std::vector<unsigned int> &atoms,
+			   const std::vector<unsigned int> &bonds,
+			   const RDKit::SubsetOptions &options=RDKit::SubsetOptions()
+			   )
+{
+  return copyMolSubset(mol, atoms, bonds, options).release();
+}
+
+
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+		     const std::vector<unsigned int> &atoms,
+		     const std::vector<unsigned int> &bonds,
+		     RDKit::SubsetInfo &subsetInfo,
+		     const RDKit::SubsetOptions &options=RDKit::SubsetOptions()
+		     ) {
+  return copyMolSubset(mol, atoms, bonds, subsetInfo, options).release();
+}
+
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+				  const std::vector<unsigned int>& path,
+				  const RDKit::SubsetOptions &options = RDKit::SubsetOptions()) {
+  return copyMolSubset(mol, path, options).release();
+}
+
+
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+				  const std::vector<unsigned int>& path,
+				  RDKit::SubsetInfo &subsetInfo,
+				  const RDKit::SubsetOptions &options = RDKit::SubsetOptions()) {
+  return copyMolSubset(mol, path, subsetInfo, options).release();
+}
+
+%}
+
+%rename("copyMolSubset") copyMolSubsetHelper;
+
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+				  const std::vector<unsigned int> &atoms,
+				  const std::vector<unsigned int> &bonds,
+				  const RDKit::SubsetOptions &options=RDKit::SubsetOptions()
+				  );
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+				  const std::vector<unsigned int> &atoms,
+				  const std::vector<unsigned int> &bonds,
+				  RDKit::SubsetInfo &subsetInfo,
+				  const RDKit::SubsetOptions &options=RDKit::SubsetOptions()
+				  );
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+				  const std::vector<unsigned int>& path,
+				  const RDKit::SubsetOptions &options = RDKit::SubsetOptions());
+
+RDKit::ROMol *copyMolSubsetHelper(const RDKit::ROMol& mol,
+				  const std::vector<unsigned int>& path,
+				  RDKit::SubsetInfo &subsetInfo,
+				  const RDKit::SubsetOptions &options = RDKit::SubsetOptions());

data/Code/RubyWrappers/SubstanceGroup.i

@@ -0,0 +1,91 @@
+/*
+*
+* Created by Gareth Jones on 9/2/2020.
+*
+* Copyright 2020 Schrodinger, Inc
+*  @@ 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/SubstanceGroup.h>
+
+const RDKit::SubstanceGroup *getSubstanceGroupWithIdx(RDKit::ROMol &mol, unsigned int idx) {
+  auto &groups = RDKit::getSubstanceGroups(mol);
+  return &(groups[idx]);
+}
+
+unsigned int getSubstanceGroupCount(RDKit::ROMol &mol) {
+    return RDKit::getSubstanceGroups(mol).size();
+}
+%}
+
+
+// Base class RDProps is wrapped with shared_ptr, so SubstanceGroup must be too.
+%shared_ptr(RDKit::SubstanceGroup)
+%ignore getSubstanceGroups;
+
+RDKit::SubstanceGroup *getSubstanceGroupWithIdx(RDKit::ROMol &mol, unsigned int idx);
+unsigned int getSubstanceGroupCount(RDKit::ROMol &mol);
+
+%ignore RDKit::SubstanceGroup::getAtoms;
+%rename(getAtoms) RDKit::SubstanceGroup::getSgAtoms;
+%ignore RDKit::SubstanceGroup::getBonds;
+%rename(getBonds) RDKit::SubstanceGroup::getSgBonds;
+%ignore RDKit::SubstanceGroup::getBrackets;
+%ignore RDKit::SubstanceGroup::getCStates;
+%ignore RDKit::SubstanceGroup::getAttachPoints;
+
+%include <GraphMol/SubstanceGroup.h>
+
+%extend RDKit::SubstanceGroup {
+  // Wrap getAtoms, getParentAtoms and getBonds to return vector<int> by value (not reference).
+  const std::vector<int> getSgAtoms() {
+    auto atoms = $self->getAtoms();
+    std::vector<int> atomIdxs(atoms.begin(), atoms.end());
+    return atomIdxs;
+  }
+  const std::vector<int> getSgBonds() {
+    auto bonds = $self->getBonds();
+    std::vector<int> bondIdxs(bonds.begin(), bonds.end());
+    return bondIdxs;
+  }
+  const std::vector<int> getSgParentAtoms() {
+    auto atoms = $self->getParentAtoms();
+    std::vector<int> atomIdxs(atoms.begin(), atoms.end());
+    return atomIdxs;
+  }
+
+  // SWIG does not do well wrapping vectors of objects, so provide accessors
+  const RDKit::SubstanceGroup::Bracket *getBracket(unsigned int idx)  {
+    auto &brackets = $self->getBrackets();
+    return &(brackets[idx]);
+  }
+  const RDKit::SubstanceGroup::CState *getCState(unsigned int idx)  {
+    auto &cstates = $self->getCStates();
+    return &(cstates[idx]);
+  }
+  const RDKit::SubstanceGroup::AttachPoint *getAttachPoint(unsigned int idx)  {
+    auto &attachPoints = $self->getAttachPoints();
+    return &(attachPoints[idx]);
+  }
+  size_t getBracketCount() {
+    return $self->getBrackets().size();
+  }
+  size_t getCStateCount() {
+    return $self->getCStates().size();
+  }
+  size_t getAttachPointCount() {
+    return $self->getAttachPoints().size();
+  }
+}
+
+%template(getStringProp) RDKit::SubstanceGroup::getProp<std::string>;
+%template(getUIntProp) RDKit::SubstanceGroup::getProp<unsigned int>;
+%template(getStringVectProp) RDKit::SubstanceGroup::getProp<RDKit::STR_VECT>;
+%template(getUIntVectProp) RDKit::SubstanceGroup::getProp<RDKit::UINT_VECT>;

data/Code/RubyWrappers/SubstructLibrary.i

@@ -0,0 +1,80 @@
+/*
+ *  Copyright (c) 2015, 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.
+ */
+
+//%import "ROMol.i"
+%include "std_vector.i"
+
+
+%{
+#include <GraphMol/SubstructLibrary/SubstructLibrary.h>
+#include <GraphMol/TautomerQuery/TautomerQuery.h>
+#include <GraphMol/GeneralizedSubstruct/XQMol.h>
+using RDKit::GeneralizedSubstruct::ExtendedQueryMol;
+%}
+%shared_ptr(RDKit::TautomerQuery)
+%shared_ptr(RDKit::MolHolderBase)
+%shared_ptr(RDKit::MolHolder)
+%shared_ptr(RDKit::CachedMolHolder)
+%shared_ptr(RDKit::CachedSmilesMolHolder)
+%shared_ptr(RDKit::CachedTrustedSmilesMolHolder)
+%shared_ptr(RDKit::FPHolderBase)
+%shared_ptr(RDKit::PatternHolder)
+%shared_ptr(RDKit::TautomerPatternHolder)
+%shared_ptr(RDKit::KeyHolderBase)
+%shared_ptr(RDKit::KeyFromPropHolder)
+
+%template(UChar_Vect) std::vector<unsigned char>;
+
+%extend RDKit::SubstructLibrary {
+  SubstructLibrary(const std::vector<unsigned char> & data ) {
+    std::string str(data.begin(), data.end());
+    return new RDKit::SubstructLibrary(str);
+  }
+
+  static bool canSerialize() {
+    return RDKit::SubstructLibraryCanSerialize();
+  }
+}
+
+%include <GraphMol/TautomerQuery/TautomerQuery.h>
+%include <GraphMol/SubstructLibrary/SubstructLibrary.h>
+
+%extend RDKit::SubstructLibrary {
+ %template(getMatches) getMatches<ROMol>;
+ %template(getMatches) getMatches<TautomerQuery>;
+ %template(getMatches) getMatches<RDKit::GeneralizedSubstruct::ExtendedQueryMol>;
+ %template(countMatches) countMatches<ROMol>;
+ %template(countMatches) countMatches<TautomerQuery>;
+ %template(countMatches) countMatches<ExtendedQueryMol>;
+ %template(hasMatch) hasMatch<ROMol>;
+ %template(hasMatch) hasMatch<TautomerQuery>;
+ %template(hasMatch) hasMatch<ExtendedQueryMol>;
+}

data/Code/RubyWrappers/TautomerQuery.i

@@ -0,0 +1,19 @@
+/*
+*
+*  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 <vector>
+#include <GraphMol/TautomerQuery/TautomerQuery.h>
+%}
+%shared_ptr(RDKit::ROMol)
+%template(Sizet_Vect) std::vector<size_t>;
+
+%include <GraphMol/TautomerQuery/TautomerQuery.h>

data/Code/RubyWrappers/Trajectory.i

@@ -0,0 +1,34 @@
+/*
+*  Copyright (C) 2016 Sereina Riniker, Paolo Tosco
+* 
+*    @@ 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/Trajectory/Snapshot.h>
+#include <GraphMol/Trajectory/Trajectory.h>
+%}
+%include <GraphMol/Trajectory/Snapshot.h>
+%include <GraphMol/Trajectory/Trajectory.h>
+
+%extend RDKit::Snapshot {
+  Snapshot(std::vector<double> &posVect, double energy = 0.0) {
+    double *posArray = new double[posVect.size()];
+    for (unsigned int i = 0; i < posVect.size(); ++i)
+      posArray[i] = posVect[i];
+    boost::shared_array<double> pos(posArray);
+    RDKit::Snapshot *s = new RDKit::Snapshot(pos, energy);
+    return s;
+  }
+  Snapshot(const RDKit::Snapshot &other) {
+    return new RDKit::Snapshot(other);
+  }
+  %newobject SnapshotVect;
+  static std::vector<RDKit::Snapshot> *SnapshotVect() {
+    return new std::vector<RDKit::Snapshot>();
+  }
+}

data/Code/RubyWrappers/boost_tuple.i

@@ -0,0 +1,64 @@
+/* 
+* 
+*
+*  Copyright (c) 2015, Greg Landrum
+*  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.
+*
+* taken from this stackexchange answer: http://stackoverflow.com/a/12768318
+*/
+%{
+#include <boost/tuple/tuple.hpp>
+%}
+
+namespace boost {
+  template <typename T1=void, typename T2=void, typename T3=void> 
+  struct tuple;
+
+  template <>
+  struct tuple<void,void,void> {
+  };
+
+  template <typename T1>
+  struct tuple<T1, void, void> {
+    tuple(T1);
+    %extend {
+      T1 first() const {
+        return boost::get<0>(*$self);
+      }
+    }
+  };
+
+  template <typename T1, typename T2>
+  struct tuple <T1, T2, void> {
+    tuple(T1,T2);
+    %extend {
+      T1 first() const {
+        return boost::get<0>(*$self);
+      }
+      T2 second() const { 
+        return boost::get<1>(*$self);
+      }
+    }
+  };
+
+  template <typename T1, typename T2, typename T3> 
+  struct tuple <T1,T2,T3> {
+    tuple(T1,T2,T3);
+    %extend {
+      T1 first() const {
+        return boost::get<0>(*$self);
+      }
+      T2 second() const {
+        return boost::get<1>(*$self);
+      }
+      T3 third() const {
+        return boost::get<2>(*$self);
+      }
+    }
+  };
+}

data/Code/RubyWrappers/extend_std_vector.i

@@ -0,0 +1,10 @@
+/* -----------------------------------------------------------------------------
+ * extend_std_vector.i
+ * ----------------------------------------------------------------------------- */
+
+// Note: The generic %extend std::vector with template parameter T doesn't work
+// properly with SWIG Ruby backend. The equals() and vector(size_type) methods
+// that use T directly cause compilation errors in the generated wrapper code.
+// These extensions are removed for Ruby compatibility.
+
+%include <std_vector.i>

data/Code/RubyWrappers/gmwrapper/CMakeLists.txt

@@ -0,0 +1,69 @@
+cmake_minimum_required(VERSION 3.8)
+
+# Apple: Don't modify install_name when touching RPATH.
+if(POLICY CMP0068)
+  cmake_policy(SET CMP0068 NEW)
+endif()
+# target_sources: use absolute path for INTERFACE_SOURCES.
+if(POLICY CMP0076)
+  cmake_policy(SET CMP0076 NEW)
+endif()
+# SWIG: use standard target name.
+if(POLICY CMP0078)
+  cmake_policy(SET CMP0078 NEW)
+endif()
+# SWIG: use SWIG_MODULE_NAME property.
+if(POLICY CMP0086)
+  cmake_policy(SET CMP0086 NEW)
+endif()
+
+project (GraphMolRuby)
+
+include_directories( ${RDKit_ExternalDir} )
+
+find_package(Ruby REQUIRED)
+
+INCLUDE_DIRECTORIES(${RDKit_INCLUDE_DIR} ${RUBY_INCLUDE_PATH})
+
+SET_SOURCE_FILES_PROPERTIES(GraphMolRuby.i PROPERTIES CPLUSPLUS ON )
+
+SET(CMAKE_SWIG_OUTDIR ${CMAKE_CURRENT_SOURCE_DIR}/swig_ruby )
+
+if(RDK_BUILD_INCHI_SUPPORT)
+  SET(CMAKE_SWIG_FLAGS "-DRDK_BUILD_INCHI_SUPPORT" ${CMAKE_SWIG_FLAGS} )
+endif()
+if(RDK_BUILD_AVALON_SUPPORT)
+  SET(CMAKE_SWIG_FLAGS "-DRDK_BUILD_AVALON_SUPPORT" ${CMAKE_SWIG_FLAGS} )
+endif()
+if(RDK_USE_BOOST_IOSTREAMS)
+  SET(CMAKE_SWIG_FLAGS "-DRDK_USE_BOOST_IOSTREAMS" ${CMAKE_SWIG_FLAGS} )
+endif()
+
+FILE(GLOB SWIG_SRC_FILES "${CMAKE_CURRENT_SOURCE_DIR}/../*.i")
+
+# we added all source files, now remove the ones that we're not supporting in this build:
+if(NOT RDK_BUILD_AVALON_SUPPORT)
+LIST(REMOVE_ITEM SWIG_SRC_FILES "${CMAKE_CURRENT_SOURCE_DIR}/../AvalonLib.i")
+endif()
+
+if(NOT RDK_BUILD_INCHI_SUPPORT)
+LIST(REMOVE_ITEM SWIG_SRC_FILES "${CMAKE_CURRENT_SOURCE_DIR}/../Inchi.i")
+endif()
+
+SET(SWIG_MODULE_RDKitChem_EXTRA_DEPS ${SWIG_SRC_FILES} )
+SET(CMAKE_SWIG_FLAGS -small -naturalvar -autorename)
+
+SWIG_ADD_LIBRARY(RDKitChem TYPE MODULE LANGUAGE ruby SOURCES GraphMolRuby.i)
+
+# 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.
+SWIG_LINK_LIBRARIES(RDKitChem
+  ${RDKit_Wrapper_Libs}
+  ${Boost_SERIALIZATION_LIBRARY}
+  ${RDKit_THREAD_LIBS})
+
+MESSAGE("serial: ${Boost_SERIALIZATION_LIBRARY}")
+MESSAGE("THREAD: ${RDKit_THREAD_LIBS}")
+
+INSTALL(TARGETS RDKitChem LIBRARY DESTINATION lib)