bio-signalp 0.2.3 → 0.3.0

data/Gemfile

@@ -3,13 +3,13 @@ source "http://rubygems.org"
 # Example:
 #   gem "activesupport", ">= 2.3.5"
 gem "bio", ">= 1.4.1"
+gem "bio-logger"
 
 # Add dependencies to develop your gem here.
 # Include everything needed to run rake, tests, features, etc.
 group :development do
   gem "shoulda", ">= 0"
-  gem "bundler", "~> 1.0.0"
-  gem "jeweler", "~> 1.6.0"
-  gem "bio", ">= 1.4.1"
-  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.6.0"
+  gem "rdoc", ">= 3.12"
 end

data/README.md

@@ -0,0 +1,58 @@
+# bio-signalp
+
+A wrapper for the signal peptide prediction algorithm SignalP.
+
+Using ```bio-signalp``` requires SignalP to be locally installed and configured correctly. http://www.cbs.dtu.dk/services/SignalP/ has instructions on how it may be downloaded. This gem works best when the signalp executable is available from the command line (i.e. running 'signalp' by itself works at the commandline).
+
+# Installation
+
+First you need to setup SignalP itself. ```bio-signalp``` is tested with SignalP versions 3.0 and 4.0.
+
+1. Download SignalP and unpack the archive
+2. Modify the signalp script in the unpacked directory. Specific instructions are provided in the script itself.
+3. Add the unpacked directory to your path (or alternately, give the path to the signalp executable to the ```calculate``` method)
+
+Then you need to install this bio-gem
+
+```sh
+gem install bio-signalp
+```
+
+# Usage
+
+Usage as a script:
+```
+Usage: signalp.rb my.fasta
+
+my.fasta is the name of the fasta file you want to analyse ($stdin also accepted). Default output is all the sequences with their signal sequences cleaved.
+
+This default output can be changed by using one (only) of -s, -S, -v, -f, -F.
+
+-s, --summary                    print a tab separated table indicating if the sequence had a signal peptide results (if Signalp 3 is used, HMM and NN predictions are both given, respectively [default: no]
+-S, --bigger-summary             like -s, except also includes where the cleavage site is predicted [default: no]
+-v, --verbose-summary            much like -s except more details of the prediction are predicted [default: no]
+-f, --filter-in                  filter in: print those sequences that have a signal peptide [default: no]
+-F, --filter-out                 filter out: print those sequences that don't have a signal peptide [default: no]
+-b, --binary-path SIGNALP_PATH   path to the signalp binary e.g. /usr/local/bin/signalp-4.0/signalp [default: 'signalp' i.e. whatever is on the PATH]
+```
+
+Usage as a programmatic interface
+```ruby
+require 'bio-signalp'
+
+# The Plasmodium falciparum ACP sequence is known to have a signal peptide (one that helps direct it to the apicoplast)
+acp_sequence = 'MKILLLCIIFLYYVNAFKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ'
+
+# Run SignalP. The version is automatically detected
+result = Bio::SignalP::Wrapper.new.calculate(acp_sequence) #=> Either a Bio::SignalP::Version3::Result or a Bio::SignalP::Version4::Result object
+
+result.signal? #=> true. ACP has a predicted signal peptide.
+result.cleavage_site #=> 17. The Ymax output from SignalP gives the predicted cleavage site.
+result.cleave(acp_sequence) #=> 'FKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ'. The acp_sequence after signal peptide cleavage.
+```
+
+# Copyright
+
+Copyright (c) 2011-2012 Ben J Woodcroft. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -33,13 +33,3 @@ Rake::TestTask.new(:test) do |test|
 end
 
 task :default => :test
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "bio-blah #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.0

data/bin/signalp.rb

@@ -9,95 +9,215 @@ require 'optparse'
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
 require 'bio-signalp'
 
-runner = Bio::SignalP::Wrapper.new
 
-options = ARGV.getopts("sShvfF") #s for summary, no args required
-if options['h']
-  $stderr.puts "Usage: signalp.rb [-svf] <my.fasta>"
-  $stderr.puts "Where my.fasta is the name of the fasta file you want to analyse. Default output is all the sequences with their signal sequences cleaved."
-  $stderr.puts "-s: summary: print a tab separated table indicating if the sequence had a signal peptide according to the HMM and NN results, respectively."
-  $stderr.puts "-S: bigger_summary: like -s, except also includes where the cleavage site is predicted"
-  $stderr.puts "-v: verbose summary: much like -s except more details of the prediction are predicted."
-  $stderr.puts "-f: filter in: print those sequences that have a signal peptide"
-  $stderr.puts "-F: filter out: print those sequences that don't have a signal peptide"
-  exit
+
+# Parse command line options into the options hash
+SCRIPT_NAME = File.basename(__FILE__)
+options = {
+  :logger => 'stderr',
+  :binary_path => nil,
+}
+o = OptionParser.new do |opts|
+  opts.banner = "
+    Usage: #{SCRIPT_NAME} my.fasta
+    
+    my.fasta is the name of the fasta file you want to analyse. Default output is all the sequences with their signal sequences cleaved.
+      
+    This default output can be changed by using one (only) of -s, -S, -v, -f, -F.\n\n"
+    
+  opts.on("-s", "--summary", "print a tab separated table indicating if the sequence had a signal peptide results (if Signalp 3 is used, HMM and NN predictions are both given, respectively [default: no]") do |arg|
+    options['s'] = true
+  end
+  opts.on("-S", "--bigger-summary", "like -s, except also includes where the cleavage site is predicted [default: no]") do
+    options['S'] = true
+  end
+  opts.on("-v", "--verbose-summary", "much like -s except more details of the prediction are predicted [default: no]") do
+    options['c'] = true
+  end
+  opts.on("-f", "--filter-in", "filter in: print those sequences that have a signal peptide [default: no]") do
+    options['f'] = true
+  end
+  opts.on("-F", "--filter-out", "filter out: print those sequences that don't have a signal peptide [default: no]") do
+    options['F'] = true
+  end
+  opts.on("-b", "--binary-path SIGNALP_PATH", "path to the signalp binary e.g. /usr/local/bin/signalp-4.0/signalp [default: 'signalp' i.e. whatever is on the PATH]") do |arg|
+    options[:binary_path] = arg
+  end
+end
+o.parse!
+if ARGV.length > 1
+  $stderr.puts o
+  exit 1
 end
 
-# Print headers if required
-if options['s']
-  puts [
-    'Name',
-    'NN Prediction',
-    'HMM Prediction'
-  ].join("\t")
-elsif options['S']
-  puts [
-    'Name',
-    'NN Prediction',
-    'HMM Prediction',
-    'Predicted?',
-    'Cleavege site (if predicted)'
-  ].join("\t")
 
-elsif options['v']
-  #       [:nn_Cmax, :nn_Cmax_position, :nn_Cmax_prediction, 
-  #      :nn_Ymax, :nn_Ymax_position, :nn_Ymax_prediction, 
-  #      :nn_Smax, :nn_Smax_position, :nn_Smax_prediction, 
-  #      :nn_Smean, :nn_Smean_prediction,
-  #      :nn_D, :nn_D_prediction]
-  #    @@hmm_results = [
-  #      :hmm_result, :hmm_Cmax, :hmm_Cmax_position, :hmm_Cmax_prediction, :hmm_Sprob, :hmm_Sprob_prediction]
-  puts [
-    'Name',
-    'NN Cmax',
-    'NN Cmax position',
-    'NN Cmax prediction',
-    'NN Ymax',
-    'NN Ymax position',
-    'NN Ymax prediction',
-    'NN Smax',
-    'NN Smax position',
-    'NN Smax prediction',
-    'NN Smean',
-    'NN Smean prediction',
-    'NN D',
-    'NN D prediction',
-    'HMM result',
-    'HMM Cmax',
-    'HMM Cmax position',
-    'HMM Cmax prediction',
-    'HMM Sprob',
-    'HMM Sprob prediction',
-  ].join("\t")
-end
+printed_header = false
+signalp_version = nil
+runner = Bio::SignalP::Wrapper.new
 
 Bio::FlatFile.open(ARGF).each do |seq|
-  result = runner.calculate(seq.seq)
+  result = runner.calculate(seq.seq, :binary_path => options[:binary_path])
   if result.nil?
     $stderr.puts "Unexpected empty sequence detected, ignoring: #{seq.definition}"
-  elsif options['s']
-    puts [
-    seq.entry_id,
-    result.nn_D_prediction ? 'T' : 'F',
-    result.hmm_Sprob_prediction ? 'T' : 'F'
-    ].join("\t")
+    next
+  end
+  
+  if !printed_header
+    printed_header = true
+    
+    # Different headers are printed for the different versions (if at all)
+    if result.kind_of?(Bio::SignalP::Version3::Result)
+      signalp_version = 3
+      if options['s']
+        puts [
+          'Name',
+          'NN Prediction',
+          'HMM Prediction'
+        ].join("\t")
+      elsif options['S']
+        puts [
+          'Name',
+          'NN Prediction',
+          'HMM Prediction',
+          'Predicted?',
+          'Cleavege site (if predicted)'
+        ].join("\t")
+      
+      elsif options['v']
+        #       [:nn_Cmax, :nn_Cmax_position, :nn_Cmax_prediction, 
+        #      :nn_Ymax, :nn_Ymax_position, :nn_Ymax_prediction, 
+        #      :nn_Smax, :nn_Smax_position, :nn_Smax_prediction, 
+        #      :nn_Smean, :nn_Smean_prediction,
+        #      :nn_D, :nn_D_prediction]
+        #    @@hmm_results = [
+        #      :hmm_result, :hmm_Cmax, :hmm_Cmax_position, :hmm_Cmax_prediction, :hmm_Sprob, :hmm_Sprob_prediction]
+        puts [
+          'Name',
+          'NN Cmax',
+          'NN Cmax position',
+          'NN Cmax prediction',
+          'NN Ymax',
+          'NN Ymax position',
+          'NN Ymax prediction',
+          'NN Smax',
+          'NN Smax position',
+          'NN Smax prediction',
+          'NN Smean',
+          'NN Smean prediction',
+          'NN D',
+          'NN D prediction',
+          'HMM result',
+          'HMM Cmax',
+          'HMM Cmax position',
+          'HMM Cmax prediction',
+          'HMM Sprob',
+          'HMM Sprob prediction',
+        ].join("\t")
+      end
+      
+    elsif result.kind_of?(Bio::SignalP::Version4::Result)
+      signalp_version = 4
+      
+      if options['s']
+        puts [
+          'Name',
+          'Predicted?',
+        ].join("\t")
+      elsif options['S']
+        puts [
+          'Name',
+          'Predicted?',
+          'Cleavege site (if predicted)'
+        ].join("\t")
+      
+      elsif options['v']
+        #:Cmax, :Cmax_position,
+        #:Ymax, :Ymax_position,
+        #:Smax, :Smax_position,
+        #:Smean,
+        #:D,
+        #:prediction,
+        #:Dmaxcut,
+        #:networks_used
+        puts [
+          'Name',
+          'Cmax',
+          'Cmax position',
+          'Ymax',
+          'Ymax position',
+          'Smax',
+          'Smax position',
+          'Smean',
+          'D',
+          'prediction',
+          'Dmaxcut',
+          'networks_used'
+        ].join("\t")
+      end
+    else
+      raise "Unexpected bio-signalp result object seen: #{result.inspect}"
+    end
+  end
+  
+  if options['s']
+    if signalp_version == 3
+      puts [
+      seq.entry_id,
+      result.nn_D_prediction ? 'T' : 'F',
+      result.hmm_Sprob_prediction ? 'T' : 'F'
+      ].join("\t")
+    elsif signalp_version == 4
+      puts [
+      seq.entry_id,
+      result.prediction ? 'T' : 'F',
+      ].join("\t")
+    else
+      raise "Programming error"
+    end
   elsif options['S']
-    puts [
-    seq.entry_id,
-    result.nn_D_prediction ? 'T' : 'F',
-    result.hmm_Sprob_prediction ? 'T' : 'F',
-    result.signal? ? 'T' : 'F',
-    result.signal? ? result.cleavage_site : 0,
-    ].join("\t")
+    if signalp_version == 3
+      puts [
+      seq.entry_id,
+      result.nn_D_prediction ? 'T' : 'F',
+      result.hmm_Sprob_prediction ? 'T' : 'F',
+      result.signal? ? 'T' : 'F',
+      result.signal? ? result.cleavage_site : 0,
+      ].join("\t")
+    elsif signalp_version == 4
+      puts [
+      seq.entry_id,
+      result.signal? ? 'T' : 'F',
+      result.signal? ? result.cleavage_site : 0,
+      ].join("\t")
+    else
+      raise "Programming error"
+    end
+
   elsif options['v']
     taputs = [seq.definition]
-    [:nn_Cmax, :nn_Cmax_position, :nn_Cmax_prediction, 
-    :nn_Ymax, :nn_Ymax_position, :nn_Ymax_prediction, 
-    :nn_Smax, :nn_Smax_position, :nn_Smax_prediction, 
-    :nn_Smean, :nn_Smean_prediction,
-    :nn_D, :nn_D_prediction,
-    :hmm_result, :hmm_Cmax, :hmm_Cmax_position, :hmm_Cmax_prediction, 
-    :hmm_Sprob, :hmm_Sprob_prediction].each do |meth|
+    extras = []
+    if signalp_version == 3
+      extras = [:nn_Cmax, :nn_Cmax_position, :nn_Cmax_prediction, 
+      :nn_Ymax, :nn_Ymax_position, :nn_Ymax_prediction, 
+      :nn_Smax, :nn_Smax_position, :nn_Smax_prediction, 
+      :nn_Smean, :nn_Smean_prediction,
+      :nn_D, :nn_D_prediction,
+      :hmm_result, :hmm_Cmax, :hmm_Cmax_position, :hmm_Cmax_prediction, 
+      :hmm_Sprob, :hmm_Sprob_prediction]
+    elsif signalp_version == 4
+      extras = [
+        :Cmax, :Cmax_position,
+        :Ymax, :Ymax_position,
+        :Smax, :Smax_position,
+        :Smean,
+        :D,
+        :prediction,
+        :Dmaxcut,
+        :networks_used
+      ]
+    end
+    
+    extras.each do |meth|
       taputs.push result.send(meth)
     end
     puts taputs.join("\t")

data/bio-signalp.gemspec

@@ -5,36 +5,38 @@
 
 Gem::Specification.new do |s|
   s.name = "bio-signalp"
-  s.version = "0.2.3"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Ben J Woodcroft"]
-  s.date = "2012-04-04"
+  s.date = "2012-08-18"
   s.description = "A wrapper for the signal peptide prediction algorith SignalP. Not very well supported, but seems to work for the author, at least."
   s.email = "donttrustben near gmail.com"
   s.executables = ["signalp.rb"]
   s.extra_rdoc_files = [
     "LICENSE.txt",
-    "README.rdoc"
+    "README.md"
   ]
   s.files = [
     ".document",
     "Gemfile",
     "LICENSE.txt",
-    "README.rdoc",
+    "README.md",
     "Rakefile",
     "VERSION",
     "bin/signalp.rb",
     "bio-signalp.gemspec",
     "lib/bio-signalp.rb",
-    "lib/bio/appl/signalp.rb",
+    "lib/bio/appl/common.rb",
+    "lib/bio/appl/signalp3.rb",
+    "lib/bio/appl/signalp4.rb",
     "test/helper.rb",
     "test/test_bio-signalp.rb"
   ]
   s.homepage = "http://github.com/wwood/bioruby-signalp"
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.17"
+  s.rubygems_version = "1.8.24"
   s.summary = "A wrapper for the signal peptide prediction algorith SignalP"
 
   if s.respond_to? :specification_version then
@@ -42,26 +44,26 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<bio>, [">= 1.4.1"])
+      s.add_runtime_dependency(%q<bio-logger>, [">= 0"])
       s.add_development_dependency(%q<shoulda>, [">= 0"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
-      s.add_development_dependency(%q<bio>, [">= 1.4.1"])
-      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 1.6.0"])
+      s.add_development_dependency(%q<rdoc>, [">= 3.12"])
     else
       s.add_dependency(%q<bio>, [">= 1.4.1"])
+      s.add_dependency(%q<bio-logger>, [">= 0"])
       s.add_dependency(%q<shoulda>, [">= 0"])
-      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
-      s.add_dependency(%q<bio>, [">= 1.4.1"])
-      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, [">= 1.0.0"])
+      s.add_dependency(%q<jeweler>, [">= 1.6.0"])
+      s.add_dependency(%q<rdoc>, [">= 3.12"])
     end
   else
     s.add_dependency(%q<bio>, [">= 1.4.1"])
+    s.add_dependency(%q<bio-logger>, [">= 0"])
     s.add_dependency(%q<shoulda>, [">= 0"])
-    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
-    s.add_dependency(%q<bio>, [">= 1.4.1"])
-    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, [">= 1.0.0"])
+    s.add_dependency(%q<jeweler>, [">= 1.6.0"])
+    s.add_dependency(%q<rdoc>, [">= 3.12"])
   end
 end
 

data/lib/bio-signalp.rb

@@ -8,4 +8,9 @@
 # and put your plugin's code there. It is bad practice to write other code 
 # directly into this file, because doing so causes confusion if this biogem 
 # was ever to get merged into the main bioruby tree.
-require 'bio/appl/signalp'
+require 'bio/appl/common'
+require 'bio/appl/signalp3'
+require 'bio/appl/signalp4'
+
+require 'bio-logger'
+Bio::Log::LoggerPlus.new('bio-signalp')

data/lib/bio/appl/common.rb

@@ -0,0 +1,92 @@
+module Bio
+  module SignalP
+    NUM_FIELDS_IN_VERSION3_SHORT_OUTPUT = 21
+    NUM_FIELDS_IN_VERSION4_SHORT_OUTPUT = 12
+    
+    class Wrapper
+      def log
+        log = Bio::Log::LoggerPlus['bio-signalp']
+      end
+      
+      # Given an amino acid sequence, return a SignalP Result
+      # representing it taken from the file. The version of SignalP used
+      # is auto-detected (versions 3 and 4 are supported)
+      #
+      # options:
+      # :binary_path: full path to signalp binary e.g. '/usr/local/bin/signalp-4.0/signalp' [default: 'signalp' i.e. signalp is in the PATH]
+      #
+      # Returns nil if the sequence is empty
+      def calculate(sequence, options={})
+        return nil if sequence.nil? or sequence == ''
+        
+        default_options = {
+          :binary_path => 'signalp'
+        }
+        options = default_options.merge options
+        raise "Unexpected option parameters passed in #{options.inspect}" unless options.length == default_options.length
+        options[:binary_path] ||= default_options[:binary_path] #in case nil is passed here
+        
+        # This command needs to work with all versions of SignalP (currently v3 and v4)
+        command = "#{options[:binary_path]} -f short -t euk"
+        log.debug "Running signalp command: #{command}" if log.debug?
+        Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
+          stdin.puts '>wrapperSeq'
+          stdin.puts "#{sequence}"
+          stdin.close
+          
+          result = stdout.readlines
+          error = stderr.readlines
+          
+          unless error.empty?
+            raise Exception, "There appears to be a problem while running signalp:\n#{error}"
+          end
+          
+          # Error checking
+          num_expected_result_lines = 3
+          unless result.length == num_expected_result_lines
+            raise Exception, "Unexpected number of lines found in SignalP output (#{result.length}, expected #{num_expected_result_lines}):\n#{result}"
+          end
+          
+          splits = result[2].strip.split(/[ \t]+/)
+          if splits.length == NUM_FIELDS_IN_VERSION3_SHORT_OUTPUT
+            # SignalP 3 detected, use that
+            log.debug "Detected SignalP version 3 type output, parsing" if log.debug?
+            return Bio::SignalP::Version3::Result.create_from_line(result[2].strip)
+          elsif splits.length == NUM_FIELDS_IN_VERSION4_SHORT_OUTPUT
+            log.debug "Detected SignalP version 4 type output, parsing" if log.debug?
+            return Bio::SignalP::Version4::Result.create_from_line(result[2].strip)
+          else
+            error_description = "Bad SignalP output line found. Are you using SignalP 3.0 or 4.0? (found #{splits.length} fields in the third line of the output):\n#{result[2]}"
+            log.error error_description
+            raise Exception, error_description
+          end
+        end
+      end
+    end
+    
+    # A module for methods common to different SignalP version Result classes.
+    module Common
+      # Given an amino acid sequence (as a string),
+      # chop it off and return the remnants. Requires that the cleavage_site
+      # method be implemented
+      def cleave(sequence)
+        if signal?
+          return sequence[cleavage_site-1..sequence.length-1]
+        else
+          return sequence
+        end
+      end
+      
+      # Simple method: 'Y' => true, 'N' => false, else nil
+      def to_bool(string)
+        if string === 'Y'
+          return true
+        elsif string === 'N'
+          return false
+        else
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/bio/appl/signalp3.rb

@@ -0,0 +1,110 @@
+# Methods to wrap around the signal peptide prediction program SignalP (version 3.0)
+require 'open3'
+
+# Wrapper around a locally installed SignalP program
+module Bio
+  module SignalP
+    class Version3
+      # The result of a SignalP program. Create using the output from
+      # -format short output and create_from_line()
+      class Result
+        include Bio::SignalP::Common
+        
+        @@nn_results = 
+        [:nn_Cmax, :nn_Cmax_position, :nn_Cmax_prediction, 
+        :nn_Ymax, :nn_Ymax_position, :nn_Ymax_prediction, 
+        :nn_Smax, :nn_Smax_position, :nn_Smax_prediction, 
+        :nn_Smean, :nn_Smean_prediction,
+        :nn_D, :nn_D_prediction]
+        @@hmm_results = [
+        :hmm_result, :hmm_Cmax, :hmm_Cmax_position, :hmm_Cmax_prediction, :hmm_Sprob, :hmm_Sprob_prediction]
+        
+        @@nn_results.each do |sym|
+          attr_accessor sym
+        end
+        @@hmm_results.each do |sym|
+          attr_accessor sym
+        end
+        
+        # Create a new SignalpResult using a line from the signal p 'short' output format,
+        # version 3.0
+        def self.create_from_line(line)
+          # e.g.
+          # # name                Cmax  pos ?  Ymax  pos ?  Smax  pos ?  Smean ?  D     ?   # name      !  Cmax  pos ?  Sprob ?
+          # 526.m04658            0.734  19 Y  0.686  19 Y  0.933   6 Y  0.760 Y  0.723 Y 526.m04658  Q  0.037  19 N  0.004 N
+          matches = line.split(/[ \t]+/)
+          if matches.length != Bio::SignalP::NUM_FIELDS_IN_VERSION3_SHORT_OUTPUT
+            raise Exception, "Bad SignalP Short Line Found (#{matches.length}): '#{line}'"
+          end
+          
+          i = 1
+          result = Result.new
+          result.nn_Cmax = matches[i].to_f; i += 1
+          result.nn_Cmax_position = matches[i].to_i; i += 1
+          result.nn_Cmax_prediction = result.to_bool matches[i]; i += 1
+          result.nn_Ymax = matches[i].to_f; i += 1
+          result.nn_Ymax_position = matches[i].to_i; i += 1
+          result.nn_Ymax_prediction = result.to_bool matches[i]; i += 1
+          result.nn_Smax = matches[i].to_f; i += 1
+          result.nn_Smax_position = matches[i].to_i; i += 1
+          result.nn_Smax_prediction = result.to_bool matches[i]; i += 1
+          result.nn_Smean = matches[i].to_f; i += 1
+          result.nn_Smean_prediction = result.to_bool matches[i]; i += 1
+          result.nn_D = matches[i].to_f; i += 1
+          result.nn_D_prediction = result.to_bool matches[i]; i += 1
+          
+          i+= 1
+          result.hmm_result = matches[i]; i += 1
+          result.hmm_Cmax = matches[i].to_f; i += 1
+          result.hmm_Cmax_position = matches[i].to_i; i += 1
+          result.hmm_Cmax_prediction = result.to_bool matches[i]; i += 1
+          result.hmm_Sprob = matches[i].to_f; i += 1
+          result.hmm_Sprob_prediction = result.to_bool matches[i]; i += 1
+          
+          return result
+        end
+        
+        # Does it have a signal peptide? It can be this class (default), 
+        # or another class that responds to :nn_D_prediction and :hmm_Sprob_prediction
+        def signal?(clazz=self)
+          return (clazz.send(:nn_D_prediction) or clazz.send(:hmm_Sprob_prediction))
+        end
+        
+        def classical_signal_sequence?
+          return @nn_D_prediction
+        end
+        
+        def signal_anchor?
+          return @hmm_Sprob_prediction
+        end
+        
+        # Return an array of all the results. NN then HMM, as per SignalP short format
+        def all_results
+          all = []
+          
+          @@nn_results.each do |sym|
+            all.push self.send(sym)
+          end
+          
+          @@hmm_results.each do |sym|
+            all.push self.send(sym)
+          end
+          
+          return all
+        end
+        
+        # Return an array of symbols representing the names of the columns
+        def self.all_result_names
+          return [@@nn_results, @@hmm_results].flatten
+        end
+        
+        # Return the number of the residue after the cleavage site
+        # ie. the first residue of the mature protein
+        # Taken from the Y score, as it was decided this is the best prediction
+        def cleavage_site
+          @nn_Ymax_position
+        end
+      end
+    end
+  end
+end

data/lib/bio/appl/signalp4.rb

@@ -0,0 +1,72 @@
+# Methods to wrap around the signal peptide prediction program SignalP (version 3.0)
+require 'open3'
+
+# Wrapper around a locally installed SignalP program
+module Bio
+  module SignalP
+    class Version4
+      # The result of a SignalP program. Create using the output from
+      # -format short output and create_from_line()
+      class Result
+        include Bio::SignalP::Common
+        
+        @@output_fields = [
+                           :Cmax, :Cmax_position,
+                           :Ymax, :Ymax_position,
+                           :Smax, :Smax_position,
+                           :Smean,
+                           :D,
+                           :prediction,
+                           :Dmaxcut,
+                           :networks_used,
+        ]
+        
+        @@output_fields.each do |sym|
+          attr_accessor sym
+        end
+        
+        # Create a new SignalpResult using a line from the signal p 'short' output format,
+        def self.create_from_line(line)
+          # e.g.
+          #$ ~/bioinfo/signalp-4.0/signalp /tmp/acp 
+          ## SignalP-4.0 euk predictions
+          ## name                     Cmax  pos  Ymax  pos  Smax  pos  Smean   D     ?  Dmaxcut    Networks-used
+          #acp                        0.871  17  0.863  17  0.886   1  0.844   0.853 Y  0.450      SignalP-noTM
+          matches = line.split(/[ \t]+/)
+          if matches.length != Bio::SignalP::NUM_FIELDS_IN_VERSION4_SHORT_OUTPUT
+            raise Exception, "Bad SignalP Short Line Found (#{matches.length}): '#{line}'"
+          end
+          
+          i = 1
+          result = Result.new
+          result.Cmax = matches[i].to_f; i += 1
+          result.Cmax_position = matches[i].to_i; i += 1
+          result.Ymax = matches[i].to_f; i += 1
+          result.Ymax_position = matches[i].to_i; i += 1
+          result.Smax = matches[i].to_f; i += 1
+          result.Smax_position = matches[i].to_i; i += 1
+          result.Smean = matches[i].to_f; i += 1
+          result.D = matches[i].to_f; i += 1
+          result.prediction = result.to_bool matches[i]; i += 1
+          result.Dmaxcut = matches[i].to_f; i += 1
+          result.networks_used = matches[i]; i += 1
+          
+          return result
+        end
+          
+        # Does it have a signal peptide? It can be this class (default), 
+        # or another class that responds to :nn_D_prediction and :hmm_Sprob_prediction
+        def signal?(clazz=self)
+          return clazz.send(:prediction)
+        end
+        
+        # Return the number of the residue after the cleavage site
+        # ie. the first residue of the mature protein
+        # Taken from the Y score, as it was decided this is the best prediction
+        def cleavage_site
+          @Ymax_position
+        end
+      end
+    end
+  end
+end

data/test/test_bio-signalp.rb

@@ -1,7 +1,20 @@
 require 'helper'
 require 'open3'
 
+@@signalp3_path = File.join(ENV['HOME'],'bioinfo','signalp-3.0','signalp')
+@@signalp4_path = File.join(ENV['HOME'],'bioinfo','signalp-4.0','signalp')
+@@binaries = [
+  @@signalp3_path,
+  @@signalp4_path,
+]
+  
 class TestBioSignalp < Test::Unit::TestCase
+  def setup
+    log_name = 'bio-signalp'
+    Bio::Log::CLI.logger('stderr')
+    #Bio::Log::CLI.configure(log_name) # when commented out no debug is printed out
+  end
+
   should "positive control" do
   # Known to have a signal peptide
     acp_sequence = 'MKILLLCIIFLYYVNAFKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ'
@@ -15,15 +28,54 @@ class TestBioSignalp < Test::Unit::TestCase
 
     assert_equal false, Bio::SignalP::Wrapper.new.calculate(non_signal_sequence).signal?
   end
+  
+  should 'work with different SignalP versions, this test is specific to Ben\'s machines probably' do
+    binaries = {
+      @@binaries[0] => Bio::SignalP::Version3::Result,
+      @@binaries[1] => Bio::SignalP::Version4::Result,
+    }
+    binaries.each do |binary, clazz|
+      acp_sequence = 'MKILLLCIIFLYYVNAFKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ'
+      positive_result = Bio::SignalP::Wrapper.new.calculate(acp_sequence, :binary_path => binary)
+      assert_equal true, positive_result.signal?, binary
+      assert_kind_of clazz, positive_result, binary
+      assert_equal 17, positive_result.cleavage_site, binary
+      assert_equal 'FKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ',
+        positive_result.cleave(acp_sequence), binary
+      non_signal_sequence = 'KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK'
+      assert_equal false, Bio::SignalP::Wrapper.new.calculate(non_signal_sequence, :binary_path => binary).signal?, binary
+    end
+  end
+  
+  should 'give different predictions for v3 and v4' do
+    different = <<EOF
+MMKGMVEAAVKWMKAGLPLRILKLVLYAKVIDGDLQGHSLRRFSEVLKTFTELKERYEMQ
+LLLPKAVPLEFDVYLSFSEEDKEVAKVIREKLSGAKDGVRIYDSSHQGINKDTVFQEDMY
+SIMMKSARVVTVLSPNYLRNKACIEQYNIALCCNRRALRDMLAPIYVDSVEMMPTYMGLV
+QYVDCRPHDPSKIGEACSQLTVSLSVTFHTELRVAEFDPLRYDVFLSYSHRDTEKANRFV
+EMLQKLAPDLKLFFDVQELKTGKSWQRTLYHSIDGSRCMLALISEPYLKSAVCQEEFALA
+QAKHCAKGKQHLQLISICLDDLDTIQPEFTHIPMVKGTPDVFDDMVKTVCPAVIQWLNGE
+RVDQTETIKTLFDDQNITTLSADAEMEKFRQSHFQKEFGTQDSLISSKSPFPPKLSDILP
+EPGKEVKDKRPKSASDCDLIFSYHSDDEKYVSFIVKILQLNAPSLKVKAVCSDENKLSAF
+ERAHCIVPVLSPNYLESPECVEEFHIAIWRQRISNPEAGALLPICVHTLPQKPTYFHLVQ
+SAVSMTDGIWAQLSGQHNFGLPQKIVDFSLAAGKTPLSQVDMLALYMAAYYILKRFAKAR
+SCKEVEFSMKPALFNIMKLQEQIKQLTQPDYTDQLCKTLLEIHFNDIPDSWREGGHYLRP
+KEPEDTTPAIMAPVEGASDSQTHNALNERTQDSSGKDKSEVQGEKAQRSASEGVSHDTVQ
+QMDQDHDLKAAQGQDTAEGQDAAEGQDSEGGQDSEGGWDSDGGRDSVGNKTDAEKITGNH
+GDEGGDGQVGGSEESKEKTEDEDEDISKRNRAPRSVACVCL
+EOF
+    assert_equal true, Bio::SignalP::Wrapper.new.calculate(different, :binary_path => @@signalp3_path).signal?
+    assert_equal false, Bio::SignalP::Wrapper.new.calculate(different, :binary_path => @@signalp4_path).signal?
+  end
 end
 
 class TestSignalPScript < Test::Unit::TestCase
-  command = File.join(File.dirname(__FILE__),'..','bin','signalp.rb')
+  # Known to have a signal peptide
+  acp_sequence = 'MKILLLCIIFLYYVNAFKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ'
   
   should "positive control" do
-  # Known to have a signal peptide
-    acp_sequence = 'MKILLLCIIFLYYVNAFKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ'
-
+    command = File.join(File.dirname(__FILE__),'..','bin','signalp.rb')
+    
     Open3.popen3(command) do |stdin, stdout, stderr|
       stdin.puts '>positive'
       stdin.puts acp_sequence
@@ -37,7 +89,7 @@ class TestSignalPScript < Test::Unit::TestCase
   end
   
   should "return gracefully when empty sequences are given" do
-    acp_sequence = 'MKILLLCIIFLYYVNAFKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ'
+    command = File.join(File.dirname(__FILE__),'..','bin','signalp.rb')
     
     Open3.popen3(command) do |stdin, stdout, stderr|
       stdin.puts '>positive'
@@ -54,4 +106,54 @@ class TestSignalPScript < Test::Unit::TestCase
     ">positive2\n", "FKNTQKDGVSLQILKKKRSNQVNFLNRKNDYNLIKNKNPSSSLKSTFDDIKKIISKQLSVEEDKIQMNSNFTKDLGADSLDLVELIMALEEKFNVTISDQDALKINTVQDAIDYIEKNNKQ\n"], @result
     assert_equal ["Unexpected empty sequence detected, ignoring: empty\n"], @error
   end
+  
+  
+  
+  
+  should 'give the right -s output for signalp 3' do
+    command = File.join(File.dirname(__FILE__),'..','bin','signalp.rb')
+    
+    # This also tests the -b flag
+    command = "#{command} -b #{@@signalp3_path} -s"
+    Open3.popen3(command) do |stdin, stdout, stderr|
+      stdin.puts '>positive'
+      stdin.puts acp_sequence
+      stdin.close
+      
+      @result = stdout.readlines # convert to string?
+      @error  = stderr.readlines
+    end
+    
+    expected = [
+    "Name\tNN Prediction\tHMM Prediction\n",
+    "positive\tT\tT\n"
+    ]
+    assert_equal expected, @result
+    assert_equal [], @error  
+  end
+  
+  
+  
+  
+  should 'give the right -s output for signalp 4' do
+    command = File.join(File.dirname(__FILE__),'..','bin','signalp.rb')
+    
+    command = "#{command} -b #{@@signalp4_path} -s"
+    Open3.popen3(command) do |stdin, stdout, stderr|
+      stdin.puts '>positive'
+      stdin.puts acp_sequence
+      stdin.close
+      
+      @result = stdout.readlines # convert to string?
+      @error  = stderr.readlines
+    end
+    
+    expected = [
+    "Name\tPredicted?\n",
+    "positive\tT\n"
+    ]
+    assert_equal [], @error
+    assert_equal expected, @result
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bio-signalp
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-04 00:00:00.000000000 Z
+date: 2012-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bio
-  requirement: &75320500 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,31 @@ dependencies:
         version: 1.4.1
   type: :runtime
   prerelease: false
-  version_requirements: *75320500
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.1
+- !ruby/object:Gem::Dependency
+  name: bio-logger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &75320020 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,51 +53,60 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *75320020
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &75318990 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *75318990
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &75318160 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.6.0
   type: :development
   prerelease: false
-  version_requirements: *75318160
-- !ruby/object:Gem::Dependency
-  name: bio
-  requirement: &75317190 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 1.4.1
-  type: :development
-  prerelease: false
-  version_requirements: *75317190
+        version: 1.6.0
 - !ruby/object:Gem::Dependency
   name: rdoc
-  requirement: &75316460 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3.12'
   type: :development
   prerelease: false
-  version_requirements: *75316460
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.12'
 description: A wrapper for the signal peptide prediction algorith SignalP. Not very
   well supported, but seems to work for the author, at least.
 email: donttrustben near gmail.com
@@ -85,18 +115,20 @@ executables:
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
+- README.md
 files:
 - .document
 - Gemfile
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - bin/signalp.rb
 - bio-signalp.gemspec
 - lib/bio-signalp.rb
-- lib/bio/appl/signalp.rb
+- lib/bio/appl/common.rb
+- lib/bio/appl/signalp3.rb
+- lib/bio/appl/signalp4.rb
 - test/helper.rb
 - test/test_bio-signalp.rb
 homepage: http://github.com/wwood/bioruby-signalp
@@ -114,7 +146,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 903911101
+      hash: -969867473
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -123,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: A wrapper for the signal peptide prediction algorith SignalP

data/README.rdoc

@@ -1,30 +0,0 @@
-= bio-signalp
-
-A wrapper for the signal peptide prediction algorithm SignalP (version 3.0).
-
-Using this bio-gem requires SignalP to be locally installed and configured correctly. http://www.cbs.dtu.dk/services/SignalP-3.0/ has instructions on how it may be downloaded. This gem requires that the signalp executable is available from the command line (i.e. running 'signalp' works at the command), so the steps to setup
-
-# Download SignalP 3.0 and unpack
-# Modify the signalp script in the unpacked directory
-# Add the unpacked directory to your path
-# install this bioruby plugin (gem install bioruby-signalp)
-
-This bio-gem includes a library for interacting with signalp programmatically, but also (as of version 0.1.1) a script as well.
-
-NOTE: Only tested with SignalP 3.0 at this point. Hopefully 4.0 will be tested in the future.
-
-== Contributing to bio-signalp
- 
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
-* Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2011-2012 Ben J Woodcroft. See LICENSE.txt for
-further details.
-

data/lib/bio/appl/signalp.rb

@@ -1,165 +0,0 @@
-# Methods to wrap around the signal peptide prediction program SignalP (version 3.0)
-require 'open3'
-
-# Wrapper around a locally installed SignalP program
-module Bio
-  class SignalP
-    NUM_FIELDS_IN_SHORT_OUTPUT = 21
-    
-    class Wrapper
-      # Given an amino acid sequence, return a SignalPResult
-      # representing it taken from the file.
-      #
-      # Returns nil if the sequence is empty
-      def calculate(sequence)
-        return nil if sequence.nil? or sequence == ''
-        
-        command = 'signalp -trunc 70 -format short -t euk'
-        Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
-          stdin.puts '>wrapperSeq'
-          stdin.puts "#{sequence}"
-          stdin.close
-          
-          result = stdout.readlines
-          error = stderr.readlines
-          
-          unless error.empty?
-            raise Exception, "There appears to be a problem while running signalp:\n#{error}"
-          end
-          
-          # Error checking
-          num_expected_result_lines = 3
-          unless result.length == num_expected_result_lines
-            raise Exception, "Unexpected number of lines found in SignalP output (#{result.length}, expected #{num_expected_result_lines}):\n#{result}"
-          end
-          
-          splits = result[2].strip.split(/[ \t]+/)
-          if splits.length != NUM_FIELDS_IN_SHORT_OUTPUT
-            raise Exception, "Bad SignalP output line found. Are you using SignalP 3.0? (expected #{NUM_FIELDS_IN_SHORT_OUTPUT} fields, found #{splits.length} fields):\n#{result[2]}"
-          end
-          
-          return Result.create_from_line(result[2].strip)
-        end
-      end
-    end
-    
-    # The result of a SignalP program. Create using the output from
-    # -format short output and create_from_line()
-    class Result
-      @@nn_results = 
-      [:nn_Cmax, :nn_Cmax_position, :nn_Cmax_prediction, 
-      :nn_Ymax, :nn_Ymax_position, :nn_Ymax_prediction, 
-      :nn_Smax, :nn_Smax_position, :nn_Smax_prediction, 
-      :nn_Smean, :nn_Smean_prediction,
-      :nn_D, :nn_D_prediction]
-      @@hmm_results = [
-      :hmm_result, :hmm_Cmax, :hmm_Cmax_position, :hmm_Cmax_prediction, :hmm_Sprob, :hmm_Sprob_prediction]
-      
-      @@nn_results.each do |sym|
-        attr_accessor sym
-      end
-      @@hmm_results.each do |sym|
-        attr_accessor sym
-      end
-      
-      # Create a new SignalpResult using a line from the signal p 'short' output format,
-      # version 3.0
-      def self.create_from_line(line)
-        # e.g.
-        # # name                Cmax  pos ?  Ymax  pos ?  Smax  pos ?  Smean ?  D     ?   # name      !  Cmax  pos ?  Sprob ?
-        # 526.m04658            0.734  19 Y  0.686  19 Y  0.933   6 Y  0.760 Y  0.723 Y 526.m04658  Q  0.037  19 N  0.004 N
-        matches = line.split(/[ \t]+/)
-        if matches.length != NUM_FIELDS_IN_SHORT_OUTPUT
-          raise Exception, "Bad SignalP Short Line Found (#{matches.length}): '#{line}'"
-        end
-        
-        i = 1
-        result = Result.new
-        result.nn_Cmax = matches[i].to_f; i += 1
-        result.nn_Cmax_position = matches[i].to_i; i += 1
-        result.nn_Cmax_prediction = to_bool matches[i]; i += 1
-        result.nn_Ymax = matches[i].to_f; i += 1
-        result.nn_Ymax_position = matches[i].to_i; i += 1
-        result.nn_Ymax_prediction = to_bool matches[i]; i += 1
-        result.nn_Smax = matches[i].to_f; i += 1
-        result.nn_Smax_position = matches[i].to_i; i += 1
-        result.nn_Smax_prediction = to_bool matches[i]; i += 1
-        result.nn_Smean = matches[i].to_f; i += 1
-        result.nn_Smean_prediction = to_bool matches[i]; i += 1
-        result.nn_D = matches[i].to_f; i += 1
-        result.nn_D_prediction = to_bool matches[i]; i += 1
-        
-        i+= 1
-        result.hmm_result = matches[i]; i += 1
-        result.hmm_Cmax = matches[i].to_f; i += 1
-        result.hmm_Cmax_position = matches[i].to_i; i += 1
-        result.hmm_Cmax_prediction = to_bool matches[i]; i += 1
-        result.hmm_Sprob = matches[i].to_f; i += 1
-        result.hmm_Sprob_prediction = to_bool matches[i]; i += 1
-        
-        return result
-      end
-      
-      def self.to_bool(string)
-        if string === 'Y'
-          return true
-        elsif string === 'N'
-          return false
-        else
-          return nil
-        end
-      end
-      
-      # Does it have a signal peptide? It can be this class (default), 
-      # or another class that responds to :nn_D_prediction and :hmm_Sprob_prediction
-      def signal?(clazz=self)
-        return (clazz.send(:nn_D_prediction) or clazz.send(:hmm_Sprob_prediction))
-      end
-      
-      def classical_signal_sequence?
-        return @nn_D_prediction
-      end
-      
-      def signal_anchor?
-        return @hmm_Sprob_prediction
-      end
-      
-      # Return an array of all the results. NN then HMM, as per SignalP short format
-      def all_results
-        all = []
-        
-        @@nn_results.each do |sym|
-          all.push self.send(sym)
-        end
-        
-        @@hmm_results.each do |sym|
-          all.push self.send(sym)
-        end
-        
-        return all
-      end
-      
-      # Return an array of symbols representing the names of the columns
-      def self.all_result_names
-        return [@@nn_results, @@hmm_results].flatten
-      end
-      
-      # Return the number of the residue after the cleavage site
-      # ie. the first residue of the mature protein
-      # Taken from the Y score, as it was decided this is the best prediction
-      def cleavage_site
-        @nn_Ymax_position
-      end
-      
-      # Given an amino acid sequence (as a string),
-      # chop it off and return the remnants
-      def cleave(sequence)
-        if signal?
-          return sequence[cleavage_site-1..sequence.length-1]
-        else
-          return sequence
-        end
-      end
-    end
-  end
-end