rubabel 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2012 Brigham Young University
+authored by: John T. Prince
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,52 @@
+= rubabel
+
+Ruby interface to the openbabel ruby bindings (or the openbabel gem).  The
+interface attempts to be a ruby-ish analogue of
+{pybel}[http://openbabel.org/docs/current/UseTheLibrary/Python_PybelAPI.html].
+
+== Examples
+
+    Rubabel.foreach("file.sdf") do |mol|
+      print mol.write  # -> canonical smiles: "smiles_string\tname\n"
+      puts mol  # .to_s -> canonical smiles string with no name or newline
+      puts mol.exact_mass
+    end
+
+    uniq_atom_types = Rubabel.foreach("file.mol").map(&:type).uniq
+
+== Installing
+
+=== Install openbabel
+
+First, make sure you have the ruby openbabel bindings properly installed.  You can do this by {properly installing the gem][https://github.com/amaunz/openbabel-gem].  Alternatively, you can following these instructions to build from source:
+
+1. download openbabel 
+2. swap out Init_OpenBabel for Init_openbabel in scripts/ruby/openbabel-ruby.cpp (see here[http://forums.openbabel.org/Ruby-Open-Babel-in-2-1-1-td957640.html]).  Some versions have this fixed already, apparently.
+3. make sure you have the right {dependencies to compile}(http://openbabel.org/docs/2.3.1/Installation/install.html#compiling-open-babel)
+
+Here's a complete example of compiling for a single user on Ubuntu 11.10 and probably will be generally forward compatible for some time.  This will compile bindings on whichever ruby comes up with '/usr/bin/env ruby':
+
+    # install the dependencies:
+    sudo apt-get install libeigen2-dev cmake libwxgtk2.8-dev libxml2-dev libcairo2-dev
+    # unpack it:
+    tar -xzvf openbabel-2.3.1.tar.gz
+    # swap out buggy lines in ruby bindings:
+    sed -i 's/Init_OpenBabel/Init_openbabel/g' openbabel-2.3.1/scripts/ruby/openbabel-ruby.cpp
+    # make a separate build directory for building in:
+    mkdir build-rvmruby1.9.3
+    cd build-rvmruby1.9.3
+    mkdir ~/tools
+    cmake ../openbabel-2.3.1 -DRUBY_BINDINGS=ON -DCMAKE_INSTALL_PREFIX=~/tools/openbabel-rvmruby1.9.3
+    make && make install
+
+=== Install the gem
+
+    gem install rubabel
+
+Assuming you have the {dependencies for the openbabel gem}[https://github.com/amaunz/openbabel-gem], you could install in one go like this:
+
+    gem install openbabel rubabel
+ 
+== Copyright
+
+MIT License.  See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,43 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "rubabel"
+  gem.homepage = "http://github.com/princelab/rubabel"
+  gem.license = "MIT"
+  gem.summary = %Q{Ruby interface to the OpenBabel ruby bindings similar to pybel}
+  gem.description = %Q{Ruby interface to the openbabel ruby bindings (or the openbabel gem).  The
+interface attempts to be a ruby-ish analogue of pybel.}
+  gem.email = "jtprince@gmail.com"
+  gem.authors = ["John T. Prince"]
+  [
+    ["rspec", "~> 2.8.0"], 
+    ["rdoc", "~> 3.12"], 
+    ["jeweler", "~> 1.8.3"]
+  ].each do |name, version_string|
+    gem.add_development_dependency(name, version_string)
+  end
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubabel #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rubabel.rb

@@ -0,0 +1,116 @@
+require 'openbabel'
+
+%w(atom molecule fingerprint smarts molecule_data).each do |klass|
+  require "rubabel/#{klass}"
+end
+
+module Rubabel
+  # the command to execute the utility.  They are initialized to be eponymous.
+  CMD = {
+    babel: 'babel',
+    obabel: 'obabel',
+  }
+
+  class << self
+
+    # returns a hash keyed by type (Symbol) pointing to a description of the
+    # format
+    def in_formats
+      @in_formats ||= formats_to_hash(OpenBabel::OBConversion.new.get_supported_input_format)
+    end
+
+    # returns a hash keyed by type (Symbol) pointing to a description of the
+    # format
+    def out_formats
+      @out_formats ||= formats_to_hash(OpenBabel::OBConversion.new.get_supported_output_format)
+    end
+
+    # determines the extension from filename if type is nil
+    def foreach(filename, type=nil, &block)
+      block or return enum_for(__method__, filename, type)
+      (obmol, obconv, not_at_end) = read_first_obmol(filename, type)
+      # the obmol is not valid if we are already at the end!
+      while not_at_end
+        block.call Rubabel::Molecule.new(obmol)
+        obmol = OpenBabel::OBMol.new
+        not_at_end = obconv.read(obmol)
+      end
+    end
+
+    # returns a Rubabel::Molecule (the first in the file if there are
+    # multiples).  See ::foreach for accessing all molecules in a file
+    # determines the type from the extension if type is nil.
+    def read_file(filename, type=nil)
+      obmol = read_first_obmol(filename, type).first
+      Rubabel::Molecule.new(obmol)
+    end
+
+    # reads one molecule from the string
+    def read_string(string, type=:smi)
+      obmol = OpenBabel::OBMol.new
+      obconv = OpenBabel::OBConversion.new
+      obconv.set_in_format(type.to_s) || raise(ArgumentError, "invalid format #{type}")
+      success = obconv.read_string(obmol, string)
+      Rubabel::Molecule.new(obmol)
+    end
+
+    # returns a filetype symbol based on the extension
+    def filetype(filename)
+      # should use the openbabel method in the future
+      File.extname(filename)[1..-1].to_sym
+    end
+
+    private
+    # reads the first entry and returns the OBMol object, the OBConversion object,
+    # and the boolean not_at_end.  This method is not intended for public usage
+    # but is necessary based on discrepancies between accessing the first
+    # molecule and subsequent molecules.
+    def read_first_obmol(filename, type=nil)
+      type ||= filetype(filename)
+      obconv = OpenBabel::OBConversion.new
+      obconv.set_in_format(type.to_s) || raise(ArgumentError, "invalid format #{type}")
+      obmol = OpenBabel::OBMol.new
+      not_at_end = obconv.read_file(obmol, filename)
+      [obmol, obconv, not_at_end]
+    end
+
+    def formats_to_hash(format_strings)
+      Hash[ 
+        format_strings.map do |str| 
+          pair = str.split(/\s+--\s+/)
+          [pair[0].to_sym, pair[1]]
+        end 
+      ]
+    end
+  end
+
+  #protected_class_method :read_first_obmol
+
+end
+
+module Rubabel
+  # capitalized strings
+  ELEMENTS = %w(H He Li Be B C N O F Ne Na Mg Al Si P S Cl Ar K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn Ga Ge As Se Br Kr Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Xe Cs Ba La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg Tl Pb Bi Po At Rn Fr Ra Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr Rf Db Sg Bh Hs Mt Ds Rg Cn Uut Fl Uup Lv Uus Uuo)
+
+  # atomic number to properly capitalized element abbreviation
+  NUM_TO_ELEMENT = Hash[ ELEMENTS.each_with_index.map {|el,i| [i+1,el] } ]
+
+  # atomic number to lowercase symbol abbreviation
+  NUM_TO_EL = Hash[ ELEMENTS.each_with_index.map {|el,i| [i+1,el.downcase.to_sym] } ]
+end
+
+=begin
+OBConversion conv;
+OBMol mol;
+bool success = conv.SetInFormat("sdf");
+if(success)
+  {
+    bool notatend = conv.ReadFile(&mol, "myfile.sdf");
+    // Do something with mol
+    while(notatend)
+      {
+        notatend = conv.Read(&mol);
+        // Do something with mol
+      }
+  }
+=end

data/lib/rubabel/atom.rb

@@ -0,0 +1,143 @@
+require 'matrix'
+
+require 'rubabel/bond'
+
+class OpenBabel::OBAtom
+  def upcast
+    Rubabel::Atom.new(self)
+  end
+end
+
+module Rubabel
+  class Atom
+    include Enumerable
+
+    # the OpenBabel::OBAtom object
+    attr_accessor :ob
+
+    def initialize(obatom)
+      @ob = obatom
+    end
+
+    def id
+      @ob.get_id
+    end
+
+    def id=(val)
+      @ob.set_id(val)
+    end
+
+    # index of the atom (begins with 1)
+    def idx
+      @ob.get_idx
+    end
+
+    # abbreviated name, all lowercase as a Symbol
+    def el
+      NUM_TO_EL[atomic_num]
+    end
+
+    # abbreviated name, properly capitalized and as a String
+    def element
+      NUM_TO_ELEMENT[atomic_num]
+    end
+
+    def each_bond(&block)
+      block or return enum_for(__method__)
+      iter = @ob.begin_bonds
+      _bond = @ob.begin_bond(iter)
+      while _bond
+        block.call _bond.upcast
+        _bond = @ob.next_bond(iter)
+      end
+    end
+
+    alias_method :each, :each_bond
+
+    # returns the bonds.  Consider using each_bond.
+    def bonds
+      each_bond.map.to_a
+    end
+
+    # iterates through each neighboring atom
+    def each_atom(&block)
+      block or return enum_for(__method__)
+      iter = @ob.begin_bonds
+      _atom = @ob.begin_nbr_atom(iter)
+      while _atom
+        block.call _atom.upcast
+        _atom = @ob.next_nbr_atom(iter)
+      end
+    end
+
+    # returns the neighboring atoms.  Consider using each_atom.
+    def atoms
+      each_atom.map.to_a
+    end
+
+    def atomic_mass
+      @ob.get_atomic_mass
+    end
+
+    def atomic_num
+      @ob.get_atomic_num
+    end
+
+    def exact_mass
+      @ob.get_exact_mass
+    end
+
+    def formal_charge
+      @ob.get_formal_charge
+    end
+    alias_method :charge, :formal_charge
+
+    def heavy_valence
+      @ob.get_heavy_valence
+    end
+
+    def hetero_valence
+      @ob.get_hetero_valence
+    end
+
+    def hyb
+      @ob.get_hybridization
+    end
+
+    def implicit_valence
+      @ob.get_implicit_valence
+    end
+
+    def isotope
+      @ob.get_isotope
+    end
+
+    def partial_charge
+      @ob.get_partial_charge
+    end
+
+    def spin
+      @ob.get_spin_multiplicity
+    end
+
+    def type
+      @ob.get_type
+    end
+
+    def valence
+      @ob.get_valence
+    end
+
+    def vector
+      @ob.get_vector
+    end
+
+    def coords
+      Vector[@ob.x, @ob.y, @ob.z]
+    end
+
+    def inspect
+      "<#{type} id:#{id}>"
+    end
+  end
+end

data/lib/rubabel/bond.rb

@@ -0,0 +1,47 @@
+require 'rubabel/atom'
+
+class OpenBabel::OBBond
+  def upcast
+    Rubabel::Bond.new(self)
+  end
+end
+
+
+module Rubabel
+
+  # delegates to obbond object if the method is missing
+  class Bond
+    include Enumerable
+
+    attr_accessor :ob
+
+    def initialize(obbond)
+      @ob = obbond
+    end
+
+    # considered included if the atom ids match
+    def include?(atom)
+      # atoms.any? {|atm| atom.id == atm.id }
+      (@ob.get_begin_atom.get_id == atom.id) || (@ob.get_end_atom.get_id == atom.id)
+    end
+
+    def each_atom(&block)
+      block or return enum_for(__method__)
+      block.call @ob.get_begin_atom.upcast
+      block.call @ob.get_end_atom.upcast
+      self
+    end
+
+    alias_method :each, :each_atom
+
+    # returns an array of Rubabel::Atoms
+    def atoms
+      [@ob.get_begin_atom.upcast, @ob.get_end_atom.upcast]
+    end
+
+    def inspect
+      "[#{atoms.map(&:inspect).join('-')}]"
+    end
+
+  end
+end

data/lib/rubabel/fragmentation.rb

@@ -0,0 +1,23 @@
+
+module Rubabel
+  class Fragmentation
+
+    ADDUCTS = [:lioh, :nh4cl, :nh4oh]
+
+    DEFAULTS = {
+      ph: 7.4,
+      adducts: [],
+    }
+
+    def initialize(mol, options)
+      @mol = mol
+      @options = options
+    end
+
+    def fragment(rules=[:co])
+    end
+
+
+
+  end
+end