rdkit_chem 2025.09.3.6-x86_64-linux → 2025.09.3.13-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 341c2a7eba1ec7f087857db35280e4678526c73432c53908067d7738adf5db2c
-  data.tar.gz: bd18c6db368ddfa06997ead4f0cab61dd4e371dfea8b18f179c879fd2f0df35d
+  metadata.gz: 0cacf75cce91a8b8dc5c4db95ac1e571fd4cc82bd7b66a4bf0eddf77c93b58da
+  data.tar.gz: bea62b57958b2ed44b826f8554f8d884cf3a6982acdf45b262a35ba00076b191
 SHA512:
-  metadata.gz: 91bb0ea9b3a5caa8653400a55ad217ffb4bdcc4836590daecb62ea53ff0cdd8809dd0fe8345cfcd570e4ea5eba86893c6bb32c36dfc79a9ed9fde6cdb3ac6479
-  data.tar.gz: 2c0e49bd5a58e40dd247080c04dc7d36d96dd7770e19fe33663951d53154cf2625d5b2831cc2ef40864f57a75c269e9c210528e4d72c37567dc55fcab08f6ebc
+  metadata.gz: 2c338e2000b175beff58ddaccb20101829c0bf30f6e1482dce7e359c1ad965d86d85cd9004badd6f4b405a5834ad77b671c461fe35c32360d941ec43ab75071e
+  data.tar.gz: f5cf656b1dd3c64ff5ea517634bd32075d891eb75e5cd90719b0be9584b4f0560710b1eecb92bc4d3d724e815202a50edc6e6371e314447cb9973d3a903ed531

data/Code/RubyWrappers/MolOps.i

@@ -56,7 +56,7 @@
   // 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{
+    try {
       RDKit::MolOps::sanitizeMol(mol, opThatFailed,
                                  static_cast<unsigned int>(sanitizeOps));
     } catch(...) {

data/Code/RubyWrappers/gmwrapper/CMakeLists.txt

@@ -55,6 +55,12 @@ SET(CMAKE_SWIG_FLAGS -small -naturalvar -autorename)
 
 SWIG_ADD_LIBRARY(RDKitChem TYPE MODULE LANGUAGE ruby SOURCES GraphMolRuby.i)
 
+if(APPLE)
+  set_target_properties(RDKitChem PROPERTIES
+    LINK_FLAGS "-undefined dynamic_lookup"
+    SUFFIX ".bundle")
+endif()
+
 # 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.

data/README.md

@@ -22,3 +22,95 @@ GEM for [RDKIT](http://rdkit.org/), an Open-Source Cheminformatics Software
 It downloads the sources, compiles and installs RDKIT with the ruby bindings.
 The installation may last very long - please be patient.
 
+## macOS Build Notes
+
+### Known Issues and Solutions
+
+#### 1. Boost Serialization Not Found
+
+**Error:**
+```
+CMake Error: Found package configuration file boost_serialization-config.cmake
+but it set boost_serialization_FOUND to FALSE
+Reason: No suitable build variant has been found.
+```
+
+**Solution:** The gem has been updated to use static Boost flags (`-DBoost_USE_STATIC_LIBS=ON -DBoost_USE_STATIC_RUNTIME=ON`).
+
+#### 2. Ruby Symbol Linking Error
+
+**Error:**
+```
+Undefined symbols for architecture x86_64:
+  "_rb_define_class", "_rb_str_new", ... (Ruby C API symbols)
+```
+
+**Solution:** Fixed in `Code/RubyWrappers/gmwrapper/CMakeLists.txt` with `-undefined dynamic_lookup` for macOS.
+
+#### 3. Ruby 3.2+ Compatibility (CRITICAL)
+
+**Error:**
+```ruby
+require 'RDKitChem'
+# => TypeError: wrong argument type nil (expected Data)
+```
+
+**Cause:** Ruby 3.2+ introduced a new `Data` class that conflicts with SWIG's wrapper generation.
+
+**Workaround:** Use Ruby 3.1.x:
+```bash
+# Using asdf
+asdf install ruby 3.1.6
+asdf set ruby 3.1.6
+
+# Using rbenv
+rbenv install 3.1.6
+rbenv local 3.1.6
+```
+
+#### 4. GitHub Actions CI - Xcode SDK Header Conflict
+
+**Error:**
+```
+error: ISO C++17 does not allow 'register' storage class specifier [-Wregister]
+error: no member named 'finite' in namespace 'std::__math'
+```
+
+**Cause:** CMake finds Xcode SDK Ruby headers instead of `ruby/setup-ruby` installed headers.
+
+**Solution:** Fixed in `extconf.rb` by explicitly passing Ruby paths to CMake.
+
+### Ruby Version Compatibility
+
+| Ruby Version | Build | Runtime | Notes |
+|--------------|-------|---------|-------|
+| 3.4.x | OK | FAIL | `Data` class conflict |
+| 3.3.x | OK | FAIL | `Data` class conflict |
+| 3.2.x | OK | FAIL | `Data` class conflict |
+| 3.1.x | OK | OK | Recommended |
+
+### Build Commands (macOS)
+
+**Full Clean Build:**
+```bash
+rm -rf rdkit/build rdkit_chem
+ruby ext/rdkit_chem/extconf.rb
+```
+
+**Resume Interrupted Build:**
+```bash
+cd rdkit/build
+make -j8
+make install
+```
+
+**Test Loading:**
+```bash
+DYLD_LIBRARY_PATH=$PWD/rdkit_chem/lib ruby -I $PWD/rdkit_chem/lib -e 'require "RDKitChem"; puts "Success!"'
+```
+
+### Additional Notes
+
+- Full build takes ~20 minutes
+- Some `BOOST_NO_CXX98_FUNCTION_BASE` warnings during build are harmless
+- For detailed troubleshooting, see [MACOS_BUILD_NOTES.md](MACOS_BUILD_NOTES.md)

data/Rakefile

@@ -2,6 +2,7 @@
 
 require 'rake/testtask'
 require 'fileutils'
+require 'set'
 
 # Load version
 $LOAD_PATH.unshift File.expand_path('lib', __dir__)
@@ -29,12 +30,14 @@ task :build do
   sh 'gem build rdkit_chem.gemspec'
 end
 
-desc 'Build pre-compiled gem for current platform (x86_64-linux)'
+desc 'Build pre-compiled gem for current platform'
 task :build_native do
-  # Check that native libraries exist
-  unless File.exist?(File.join(NATIVE_DIR, 'RDKitChem.so'))
-    abort "ERROR: Native extension not found at #{NATIVE_DIR}/RDKitChem.so\n" \
-          "Run 'gem install rdkit_chem' first to compile, or build manually."
+  ext_so = File.join(NATIVE_DIR, 'RDKitChem.so')
+  ext_bundle = File.join(NATIVE_DIR, 'RDKitChem.bundle')
+
+  unless File.exist?(ext_so) || File.exist?(ext_bundle)
+    abort "ERROR: Native extension not found at #{NATIVE_DIR}/RDKitChem.{so,bundle}\n" \
+          "Run 'cd ext/rdkit_chem && ruby extconf.rb' first to compile."
   end
 
   # Get Ruby version for directory structure
@@ -47,21 +50,28 @@ task :build_native do
   FileUtils.mkdir_p(target_dir)
 
   # Copy native extension and all shared libraries
-  Dir.glob("#{NATIVE_DIR}/*.so*").each do |lib|
-    # Skip symlinks, copy only real files
-    next if File.symlink?(lib)
-    dest = File.join(target_dir, File.basename(lib))
-    FileUtils.cp(lib, dest, verbose: true)
+  # Linux: *.so*, macOS: *.bundle and *.dylib
+  lib_patterns = ["#{NATIVE_DIR}/*.so*", "#{NATIVE_DIR}/*.bundle", "#{NATIVE_DIR}/*.dylib"]
+  
+  lib_patterns.each do |pattern|
+    Dir.glob(pattern).each do |lib|
+      # Skip symlinks first pass, copy only real files
+      next if File.symlink?(lib)
+      dest = File.join(target_dir, File.basename(lib))
+      FileUtils.cp(lib, dest, verbose: true)
+    end
   end
 
   # Also copy symlinks (they're needed for library resolution)
   # This includes both .so -> .so.1 and .so.1 -> .so.1.version symlinks
-  Dir.glob("#{NATIVE_DIR}/*.so*").each do |lib|
-    next unless File.symlink?(lib)
-    link_target = File.readlink(lib)
-    dest = File.join(target_dir, File.basename(lib))
-    FileUtils.rm_f(dest)
-    FileUtils.ln_s(link_target, dest, verbose: true)
+  lib_patterns.each do |pattern|
+    Dir.glob(pattern).each do |lib|
+      next unless File.symlink?(lib)
+      link_target = File.readlink(lib)
+      dest = File.join(target_dir, File.basename(lib))
+      FileUtils.rm_f(dest)
+      FileUtils.ln_s(link_target, dest, verbose: true)
+    end
   end
 
   # Build the platform-specific gem
@@ -137,6 +147,82 @@ task :fix_rpath do
   sh "readelf -d #{so_file} | grep -E '(RPATH|RUNPATH)' || echo 'No RPATH found'"
 end
 
+desc 'Repair: bundle system libraries and fix RPATH'
+task :repair do
+  Rake::Task['bundle_system_libs'].invoke
+  Rake::Task['fix_rpath'].invoke
+end
+
+MACOS_SYSTEM_LIBRARY_PREFIXES = ['/usr/lib/', '/System/'].freeze
+MACOS_DEFAULT_SEARCH_PATHS = ['/opt/homebrew/lib', '/usr/local/lib'].freeze
+
+def macos_shared_libraries(libs_dir)
+  Dir.glob("#{libs_dir}/*.dylib") + Dir.glob("#{libs_dir}/*.bundle")
+end
+
+def macos_dependencies(lib)
+  otool_output = `otool -L '#{lib}' 2>/dev/null`
+  otool_output.lines.drop(1).map { |line| line.strip.split(' ').first }.compact
+end
+
+def macos_system_library?(path)
+  MACOS_SYSTEM_LIBRARY_PREFIXES.any? { |prefix| path.start_with?(prefix) }
+end
+
+def macos_resolve_dependency(dep, libs_dir)
+  return dep if dep.start_with?('/') && File.exist?(dep)
+
+  basename = File.basename(dep)
+  candidates = [File.join(libs_dir, basename)] +
+               MACOS_DEFAULT_SEARCH_PATHS.map { |dir| File.join(dir, basename) }
+  candidates.find { |path| File.exist?(path) }
+end
+
+desc 'Repair for macOS (bundle deps and fix install names)'
+task :repair_macos do
+  libs_dir = File.expand_path(NATIVE_DIR)
+  libs = macos_shared_libraries(libs_dir)
+  abort "ERROR: no macOS libraries found in #{libs_dir}" if libs.empty?
+
+  queue = libs.dup
+  processed = Set.new
+  copied = 0
+
+  until queue.empty?
+    lib = queue.shift
+    next if processed.include?(lib)
+    processed.add(lib)
+
+    macos_dependencies(lib).each do |dep|
+      next if macos_system_library?(dep)
+
+      dep_path = macos_resolve_dependency(dep, libs_dir)
+      next if dep_path.nil?
+
+      dest = File.join(libs_dir, File.basename(dep_path))
+      unless File.exist?(dest)
+        FileUtils.cp(dep_path, dest, verbose: true)
+        copied += 1
+      end
+      queue << dest if File.exist?(dest)
+    end
+  end
+
+  macos_shared_libraries(libs_dir).each do |lib|
+    lib_name = File.basename(lib)
+    system("install_name_tool -id @loader_path/#{lib_name} '#{lib}' 2>/dev/null") if lib.end_with?('.dylib')
+
+    macos_dependencies(lib).each do |dep|
+      next if macos_system_library?(dep)
+
+      dep_basename = File.basename(dep)
+      system("install_name_tool -change '#{dep}' '@loader_path/#{dep_basename}' '#{lib}' 2>/dev/null")
+    end
+  end
+
+  puts "Bundled #{copied} macOS dependencies."
+end
+
 desc 'Test that native extension loads without LD_LIBRARY_PATH'
 task :test_native do
   so_dir = File.expand_path(NATIVE_DIR, __dir__)

data/ext/rdkit_chem/extconf.rb

@@ -16,17 +16,20 @@ 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
+def run_command(command, description)
+  puts description if description
+  success = system(command)
+  abort "ERROR: #{description || command} failed" unless success
+end
+
+FileUtils.mkdir_p rdkit_dir
+Dir.chdir main_dir do
+  FileUtils.rm_rf src_dir
+  run_command('git clone https://github.com/rdkit/rdkit.git', 'Downloading RDKit sources')
+end
 
 Dir.chdir(src_dir) do
-  checkout = 'git checkout c2e48f41d88ddc15c6e1f818d1c4ced70b7f20d1'
-  system checkout
+  run_command('git checkout c2e48f41d88ddc15c6e1f818d1c4ced70b7f20d1', 'Checking out RDKit sources')
 end
 
 FileUtils.cp_r(
@@ -46,6 +49,26 @@ is_linux = host_os =~ /linux/
 is_mac = host_os =~ /darwin/
 ld_path = ''
 
+# macOS-specific compiler flags to fix Ruby header compatibility issues
+extra_cmake_flags = ''
+if is_mac
+  # -Wno-register: Ruby headers use deprecated 'register' keyword (removed in C++17)
+  # -DHAVE_ISFINITE=1: Prevents Ruby's finite() from conflicting with std::isfinite
+  cxx_flags = '-std=c++17 -stdlib=libc++ -Wno-register -DHAVE_ISFINITE=1'
+  extra_cmake_flags = " -DCMAKE_CXX_FLAGS='#{cxx_flags}'"
+end
+
+# Explicitly specify Ruby paths to avoid CMake finding system Ruby headers
+# This is critical on macOS where Xcode SDK contains incompatible Ruby headers
+ruby_executable = RbConfig.ruby
+ruby_include_dir = RbConfig::CONFIG['rubyhdrdir']
+ruby_arch_include_dir = RbConfig::CONFIG['rubyarchhdrdir']
+
+extra_cmake_flags += " -DRuby_EXECUTABLE=#{ruby_executable}"
+extra_cmake_flags += " -DRuby_INCLUDE_DIR=#{ruby_include_dir}"
+extra_cmake_flags += " -DRuby_CONFIG_INCLUDE_DIR=#{ruby_arch_include_dir}" if ruby_arch_include_dir
+extra_cmake_flags += " -DCMAKE_IGNORE_PREFIX_PATH='/Applications/Xcode.app;/Applications/Xcode_*.app'" if is_mac
+
 if is_linux || is_mac
   ld_string = is_linux ? 'LD_LIBRARY_PATH' : 'DYLD_LIBRARY_PATH'
   ld_path = "#{ld_string}=#{install_dir}/lib"
@@ -56,25 +79,22 @@ end
 
 FileUtils.mkdir_p build_dir
 Dir.chdir build_dir do
-  puts 'Configuring RDKit'
-
   cmake = "#{ld_path} cmake #{src_dir} -DRDK_INSTALL_INTREE=OFF " \
           "-DCMAKE_INSTALL_PREFIX=#{install_dir} " \
           '-DCMAKE_BUILD_TYPE=Release -DRDK_BUILD_PYTHON_WRAPPERS=OFF ' \
           '-DRDK_BUILD_SWIG_WRAPPERS=ON -DRDK_BUILD_INCHI_SUPPORT=OFF ' \
-          '-DBoost_NO_BOOST_CMAKE=ON'
-  system cmake
+          "-DBoost_NO_BOOST_CMAKE=ON -DRDK_USE_BOOST_IOSTREAMS=OFF#{extra_cmake_flags}"
+  run_command(cmake, 'Configuring RDKit')
 end
 
 # local installation in gem directory
 Dir.chdir build_dir do
-  puts 'Compiling RDKit sources.'
-  system "#{ld_path} make -j#{nr_processors}"
-  system "#{ld_path} make install"
+  run_command("#{ld_path} make -j#{nr_processors}", 'Compiling RDKit sources')
+  run_command("#{ld_path} make install", 'Installing RDKit sources')
 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,6 @@
 # frozen_string_literal: true
 
 module RDKitChem
-  VERSION = "2025.09.3"
-  GEMVERSION = "#{VERSION}.6"
+  VERSION = '2025.09.3'
+  GEMVERSION = "#{VERSION}.13"
 end

data/lib/rdkit_chem.rb

@@ -8,22 +8,31 @@ require 'rdkit_chem/version'
 
 def find_rdkit_native_extension
   ruby_version = "#{RUBY_VERSION.split('.')[0..1].join('.')}.0"
-
-  # Location 1: Pre-compiled gem (platform-specific)
-  precompiled_path = File.expand_path("rdkit_chem/#{ruby_version}", __dir__)
-  if File.directory?(precompiled_path)
-    return precompiled_path
+  base_dir = File.expand_path('rdkit_chem', __dir__)
+
+  # Location 1: Pre-compiled gem - exact Ruby version match
+  precompiled_path = File.join(base_dir, ruby_version)
+  return precompiled_path if File.directory?(precompiled_path) && has_native_extension?(precompiled_path)
+
+  # Location 2: Pre-compiled gem - any available Ruby version (fallback)
+  # This handles cases where gem was built with different Ruby minor version
+  if File.directory?(base_dir)
+    Dir.glob(File.join(base_dir, '*.0')).sort.reverse.each do |version_dir|
+      return version_dir if has_native_extension?(version_dir)
+    end
   end
 
-  # Location 2: Source-compiled gem (legacy rdkit_chem/lib/)
+  # Location 3: Source-compiled gem (legacy rdkit_chem/lib/)
   source_compiled_path = File.expand_path('../rdkit_chem/lib', __dir__)
-  if File.exist?(File.join(source_compiled_path, 'RDKitChem.so')) ||
-     File.exist?(File.join(source_compiled_path, 'RDKitChem.bundle'))
-    return source_compiled_path
-  end
+  return source_compiled_path if has_native_extension?(source_compiled_path)
+
+  raise LoadError, 'Cannot find RDKitChem native extension. ' \
+                   "Searched in:\n  - #{precompiled_path}\n  - #{base_dir}/*.0\n  - #{source_compiled_path}"
+end
 
-  raise LoadError, "Cannot find RDKitChem native extension. " \
-                   "Searched in:\n  - #{precompiled_path}\n  - #{source_compiled_path}"
+def has_native_extension?(dir)
+  File.exist?(File.join(dir, 'RDKitChem.so')) ||
+    File.exist?(File.join(dir, 'RDKitChem.bundle'))
 end
 
 native_path = find_rdkit_native_extension