rubabel 0.2.2 → 0.3.0

data/README.md

@@ -1,8 +1,8 @@
 # rubabel
 
-Ruby interface to the openbabel ruby bindings (or the openbabel gem).  The
+Ruby interface to the OpenBabel ruby bindings (or the openbabel gem).  The
 interface attempts to be a ruby-ish analogue of
-[pybel](http://openbabel.org/docs/current/UseTheLibrary/Python_PybelAPI.html).
+[pybel](http://openbabel.org/docs/current/UseTheLibrary/Python_PybelAPI.html).  Works with ruby 1.9 and 2.0.
 
 ## Examples
 
@@ -12,150 +12,185 @@ The [Chemistry Toolkit Rosetta Wiki](http://ctr.wikia.com/wiki/Chemistry_Toolkit
 
 #### From a string
 
-    require 'rubabel'
+```ruby
+require 'rubabel'
 
-    # by default, reads in smiles strings
-    serine = Rubabel["C(C(C(=O)O)N)O"]
-    # more formally:
-    serine = Rubabel::Molecule.from_string("C(C(C(=O)O)N)O")
+# by default, reads in smiles strings
+serine = Rubabel["C(C(C(=O)O)N)O"]
+# more formally:
+serine = Rubabel::Molecule.from_string("C(C(C(=O)O)N)O")
 
-    # also any other format openbabel supports, for example inchi
-    serine = Rubabel["InChI=1S/C3H7NO3/c4-2(1-5)3(6)7/h2,5H,1,4H2,(H,6,7)", :inchi]
+# also any other format openbabel supports, for example inchi
+serine = Rubabel["InChI=1S/C3H7NO3/c4-2(1-5)3(6)7/h2,5H,1,4H2,(H,6,7)", :inchi]
 
-    # from the internet:
-    mol = Rubabel[some_molecule, Rubabel.format_from_mime(some_mime_type)]
+# from the internet:
+mol = Rubabel[some_molecule, Rubabel.format_from_mime(some_mime_type)]
 
 Find out all the formats Rubabel supports (hash is format key pointing to the description):
 
-    hash = Rubabel.in_formats
-    hash = Rubabel.out_formats
+hash = Rubabel.in_formats
+hash = Rubabel.out_formats
+```
 
 #### From a file
 
 Reading multiple entries from a file:
     
-    Rubabel.foreach("file.sdf") do |mol|
-      puts mol.exact_mass
-    end
+```ruby
+Rubabel.foreach("file.sdf") do |mol|
+  puts mol.exact_mass
+end
+```
 
 Foreach returns an enumerator that can be chained:
 
-    # return an array of every unique atom type in the file
-    uniq_atom_types = Rubabel.foreach("file.mol").flat_map {|mol| mol.map(&:type) }.uniq
+```ruby
+# return an array of every unique atom type in the file
+uniq_atom_types = Rubabel.foreach("file.mol").flat_map {|mol| mol.map(&:type) }.uniq
+```
 
 Read a single molecule from a file (reads only the first molecule)
 
-    mol = Rubabel::Molecule.from_file("file.sdf")
-    # handles gzipped files seamlessly:
-    mol = Rubabel::Molecule.from_file("file.sdf.gz") 
-    mol = Rubabel.molecule_from_file("file.sdf") # alternative
+```ruby
+mol = Rubabel::Molecule.from_file("file.sdf")
+# handles gzipped files seamlessly:
+mol = Rubabel::Molecule.from_file("file.sdf.gz") 
+mol = Rubabel.molecule_from_file("file.sdf") # alternative
 
-    # explicit format for uninformative/wrong extensions:
-    mol = Rubabel::Molecule.from_file("file", :sdf)
+# explicit format for uninformative/wrong extensions:
+mol = Rubabel::Molecule.from_file("file", :sdf)
+```
 
 ### Writing/Drawing
 
 #### create string output
 
-    mol = Rubabel["OCC"] # ethanol
+```ruby
+mol = Rubabel["OCC"] # ethanol
 
-    mol.to_s       # canonical smiles -> "CCO"
-    mol.csmiles    # same thing
+mol.to_s       # canonical smiles -> "CCO"
+mol.csmiles    # same thing
 
-    mol.to_s(:smi) # smiles -> "OCC"
-    mol.smiles     # same thing
+mol.to_s(:smi) # smiles -> "OCC"
+mol.smiles     # same thing
+```
 
 For inclusion in a file with standard smiles formatting (SMILES\tID\n):
 
-    can_smiles_string = mol.write_string # -> "CCO\t\n"
-    mol.title = "ethanol"
-    can_smiles_string = mol.write(:can)  # -> "CCO\tethanol\n"
+```ruby
+can_smiles_string = mol.write_string # -> "CCO\t\n"
+mol.title = "ethanol"
+can_smiles_string = mol.write(:can)  # -> "CCO\tethanol\n"
+```
 
 Other formats in the same manner:
 
-    pdb_string = mol.write(:pdb)
+```ruby
+pdb_string = mol.write(:pdb)
+```
 
 Write to a file directly (single molecule only; depends on file extension for type):
 
-    # write to a smiles file
-    mol.write("file.smi")
-    mol.write_file("file.smi")
+```ruby
+# write to a smiles file
+mol.write("file.smi")
+mol.write_file("file.smi")
+```
 
 Write multiple molecules to a file:
 
-    File.open("somefile.pdb", 'w') do |out|
-      molecules.each {|mol| out.print mol.write(:pdb) }
-    end
+```ruby
+File.open("somefile.pdb", 'w') do |out|
+  molecules.each {|mol| out.print mol.write(:pdb) }
+end
+```
 
 #### Drawing
 
 If you write to svg or png (png uses mini_magick to convert from svg) then the
 molecule is automatically drawn in 2D:
 
-    mol = Rubabel["NCC(O)C(=O)O"]
-    mol.write("file.svg")
+```ruby
+mol = Rubabel["NCC(O)C(=O)O"]
+mol.write("file.svg")
 
-    # must have imagemagick ('convert' command) and mini_magick gem installed
-    mol.write("file.png") 
+# must have imagemagick ('convert' command) and mini_magick gem installed
+mol.write("file.png") 
+```
 
 ### Searching and Splitting
 
 *each_match*, *matches*, *matches?*, *smarts_indices* all take the same input (SMARTS
 string or object and optional boolean specifying uniqueness of results):
 
-    mol = Rubabel["NCC(O)C(=O)O"]
-    mol.each_match("CO") do |match|
-      # match is just an array of atoms that matched
-      match.first.el # => :c
-      match.last.el # => :o
-    end
-    
-    # matches returns all the matches in an array
-    all_matches = mol.matches("CO")
-    # all the match routines take a boolean to alter uniqueness
-    all_matches = mol.matches("CO", false) # some matches may not be uniq
+```ruby
+mol = Rubabel["NCC(O)C(=O)O"]
+mol.each_match("CO") do |match|
+  # match is just an array of atoms that matched
+  match.first.el # => :C
+  match.last.el # => :O
+end
+
+# matches returns all the matches in an array
+all_matches = mol.matches("CO")
+# all the match routines take a boolean to alter uniqueness
+all_matches = mol.matches("CO", false) # some matches may not be uniq
+```
 
 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
+
+```ruby
+bonds = mol.matches("CO").map {|c, o| c.get_bond(o) }
+mol.split(*bonds)  # splits between every carbon single bonded to oxygen
+```
 
 ### Add, delete, modify atoms/bonds
 
 #### Adding
 
-    mol = Rubabel["OCC"]
-    # adds a carbon, then an oxygen to last indexed atom by atomic number
-    mol << 6 << 8    # #<Mol "OCCCO">
-    mol << :c << :o  # same thing
+```ruby
+mol = Rubabel["OCC"]
+# adds a carbon, then an oxygen to the previous carbon
+mol << 6 << 8    # #<Mol "OCCCO">
+mol << :C << :O  # same thing
 
-    # add an ethyl group specifically to second carbon
-    mol = Rubabel["OCC"]
-    mol[1] << :c << :c
+# add an ethyl group specifically to second atom (the first carbon)
+mol = Rubabel["OCC"]
+mol[1] << :C << :C
 
-    # add a vinyl group to second carbon (use method notation and parenthesis 
-    # because we are going to specify 2 arguments (the bond order):
-    ( mol[1] << :c).<<(:c, 2)
+# add a vinyl group to second carbon (use method notation and parenthesis 
+# because we are going to specify 2 arguments (the bond order):
+( mol[1] << :C).<<(:C, 2)
+```
 
 #### Deleting
 
-    # delete an atom:
-    mol = Rubabel["NCO"]
-    mol.delete(mol[0])  # -> #<Mol CO>
+```ruby
+# delete an atom:
+mol = Rubabel["NCO"]
+mol.delete(mol[0])  
+# mol.to_s -> #<Mol CO>
 
-    # delete a bond:
-    bond = mol[0].get_bond(mol[1])
-    mol.delete(bond)  # ->  #<Mol C.O>
+# delete a bond:
+bond = mol[0].get_bond(mol[1])
+mol.delete(bond)  
+# mol.to_s ->  #<Mol C.O>
+```
 
 #### Modifying
 
-Can add or subtract from bonds to change bond order:
+Can easily change the bond order:
+
+```ruby
+mol = Rubabel["CC"]
+bond = mol[0].get_bond(mol[1])  # get the bond you want
+bond = mol[0].bonds.first       # alternate way to get at bonds
 
-    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
+bond += 2    # now it is a triple bond
+bond.dec!    # now a double bond
+bond -= 1    # now a single bond
+bond.inc!(2) # back to a triple bond
+```
 
 ## Installing
 
@@ -165,11 +200,15 @@ First, many thanks to Andreas Maunz for packaging openbabel as a gem which makes
 
 On a POSIX system, make sure you have openbabel (including header files), cmake, curl, tar, sed and make {see openbabel instructions}[https://github.com/amaunz/openbabel-gem].  On ubuntu/debian:
 
-    sudo apt-get install openbabel libopenbabel-dev cmake make curl
+```bash
+sudo apt-get install openbabel libopenbabel-dev cmake make curl
+```
 
 Then install the gem (which should install the openbabel gem, too):
 
-    gem install rubabel
+```bash
+gem install rubabel
+```
 
 ### Building from Source
 
@@ -179,21 +218,26 @@ Then install the gem (which should install the openbabel gem, too):
 
 Here's a complete example of compiling for a single user on Ubuntu 11.10 and probably will be generally forward compatible for some time.  This will compile bindings on whichever ruby comes up with '/usr/bin/env ruby':
 
-    # install the dependencies:
-    sudo apt-get install libeigen2-dev cmake libwxgtk2.8-dev libxml2-dev libcairo2-dev
-    # unpack it:
-    tar -xzvf openbabel-2.3.1.tar.gz
-    # swap out buggy lines in ruby bindings:
-    sed -i 's/Init_OpenBabel/Init_openbabel/g' openbabel-2.3.1/scripts/ruby/openbabel-ruby.cpp
-    # make a separate build directory for building in:
-    mkdir build-rvmruby1.9.3
-    cd build-rvmruby1.9.3
-    mkdir ~/tools
-    cmake ../openbabel-2.3.1 -DRUBY_BINDINGS=ON -DCMAKE_INSTALL_PREFIX=~/tools/openbabel-rvmruby1.9.3
-    make && make install
-
-[[Still need directions to install the gem on top of a build from source]]
- 
+```bash
+# install the dependencies:
+sudo apt-get install libeigen2-dev cmake libwxgtk2.8-dev libxml2-dev libcairo2-dev
+# unpack it:
+tar -xzvf openbabel-2.3.1.tar.gz
+# swap out buggy lines in ruby bindings:
+sed -i 's/Init_OpenBabel/Init_openbabel/g' openbabel-2.3.1/scripts/ruby/openbabel-ruby.cpp
+# make a separate build directory for building in:
+mkdir build-rvmruby1.9.3
+cd build-rvmruby1.9.3
+mkdir ~/tools
+cmake ../openbabel-2.3.1 -DRUBY_BINDINGS=ON -DCMAKE_INSTALL_PREFIX=~/tools/openbabel-rvmruby1.9.3
+make && make install
+```
+## See also
+
+* [Rubidium](http://rbtk.rubyforge.org/) (based on the Chemistry Development Kit [jruby])
+* [ChemRuby](https://github.com/ank/chemruby) [standalone using MRI extensions]
+* [Chemcaster Ruby API](https://github.com/metamolecular/chemcaster-ruby)
+
 ## Copyright
 
 MIT License.  See LICENSE for further details.

data/Rakefile

@@ -23,7 +23,7 @@ interface attempts to be a ruby-ish analogue of pybel.}
   end
 
   [
-    ["rspec", "~> 2.8.0"], 
+    ["rspec", "~> 2.13.0"], 
     ["rdoc", "~> 3.12"], 
     ["jeweler", "~> 1.8.3"]
   ].each do |args|

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.0

data/lib/rubabel/atom.rb

@@ -37,11 +37,6 @@ module Rubabel
       #end
     end
 
-    # adds an atom and returns the added atom (allows chaining)
-    def <<(atom, bond_order=1)
-      add_atom!(atom, bond_order)
-    end
-
     # returns the molecule that is parent of this atom
     def mol
       @ob.get_parent.andand.upcast
@@ -67,24 +62,23 @@ module Rubabel
       @ob.get_idx
     end
 
-    # abbreviated name, all lowercase as a Symbol
-    def el
-      NUM_TO_EL[atomic_num]
-    end
-
-    # abbreviated name, properly capitalized and as a String
+    # elemental symbol, properly capitalized and returned as a Symbol
     def element
       NUM_TO_ELEMENT[atomic_num]
     end
+    alias_method :el, :element
 
-    # creates a bond and adds it to both atoms.  Returns the passed in or
-    # newly created atom.
-    def add_atom!(arg, bond_order=1)
-      unless arg.is_a?(Rubabel::Atom)
-        arg = mol.add_atom!(arg)
-      end
-      @ob.get_parent.add_bond(self.ob.get_idx, arg.ob.get_idx, bond_order)
-      arg
+    # connects the atom-like specifier to this atom through Molecule#add_atom!
+    # returns the atom that was just added for chaining.  Takes any argument
+    # that Molecule#add_atom! will take.
+    def bond!(arg, bond_order=1)
+      mol.add_atom!(arg, bond_order, self)
+    end
+    alias_method :<<, :bond!
+
+    # connects a Rubabel::Atom object with a bond
+    def connect!(atom, bond_order=1)
+      @ob.get_parent.add_bond(@ob.get_idx, atom.ob.get_idx, bond_order)
     end
 
     def each_bond(&block)
@@ -319,7 +313,7 @@ module Rubabel
 
     def carbonyl_oxygen?
       ats = atoms
-      ats.size == 1 && ats.first.el == :c && double_bond?
+      ats.size == 1 && ats.first.el == :C && double_bond?
     end
 
     def carbonyl_carbon?

data/lib/rubabel/bond.rb

@@ -59,11 +59,13 @@ module Rubabel
     def bond_order
       @ob.get_bond_order
     end
+    alias_method :order, :bond_order
 
     # 1 = single, 2 = double, 5 = aromatic
     def bond_order=(val=1)
       @ob.set_bond_order(val)
     end
+    alias_method :order=, :bond_order=
 
     # returns self
     def set_atoms!(beg_atom, end_atom)
@@ -99,20 +101,31 @@ module Rubabel
       "#{atoms.map(&:inspect).join(bond_symbol)}"
     end
 
-    # returns self
+    # Increases the bond order and returns a new Rubabel::Bond object--but it
+    # will still be pointing to the same underlying @ob object.
     def +(val)
-      # do we need to check the bounds here?
+      inc!(val)
+      @ob.upcast
+    end
+
+    # increase the bond order by val
+    def inc!(val=1)
       newval = @ob.get_bond_order + val
+      newval = 0 if newval < 0
       @ob.set_bond_order(newval)
       self
     end
 
-    # won't decrease below zero. returns self
+    # decrease the bond order by val
+    def dec!(val=1)
+      inc!(-val)
+    end
+
+    # Decreases the bond order and returns a new Rubabel::Bond object--but it
+    # will still be pointing to the same underlying @ob object.  Won't
+    # decrease below zero.
     def -(val)
-      newval = @ob.get_bond_order - val
-      newval = 0 if newval < 0
-      @ob.set_bond_order(newval)
-      self
+      self.+(-val)
     end
 
   end

data/lib/rubabel/molecule/fragmentable.rb

@@ -31,7 +31,7 @@ module Rubabel
       # 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 }
+        appendage = oxygen.atoms.find {|a| a.el != :C }
         if oxygen.charge != 0
           ocharge = oxygen.charge
         end
@@ -104,7 +104,7 @@ module Rubabel
 
         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|
+            carbon.atoms.select {|a| a.el == :C }.each do |carbon_nbr|
               fragment_sets << carbonyl_oxygen_dump(carbon, oxygen, carbon_nbr)
             end
           end

data/lib/rubabel/molecule.rb

@@ -108,25 +108,40 @@ module Rubabel
       end
     end
 
+    # arg may be a Fixnum, a Symbol (Elemental symbol that is a Symbol), or a
+    # Rubabel::Atom.  Returns the newly associated/created atom.
+    def associate_atom!(arg)
+      if arg.is_a?(Rubabel::Atom)
+        @ob.add_atom(arg.ob)
+        arg
+      else
+        (num, is_aromatic) = 
+          if arg.is_a?(Symbol)
+            [Rubabel::ELEMENT_TO_NUM[arg], (arg.to_s.capitalize != arg.to_s)]
+          else
+            [arg, false]
+          end
+
+        new_obatom = @ob.new_atom
+        new_obatom.set_atomic_num(num)
+        new_obatom.set_aromatic if is_aromatic
+        Rubabel::Atom.new(new_obatom)
+      end
+    end
+
+
     # returns the atom passed in or that was created.  arg is a pre-existing
     # atom, an atomic number or an element symbol (e.g. :c).  default is to
     # add carbon.
-    def add_atom!(arg=6, attach_to=nil, bond_order=1)
-      if attach_to
-        attach_to.add_atom!(arg, bond_order)
-      else
-        if arg.is_a?(Rubabel::Atom)
-          @ob.add_atom(arg.ob)
-          arg
-        else
-          new_obatom = @ob.new_atom
-          arg = Rubabel::EL_TO_NUM[arg] if arg.is_a?(Symbol)
-          new_obatom.set_atomic_num(arg)
-          Rubabel::Atom.new(new_obatom)
-        end
-      end
+    def add_atom!(arg=6, bond_order=1, attach_to=nil)
+      attach_to ||= atoms.last
+      atom = associate_atom!(arg)
+      add_bond!(attach_to, atom, bond_order) if attach_to
+      atom
     end
 
+    alias_method :<<, :add_atom!
+
     # retrieves the atom by index (accepts everything an array would)
     def [](*args)
       atoms[*args]
@@ -490,18 +505,6 @@ module Rubabel
       Rubabel::MoleculeData.new(@ob)
     end
 
-    # adds the atom (takes atomic number, element symbol or preexisting atom)
-    # and returns self
-    def <<(arg, bond_order=1)
-      last_atom = atoms[-1]
-      if last_atom
-        last_atom.add_atom!(arg, bond_order)
-      else
-        add_atom!(arg)
-      end
-      self
-    end
-
     # sensitive to add_h!
     def num_atoms(count_implied_hydrogens=false) 
       if !count_implied_hydrogens

data/lib/rubabel.rb

@@ -113,19 +113,28 @@ module Rubabel
 end
 
 module Rubabel
-  # capitalized strings
-  ELEMENTS = %w(H He Li Be B C N O F Ne Na Mg Al Si P S Cl Ar K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn Ga Ge As Se Br Kr Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Xe Cs Ba La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg Tl Pb Bi Po At Rn Fr Ra Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr Rf Db Sg Bh Hs Mt Ds Rg Cn Uut Fl Uup Lv Uus Uuo)
+  # capitalized Symbols
+  ELEMENTS = %w(H He Li Be B C N O F Ne Na Mg Al Si P S Cl Ar K Ca Sc Ti V Cr Mn Fe Co Ni Cu Zn Ga Ge As Se Br Kr Rb Sr Y Zr Nb Mo Tc Ru Rh Pd Ag Cd In Sn Sb Te I Xe Cs Ba La Ce Pr Nd Pm Sm Eu Gd Tb Dy Ho Er Tm Yb Lu Hf Ta W Re Os Ir Pt Au Hg Tl Pb Bi Po At Rn Fr Ra Ac Th Pa U Np Pu Am Cm Bk Cf Es Fm Md No Lr Rf Db Sg Bh Hs Mt Ds Rg Cn Uut Fl Uup Lv Uus Uuo).map(&:to_sym)
 
-  # atomic number to properly capitalized element abbreviation
+  # atomic number to properly capitalized element abbreviation (as Symbol)
   NUM_TO_ELEMENT = Hash[ ELEMENTS.each_with_index.map {|el,i| [i+1,el] } ]
+  # atomic number to properly capitalized element abbreviation (as Symbol)
 
-  # atomic number to lowercase symbol abbreviation
-  NUM_TO_EL = Hash[ ELEMENTS.each_with_index.map {|el,i| [i+1,el.downcase.to_sym] } ]
+  # the SMILES aromatic elements, listed in proper capitalized notation (e.g., :Se)
+  AROMATIC_ELEMENTS = [:C, :O, :S, :Se, :N]
+  # (http://esc.syrres.com/esc/docsmile.htm)
 
-  EL_TO_NUM = NUM_TO_EL.invert
+  # Along with properly capitalized element symbols (e.g., :Se) ELEMENT_TO_NUM
+  # will include keys to lowercase versions of the AROMATIC_ELEMENTS
   ELEMENT_TO_NUM = NUM_TO_ELEMENT.invert
+
+  AROMATIC_ELEMENTS.each do |el|
+    ELEMENT_TO_NUM[el.to_s.downcase.to_sym] = ELEMENT_TO_NUM[el]
+  end
 end
 
+
+
 =begin
 OBConversion conv;
 OBMol mol;

data/spec/chemistry_toolkit_rosetta/chemistry_toolkit_rosetta_spec.rb

@@ -24,8 +24,12 @@ end
 
 describe 'Chemistry Toolkit Rosetta Wiki' do
 
-  def equivalent_pngs(png1, png2)
-    (png1.size - png2.size < 50) && (png1[0..100] == png2[0..100])
+  def pngs_are_about_same_size(png1, png2, delta=150)
+    (png1.size - png2.size < delta)
+  end
+
+  def pngs_have_same_header(png1, png2, check_length=60)
+     png1[0..check_length] == png2[0..check_length]
   end
 
   before(:each) do
@@ -239,7 +243,9 @@ describe 'Chemistry Toolkit Rosetta Wiki' do
     end
     png_out = IO.read(@wiki_spec_dir + "/caffeine.png")
     key_out = IO.read(@keydir + "/caffeine.frozen.png")
-    equivalent_pngs(png_out, key_out).should be_true
+    
+    pngs_are_about_same_size(png_out, key_out).should be_true
+    pngs_have_same_header(png_out, key_out).should be_true
     File.unlink('caffeine.png')
   end
   #OR, using commandline
@@ -258,7 +264,8 @@ describe 'Chemistry Toolkit Rosetta Wiki' do
     end
     png_out = IO.read(@wiki_spec_dir + "/3016_highlighted.rubabel.png")
     key_out = IO.read(@keydir + "/3016_highlighted.rubabel.frozen.png")
-    equivalent_pngs(png_out, key_out)
+    pngs_are_about_same_size(png_out, key_out).should be_true
+    pngs_have_same_header(png_out, key_out).should be_true
     File.unlink('3016_highlighted.rubabel.png')
   end
 
@@ -307,7 +314,7 @@ describe 'Chemistry Toolkit Rosetta Wiki' do
       mol.matches(smarts).each do |atom1, atom2|
         mol.delete(atom1.get_bond(atom2))
         [atom1, atom2].each do |old_a|
-          mol.add_bond!(old_a, mol.add_atom!(0))
+          mol.add_atom!(0, 1, old_a)
         end
       end
       puts "#{mol.to_s.gsub('.',"\n")}"

data/spec/rubabel/atom_spec.rb

@@ -23,6 +23,7 @@ describe Rubabel::Atom do
     end
 
     it 'attaches given an atomic number' do
+
     end
 
     it 'attaches given an element symbol' do

data/spec/rubabel/bond_spec.rb

@@ -19,4 +19,61 @@ describe Rubabel::Bond do
     end
   end
 
+  describe 'manipulating the bond order' do
+    subject { 
+      mol = Rubabel['CC'] 
+      mol[0].get_bond(mol[1])
+    }
+
+    specify '#inc! increases the bond order' do
+      subject.order.should == 1
+      subject.inc! 
+      subject.order.should == 2
+    end
+
+    specify '#inc!(n) increases the bond order by n' do
+      subject.order.should == 1
+      subject.inc!(2) 
+      subject.order.should == 3
+    end
+
+    specify '#inc!(-n) will not go below 0' do
+      subject.order.should == 1
+      subject.inc!(-1) 
+      subject.order.should == 0
+      subject.inc!(-1) 
+      subject.order.should == 0
+    end
+
+    specify '#+(n) will add but not return same ruby object (underlying ob object same)' do
+      other = subject + 1
+      other.order.should == 2
+      subject.order.should == 2
+      subject.should_not equal(other)
+      #other.object_id.should_not == subject.object_id
+    end
+
+    specify '#+(n) will add but not return same ruby object (underlying ob object same)' do
+      another_var = subject
+      another_var += 1
+      another_var.order.should == 2
+      subject.order.should == 2
+      subject.ob.should equal(another_var.ob)
+    end
+
+    specify '#dec!' do
+      subject.dec!
+      subject.order.should == 0
+    end
+
+    specify '#-(n)' do
+      var = subject
+      var.inc!
+      var.order.should == 2
+      var -= 2
+      var.order.should == 0
+      var -= 1
+      var.order.should == 0
+    end
+  end
 end

data/spec/rubabel/molecule_spec.rb

@@ -22,10 +22,10 @@ describe Rubabel::Molecule do
   end
 
   #xit 'can add a hydrogen to the formula' do
-    #mol = Rubabel["CCC"]
-    #p mol.formula
-    #mol.add_hydrogen_to_formula!
-    #p mol.formula
+  #mol = Rubabel["CCC"]
+  #p mol.formula
+  #mol.add_hydrogen_to_formula!
+  #p mol.formula
   #end
 
   describe 'png output' do
@@ -77,14 +77,14 @@ describe Rubabel::Molecule do
 
   specify '#[] retrieves atom by index' do
     mol = Rubabel["NCO"]
-    mol[0].el.should == :n
-    mol[1].el.should == :c
-    mol[2].el.should == :o
-    mol[-1].el.should == :o
-    mol[-2].el.should == :c
+    mol[0].el.should == :N
+    mol[1].el.should == :C
+    mol[2].el.should == :O
+    mol[-1].el.should == :O
+    mol[-2].el.should == :C
     ar = mol[1..-1]
-    ar.first.el.should == :c
-    ar.last.el.should == :o
+    ar.first.el.should == :C
+    ar.last.el.should == :O
     ar.size.should == 2
   end
 
@@ -100,34 +100,44 @@ describe Rubabel::Molecule do
     mol.num_atoms(true).should == 11
   end
 
-  describe 'adding an atom' do
-    it 'can be added but not attached' do
+  describe 'adding or associating atoms' do
+
+    it 'can associate atoms with the molecule' do
       mol = Rubabel["CCO"]
-      atom = mol.add_atom!(:n)
-      atom.el.should == :n
-      atom = mol.add_atom!(8)
-      atom.el.should == :o
+      nitrogen = mol.associate_atom!(:N)
+      nitrogen.el.should == :N
+      oxygen = mol.associate_atom!(8)
+      oxygen.el.should == :O
       mol.csmiles.should == "CCO.N.O"
+
+      oxygen_aromatic = mol.associate_atom!(:O)
+      mol.csmiles.should == "CCO.N.O.O"
     end
 
-    it "can be added and attached by el symbol or atomic number" do 
+    it "can be added and attached by element symbol or atomic number" do 
       mol = Rubabel["CCO"]
       first_carbon = mol[0]
-      mol.add_atom!(:n, first_carbon)
+      mol.add_atom!(:N, 1, first_carbon)
       mol.csmiles.should == "NCCO"
 
-      mol.add_atom!(16, first_carbon)
+      mol.add_atom!(16, 1, first_carbon)
       mol.csmiles.should == "NC(CO)S"
     end
 
   end
-  
-  specify '#<< adds atom to the last atom and returns the mol' do
+
+  specify '#<< adds atom to the last atom and returns the added atom' do
     mol = Rubabel::Molecule.new
+    reply = (mol << :N)
     # by element symbol or atomic number
-    reply = (mol << :n << :c)
-    reply.should be_a(Rubabel::Molecule)
-    reply.csmiles.should == 'CN'
+    reply = (mol << :N << :C)
+    reply.should be_a(Rubabel::Atom)
+    reply.el.should == :C
+
+    # properly handles aromaticity
+    mol.atoms.last.aromatic?.should be_false
+    mol << :c # aromatic specifier in SMILES
+    mol.atoms.last.aromatic?.should be_true
   end
 
   specify '#dup duplicates the molecule' do
@@ -143,7 +153,7 @@ describe Rubabel::Molecule do
   describe '#add_bond! adds a bond (and updates atoms)' do
     specify 'given two atoms' do
       mol = Rubabel["CCO"]
-      atom = mol.add_atom!(0)
+      atom = mol.associate_atom!(0)
       mol.add_bond!(mol[1], atom)
       mol.csmiles.should == '*C(O)C'
     end
@@ -151,7 +161,7 @@ describe Rubabel::Molecule do
 
   specify '#atom(id) retrieves atom by id num' do
     mol = Rubabel["CCO"]
-    o = mol.find {|a| a.el == :o }
+    o = mol.find {|a| a.el == :O }
     mol.atom(o.id).id.should == o.id
   end
 
@@ -160,7 +170,7 @@ describe Rubabel::Molecule do
     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 }
+    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'
@@ -315,7 +325,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 }
+      @n = @mol.find {|a| a.el == :N }
     end
 
     it 'num_atoms, atoms and each_atom are sensitive to #add_h!' do

data/spec/spec_helper.rb

@@ -5,14 +5,14 @@ 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('*')
+    output.print pending_color('*')
   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]}" )
+    output.puts pending_color( "<pending>: #{example.execution_result[:pending_message]}" )
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubabel
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-18 00:00:00.000000000 Z
+date: 2013-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: openbabel
@@ -66,7 +66,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.0
+        version: 2.13.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -74,7 +74,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.8.0
+        version: 2.13.0
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement