quorum 0.7.1 → 0.8.0

data/app/models/quorum/job.rb

@@ -3,8 +3,6 @@ module Quorum
 
     include Quorum::Sequence
 
-    after_save :queue_workers
-
     has_one :blastn_job, :dependent => :destroy
     has_many :blastn_job_reports, :through => :blastn_job,
       :dependent => :destroy
@@ -34,33 +32,72 @@ module Quorum
     validate :filter_input_sequences, :algorithm_selected, :sequence_size
 
     #
-    # Fetch Blast hit_id, hit_display_id, queue Resque worker and
-    # return worker's meta_id.
+    # Return search results (Resque worker results).
     #
-    def fetch_quorum_blast_sequence(algo, algo_id)
-      job         = "#{algo}_job".to_sym
-      job_reports = "#{algo}_job_reports".to_sym
-
-      blast_dbs = self.method(job).call.blast_dbs
-
-      job_report = self.method(job_reports).call.where(
-        "quorum_#{algo}_job_reports.id = ?", algo_id
-      ).first
-
-      hit_id          = job_report.hit_id
-      hit_display_id  = job_report.hit_display_id
-
-      cmd = Workers::System.create_blast_fetch_command(
-        blast_dbs, hit_id, hit_display_id, algo
-      )
+    def self.search(params)
+      data = JobData.new
+
+      # Allow for multiple algos and search params.
+      # Ex: /quorum/jobs/:id/search?algo=blastn,blastp
+      if params[:algo]
+        params[:algo].split(",").each do |a|
+          if Quorum::SUPPORTED_ALGORITHMS.include?(a)
+            enqueued = "#{a}_job".to_sym
+            report   = "#{a}_job_reports".to_sym
+            begin
+              job = Job.find(params[:id])
+            rescue ActiveRecord::RecordNotFound => e
+              logger.error e.message
+            else
+              if job.try(enqueued).present?
+                if job.try(report).present?
+                  data.results << job.try(report).search(a, params).default_order
+                else
+                  data = JobData.new
+                end
+              else
+                data.not_enqueued
+              end
+            end
+          end
+        end
+      else
+        data.no_results
+      end
 
-      data = Workers::System.enqueue(
-        cmd, Quorum.blast_remote,
-        Quorum.blast_ssh_host, Quorum.blast_ssh_user,
-        Quorum.blast_ssh_options, true
-      )
+      data.results
+    end
 
-      Workers::System.get_meta(data.meta_id)
+    #
+    # Fetch Blast hit_id, hit_display_id, queue Resque worker and
+    # return worker's meta_id.
+    #
+    def self.set_blast_hit_sequence_lookup_values(params)
+      fetch_data   = JobFetchData.new
+      algo         = params[:algo]
+      algo_id      = params[:algo_id]
+
+      if Quorum::SUPPORTED_ALGORITHMS.include?(algo)
+        fetch_data.algo = algo
+        begin
+          job = Job.find(params[:id])
+        rescue ActiveRecord::RecordNotFound => e
+          logger.error e.message
+        else
+          algo_job         = "#{algo}_job".to_sym
+          algo_job_reports = "#{algo}_job_reports".to_sym
+
+          fetch_data.blast_dbs = job.try(algo_job).blast_dbs
+
+          job_report = job.try(algo_job_reports).where(
+            "quorum_#{algo}_job_reports.id = ?", algo_id
+          ).first
+
+          fetch_data.hit_id          = job_report.hit_id
+          fetch_data.hit_display_id  = job_report.hit_display_id
+        end
+      end
+      fetch_data
     end
 
     #
@@ -84,7 +121,7 @@ module Quorum
       # Ensure the sequences are in plain text.
       begin
         ActiveSupport::Multibyte::Unicode.u_unpack(self.sequence)
-      rescue ActiveSupport::Multibyte::EncodingError => e
+      rescue Exception => e
         logger.error e.message
         errors.add(
           :sequence,
@@ -164,34 +201,5 @@ module Quorum
       end
     end
 
-    #
-    # Queue Resque workers.
-    #
-    def queue_workers
-      jobs = []
-      if self.blastn_job && self.blastn_job.queue
-        jobs << Workers::System.create_search_command("blastn", self.id)
-      end
-      if self.blastx_job && self.blastx_job.queue
-        jobs << Workers::System.create_search_command("blastx", self.id)
-      end
-      if self.tblastn_job && self.tblastn_job.queue
-        jobs << Workers::System.create_search_command("tblastn", self.id)
-      end
-      if self.blastp_job && self.blastp_job.queue
-        jobs << Workers::System.create_search_command("blastp", self.id)
-      end
-
-      unless jobs.blank?
-        jobs.each do |j|
-          Workers::System.enqueue(
-            j, Quorum.blast_remote,
-            Quorum.blast_ssh_host, Quorum.blast_ssh_user,
-            Quorum.blast_ssh_options
-          )
-        end
-      end
-    end
-
   end
 end

data/app/models/quorum/job_data.rb

@@ -0,0 +1,22 @@
+module Quorum
+  class JobData
+
+    def initialize
+      @data = []
+    end
+
+    def results
+      @data
+    end
+
+    def no_results
+      @data = [{ results: false }]
+    end
+
+    def not_enqueued
+      no_results
+      @data = [{ enqueued: false }.merge(@data[0])]
+    end
+
+  end
+end

data/app/models/quorum/job_fetch_data.rb

@@ -0,0 +1,11 @@
+module Quorum
+  class JobFetchData
+
+    include ActiveModel::Validations
+
+    attr_accessor :algo, :blast_dbs, :hit_id, :hit_display_id
+
+    validates_presence_of :algo, :blast_dbs, :hit_id, :hit_display_id
+
+  end
+end

data/app/models/quorum/job_queue_observer.rb

@@ -0,0 +1,11 @@
+module Quorum
+  class JobQueueObserver < ActiveRecord::Observer
+
+    observe Quorum::Job
+
+    def after_create(job)
+      Quorum::JobQueueService.queue_search_workers(job)
+    end
+
+  end
+end

data/app/models/quorum/job_queue_service.rb

@@ -0,0 +1,66 @@
+module Quorum
+  class JobQueueService
+
+    #
+    # Queue search workers.
+    #
+    def self.queue_search_workers(job)
+      blast_jobs = []
+      if job.blastn_job && job.blastn_job.queue
+        blast_jobs << Workers::System.create_search_command("blastn", job.id)
+      end
+      if job.blastx_job && job.blastx_job.queue
+        blast_jobs << Workers::System.create_search_command("blastx", job.id)
+      end
+      if job.tblastn_job && job.tblastn_job.queue
+        blast_jobs << Workers::System.create_search_command("tblastn", job.id)
+      end
+      if job.blastp_job && job.blastp_job.queue
+        blast_jobs << Workers::System.create_search_command("blastp", job.id)
+      end
+
+      unless blast_jobs.blank?
+        blast_jobs.each do |b|
+          Workers::System.enqueue(
+            b,
+            Quorum.blast_remote,
+            Quorum.blast_ssh_host,
+            Quorum.blast_ssh_user,
+            Quorum.blast_ssh_options
+          )
+        end
+      end
+    end
+
+    #
+    # Queue fetch worker to send blast hit sequence. Return job meta_id for
+    # for data access.
+    #
+    # See JobsController#send_blast_hit_sequence for more info.
+    #
+    def self.queue_fetch_worker(fetch_data)
+      unless fetch_data.valid?
+        return nil
+      end
+
+      cmd = Workers::System.create_blast_fetch_command(
+        fetch_data.blast_dbs,
+        fetch_data.hit_id,
+        fetch_data.hit_display_id,
+        fetch_data.algo
+      )
+
+      data = Workers::System.enqueue(
+        cmd,
+        Quorum.blast_remote,
+        Quorum.blast_ssh_host,
+        Quorum.blast_ssh_user,
+        Quorum.blast_ssh_options,
+        true
+      )
+
+      [{ meta_id: data.meta_id }]
+    end
+
+  end
+end

data/app/models/quorum/job_report_searcher.rb

@@ -0,0 +1,36 @@
+module Quorum
+  module JobReportSearcher
+
+    #
+    # Simple search interface on query, id and job id for job reports.
+    #
+    def search(algo, params)
+      algo.downcase!
+      klass = "quorum/#{algo}_job_report".camelize.constantize
+      if params[:"#{algo}_id"].present? && params[:query].present?
+        klass.where(
+          "quorum_#{algo}_job_reports.id IN (?) AND query = ? " <<
+          "AND #{algo}_job_id = ?",
+          params[:"#{algo}_id"].split(","),
+          params[:query],
+          params[:id]
+        )
+      elsif params[:"#{algo}_id"].present?
+        klass.where(
+          "quorum_#{algo}_job_reports.id IN (?) AND #{algo}_job_id = ? ",
+          params[:"#{algo}_id"].split(","),
+          params[:id]
+        )
+      elsif params[:query].present?
+        klass.where(
+          "query = ? AND #{algo}_job_id = ?",
+          params[:query],
+          params[:id]
+        )
+      else
+        klass.where("#{algo}_job_id = ?", params[:id])
+      end
+    end
+
+  end
+end

data/app/models/quorum/job_serializer.rb

@@ -0,0 +1,96 @@
+module Quorum
+  module JobSerializer
+
+    #
+    # Convert jobs to json. Uses Rails default.
+    #
+    def self.as_json(job)
+      if job.respond_to?(:errors) && job.errors.present?
+        { errors: job.errors.full_messages }
+      else
+        job.as_json(root: false)
+      end
+    end
+
+    #
+    # Convert jobs to tab delimited output.
+    #
+    def self.as_txt(job)
+      txt = ""
+      values = [
+        "query",
+        "hit_display_id",
+        "pct_identity",
+        "align_len",
+        "mismatch",
+        "gaps",
+        "query_from",
+        "query_to",
+        "hit_from",
+        "hit_to",
+        "evalue",
+        "bit_score"
+      ]
+
+      job.each do |j|
+        txt << j.attributes.values_at(*values).join("\t") << "\n"
+      end
+      txt
+    end
+
+    #
+    # Convert jobs to GFF.
+    #
+    def self.as_gff(job)
+      pragma = "##gff-version 3\n"
+      source = "."
+      type   = "match"
+      phase  = "."
+      txt    = ""
+      job.each do |j|
+        if j.results
+          # Add sequence-region.
+          unless pragma.include?(j.hit_display_id)
+            pragma << "##sequence-region #{j.hit_display_id} 1 #{j.hit_len}\n"
+          end
+
+          start, stop = j.hit_from, j.hit_to
+
+          # Set the strand based on the original start, stop.
+          start > stop ? strand = "-" : strand = "+"
+          # Format the start, stop for GFF.
+          start, stop = format_hit_start_stop(start, stop)
+
+          values = [
+            j.hit_display_id,
+            source,
+            type,
+            start,
+            stop,
+            j.evalue,
+            strand,
+            phase
+          ]
+
+          txt << values.join("\t") << "\tTarget=#{j.query} " <<
+            "#{j.query_from} #{j.query_to};Name=#{j.query};" <<
+            "identity=#{j.pct_identity};rawscore=#{j.score};" <<
+            "significance=#{j.evalue}\n"
+        end
+      end
+      txt.insert(0, pragma)
+    end
+
+    #
+    # Start must be <= to stop.
+    #
+    def self.format_hit_start_stop(start, stop)
+      tmp_start, tmp_stop = start, stop
+      if start > stop
+        tmp_start, tmp_stop = stop, start
+      end
+      return tmp_start, tmp_stop
+    end
+
+  end
+end

data/app/models/quorum/tblastn_job.rb

@@ -17,7 +17,7 @@ module Quorum
       :blast_dbs
 
     validates_format_of :expectation,
-      :with        => /^[+-]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/,
+      :with        => /\A[+-]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?\z/,
       :message     => " - Valid formats (12, 32.05, 43e-123)",
       :allow_blank => true
     validates_numericality_of :max_target_seqs,

data/app/models/quorum/tblastn_job_report.rb

@@ -1,7 +1,10 @@
 module Quorum
   class TblastnJobReport < ActiveRecord::Base
+
+    extend Quorum::JobReportSearcher
+
     belongs_to :tblastn_job
     scope :default_order, order("query ASC, bit_score DESC")
-    scope :by_query, lambda { |query| where("query = ?", query) }
+
   end
 end

data/app/views/quorum/jobs/show.html.erb

@@ -79,6 +79,9 @@
     //      // awesome logic
     //    };
     //
+    //  See https://github.com/ncgr/lis_sequence_search for a complete example
+    //  using d3.js (http://d3js.org/).
+    //
     QUORUM.pollResults();
   });
 </script>

data/app/views/quorum/jobs/templates/_blast_detailed_report_template.html.erb

@@ -29,7 +29,7 @@
         </tr>
       </table>
       <p class="small">
-        <a id="download_sequence_{{= v.id }}"
+        <a class="download_sequence" id="download_sequence_{{= v.id }}"
           onclick="QUORUM.downloadSequence({{= v.id }}, '{{= algo }}', this)">
           Download Sequence
         </a>

data/app/views/quorum/jobs/templates/_blast_template.html.erb

@@ -1,6 +1,8 @@
 <%# Blast Results Template %>
 <script type="text/template" id="blast_template">
-  {{ if (data[0].results === false) { }}
+  {{ if (data[0].enqueued === false) { }}
+    <p><strong>Not enqueued.</strong></p>
+  {{ } else if (data[0].results === false) { }}
     <p><strong>Your search returned 0 hits.</strong></p>
   {{ } else { }}
     <table class="results">

data/config/initializers/mime_types.rb

@@ -0,0 +1,2 @@
+Mime::Type.register "text/plain", :gff
+Mime::Type.register "text/plain", :txt

data/config/routes.rb

@@ -1,9 +1,9 @@
 Quorum::Engine.routes.draw do
   resources :jobs, :only => [:index, :show, :new, :create] do
     member do
-      get :get_quorum_search_results
-      get :get_quorum_blast_hit_sequence
-      get :send_quorum_blast_hit_sequence
+      get :search, :defaults => { :format => 'json' }
+      get :get_blast_hit_sequence, :defaults => { :format => 'json' }
+      get :send_blast_hit_sequence
     end
   end
 

data/db/migrate/20120809155712_add_percent_identity_to_blast_reports.rb

@@ -0,0 +1,8 @@
+class AddPercentIdentityToBlastReports < ActiveRecord::Migration
+  def change
+    add_column :quorum_blastn_job_reports, :pct_identity, :float
+    add_column :quorum_blastx_job_reports, :pct_identity, :float
+    add_column :quorum_tblastn_job_reports, :pct_identity, :float
+    add_column :quorum_blastp_job_reports, :pct_identity, :float
+  end
+end

data/db/migrate/20120921182416_add_mismatch_to_blast_reports.rb

@@ -0,0 +1,8 @@
+class AddMismatchToBlastReports < ActiveRecord::Migration
+  def change
+    add_column :quorum_blastn_job_reports, :mismatch, :integer
+    add_column :quorum_blastx_job_reports, :mismatch, :integer
+    add_column :quorum_tblastn_job_reports, :mismatch, :integer
+    add_column :quorum_blastp_job_reports, :mismatch, :integer
+  end
+end

data/lib/generators/templates/blast.rb

@@ -364,12 +364,19 @@ module Quorum
                 @data[:hseq]        = hsp.hseq
                 @data[:midline]     = hsp.midline
 
+                # Calculate percent identity
+                @data[:pct_identity] = (
+                  @data[:identity].to_f / @data[:align_len].to_f
+                ) * 100
+
+                # Calculate mismatch
+                @data[:mismatch] = @data[:align_len] - @data[:identity]
+
                 if @data[:bit_score] &&
                   (@data[:bit_score].to_i > @min_score.to_i)
                   @results = true
                   save_hsp_results
                 end
-
               end
             end
           end

data/lib/quorum/engine.rb

@@ -1,5 +1,7 @@
 module Quorum
   class Engine < Rails::Engine
     isolate_namespace Quorum
+
+    config.active_record.observers = "Quorum::JobQueueObserver"
   end
 end

data/lib/quorum/sequence.rb

@@ -86,5 +86,40 @@ module Quorum
       type
     end
 
+
+    #
+    # Send sequence data to the browser.
+    #
+    module SendSequence
+
+      def sequence(data)
+        @data = data
+        if @data.respond_to?(:succeeded?) && @data.succeeded?
+          if self.has_error?
+            return self.render_error
+          else
+            return send_data @data.result,
+              :filename     => @data.meta_id,
+              :type         => "text/plain",
+              :disposition  => "attachment"
+          end
+        end
+        self.render_empty
+      end
+
+      def has_error?
+        @data.result.downcase.include?("error")
+      end
+
+      def render_error
+        render :text => @data.result
+      end
+
+      def render_empty
+        render :text => ""
+      end
+
+    end
+
   end
 end

data/lib/quorum/version.rb

@@ -1,3 +1,3 @@
 module Quorum
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

data/lib/quorum.rb

@@ -11,16 +11,15 @@ require "workers/system"
 module Quorum
 
   ## Supported Algorithms ##
-  BLAST_ALGORITHMS = ["blastn", "blastx", "blastp", "tblastn"].freeze
+  BLAST_ALGORITHMS     = ["blastn", "blastx", "blastp", "tblastn"].freeze
+  SUPPORTED_ALGORITHMS = [BLAST_ALGORITHMS]
+  SUPPORTED_ALGORITHMS.flatten!
 
   mattr_accessor :max_sequence_size, :blast_remote, :blast_ssh_host,
                  :blast_ssh_user, :blast_ssh_options, :blast_bin,
                  :blast_log_dir, :blast_tmp_dir, :blast_db, :tblastn,
                  :blastp, :blastn, :blastx, :blast_threads
 
-  ## Deprecated ##
-  mattr_accessor :blast_script
-
   class << self
 
     ## General ##
@@ -97,12 +96,6 @@ module Quorum
       @@blast_threads || 1
     end
 
-    ## Blast Deprecated ##
-
-    def blast_script
-      nil
-    end
-
   end
 
 end

data/lib/tasks/quorum_blastdb_build.rake

@@ -40,7 +40,9 @@ namespace :quorum do
       args[:nucl_file] = "NULL" if args[:type] == "prot"
       args[:prot_file] = "NULL" if args[:type] == "nucl"
 
-      puts "Building your Blast database(s). This may take a while..."
+      unless args[:empty]
+        puts "Building your Blast database(s). This may take a while..."
+      end
 
       build = Quorum::BuildBlastDB.new(args)
       build.build_blast_db_data

data/lib/workers/system.rb

@@ -94,8 +94,10 @@ module Workers
     def self.create_search_command(algo, id)
       # System command
       cmd = ""
+      return cmd unless Quorum::SUPPORTED_ALGORITHMS.include?(algo)
 
-      if Quorum::BLAST_ALGORITHMS.include?(algo)
+      case
+      when Quorum::BLAST_ALGORITHMS.include?(algo)
         search = File.join(Quorum.blast_bin, "search")
         cmd << "#{search} -l #{Quorum.blast_log_dir} " <<
           "-m #{Quorum.blast_tmp_dir} -b #{Quorum.blast_db} " <<

data/quorum.gemspec

@@ -23,6 +23,7 @@ Gem::Specification.new do |s|
   s.add_dependency "bio-blastxmlparser", "~> 1.1.0"
 
   s.add_development_dependency "mysql2", "~> 0.3.11"
+  s.add_development_dependency "pg", "~> 0.14.1"
   s.add_development_dependency "rspec-rails", "~> 2.11"
   s.add_development_dependency "resque_spec", "~> 0.12"
   s.add_development_dependency "capybara", "~> 1.1"

data/spec/dummy/config/environment.rb

@@ -4,17 +4,30 @@ require File.expand_path('../application', __FILE__)
 # Initialize the rails application
 Dummy::Application.initialize!
 
-## Explicitly remove AR transactions during tests ##
+## Explicitly remove MySQL AR transactions during tests ##
 if Rails.env.test?
   # Force the loading of AR stuff
   ActiveRecord::Base.connection.execute('SELECT 1')
 
-  # Remove transactions
-  ActiveRecord::ConnectionAdapters::Mysql2Adapter.class_eval do
-    def begin_db_transaction
+  if ENV['DB'] == 'mysql'
+    # Remove transactions
+    ActiveRecord::ConnectionAdapters::Mysql2Adapter.class_eval do
+      def begin_db_transaction
+      end
+
+      def commit_db_transaction
+      end
     end
+  end
+
+  if ENV['DB'] == 'postgresql'
+    # Remove transactions
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+      def begin_db_transaction
+      end
 
-    def commit_db_transaction
+      def commit_db_transaction
+      end
     end
   end
 end