rubabel 0.2.1 → 0.2.2

data/README.md

@@ -120,7 +120,7 @@ Have some bonds to break?, split makes new molecules split from that bond(s)
     bonds = mol.matches("CO").map {|c, o| c.get_bond(o) }
     mol.split(*bonds)  # splits between every carbon single bonded to oxygen
 
-### Add & Delete atoms/bonds
+### Add, delete, modify atoms/bonds
 
 #### Adding
 
@@ -147,6 +147,16 @@ Have some bonds to break?, split makes new molecules split from that bond(s)
     bond = mol[0].get_bond(mol[1])
     mol.delete(bond)  # ->  #<Mol C.O>
 
+#### Modifying
+
+Can add or subtract from bonds to change bond order:
+
+    mol = Rubabel["CC"]
+    mol[0].get_bond(mol[1]) + 1   # now it is a double bond
+    bond = mol[0].bonds.first
+    bond - 1 
+    bond.bond_order   # => 1
+
 ## Installing
 
 First, many thanks to Andreas Maunz for packaging openbabel as a gem which makes this install quite painless.

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.2.2

data/bin/fragmenter.rb

@@ -4,40 +4,64 @@ 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 => Rubabel::Molecule::Fragmentable::DEFAULT_OPTIONS[:ph]
+  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 -aecsoxn 'CCC(=O)OCCC' 'CCC(=O)OCCC(=O)O'"
+  text "fragmenter.rb -xeh 'CCC(=O)OCCC' 'CCC(=O)OCCC(=O)O'"
 end
 
-rules = parser.parse(ARGV)
-options = {rules: []}
-options[:ph] = rules.delete(:ph)
-options[:uniq] = rules.delete(:uniq)
-rules.each do |k,v|
-  options[:rules] << k if v && k.to_s !~ /_given/
-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 |mol|
-  mol = Rubabel[mol]
+ARGV.each do |smiles|
+  mol = Rubabel[smiles, options[:format].to_sym]
   puts "\nmolecule: #{mol.csmiles}"
-  fragment_sets = mol.fragment(options)
-  fragment_sets.each do |frag_set|
-    puts ""
-    frag_set.each do |frag|
-      puts "#{frag.mass.round(5)} #{frag.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/atom.rb

@@ -1,3 +1,5 @@
+#encoding: utf-8
+
 require 'matrix'
 require 'andand'
 
@@ -184,7 +186,7 @@ module Rubabel
         end
       @ob.set_spin_multiplicity(new_spin)
       atoms.each do |atom|
-        if atom.atomic_num == 1
+        if atom.hydrogen?
           self.mol.delete_atom(atom)
           break
         end
@@ -246,6 +248,10 @@ module Rubabel
       @ob.get_spin_multiplicity
     end
 
+    def spin=(val)
+      @ob.set_spin_multiplicity(val)
+    end
+
     def type
       @ob.get_type
     end
@@ -292,6 +298,13 @@ module Rubabel
     def hbond_donor?() @ob.is_hbond_donor end
     def hbond_donor_h?() @ob.is_hbond_donor_h end
 
+    # the total number of hydrogens bonded to the atom (implicit + explicit)
+    def hydrogen_count
+      @ob.implicit_hydrogen_count + @ob.explicit_hydrogen_count
+    end
+
+    alias_method :num_h, :hydrogen_count
+
     def double_bond?
       each_bond.any? {|bond| bond.bond_order == 2 }
     end

data/lib/rubabel/bond.rb

@@ -1,3 +1,5 @@
+#encoding: utf-8
+
 require 'rubabel/atom'
 
 class OpenBabel::OBBond
@@ -88,7 +90,29 @@ module Rubabel
     end
 
     def inspect
-      "[#{atoms.map(&:inspect).join('-')}]"
+      bond_symbol = case bond_order
+      when 2 then '='
+      when 3 then '≡'
+      else 
+        '-'
+      end
+      "#{atoms.map(&:inspect).join(bond_symbol)}"
+    end
+
+    # returns self
+    def +(val)
+      # do we need to check the bounds here?
+      newval = @ob.get_bond_order + val
+      @ob.set_bond_order(newval)
+      self
+    end
+
+    # won't decrease below zero. returns self
+    def -(val)
+      newval = @ob.get_bond_order - val
+      newval = 0 if newval < 0
+      @ob.set_bond_order(newval)
+      self
     end
 
   end

data/lib/rubabel/molecule.rb

@@ -503,7 +503,13 @@ module Rubabel
     end
 
     # sensitive to add_h!
-    def num_atoms() @ob.num_atoms  end
+    def num_atoms(count_implied_hydrogens=false) 
+      if !count_implied_hydrogens
+        @ob.num_atoms  
+      else
+        @ob.num_atoms + reduce(0) {|cnt, atom| cnt + atom.ob.implicit_hydrogen_count }
+      end
+    end
     def num_bonds() @ob.num_bonds  end
     def num_hvy_atoms() @ob.num_hvy_atoms  end
     def num_residues() @ob.num_residues  end

data/lib/rubabel/molecule/fragmentable.rb

@@ -6,21 +6,12 @@ module Rubabel
   class Molecule
     module Fragmentable
 
-      #:sp3c_oxygen_asymmetric_far_sp3, :sp3c_nitrogen_asymmetric_far_sp3,
-      #RULES = Set[ :alcohol_to_aldehyde, :peroxy_to_carboxy, :co2_loss, 
-      #  :sp3c_oxygen_double_bond_far_side_sp3, :sp3c_oxygen_double_bond_far_side_sp2, :sp3c_oxygen_double_bond_water_loss, :sp3c_nitrogen_double_bond,
-      #]
-      #ADDUCTS = [:lioh, :nh4cl, :nh4oh]
-      #CO_RULES = Set[:alcohol_to_aldehyde, :peroxy_to_carboxy, :co2_loss, 
-      #  :sp3c_oxygen_double_bond_water_loss, :sp3c_oxygen_double_bond_far_side_sp2, :sp3c_oxygen_double_bond_far_side_sp3, :sp3c_oxygen_asymmetric_far_sp3
-      #]
-
-      RULES = Set[:cad_o, :cad_oo, :oxed_ether]
+      #RULES = Set[:cod, :codoo, :oxe, :oxepd, :oxh]
+      RULES = Set[:cod, :codoo, :oxe, :oxepd, :oxh, :oxhpd]
 
       DEFAULT_OPTIONS = {
         rules: RULES,
-        #adduct: nil,
-        #ph: 7.4,
+        errors: :remove,
         # return only the set of unique fragments
         uniq: false, 
       }
@@ -31,117 +22,8 @@ module Rubabel
       # 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 == frags.map(&:num_atoms).reduce(:+)
-      end
-
-      # add_h! to self, then selects allowable fragments
-      def allowable_fragment_sets!(fragment_sets)
-        self.add_h!
-        fragment_sets.select do |_frags| 
-          putsv "ExMAIN:"
-          putsv _frags.inspect
-          putsv self.allowable_fragmentation?(_frags)
-          self.allowable_fragmentation?(_frags)
-        end
-      end
-
-      # will turn bond into a double bond, yield the changed molecule, then
-      # return the bond to the original state when the block is closed
-      # returns whatever the block returned
-      def feint_double_bond(bond, give_e_pair=nil, get_e_pair=nil, &block)
-        orig = bond.bond_order
-        bond.bond_order = 2
-        reply = 
-          if give_e_pair || get_e_pair
-            feint_e_transfer(give_e_pair, get_e_pair, &block)
-          else
-            block.call(self)
-          end
-        bond.bond_order = orig
-        reply
-      end
-
-      # warning, this method adds_h! to the calling molecule
-      def electrophile_snatches_electrons(carbon, electrophile)
-        self.add_h!
-        frags = self.split(carbon.get_bond(electrophile))
-        raise NotImplementedError
-        # don't check for allowable fragments because it 
-        #allowable_fragment_sets!([frag_set])
-      end
-
-      def feint_e_transfer(give_e_pair=nil, get_e_pair=nil, &block)
-        if give_e_pair
-          gc_orig = give_e_pair.charge
-          give_e_pair.charge = gc_orig + 1
-        end
-        if get_e_pair
-          rc_orig = get_e_pair.charge
-          get_e_pair.charge = rc_orig - 1
-        end
-
-        reply = block.call(self)
-        
-        give_e_pair.charge = gc_orig if give_e_pair
-        get_e_pair.charge = rc_orig if get_e_pair
-
-        reply
-      end
-
-      def near_side_double_bond_break(carbon, electrophile)
-        frag_sets = carbon.atoms.select {|atom| atom.type == "C3" }.map do |near_c3|
-          frags = feint_double_bond(carbon.get_bond(near_c3)) do |_mol|
-            frags = _mol.split(electrophile.get_bond(carbon))
-            frags.map(&:add_h!)
-          end
-        end
-        allowable_fragment_sets!(frag_sets)
-      end
-
-      def alcohol_to_aldehyde(carbon, oxygen, carbon_nbrs)
-        # alcohol becomes a ketone and one R group is released
-        frag_sets = carbon_nbrs.select {|atom| atom.type == 'C3' }.map do |_atom|
-          frags = feint_double_bond(carbon.get_bond(oxygen)) do |_mol|
-            frags = _mol.split(carbon.get_bond(_atom))
-            frags.map(&:add_h!)
-          end
-        end
-        allowable_fragment_sets!(frag_sets)
-      end
-
-      def co2_loss(carbon, oxygen, c3_nbr)
-        # carboxyl rules ...
-        # neutral carbon dioxide loss with anion gain on attaching group
-        # (if carbon)
-        frags = feint_double_bond(carbon.get_bond(oxygen), oxygen, c3_nbr) do |_mol|
-          frags = _mol.split(c3_nbr.get_bond(carbon))
-          frags.map(&:add_h!)
-        end
-        allowable_fragment_sets!([frags])
-      end
-
-      def peroxy_to_carboxy(carbon, oxygen, carbon_nbrs, oxygen_nbr)
-        if oxygen_nbr.el == :o # has a neighbor oxygen
-          distal_o = oxygen_nbr
-          if distal_o.bonds.size == 1  # this is a peroxy
-            frag_sets = carbon_nbrs.select {|atom| atom.type == 'C3' }.map do |_atom|
-              self.swap!(carbon, _atom, oxygen, distal_o)
-              frags = feint_double_bond(carbon.get_bond(oxygen)) do |_mol|
-
-                # we swapped the atoms so the bond to split off is now
-                # attached to the oxygen
-                frags = _mol.split(oxygen.get_bond(_atom))
-                frags.map(&:add_h!)
-              end
-              self.swap!(carbon, distal_o, oxygen, _atom)
-              frags
-            end
-            allowable_fragment_sets!(frag_sets)
-          end
-        end
-
+        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
@@ -174,29 +56,30 @@ module Rubabel
       # breaks the bond and gives the electrons to the oxygen
       def carbon_oxygen_esteal(carbon, oxygen)
         nmol = self.dup
-        nmol.ob.add_hydrogens
         ncarbon = nmol.atom(carbon.id)
         noxygen = nmol.atom(oxygen.id)
         nmol.delete_bond(ncarbon, noxygen)
-        ncarbon.charge += 1
-        noxygen.charge -= 1
         ncarbon.remove_an_h!
-        #p ncarbon.ob.implicit_hydrogen_count
-        #p ncarbon
-        #ncarbon.ob.decrement_implicit_valence
-        #p ncarbon.ob.implicit_hydrogen_count
-        #p ncarbon
-        #ncarbon.ob.increment_implicit_valence
+        #noxygen.ob.set_spin_multiplicity  1
+        noxygen.spin = 1
+        noxygen.charge = -1
+        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
 
-        nmol.title = nmol.to_s
-        p nmol.write("tmp.svg")
-        parts = nmol.split
-        p z=parts.first
-        p z.formula
-        p z.mass
-        p z.exact_mass
-        
-        puts "HIAY"
+      # 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.
@@ -205,6 +88,7 @@ module Rubabel
       #
       #     :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)
@@ -218,131 +102,60 @@ module Rubabel
 
         fragment_sets = []
 
-        if opts[:rules].any? {|r| [:cad_o, :cad_oo].include?(r) }
+        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| [:oxed_ether].include?(r) }
-          self.each_match("C[O&X2]", only_uniqs) do |carbon, oxygen|
+        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
 
-        unless had_hydrogens
-          fragment_sets.each {|set| set.each(&:remove_h!) }
-          self.remove_h!
+        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) 
+          #fragment_sets = fragment_sets.uniq_by(&:csmiles)
         end
 
         fragment_sets
       end
-
-
-      #        had_hydrogens = self.h_added?
-
-      #self.correct_for_ph!(opts[:ph])
-      #self.remove_h!
-
-      #rules = opts[:rules]
-      #fragment_sets = []
-      #if rules.any? {|rule| CO_RULES.include?(rule) }
-      #putsv "matching C-O"
-      #self.each_match("CO").each do |_atoms|
-      ## note: this will *not* match C=O
-      #(carbon, oxygen) = _atoms
-      #carbon_nbrs = carbon.atoms.reject {|atom| atom == oxygen }
-      #c3_nbrs = carbon_nbrs.select {|atm| atm.type == 'C3' }
-      ## pulling this out here causes it to work incorrectly internally
-      ## (not sure why)
-      ##co_bond = carbon.get_bond(oxygen)
-
-      #case oxygen.bonds.size # non-hydrogen bonds
-      #when 1  # *must* be an alcohol or a carboxylic acid
-      #putsv "#{csmiles} oxygen has no other bonds besides C-O (alcohol or carboxylic acid)"
-      #if carbon.type == 'C3'
-      #if rules.include?(:sp3c_oxygen_double_bond_water_loss) 
-      #putsv "rule :sp3c_oxygen_double_bond_water_loss"
-      #fragment_sets.push *near_side_double_bond_break(carbon, oxygen)
-      #end
-      #if rules.include?(:alcohol_to_aldehyde)
-      #putsv "rule :alcohol_to_aldehyde"
-      #fragment_sets.push *alcohol_to_aldehyde(carbon, oxygen, carbon_nbrs)
-      #end
-      #elsif carbon.carboxyl_carbon?
-      #if rules.include?(:co2_loss)
-      #putsv "rule :co2_loss"
-      #if c3_nbr = c3_nbrs.first
-      #fragment_sets.push *co2_loss(carbon, oxygen, c3_nbr)
-      #end
-      #end
-      #end
-      #when 2
-      #putsv "#{csmiles} c-o & oxygen has 2 non-hydrogen bonds"
-      #oxygen_nbr = oxygen.atoms.reject {|atom| atom.idx == carbon.idx }.first
-      #if carbon.type == 'C3'
-      #if rules.include?(:peroxy_to_carboxy)
-      #fragment_sets.push *peroxy_to_carboxy(carbon, oxygen, carbon_nbrs, oxygen_nbr)
-      #end
-      ## ester and ethers (look *only* on close side for places to make
-      ## double bond)
-
-      #if oxygen_nbr.type == 'C3'
-      #putsv "oxygen nbr is C3"
-      #if rules.include?(:sp3c_oxygen_double_bond_far_side_sp3) 
-      #putsv "rule :sp3c_oxygen_double_bond_far_side_sp3"
-      #fragment_sets.push *near_side_double_bond_break(carbon, oxygen)
-      #end
-      #if rules.include?(:sp3c_oxygen_asymmetric_far_sp3)
-      #putsv "rule :sp3c_oxygen_asymmetric_far_sp3"
-      ## only returns a single frag set
-      #fragment_sets.push electrophile_snatches_electrons(carbon, oxygen)
-      #end
-      #end
-      #if oxygen_nbr.type == 'C2'
-      #if rules.include?(:sp3c_oxygen_double_bond_far_side_sp2)
-      #putsv "rule :sp3c_oxygen_double_bond_far_side_sp2"
-      #fragment_sets.push *near_side_double_bond_break(carbon, oxygen)
-      #end
-      #end
-      ## note: the case of a carboxy is found with CO search
-      #end
-      #end
-      #end
-      #end
-      #if rules.include?(:sp3c_nitrogen_double_bond)
-      #self.each_match("CN") do |_atoms|
-      #(carbon, nitrogen) = _atoms
-      #num_nitrogen_bonds = nitrogen.bonds.size
-      #case num_nitrogen_bonds
-      #when 2
-      #if carbon.type == 'C3'
-      #fragment_sets.push *near_side_double_bond_break(carbon, nitrogen)
-      #end
-      #end
-      #end
-      #end
-
-      #unless had_hydrogens
-      #fragment_sets.each {|set| set.each(&:remove_h!) }
-      #self.remove_h!
-      #end
-      #if opts[:uniq]
-      ## TODO: impelent properly
-      ##fragment_sets = fragment_sets.uniq_by(&:csmiles) 
-      #raise NotImplementedError
-      #end
-      #fragment_sets
-      #end
-
     end
     include Fragmentable
   end
-end
-
+end # Rubabel

data/spec/rubabel/molecule/fragmentable_spec.rb

@@ -4,226 +4,184 @@ require 'rubabel'
 
 $VERBOSE = nil
 
-#describe Rubabel::Molecule::Fragmentable do
+describe Rubabel::Molecule::Fragmentable do
 
-  ## :peroxy_to_carboxy
-  ## :oxygen_asymmetric_sp3, :nitrogen_asymmetric_sp3,
-  ## :internal_phosphoester
+  # :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
+  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
+    it 'raises an error for a bad rule' do
+      mol = Rubabel["CCNC"]
+      expect { mol.fragment(rules: [:wackiness]) }.to raise_error
+    end
 
-    #describe 'cad_o: carbonyl appendage dump ' do
-      ## a primary oxygen or peroxide => C=O appendage dump
+    describe 'cod: carbonyl appendage dump' do
+      # a primary oxygen or peroxide => C=O appendage dump
       
-      #describe 'cad_o: primary alcohol' do
-        #mol = Rubabel["NCC(O)CC"]
-        #frags = mol.fragment(rules: [:cad_o])
-        #frags.flatten(1).map(&:csmiles).should == ["C[NH3+]", "CCC=O", "C([NH3+])C=O", "CC"]
-      #end
-
-      #describe 'peroxide' do
-        #mol = Rubabel["NCC(OO)CC"]
-        #frags = mol.fragment(rules: [:cad_oo])
-        #frags.flatten(1).each_with_index do |f,i|
-          #f.write("mol#{i}.svg")
-        #end
-        #frags.flatten(1).map(&:csmiles).should == ["OC[NH3+]", "CCC=O", "C([NH3+])C=O", "CCO"]
-      #end
-
-      #describe 'cad_o: carboxylate' do
-        #mol = Rubabel["CCC(=O)O"]
-        #pieces = mol.fragment(rules: [:cad_o])
-        #pieces.flatten(1).map(&:csmiles).should == ["[CH2-]C", "O=C=O"]
-      #end
-
-      #describe 'cad_o: carboxylic acid' do
-        #mol = Rubabel["CCC(=O)O"]
-        #mol.add_h!(1.5)
-        #pieces = mol.fragment(rules: [:cad_o])
-        #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.
-      #describe 'ether to ions' do
-        #mol = Rubabel["NCCOCC"]
-        ##mol.add_h!
-        #pieces = mol.fragment(rules: [:oxed_ether])
-        #m = pieces.first.first
-        ##[CH2+]CH2NH3+
-        ##  C2H7N
-
-        #p m
-        #m.add_h!
-        #h = m.atoms[4].atoms.find {|a| a.el == :h }
-        #m.delete_atom(h)
-        #p m
-        #p m.atoms
-        ##mol = Rubabel["NCO"]
-        ##pieces = mol.fragment(rules: [:oxed_ether])
-        ##pieces.size.should == 0
-      #end
-
-      #describe 'ester to ions' do
-      #end
-
-      #describe 'carboxyl group' do
-      #end
-
-      #describe 'phosphodiester' do
-      #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 'oxygen alpha/beta/gamma hydrogen stealing' do
-      #describe 'primary alcohol giving water loss' do
-      #end
-
-      #describe 'peroxide carbonyl formation' do
-      #end
-
-      #describe 'ether to alcohol' do
-      #end
-
-      #describe 'ester to alcohol' do
-      #end
-
-      #describe 'phosphodiester' do
-      #end
-    #end
-
-  #end
-#end
-
-
-
-
-    ##describe ':sp3c_nitrogen_double_bond' do
-
-      ##it 'cleaves like an ether a secondary NH group if possible' do
-        ##mol = Rubabel["CCNC"]
-        ##frag_sets = mol.fragment(rules: [:sp3c_nitrogen_double_bond])
-        ##frag_sets.size.should == 1
-        ##csmiles = frag_sets.first.map(&:csmiles)
-        ##csmiles.should include("C=C")
-        ##csmiles.should include("C[NH3+]")
-      ##end
-
-      ##it 'will not cleave if not possible' do
-        ##mol = Rubabel["CNC"]
-        ##frag_sets = mol.fragment(rules: [:sp3c_nitrogen_double_bond])
-        ##frag_sets.should be_empty
-      ##end
-
-    ##end
-
-    ##describe ':co2_loss' do
-      ##it 'loss of CO2 from carboxy group with charge transfer' do
-        ##mol = Rubabel["NCC(=O)O"]
-        ##frag_sets = mol.fragment( rules: [:co2_loss] )
-        ##frag_sets.size.should == 1
-        ##csmiles = frag_sets.first.map(&:csmiles)
-
-        ##csmiles.should include("[CH2-][NH3+]")
-        ##csmiles.should include("O=C=O")
-      ##end
-
-      ##it "doesn't remove CO2 if adjacent is not c3" do
-        ##mol = Rubabel["C=CC(=O)O"]
-        ##fragments = mol.fragment( rules: [:co2_loss] )
-        ##fragments.should be_empty
-      ##end
-
-    ##end
-
-    ##describe ':peroxy_to_carboxy' do
-      ##it 'works' do
-        ##mol = Rubabel["NCCC(OO)CC"]
-        ##frag_sets = mol.fragment( rules: [:peroxy_to_carboxy] )
-        ##frag_sets.size.should == 2 
-        ##frag_sets.flatten(1).map(&:csmiles).sort.should == ["CC", "CCC(=O)O", "CC[NH3+]", "OC(=O)CC[NH3+]"]
-      ##end
-    ##end
-
-    ##describe ':sp3c_oxygen_asymmetric_far_sp3', :pending do
-      ##it 'splits like sp3c_oxygen_double_bond except oxygen takes the electrons' do
-        ##$VERBOSE = 3
-        ##mol = Rubabel["NCCCOCC"]
-        ##frag_sets = mol.fragment( rules: [:sp3c_oxygen_asymmetric_far_sp3] )
-        ##$VERBOSE = nil
-        ##frag_sets.size.should == 2
-        ###mol = Rubabel["NCCOCC"]
-        ###p mol.fragment( rules: [:sp3c_oxygen_asymmetric_far_sp3] )
-        ###mol = Rubabel["NCOC"] 
-        ###p mol.fragment( rules: [:sp3c_oxygen_asymmetric_far_sp3] )
-      ##end
-    ##end
-
-    ##describe ':sp3c_oxygen_double_bond_water_loss' do
-
-      ##it 'does h2o loss of alcohol' do
-        ##mol = Rubabel["NCCC(O)CC"]
-        ##fragments = mol.fragment( rules: [:sp3c_oxygen_double_bond_water_loss] )
-        ##fragments.flatten(1).map(&:csmiles).sort.should == ["CC=CCC[NH3+]", "CCC=CC[NH3+]", "O", "O"]
-      ##end
-
-      ##it 'h2o loss does not allow bad chemistry' do
-        ### lone pair and double bond resonance ?
-        ##mol = Rubabel["NCC(O)CC"]
-        ##fragments = mol.fragment( rules: [:sp3c_oxygen_double_bond_water_loss] )
-        ##fragments.flatten(1).map(&:csmiles).sort.should == ["CC=CC[NH3+]", "O"]
-
-        ##mol = Rubabel["NC(O)CC"] 
-        ##fragments = mol.fragment( rules: [:sp3c_oxygen_double_bond_water_loss] )
-        ##fragments.flatten(1).map(&:csmiles).sort.should == []
-      ##end
-    ##end
-
-    ##describe 'sp3c_oxygen_double_bond_far_side_sp2' do
-
-      ##it 'does not cleave esters without sp3 carbons available for double bond' do
-        ##mol = Rubabel["NCCC(=O)OC"]
-        ##pieces = mol.fragment( rules: [:sp3c_oxygen_double_bond_far_side_sp2] )
-        ##pieces.should be_empty
-      ##end
-
-      ##it 'cleaves esters on far side of singly bonded oxygen' do
-        ##mol = Rubabel["NCCC(=O)OCC"]
-        ##pieces = mol.fragment( rules: [:sp3c_oxygen_double_bond_far_side_sp2] )
-        ##pieces.size.should == 1  # one set
-        ##the_pair = pieces.first
-        ##csmiles = the_pair.map(&:csmiles)
-        ##csmiles.should include("OC(=O)CC[NH3+]")
-        ##csmiles.should include("C=C")
-      ##end
-
-    ##end
-
-    ##describe ':alcohol_to_aldehyde' do
-      ##it 'cleaves beside alcohols to generate an aldehyde' do
-        ##mol = Rubabel["NCCC(O)CC"]
-        ##mol.correct_for_ph!
-        ##total_mass = mol.add_h!.mass
-
-        ##pieces = mol.fragment(rules: [:alcohol_to_aldehyde])
-        ##pieces.size.should == 2
-        ##pieces.map(&:size).should == [2,2]
-        ##pieces.flatten(1).map(&:csmiles).should == ["CC[NH3+]", "CCC=O", "C(C=O)C[NH3+]", "CC"]
-        ##pieces.each do |pair|
-          ##pair.map(&:mass).reduce(:+).should == total_mass
-        ##end
-      ##end
-    ##end
+      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 (same for esters)' 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)
+
+        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'
+        ff.last.csmiles.should == '[O-]'
+        ff.first.formula.should == "C3H5O"
+        ff.first.exact_mass.should be_within(1e-6).of(57.034039779909996)
+        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.first.formula.should == 'C3H7O'
+        ff.first.exact_mass.should be_within(1e-6).of(59.049689844)
+        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", "CCCO[P](=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.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(&: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(&: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
+
+
+

data/spec/rubabel/molecule_spec.rb

@@ -88,6 +88,18 @@ describe Rubabel::Molecule do
     ar.size.should == 2
   end
 
+  specify 'num_atoms gives the number of atoms which can vary with hydrogens added' do
+    mol = Rubabel["CCC"]
+    mol.num_atoms.should == 3
+    mol.add_h!
+    mol.num_atoms.should == 11
+  end
+
+  specify 'num_atoms(true) gives the number including implied hydrogens' do
+    mol = Rubabel["CCC"]
+    mol.num_atoms(true).should == 11
+  end
+
   describe 'adding an atom' do
     it 'can be added but not attached' do
       mol = Rubabel["CCO"]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubabel
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-07 00:00:00.000000000 Z
+date: 2012-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openbabel