msplinter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 549e4f5c83a9065e97cc542ee98a6c69c54d0443
+  data.tar.gz: a93e6a4567344e57b8a6d3bdfc86bb766200118d
+SHA512:
+  metadata.gz: 4b705b21e3db91c1f5b9862b4b02a01d09140b1b827244c98cf86e89bd1ce6558a169c6a8b3f702b553aa2f7d4094ffa81952cef83c138cb519183bc4e431dc9
+  data.tar.gz: 38695117916f6328b555d78338d114a8994ae859b0bbb604fba059ed08eb9498f8eadddc530a220ea6e6a56d3cca905f60ff9389737c518dc1fe09f16e2b1754

data/.gitignore

@@ -0,0 +1,2 @@
+coverage
+.coveralls.yml

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in msplinter.gemspec
+gemspec
+
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2013 Brigham Young University
+Authored by: 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,41 @@
+# msplinter
+
+[![Gem Version][GV img]][Gem Version]
+[![Dependency Status][DS img]][Dependency Status]
+[![Code Climate][CC img]][Code Climate]
+[![Coverage Status][CS img]][Coverage Status]
+
+Predicts how molecules will fragment in a mass spectrometer.  Currently
+focused on lipid fragmentation under CID, HCD or PQD.
+
+## Installation
+
+msplinter is built on rubabel, which is built on openbabel.  To get the
+necessary openbabel dependencies on ubuntu/debian:
+
+    sudo apt-get install openbabel libopenbabel-dev cmake make curl
+
+Then
+
+    gem install msplinter
+
+See [the "Installing" section](https://github.com/princelab/rubabel) for
+complete instructions for installing rubabel and openbabel.
+
+## Commandline Usage
+
+Type 'msplinter' with no arguments to see a help message.
+
+## Copyright
+
+MIT license.  See LICENSE.txt for further details.
+
+[Gem Version]: https://rubygems.org/gems/msplinter
+[Dependency Status]: https://gemnasium.com/princelab/msplinter
+[Code Climate]: https://codeclimate.com/github/princelab/msplinter
+[Coverage Status]: https://coveralls.io/r/princelab/msplinter
+
+[GV img]: https://badge.fury.io/rb/msplinter.png
+[DS img]: https://gemnasium.com/princelab/msplinter.png
+[CC img]: https://codeclimate.com/github/princelab/msplinter.png
+[CS img]: https://coveralls.io/repos/princelab/msplinter/badge.png?branch=master

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler/gem_tasks"
+
+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 = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubabel #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/bin/msplinter

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require 'rubabel'
+require 'rubabel/molecule/fragmentable'
+
+default_ph = 2.5
+
+Fragment = Struct.new(:frag, :id, :title, :mz, :mass, :charge, :smiles, :pairing)
+
+progname = File.basename(__FILE__)
+
+parser = Trollop::Parser.new do
+  banner "usage: #{progname} [OPTIONS|RULES] <SMARTS> ..."
+  text "\noptions:"
+  opt :ph, "the pH to use (experimental option)", :default => default_ph
+  opt :images, "print out svg images of fragments" 
+  opt :format, "format of the molecules", :default => 'smiles'
+  #opt :uniq, "no repeated fragments", :default => false
+  text "\nrules:"
+  Rubabel::Molecule::Fragmentable::RULES.each do |rule|
+    opt rule, rule.to_s.gsub("_",' ')
+  end
+  text "\nexample:"
+  text "    #{progname} -xeh 'CCC(=O)OCCC' 'CCC(=O)OCCC(=O)O'"
+end
+
+options = parser.parse(ARGV)
+opts = {rules: []}
+opts[:uniq] = options.delete(:uniq)
+ph = options.delete(:ph)
+opts[:rules] = Rubabel::Molecule::Fragmentable::RULES.map do |rule|
+  rule if options["#{rule}_given".to_sym]
+end.compact
+
+if ARGV.size == 0
+  parser.educate && exit
+end
+
+ARGV.each do |smiles|
+  mol = Rubabel[smiles, options[:format].to_sym]
+  puts "\nmolecule: #{mol.csmiles}"
+  mol.correct_for_ph!(ph)
+  puts "at ph #{ph}: #{mol.csmiles}"
+  fragment_sets = mol.fragment(opts)
+  puts %w(mz mass charge title smiles pairing).join("\t")
+  frags = []
+  fragment_sets.each_with_index do |frag_set,i|
+    frag_set.each_with_index do |frag,j|
+      unless frag.charge == 0
+        mz = (frag.mass / frag.charge).round(5)
+      end
+
+      frag.title = "#{i}-#{j}pair_" + (mz ? "#{mz}_mz" : "#{frag.mass.round(3)}_Mass")
+      frag_obj = Fragment.new(frag, frag.title, frag.title, mz, frag.exact_mass, frag.charge, frag.csmiles, i)
+      frags << frag_obj
+    end
+  end
+  frags = frags.sort_by {|frag| [-frag.charge, frag.mz] }
+  if options[:images]
+    frags.each do |frag|
+      fn = "#{frag.title}.svg"
+      frag.frag.write(fn)
+    end
+  end
+  frags.each do |frag|
+    puts [:mz, :mass, :charge, :title, :smiles, :pairing].map {|cat| frag.send(cat) }.join("\t")
+  end
+end

data/lib/msplinter/commandline.rb

@@ -0,0 +1 @@
+

data/lib/msplinter/version.rb

@@ -0,0 +1,3 @@
+module Msplinter
+  VERSION = "0.0.1"
+end

data/lib/msplinter.rb

@@ -0,0 +1,4 @@
+require "msplinter/version"
+
+module Msplinter
+end

data/lib/rubabel/molecule/fragmentable.rb

@@ -0,0 +1,160 @@
+require 'set'
+
+module Rubabel
+  class Molecule
+    module Fragmentable
+
+      #RULES = Set[:cod, :codoo, :oxe, :oxepd, :oxh]
+      RULES = Set[:cod, :codoo, :oxe, :oxepd, :oxh, :oxhpd]
+
+      DEFAULT_OPTIONS = {
+        rules: RULES,
+        errors: :remove,
+        # return only the set of unique fragments
+        uniq: false, 
+      }
+
+      # molecules and fragments should all have hydrogens added (add_h!)
+      # before calling this method
+      # 
+      # For instance, water loss with double bond formation is not allowable
+      # for NCC(O)CC => CCC=C[NH2+], presumably because of the lone pair and
+      # double bond resonance.
+      def allowable_fragmentation?(frags)
+        self.num_atoms(true) == frags.reduce(0) {|cnt,fr| cnt + fr.num_atoms(true) }
+      end
+
+      # splits the molecule between the carbon and carbon_nbr, adds a double
+      # bond between the carbon and oxygen, and moves whatever was on the
+      # oxygen (e.g., an OH or a charge) to the carbon_nbr. Returns two new
+      # molecules.
+      def carbonyl_oxygen_dump(carbon, oxygen, carbon_nbr)
+        appendage = oxygen.atoms.find {|a| a.el != :C }
+        if oxygen.charge != 0
+          ocharge = oxygen.charge
+        end
+        nmol = self.dup
+        new_oxygen = nmol.atom(oxygen.id)
+        new_carbon = nmol.atom(carbon.id)
+        new_carbon_nbr = nmol.atom(carbon_nbr.id)
+        new_appendage = nmol.atom(appendage.id) if appendage
+        nmol.delete_bond(new_carbon.get_bond(new_carbon_nbr))
+        if new_appendage
+          nmol.delete_bond(new_oxygen.get_bond(new_appendage)) 
+          nmol.add_bond!(new_carbon_nbr, new_appendage)
+        end
+        if ocharge
+          new_carbon_nbr.charge += ocharge
+          new_oxygen.charge -= ocharge
+        end
+        new_carbon.get_bond(new_oxygen).bond_order = 2
+        nmol.split
+      end
+
+      # breaks the bond and gives the electrons to the oxygen
+      def carbon_oxygen_esteal(carbon, oxygen)
+        nmol = self.dup
+        ncarbon = nmol.atom(carbon.id)
+        noxygen = nmol.atom(oxygen.id)
+
+        is_carboxyl = noxygen.carboxyl_oxygen?
+        
+        nmol.delete_bond(ncarbon, noxygen)
+        ncarbon.remove_a_hydride!
+        noxygen.remove_a_proton! 
+        nmol.split
+      end
+
+      # returns the duplicated molecule and the equivalent atoms
+      def dup_molecule(atoms=[])
+        nmol = self.dup
+        [nmol, atoms.map {|old_atom| nmol.atom(old_atom.id) }]
+      end
+
+      # returns molecules created from splitting between the electrophile and
+      # the center and where the bond order is increased between the center
+      # and center_nbr
+      def break_with_double_bond(electrophile, center, center_nbr)
+        (nmol, (nele, ncarb, ncarb_nbr)) = self.dup_molecule([electrophile, center, center_nbr])
+        nmol.delete_bond(nele, ncarb)
+        ncarb_nbr.get_bond(ncarb) + 1
+        nmol.split
+      end
+
+      # an empty array is returned if there are no fragments generated.
+      # Hydrogens are added at a pH of 7.4, unless they have already been
+      # added.
+      #
+      #     :rules => queryable by :include? set of rules
+      #     :uniq => false
+      #     :errors => :remove | :fix | :ignore  (default is :remove)
+      def fragment(opts={})
+        only_uniqs = true
+        opts = DEFAULT_OPTIONS.merge(opts)
+        opts[:rules].each do |rule| 
+          raise ArgumentError, "bad rule: #{rule}" unless RULES.include?(rule)
+        end
+
+        had_hydrogens = self.h_added?
+        self.correct_for_ph!(7.4) unless had_hydrogens
+        self.remove_h!
+
+        fragment_sets = []
+
+        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|
+              fragment_sets << carbonyl_oxygen_dump(carbon, oxygen, carbon_nbr)
+            end
+          end
+        end
+        if opts[:rules].any? {|r| [:oxe].include?(r) }
+          self.each_match("C-O", only_uniqs) do |carbon, oxygen|
+            fragment_sets << carbon_oxygen_esteal(carbon, oxygen)
+          end
+        end
+        # right now implemented so that a beta hydrogen has to be availabe for
+        # extraction
+        if opts[:rules].any? {|r| [:oxh].include?(r) }
+          self.each_match("C[C,O]-O", only_uniqs) do |beta_c, center, oxygen|
+            next unless beta_c.hydrogen_count > 0
+            fragment_sets << break_with_double_bond(oxygen, center, beta_c)
+          end
+        end
+        if opts[:rules].any? {|r| [:oxhpd].include?(r) }
+          self.each_match("C-O-P-O", only_uniqs) do |carbon, alc_oxy, phosphate, beta_carb_oxy|
+            next unless beta_carb_oxy.hydrogen_count > 0
+            frag_set = break_with_double_bond(alc_oxy, phosphate, beta_carb_oxy)
+            frag_set.map! &:convert_dative_bonds!
+            fragment_sets << frag_set
+          end
+        end
+        if opts[:rules].any? {|r| [:oxepd].include?(r) }
+          self.each_match("P-O-C", only_uniqs) do |phosphate, oxygen, carbon|
+            frag_set = carbon_oxygen_esteal(phosphate, oxygen)
+            frag_set.map! &:convert_dative_bonds!
+            fragment_sets << frag_set
+          end
+        end
+
+        case opts[:errors]
+        when :remove
+          fragment_sets.select! {|set| allowable_fragmentation?(set) }
+        when :fix
+          raise NotImplementedError
+        when :ignore  # do nothing
+        end
+
+        self.remove_h!
+        if opts[:uniq]
+          # TODO: impelent properly
+          raise NotImplementedError
+          #fragment_sets = fragment_sets.uniq_by(&:csmiles)
+        end
+
+        fragment_sets
+      end
+    end
+    include Fragmentable
+  end
+end # Rubabel

data/msplinter.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'msplinter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "msplinter"
+  spec.version       = Msplinter::VERSION
+  spec.authors       = ["John T. Prince"]
+  spec.email         = ["jtprince@gmail.com"]
+  spec.description   = %q{Predicts how molecules will fragment in a mass spectrometer.  Currently focused on lipid fragmentation under CID, HCD or PQD.}
+  spec.summary       = %q{Predicts how molecules will fragment in a mass spectrometer}
+  spec.homepage      = "https://github.com/princelab/msplinter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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"]
+
+  [
+    ["rubabel", "~> 0.4.1"],
+  ].each do |args|
+    spec.add_dependency(*args)
+  end
+  [
+    ["bundler", "~> 1.3"],
+    ["rake"],
+    ["rspec", "~> 2.13.0"], 
+    ["rdoc", "~> 3.12"], 
+    ["simplecov"],
+  ].each do |args|
+    spec.add_development_dependency(*args)
+  end
+
+end

data/spec/rubabel/molecule/fragmentable_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+require 'rubabel'
+require 'rubabel/molecule/fragmentable'
+
+$VERBOSE = nil
+
+describe Rubabel::Molecule::Fragmentable do
+
+  # :peroxy_to_carboxy
+  # :oxygen_asymmetric_sp3, :nitrogen_asymmetric_sp3,
+  # :internal_phosphoester
+
+  describe 'fragmentation rules' do
+    # coenzyme: CC1=CC(=O)C=CC1=O
+    # 2-methylcyclohexa-2,5-diene-1,4-dione
+
+    #let(:test_mol) { "COP(=O)(O)OCNCOCC(OO)C(=O)O" }
+
+    it 'raises an error for a bad rule' do
+      mol = Rubabel["CCNC"]
+      expect { mol.fragment(rules: [:wackiness]) }.to raise_error
+    end
+
+    describe 'cod: carbonyl appendage dump' do
+      # a primary oxygen or peroxide => C=O appendage dump
+      
+      specify 'cod: primary alcohol' do
+        mol = Rubabel["NCC(O)CC"]
+        frags = mol.fragment(rules: [:cod])
+        frags.flatten(1).map(&:csmiles).should == ["C[NH3+]", "CCC=O", "C([NH3+])C=O", "CC"]
+      end
+
+      specify 'peroxide' do
+        mol = Rubabel["NCC(OO)CC"]
+        frags = mol.fragment(rules: [:codoo])
+        frags.flatten(1).map(&:csmiles).should == ["OC[NH3+]", "CCC=O", "C([NH3+])C=O", "CCO"]
+      end
+
+      specify 'cod: carboxylate' do
+        mol = Rubabel["CCC(=O)O"]
+        pieces = mol.fragment(rules: [:cod])
+        pieces.flatten(1).map(&:csmiles).should == ["[CH2-]C", "O=C=O"]
+      end
+
+      specify 'cod: carboxylic acid' do
+        mol = Rubabel["CCC(=O)O"]
+        mol.add_h!(1.5)
+        pieces = mol.fragment(rules: [:cod])
+        pieces.flatten(1).map(&:csmiles).should == ["CC", "O=C=O"]
+      end
+    end
+
+    describe 'oxe: oxygen electron stealing' do
+      # oxygen just steals the electron pair it is attached to.  This
+      # typically results in a negatively charged oxygen and a positively
+      # charged carbo-cation.
+      specify 'ether to ions' do
+        mol = Rubabel["CCOCCN"]
+        frag_set = mol.fragment(rules: [:oxe])
+        frags = frag_set.first
+        frags.first.csmiles.should == "C[CH2+]"
+        frags.last.csmiles.should == '[O-]CC[NH3+]'
+        frags.first.formula.should == 'C2H5+'
+        frags.last.formula.should == 'C2H7NO'
+        frags.first.exact_mass.should be_within(1e-6).of(29.03912516)
+        frags.last.exact_mass.should be_within(1e-6).of(61.052763849)
+      end
+
+      specify 'ester to ions' do
+        mol = Rubabel["CCOC(=O)CCN"]
+        frag_set = mol.fragment(rules: [:oxe])
+        ff = frag_set.first
+        ff.first.csmiles.should == 'C[CH2+]'
+        ff.last.csmiles.should == '[O-]C(=O)CC[NH3+]'
+        ff.first.formula.should == "C2H5+"
+
+        ff.last.formula.should == "C3H7NO2"
+        ff.first.exact_mass.should be_within(1e-6).of(29.03912516035)
+        ff.last.exact_mass.should be_within(1e-6).of(89.04767846841)
+      end
+
+      specify 'carboxyl group' do
+        mol = Rubabel["CCC(=O)O"]
+        frag_set = mol.fragment(rules: [:oxe])
+        ff = frag_set.first
+        ff.first.csmiles.should == 'CC[C+]=O'
+        # this is a carboxylate oxygen that falls off
+        ff.last.csmiles.should == '[O-2]'
+        #ff.first.formula.should == "C3H5O"
+        ff.first.formula.should == "C3H5O+"
+        ff.first.exact_mass.should be_within(1e-6).of(57.034039779909996)
+        #ff.last.formula.should == "O"
+        ff.last.formula.should == "O--"
+      end
+
+      specify 'phosphodiester' do
+        mol = Rubabel["CC(COP(=O)([O-])OCCN"]
+        frag_set = mol.fragment(rules: [:oxepd])
+        ff = frag_set.first
+        ff.first.csmiles.should == '[O-]CCC' 
+        #ff.last.csmiles.should == '[NH3+]CCO[P](=O)=O'
+        ff.last.csmiles.should == "[NH3+]CCOP(=O)=O"
+        #ff.first.formula.should == 'C3H7O'
+        ff.first.formula.should == 'C3H7O-'
+        ff.first.exact_mass.should be_within(1e-6).of(59.049689844)
+        #ff.last.formula.should == 'C2H7NO3P'
+        ff.last.formula.should == 'C2H7NO3P+'
+        ff.last.exact_mass.should be_within(1e-6).of(124.016354719)
+
+        mol = Rubabel["CCCOP(=O)(OCC[N+](C)(C)C)[O-]"]
+        frag_set = mol.fragment(rules: [:oxepd, :oxe])
+        # some of these don't like right on first inspection, but that is
+        # because we 'converted dative bonds' meaning + and - next to each
+        # other are allowed to cancel one another out!
+        frag_set.size.should == 4
+        mols = frag_set.flatten
+        mols.map(&:csmiles).should == ["CC[CH2+]", "[O-]P(=O)(OCC[N+](C)(C)C)[O-]", "CCCOP(=O)([O-])[O-]", "[CH2+]C[N+](C)(C)C", "[O-]CCC", "O=P(=O)OCC[N+](C)(C)C", "CCCOP(=O)=O", "[O-]CC[N+](C)(C)C"]
+        mols.map(&:formula).should == ["C3H7+", "C5H13NO4P-", "C3H7O4P--", "C5H13N++", "C3H7O-", "C5H13NO3P+", "C3H7O3P", "C5H13NO"]
+        mols.map(&:exact_mass).zip([43.05477522449, 182.05821952995, 138.00819533273, 87.10479942171, 59.04968984405, 166.06330491039, 122.01328071317, 103.09971404127]) do |act, exp|
+          act.should be_within(1e-6).of(exp)
+        end
+
+      end
+    end
+
+    # this is really a subset of oxygen bond stealing: if the negatively
+    # charged oxygen can rip off a nearby proton, it will.
+    describe 'oxh: oxygen alpha/beta/gamma hydrogen stealing' do
+      specify 'primary alcohol giving water loss' do
+        mol = Rubabel["CC(O)CCN"]
+        frags = mol.fragment(rules: [:oxh])
+        ff = frags.first
+        ff.first.csmiles.should == 'C=CCC[NH3+]'
+        ff.last.csmiles.should == 'O'
+        ll = frags.last
+        ll.first.csmiles.should == 'CC=CC[NH3+]'
+        ll.last.csmiles.should == 'O'
+        #ff.first.formula.should == 'C4H10N'
+        ff.first.formula.should == 'C4H10N+'
+        ff.first.exact_mass.should be_within(1e-6).of(72.0813243255)
+      end
+
+      specify 'peroxide carbonyl formation (or peroxide formation [that what we want??])' do
+        # do we really see peroxide formation?  Tamil didn't include this in
+        # the rules but it follows from the broad way for creating these
+        # rules.  Can prohibit peroxide formation in future if necessary...
+        mol = Rubabel["CC(OO)CCN"]
+        frags = mol.fragment(rules: [:oxh])
+        mols = frags.flatten
+        mols.map(&:csmiles).should == ["C=CCC[NH3+]", "OO", "CC(=O)CC[NH3+]", "O", "CC=CC[NH3+]", "OO"]
+        mols.map(&:formula).should == ["C4H10N+", "H2O2", "C4H10NO+", "H2O", "C4H10N+", "H2O2"]
+        #mols.map(&:formula).should == ["C4H10N", "H2O2", "C4H10NO", "H2O", "C4H10N", "H2O2"]
+        mols.map(&:exact_mass).zip([72.081324325, 34.005479304, 88.076238945, 18.010564684, 72.081324325, 34.005479304]) do |act, exp|
+          act.should be_within(1e-6).of(exp)
+        end
+      end
+
+      specify 'ether to alcohol, ignoring errors' do
+        # this is a good example of a 'disallowed structure' where the
+        # formula's do not match up to the original formulas
+        mol = Rubabel["CCOCCN"]
+        frags = mol.fragment(rules: [:oxh], errors: :ignore)
+        mols = frags.flatten
+        mols.map(&:csmiles).should == ["C=C", "OCC[NH3+]", "CCO", "C=C[NH2+]"]
+      end
+
+      specify 'ether to alcohol, removing errors' do
+        mol = Rubabel["CCOCCN"]
+        frags = mol.fragment(rules: [:oxh])
+        mols = frags.flatten
+        mols.map(&:csmiles).should == ["C=C", "OCC[NH3+]"]
+      end
+
+      specify 'ester to alcohol' do
+        mol = Rubabel["CC(=O)OCCCN"]
+        frags = mol.fragment(rules: [:oxh])
+        mols = frags.flatten
+        mols.map(&:csmiles).should == ["C=C=O", "OCCC[NH3+]", "CC(=O)O", "C=CC[NH3+]"]
+        #mols.map(&:formula).should == ["C2H2O", "C3H10NO", "C2H4O2", "C3H8N"]
+        mols.map(&:formula).should == ["C2H2O", "C3H10NO+", "C2H4O2", "C3H8N+"]
+        mols.map(&:exact_mass).zip([42.010564684, 76.076238945, 60.021129368000004, 58.065674261]) do |act,exp|
+          act.should be_within(1e-6).of(exp)
+        end
+      end
+
+      specify 'phosphodiester (right now needs very low pH and NOT SURE WORKING PROPERLY)' do
+        mol = Rubabel["CC(COP(=O)(O)OCCCN"]
+        mol.add_h!(1.0)
+        frags = mol.fragment(rules: [:oxhpd])
+        frags = frags.flatten
+        frags.map(&:csmiles).should == ["CCCO", "[NH3+]CCCOP(=O)=O", "CCCOP(=O)=O", "OCCC[NH3+]"]
+      end
+    end
+
+  end
+end
+
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'rspec'
+require 'stringio'
+
+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 pending_color('*')
+  end
+end
+
+require 'rspec/core/formatters/documentation_formatter'
+class QuietPendingDocFormatter < RSpec::Core::Formatters::DocumentationFormatter
+  def example_pending(example)
+    output.puts pending_color( "<pending>: #{example.execution_result[:pending_message]}" )
+  end
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.formatter = QuietPendingDocFormatter
+  config.color = true
+end
+
+TESTFILES = File.dirname(__FILE__) + "/testfiles"

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: msplinter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John T. Prince
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubabel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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'
+description: Predicts how molecules will fragment in a mass spectrometer.  Currently
+  focused on lipid fragmentation under CID, HCD or PQD.
+email:
+- jtprince@gmail.com
+executables:
+- msplinter
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/msplinter
+- lib/msplinter.rb
+- lib/msplinter/commandline.rb
+- lib/msplinter/version.rb
+- lib/rubabel/molecule/fragmentable.rb
+- msplinter.gemspec
+- spec/rubabel/molecule/fragmentable_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/princelab/msplinter
+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.0.2
+signing_key: 
+specification_version: 4
+summary: Predicts how molecules will fragment in a mass spectrometer
+test_files:
+- spec/rubabel/molecule/fragmentable_spec.rb
+- spec/spec_helper.rb
+has_rdoc: