mspire-obo 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45d44376c536159e5d906e57b3bc726517834f43
+  data.tar.gz: 2343cf00ab153e903f14a9ef8ddb804a1fc4e3a9
+SHA512:
+  metadata.gz: 1cbfd483cac33cc25ad8fc26aea40c2a097bc0d26605393102432545741cd6e3df38340d91b66e809eb156f30ca5218222c9584c01770cb821183f7d4cc29a03
+  data.tar.gz: cf8774fba09f176b66563759b9d62a17fecf20b77431eb3782ea2efa0b75034d667e11838f5317185ab04e18c8ec89b9bafb037df252a58b3b5ab7a34d0653fb

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-obo.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,103 @@
+## Mspire::Obo
+
+Tools for working with ontologies (specificially obo files) with built-in
+access to mass spectrometry related ontologies.
+
+### Installation
+
+    gem install mspire-obo
+
+### Examples
+
+```ruby
+require 'mspire/obo'
+```
+
+#### Discover which ontologies are available
+
+```ruby
+Mspire::Obo.available  # =>
+
+[{:full_name=>"protein modification ontology",
+  :uri=> "http://psidev.cvs.sourceforge.net/viewvc/psidev/psi/mod/data/PSI-MOD.obo",
+  :namespace=>"MOD",
+  :path=>"/home/jtprince/dev/mspire-obo/obo/PSI-MOD.obo",
+  :version=>"1.013.0",
+  :key=>:mod},
+ {:full_name=>"Imaging MS Ontology",
+ ...
+]
+
+```
+
+#### Use a particular ontology
+
+Keywords (downcased symbol of the namespace) are used to easily load an ontology.
+
+```ruby
+ontologies_by_key = Mspire::Obo.available(:key)  # => index the available obos by their key
+
+ms_obo = Mspire::Obo[:ms] # the Proteomics Standards Initiative Mass Spectrometry Ontology
+```
+
+#### Access ontology information
+
+Can create hashes on the fly.
+
+```ruby
+id_to_name_hash = ms_obo.make_id_to_name
+id_to_name_hash['MS:1000005'] # => 'sample volume'
+
+id_to_stanza_hash = ms_obo.make_id_to_stanza
+...
+```
+
+Can make and set hashes (bake them into the Obo object)
+
+```ruby
+ms_obo.id_to_name!
+ms_obo.id_to_name['MS:1000005'] # => 'sample volume'
+```
+
+If you want all access hashes baked in:
+
+```ruby
+ms_obo.make_all!
+```
+
+#### Cast values
+
+```ruby
+ms_obo.id_to_cast!
+ms_obo.cast('MS:1000004') # => :to_f
+ms_obo.cast('MS:1000004', '3.3') # => 3.3 (a Float)
+```
+
+#### Access ontology meta-information
+
+```ruby
+ms_obo.version
+ms_obo.full_name
+ms_obo.uri
+...
+```
+
+#### Multiple ontologies? - create merged lookup hashes 
+
+```ruby
+group = Mspire::Obo::Group.new [Mspire::Obo[:ms], Mspire::Obo[:uo]]
+a_hash = group.make_id_to_stanza # if you want the hash itself
+group.id_to_stanza!
+group.id_to_stanza["UO:0000012"] => an Obo::Stanza object
+group.id_to_stanza["IMS:1001207"] => an Obo::Stanza object
+```
+
+#### Use *any* obo file
+
+```ruby
+obo = Mspire::Obo.new("somefile.obo")
+```
+
+### License
+
+MIT.  See LICENSE.txt for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require "bundler/gem_tasks"
+require 'tempfile'
+require 'fileutils'
+
+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
+
+desc "downloads the latest obo to appropriate spot"
+task 'update' do
+  require 'mspire/obo'
+  require 'open-uri'
+  puts "Downloading the latest:"
+  Mspire::Obo.all(false).each do |obo|
+    begin
+      print "    #{File.basename(obo.uri)} ... "
+      tmpfile = Tempfile.new("test_temp")
+      tmpfile << open(obo.uri, &:read).gsub(/\r\n?/, "\n")
+      tmpfile.close
+      new_version = Mspire::Obo.version(tmpfile)
+      if obo.version != new_version
+        puts "!! ---> updating from #{obo.version} to #{new_version} (check into git) <--- !!"
+        FileUtils.mv(tmpfile.path, obo.path)  
+      else
+        puts "already latest."
+      end
+    ensure
+      if File.exist?(tmpfile.path)
+        tmpfile.close!
+      end
+    end
+  end
+end
+

data/lib/ext/obo.rb

@@ -0,0 +1,31 @@
+module Obo
+  class Stanza
+
+    # returns :to_f, :to_i, :to_s or false based on the xref value.
+    def cast_method
+      xref = @tagvalues['xref'].first
+      @cast_method = 
+        if xref.nil? || (@cast_method == false)
+          false
+        else
+          if @cast_method
+            @cast_method
+          else
+            case xref[/value-type:xsd\\:([^\s]+) /, 1]
+            when 'float'  ; :to_f
+            when 'int'    ; :to_i
+            when 'string' ; :to_s
+            else          ; false
+            end
+          end
+        end
+    end
+
+    # returns the value cast based on rules in first xref
+    # no casting performed if there is no xref
+    def cast(val)
+      methd = cast_method
+      methd ? val.send(methd) : val
+    end
+  end
+end

data/lib/mspire/obo/group.rb

@@ -0,0 +1,75 @@
+require 'mspire/obo'
+require 'mspire/obo/hash_provider'
+
+module Mspire
+  class Obo
+    # An Mspire::Obo::Group is a distinct collection of Mspire::Obo objects,
+    # but all lookup hashes are merged across the various ontologies.  This
+    # means that a user can make a group and query across all the ontologies
+    # in a single, simple call.  The interface mimics that of the hash
+    # providing Mspire::Obo object.
+    #
+    #     group = Mspire::Obo::Group.new([Mspire::Obo[:ms], Mspire::Obo[:uo]])
+    #     hash = group.id_to_name
+    #     # can access any ids from the various Mspire::Obo objects
+    #     hash["MS:1000001"] # -> 'sample number'
+    #     group
+    #
+    class Group
+      include Mspire::Obo::HashProvider
+
+      # the array of Mspire::Obo objects
+      attr_accessor :obos
+
+      def initialize(obos=[])
+        @obos = obos
+      end
+
+      # returns an id to name Hash
+      def make_id_to_name
+        merge_hashes(__method__)
+      end
+
+      def make_id_to_cast
+        merge_hashes(__method__)
+      end
+
+      # returns an id_to_stanza hash
+      def make_id_to_stanza
+        merge_hashes(__method__)
+      end
+
+      # returns a name_to_id Hash
+      def make_name_to_id
+        merge_hashes(__method__)
+      end
+
+      # merges the hashes retrieved with that symbol
+      def merge_hashes(symbol)
+        obos.map(&symbol).reduce({}, :merge)
+      end
+
+      # creates a hash keyed by namespace string that yields the name_to_id
+      # hash.
+      def name_to_id_by_namespace
+        Hash[ obos.map(&:namespace).zip(obos.map(&:make_name_to_id)) ]
+      end
+
+      # with no arguments, merely returns the @name_to_id merged hash (if
+      # made).  With one argument, looks up the id given the name.  With a
+      # namespace, the id will be returned without collision.
+      def name_to_id(name=nil, namespace=nil)
+        if namespace
+          @name_to_id_by_namespace ||= name_to_id_by_namespace
+          @name_to_id_by_namespace[namespace][name]
+        elsif name
+          @name_to_id[name]
+        else
+          @name_to_id
+        end
+      end
+
+      undef_method(:build_hash)
+    end
+  end
+end

data/lib/mspire/obo/hash_provider.rb

@@ -0,0 +1,111 @@
+module Mspire
+  class Obo
+    # requires classes to provide the :stanzas method
+    module HashProvider
+
+      attr_reader :id_to_stanza
+      attr_reader :id_to_name
+      attr_reader :id_to_cast
+      attr_reader :name_to_id
+
+      # builds all hashes for fast access
+      def make_all!
+        id_to_name!.id_to_cast!.id_to_stanza!.name_to_id!
+      end
+
+      ####################
+      ## ID TO STANZA
+      ####################
+
+      # returns an id_to_stanza hash
+      def make_id_to_stanza
+        build_hash('id', nil)
+      end
+
+      # makes and sets the id_to_stanza hash and returns self
+      def id_to_stanza!
+        @id_to_stanza = make_id_to_stanza
+        self
+      end
+
+      # returns an Obo::Stanza object
+      def stanza(id)
+        @id_to_stanza[id]
+      end
+
+      ####################
+      ## ID TO NAME
+      ####################
+
+      # returns an id to name Hash
+      def make_id_to_name
+        build_hash('id', 'name')
+      end
+
+      # builds the id_to_name hash and returns self for chaining
+      def id_to_name!
+        @id_to_name = make_id_to_name
+        self
+      end
+
+      # requires id_to_name! be called first
+      def name(id)
+        @id_to_name[id]
+      end
+
+      ####################
+      ## ID TO CAST
+      ####################
+
+      def make_id_to_cast
+        build_hash('id', :cast_method)
+      end
+
+      # makes and sets the id_to_cast hash
+      def id_to_cast!
+        @id_to_cast = make_id_to_cast
+        self
+      end
+
+      # requires id_to_cast! be called first.  If no val given, returns a symbol (e.g., :to_f).  If given a val, then it returns the cast of that val.
+      def cast(id, val=nil)
+        val ? val.send(@id_to_cast[id]) : @id_to_cast[id]
+      end
+
+      ####################
+      ## NAME TO ID
+      ####################
+
+      # makes and sets the name_to_id hash and returns self
+      def name_to_id!
+        @name_to_id = make_name_to_id
+        self
+      end
+
+      # returns a name_to_id Hash
+      def make_name_to_id
+        build_hash('name', 'id')
+      end
+
+      ####################
+      ####################
+      
+      # if val is a symbol, will call that method on the stanza
+      def build_hash(key,val)
+        hash = {}
+        stanzas.each do |el|
+          tv = el.tagvalues
+          case val
+          when nil
+            hash[tv[key].first] = el
+          when Symbol
+            hash[tv[key].first] = (el.send(val))
+          else
+            hash[tv[key].first] = tv[val].first
+          end
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/mspire/obo/header_parser.rb

@@ -0,0 +1,16 @@
+require 'obo/parser'
+
+module Mspire
+  class Obo
+    class HeaderParser < ::Obo::Parser
+      def initialize
+      end
+
+      def header(filename)
+        File.open(filename) do |io|
+          elements(io).next
+        end
+      end
+    end
+  end
+end

data/lib/mspire/obo/version.rb

@@ -0,0 +1,5 @@
+module Mspire
+  class Obo
+    VERSION = "0.0.3"
+  end
+end

data/lib/mspire/obo.rb

@@ -0,0 +1,146 @@
+require 'mspire/obo/version'
+require 'mspire/obo/header_parser'
+require 'mspire/obo/hash_provider'
+require 'obo'
+require 'ext/obo'
+require 'andand'
+require 'yaml'
+
+module Enumerable
+  def index_by
+    if block_given?
+      Hash[map { |elem| [yield(elem), elem] }]
+    else
+      to_enum :index_by
+    end
+  end
+end
+
+module Mspire
+  # This is the major class representing an ontology.  Because there are
+  # multiple ways to access the information, and fast access requires building
+  # a hash, you will need to explicitly build any hashes you want to use.
+  #
+  #     Mspire::Obo.new(file).make_all!
+  class Obo
+    include Mspire::Obo::HashProvider
+
+    DIR = File.expand_path(File.dirname(__FILE__) + '/../../obo')
+
+    class << self
+      # returns an array of hashes with each hash describing the available
+      # obos (those in the Mspire::Obo::DIR directory) with these keys:
+      #
+      #     :full_name # the generic name of the ontology
+      #     :uri       # where the ontology may be downloaded
+      #     :namespace # namespace (String)
+      #     :path      # the expanded path filename
+      #     :version   # the ontology version (String)
+      #     :key       # access symbol [typically namespace.downcase.to_sym] (Symbol)
+      def available(index_by=nil)
+        obos = []
+        Dir.chdir(Mspire::Obo::DIR) do
+          Dir['*.*'].sort.each_slice(2) do |meta, obo|
+            hash = Hash[YAML.load_file(meta).map {|k,v| [k.to_sym, v] }]
+            hash[:path] = File.expand_path(obo)
+            hash[:version] = version(hash[:path])
+            hash[:key] = hash[:namespace].downcase.to_sym
+            obos << hash
+          end
+        end
+        if index_by
+          obos.index_by {|info| info[index_by] }
+        else
+          obos
+        end
+      end
+
+      # returns an array of Obo objects corresponding to all obos held
+      def all(load_file=true)
+        available(:key).keys.map {|key| self[key, load_file] }
+      end
+
+      # determines the version of the obo by just reading the header
+      def version(filename)
+        self.new.set_version!(filename).version
+      end
+
+      # create an Mspire::Obo object from any obo file within the obo
+      # directory using its :key.  The key is the downcased symbol of the
+      # namespace and can effortlessly be determined with
+      # Mspire::Obo.available().
+      def [](key, load_file=true)
+        lookup = available.index_by {|info| info[:key] }
+        info = lookup[key]
+        self.new(
+          load_file ? info[:path] : nil,
+          uri: info[:uri], 
+          full_name: info[:full_name], 
+          version: info[:version],
+          path: info[:path],
+          namespace: info[:namespace],
+        )
+      end
+    end
+
+
+    attr_accessor :header
+    attr_accessor :stanzas
+
+    ## These are common attributes associated with typical usage of obo files
+    ## (e.g. see mzML spec)
+
+    # String specifying the namespace of the obo, e.g., 'UO' for unit
+    # ontology, "IMS" for imaging mass spec.  (necessary for name_to_id
+    # collision resolution for Mspire::Obo::Group objects).
+    attr_accessor :namespace
+    # the uri of the obo file (required for most markup languages using
+    # ontologies)
+    attr_accessor :uri
+    # the English name of the ontology (e.g., "Proteomics Ontology") (required
+    # for most markup languages using ontologies)
+    attr_accessor :full_name
+    # the version of the file.  This can be found dynamically if you have the
+    # file (required for most markup languages using ontologies)
+    attr_accessor :version
+    # expanded path to the obo file (optional)
+    attr_accessor :path
+
+    # if given a filename, then the file will be read and relevant properties
+    # will be set.
+    def initialize(filename=nil, uri: nil, full_name: nil, version: nil, path: nil, namespace: nil)
+      @uri, @full_name, @version, @path, @namespace = uri, full_name, version, path, namespace
+      from_file(filename) if filename
+    end
+
+    # sets the object properties and returns self for chaining
+    def from_file(filename)
+      obo = ::Obo::Parser.new(filename)
+      @stanzas = obo.elements.to_a
+      @header = @stanzas.shift
+      version_from_header!
+      self
+    end
+
+    # sets the header attribut and returns self for chaining
+    def set_header_from_file!(filename)
+      @header = Mspire::Obo::HeaderParser.new.header(filename)
+      self
+    end
+
+    # sets the version attribute from the header, returns self.
+    def version_from_header!
+      @version = [header.tagvalues['data-version'].first, 
+                  header.tagvalues['remark'].map {|str| str[/version\s*:\s*([^\s]+)/, 1] }.compact.first,
+                  header['date'].andand.split(' ').first
+      ].compact.first
+      self
+    end
+
+    # sets the version by just reading the header of the file.  Returns self for
+    # chaining.
+    def set_version!(filename)
+      set_header_from_file!(filename).version_from_header!
+    end
+  end
+end

data/mspire-obo.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mspire/obo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mspire-obo"
+  spec.version       = Mspire::Obo::VERSION
+  spec.authors       = ["John T. Prince"]
+  spec.email         = ["jtprince@gmail.com"]
+  spec.summary       = %q{simplified access for obo ontology files}
+  spec.description   = %q{simplified access for obo ontology files.  Builds hashes for quick lookup of terms and finds version, etc.}
+  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"]
+
+  [
+    ["obo", ">= 0.1.5"],
+    ["andand", ">= 1.3.3"],
+  ].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/obo/PSI-MOD.meta

@@ -0,0 +1,3 @@
+full_name: protein modification ontology
+uri: http://psidev.cvs.sourceforge.net/viewvc/psidev/psi/mod/data/PSI-MOD.obo
+namespace: MOD