rubabel 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6e50e4f083ed06992600b2b86767d0d3a2b00fcf
-  data.tar.gz: e2b4f65a73450c8336b31d650c3c4bfff6981942
+  metadata.gz: 8c407acb50267d5d801e3b17c7ca6c9090f09935
+  data.tar.gz: dc4f917d5688fd3be0b593bb34d3f25edce5b362
 SHA512:
-  metadata.gz: a1e131cbc6b178f52ea340acc11ca1b48b606846cdfe3f21609e9578c7b7ecbd9f5590655c988a1098bc7356e9089a930c5570dc359df09f6384f4349d69c65f
-  data.tar.gz: e626626e6f236810a4e46e41bdcf63da8927e8bfe0bc2d8b271c915ba2fc48dc898012eccf0c535f2b5c95dd1281e3be2c1d99c27c53f9779811613da191629b
+  metadata.gz: 618fb4a2d529cdbf7c3ec1ae1fc85088a92cd4b554d43f95bfa527bb15c1cae946a45474c1553db0a4ab456cf70a7cd5c6566a47856a0a4f4656c251378ff067
+  data.tar.gz: eeb366cb6d73da968fd54dae44e6f64d3edc485a0913742713846ed7b28dabdb89708533d145dfc6ad6bf6b164a6584f8288120e45dc19e82c7af9e9410fa8a2

data/lib/rubabel/molecule.rb

@@ -2,7 +2,6 @@ require 'openbabel'
 require 'rubabel'
 require 'rubabel/atom'
 require 'rubabel/bond'
-require 'rubabel/molecule/fragmentable'
 require 'stringio'
 require 'mini_magick'
 

data/lib/rubabel/version.rb

@@ -1,3 +1,3 @@
 module Rubabel
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubabel
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - John T. Prince
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-07 00:00:00.000000000 Z
+date: 2013-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openbabel
@@ -139,8 +139,7 @@ dependencies:
 description: Ruby interface to the OpenBabel ruby bindings similar to pybel
 email:
 - jtprince@gmail.com
-executables:
-- fragmenter.rb
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -152,7 +151,6 @@ files:
 - README.md
 - Rakefile
 - VERSION
-- bin/fragmenter.rb
 - lib/rubabel.rb
 - lib/rubabel/atom.rb
 - lib/rubabel/bond.rb
@@ -160,7 +158,6 @@ files:
 - lib/rubabel/core_ext/putsv.rb
 - lib/rubabel/fingerprint.rb
 - lib/rubabel/molecule.rb
-- lib/rubabel/molecule/fragmentable.rb
 - lib/rubabel/molecule_data.rb
 - lib/rubabel/pm.rb
 - lib/rubabel/smarts.rb
@@ -186,7 +183,6 @@ files:
 - spec/chemistry_toolkit_rosetta/tpsa.tab
 - spec/rubabel/atom_spec.rb
 - spec/rubabel/bond_spec.rb
-- spec/rubabel/molecule/fragmentable_spec.rb
 - spec/rubabel/molecule_data_spec.rb
 - spec/rubabel/molecule_spec.rb
 - spec/rubabel_spec.rb
@@ -236,7 +232,6 @@ test_files:
 - spec/chemistry_toolkit_rosetta/tpsa.tab
 - spec/rubabel/atom_spec.rb
 - spec/rubabel/bond_spec.rb
-- spec/rubabel/molecule/fragmentable_spec.rb
 - spec/rubabel/molecule_data_spec.rb
 - spec/rubabel/molecule_spec.rb
 - spec/rubabel_spec.rb

data/bin/fragmenter.rb

@@ -1,67 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'trollop'
-require 'rubabel'
-require 'rubabel/molecule/fragmentable'
-
-default_ph = 2.5
-
-Fragment = Struct.new(:frag, :id, :title, :mz, :mass, :charge, :smiles, :pairing)
-
-parser = Trollop::Parser.new do
-  banner "usage: #{File.basename($0)} [OPTIONS|RULES] <SMARTS> ..."
-  text "\noptions:"
-  opt :ph, "the pH to use (experimental option)", :default => default_ph
-  opt :images, "print out svg images of fragments" 
-  opt :format, "format of the molecules", :default => 'smiles'
-  #opt :uniq, "no repeated fragments", :default => false
-  text "\nrules:"
-  Rubabel::Molecule::Fragmentable::RULES.each do |rule|
-    opt rule, rule.to_s.gsub("_",' ')
-  end
-  text "\nexample:"
-  text "fragmenter.rb -xeh 'CCC(=O)OCCC' 'CCC(=O)OCCC(=O)O'"
-end
-
-options = parser.parse(ARGV)
-opts = {rules: []}
-opts[:uniq] = options.delete(:uniq)
-ph = options.delete(:ph)
-opts[:rules] = Rubabel::Molecule::Fragmentable::RULES.map do |rule|
-  rule if options["#{rule}_given".to_sym]
-end.compact
-
-if ARGV.size == 0
-  parser.educate && exit
-end
-
-ARGV.each do |smiles|
-  mol = Rubabel[smiles, options[:format].to_sym]
-  puts "\nmolecule: #{mol.csmiles}"
-  mol.correct_for_ph!(ph)
-  puts "at ph #{ph}: #{mol.csmiles}"
-  fragment_sets = mol.fragment(opts)
-  puts %w(mz mass charge title smiles pairing).join("\t")
-  frags = []
-  fragment_sets.each_with_index do |frag_set,i|
-    frag_set.each_with_index do |frag,j|
-      unless frag.charge == 0
-        mz = (frag.mass / frag.charge).round(5)
-      end
-
-      frag.title = "#{i}-#{j}pair_" + (mz ? "#{mz}_mz" : "#{frag.mass.round(3)}_Mass")
-      frag_obj = Fragment.new(frag, frag.title, frag.title, mz, frag.exact_mass, frag.charge, frag.csmiles, i)
-      frags << frag_obj
-    end
-  end
-  frags = frags.sort_by {|frag| [-frag.charge, frag.mz] }
-  if options[:images]
-    frags.each do |frag|
-      fn = "#{frag.title}.png"
-      frag.frag.write(fn)
-    end
-  end
-  frags.each do |frag|
-    puts [:mz, :mass, :charge, :title, :smiles, :pairing].map {|cat| frag.send(cat) }.join("\t")
-  end
-end

data/lib/rubabel/molecule/fragmentable.rb

@@ -1,162 +0,0 @@
-require 'set'
-require 'rubabel/core_ext/putsv'
-require 'rubabel/core_ext/enumerable'
-
-module Rubabel
-  class Molecule
-    module Fragmentable
-
-      #RULES = Set[:cod, :codoo, :oxe, :oxepd, :oxh]
-      RULES = Set[:cod, :codoo, :oxe, :oxepd, :oxh, :oxhpd]
-
-      DEFAULT_OPTIONS = {
-        rules: RULES,
-        errors: :remove,
-        # return only the set of unique fragments
-        uniq: false, 
-      }
-
-      # molecules and fragments should all have hydrogens added (add_h!)
-      # before calling this method
-      # 
-      # For instance, water loss with double bond formation is not allowable
-      # for NCC(O)CC => CCC=C[NH2+], presumably because of the lone pair and
-      # double bond resonance.
-      def allowable_fragmentation?(frags)
-        self.num_atoms(true) == frags.reduce(0) {|cnt,fr| cnt + fr.num_atoms(true) }
-      end
-
-      # splits the molecule between the carbon and carbon_nbr, adds a double
-      # bond between the carbon and oxygen, and moves whatever was on the
-      # oxygen (e.g., an OH or a charge) to the carbon_nbr. Returns two new
-      # molecules.
-      def carbonyl_oxygen_dump(carbon, oxygen, carbon_nbr)
-        appendage = oxygen.atoms.find {|a| a.el != :C }
-        if oxygen.charge != 0
-          ocharge = oxygen.charge
-        end
-        nmol = self.dup
-        new_oxygen = nmol.atom(oxygen.id)
-        new_carbon = nmol.atom(carbon.id)
-        new_carbon_nbr = nmol.atom(carbon_nbr.id)
-        new_appendage = nmol.atom(appendage.id) if appendage
-        nmol.delete_bond(new_carbon.get_bond(new_carbon_nbr))
-        if new_appendage
-          nmol.delete_bond(new_oxygen.get_bond(new_appendage)) 
-          nmol.add_bond!(new_carbon_nbr, new_appendage)
-        end
-        if ocharge
-          new_carbon_nbr.charge += ocharge
-          new_oxygen.charge -= ocharge
-        end
-        new_carbon.get_bond(new_oxygen).bond_order = 2
-        nmol.split
-      end
-
-      # breaks the bond and gives the electrons to the oxygen
-      def carbon_oxygen_esteal(carbon, oxygen)
-        nmol = self.dup
-        ncarbon = nmol.atom(carbon.id)
-        noxygen = nmol.atom(oxygen.id)
-
-        is_carboxyl = noxygen.carboxyl_oxygen?
-        
-        nmol.delete_bond(ncarbon, noxygen)
-        ncarbon.remove_a_hydride!
-        noxygen.remove_a_proton! 
-        nmol.split
-      end
-
-      # returns the duplicated molecule and the equivalent atoms
-      def dup_molecule(atoms=[])
-        nmol = self.dup
-        [nmol, atoms.map {|old_atom| nmol.atom(old_atom.id) }]
-      end
-
-      # returns molecules created from splitting between the electrophile and
-      # the center and where the bond order is increased between the center
-      # and center_nbr
-      def break_with_double_bond(electrophile, center, center_nbr)
-        (nmol, (nele, ncarb, ncarb_nbr)) = self.dup_molecule([electrophile, center, center_nbr])
-        nmol.delete_bond(nele, ncarb)
-        ncarb_nbr.get_bond(ncarb) + 1
-        nmol.split
-      end
-
-      # an empty array is returned if there are no fragments generated.
-      # Hydrogens are added at a pH of 7.4, unless they have already been
-      # added.
-      #
-      #     :rules => queryable by :include? set of rules
-      #     :uniq => false
-      #     :errors => :remove | :fix | :ignore  (default is :remove)
-      def fragment(opts={})
-        only_uniqs = true
-        opts = DEFAULT_OPTIONS.merge(opts)
-        opts[:rules].each do |rule| 
-          raise ArgumentError, "bad rule: #{rule}" unless RULES.include?(rule)
-        end
-
-        had_hydrogens = self.h_added?
-        self.correct_for_ph!(7.4) unless had_hydrogens
-        self.remove_h!
-
-        fragment_sets = []
-
-        if opts[:rules].any? {|r| [:cod, :codoo].include?(r) }
-          self.each_match("C[O;h1,O]", only_uniqs) do |carbon, oxygen|
-            carbon.atoms.select {|a| a.el == :C }.each do |carbon_nbr|
-              fragment_sets << carbonyl_oxygen_dump(carbon, oxygen, carbon_nbr)
-            end
-          end
-        end
-        if opts[:rules].any? {|r| [:oxe].include?(r) }
-          self.each_match("C-O", only_uniqs) do |carbon, oxygen|
-            fragment_sets << carbon_oxygen_esteal(carbon, oxygen)
-          end
-        end
-        # right now implemented so that a beta hydrogen has to be availabe for
-        # extraction
-        if opts[:rules].any? {|r| [:oxh].include?(r) }
-          self.each_match("C[C,O]-O", only_uniqs) do |beta_c, center, oxygen|
-            next unless beta_c.hydrogen_count > 0
-            fragment_sets << break_with_double_bond(oxygen, center, beta_c)
-          end
-        end
-        if opts[:rules].any? {|r| [:oxhpd].include?(r) }
-          self.each_match("C-O-P-O", only_uniqs) do |carbon, alc_oxy, phosphate, beta_carb_oxy|
-            next unless beta_carb_oxy.hydrogen_count > 0
-            frag_set = break_with_double_bond(alc_oxy, phosphate, beta_carb_oxy)
-            frag_set.map! &:convert_dative_bonds!
-            fragment_sets << frag_set
-          end
-        end
-        if opts[:rules].any? {|r| [:oxepd].include?(r) }
-          self.each_match("P-O-C", only_uniqs) do |phosphate, oxygen, carbon|
-            frag_set = carbon_oxygen_esteal(phosphate, oxygen)
-            frag_set.map! &:convert_dative_bonds!
-            fragment_sets << frag_set
-          end
-        end
-
-        case opts[:errors]
-        when :remove
-          fragment_sets.select! {|set| allowable_fragmentation?(set) }
-        when :fix
-          raise NotImplementedError
-        when :ignore  # do nothing
-        end
-
-        self.remove_h!
-        if opts[:uniq]
-          # TODO: impelent properly
-          raise NotImplementedError
-          #fragment_sets = fragment_sets.uniq_by(&:csmiles)
-        end
-
-        fragment_sets
-      end
-    end
-    include Fragmentable
-  end
-end # Rubabel

data/spec/rubabel/molecule/fragmentable_spec.rb

@@ -1,199 +0,0 @@
-require 'spec_helper'
-
-require 'rubabel'
-
-$VERBOSE = nil
-
-describe Rubabel::Molecule::Fragmentable do
-
-  # :peroxy_to_carboxy
-  # :oxygen_asymmetric_sp3, :nitrogen_asymmetric_sp3,
-  # :internal_phosphoester
-
-  describe 'fragmentation rules' do
-    # coenzyme: CC1=CC(=O)C=CC1=O
-    # 2-methylcyclohexa-2,5-diene-1,4-dione
-
-    #let(:test_mol) { "COP(=O)(O)OCNCOCC(OO)C(=O)O" }
-
-    it 'raises an error for a bad rule' do
-      mol = Rubabel["CCNC"]
-      expect { mol.fragment(rules: [:wackiness]) }.to raise_error
-    end
-
-    describe 'cod: carbonyl appendage dump' do
-      # a primary oxygen or peroxide => C=O appendage dump
-      
-      specify 'cod: primary alcohol' do
-        mol = Rubabel["NCC(O)CC"]
-        frags = mol.fragment(rules: [:cod])
-        frags.flatten(1).map(&:csmiles).should == ["C[NH3+]", "CCC=O", "C([NH3+])C=O", "CC"]
-      end
-
-      specify 'peroxide' do
-        mol = Rubabel["NCC(OO)CC"]
-        frags = mol.fragment(rules: [:codoo])
-        frags.flatten(1).map(&:csmiles).should == ["OC[NH3+]", "CCC=O", "C([NH3+])C=O", "CCO"]
-      end
-
-      specify 'cod: carboxylate' do
-        mol = Rubabel["CCC(=O)O"]
-        pieces = mol.fragment(rules: [:cod])
-        pieces.flatten(1).map(&:csmiles).should == ["[CH2-]C", "O=C=O"]
-      end
-
-      specify 'cod: carboxylic acid' do
-        mol = Rubabel["CCC(=O)O"]
-        mol.add_h!(1.5)
-        pieces = mol.fragment(rules: [:cod])
-        pieces.flatten(1).map(&:csmiles).should == ["CC", "O=C=O"]
-      end
-    end
-
-    describe 'oxe: oxygen electron stealing' do
-      # oxygen just steals the electron pair it is attached to.  This
-      # typically results in a negatively charged oxygen and a positively
-      # charged carbo-cation.
-      specify 'ether to ions' do
-        mol = Rubabel["CCOCCN"]
-        frag_set = mol.fragment(rules: [:oxe])
-        frags = frag_set.first
-        frags.first.csmiles.should == "C[CH2+]"
-        frags.last.csmiles.should == '[O-]CC[NH3+]'
-        frags.first.formula.should == 'C2H5+'
-        frags.last.formula.should == 'C2H7NO'
-        frags.first.exact_mass.should be_within(1e-6).of(29.03912516)
-        frags.last.exact_mass.should be_within(1e-6).of(61.052763849)
-      end
-
-      specify 'ester to ions' do
-        mol = Rubabel["CCOC(=O)CCN"]
-        frag_set = mol.fragment(rules: [:oxe])
-        ff = frag_set.first
-        ff.first.csmiles.should == 'C[CH2+]'
-        ff.last.csmiles.should == '[O-]C(=O)CC[NH3+]'
-        ff.first.formula.should == "C2H5+"
-
-        ff.last.formula.should == "C3H7NO2"
-        ff.first.exact_mass.should be_within(1e-6).of(29.03912516035)
-        ff.last.exact_mass.should be_within(1e-6).of(89.04767846841)
-      end
-
-      specify 'carboxyl group' do
-        mol = Rubabel["CCC(=O)O"]
-        frag_set = mol.fragment(rules: [:oxe])
-        ff = frag_set.first
-        ff.first.csmiles.should == 'CC[C+]=O'
-        # this is a carboxylate oxygen that falls off
-        ff.last.csmiles.should == '[O-2]'
-        #ff.first.formula.should == "C3H5O"
-        ff.first.formula.should == "C3H5O+"
-        ff.first.exact_mass.should be_within(1e-6).of(57.034039779909996)
-        #ff.last.formula.should == "O"
-        ff.last.formula.should == "O--"
-      end
-
-      specify 'phosphodiester' do
-        mol = Rubabel["CC(COP(=O)([O-])OCCN"]
-        frag_set = mol.fragment(rules: [:oxepd])
-        ff = frag_set.first
-        ff.first.csmiles.should == '[O-]CCC' 
-        #ff.last.csmiles.should == '[NH3+]CCO[P](=O)=O'
-        ff.last.csmiles.should == "[NH3+]CCOP(=O)=O"
-        #ff.first.formula.should == 'C3H7O'
-        ff.first.formula.should == 'C3H7O-'
-        ff.first.exact_mass.should be_within(1e-6).of(59.049689844)
-        #ff.last.formula.should == 'C2H7NO3P'
-        ff.last.formula.should == 'C2H7NO3P+'
-        ff.last.exact_mass.should be_within(1e-6).of(124.016354719)
-
-        mol = Rubabel["CCCOP(=O)(OCC[N+](C)(C)C)[O-]"]
-        frag_set = mol.fragment(rules: [:oxepd, :oxe])
-        # some of these don't like right on first inspection, but that is
-        # because we 'converted dative bonds' meaning + and - next to each
-        # other are allowed to cancel one another out!
-        frag_set.size.should == 4
-        mols = frag_set.flatten
-        mols.map(&:csmiles).should == ["CC[CH2+]", "[O-]P(=O)(OCC[N+](C)(C)C)[O-]", "CCCOP(=O)([O-])[O-]", "[CH2+]C[N+](C)(C)C", "[O-]CCC", "O=P(=O)OCC[N+](C)(C)C", "CCCOP(=O)=O", "[O-]CC[N+](C)(C)C"]
-        mols.map(&:formula).should == ["C3H7+", "C5H13NO4P-", "C3H7O4P--", "C5H13N++", "C3H7O-", "C5H13NO3P+", "C3H7O3P", "C5H13NO"]
-        mols.map(&:exact_mass).zip([43.05477522449, 182.05821952995, 138.00819533273, 87.10479942171, 59.04968984405, 166.06330491039, 122.01328071317, 103.09971404127]) do |act, exp|
-          act.should be_within(1e-6).of(exp)
-        end
-
-      end
-    end
-
-    # this is really a subset of oxygen bond stealing: if the negatively
-    # charged oxygen can rip off a nearby proton, it will.
-    describe 'oxh: oxygen alpha/beta/gamma hydrogen stealing' do
-      specify 'primary alcohol giving water loss' do
-        mol = Rubabel["CC(O)CCN"]
-        frags = mol.fragment(rules: [:oxh])
-        ff = frags.first
-        ff.first.csmiles.should == 'C=CCC[NH3+]'
-        ff.last.csmiles.should == 'O'
-        ll = frags.last
-        ll.first.csmiles.should == 'CC=CC[NH3+]'
-        ll.last.csmiles.should == 'O'
-        #ff.first.formula.should == 'C4H10N'
-        ff.first.formula.should == 'C4H10N+'
-        ff.first.exact_mass.should be_within(1e-6).of(72.0813243255)
-      end
-
-      specify 'peroxide carbonyl formation (or peroxide formation [that what we want??])' do
-        # do we really see peroxide formation?  Tamil didn't include this in
-        # the rules but it follows from the broad way for creating these
-        # rules.  Can prohibit peroxide formation in future if necessary...
-        mol = Rubabel["CC(OO)CCN"]
-        frags = mol.fragment(rules: [:oxh])
-        mols = frags.flatten
-        mols.map(&:csmiles).should == ["C=CCC[NH3+]", "OO", "CC(=O)CC[NH3+]", "O", "CC=CC[NH3+]", "OO"]
-        mols.map(&:formula).should == ["C4H10N+", "H2O2", "C4H10NO+", "H2O", "C4H10N+", "H2O2"]
-        #mols.map(&:formula).should == ["C4H10N", "H2O2", "C4H10NO", "H2O", "C4H10N", "H2O2"]
-        mols.map(&:exact_mass).zip([72.081324325, 34.005479304, 88.076238945, 18.010564684, 72.081324325, 34.005479304]) do |act, exp|
-          act.should be_within(1e-6).of(exp)
-        end
-      end
-
-      specify 'ether to alcohol, ignoring errors' do
-        # this is a good example of a 'disallowed structure' where the
-        # formula's do not match up to the original formulas
-        mol = Rubabel["CCOCCN"]
-        frags = mol.fragment(rules: [:oxh], errors: :ignore)
-        mols = frags.flatten
-        mols.map(&:csmiles).should == ["C=C", "OCC[NH3+]", "CCO", "C=C[NH2+]"]
-      end
-
-      specify 'ether to alcohol, removing errors' do
-        mol = Rubabel["CCOCCN"]
-        frags = mol.fragment(rules: [:oxh])
-        mols = frags.flatten
-        mols.map(&:csmiles).should == ["C=C", "OCC[NH3+]"]
-      end
-
-      specify 'ester to alcohol' do
-        mol = Rubabel["CC(=O)OCCCN"]
-        frags = mol.fragment(rules: [:oxh])
-        mols = frags.flatten
-        mols.map(&:csmiles).should == ["C=C=O", "OCCC[NH3+]", "CC(=O)O", "C=CC[NH3+]"]
-        #mols.map(&:formula).should == ["C2H2O", "C3H10NO", "C2H4O2", "C3H8N"]
-        mols.map(&:formula).should == ["C2H2O", "C3H10NO+", "C2H4O2", "C3H8N+"]
-        mols.map(&:exact_mass).zip([42.010564684, 76.076238945, 60.021129368000004, 58.065674261]) do |act,exp|
-          act.should be_within(1e-6).of(exp)
-        end
-      end
-
-      specify 'phosphodiester (right now needs very low pH and NOT SURE WORKING PROPERLY)' do
-        mol = Rubabel["CC(COP(=O)(O)OCCCN"]
-        mol.add_h!(1.0)
-        frags = mol.fragment(rules: [:oxhpd])
-        frags = frags.flatten
-        frags.map(&:csmiles).should == ["CCCO", "[NH3+]CCCOP(=O)=O", "CCCOP(=O)=O", "OCCC[NH3+]"]
-      end
-    end
-
-  end
-end
-
-
-