alumina 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+.yardoc
+doc
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tim Morgan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,17 @@
+= Alumina
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Tim Morgan. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "alumina"
+    gem.summary = %Q{Ruby parser for various chemistry-related file formats}
+    gem.description = %Q{This gem parses HyperChem's .HIN files, PDB files, and in the future others, converting them to Ruby objects for easy manipulation}
+    gem.email = "git@timothymorgan.info"
+    gem.homepage = "http://github.com/RISCfuture/alumina"
+    gem.authors = ["Tim Morgan"]
+    gem.add_development_dependency "bacon", ">= 0"
+    gem.add_development_dependency "yard", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |spec|
+    spec.libs << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |doc|
+    doc.options << "-m" << "textile"
+    doc.options << "--protected"
+    doc.options << "-r" << "README.textile"
+    doc.options << "-o" << "doc"
+    doc.options << "--title" << "Alumina Documentation".inspect
+    
+    doc.files << "lib/**/*"
+  end
+rescue LoadError
+  task :yard do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end
+
+task :doc => :yard

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/data/elements.yml

@@ -0,0 +1,355 @@
+--- 
+1: 
+  :symbol: H
+  :name: Hydrogen
+2: 
+  :symbol: He
+  :name: Helium
+3: 
+  :symbol: Li
+  :name: Lithium
+4: 
+  :symbol: Be
+  :name: Beryllium
+5: 
+  :symbol: B
+  :name: Boron
+6: 
+  :symbol: C
+  :name: Carbon
+7: 
+  :symbol: N
+  :name: Nitrogen
+8: 
+  :symbol: O
+  :name: Oxygen
+9: 
+  :symbol: F
+  :name: Fluorine
+10: 
+  :symbol: Ne
+  :name: Neon
+11: 
+  :symbol: Na
+  :name: Sodium
+12: 
+  :symbol: Mg
+  :name: Magnesium
+13: 
+  :symbol: Al
+  :name: Aluminium
+14: 
+  :symbol: Si
+  :name: Silicon
+15: 
+  :symbol: P
+  :name: Phosphorus
+16: 
+  :symbol: S
+  :name: Sulfur
+17: 
+  :symbol: Cl
+  :name: Chlorine
+18: 
+  :symbol: Ar
+  :name: Argon
+19: 
+  :symbol: K
+  :name: Potassium
+20: 
+  :symbol: Ca
+  :name: Calcium
+21: 
+  :symbol: Sc
+  :name: Scandium
+22: 
+  :symbol: Ti
+  :name: Titanium
+23: 
+  :symbol: V
+  :name: Vanadium
+24: 
+  :symbol: Cr
+  :name: Chromium
+25: 
+  :symbol: Mn
+  :name: Manganese
+26: 
+  :symbol: Fe
+  :name: Iron
+27: 
+  :symbol: Co
+  :name: Cobalt
+28: 
+  :symbol: Ni
+  :name: Nickel
+29: 
+  :symbol: Cu
+  :name: Copper
+30: 
+  :symbol: Zn
+  :name: Zinc
+31: 
+  :symbol: Ga
+  :name: Gallium
+32: 
+  :symbol: Ge
+  :name: Germanium
+33: 
+  :symbol: As
+  :name: Arsenic
+34: 
+  :symbol: Se
+  :name: Selenium
+35: 
+  :symbol: Br
+  :name: Bromine
+36: 
+  :symbol: Kr
+  :name: Krypton
+37: 
+  :symbol: Rb
+  :name: Rubidium
+38: 
+  :symbol: Sr
+  :name: Strontium
+39: 
+  :symbol: Y
+  :name: Yttrium
+40: 
+  :symbol: Zr
+  :name: Zirconium
+41: 
+  :symbol: Nb
+  :name: Niobium
+42: 
+  :symbol: Mo
+  :name: Molybdenum
+43: 
+  :symbol: Tc
+  :name: Technetium
+44: 
+  :symbol: Ru
+  :name: Ruthenium
+45: 
+  :symbol: Rh
+  :name: Rhodium
+46: 
+  :symbol: Pd
+  :name: Palladium
+47: 
+  :symbol: Ag
+  :name: Silver
+48: 
+  :symbol: Cd
+  :name: Cadmium
+49: 
+  :symbol: In
+  :name: Indium
+50: 
+  :symbol: Sn
+  :name: Tin
+51: 
+  :symbol: Sb
+  :name: Antimony
+52: 
+  :symbol: Te
+  :name: Tellurium
+53: 
+  :symbol: I
+  :name: Iodine
+54: 
+  :symbol: Xe
+  :name: Xenon
+55: 
+  :symbol: Cs
+  :name: Caesium
+56: 
+  :symbol: Ba
+  :name: Barium
+57: 
+  :symbol: La
+  :name: Lanthanum
+58: 
+  :symbol: Ce
+  :name: Cerium
+59: 
+  :symbol: Pr
+  :name: Praseodymium
+60: 
+  :symbol: Nd
+  :name: Neodymium
+61: 
+  :symbol: Pm
+  :name: Promethium
+62: 
+  :symbol: Sm
+  :name: Samarium
+63: 
+  :symbol: Eu
+  :name: Europium
+64: 
+  :symbol: Gd
+  :name: Gadolinium
+65: 
+  :symbol: Tb
+  :name: Terbium
+66: 
+  :symbol: Dy
+  :name: Dysprosium
+67: 
+  :symbol: Ho
+  :name: Holmium
+68: 
+  :symbol: Er
+  :name: Erbium
+69: 
+  :symbol: Tm
+  :name: Thulium
+70: 
+  :symbol: Yb
+  :name: Ytterbium
+71: 
+  :symbol: Lu
+  :name: Lutetium
+72: 
+  :symbol: Hf
+  :name: Hafnium
+73: 
+  :symbol: Ta
+  :name: Tantalum
+74: 
+  :symbol: W
+  :name: Tungsten
+75: 
+  :symbol: Re
+  :name: Rhenium
+76: 
+  :symbol: Os
+  :name: Osmium
+77: 
+  :symbol: Ir
+  :name: Iridium
+78: 
+  :symbol: Pt
+  :name: Platinum
+79: 
+  :symbol: Au
+  :name: Gold
+80: 
+  :symbol: Hg
+  :name: Mercury
+81: 
+  :symbol: Tl
+  :name: Thallium
+82: 
+  :symbol: Pb
+  :name: Lead
+83: 
+  :symbol: Bi
+  :name: Bismuth
+84: 
+  :symbol: Po
+  :name: Polonium
+85: 
+  :symbol: At
+  :name: Astatine
+86: 
+  :symbol: Rn
+  :name: Radon
+87: 
+  :symbol: Fr
+  :name: Francium
+88: 
+  :symbol: Ra
+  :name: Radium
+89: 
+  :symbol: Ac
+  :name: Actinium
+90: 
+  :symbol: Th
+  :name: Thorium
+91: 
+  :symbol: Pa
+  :name: Protactinium
+92: 
+  :symbol: U
+  :name: Uranium
+93: 
+  :symbol: Np
+  :name: Neptunium
+94: 
+  :symbol: Pu
+  :name: Plutonium
+95: 
+  :symbol: Am
+  :name: Americium
+96: 
+  :symbol: Cm
+  :name: Curium
+97: 
+  :symbol: Bk
+  :name: Berkelium
+98: 
+  :symbol: Cf
+  :name: Californium
+99: 
+  :symbol: Es
+  :name: Einsteinium
+100: 
+  :symbol: Fm
+  :name: Fermium
+101: 
+  :symbol: Md
+  :name: Mendelevium
+102: 
+  :symbol: "No"
+  :name: Nobelium
+103: 
+  :symbol: Lr
+  :name: Lawrencium
+104: 
+  :symbol: Rf
+  :name: Rutherfordium
+105: 
+  :symbol: Db
+  :name: Dubnium
+106: 
+  :symbol: Sg
+  :name: Seaborgium
+107: 
+  :symbol: Bh
+  :name: Bohrium
+108: 
+  :symbol: Hs
+  :name: Hassium
+109: 
+  :symbol: Mt
+  :name: Meitnerium
+110: 
+  :symbol: Ds
+  :name: Darmstadtium
+111: 
+  :symbol: Rg
+  :name: Roentgenium
+112: 
+  :symbol: Cn
+  :name: Copernicium
+113: 
+  :symbol: Uut
+  :name: Ununtrium
+114: 
+  :symbol: Uuq
+  :name: Ununquadium
+115: 
+  :symbol: Uup
+  :name: Ununpentium
+116: 
+  :symbol: Uuh
+  :name: Ununhexium
+117: 
+  :symbol: Uuh
+  :name: Ununseptium
+118: 
+  :symbol: Uuo
+  :name: Ununoctium

data/lib/alumina.rb

@@ -0,0 +1,32 @@
+require 'yaml'
+require 'extensions'
+require 'alumina/errors'
+require 'alumina/hin/writer'
+require 'alumina/element'
+require 'alumina/atom'
+require 'alumina/molecule'
+require 'alumina/hin'
+require 'alumina/hin/parser'
+
+# Container module for classes of the Alumina gem.
+
+module Alumina
+  # @private
+  ELEMENTS_PATH = File.expand_path("#{File.dirname(__FILE__)}/../data/elements.yml")
+  # An array of all {Element Elements}, loaded from a YAML data file.
+  ELEMENTS = YAML.load(File.read(ELEMENTS_PATH)).map { |atomic_number, data| Element.new(atomic_number, data[:name], data[:symbol]) }
+  # All elements hashed by their symbol (e.g., "Ag" for silver).
+  ELEMENTS_BY_SYMBOL = ELEMENTS.inject({}) { |hsh, cur| hsh[cur.symbol] = cur ; hsh }
+  # All elements hashed by their atomic number.
+  ELEMENTS_BY_NUMBER = ELEMENTS.inject({}) { |hsh, cur| hsh[cur.atomic_number] = cur ; hsh }
+  
+  # Creates a {HIN::Parser} and calls {HIN::Parser#parse} on it.
+  #
+  # @param [IO, String] input The HIN data to parse.
+  # @return [Array<Alumina::Molecule>] The molecules described by the data.
+  # @raise [ParseError] If the HIN data is improperly formatted.
+  
+  def self.HIN(input)
+    Alumina::HIN::Parser.new.parse(input)
+  end
+end

data/lib/alumina/atom.rb

@@ -0,0 +1,93 @@
+module Alumina
+  
+  # An atom as part of a {Molecule}.
+  
+  class Atom
+    include Alumina::HIN::Writer::Atom
+    
+    BOND_TYPES = [ :single, :double, :triple, :aromatic ]
+    
+    # @return [Fixnum] The unique numerical identifier assigned to the atom.
+    attr_accessor :id
+    # @return [String, nil] The optional label given to the atom.
+    attr_accessor :label
+    # @return [Element] The atomic type.
+    attr_accessor :element
+    # @return [Float] The atom's _x_-coordinate in the molecule.
+    attr_accessor :x
+    # @return [Float] The atom's _y_-coordinate in the molecule.
+    attr_accessor :y
+    # @return [Float] The atom's _z_-coordinate in the molecule.
+    attr_accessor :z
+    # @return [Hash<Atom, Symbol>] The atoms this atom is bonded to, along with
+    # the bond type.
+    attr_accessor :bonds
+    # @return [Fixnum] The partial charge.
+    attr_accessor :partial_charge
+    
+    # @private
+    attr_accessor :ignored1, :ignored2
+    
+    # Initializes a new atom. After initializing it you can define its bonds
+    # strucrure using the {.bind} method. Atoms are added to
+    # {Molecule Molecules} with the @<<@ method.
+    #
+    # @param [Fixnum] id A unique identifier for this atom. Uniqueness is not
+    # checked here.
+    # @param [Element] element The atom's type.
+    # @param [Float] x The atom's _x_-coordinate in the molecule.
+    # @param [Float] y The atom's _y_-coordinate in the molecule.
+    # @param [Float] z The atom's _z_-coordinate in the molecule.
+    
+    def initialize(id, element, x, y, z)
+      @id = id
+      @element = element
+      @x = x
+      @y = y
+      @z = z
+      @bonds = Hash.new
+    end
+    
+    # Binds two atoms together.
+    #
+    # @param [Atom] atom1 An atom to bind.
+    # @param [Atom] atom2 An atom to bind.
+    # @param [Symbol] The bond type. (See {BOND_TYPES}.)
+    # @raise [ArgumentError] If an invalid bond type is given.
+    
+    def self.bind(atom1, atom2, type)
+      raise ArgumentError, "Invalid bond type #{type.inspect}" unless BOND_TYPES.include?(type)
+      
+      atom1.bonds[atom2] = type
+      atom2.bonds[atom1] = type
+    end
+    
+    # @return [Fixnum] The number of atoms bound to this atom.
+    
+    def bond_count
+      bonds.size
+    end
+    
+    # Creates a duplicate of this atom with no bonds.
+    #
+    # @return [Atom] A duplicate of this atom.
+    
+    def dup
+      atom = Atom.new(id, element, x, y, z)
+      atom.label = label
+      atom.partial_charge = partial_charge
+      atom.ignored1 = ignored1
+      atom.ignored2 = ignored2
+      return atom
+    end
+    
+    # @private
+    def inspect
+      if label then
+        "#<Atom ##{id} #{label} (#{element.symbol})>"
+      else
+        "#<Atom ##{id} #{element.symbol}>"
+      end
+    end
+  end
+end

data/lib/alumina/element.rb

@@ -0,0 +1,30 @@
+module Alumina
+  
+  # Each of the elements has a singleton instance of this class. You do not
+  # create instances of this class; they are loaded from a data file.
+  
+  class Element
+    # @return [Fixnum] The element's atomic number (hydrogen is 1).
+    attr_reader :atomic_number
+    # @return [String] The element's name.
+    attr_reader :name
+    # @return [String] The element's symbol (hydrogen is @H@).
+    attr_reader :symbol
+    
+    # @private
+    def initialize(atomic_number, name, symbol)
+      @atomic_number = atomic_number
+      @name = name
+      @symbol = symbol
+    end
+    
+    # Provides a natural ordering based on atomic number.
+    #
+    # @param [Element] other The other element to compare against.
+    # @return [-1, 0, 1] The sort equivalency.
+    
+    def <=>(other)
+      atomic_number <=> other.atomic_number
+    end
+  end
+end

data/lib/alumina/errors.rb

@@ -0,0 +1,15 @@
+module Alumina
+  
+  # Raised when invalid HIN data is encountered.
+  
+  class ParseError < StandardError
+    # @return [Fixnum] The line in the HIN data at which the error occurred.
+    attr_accessor :line
+    
+    # @private
+    def initialize(line, reason)
+      @line = line
+      super(reason)
+    end
+  end
+end

data/lib/alumina/hin.rb

@@ -0,0 +1,7 @@
+module Alumina
+  
+  # Container module for classes working with HyperChem's HIN file format.
+  
+  module HIN
+  end
+end

data/lib/alumina/hin/parser.rb

@@ -0,0 +1,139 @@
+module Alumina
+  module HIN
+  
+    # Class that parses HIN files to produce {Molecule} instances. This class is
+    # not thread-safe! You must instantiate a new parser for each thread of your
+    # program.
+  
+    class Parser
+      # Mapping of HIN file bond types to their symbol values for the {Atom}
+      # class.
+      BOND_TYPES = {
+        's' => :single,
+        'd' => :double,
+        't' => :triple,
+        'a' => :aromatic
+      }
+      
+      # If @true@, does not raise {ParseError} when
+      #
+      # * unknown commands are encountered,
+      # * the bond count is incorrect, or
+      # * an @endmol@'s ID does not correspond to its @mol@'s ID.
+      attr_accessor :lenient
+    
+      # Parses HIN data and returns an array of {Molecule Molecules}.
+      #
+      # @param [IO, String] input The HIN data to parse.
+      # @return [Array<Alumina::Molecule>] The molecules described by the data.
+      # @raise [ParseError] If the HIN data is improperly formatted.
+    
+      def parse(input)
+        @molecules = Array.new
+        @current_molecule = nil
+        @line_counter = 0
+        @bonds = Hash.autonew
+
+        input.each_line do |line|
+          @line_counter += 1
+          next if line =~ /^\s*$/
+          next if line[0] == ';' # comment
+          parts = line.split(/\s+/)
+
+          command = parts.shift
+          method = :"parse_#{command}"
+          if respond_to?(method) then
+            send(method, *parts)
+          else
+            if lenient then
+              next
+            else
+              raise ParseError.new(@line_counter, "Unknown command #{command}")
+            end
+          end
+        end
+        
+        @bonds.each do |molecule, firsts|
+          firsts.each do |atom1, lasts|
+            lasts.each do |atom2, bond_type|
+              Atom.bind molecule[atom1], molecule[atom2], BOND_TYPES[bond_type]
+            end
+          end
+        end
+
+        return @molecules
+      end
+    
+      protected
+    
+      def parse_forcefield(*unknowns)
+        #TODO
+      end
+    
+      def parse_sys(*unknowns)
+        #TODO
+      end
+    
+      def parse_view(*unknowns)
+        #TODO
+      end
+    
+      def parse_box(*unknowns)
+        #TODO
+      end
+      
+      def parse_seed(*unknowns)
+        #TODO
+      end
+    
+      # @private
+      def parse_mol(id, label=nil)
+        if @current_molecule then
+          raise ParseError.new(@line_counter, "Can't have a mol section within another mol section")
+        else
+          label = nil if label.blank?
+          @current_molecule = Molecule.new(id.to_i, label)
+        end
+      end
+    
+      # @private
+      def parse_endmol(id)
+        raise ParseError.new(@line_counter, "Given endmol with id #{@id}, but open molecule has ID #{@current_molecule.id}") if id.to_i != @current_molecule.id and not lenient
+      
+        @molecules << @current_molecule
+        @current_molecule = nil
+      end
+
+      # @private
+      def parse_atom(id, label, symbol, ignored1, ignored2, partial_charge, x, y, z, bond_count, *bonds)
+        if @current_molecule then
+          label = nil if label.blank?
+          element = ELEMENTS_BY_SYMBOL[symbol]
+          raise ParseError.new("Unknown element #{symbol}") unless element
+        
+          atom = Atom.new(id.to_i, element, x.to_f, y.to_f, z.to_f)
+          atom.label = label
+          atom.ignored1 = ignored1
+          atom.ignored2 = ignored2
+          atom.partial_charge = partial_charge.to_i
+          
+          bond_count = bond_count.to_i
+          raise ParseError.new(@line_counter, "Expected #{bond_count} bonds but found #{bonds.size/2}") if bond_count != bonds.size/2 and not lenient
+          
+          bonds.in_groups_of(2).each do |(atom_id, bond_type)|
+            first_id = [ atom.id, atom_id.to_i ].min
+            last_id = [ atom.id, atom_id.to_i ].max
+            if @bonds[@current_molecule][first_id][last_id] != {} and @bonds[@current_molecule][first_id][last_id] != bond_type then
+              raise ParseError.new(@line_counter, "Assymetric bond between #{first_id} and #{last_id} of type #{bond_type}")
+            end
+            raise ParseError.new(@line_counter, "Unknown bond type #{bond_type}") unless BOND_TYPES.include?(bond_type)
+            @bonds[@current_molecule][first_id][last_id] = bond_type
+          end
+          @current_molecule << atom
+        else
+          raise ParseError.new(@line_counter, "Can't have an atom command outside of a mol section")
+        end
+      end
+    end
+  end
+end

data/lib/alumina/hin/writer.rb

@@ -0,0 +1,34 @@
+module Alumina
+  module HIN
+    
+    # Modules that add methods for writing data in HIN format.
+    
+    module Writer
+      
+      # Adds methods for writing data in HIN format to {Molecule} objects.
+      
+      module Molecule
+        
+        # Outputs this molecule in HIN format.
+        
+        def to_hin
+          lines = atoms.map(&:to_hin)
+          lines.unshift "mol #{id}#{" #{label}" if label}"
+          lines.push "endmol #{id}"
+          lines.join("\n")
+        end
+      end
+      
+      # Adds methods for writing data in HIN format to {Atom} objects.
+      
+      module Atom
+        
+        # Outputs this atom in HIN format.
+        
+        def to_hin
+          "atom #{id} #{label || '-'} #{element.symbol} #{ignored1} #{ignored2} #{partial_charge} #{x} #{y} #{z} #{bonds.size} " + bonds.map { |atom, type| "#{atom.id} #{HIN::Parser::BOND_TYPES.key(type)}" }.join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/alumina/molecule.rb

@@ -0,0 +1,89 @@
+module Alumina
+  
+  # A molecule as represented by HIN data, consisting of multiple {Atom Atoms}.
+  
+  class Molecule
+    include Alumina::HIN::Writer::Molecule
+    
+    # @return [Fixnum] The unique numerical identifier for this molecule.
+    attr_accessor :id
+    # @return [String, nil] The optional label given to this molecule.
+    attr_accessor :label
+    
+    # Creates a new instance.
+    #
+    # @param [Fixnum] id The molecule's unique ID. Uniqueness is not checked in
+    # this method.
+    # @param [String] label A label to give the molecule.
+    
+    def initialize(id, label=nil)
+      @id = id
+      @label = label
+      @atoms = Hash.new
+    end
+    
+    # Adds an atom to this molecule. If there is already an atom in this
+    # molecule sharing this atom's {Atom#id ID}, it will be replaced by this
+    # atom.
+    #
+    # @param [Atom] atom The atom to add.
+    
+    def <<(atom)
+      @atoms[atom.id] = atom
+    end
+    
+    # @return [Array<Atom>] An array of atoms in this molecule.
+    
+    def atoms
+      @atoms.values
+    end
+    
+    # Returns an atom for a given unique identifier.
+    #
+    # @param [Fixnum] ident The identifier to search.
+    # @return [Atom, nil] The atom with that identifier, or @nil@ if no such
+    # atom was found.
+    
+    def atom(ident)
+      @atoms[ident]
+    end
+    
+    alias :[] :atom
+    
+    # @return [String] Returns the plain-text molecular formula for this atom;
+    # for example, @C7H5N3O6@ for TNT.
+    
+    def molecular_formula
+      counts = atoms.map(&:element).inject(Hash.new(0)) { |hsh, cur| hsh[cur] += 1 ; hsh }
+      counts.keys.sort.reverse.map { |element| "#{element.symbol}#{num_for counts[element]}" }.join
+    end
+    
+    # @private
+    def inspect
+      if label then
+        "#<Molecule ##{id} (#{label}): #{molecular_formula}>"
+      else
+        "#<Molecule ##{id}: #{molecular_formula}>"
+      end
+    end
+    
+    private
+    
+    def num_for(num)
+      num.to_s.chars.map do |char|
+        case char
+          when '0' then ?\u2080
+          when '1' then ?\u2081
+          when '2' then ?\u2082
+          when '3' then ?\u2083
+          when '4' then ?\u2084
+          when '5' then ?\u2085
+          when '6' then ?\u2086
+          when '7' then ?\u2087
+          when '8' then ?\u2088
+          when '9' then ?\u2089
+        end
+      end.join
+    end
+  end
+end

data/lib/extensions.rb

@@ -0,0 +1,59 @@
+# @private
+class String
+  
+  # @private
+  def blank?
+    self =~ /^\s*$/
+  end
+end
+
+# @private
+class NilClass
+  
+  # @private
+  def blank?
+    true
+  end
+end
+
+# @private
+class Array
+  # @private -- Credit to DHH and the Rails team
+  def in_groups_of(number, fill_with = nil)
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat([fill_with] * padding)
+    end
+  
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      returning [] do |groups|
+        collection.each_slice(number) { |group| groups << group }
+      end
+    end
+  end
+end
+
+# @private
+class Object
+  # @private -- Credit to DHH and the Rails team
+  def returning(value)
+    yield(value)
+    value
+  end
+end
+
+# @private
+class Hash
+  # @private -- credit to Trans, Jan Molic, Facets team
+  def self.autonew(*args)
+    leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
+    new(*args,&leet)
+  end
+end

data/spec/alumina_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "Alumina" do
+  it "fails" do
+    should.flunk "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bacon'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'alumina'
+
+Bacon.summary_on_exit

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification 
+name: alumina
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Tim Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-02 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bacon
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: This gem parses HyperChem's .HIN files, PDB files, and in the future others, converting them to Ruby objects for easy manipulation
+email: git@timothymorgan.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.textile
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.textile
+- Rakefile
+- VERSION
+- data/elements.yml
+- lib/alumina.rb
+- lib/alumina/atom.rb
+- lib/alumina/element.rb
+- lib/alumina/errors.rb
+- lib/alumina/hin.rb
+- lib/alumina/hin/parser.rb
+- lib/alumina/hin/writer.rb
+- lib/alumina/molecule.rb
+- lib/extensions.rb
+- spec/alumina_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/RISCfuture/alumina
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby parser for various chemistry-related file formats
+test_files: 
+- spec/alumina_spec.rb
+- spec/spec_helper.rb