molecules 0.1.0 → 0.1.3

data/MIT-LICENSE

@@ -1,6 +1,4 @@
 Copyright (c) 2006-2008, Regents of the University of Colorado.
-Developer:: Simon Chiang, Biomolecular Structure Program
-Support:: CU Denver School of Medicine Deans Academic Enrichment Fund
 
 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

data/README

@@ -47,8 +47,8 @@ Molecules provides a mass calculator tap task.  Tap[http://tap.rubyforge.org]
 is not required by molecules in general, but you get this bonus if you have tap
 installed:
 
-  % tap -- molecules/calc ":RPPGFSPFR + H2O"
-    I[15:34:30]         1077.57 Da :RPPGFSPFR + H2O
+  % tap run -- molecules/calc H2O
+    I[17:08:00]   18.0105646863 Da H2O
 
 == Known Issues
 

data/lib/molecules/calc.rb

@@ -10,101 +10,40 @@ Unit.setup
 
 module Molecules
 
-  # :startdoc::manifest a mass calculator
-  # Calculates the mass of a molecule or empirical formula.  The
-  # options can be used to alter the output (precision, mass
-  # calculation method etc.)  You may enter compound formulae, or
-  # a list of formulae.  In addition, polypeptides can be specified 
-  # using the one-letter residue codes:
+  # :startdoc::manifest a mass calculator
   #
-  #   % tap -- molecules/calc H2O
-  #     I[17:09:00]   18.0105646863 Da H2O
-  #
-  #   % tap -- molecules/calc H2O -u kg
-  #     I[13:35:59]    2.99072e-026 kg H2O
+  # Calculates the mass of a molecule.  Compound formulae are allowed and you may
+  # specify a list of formulae. The options can be used to alter the output (precision, 
+  # mass calculation method etc.)
   #
-  #   % tap -- molecules/calc 'C3H5NO + H2O' C50H73N15O11 -p 2
-  #     I[17:08:21]           89.05 Da C3H5NO + H2O
-  #     I[17:08:21]         1059.56 Da C50H73N15O11
-  #
-  #   % tap -- molecules/calc :RPPGFSPFR
-  #     I[13:35:02]         1059.56 Da :RPPGFSPFR
-  #
-  # Furthermore, if a unimod path is specified in the configurations,
-  # unimod modifcations may be specified by name as the polypeptide
-  # termini.  Use '%' signs as in a SQL query to shorten the name:
-  #
-  #   % tap -- molecules/calc 'Acetyl:RPPGFSPFR:Hydroxyl%' --unimod-path <...>
-  #     I[13:33:25]         1059.56 Da Acetyl:RPPGFSPFR:Hydroxyl%
+  #   % tap run -- molecules/calc H2O
+  #     I[17:08:00]   18.0105646863 Da H2O
   #
-  # The unimod path must point to an sqlite3 ActiveUnimod database, and 
-  # sqlite3-ruby must be installed for this feature to work.
-  # 
-  #   * ActiveUnimod[http://bioactive.rubyforge.org/]
-  #   * sqlite3-ruby[http://rubyforge.org/projects/sqlite-ruby/]
-  #  
+  #   % tap run -- molecules/calc H2O --units yg --precision 6
+  #     I[17:08:21]       29.907243 yg H2O
+  #
+  #   % tap run -- molecules/calc 'C3H5NO + H2O' C50H73N15O11 -p 2
+  #     I[17:08:53]           89.05 Da C3H5NO + H2O
+  #     I[17:08:53]         1059.56 Da C50H73N15O11
+  #
   class Calc < Tap::Task
   
     config :type, :monoisotopic                             # the mass type calculated
     config :precision, nil, :short => 'p'                   # the precision of the mass
     config :units, "Da", :short => 'u', &c.string           # the mass unit reported
     config :composition, false, :short => 'c', &c.flag      # reports the composition, not the formula
-    config :unimod_path, nil do |path|                      # the path to the unimod database
-      case
-      when path == nil then nil
-      when File.exists?(path) then path
-      else raise "path to unimod db does not exist: #{path}"
-      end
-    end
     
-    # Formulates a query for a modification matching code_name 
-    # for the unimod database.  If the code_name contains a '%'
-    # then the query will use a LIKE syntax, otherwise the 
-    # code_name will be searced for exactly.
-    def mod_query(code_name)
-      # should do a rails-like escape on code_name
-      "SELECT code_name, composition FROM modifications WHERE code_name #{code_name.include?('%') ? 'LIKE' : '='} '#{code_name}'"
+    # Parses the formula string into an EmpiricalFormula.
+    # Can be used as a hook for more complicated formulae
+    # in subclases.
+    def parse(formula)
+      EmpiricalFormula.parse(formula)
     end
     
-    # Attempts to find and instantiate an EmpiricalFormula for
-    # a unimod modification matching code_name.
-    def find_mod(code_name)
-      raise "no unimod_path was specified" if unimod_path == nil
-      require 'sqlite3' unless Object.const_defined?(:SQLite3)
-      
-      results = []
-      db = SQLite3::Database.new(unimod_path)
-      db.execute(mod_query(code_name)) do |row|
-        results << row
-      end
-      db.close
-      
-      case results.length
-      when 1 then EmpiricalFormula.parse_simple(results[0][1])
-      when 0 then raise "could not find modification: #{code_name}"
-      else raise "multiple modifications found for: #{code_name} (#{results.collect {|result| result[0]}.join(', ')})"
-      end
-    end
-    
-    WATER = EmpiricalFormula.parse "H2O"
-    HYDROGEN = EmpiricalFormula.parse "H"
-    HYDROXIDE = EmpiricalFormula.parse "OH"
-    
     # Returns an array of the calculated masses, in the correct unit.
     def process(*formulae)
-      formulae.collect do |formula_str|
-        formula = EmpiricalFormula.parse(formula_str) do |str|
-          case str
-          when /^(.*?):([A-Z]+):?(.*)$/
-            peptide = Libraries::Polypeptide.new($2) + WATER
-            peptide += find_mod($1) unless $1.to_s.empty? 
-            peptide += find_mod($3) unless $3.to_s.empty?
-            peptide
-          else nil
-          end
-        end
-
-        mass = formula.mass do |element|
+      formulae.collect do |formula_str|
+        mass = parse(formula_str).mass do |element|
           case type
           when :monoisotopic then element.mass
           when :average then element.std_atomic_weight.value
@@ -116,8 +55,8 @@ module Molecules
         unless precision == nil
           mass = Unit.new( Utils.round(mass.scalar, precision), units) 
         end
-        
-        log mass, composition ? formula : formula_str
+
+        log "#{mass.scalar} #{mass.units}", composition ? formula : formula_str
 
         mass
       end

data/lib/molecules/empirical_formula.rb

@@ -39,7 +39,7 @@ module Molecules
         factor = nil
         composition = Hash.new(0)
         scanner = StringScanner.new(formula.reverse)
-        while scanner.restsize > 0
+        while scanner.rest_size > 0
           case
           when scanner.scan_full(/\)(\d+-?)\(/, true, false)
             # found a factor
@@ -133,7 +133,7 @@ module Molecules
 
         # Parse elements and factors out of the formula from right to left     
         scanner = StringScanner.new(formula.reverse)
-        while scanner.restsize > 0
+        while scanner.rest_size > 0
 
           case
           when scanner.scan_full(/(\d+)/, true, false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: molecules
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors: 
 - Simon Chiang
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-11 00:00:00 -06:00
+date: 2008-10-13 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,6 +22,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.1.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: tap
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.8
+    version: 
 description: 
 email: simon.a.chiang@gmail.com
 executables: []
@@ -32,9 +42,6 @@ extra_rdoc_files:
 - README
 - MIT-LICENSE
 files: 
-- MIT-LICENSE
-- Rakefile
-- README
 - lib/molecules.rb
 - lib/molecules/calc.rb
 - lib/molecules/empirical_formula.rb
@@ -42,16 +49,8 @@ files:
 - lib/molecules/libraries/residue.rb
 - lib/molecules/utils.rb
 - tap.yml
-- test/molecules/calc_test.rb
-- test/molecules/empirical_formula_class_test.rb
-- test/molecules/empirical_formula_test.rb
-- test/molecules/libraries/polypeptide_test.rb
-- test/molecules/libraries/residue_test.rb
-- test/molecules/utils_test.rb
-- test/molecules_test.rb
-- test/molecules_test_helper.rb
-- test/molecules_test_suite.rb
-- test/tap_test_helper.rb
+- README
+- MIT-LICENSE
 has_rdoc: true
 homepage: http://bioactive.rubyforge.org/molecules/
 post_install_message: 
@@ -78,5 +77,5 @@ rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: A library of molecules for scientific calculations in Ruby.
-test_files: 
-- test/molecules_test_suite.rb
+test_files: []
+

data/Rakefile

@@ -1,78 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'yaml'
-
-# tasks
-desc 'Default: Run tests.'
-task :default => :test
-
-desc 'Run tests.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.pattern = File.join('test', ENV['subset'] || '', ENV['pattern'] || '**/*_test.rb')
-  t.verbose = true
-end
-
-#
-# admin tasks
-#
-
-def gemspec
-  data = File.read("molecules.gemspec")
-  spec = nil
-  Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
-  spec
-end
-
-Rake::GemPackageTask.new(gemspec) do |pkg|
-  pkg.need_tar = true
-end
-
-task :print_manifest do
-  # collect files from the gemspec, labeling 
-  # with true or false corresponding to the
-  # file existing or not
-  files = gemspec.files.inject({}) do |files, file|
-    files[File.expand_path(file)] = [File.exists?(file), file]
-    files
-  end
-  
-  # gather non-rdoc/pkg files for the project
-  # and add to the files list if they are not
-  # included already (marking by the absence
-  # of a label)
-  Dir.glob("**/*").each do |file|
-    next if file =~ /^(rdoc|pkg)/ || File.directory?(file)
-    
-    path = File.expand_path(file)
-    files[path] = ["", file] unless files.has_key?(path)
-  end
-  
-  # sort and output the results
-  files.values.sort_by {|exists, file| file }.each do |entry| 
-    puts "%-5s : %s" % entry
-  end
-end
-
-desc 'Generate documentation.'
-Rake::RDocTask.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = "molecules"
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include(["README", 'MIT-LICENSE'])
-  rdoc.rdoc_files.include(gemspec.files.select {|file| file =~ /^lib/})
-end
-
-desc "Publish RDoc to RubyForge"
-task :publish_rdoc => [:rdoc] do
-  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
-  host = "#{config["username"]}@rubyforge.org"
-  
-  rsync_args = "-v -c -r"
-  remote_dir = "/var/www/gforge-projects/bioactive/molecules"
-  local_dir = "rdoc"
- 
-  sh %{rsync #{rsync_args} #{local_dir}/ #{host}:#{remote_dir}}
-end

data/test/molecules/calc_test.rb

@@ -1,37 +0,0 @@
-require File.join(File.dirname(__FILE__), '../tap_test_helper.rb') 
-require 'molecules/calc'
-
-class Molecules::CalcTest < Test::Unit::TestCase
-  acts_as_tap_test 
-  
-  attr_reader :t
-  
-  def setup
-    super
-    @t = Molecules::Calc.new
-  end
-  
-  def test_mass_calculation
-    t.enq("H2O")
-    app.run
-      
-    assert_equal [[Unit.new(18.0105646863, "Da")]], app.results(t)
-  end
-  
-  def test_mass_calculation_with_precision
-    t.precision = 2
-    t.enq("H2O", "NH3 + H2O")
-    app.run
-      
-    assert_equal [[Unit.new(18.01, "Da"), Unit.new(35.04, "Da")]], app.results(t)
-  end
-  
-  def test_mass_calculation_with_precision_and_unit_conversion
-    t.units = "yg"
-    t.precision = 3
-    t.enq("H2O")
-    app.run
-      
-    assert_equal [[Unit.new(29.907, "yg")]], app.results(t)
-  end
-end

data/test/molecules/empirical_formula_class_test.rb

@@ -1,196 +0,0 @@
-require File.join(File.dirname(__FILE__), '../molecules_test_helper.rb') 
-require 'molecules/empirical_formula'
-
-class EmpiricalFormulaClassTest < Test::Unit::TestCase
-  include Molecules
-  
-  #
-  # parse_simple test
-  #
-  
-  def test_parse_simple_documentation
-    assert_equal "H(2)O", EmpiricalFormula.parse_simple("H(2)O").to_s
-    assert_equal "H(2)O", EmpiricalFormula.parse_simple("H (2) O").to_s
-    assert_equal "H(2)O", EmpiricalFormula.parse_simple("HO(-1)O(2)H").to_s
-  end
-  
-  def test_parse_simple
-    assert_equal([2,1], EmpiricalFormula.parse_simple("HO(-1)O(2)H").formula)
-    assert_equal([2,1], EmpiricalFormula.parse_simple("H O (-1  )O( 2) H ").formula)
-  end
-  
-  def test_parse_simple_fails_for_malformed_formulae
-    [
-      # numbers outside parenthesis
-      "H2", 
-      # empty parenthesis
-      "H()",
-      # mismatched parenthesis
-      "H(",
-      ")H",
-      # anything complex
-      "H + O"
-    ].each do |formula|
-      assert_raise(EmpiricalFormula::ParseError) { EmpiricalFormula.parse_simple(formula) }
-    end
-  end
-  
-  #
-  # test class parse
-  #
-  
-  def test_parse_documentation
-    assert_equal "H(2)O", EmpiricalFormula.parse("H2O").to_s
-    assert_equal "C(52)H(106)", EmpiricalFormula.parse("CH3(CH2)50CH3").to_s 
-    assert_equal "C(2)H(4)N(2)", EmpiricalFormula.parse("C2H3NO - H2O + NH3").to_s 
-    
-    block = lambda do |formula|
-      case formula
-      when /\[(.*)\]/
-        factors = $1.split(/,/).collect {|i| i.strip.to_i }
-        EmpiricalFormula.new(factors)
-      else nil
-      end
-    end
-    
-    assert_equal  "H(4)O(2)", EmpiricalFormula.parse("H2O + [2, 1]", &block).to_s
-    assert_raise(EmpiricalFormula::ParseError) { EmpiricalFormula.parse("H2O + :not_expected", &block) }
-  end
-  
-  def test_parse
-    {
-      nil => "",
-      "" => "",
-      "H" => "H", 
-      "HO" => "HO", 
-      "HFe" => "FeH", 
-      "FeH" => "FeH", 
-      "OH2" => "H(2)O",
-      "H2O" => "H(2)O", 
-      "C6H12O4" => "C(6)H(12)O(4)", 
-      "Fe2OMg3" => "Fe(2)Mg(3)O", 
-      "(H)2" => "H(2)", 
-      "(OH)2" => "H(2)O(2)", 
-      "(HFe)" => "FeH", 
-      "(FeH)" => "FeH", 
-      "(OH2)2" => "H(4)O(2)", 
-      "(H2O)2" => "H(4)O(2)", 
-      "(C6H12O4)2" => "C(12)H(24)O(8)",
-      "(Fe2OMg3)2" => "Fe(4)Mg(6)O(2)",
-      "C6H12O4(C6H12O4)2C6H12O4" => "C(24)H(48)O(16)", 
-      "Fe2OMg3(Fe2OMg3(Fe2OMg3))Fe2OMg3" => "Fe(8)Mg(12)O(4)",
-      "Fe2OMg3(Fe2OMg3)(Fe2OMg3)Fe2OMg3" => "Fe(8)Mg(12)O(4)",
-      "Fe2OMg3(Fe2OMg3(Fe2OMg3)3((C)6H12O4)2)2C" => "C(25)Fe(18)H(48)Mg(27)O(25)",
-      "  (H2O) 10 0   " => "H(200)O(100)",
-      "CH3(CH2)7CH" => "C(9)H(18)", 
-      "H3NCHCO2" => "C(2)H(4)NO(2)", 
-      "(CH3)2CuLi" => "C(2)CuH(6)Li",
-      
-      # multipart
-      "-H" => "H(-1)",
-      "H2O-H" => "HO",
-      "H2O - (OH)2+ H2O2-H2O" => ""
-    }.each_pair do |formula, composition_str|
-      m = EmpiricalFormula.parse(formula)
-      assert_equal composition_str, m.to_s, formula
-    end
-  end
-  
-  def test_parse_fails_for_malformed_formulae
-    [
-      # mismatched parenthesis
-      "H)2",
-      "(H2", 
-      "(O2(H2)",
-      "(O)2H2)", 
-      # hanging factors
-      "2C", 
-      #"(2)",
-      "(2)2", 
-      "(2C)", 
-      "(2C)2",
-      "C(2C)",
-      # empty parenthesis
-      "()",
-      "()2"
-    ].each do |formula|
-      assert_raise(EmpiricalFormula::ParseError) { EmpiricalFormula.parse(formula) }
-    end
-  end
-  
-  #
-  # class mass test
-  #
-  
-  def break_test_class_mass_method
-    water_mass = EmpiricalFormula::Element::H.mass * 2 + EmpiricalFormula::Element::O.mass
-    assert_equal 18.010565, water_mass
-    
-    assert_equal 18.010565, EmpiricalFormula.mass("H2O")
-    assert_equal 18.010565, EmpiricalFormula.mass("H + OH")
-    assert_equal 18, EmpiricalFormula.mass("H2O", 0)
-  end
-  
-  #
-  # library molecules
-  #
-  
-  def break_test_access_library_molecules
-    water = EmpiricalFormula::H2O
-    
-    assert_equal water, EmpiricalFormula.lookup('h2o')
-    assert_equal water, EmpiricalFormula.h2o
-    assert_equal 18.010565, EmpiricalFormula.h2o.mass
-  end
-
-  # vs the VG Analytical Organic Mass Spectrometry reference, reference date unknown (prior to 2005)
-  # the data from the data sheet was copied manually to doc/VG Analytical DataSheet.txt
-  def test_molecule_mass_values_vs_vg_analytical
-    str = %Q{
-NH2 16.01872 16.0226
-OH 17.00274 17.0073
-OCH3 31.01839 31.0342
-CH3CO 43.01839 43.0452}
-
-    molecules = str.split(/\n/)
-    molecules.each do |mol_str|
-      next if mol_str.empty?
-      
-      name, monoisotopic, average = mol_str.split(/\s/)
-      monoisotopic = monoisotopic.to_f
-      average = average.to_f
-      
-      molecule = EmpiricalFormula.parse(name)
-      assert_in_delta monoisotopic, molecule.mass, delta_mass, mol_str 
-      # TODO -- check average mass
-    end    
-  end
-
-  #
-  # benchmark
-  #
-   
-  def test_parse_speed
-    benchmark_test(20) do |x|
-      n = 10
-       
-      ["H20","H2(H2(H2))H2"].each do |formula|
-        x.report("#{n}k #{formula}") do 
-          (n*1000).times { EmpiricalFormula.parse(formula) }
-        end
-      end
-    end
-  end
-   
-  def test_parse_simple_speed
-    benchmark_test(20) do |x|
-      n = 10
-       
-      ["H(20)","H(2)H(2)H(2)H(2)"].each do |formula|
-        x.report("#{n}k #{formula}") do 
-          (n*1000).times { EmpiricalFormula.parse_simple(formula) }
-        end
-      end
-    end
-  end
-end