sequenceserver 1.0.0.pre.3 → 1.0.0.pre.4

data/lib/sequenceserver/blast/hit.rb

@@ -2,22 +2,17 @@ module SequenceServer
   # Define BLAST::Hit.
   module BLAST
     # Hit Object to store all the hits per Query.
-    # @member [Fixnum]     number
-    # @member [String]     id
-    # @member [String]     def
-    # @member [String]     accession
-    # @member [Fixnum]     len
-    # @member [HSP]        hsp
-    Hit = Struct.new(:number, :id, :title, :accession, :len, :hsps) do
+    Hit = Struct.new(:query, :number, :id, :accession, :title,
+                     :length, :hsps) do
+      include Links
+
       def initialize(*args)
-        args[0] = args[0].to_i
-        args[2] = '' if args[2] == 'No definition line'
-        args[4] = args[4].to_i
+        args[1] = args[1].to_i
+        args[4] = '' if args[4] == 'No definition line'
+        args[5] = args[5].to_i
         super
       end
 
-      alias_method :length, :len
-
       # Hit evalue is the minimum evalue of all HSP(s).
       def evalue
         hsps.map(&:evalue).min
@@ -27,6 +22,32 @@ module SequenceServer
       def score
         hsps.map(&:bit_score).reduce(:+)
       end
+
+      def links
+        links = Links.instance_methods.map { |m| send m }
+        links.compact!
+        links.sort_by! { |link| link[:order] }
+      end
+
+      # Returns an array of database objects which contain the queried sequence
+      # id.
+      #
+      # NOTE:
+      #   This function may return more than one database object for a single
+      #   sequence id.
+      #
+      # e.g., which_blastdb('SI_2.2.23') => [<Database: ...>, ...]
+      def whichdb
+        querydb.select { |db| db.include? id }
+      end
+
+      def report
+        query.report
+      end
+
+      def querydb
+        report.querydb
+      end
     end
   end
 end

data/lib/sequenceserver/blast/hsp.rb

@@ -6,11 +6,11 @@ module SequenceServer
     # HSP class is not used directly.  Relevant HSP stats and formatting the
     # alignment changes with BLAST algorithm. We subclass HSP for each BLAST
     # algorithm.
-    HSP = Struct.new(:number, :bit_score, :score, :evalue, :qstart, :qend,
+    HSP = Struct.new(:hit, :number, :bit_score, :score, :evalue, :qstart, :qend,
                      :sstart, :send, :qframe, :sframe, :identity, :positives,
-                     :gaps, :len, :qseq, :sseq, :midline) do
-      INTEGER_ARGS = [0, 2].concat((4..13).to_a)
-      FLOAT_ARGS   = [1, 3]
+                     :gaps, :length, :qseq, :sseq, :midline) do
+      INTEGER_ARGS = [1, 3].concat((5..14).to_a)
+      FLOAT_ARGS   = [2, 4]
 
       def initialize(*args)
         INTEGER_ARGS.each do |i|
@@ -24,8 +24,6 @@ module SequenceServer
         super
       end
 
-      alias_method :length, :len
-
       # Returns a Hash of stats common to all BLAST algorithms. Subclasses must
       # update the returned Hash to add relevant stats of their own.
       #

data/lib/sequenceserver/blast/query.rb

@@ -4,14 +4,14 @@ module SequenceServer
     # Capture results per query of a BLAST search.
     # @member [String]     number
     # @member [String]     def
-    # @member [Fixnum]     len
+    # @member [Fixnum]     length
     # @member [Array(Hit)] hits
-    Query = Struct.new(:number, :def, :len, :hits) do
+    Query = Struct.new(:report, :number, :def, :length, :hits) do
       def initialize(*args)
-        args[0] = args[0].to_i
-        args[1] = "Query_#{args[0]}" if args[1] == 'No definition line'
-        args[2] = args[2].to_i
-        @id, *rest = args[1].split
+        args[1] = args[1].to_i
+        args[2] = "Query_#{args[1]}" if args[2] == 'No definition line'
+        args[3] = args[3].to_i
+        @id, *rest = args[2].split
         @title = rest.join(' ')
         super
       end
@@ -21,8 +21,6 @@ module SequenceServer
       end
 
       attr_reader :id, :title
-
-      alias_method :length, :len
     end
   end
 end

data/lib/sequenceserver/blast/report.rb

@@ -1,99 +1,116 @@
 module SequenceServer
   module BLAST
-    # Captures BLAST results from BLAST+'s XML output.
+    # Captures results of a BLAST search.
+    #
+    # A report is constructed from a search id. Search id is simply the
+    # basename of the temporary file that holds BLAST results in binary
+    # BLAST archive format.
+    #
+    # For a given search id, result is obtained in XML format using the
+    # Formatter class, parsed into a simple intermediate representation
+    # (Array of values and Arrays) and information extracted from the
+    # intermediate representation (ir).
     class Report
-      include Links
-
-      # Expects a File object and Database objects used to BLAST against.
-      #
-      # Parses the XML file into an intermediate representation (ir) and
-      # constructs an object model from that.
-      #
-      # NOTE:
-      #   Databases param is optional for test suite.
-      #
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def initialize(rfile, databases = nil)
-        @archive_file = rfile
-
-        xml_file = BLAST.format('report' => @archive_file,
-                                'type'   => 'full',
-                                'format' => 'xml')
-
-        ir = File.open(xml_file[:filepath]) do |f|
-          node_to_array Ox.parse(f.read).root
-        end
-
-        @program = ir[0]
-        @program_version = ir[1]
+      # Expects a BLAST search id and an Array of Database objects that were
+      # used to BLAST. The second argument being optional to aid test suite.
+      def initialize(search_id, databases = nil)
+        @search_id = search_id
         @querydb = Array databases
-        @parameters = {
-          :matrix    => ir[7][0],
-          :evalue    => ir[7][1],
-          :gapopen   => ir[7][2],
-          :gapextend => ir[7][3],
-          :filters   => ir[7][4]
-        }
+        @queries = []
 
-        ir[8].each_with_index do |n, i|
-          @stats ||= n[5][0]
-          @queries ||= []
-          @queries.push(Query.new(n[0], n[2], n[3], []))
-
-          # Ensure a hit object is received. No hits, returns a newline. Note
-          # that checking to "\n" doesn't work since n[4] = ["\n"]
-          if n[4] == ["\n"]
-            @queries[i][:hits] = []
-          else
-            n[4].each_with_index do |hits, j|
-              @queries[i][:hits].push(Hit.new(hits[0], hits[1], hits[2],
-                                              hits[3], hits[4], []))
-              hits[5].each do |hsp|
-                hsp_klass = HSP.const_get program.upcase
-                @queries[i][:hits][j][:hsps].push(hsp_klass.new(*hsp))
-              end
-            end
-            @queries[i].sort_hits_by_evalue!
-          end
-        end
+        generate
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      attr_reader :archive_file
-      attr_reader :program, :program_version
+      attr_reader :search_id, :querydb
 
       # :nodoc:
-      # params are defaults provided by BLAST or user input to tweak the
-      # result. stats are computed metrics provided by BLAST.
-      #
-      # BLAST+ doesn't list all input params (like word_size) in the XML
-      # output. Only matrix, evalue, gapopen, gapextend, and filters.
+      # Attributes parsed out from XML output.
+      attr_reader :program, :program_version
       attr_reader :params, :stats
-
-      attr_reader :querydb
-
       attr_reader :queries
 
-      # Helper methods for pretty printing results
+      private
 
-      def link_per_hit(sequence_id)
-        links = Links.instance_methods.map { |m| send(m, sequence_id) }
+      # Generate report.
+      def generate
+        xml = Formatter.run(search_id, 'xml').file
+        ir  = node_to_array(Ox.parse(xml.open.read).root)
+        extract_program_info ir
+        extract_params ir
+        extract_stats ir
+        extract_query ir
+      end
 
-        # Sort links based on :order key (ascending)
-        links.compact!.sort_by! { |link| link[:order] }
+      # Make program name and program name + version available via `program`
+      # and `program_version` attributes.
+      def extract_program_info(ir)
+        @program         = ir[0]
+        @program_version = ir[1]
       end
 
-      # Returns an array of database objects which contain the queried
-      # sequence id.
-      # NOTE: This function may return more than one database object for
-      # a single sequence id.
+      # Make search params available via `params` attribute.
       #
-      # e.g., which_blastdb('SI_2.2.23') => [<Database: ...>, ...]
-      def which_blastdb(sequence_id)
-        querydb.select { |db| db.include? sequence_id }
+      # Search params tweak the results. Like evalue cutoff or penalty to open
+      # a gap. BLAST+ doesn't list all input params in the XML output. Only
+      # matrix, evalue, gapopen, gapextend, and filters are available from XML
+      # output.
+      def extract_params(ir)
+        params  = ir[7]
+        @params = {
+          :matrix    => params[0],
+          :evalue    => params[1],
+          :gapopen   => params[2],
+          :gapextend => params[3],
+          :filters   => params[4]
+        }
       end
 
-      private
+      # Make search stats available via `stats` attribute.
+      #
+      # Search stats are computed metrics. Like total number of sequences or
+      # effective search space.
+      def extract_stats(ir)
+        stats  = ir[8].first[5][0]
+        @stats = {
+          :nsequences   => stats[0],
+          :ncharacters  => stats[1],
+          :hsp_length   => stats[2],
+          :search_space => stats[3],
+          :kappa        => stats[4],
+          :labmda       => stats[5],
+          :entropy      => stats[6]
+        }
+      end
+
+      # Make results for each input query available via `queries` atribute.
+      def extract_query(ir)
+        ir[8].each do |n|
+          query = Query.new(self, n[0], n[2], n[3], [])
+          extract_hits(n[4], query)
+          query.sort_hits_by_evalue!
+          queries << query
+        end
+      end
+
+      # Create Hit objects from given ir and associate them to query i.
+      def extract_hits(hits_ir, query)
+        return if hits_ir == ["\n"] # => No hits.
+        hits_ir.each do |n|
+          hit = Hit.new(query, n[0], n[1], n[3], n[2], n[4], [])
+          extract_hsps(n[5], hit)
+          query.hits << hit
+        end
+      end
+
+      # Create HSP objects from the given ir and associate them with hit j of
+      # query i.
+      def extract_hsps(hsp_ir, hit)
+        hsp_ir.each do |n|
+          hsp_klass = HSP.const_get program.upcase
+          hsp = hsp_klass.new(*[hit, *n])
+          hit.hsps << hsp
+        end
+      end
 
       PARSEABLE_AS_ARRAY = %w(Parameters BlastOutput_param Iteration_stat
                               Statistics Iteration_hits BlastOutput_iterations

data/lib/sequenceserver/config.rb

@@ -1,3 +1,4 @@
+require 'yaml'
 require 'forwardable'
 
 # Define Config class.

data/lib/sequenceserver/exceptions.rb

@@ -23,7 +23,7 @@ module SequenceServer
 
     def to_s
       <<MSG
-Error in config file: #{ent}.
+Error reading config file: #{ent}.
 #{err}
 MSG
     end

data/lib/sequenceserver/links.rb

@@ -10,15 +10,7 @@ module SequenceServer
 
     NCBI_ID_PATTERN = /gi\|(\d+)\|/
 
-    # Your custom method should have following pattern:
-    #
-    # Input
-    # -----
-    # sequence_id: Array of sequence ids
-    #
-    # Return
-    # ------
-    # The return value should be a Hash:
+    # Link generators return a Hash like below.
     #
     # {
     #   # Required. Display title.
@@ -56,21 +48,21 @@ module SequenceServer
     #   querydb:
     #     Returns an array of databases that were used for BLASTing.
     #
-    #   which_blastdb:
+    #   whichdb:
     #     Returns the database from which the given hit came from.
     #
     #     e.g:
     #
-    #         hit_database = which_blastdb sequence_id
+    #         hit_database = whichdb
     #
     # Examples:
     # ---------
     # See methods provided by default for an example implementation.
 
-    def sequence_viewer(sequence_id)
-      sequence_id  = encode sequence_id
+    def sequence_viewer
+      accession  = encode self.accession
       database_ids = encode querydb.map(&:id).join(' ')
-      url = "get_sequence/?sequence_ids=#{sequence_id}" \
+      url = "get_sequence/?sequence_ids=#{accession}" \
             "&database_ids=#{database_ids}"
 
       {
@@ -82,28 +74,29 @@ module SequenceServer
       }
     end
 
-    def fasta_download(sequence_id)
-      sequence_id  = encode sequence_id
+    def fasta_download
+      accession  = encode self.accession
       database_ids = encode querydb.map(&:id).join(' ')
-      url = "get_sequence/?sequence_ids=#{sequence_id}" \
+      url = "get_sequence/?sequence_ids=#{accession}" \
             "&database_ids=#{database_ids}&download=fasta"
 
       {
         :order => 1,
         :title => 'FASTA',
         :url   => url,
+        :class => 'download',
         :icon  => 'fa-download'
       }
     end
 
-    def ncbi(sequence_id)
-      return nil unless sequence_id.match(NCBI_ID_PATTERN)
+    def ncbi
+      return nil unless id.match(NCBI_ID_PATTERN)
       ncbi_id = Regexp.last_match[1]
       ncbi_id = encode ncbi_id
-      url = "http://www.ncbi.nlm.nih.gov/#{querydb.first.typ}/#{ncbi_id}"
+      url = "http://www.ncbi.nlm.nih.gov/#{querydb.first.type}/#{ncbi_id}"
       {
         :order => 2,
-        :title => 'View on NCBI',
+        :title => 'NCBI',
         :url   => url,
         :icon  => 'fa-external-link'
       }

data/lib/sequenceserver/routes.rb

@@ -0,0 +1,163 @@
+require 'json'
+require 'sinatra/base'
+
+module SequenceServer
+  # Controller.
+  class Routes < Sinatra::Base
+    # See
+    # http://www.sinatrarb.com/configuration.html
+    configure do
+      # We don't need Rack::MethodOverride. Let's avoid the overhead.
+      disable :method_override
+
+      # Ensure exceptions never leak out of the app. Exceptions raised within
+      # the app must be handled by the app. We do this by attaching error
+      # blocks to exceptions we know how to handle and attaching to Exception
+      # as fallback.
+      disable :show_exceptions, :raise_errors
+
+      # Make it a policy to dump to 'rack.errors' any exception raised by the
+      # app so that error handlers don't have to do it themselves. But for it
+      # to always work, Exceptions defined by us should not respond to `code`
+      # or http_status` methods. Error blocks errors must explicitly set http
+      # status, if needed, by calling `status` method.
+      # method.
+      enable :dump_errors
+
+      # We don't want Sinatra do setup any loggers for us. We will use our own.
+      set :logging, nil
+
+      # Public, and views directory will be found here.
+      set :root,    lambda { SequenceServer.root }
+    end
+
+    # See
+    # http://www.sinatrarb.com/intro.html#Mime%20Types
+    configure do
+      mime_type :fasta, 'text/fasta'
+      mime_type :xml,   'text/xml'
+      mime_type :tsv,   'text/tsv'
+    end
+
+    configure :production do
+      set :public_folder,
+          lambda { File.join SequenceServer.root, 'public', 'dist' }
+    end
+
+    helpers do
+      # Render an anchor element from the given Hash.
+      #
+      # See links.rb for example of a Hash object that will be rendered.
+      def a(link)
+        return unless link[:title] && link[:url]
+        target = absolute?(link[:url]) && '_blank' || '_self'
+        a =  %(<a href="#{link[:url]}" class="#{link[:class]}" \
+target="#{target}">)
+        a << %(<i class="fa #{link[:icon]}"></i> ) if link[:icon]
+        a << "#{link[:title]}</a>"
+      end
+
+      # Is the given URI absolute? (or relative?)
+      #
+      # Returns false if nil is passed.
+      def absolute?(uri)
+        uri && URI.parse(uri).absolute?
+      end
+
+      # Prettify given data.
+      def prettify(data)
+        return prettify_tuple(data) if tuple? data
+        return prettify_float(data) if data.is_a? Float
+        data
+      end
+
+      # Formats float as "a.bcd" or "a x b^c". The latter if float is
+      # scientific notation. Former otherwise.
+      def prettify_float(float)
+        float.to_s.sub(/(\d*\.\d*)e?([+-]\d*)?/) do
+          base  = Regexp.last_match[1]
+          power = Regexp.last_match[2]
+          s = format '%.2f', base
+          s << " &times; 10<sup>#{power}</sup>" if power
+          s
+        end
+      end
+
+      # Formats an array of two elements as "first (last)".
+      def prettify_tuple(tuple)
+        "#{tuple.first} (#{tuple.last})"
+      end
+
+      # Is the given value a tuple? (array of length two).
+      def tuple?(data)
+        return true if data.is_a?(Array) && data.length == 2
+      end
+    end
+
+    # For any request that hits the app in development mode, log incoming
+    # params.
+    before do
+      logger.debug params
+    end
+
+    # Render the search form.
+    get '/' do
+      erb :search, :locals => { :databases => Database.group_by(&:type) }
+    end
+
+    # BLAST search!
+    post '/' do
+      erb :result, :locals => { :report => BLAST.run(params) }
+    end
+
+    # @params sequence_ids: whitespace separated list of sequence ids to
+    # retrieve
+    # @params database_ids: whitespace separated list of database ids to
+    # retrieve the sequence from.
+    # @params download: whether to return raw response or initiate file
+    # download
+    #
+    # Use whitespace to separate entries in sequence_ids (all other chars exist
+    # in identifiers) and retreival_databases (we don't allow whitespace in a
+    # database's name, so it's safe).
+    get '/get_sequence/' do
+      sequence_ids = params[:sequence_ids].split(/\s/)
+      database_ids = params[:database_ids].split(/\s/)
+
+      sequences = Sequence::Retriever.new(sequence_ids, database_ids,
+                                          params[:download])
+
+      send_file(sequences.file.path,
+                :type     => sequences.mime,
+                :filename => sequences.filename) if params[:download]
+
+      sequences.to_json
+    end
+
+    # Download BLAST report in various formats.
+    get '/download/:search_id.:type' do
+      out = BLAST::Formatter.new(params[:search_id], params[:type])
+      send_file out.file.path, :filename => out.filename, :type => out.mime
+    end
+
+    # This error block will only ever be hit if the user gives us a funny
+    # sequence or incorrect advanced parameter. Well, we could hit this block
+    # if someone is playing around with our HTTP API too.
+    error BLAST::ArgumentError do
+      status 400
+      error = env['sinatra.error']
+      erb :'400', :locals => { :error => error }
+    end
+
+    # This will catch any unhandled error and some very special errors. Ideally
+    # we will never hit this block. If we do, there's a bug in SequenceServer
+    # or something really weird going on. If we hit this error block we show
+    # the stacktrace to the user requesting them to post the same to our Google
+    # Group.
+    error Exception, BLAST::RuntimeError do
+      status 500
+      error = env['sinatra.error']
+      erb :'500', :locals => { :error => error }
+    end
+  end
+end