mspire-mass 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 031bab08ab5b939d6cf65abe8f610bc08206b2ee
+  data.tar.gz: f11cfb2f633ea73d2435bb8fcac67f94859b507a
+SHA512:
+  metadata.gz: 6635c2dc17e376012df5b938c65b1ea225bd222d1f287b8763e8aaa72df2069ced8daa835f6d686643f9481e0165fc6142dd96cfc951b94c22875686ee127ee2
+  data.tar.gz: b6220a5181ccca4604ad0f9b9c7e41ef773873d37b072b5bc5746b5f9c379ed2c05a55291cecf54d186baee41bb1f7c4e851f1ec77fc59f2d2985ca223c605ba

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mspire-mass.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2014 Brigham Young University
+author: John T. Prince
+
+MIT License
+
+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.md

@@ -0,0 +1,90 @@
+# Mspire::Mass
+
+mspire library holding constants for mass lookup.  Uses NIST masses (where applicable).  See [mspire-isotope](https://github.com/princelab/mspire-isotope) for complete isotope information (including masses).  See [mspire-molecular_formula](https://github.com/princelab/mspire-molecular_formula) for mass or m/z methods for larger molecular formulas.
+
+## Installation
+
+    gem install mspire-mass
+
+## Examples
+
+### MONO\_STRING and AVG\_STRING
+
+A simple hash may be accessed directly from the various modules:
+
+```ruby
+require 'mspire/mass'
+
+Mspire::Mass::Element::MONO_STRING['C']         # => 12.0
+Mspire::Mass::AA::MONO_STRING['C']              # => 103.0091844778 (residue)
+Mspire::Mass::Subatomic::MONO_STRING['NEUTRON'] # => 1.0086649156
+Mspire::Mass::Common::MONO_STRING['H2O']        # => 18.0105646837
+
+# similar for average masses
+Mspire::Mass::Element::AVG_STRING['C']          # => 12.0107
+
+# note that elements are accessed in mixed case by default
+Mspire::Mass::Element::MONO_STRING['Se']        # => 79.9165213
+```
+
+A hash where everything but the amino acids is downcased can also be accessed
+
+```ruby
+require 'mspire/mass/merged'  # <- must be required explicitly
+Mspire::Mass::Merged::MONO_STRING['C']   # (cysteine) => 103.0091844778
+Mspire::Mass::Merged::MONO_STRING['c']   # (carbon)   => 12.0
+Mspire::Mass::Merged::MONO_STRING['h2o'] # (water)    => 18.0105646837
+Mspire::Mass::Merged::MONO_STRING['e']   # (or 'electron') => 0.0005486 
+# Mspire::Mass::Merged::AVG_STRING also available
+```
+
+MONO\_STRING and AVG\_STRING are only for quick, low-level access.  They are
+purposefully ugly to encourage you to use the beautiful interface shown
+directly below!
+
+### <Module>.masses
+
+A mass hash can be created in a variety of forms depending on your
+needs/preferences. 
+
+    ---------------------------------
+          <default>
+    ---------------------------------
+    type = :mono   | :avg
+    by   = :symbol | :string | :both
+    case = :up     | :down   | :both
+
+**NOTE:** it defaults to symbols, not strings.
+
+```ruby
+el_masses = Mspire::Mass::Element.masses
+# which defaults to this
+el_masses = Mspire::Mass::Element.masses(type: :mono, by: :symbol, case: :up)
+el_masses[:C]  # (carbon) => 12.0
+
+aas = Mspire::Mass::AA.masses(type: :avg, by: :string)
+aas['C'] # (cysteine) => 103.1429
+
+subatomic = Mspire::Mass::Subatomic.masses
+subatomic[:PROTON]   # (same as subatomic[:'H+'] or subatomic[:H_PLUS]) # => 1.00727643207
+```
+
+A merged hash can be created in a similar way, but :up and :down aren't
+respected since it merges by upcasing amino acids and downcasing all else.
+
+```ruby
+merged = Mspire::Mass::Merged.masses(type: :mono)
+merged[:C] # (cysteine) => 103.0091844778
+merged[:c] # (carbon)   => 12.0
+```
+
+### Subatomic constants on Mspire::Mass
+
+The strings that play nice are defined as constants on Mspire::Mass so you can
+do this:
+
+```ruby
+Mspire::Mass::ELECTRON #=> 0.0005486
+Mspire::Mass::PROTON   #=> 1.00727643207
+Mspire::Mass::NEUTRON  #=> 1.0086649156
+```

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+
+@module_name = Mspire::Mass
+@gem_name = 'mspire-mass'
+@gem_path_name = @gem_name.gsub('-','/')
+
+require "#{@gem_path_name}/version"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = @module_name.const_get('VERSION')
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{@gem_name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/mspire/mass.rb

@@ -0,0 +1,39 @@
+require 'mspire/mass/version'
+require 'mspire/mass/element'
+require 'mspire/mass/subatomic'
+require 'mspire/mass/common'
+require 'mspire/mass/aa'
+
+module Mspire
+  # includes the Subatomic entities that are acceptable contants (e.g., H+
+  # won't work) as uppercase module constants (e.g.  Mspire::Mass::ELECTRON
+  # and Mspire::Mass::PROTON)
+  module Mass
+    Subatomic::MONO_STRING.each do |key, val|
+      unless key == 'H+'
+        self.const_set(key, val)
+      end
+    end
+
+    #class << self
+      ## takes a molecular formula as a string, hash or MolecularFormula object
+      ## and returns the exact mass.
+      #def formula_to_exact_mass(formula)
+        #Mspire::MolecularFormula.from_any(formula).mass
+      #end
+      #alias_method :formula, :formula_to_exact_mass
+
+      #def aa_to_exact_mass(aa_seq)
+        #chain_mass = aa_seq.each_char.inject(0.0) do |sum, aa_char|
+          #sum + AA[aa_char]
+        #end
+        #chain_mass + formula_to_exact_mass('H2O')
+      #end
+      #alias_method :aa, :aa_to_exact_mass
+
+    #end
+
+  end
+end
+
+

data/lib/mspire/mass/aa.rb

@@ -0,0 +1,70 @@
+require 'mspire/mass/mass_provider'
+
+module Mspire
+  module Mass
+    module AA
+      extend MassProvider
+
+      # amino_acids keys as strings, average masses
+      AVG_STRING = {
+        "*"=>118.88603,
+        "A"=>71.0779,
+        "B"=>172.1405,
+        "C"=>103.1429,
+        "D"=>115.0874,
+        "E"=>129.11398,
+        "F"=>147.17386,
+        "G"=>57.05132,
+        "H"=>137.13928,
+        "I"=>113.15764,
+        "K"=>128.17228,
+        "L"=>113.15764,
+        "M"=>131.19606,
+        "N"=>114.10264,
+        "O"=>211.28076,
+        "P"=>97.11518,
+        "Q"=>128.12922,
+        "R"=>156.18568,
+        "S"=>87.0773,
+        "T"=>101.10388,
+        "U"=>150.0379,
+        "V"=>99.13106,
+        "W"=>186.2099,
+        "X"=>118.88603,
+        "Y"=>163.17326,
+        "Z"=>128.6231
+      }
+
+      # amino_acids keys as strings, monoisotopic masses
+      MONO_STRING = {
+        "*"=>118.805716,
+        "A"=>71.0371137878,
+        "B"=>172.048405,
+        "C"=>103.0091844778,
+        "D"=>115.026943032,
+        "E"=>129.0425930962,
+        "F"=>147.0684139162,
+        "G"=>57.0214637236,
+        "H"=>137.0589118624,
+        "I"=>113.0840639804,
+        "K"=>128.0949630177,
+        "L"=>113.0840639804,
+        "M"=>131.0404846062,
+        "N"=>114.0429274472,
+        "O"=>211.1446528645,
+        "P"=>97.052763852,
+        "Q"=>128.0585775114,
+        "R"=>156.1011110281,
+        "S"=>87.0320284099,
+        "T"=>101.0476784741,
+        "U"=>150.9536355878,
+        "V"=>99.0684139162,
+        "W"=>186.0793129535,
+        "X"=>118.805716,
+        "Y"=>163.0633285383,
+        "Z"=>128.550585
+      }
+
+    end
+  end
+end

data/lib/mspire/mass/common.rb

@@ -0,0 +1,21 @@
+require 'mspire/mass/mass_provider'
+require 'mspire/mass/element'
+
+module Mspire
+  module Mass
+    module Common
+      extend MassProvider
+
+      MONO_STRING = {
+        'H2O' => %w(H H O).map {|el| Element::MONO_STRING[el] }.reduce(:+),
+        'OH' => %w(O H).map {|el| Element::MONO_STRING[el] }.reduce(:+),
+      }
+
+      AVG_STRING = {
+        'H2O' => %w(H H O).map {|el| Element::AVG_STRING[el] }.reduce(:+),
+        'OH' => %w(O H).map {|el| Element::AVG_STRING[el] }.reduce(:+),
+      }
+
+    end
+  end
+end

data/lib/mspire/mass/element.rb

@@ -0,0 +1,20 @@
+require 'mspire/isotope'
+require 'mspire/mass/mass_provider'
+
+module Mspire
+  module Mass
+    module Element
+      extend MassProvider
+
+      AVG_STRING = {}
+      MONO_STRING = {}
+      Mspire::Isotope::BY_ELEMENT.each do |el, isotopes|
+        AVG_STRING[el.to_s] = isotopes.first.average_mass
+        MONO_STRING[el.to_s] = isotopes.find(&:mono).atomic_mass
+      end
+
+      MONO_STRING['D'] = Mspire::Isotope::BY_ELEMENT[:H].find {|iso| iso.element == :H && iso.mass_number == 2 }.atomic_mass
+
+    end
+  end
+end

data/lib/mspire/mass/mass_provider.rb

@@ -0,0 +1,59 @@
+module Mspire
+  module Mass
+    module MassProvider
+      DEFAULTS = {
+        type: :mono,
+        by: :symbol,
+        case: :up,
+      }
+
+      def prepare_hash(hash, opts={})
+        opt = Mspire::Mass::MassProvider::DEFAULTS.merge(opts)
+        newhash = {}
+
+        (upcase, downcase, symbol, string) = 
+          ['case'.to_sym, :up, 'case'.to_sym, :down, :by, :symbol, :by, :string].each_slice(2).map do |opt_key, unique|
+          [:both, unique].include?(opt[opt_key])
+          end
+
+        hash.each do |k,v| 
+          keys = []
+          if upcase
+            keys << k.to_s  # <= assumes they start in proper up or mixed case
+          end
+          if downcase
+            keys << k.to_s.downcase
+          end
+          if symbol
+            final_keys = keys.map(&:to_sym)
+          end
+          if string
+            string_keys = keys.map(&:to_s)
+            final_keys ||= []
+            final_keys.push(*string_keys)
+          end
+          final_keys.each {|key| newhash[key] = v }
+        end
+        newhash
+      end
+
+      # options:
+      #
+      #          <default>
+      #     type: :mono   | :avg
+      #     case: :up     | :down   | :both
+      #     by:   :symbol | :string | :both
+      #
+      # By default will use the module's <type>_STRING constant but this can
+      # be overridden with the :hash option which accetps a hash with symbol
+      # or string keys in uppercase or mixed case form (the :up merely
+      # respects the given case, while :down actively downcases.  Accepts a
+      # hash with symbol or string keys.  The keys should be in uppercase or
+      # mixed case to begin with.        
+      def masses(opts={})
+        opt = DEFAULTS.merge(opts)
+        prepare_hash(opt[:hash] || self.const_get(opt[:type].to_s.upcase << "_STRING"), opt)
+      end
+    end
+  end
+end

data/lib/mspire/mass/merged.rb

@@ -0,0 +1,38 @@
+require 'mspire/mass/mass_provider'
+require 'mspire/mass/element'
+require 'mspire/mass/common'
+require 'mspire/mass/aa'
+require 'mspire/mass/subatomic'
+require 'mspire/mass'
+
+module Mspire
+  module Mass
+    # provides hashes with both Amino Acids (uppercase letters) and elements
+    # (lowercased) along with common abbreviations
+    module Merged
+      extend MassProvider
+
+      class << self
+        def downcase_keys(hash)
+          Hash[ hash.map {|key,val| [key.to_s.downcase, val] } ]
+        end
+
+        def masses(opts={})
+          # force upper case (which merely respects the case given)
+          super(opts.merge(case: :up))
+        end
+      end
+
+      MONO_STRING = downcase_keys( Element::MONO_STRING )
+        .merge( downcase_keys( Common::MONO_STRING ) )
+        .merge( AA::MONO_STRING )
+        .merge( downcase_keys( Subatomic::MONO_STRING ) )
+
+      AVG_STRING = downcase_keys( Element::AVG_STRING )
+        .merge( downcase_keys( Common::AVG_STRING ) )
+        .merge( AA::AVG_STRING )
+        .merge( downcase_keys( Subatomic::AVG_STRING ) )  
+
+    end
+  end
+end

data/lib/mspire/mass/subatomic.rb

@@ -0,0 +1,20 @@
+require 'mspire/mass/mass_provider'
+require 'mspire/mass/element'
+
+module Mspire
+  module Mass
+    module Subatomic
+      extend MassProvider
+
+      MONO_STRING = {
+        'ELECTRON' => 0.0005486,   # www.mikeblaber.org/oldwine/chm1045/notes/Atoms/.../Atoms03.htm
+        'NEUTRON' => 1.0086649156,
+      }
+      # 'h+' => 1.00727646677,
+      MONO_STRING['PROTON'] = MONO_STRING['H_PLUS'] = MONO_STRING['H+'] = Mspire::Mass::Element::MONO_STRING['H'] - MONO_STRING['ELECTRON']
+      MONO_STRING['E'] = MONO_STRING['ELECTRON']
+
+      AVG_STRING = MONO_STRING.dup
+    end
+  end
+end

data/lib/mspire/mass/version.rb

@@ -0,0 +1,5 @@
+module Mspire
+  module Mass
+    VERSION = "0.1.0"
+  end
+end

data/mspire-mass.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mspire/mass/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mspire-mass"
+  spec.version       = Mspire::Mass::VERSION
+  spec.authors       = ["John T. Prince"]
+  spec.email         = ["jtprince@gmail.com"]
+  spec.summary       = %q{mspire library for mass calculations.}
+  spec.description   = %q{mspire library for mass calculations.  Mainly holds constants for simple lookup.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  [
+    # should probably be its only dependency
+    ["mspire-isotope", "~> 0.1.0"],
+  ].each do |args|
+    spec.add_dependency(*args)
+  end
+
+  [
+    ["bundler", "~> 1.6.2"],
+    ["rake"],
+    ["rspec", "~> 2.14.1"], 
+    ["rdoc", "~> 4.1.1"], 
+    ["simplecov", "~> 0.8.2"],
+  ].each do |args|
+    spec.add_development_dependency(*args)
+  end
+
+end

data/spec/mspire/mass/aa_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+require 'mspire/mass/aa'
+
+describe Mspire::Mass::AA do
+  specify 'Mspire::Mass::AA::MONO_STRING provides direct access to amino acid masses (precalculated)' do
+    mono = Mspire::Mass::AA::MONO_STRING
+    mono['C'].should == 103.0091844778
+  end
+
+  specify 'Mspire::Mass::AA::AVG_STRING provides direct access to avg amino acid masses (precalculated)' do
+    avg = Mspire::Mass::AA::AVG_STRING
+    avg['C'].should == 103.1429
+  end
+
+  specify 'also gives access to: "*", "B", "O", "U", "X" (averagine), and "Z"' do
+    mono = Mspire::Mass::AA::MONO_STRING
+    avg = Mspire::Mass::AA::AVG_STRING
+    [mono, avg].each do |hash|
+      ["*", "B", "O", "U", "X", "Z"].each do |key|
+        hash.key?(key).should be_true
+      end
+    end
+  end
+
+  specify '#masses can return hash of mono|avg, symbols|strings|both, up|down|both' do
+    masses = Mspire::Mass::AA.masses
+    masses[:C].should == 103.0091844778
+
+    masses = Mspire::Mass::AA.masses(type: :mono)
+    masses[:C].should ==103.0091844778
+
+    masses = Mspire::Mass::AA.masses(by: :symbol)
+    masses[:C].should ==103.0091844778
+
+    masses = Mspire::Mass::AA.masses(by: :symbol, case: :down)
+    masses[:c].should ==103.0091844778
+
+    masses = Mspire::Mass::AA.masses(type: :avg, by: :string)
+    masses['C'].should == 103.1429 
+
+    masses = Mspire::Mass::AA.masses(type: :avg, by: :string, case: :down)
+    masses['c'].should == 103.1429 
+
+    masses = Mspire::Mass::AA.masses(type: :avg, by: :symbol, case: :down)
+    masses[:c].should == 103.1429 
+  end
+
+  specify 'can pass in own lookup hash' do
+    masses = Mspire::Mass::AA.masses(hash: {C: 66}, case: :down)
+    masses[:c].should == 66
+  end
+end

data/spec/mspire/mass/common_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+require 'mspire/mass/common'
+
+describe Mspire::Mass::Common do
+  specify 'Mspire::Mass::Common::MONO_STRING provides string direct access to a few common masses' do
+    masses = Mspire::Mass::Common::MONO_STRING
+    masses['OH'].should be_within(0.0000001).of( 17.002739651629998 )
+  end
+
+  specify 'Mspire::Mass::Common::AVG_STRING provides string direct access to a few common avg masses' do
+    avg = Mspire::Mass::Common::AVG_STRING
+    avg['OH'].should == 17.00734
+  end 
+  
+  specify 'gives mass of H2O and OH' do
+    masses = Mspire::Mass::Common.masses
+    masses[:H2O].should == 18.0105646837
+    masses[:OH].should == 17.002739651629998
+  end
+
+  specify '#masses can return hash of mono|avg, symbols|strings|both, up|down|both' do
+    masses = Mspire::Mass::Common.masses
+    masses[:H2O].should == 18.0105646837
+
+    masses = Mspire::Mass::Common.masses(type: :mono)
+    masses[:H2O].should == 18.0105646837
+
+    masses = Mspire::Mass::Common.masses(by: :symbol)
+    masses[:H2O].should == 18.0105646837
+
+    masses = Mspire::Mass::Common.masses(by: :symbol, case: :down)
+    masses[:h2o].should == 18.0105646837
+
+    masses = Mspire::Mass::Common.masses(type: :avg, by: :string)
+    masses['H2O'].should == 18.01528
+
+    masses = Mspire::Mass::Common.masses(type: :avg, by: :string, case: :down)
+    masses['h2o'].should == 18.01528
+
+    masses = Mspire::Mass::Common.masses(type: :avg, by: :symbol, case: :down)
+    masses[:h2o].should == 18.01528
+  end
+
+end

data/spec/mspire/mass/element_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+require 'mspire/mass/element'
+
+describe Mspire::Mass::Element do
+
+  specify 'Mspire::Mass::Element::MONO_STRING provides direct access to element masses' do
+    mono_str = Mspire::Mass::Element::MONO_STRING
+    mono_str['Se'].should == 79.9165213
+  end
+
+  specify 'Mspire::Mass::Element::AVG_STRING provides direct access to avg element masses' do
+    avg = Mspire::Mass::Element::AVG_STRING
+    avg['Se'].should == 78.96
+  end
+
+  specify '#masses can return hash of mono|avg, symbols|strings|both, up|down|both' do
+    masses = Mspire::Mass::Element.masses
+    masses[:Se].should == 79.9165213
+
+    masses = Mspire::Mass::Element.masses(type: :mono)
+    masses[:Se].should == 79.9165213
+
+    masses = Mspire::Mass::Element.masses(by: :symbol)
+    masses[:Se].should == 79.9165213
+
+    masses = Mspire::Mass::Element.masses(by: :symbol, case: :down)
+    masses[:se].should == 79.9165213
+
+    masses = Mspire::Mass::Element.masses(type: :avg, by: :string)
+    masses['Se'].should == 78.96
+
+    masses = Mspire::Mass::Element.masses(type: :avg, by: :string, case: :down)
+    masses['se'].should == 78.96
+
+    masses = Mspire::Mass::Element.masses(type: :avg, by: :symbol, case: :down)
+    masses[:se].should == 78.96
+  end
+
+  specify 'can pass in own lookup hash' do
+    masses = Mspire::Mass::Element.masses(hash: {Se: 77})
+    masses[:Se].should == 77
+  end
+
+end

data/spec/mspire/mass/mass_provider_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+require 'mspire/mass/mass_provider'
+
+module MockModule
+  extend Mspire::Mass::MassProvider
+end
+
+describe Mspire::Mass::MassProvider do
+  subject do
+    { :C => 3, :E => 5 }
+  end
+  it 'can prepare hashes' do
+    new_hash = MockModule.prepare_hash(subject) 
+    new_hash.should == {:C=>3, :E=>5}
+  end
+
+  it 'can prepare hashes with downcase keys' do
+    new_hash = MockModule.prepare_hash(subject, case: :down) 
+    new_hash.should == {:c=>3, :e=>5}
+  end
+
+  it 'can prepare hashes with upcase keys' do
+    new_hash = MockModule.prepare_hash(subject, case: :up) 
+    new_hash.should == {:C=>3, :E=>5}
+  end
+
+  it 'can prepare hashes with either case keys' do
+    new_hash = MockModule.prepare_hash(subject, case: :both) 
+    new_hash.sort.should == {:c=>3, :e=>5, :C=>3, :E=>5}.sort
+  end
+
+  it 'can prepare hashes with symbol keys' do
+    new_hash = MockModule.prepare_hash(subject, by: :symbol) 
+    new_hash.should == {:C=>3, :E=>5}
+  end
+
+  it 'can prepare hashes with symbol keys even if string keys were used' do
+    yikes = subject.map {|k,v| [k.to_s, v]}.to_h
+    yikes.should == {"C"=>3, "E"=>5}
+    new_hash = MockModule.prepare_hash(yikes, by: :symbol) 
+    new_hash.should == {:C=>3, :E=>5}
+  end
+
+  it 'can prepare hashes with string keys' do
+    new_hash = MockModule.prepare_hash(subject, by: :string) 
+    new_hash.should == {'C'=>3, 'E'=>5}
+  end
+
+  it 'can prepare hashes with both string and symbol keys' do
+    new_hash = MockModule.prepare_hash(subject, by: :both) 
+    # could fail if sort order is done differently
+    new_hash.should == {:C=>3, :E=>5, 'C'=>3, 'E'=>5}
+  end
+
+  it 'can prepare hashes with both string and symbol keys and upper and lower case' do
+    new_hash = MockModule.prepare_hash(subject, by: :both, case: :both) 
+    # could fail if sort order is done differently
+    new_hash.should == {:C=>3, :c=>3, "C"=>3, "c"=>3, :E=>5, :e=>5, "E"=>5, "e"=>5}
+  end
+end

data/spec/mspire/mass/merged_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'mspire/mass/merged'
+
+describe Mspire::Mass::Merged do
+  it 'accesses elements by lower case and amino acids by upper case' do
+    {
+      'c' => 12.0,  # carbon
+      'C' => 103.00918,  # cysteine
+      'br' => 78.9183361,  # bromine
+      'd' => 2.014101779,  # deuterium
+      'D' => 115.0269430,  # aspartic acid
+      'h+' => 1.00727646677, # proton
+      'h' => 1.007825035,  # hydrogen
+      'h2o' => 18.0105647, # water
+      'oh' => 17.002739665, # oh
+      'e' => 0.0005486, # electron
+    }.each do |el, mass|
+      Mspire::Mass::Merged::MONO_STRING[el].should_not be_nil
+      Mspire::Mass::Merged::MONO_STRING[el].should be_within(0.00001).of(mass) 
+    end
+
+    { 'h' => 1.00794, 'he' => 4.002602, 'ni' => 58.6934, 'H' => 137.13928 }.each do |el, mass|
+      Mspire::Mass::Merged::AVG_STRING[el].should_not be_nil
+      Mspire::Mass::Merged::AVG_STRING[el].should be_within(0.00001).of(mass) 
+    end
+  end
+
+  specify '#masses can return hash of mono|avg, symbols|strings|both' do
+    masses = Mspire::Mass::Merged.masses
+    masses[:D].should == 115.026943032
+    masses[:d].should == 2.0141017778
+
+    masses = Mspire::Mass::Merged.masses(type: :mono)
+    masses[:D].should == 115.026943032
+    masses[:d].should == 2.0141017778
+
+    masses = Mspire::Mass::Merged.masses(by: :symbol)
+    masses[:D].should == 115.026943032
+    masses[:d].should == 2.0141017778
+
+    masses = Mspire::Mass::Merged.masses(type: :avg, by: :string)
+    masses['D'].should == 115.0874
+    masses['d'].should be_nil  # there is no deuterium as an average mass!
+    masses['c'].should == 12.0107
+  end
+
+  specify ':case => :up and => :down are meaningless' do
+    masses = Mspire::Mass::Merged.masses(type: :avg, by: :string, case: :down)
+    #masses = Mspire::Mass::Merged.masses(type: :avg, by: :string)
+    masses['D'].should == 115.0874
+    masses['c'].should == 12.0107
+  end
+
+end

data/spec/mspire/mass/subatomic_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+require 'mspire/mass/subatomic'
+
+describe Mspire::Mass::Subatomic do
+
+  specify 'Mspire::Mass::Subatomic::MONO_STRING provides direct access to subatomic masses' do
+    masses = Mspire::Mass::Subatomic::MONO_STRING
+    masses['NEUTRON'].should == 1.0086649156
+  end
+
+  specify 'Mspire::Mass::Subatomic::AVG_STRING provides direct access to subatomic masses (same values as mono for subatomic)' do
+    masses = Mspire::Mass::Subatomic::AVG_STRING
+    masses['NEUTRON'].should == 1.0086649156
+  end
+
+  specify 'gives mass of :ELECTRON (and :E), :NEUTRON, :PROTON (:H+ and :H_PLUS)' do
+    masses = Mspire::Mass::Subatomic.masses
+    masses[:ELECTRON].should == 0.0005486
+    masses[:E].should == 0.0005486
+    masses[:NEUTRON].should == 1.0086649156
+    masses[:PROTON].should == 1.00727643207
+    masses['H+'.to_sym].should == 1.00727643207
+    masses[:H_PLUS].should == 1.00727643207
+  end
+
+  specify '#masses can return hash of mono|avg, symbols|strings|both, up|down|both' do
+    masses = Mspire::Mass::Subatomic.masses
+    masses[:ELECTRON].should == 0.0005486
+
+    masses = Mspire::Mass::Subatomic.masses(type: :mono)
+    masses[:ELECTRON].should == 0.0005486
+
+    masses = Mspire::Mass::Subatomic.masses(by: :symbol)
+    masses[:ELECTRON].should == 0.0005486
+
+    masses = Mspire::Mass::Subatomic.masses(by: :symbol, case: :down)
+    masses[:electron].should == 0.0005486
+
+    masses = Mspire::Mass::Subatomic.masses(type: :avg, by: :string)
+    masses['ELECTRON'].should == 0.0005486
+
+    masses = Mspire::Mass::Subatomic.masses(type: :avg, by: :string, case: :down)
+    masses['electron'].should == 0.0005486
+
+    masses = Mspire::Mass::Subatomic.masses(type: :avg, by: :symbol, case: :down)
+    masses[:electron].should == 0.0005486
+  end
+
+  specify 'can pass in own lookup hash' do
+    masses = Mspire::Mass::Subatomic.masses(hash: {ELECTRON: 8.77})
+    masses[:ELECTRON].should == 8.77
+  end
+
+end
+
+

data/spec/mspire/mass_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+require 'mspire/mass'
+
+describe Mspire::Mass do
+  specify 'require "mspire/mass" => requires Element, Subatomic, Common, and AA, but not "merged"' do
+    %w(Element Subatomic Common AA).each do |mod|
+      Mspire::Mass.const_get(mod).class.should == Module
+    end
+    expect { Mspire::Mass.const_get(Merged) }.to raise_error(NameError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rspec'
+
+TESTFILES = File.dirname(__FILE__) + '/testfiles'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.color_enabled = true
+  config.tty = true
+  config.formatter = :documentation  # :progress, :html, :textmate
+  #config.formatter = :progress # :progress, :html, :textmate
+end
+
+

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: mspire-mass
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John T. Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mspire-isotope
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.1.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+description: mspire library for mass calculations.  Mainly holds constants for simple
+  lookup.
+email:
+- jtprince@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mspire/mass.rb
+- lib/mspire/mass/aa.rb
+- lib/mspire/mass/common.rb
+- lib/mspire/mass/element.rb
+- lib/mspire/mass/mass_provider.rb
+- lib/mspire/mass/merged.rb
+- lib/mspire/mass/subatomic.rb
+- lib/mspire/mass/version.rb
+- mspire-mass.gemspec
+- spec/mspire/mass/aa_spec.rb
+- spec/mspire/mass/common_spec.rb
+- spec/mspire/mass/element_spec.rb
+- spec/mspire/mass/mass_provider_spec.rb
+- spec/mspire/mass/merged_spec.rb
+- spec/mspire/mass/subatomic_spec.rb
+- spec/mspire/mass_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: mspire library for mass calculations.
+test_files:
+- spec/mspire/mass/aa_spec.rb
+- spec/mspire/mass/common_spec.rb
+- spec/mspire/mass/element_spec.rb
+- spec/mspire/mass/mass_provider_spec.rb
+- spec/mspire/mass/merged_spec.rb
+- spec/mspire/mass/subatomic_spec.rb
+- spec/mspire/mass_spec.rb
+- spec/spec_helper.rb