rubabel 0.1.1 → 0.1.5

data/Rakefile

@@ -16,7 +16,6 @@ interface attempts to be a ruby-ish analogue of pybel.}
   gem.authors = ["John T. Prince"]
   [
     ["openbabel", "~> 2.3.1.2"],
-    ["commander", "~> 4.1.2"],
     ["andand", "~> 1.3.3"]
   ].each do |args|
     gem.add_dependency(*args)

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.5

data/bin/fragmenter.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require 'rubabel'
+require 'rubabel/molecule/fragmentable'
+
+
+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 :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'"
+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
+
+if ARGV.size == 0
+  parser.educate && exit
+end
+
+ARGV.each do |mol|
+  mol = Rubabel[mol]
+  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}"
+    end
+  end
+end

data/lib/rubabel.rb

@@ -146,3 +146,5 @@ if(success)
       }
   }
 =end
+
+

data/lib/rubabel/bond.rb

@@ -14,12 +14,23 @@ module Rubabel
     include Enumerable
 
     class << self
-      def [](atom1, atom2)
+=begin
+      def [](atom1, atom2, bond_order=1, index=0)
+        abort 'cannot get bond generated properly yet, arghhh!'
+        flags = 0
         obbond = OpenBabel::OBBond.new
-        obbond.set_begin(atom1.ob)
-        obbond.set_end(atom2.ob)
+        p obbond
+        obbond.set(index, atom1.ob, atom2.ob, bond_order, flags)
+        #obbond.set_end(atom2.ob)
+        p obbond
+        puts "GEGIN:"
+        p obbond.get_begin_atom.get_id
+        puts "END:"
+        p obbond.get_end_atom.get_id
+        obbond.set_bond_order(bond_order)
         self.new(obbond)
       end
+=end
     end
 
     attr_accessor :ob

data/lib/rubabel/core_ext/enumerable.rb

@@ -0,0 +1,13 @@
+
+module Enumerable
+  # File activesupport/lib/active_support/core_ext/enumerable.rb, line 94
+  def index_by
+    return to_enum :index_by unless block_given?
+    Hash[map { |elem| [yield(elem), elem] }]
+  end
+
+  def uniq_by
+    h = {}
+    inject([]) {|a,x| h[yield(x)] ||= a << x}
+  end
+end

data/lib/rubabel/core_ext/putsv.rb

@@ -0,0 +1,14 @@
+
+# puts if $VERBOSE
+def putsv(*args)
+  if $VERBOSE
+    puts(*args)
+  end
+end
+
+# puts to $stderr if $VERBOSE
+def putsev(*args)
+  if $VERBOSE
+    $stderr.puts(*args)
+  end
+end

data/lib/rubabel/molecule.rb

@@ -41,8 +41,22 @@ module Rubabel
       def from_string(string, type=DEFAULT_IN_TYPE)
         Rubabel.molecule_from_string(string, type)
       end
+
+      def from_atoms_and_bonds(atoms=[], bonds=[])
+        obj = self.new( OpenBabel::OBMol.new )
+        atoms.each {|atom| obj.add_atom(atom) }
+        bonds.each {|bond| obj.add_bond(bond) }
+        obj
+      end
+    end
+
+    def add_atom(atom)
+      @ob.add_atom(atom.ob)
     end
 
+    def delete_atom(atom)
+      @ob.delete_atom(atom.ob, false)
+    end
 
     # attributes
     def title() @ob.get_title end
@@ -69,8 +83,8 @@ module Rubabel
 
 
     def initialize(obmol, obconv=nil)
-      @obconv = obconv
       @ob = obmol
+      @obconv = obconv
     end
 
     # returns a list of atom indices matching the patterns (corresponds to
@@ -267,20 +281,43 @@ module Rubabel
     def delete(obj)
       case obj
       when Rubabel::Bond
-        delete_bond(obj)
+        delete_bond(obj, false)
       when Rubabel::Atom
-        delete_atom(obj)
+        delete_atom(obj, false)
       else 
         raise(ArgumentError, "don't know how to delete objects of type: #{obj.class}")
       end
     end
 
     def delete_bond(bond)
-      @ob.delete_bond(bond.ob)
+      @ob.delete_bond(bond.ob, false)
     end
 
     def delete_atom(atom)
-      @ob.delete_atom(atom.ob)
+      @ob.delete_atom(atom.ob, false)
+    end
+
+    # swaps to_move1 for to_move2 on the respective anchors
+    # returns self
+    def swap!(anchor1, to_move1, anchor2, to_move2)
+      OpenBabel::OBBuilder.swap(@ob, *[anchor1, to_move1, anchor2, to_move2].map {|at| at.ob.get_idx } )
+      self
+    end
+
+    # takes a Rubabel::Bond object or a pair of Rubabel::Atom objects
+    def add_bond(*args)
+      case args.size
+      when 1
+        ob_bond = args.first.ob
+        @ob.add_bond(ob_bond)
+        ob_bond.get_begin_atom.add_bond(ob_bond)
+        ob_bond.get_end_atom.add_bond(ob_bond)
+      when 2
+        ob_bond = Rubabel::Bond[ *args ].ob
+        ob_bond.get_begin_atom.add_bond(ob_bond)
+        ob_bond.get_end_atom.add_bond(ob_bond)
+        @ob.add_bond(ob_bond)
+      end
     end
 
     # yields self after deleting the specified bonds.  When the block is
@@ -297,6 +334,8 @@ module Rubabel
       reply
     end
 
+    # splits the molecules at the given bonds and returns the fragments.  Does
+    # not alter the caller.
     def split(*bonds)
       delete_and_restore_bonds(*bonds) do |mol|
         mol.ob.separate.map(&:upcast)

data/lib/rubabel/molecule/fragmentable.rb

@@ -1,9 +1,19 @@
+require 'set'
+require 'rubabel/core_ext/putsv'
+require 'rubabel/core_ext/enumerable'
 
 module Rubabel
   class Molecule
     module Fragmentable
-      RULES = [:co]
+
+      #: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
+      ]
 
       DEFAULT_OPTIONS = {
         rules: RULES,
@@ -24,21 +34,124 @@ module Rubabel
         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, &block)
+      def feint_double_bond(bond, give_e_pair=nil, get_e_pair=nil, &block)
         orig = bond.bond_order
         bond.bond_order = 2
-        reply = block.call(self)
+        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
+
+      end
+
       # to ensure proper fragmentation, will add_h!(ph) first at the given ph
       # an empty array is returned if there are no fragments generated.
+      #
+      #     :ph => 7.4
+      #     :uniq => false 
       def fragment(opts={})
         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?
 
@@ -46,84 +159,94 @@ module Rubabel
         self.remove_h!
 
         rules = opts[:rules]
-        fragments = []
-        self.each_match("CO").each do |_atoms|
-          (carbon, oxygen) = _atoms
-          carbon_nbrs = carbon.atoms.reject {|atom| atom == oxygen }
-          c3_nbrs = carbon_nbrs.select {|atm| atm.type == 'C3' }
-          c2_nbrs = carbon_nbrs.select {|atm| atm.type == 'C2' }
-          num_oxygen_bonds = oxygen.bonds.size
-          # pulling this out here causes it to work incorrectly internally
-          # (not sure why)
-          #co_bond = carbon.get_bond(oxygen)
-
-          case num_oxygen_bonds
-          when 1  # an alcohol
-            # water loss
-            if (c3_nbrs.size > 0 || c2_nbrs.size > 0) && !carbon.carboxyl_carbon?
-              if rules.include?(:h2oloss)
-                frag_sets = (c2_nbrs + c3_nbrs).map do |dbl_bondable_atom|
-                  frags = feint_double_bond(dbl_bondable_atom.get_bond(carbon)) do |_mol|
-                    # TODO: check accuracy before completely splitting for efficiency
-                    frags = _mol.split(carbon.get_bond(oxygen))
-                    frags.map(&:add_h!)
-                  end
-                end
+        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)
 
-                self.add_h!
-                frag_sets.select! do |_frags| 
-                  self.allowable_fragmentation?(_frags)
+            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
-                fragments.push *frag_sets
-              end
-              if rules.include?(:co)
-                # alcohol becomes a ketone and one R group is released
-                frag_sets = c3_nbrs.map do |neighbor_atom|
-                  frags = feint_double_bond(carbon.get_bond(oxygen)) do |_mol|
-                    frags = _mol.split(carbon.get_bond(neighbor_atom))
-                    frags.map(&:add_h!)
-                  end
+                if rules.include?(:alcohol_to_aldehyde)
+                    putsv "rule :alcohol_to_aldehyde"
+                  fragment_sets.push *alcohol_to_aldehyde(carbon, oxygen, carbon_nbrs)
                 end
-
-                self.add_h!
-                frag_sets.select! do |_frags| 
-                  self.allowable_fragmentation?(_frags)
+              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
-                fragments.push *frag_sets
               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 rules.include?(:co) && (num_oxygen_bonds == 2)
-                if oxygen
-
-
-                  # alcohol becomes a ketone and one R group is released
-                  frag_sets = c3_nbrs.map do |neighbor_atom|
-                    frags = feint_double_bond(carbon.get_bond(oxygen)) do |_mol|
-                      frags = _mol.split(carbon.get_bond(neighbor_atom))
-                      frags.map(&:add_h!)
-                    end
+                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
-
-                  self.add_h!
-                  frag_sets.select! do |_frags| 
-                    self.allowable_fragmentation?(_frags)
+                  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
-                  fragments.push *frag_sets
                 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
-            # oxygen bonded to something else (per-oxide??)
-            # also could be ether situation...
-          when 2  
-            raise NotImplementedError
           end
         end
+
         unless had_hydrogens
-          fragments.each {|set| set.each(&:remove_h!) }
+          fragment_sets.each {|set| set.each(&:remove_h!) }
           self.remove_h!
         end
-        fragments
+        if opts[:uniq]
+          # TODO: impelent properly
+          #fragment_sets = fragment_sets.uniq_by(&:csmiles) 
+          raise NotImplementedError
+        end
+        fragment_sets
       end
 
     end
@@ -131,79 +254,3 @@ module Rubabel
   end
 end
 
-
-  #          co_bond = carbon.get_bond(oxygen)
-  #            left_to_c_bond = carbon.get_bond(left)
-  #            right_to_c_bond = carbon.get_bond(right)
-  #
-  #            co_bond.bond_order = 2
-  #
-  #            [left_to_c_bond, right_to_c_bond].flat_map do |other_to_c_bond|
-  #              mol.ob.delete_bond(other_to_c_bond.ob, false)
-  #              pieces = mol.ob.separate.map(&:upcast)
-  #              mol.ob.add_bond(other_to_c_bond.ob)
-  #              pieces
-  #            end
-
-
-=begin
-
-        # duplicate the molecule so we can do what we like with it
-        mol = self.dup
-
-        has_hydrogens_added = h_added?
-        mol.remove_h! if has_hydrogens_added
-
-        mol.correct_for_ph!(opts[:ph])
-
-        rules = opts[:rules]
-        fragments = []
-        if rules.include?(:co)
-          mol.each_match("C(O)").flat_map do |_atoms|
-            carbon = _atoms.first
-            non_oxygen = carbon.each_bond.reject {|bond| bond.include?(_atoms.last) }
-            non_oxygen.each {|bond| p mol.split(bond) }
-
-            fragments.push *non_oxygen.flat_map {|bond| mol.split(bond) }
-          end
-        end
-        p fragments
-        abort 'here'
-        fragments.each(&:add_h!) if has_hydrogens_added
-        fragments
-      end
-    end
-
-=end
-
-
-  #            [[left_to_c_bond, left], [right_to_c_bond, right]].flat_map do |other_to_carbony_c, other|
-  #              puts "INSIDE!!!"
-  #              pieces = mol.split(other_to_carbony_c)
-  #              c_in_pieces = nil
-  #              oxy_in_pieces = nil
-  #              other_in_pieces = nil
-  #              pieces.each do |piece| 
-  #                piece.each_atom do |atom| 
-  #                  p piece
-  #                  p [atom.id, other.id]
-  #                  other_in_pieces = atom if atom.id == other.id
-  #                  c_in_pieces = atom if atom.id == carbon.id 
-  #                  oxy_in_pieces = atom if atom.id == oxygen.id 
-  #                  break if c_in_pieces && oxy_in_pieces
-  #                end
-  #                break if c_in_pieces && oxy_in_pieces
-  #              end
-  #              oxygen_bond = c_in_pieces.get_bond(oxy_in_pieces)
-  #              oxygen_bond.bond_order = 2
-  #
-  #              puts "EXAMINE:other"
-  #              p other_in_pieces.ob
-  #              p other_in_pieces.mol.csmiles
-  #              other_mol = other_in_pieces.mol
-  #              ob_atom = other_mol.ob.new_atom
-  #              ob_atom.set_atomic_num 1
-  #              newbond = OpenBabel::OBBond.new 
-  #              ob_atom
-  #
-

data/rubabel.gemspec

@@ -5,14 +5,14 @@
 
 Gem::Specification.new do |s|
   s.name = "rubabel"
-  s.version = "0.1.1"
+  s.version = "0.1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["John T. Prince"]
-  s.date = "2012-05-31"
+  s.date = "2012-08-08"
   s.description = "Ruby interface to the openbabel ruby bindings (or the openbabel gem).  The\ninterface attempts to be a ruby-ish analogue of pybel."
   s.email = "jtprince@gmail.com"
-  s.executables = ["rubabel"]
+  s.executables = ["fragmenter.rb"]
   s.extra_rdoc_files = [
     "LICENSE",
     "README.rdoc"
@@ -24,10 +24,12 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "VERSION",
-    "bin/rubabel",
+    "bin/fragmenter.rb",
     "lib/rubabel.rb",
     "lib/rubabel/atom.rb",
     "lib/rubabel/bond.rb",
+    "lib/rubabel/core_ext/enumerable.rb",
+    "lib/rubabel/core_ext/putsv.rb",
     "lib/rubabel/fingerprint.rb",
     "lib/rubabel/molecule.rb",
     "lib/rubabel/molecule/fragmentable.rb",
@@ -39,6 +41,7 @@ Gem::Specification.new do |s|
     "reference/arity_method_list_CLASS.txt",
     "reference/atom_methods.txt",
     "reference/bond_methods.txt",
+    "reference/fragmentation_rules_.pdf",
     "reference/get_methods.rb",
     "reference/mol_methods.txt",
     "rubabel.gemspec",
@@ -67,7 +70,7 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/princelab/rubabel"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.18"
+  s.rubygems_version = "1.8.23"
   s.summary = "Ruby interface to the OpenBabel ruby bindings similar to pybel"
 
   if s.respond_to? :specification_version then
@@ -75,14 +78,12 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<openbabel>, ["~> 2.3.1.2"])
-      s.add_runtime_dependency(%q<commander>, ["~> 4.1.2"])
       s.add_runtime_dependency(%q<andand>, ["~> 1.3.3"])
       s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
       s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
     else
       s.add_dependency(%q<openbabel>, ["~> 2.3.1.2"])
-      s.add_dependency(%q<commander>, ["~> 4.1.2"])
       s.add_dependency(%q<andand>, ["~> 1.3.3"])
       s.add_dependency(%q<rspec>, ["~> 2.8.0"])
       s.add_dependency(%q<rdoc>, ["~> 3.12"])
@@ -90,7 +91,6 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<openbabel>, ["~> 2.3.1.2"])
-    s.add_dependency(%q<commander>, ["~> 4.1.2"])
     s.add_dependency(%q<andand>, ["~> 1.3.3"])
     s.add_dependency(%q<rspec>, ["~> 2.8.0"])
     s.add_dependency(%q<rdoc>, ["~> 3.12"])

data/spec/rubabel/molecule/fragmentable_spec.rb

@@ -2,37 +2,133 @@ require 'spec_helper'
 
 require 'rubabel'
 
+$VERBOSE = nil
+
 describe Rubabel::Molecule::Fragmentable do
-  describe 'the :co rule' do
 
-    describe 'water loss' 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 ':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
 
-      it ':h2oloss' do
+    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: [:h2oloss] )
+        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 ':h2oloss [does not allow bad chemistry]' do
+      it 'h2o loss does not allow bad chemistry' do
         # lone pair and double bond resonance ?
         mol = Rubabel["NCC(O)CC"]
-        fragments = mol.fragment( rules: [:h2oloss] )
+        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: [:h2oloss] )
+        fragments = mol.fragment( rules: [:sp3c_oxygen_double_bond_water_loss] )
         fragments.flatten(1).map(&:csmiles).sort.should == []
       end
     end
 
-    describe 'backbone cleavage' do
+    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 beside alcohols yielding aldehydes' do
+      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: [:co])
+        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"]
@@ -40,12 +136,7 @@ describe Rubabel::Molecule::Fragmentable do
           pair.map(&:mass).reduce(:+).should == total_mass
         end
       end
-
-      xit 'does not cleave esters' do
-        mol = Rubabel["NCCC(=O)OC"]
-        pieces = mol.fragment( rules: [:co] )
-        pieces.should be_empty
-      end
     end
+
   end
 end

data/spec/rubabel/molecule_spec.rb

@@ -25,7 +25,33 @@ describe Rubabel::Molecule do
     end
   end
 
-  it '#dup creates an entirely new molecule based on the first' do
+#  specify '#add_bond adds a bond (and updates atoms)' do
+#    c = Rubabel::Atom[:c]
+#    o = Rubabel::Atom[:o]
+#    mol = Rubabel::Molecule.from_atoms_and_bonds([c,o])
+#    mol.add_bond(c,o)
+#    puts "BONDS:"
+#    p mol.bonds
+#    puts "ATOMS:"
+#    p mol.atoms
+#    puts "C ATOMS:"
+#    p c.atoms
+#    puts "O ATOMS:"
+#    p o.atoms
+#  end
+
+  specify '#swap! can swap atoms around' do
+    mol = Rubabel["NCC(=O)O"]
+    carboxy_carbon = mol.atoms.find {|atom| atom.type == 'Cac' }
+    single_bonded_oxygen = mol.atoms.find {|atom| atom.type == 'O.co2' && atom.get_bond(carboxy_carbon).bond_order == 1 }
+    nit_carbon = mol.atoms.find {|atom| atom.atoms.any? {|nbr| nbr.type == 'N3' } }
+    nitrogen = mol.atoms.find {|atom| atom.el == :n }
+    swapped = mol.swap!(nit_carbon, nitrogen, carboxy_carbon, single_bonded_oxygen)
+    swapped.should == mol
+    swapped.csmiles.should == 'NC(=O)CO'
+  end
+
+  specify '#dup creates an entirely new molecule based on the first' do
     another = @mol.dup
     # this is a deep copy all the way.  Even the atoms are duplicated so that
     # they can be modified in one and do not affect the other at all.
@@ -33,7 +59,7 @@ describe Rubabel::Molecule do
     @mol.charge.should_not == another.charge
   end
 
-  it '#each iterates through each atom in id order' do
+  specify '#each iterates through each atom in id order' do
     cnt = 0
     @mol.each do |atom|
       atom.id.should == cnt
@@ -44,7 +70,7 @@ describe Rubabel::Molecule do
     @mol.atoms.size.should == 74
   end
 
-  it '#hydrogens_added?' do
+  specify '#hydrogens_added?' do
     @mol.hydrogens_added?.should be_false
     @mol.atoms.size.should == 33
     @mol.add_h!

data/spec/spec_helper.rb

@@ -1,12 +1,25 @@
 require 'rspec'
 require 'stringio'
 
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-#Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+require 'rspec/core/formatters/progress_formatter'
+# doesn't say so much about pending guys
+class QuietPendingFormatter < RSpec::Core::Formatters::ProgressFormatter
+  def example_pending(example)
+    output.print yellow('*')
+  end
+end
+
+require 'rspec/core/formatters/documentation_formatter'
+class QuietPendingDocFormatter < RSpec::Core::Formatters::DocumentationFormatter
+  def example_pending(example)
+    output.puts yellow( "<pending>: #{example.execution_result[:pending_message]}" )
+  end
+end
+
 
 RSpec.configure do |config|
-  config.formatter = :documentation  
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.formatter = QuietPendingDocFormatter
   config.color = true
 end
 
@@ -31,6 +44,4 @@ module Kernel
   ensure
     $stderr = STDERR
   end
-
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubabel
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-31 00:00:00.000000000 Z
+date: 2012-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openbabel
@@ -27,22 +27,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 2.3.1.2
-- !ruby/object:Gem::Dependency
-  name: commander
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 4.1.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 4.1.2
 - !ruby/object:Gem::Dependency
   name: andand
   requirement: !ruby/object:Gem::Requirement
@@ -112,7 +96,7 @@ description: ! 'Ruby interface to the openbabel ruby bindings (or the openbabel
   interface attempts to be a ruby-ish analogue of pybel.'
 email: jtprince@gmail.com
 executables:
-- rubabel
+- fragmenter.rb
 extensions: []
 extra_rdoc_files:
 - LICENSE
@@ -124,10 +108,12 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
-- bin/rubabel
+- bin/fragmenter.rb
 - lib/rubabel.rb
 - lib/rubabel/atom.rb
 - lib/rubabel/bond.rb
+- lib/rubabel/core_ext/enumerable.rb
+- lib/rubabel/core_ext/putsv.rb
 - lib/rubabel/fingerprint.rb
 - lib/rubabel/molecule.rb
 - lib/rubabel/molecule/fragmentable.rb
@@ -139,6 +125,7 @@ files:
 - reference/arity_method_list_CLASS.txt
 - reference/atom_methods.txt
 - reference/bond_methods.txt
+- reference/fragmentation_rules_.pdf
 - reference/get_methods.rb
 - reference/mol_methods.txt
 - rubabel.gemspec
@@ -184,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.18
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Ruby interface to the OpenBabel ruby bindings similar to pybel

data/bin/rubabel

@@ -1,229 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'commander/import'
-require 'rubabel'
-
-program :version, Rubabel::VERSION
-program :description, 'tools for manipulating molecules with rubabel'
-
-=begin
-    filename = filename.first unless options[:string_format]
-    mol_iter = 
-      if str_f=options[:string_format]
-        # assumes you aren't passing massive numbers of molecules as strings
-        # on the commandline
-        filename.map {|str| Rubabel.read_string(str, str_f.to_sym) }.each
-      else
-        Rubabel.foreach(ARGV.first)
-      end
-    mol_iter.each do |mol|
-      mol.add_h! unless mol.ob.has_hydrogens_added
-      mol.ob.get_title || 
-
-    end
-=end
-
-def mol_iterator(args, strings)
-  
-end
-
-
-command :babel do |c|
-  c.syntax = 'rubabel babel [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Babel
-  end
-end
-
-command :obabel do |c|
-  c.syntax = 'rubabel obabel [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Obabel
-  end
-end
-
-command :chiral do |c|
-  c.syntax = 'rubabel chiral [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Chiral
-  end
-end
-
-command :conformer do |c|
-  c.syntax = 'rubabel conformer [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Conformer
-  end
-end
-
-command :energy do |c|
-  c.syntax = 'rubabel energy [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Energy
-  end
-end
-
-command :fit do |c|
-  c.syntax = 'rubabel fit [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Fit
-  end
-end
-
-command :gen do |c|
-  c.syntax = 'rubabel gen [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Gen
-  end
-end
-
-command :grep do |c|
-  c.syntax = 'rubabel grep [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Grep
-  end
-end
-
-command :gui do |c|
-  c.syntax = 'rubabel gui [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Gui
-  end
-end
-
-command :minimize do |c|
-  c.syntax = 'rubabel minimize [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Minimize
-  end
-end
-
-command :probe do |c|
-  c.syntax = 'rubabel probe [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Probe
-  end
-end
-
-command :prop do |c|
-  c.syntax = 'rubabel prop [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Prop
-  end
-end
-
-command :probe do |c|
-  c.syntax = 'rubabel probe [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Probe
-  end
-end
-
-command :prop do |c|
-  c.syntax = 'rubabel prop [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Prop
-  end
-end
-
-command :rotamer do |c|
-  c.syntax = 'rubabel rotamer [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Rotamer
-  end
-end
-
-command :rotate do |c|
-  c.syntax = 'rubabel rotate [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Rotate
-  end
-end
-
-command :spectrophore do |c|
-  c.syntax = 'rubabel spectrophore [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Spectrophore
-  end
-end
-
-command :roundtrip do |c|
-  c.syntax = 'rubabel roundtrip [options]'
-  c.summary = ''
-  c.description = ''
-  c.example 'description', 'command example'
-  c.option '--some-switch', 'Some switch that does something'
-  c.action do |args, options|
-    # Do something or c.when_called Rubabel::Commands::Roundtrip
-  end
-end
-