rubabel 0.1.6 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.2.0

data/lib/rubabel/atom.rb

@@ -79,7 +79,6 @@ module Rubabel
       end
     end
 
-    alias_method :each, :each_bond
 
     # retrieves the bond 
     def get_bond(atom)
@@ -101,6 +100,7 @@ module Rubabel
         _atom = @ob.next_nbr_atom(iter)
       end
     end
+    alias_method :each, :each_atom
 
     # returns the neighboring atoms.  Consider using each_atom.
     def atoms
@@ -153,6 +153,79 @@ module Rubabel
       @ob.get_partial_charge
     end
 
+    # permanently removes a hydrogen by properly incrementing the
+    # spin_multiplicity (and deleting a hydrogen if one is explicitly attached
+    # to the atom).  If called with cnt=2 a carbene or nitrene can be made
+    # (giving a spin_multiplicity of 3).  Makes no effort to ensure that the
+    # proper number of hydrogens already exist to be deleted, just alters the
+    # spin_multiplicity and deletes the right number of hydrogens if they are
+    # available to be deleted.  Adds one charge to the atom.
+    def remove_an_h!(add_charge=true)
+      new_spin = 
+        case @ob.get_spin_multiplicity
+        when 0 then 2
+        when 2 then 3
+        end
+      @ob.set_spin_multiplicity(new_spin)
+      atoms.each do |atom|
+        if atom.atomic_num == 1
+          self.mol.delete_atom(atom)
+          break
+        end
+      end
+      # add the charge
+      (self.charge = charge + 1) if add_charge
+      self
+    end
+
+    # philosophy on equality: there are *so* many ways for two atoms to be
+    # different that we can never really ensure that "equivalence" is met
+    # without calling ~20 methods.  We narrowly define equivalence so it is
+    # useful for that case and let the user make more complicated
+    # equivalency/equality definitions themselves.
+
+    # the exact same atom in the same molecule.  The equivalency test for
+    # molecules is a little pricey, so better to use something like atom.id ==
+    # other.id if you know you are working within the same molecule.
+    def equal?(other)
+      other.respond_to?(:mol) && mol.equal?(other.mol) && id == other.id 
+    end
+
+    alias_method :==, :equal?
+    alias_method :eql?, :equal?
+
+    ## opposite of remove_an_h!
+    ## THIS IS STILL BROKEN!!!
+    # maybe need to change the type?? C+ -> C2 or C3, but this gets really
+    # invasive...  Why is this so flippin hard to do!!
+    #def add_an_h!(remove_charge=true)
+      #new_spin = 
+        #case @ob.get_spin_multiplicity
+        #when 2 then 0
+        #when [1,3] then 2
+        #end
+      #@ob.set_spin_multiplicity(new_spin)
+      
+      #puts self.inspect_internals
+      #puts "EXAMIN B:"
+      #p self
+      #p self.charge
+      #(self.charge = self.charge - 1) if remove_charge
+      #puts "EXAMIN A:"
+      #puts self.inspect_internals
+      #p self
+      #p self.charge
+      #puts "BEFORE:"
+      #p mol.formula
+      #p mol.atoms
+      #mol.add_bond!(self, mol.add_atom!(1))
+      #puts "AFTER:"
+      #p mol.formula
+      #p mol.atoms
+      #abort 'here'
+      #self
+    #end
+
     def spin
       @ob.get_spin_multiplicity
     end
@@ -203,8 +276,25 @@ module Rubabel
     def hbond_donor?() @ob.is_hbond_donor end
     def hbond_donor_h?() @ob.is_hbond_donor_h end
 
+    def double_bond?
+      each_bond.any? {|bond| bond.bond_order == 2 }
+    end
+
+    def single_bond?
+      each_bond.any? {|bond| bond.bond_order == 1 }
+    end
+
     def carboxyl_carbon?
-      atoms.any?(&:carboxyl_oxygen?)
+      each_atom.any?(&:carboxyl_oxygen?)
+    end
+
+    def carbonyl_oxygen?
+      ats = atoms
+      ats.size == 1 && ats.first.el == :c && double_bond?
+    end
+
+    def carbonyl_carbon?
+      each_atom.any?(&:carbonyl_oxygen?)
     end
 
 #    # does this carbon hold a primary alcohol
@@ -218,5 +308,17 @@ module Rubabel
     def inspect
       "<#{type} id:#{id}>"
     end
+
+    def inspect_internals
+      "<" << @ob.methods.grep(/get_/).map do |mthd| 
+        begin
+          "#{mthd.to_s.sub(/get_/,'')}=#{@ob.send(mthd)}" 
+        rescue ArgumentError
+          nil
+        end
+      end.compact.join(" ") << ">"
+    end
+
+
   end
 end

data/lib/rubabel/bond.rb

@@ -63,6 +63,25 @@ module Rubabel
       @ob.set_bond_order(val)
     end
 
+    # returns self
+    def set_atoms!(beg_atom, end_atom)
+      @ob.set_begin(beg_atom.ob)
+      @ob.set_end(end_atom.ob)
+      self
+    end
+
+    # Sets the beginning atom of the bond to atom. returns self
+    def set_begin!(atom)
+      @ob.set_begin(atom.ob)
+      self
+    end
+
+    # Sets the end atom of the bond to the given atom. returns self
+    def set_end!(atom)
+      @ob.set_end(atom.ob)
+      self
+    end
+
     # returns an array of Rubabel::Atoms
     def atoms
       [@ob.get_begin_atom.upcast, @ob.get_end_atom.upcast]

data/lib/rubabel/molecule.rb

@@ -112,9 +112,10 @@ module Rubabel
     def add_atom!(atomic_num=1)
       # jtp implementation:
       # @ob.add_atom(atom.ob)
-      new_a = @ob.new_atom
-      new_a.set_atomic_num(atomic_num)
-      Rubabel::Atom.new(new_a)
+      new_obatom = @ob.new_atom
+      new_obatom.set_atomic_num(atomic_num)
+      #@ob.add_atom(new_obatom)
+      Rubabel::Atom.new(new_obatom)
     end
 
     def delete_atom(atom)
@@ -144,7 +145,6 @@ module Rubabel
     # to add_h!
     def formula() @ob.get_formula end
 
-
     def initialize(obmol)
       @ob = obmol
     end
@@ -254,11 +254,6 @@ module Rubabel
       self
     end
 
-    # calls separate on the OBMol object
-    def separate!
-      @ob.separate
-    end
-
     # returns just the smiles string :smi (not the id)
     def smiles
       to_s(:smi)
@@ -269,10 +264,38 @@ module Rubabel
       to_s(:can)
     end
 
-    # equal if their canonical SMILES strings (including ID) are equal.  This
-    # may become more rigorous in the future
+    # checks to see if the molecules are the same OBMol object underneath by
+    # modifying one and seeing if the other changes.  This is because
+    # openbabel routinely creates new objects that point to the same
+    # underlying data store, so even checking for OBMol equivalency is not
+    # enough.
+    def equal?(other)
+      return false unless other.is_a?(self.class)
+      are_identical = false
+      if self.title == other.title
+        begin
+          obj_id = self.object_id.to_s
+          self.title += obj_id
+          are_identical = (self.title == other.title)
+        ensure
+          self.title.sub(/#{obj_id}$/,'')
+        end
+        are_identical
+      else
+        false
+      end
+    end
+
+    alias_method :eql?, :equal?
+
+    # defined as whether the csmiles strings are identical.  This incorporates
+    # more information than the FP2 fingerprint, for instance (try changing
+    # the charge and see how it does not influence the fingerprint).
+    # Obviously, things like title or data will not be evaluated with ==.  See
+    # equal? if you are looking for identity.  More stringent comparisons will
+    # have to be done by hand!
     def ==(other)
-      self.write_string(:can) == other.write_string(:can)
+      other.respond_to?(:csmiles) && (csmiles == other.csmiles)
     end
 
     # iterates over the molecule's Rubabel::Atom objects
@@ -308,11 +331,21 @@ module Rubabel
       self
     end
 
+    # gets the bond by id
+    def bond(id)
+      @ob.get_bond_by_id(id).upcast
+    end
+
     # returns the array of bonds.  Consider using #each_bond
     def bonds
       each_bond.map.to_a
     end
 
+    # gets the atom by id
+    def atom(id)
+      @ob.get_atom_by_id(id).upcast
+    end
+
     # returns the array of atoms. Consider using #each
     def atoms
       each_atom.map.to_a
@@ -358,8 +391,15 @@ module Rubabel
       end
     end
 
-    def delete_bond(bond)
-      @ob.delete_bond(bond.ob, false)
+    # if given a bond, deletes it (doesn't garbage collect).  If given two
+    # atoms, deletes the bond between them.
+    def delete_bond(*args)
+      case args.size
+      when 1
+        @ob.delete_bond(args[0].ob, false)
+      when 2
+        @ob.delete_bond(args[0].get_bond(args[1]).ob, false)
+      end
     end
 
     def delete_atom(atom)
@@ -373,21 +413,15 @@ module Rubabel
       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.add_bond(args[0].idx, args[1].idx, args[2] || 1)
-        #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
+    # creates a new (as yet unspecified) bond associated with the molecule and gives it a unique id
+    def new_bond
+      @ob.new_bond.upcast
+    end
+
+    # takes a pair of Rubabel::Atom objects and adds a bond to the molecule
+    # returns whether the bond creation was successful.
+    def add_bond!(atom1, atom2, order=1)
+      @ob.add_bond(atom1.idx, atom2.idx, order)
     end
 
     # yields self after deleting the specified bonds.  When the block is
@@ -405,14 +439,24 @@ module Rubabel
     end
 
     # splits the molecules at the given bonds and returns the fragments.  Does
-    # not alter the caller.
+    # not alter the caller.  If the molecule is already fragmented, then
+    # returns the separate fragments.
     def split(*bonds)
-      delete_and_restore_bonds(*bonds) do |mol|
-        mol.ob.separate.map(&:upcast)
+      if bonds.size > 0
+        delete_and_restore_bonds(*bonds) do |mol|
+          mol.ob.separate.map(&:upcast)
+        end
+      else
+        self.ob.separate.map(&:upcast)
       end
     end
 
-    alias_method :separate, :split
+    def each_fragment(&block)
+      block or return enum_for(__method__)
+      @ob.separate.each do |ob_mol|
+        block.call( ob_mol.upcast )
+      end
+    end
 
     # emits smiles without the trailing tab, newline, or id.  Use write_string
     # to get the default OpenBabel behavior (ie., tabs and newlines).
@@ -593,6 +637,21 @@ module Rubabel
       distance_matrix.max
     end
 
+    # adds 1 hydrogen to the formula and returns self
+    def add_hydrogen_to_formula!
+      string = @ob.get_formula
+      substituted = false
+      new_string = string.sub(/H(\d*)/) { substituted=true; "H#{$1.to_i+1}" }
+      unless substituted
+        new_string = string.sub("^(C?\d*)") { $1 + 'H' }
+      end
+      puts 'HERE'
+      p string
+      p new_string
+      #@ob.set_formula(new_string)
+      self
+    end
+
   end
 end
 

data/lib/rubabel/molecule/fragmentable.rb

@@ -7,18 +7,20 @@ module Rubabel
     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,
-      ]
+      #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
-      ]
+      #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]
 
       DEFAULT_OPTIONS = {
         rules: RULES,
         #adduct: nil,
-        ph: 7.4,
+        #ph: 7.4,
         # return only the set of unique fragments
         uniq: false, 
       }
@@ -142,98 +144,90 @@ module Rubabel
 
       end
 
-      # to ensure proper fragmentation, will add_h!(ph) first at the given ph
+      # 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
+        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
+
+        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"
+      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.
       #
-      #     :ph => 7.4
-      #     :uniq => false 
+      #     :rules => queryable by :include? set of rules
+      #     :uniq => false
       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!(opts[:ph])
+        self.correct_for_ph!(7.4) unless had_hydrogens
         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
+
+        if opts[:rules].any? {|r| [:cad_o, :cad_oo].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 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
+        if opts[:rules].any? {|r| [:oxed_ether].include?(r) }
+          self.each_match("C[O&X2]", only_uniqs) do |carbon, oxygen|
+            fragment_sets << carbon_oxygen_esteal(carbon, oxygen)
           end
         end
 
@@ -243,12 +237,110 @@ module Rubabel
         end
         if opts[:uniq]
           # TODO: impelent properly
-          #fragment_sets = fragment_sets.uniq_by(&:csmiles) 
           raise NotImplementedError
+          #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

data/spec/rubabel/atom_spec.rb

@@ -17,6 +17,45 @@ describe Rubabel::Atom do
     chlorine.id.should == 3
   end
 
+  specify 'equality' do
+    mol = Rubabel["CCO"]
+    oxygen = mol.atoms[2]
+    oxygen_from_match = mol.matches("CO").first.last
+    (oxygen == oxygen_from_match).should be_true
+    (oxygen.equal?(oxygen_from_match)).should be_true
+    (oxygen.eql?(oxygen_from_match)).should be_true
+
+    mol2 = Rubabel["CCO"]
+    (mol.atoms[0] == mol2.atoms[0]).should_not be_true
+    (mol.atoms[0].equal?(mol2.atoms[0])).should_not be_true
+    (mol.atoms[0].eql?(mol2.atoms[0])).should_not be_true
+  end
+
+  it 'removes hydrogens with proper charge accounting' do
+    mol = Rubabel["CC"]
+    mol.add_h!
+    mol.atoms[0].remove_an_h!
+    mol.formula.should == "C2H5"
+    mol.csmiles.should == 'C[CH2+]'
+    mol.exact_mass.round(5).should == 29.03913
+    mol.charge.should == 1
+
+    # can't seem to get working properly!!!
+    #mol.atoms[0].add_an_h!
+    #mol.formula.should == 'C2H6'
+    #mol.csmiles.should == 'CC'
+    #mol.charge.should == 0
+    ##fmol.atoms[0].charge -= 1
+    #mol.exact_mass.should == 323
+  end
+
+  it 'can find atom identities with simple questions' do
+    mol = Rubabel["NCC(O)CC(=O)"]
+    (c_exp, o_exp) = mol.matches("C=O").first
+    mol.find(&:carbonyl_carbon?).id.should == c_exp.id
+    mol.find(&:carbonyl_oxygen?).id.should == o_exp.id
+  end
+
   describe 'working with a complex molecule' do
 
     before do

data/spec/rubabel/bond_spec.rb

@@ -4,16 +4,19 @@ require 'rubabel/molecule'
 require 'rubabel/bond'
 
 describe Rubabel::Bond do
-  subject { Rubabel::Molecule.from_file( TESTFILES + '/cholesterol.sdf' ).bonds.first }
+  describe 'cholesterol from sdf' do
+    subject { Rubabel::Molecule.from_file( TESTFILES + '/cholesterol.sdf' ).bonds.first }
 
-  it 'is a Rubabel::Bond' do
-    subject.should be_a(Rubabel::Bond)
-  end
+    it 'is a Rubabel::Bond' do
+      subject.should be_a(Rubabel::Bond)
+    end
 
-  it 'knows what atoms it includes' do
-    subject.each_atom do |atom|
-      atom.should be_a(Rubabel::Atom)
+    it 'knows what atoms it includes' do
+      subject.each_atom do |atom|
+        atom.should be_a(Rubabel::Atom)
+      end
+      subject.atoms.size.should == 2
     end
-    subject.atoms.size.should == 2
   end
+
 end

data/spec/rubabel/molecule/fragmentable_spec.rb

@@ -4,139 +4,226 @@ 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 ':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
+#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 'cad_o: 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"]
-        #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
-
-  end
-end
+        ##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

data/spec/rubabel/molecule_spec.rb

@@ -10,6 +10,13 @@ describe Rubabel::Molecule do
     end
   end
 
+  #xit 'can add a hydrogen to the formula' do
+    #mol = Rubabel["CCC"]
+    #p mol.formula
+    #mol.add_hydrogen_to_formula!
+    #p mol.formula
+  #end
+
   describe 'png output' do
     it 'creates a png image (corresponds to the svg)' do
       mol = Rubabel["NCC(=O)O"]
@@ -39,6 +46,24 @@ describe Rubabel::Molecule do
     end
   end
 
+  specify 'eql? and equal? mean the objects modify the same underlying openbabel molecule data' do
+    mol = Rubabel["C"]
+    eq_mol = mol.atoms.first.mol
+    mol.equal?(eq_mol).should be_true
+    another = Rubabel["C"]
+    mol.equal?(another).should be_false
+  end
+
+  specify '== means the canonical smiles strings (:csmiles) are equal' do
+    mol1 = Rubabel["CCO"]
+    mol2 = Rubabel["OCC"]
+    (mol1 == mol2).should be_true
+    mol2.atoms[0].charge += 1
+    (mol1 == mol2).should be_false
+    mol3 = Rubabel["CCCO"]
+    (mol1 == mol3).should be_false
+  end
+
   specify '#add_atom! adds an atom given an atomic number and returns it' do
     mol = Rubabel["CCO"]
     before_size = mol.atoms.size
@@ -48,29 +73,30 @@ describe Rubabel::Molecule do
     mol.csmiles.should == "CCO.C"
   end
 
+  specify '#dup duplicates the molecule' do
+    mol = Rubabel["CCO"]
+    dup_mol = mol.dup
+    mol.atoms[0].ob.set_atomic_num(9)
+    mol.csmiles.should == "OCF"
+    dup_mol.csmiles.should == "CCO"
+  end
+
   specify '#add_atom! with a Rubabel::Atom'
 
-  specify '#add_bond! adds a bond (and updates atoms)' do
-    mol = Rubabel["CCO"]
-    atom = mol.add_atom!(0)
-    mol.add_bond!(mol.atoms[1], atom)
-    mol.csmiles.should == '*C(O)C'
+  describe '#add_bond! adds a bond (and updates atoms)' do
+    specify 'given two atoms' do
+      mol = Rubabel["CCO"]
+      atom = mol.add_atom!(0)
+      mol.add_bond!(mol.atoms[1], atom)
+      mol.csmiles.should == '*C(O)C'
+    end
   end
 
-#  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 '#atom(id) retrieves atom by id num' do
+    mol = Rubabel["CCO"]
+    o = mol.find {|a| a.el == :o }
+    mol.atom(o.id).id.should == o.id
+  end
 
   specify '#swap! can swap atoms around' do
     mol = Rubabel["NCC(=O)O"]
@@ -117,8 +143,20 @@ describe Rubabel::Molecule do
     ar.first.should be_a(OpenBabel::OBRing)
   end
 
+  describe 'making carbo-cations: spin_multiplicity and charges' do
+    # http://openbabel.org/docs/2.3.1/Features/Radicals.html
+    subject { mol = Rubabel["CC"] }
+    it 'can be turned into a carbocation' do
+      mol = subject
+      c = mol.atoms[0]
+      c.ob.set_spin_multiplicity 2
+      c.charge += 1
+      mol.csmiles.should == "C[CH2+]"
+    end
+  end
+
   describe 'masses' do
-    subject { Rubabel::Molecule.from_string("C(=O)COC(=O)C[NH3+]") }
+    subject { Rubabel["C(=O)COC(=O)C[NH3+]"] }
     it '#mol_wt (or #avg_mass)' do
       subject.mol_wt.should be_within(0.000001).of(118.11121999999999)
     end
@@ -138,7 +176,7 @@ describe Rubabel::Molecule do
 
   describe 'pH' do
 
-    subject { Rubabel::Molecule.from_string("NCC(=O)OCC(=O)O") }
+    subject { Rubabel["NCC(=O)OCC(=O)O"] }
 
     it '#correct_for_ph! neutral' do
       subject.correct_for_ph!.to_s.should == '[O-]C(=O)COC(=O)C[NH3+]'
@@ -220,6 +258,7 @@ describe Rubabel::Molecule do
   describe 'breaking a molecule' do
     before(:each) do
       @mol =  Rubabel::Molecule.from_string("NC(=O)CO")
+      @n = @mol.find {|a| a.el == :n }
     end
 
     it 'num_atoms, atoms and each_atom are sensitive to #add_h!' do
@@ -256,6 +295,20 @@ describe Rubabel::Molecule do
       csmiles.sort.should == %w(N CC=O O).sort
     end
 
+    it 'can split fragments (akin to separate)' do
+      @mol.delete_bond(@n, @n.atoms.first)
+      pieces = @mol.split
+      pieces.map(&:csmiles).sort.should == ["N", "OCC=O"]
+    end
+
+    it 'can iterate through fragments' do
+      expected = %w(N OCC=O)
+      @mol.delete_bond(@n, @n.atoms.first)
+      @mol.each_fragment do |frag|
+        frag.csmiles.should == expected.shift
+      end
+    end
+
   end
 
   describe 'matching patterns (SMARTS)' do

metadata

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