sequenceserver 0.6.7

data/lib/sequenceserver/helpers.rb

@@ -0,0 +1,127 @@
+require 'sequenceserver/database'
+
+module SequenceServer
+  module Helpers
+    module SystemHelpers
+      # Scan the given directory for blast executables. Passing `nil` scans the
+      # system `PATH`.
+      # ---
+      # Arguments:
+      # * bin(String) - absolute path to the directory containing blast binaries
+      # ---
+      # Returns:
+      # * a hash of blast methods, and their corresponding absolute path
+      # ---
+      # Raises:
+      # * IOError - if the executables can't be found
+      #
+      #   > scan_blast_executables('/home/yeban/bin')
+      #   =>  { "blastx"=>"/home/yeban/bin/blastx",
+      #         "blastn"=>"/home/yeban/bin/blastn",
+      #         ...
+      #       }
+      def scan_blast_executables(bin)
+        if bin and not File.directory?(bin)
+          raise IOError, "Could not find '#{bin}' defined in config.yml."
+        end
+
+        binaries = {}
+        %w|blastn blastp blastx tblastn tblastx blastdbcmd makeblastdb blast_formatter|.each do |method|
+          path = File.join(bin, method) rescue method
+          if command?(path)
+            binaries[method] = path
+          else
+            blasturl = 'http://www.ncbi.nlm.nih.gov/blast/Blast.cgi?CMD=Web&PAGE_TYPE=BlastDocs&DOC_TYPE=Download'
+            raise IOError, "Could not find blast binaries. You may need to
+            install BLAST+ from #{blasturl}. And/or point config.yml to blast's
+            bin directory."
+          end
+        end
+
+        #LOG.info("Config bin dir:          #{bin}")
+        binaries
+      end
+
+      # Scan the given directory (including subdirectory) for blast databases.
+      # ---
+      # Arguments:
+      # * db_root(String) - absolute path to the blast databases
+      # ---
+      # Returns:
+      # * a hash of sorted blast databases grouped by database type:
+      # protein, or nucleotide
+      # ---
+      # Raises:
+      # * IOError - if no database can be found
+      #
+      #   > scan_blast_db('/home/yeban/blast_db')
+      #   => { "protein" => [], "nucleotide" => [] }
+      def scan_blast_db(db_root, blastdbcmd = 'blastdbcmd')
+        raise IOError, "Database directory doesn't exist: #{db_root}" unless File.directory?( db_root )
+
+        find_dbs_command = %|#{blastdbcmd} -recursive -list #{db_root} -list_outfmt "%p %f %t" 2>&1|
+
+        begin
+          db_list = %x|#{find_dbs_command}|
+          if db_list.empty?
+            raise IOError, "No formatted blast databases found in '#{ db_root }'."
+          end
+        rescue => e
+          puts '', e.to_s
+
+          print "Do you want to format your blast databases now? [Y/n]: "
+          choice = gets.chomp[0,1].downcase
+
+          unless choice == 'n'
+            database_formatter = File.join(settings.root, 'database_formatter.rb')
+            system("#{database_formatter} #{db_root}")
+            retry
+          else
+            raise # let the caller decide what to do if database discovery fails
+          end
+        end
+
+        if db_list.match(/BLAST Database error/)
+          raise IOError, "Error parsing blast databases.\n" + "Tried: '#{find_dbs_command}'\n"+
+            "It crashed with the following error: '#{db_list}'\n" +
+            "Try reformatting databases using makeblastdb.\n"
+        end
+
+        db = {}
+
+        db_list.each_line do |line|
+          next if line.empty?  # required for BLAST+ 2.2.22
+          type, name, *title =  line.split(' ') 
+          type = type.downcase
+          name = name.freeze
+          title = title.join(' ').freeze
+          #LOG.info("Found #{type} database: #{title} at #{name}")
+          (db[type] ||= []) << Database.new(name, title)
+        end
+
+
+        # the erb would fail as calling nil.each_with_index if a dbtype was undefined. 
+        db['protein']    = [] unless db.keys.include?('protein')
+        db['nucleotide'] = [] unless db.keys.include?('nucleotide')
+
+        # sort the list of dbs
+        db['protein'].sort!
+        db['nucleotide'].sort!
+
+        db 
+      end
+
+      private
+
+      # check if the given command exists and is executable
+      # returns True if all is good.
+      def command?(command)
+        system("which #{command} > /dev/null 2>&1")
+      end
+    end
+
+    def self.included(klass)
+      klass.extend SystemHelpers
+    end
+  end
+end

data/lib/sequenceserver/sequencehelpers.rb

@@ -0,0 +1,119 @@
+module SequenceServer
+  # Module to collect some sequence-related helper functions
+  module SequenceHelpers
+
+    # copied from bioruby's Bio::Sequence
+    # returns a Hash. Eg: composition("asdfasdfffffasdf")
+    #                      => {"a"=>3, "d"=>3, "f"=>7, "s"=>3}
+    def composition(sequence_string)
+      count = Hash.new(0)
+      sequence_string.scan(/./) do |x|
+        count[x] += 1
+      end
+      return count
+    end
+
+    # Strips all non-letter characters. guestimates sequence based on that.
+    # If less than 10 useable characters... returns nil
+    # If more than 90% ACGTU returns :nucleotide. else returns :protein
+    def guess_sequence_type(sequence_string)
+      cleaned_sequence = sequence_string.gsub(/[^A-Z]/i, '')  # removing non-letter characters
+      cleaned_sequence.gsub!(/[NX]/i, '')                     # removing ambiguous  characters
+
+      return nil if cleaned_sequence.length < 10 # conservative
+
+      composition = composition(cleaned_sequence)       
+      composition_NAs    = composition.select { |character, count|character.match(/[ACGTU]/i) } # only putative NAs
+      putative_NA_counts = composition_NAs.collect { |key_value_array| key_value_array[1] }     # only count, not char
+      putative_NA_sum    = putative_NA_counts.inject { |sum, n| sum + n }                       # count of all putative NA
+      putative_NA_sum    = 0 if putative_NA_sum.nil?
+
+      if putative_NA_sum > (0.9 * cleaned_sequence.length)
+        return :nucleotide
+      else
+        return :protein
+      end
+    end
+
+    # splits input at putative fasta definition lines (like ">adsfadsf"), guesses sequence type for each sequence. 
+    # if not enough sequence to determine, returns nil.
+    # if 2 kinds of sequence mixed together, raises ArgumentError
+    # otherwise, returns :nucleotide or :protein
+    def type_of_sequences(fasta_format_string)
+      # the first sequence does not need to have a fasta definition line
+      sequences = fasta_format_string.split(/^>.*$/).delete_if { |seq| seq.empty? }
+
+      # get all sequence types
+      sequence_types = sequences.collect { |seq|  guess_sequence_type(seq) }.uniq.compact
+
+      return nil if sequence_types.empty?
+
+      if sequence_types.length == 1
+        return sequence_types.first # there is only one (but yes its an array)
+      else 
+        raise ArgumentError, "Insufficient info to determine sequence type. Cleaned queries are: #{ sequences.to_s }"
+      end
+    end
+
+    # Return the database type that can be used for a given blast method.
+    #   db_type_for("blastp")  => :protein
+    #   db_type_for("tblastn") => :nucleotide
+    #   db_type_for(nil)       => nil
+    def db_type_for(blast_method)
+      case blast_method
+      when 'blastp', 'blastx'
+        :protein
+      when 'blastn', 'tblastx', 'tblastn'
+        :nucleotide
+      end
+    end
+
+    # Return the blast methods that can be used for a given type of sequence.
+    #   blast_methods_for(:protein)     => ['blastp', 'tblastn']
+    #   blast_methods_for(:nucleotide)  => ['blastn','tblastx','blastx']
+    #   blast_methods_for(nil)          => ['blastp', 'tblastn','blastn','tblastx','blastx']
+    def blast_methods_for(seq_type)
+      case seq_type
+      when :protein
+        ['blastp', 'tblastn']
+      when :nucleotide
+        ['blastn','tblastx','blastx']
+      else # Sequence type not predicted, so don't make any assumptions about the blast method
+        ['blastp', 'tblastn','blastn','tblastx','blastx']
+      end
+    end
+
+    def sequence_from_blastdb(ids, db)  # helpful when displaying parsed blast results
+      # we know how to handle an Array of ids
+      ids = ids.join(',') if ids.is_a? Array
+
+      # we don't know what to do if the arguments ain't String
+      raise TypeError unless ids.is_a? String and db.is_a? String
+
+      # query now!
+      #
+      # If `blastdbcmd` throws error, we assume sequence not found.
+      blastdbcmd = settings.binaries['blastdbcmd']
+      command = %x|#{blastdbcmd} -db #{db} -entry #{ids} 2> /dev/null|
+    end
+
+    # Given a sequence_id and databases, apply the default (standard)
+    # way to convert a sequence_id into a hyperlink, so that the
+    # blast results include hyperlinks.
+    def construct_standard_sequence_hyperlink(options)
+      if options[:sequence_id].match(/^[^ ]/) #if there is a space right after the '>', makeblastdb was run without -parse_seqids
+        # By default, add a link to a fasta file of the sequence (if makeblastdb was called with -parse_seqids)
+        complete_id = options[:sequence_id][/^(\S+)\s*.*/, 1]  # get id part
+        id = complete_id.include?('|') ? complete_id.split('|')[1] : complete_id.split('|')[0]
+        @all_retrievable_ids ||= []
+        @all_retrievable_ids.push(id)
+
+        link = "/get_sequence/?id=#{id}&db=#{options[:databases].join(' ')}" # several dbs... separate by ' '
+        return link
+      else
+        # do nothing - link == nil means no link will be incorporated
+        return nil
+      end
+    end
+  end
+end

data/lib/sequenceserver/sinatralikeloggerformatter.rb

@@ -0,0 +1,12 @@
+module SequenceServer
+  # We change Logging format so that it is consistent with Sinatra's
+  class SinatraLikeLogFormatter < Logger::Formatter 
+    MyFormat = "[%s] %s  %s\n"
+    def initialize
+      self.datetime_format = "%Y-%m-%d %H:%M:%S" 
+    end
+    def call(severity, time, progname, msg)
+      MyFormat % [format_datetime(time), severity, msg2str(msg)]
+    end
+  end
+end