genevalidator 1.6.12 → 2.1.3

data/lib/genevalidator/validation_blast_reading_frame.rb

@@ -15,7 +15,9 @@ module GeneValidator
 
     def initialize(short_header, header, description, frames,
                    expected = :yes)
-      @short_header, @header, @description = short_header, header, description
+      @short_header = short_header
+      @header = header
+      @description = description
       @frames = frames
       @expected     = expected
       @result       = validation
@@ -70,7 +72,7 @@ module GeneValidator
         count_p += 1 if x > 0
         count_n += 1 if x < 0
       end
-      (count_p > 1 || count_n > 1) ? :no : :yes
+      count_p > 1 || count_n > 1 ? :no : :yes
     end
   end
 
@@ -78,6 +80,9 @@ module GeneValidator
   # This class contains the methods necessary for
   # reading frame validation based on BLAST output
   class BlastReadingFrameValidation < ValidationTest
+    extend Forwardable
+    def_delegators GeneValidator, :opt
+
     def initialize(type, prediction, hits = nil)
       super
       @short_header = 'ReadingFrame'
@@ -100,8 +105,8 @@ module GeneValidator
         return @validation_report
       end
 
-      fail NotEnoughHitsError unless hits.length >= 5
-      fail unless prediction.is_a?(Query) && hits[0].is_a?(Query)
+      raise NotEnoughHitsError if hits.length < opt[:min_blast_hits]
+      raise unless prediction.is_a?(Query) && hits[0].is_a?(Query)
 
       start = Time.now
 
@@ -116,12 +121,11 @@ module GeneValidator
                                                        @description, frames)
       @validation_report.run_time = Time.now - start
       @validation_report
-
     rescue NotEnoughHitsError
-      @validation_report =  ValidationReport.new('Not enough evidence',
-                                                 :warning, @short_header,
-                                                 @header, @description)
-    rescue
+      @validation_report = ValidationReport.new('Not enough evidence',
+                                                :warning, @short_header,
+                                                @header, @description)
+    rescue StandardError
       @validation_report = ValidationReport.new('Unexpected error', :error,
                                                 @short_header, @header,
                                                 @description)

data/lib/genevalidator/validation_duplication.rb

@@ -19,7 +19,9 @@ module GeneValidator
 
     def initialize(short_header, header, description, pvalue, averages,
                    threshold = 0.05, expected = :yes)
-      @short_header, @header, @description = short_header, header, description
+      @short_header = short_header
+      @header = header
+      @description = description
       @pvalue      = pvalue
       @threshold   = threshold
       @result      = validation
@@ -36,7 +38,7 @@ module GeneValidator
 
     def explain
       "The Wilcoxon test produced a p-value of #{prettify_evalue(@pvalue)}" \
-      "#{(@result == :no) ? " (average = #{@average.round(2)})." : '.'}"
+      "#{@result == :no ? " (average = #{@average.round(2)})." : '.'}"
     end
 
     def conclude
@@ -50,15 +52,15 @@ module GeneValidator
     end
 
     def print
-      "#{@pvalue.round(2)}"
+      @pvalue.round(2).to_s
     end
 
     def validation
-      (@pvalue > @threshold) ? :yes : :no
+      @pvalue > @threshold ? :yes : :no
     end
 
     def color
-      (validation == :yes) ? 'success' : 'danger'
+      validation == :yes ? 'success' : 'danger'
     end
 
     private
@@ -97,41 +99,33 @@ module GeneValidator
       @index_file_name   = config[:raw_seq_file_index]
       @raw_seq_file_load = config[:raw_seq_file_load]
       @db                = opt[:db]
-      @num_threads       = opt[:num_threads]
+      @num_threads       = opt[:mafft_threads]
       @type              = config[:type]
     end
 
-    def in_range?(ranges, idx)
-      ranges.each do |range|
-        return (range.member?(idx)) ? true : false
-      end
-      false
-    end
-
     ##
     # Check duplication in the first n hits
     # Output:
     # +DuplicationValidationOutput+ object
     def run(n = 10)
-      fail NotEnoughHitsError unless hits.length >= 5
-      fail unless prediction.is_a?(Query) && !prediction.raw_sequence.nil? &&
-                  hits[0].is_a?(Query)
+      raise NotEnoughHitsError if hits.length < opt[:min_blast_hits]
+      raise unless prediction.is_a?(Query) && !prediction.raw_sequence.nil? &&
+                   hits[0].is_a?(Query)
 
       start = Time.new
       # get the first n hits
-      less_hits = @hits[0..[n - 1, @hits.length].min]
-      useless_hits = []
+      n_hits = [n - 1, @hits.length].min
+      less_hits = @hits[0..n_hits]
       # get raw sequences for less_hits
-      less_hits.map do |hit|
-        next unless hit.raw_sequence.nil?
-        hit.raw_sequence = FetchRawSequences.run(hit.identifier,
-                                                 hit.accession_no)
-        useless_hits.push(hit) if hit.raw_sequence.nil?
+      less_hits.delete_if do |hit|
+        if hit.raw_sequence.nil?
+          hit.raw_sequence = FetchRawSequences.run(hit.identifier,
+                                                   hit.accession_no)
+        end
+        hit.raw_sequence.nil? ? true : false
       end
 
-      useless_hits.each { |hit| less_hits.delete(hit) }
-
-      fail NoInternetError if less_hits.length == 0
+      raise NoInternetError if less_hits.length.zero?
 
       averages = []
 
@@ -146,62 +140,17 @@ module GeneValidator
             hit_alignment   = hsp.hit_alignment
             query_alignment = hsp.query_alignment
           else
-            # indexing in blast starts from 1
-            hit_local   = hit.raw_sequence[hsp.hit_from - 1..hsp.hit_to - 1]
-            query_local = prediction.raw_sequence[hsp.match_query_from -
-                                                  1..hsp.match_query_to - 1]
-
-            # in case of nucleotide prediction sequence translate into protein
-            # use translate with reading frame 1 because
-            # to/from coordinates of the hsp already correspond to the
-            # reading frame in which the prediction was read to match this hsp
-            if @type == :nucleotide
-              s = Bio::Sequence::NA.new(query_local)
-              query_local = s.translate
-            end
-
-            # local alignment for hit and query
-            seqs = [hit_local, query_local]
-
-            begin
-              options   = ['--maxiterate', '1000', '--localpair', '--anysymbol',
-                           '--quiet', '--thread', "#{@num_threads}"]
-              mafft     = Bio::MAFFT.new('mafft', options)
-
-              report    = mafft.query_align(seqs)
-              raw_align = report.alignment
-              align     = []
-
-              raw_align.each { |seq| align.push(seq.to_s) }
-              hit_alignment   = align[0]
-              query_alignment = align[1]
-            rescue
-              raise NoMafftInstallationError
-            end
+            align = find_local_alignment(hit, prediction, hsp)
+            hit_alignment   = align[0]
+            query_alignment = align[1]
           end
 
-          # check multiple coverage
-
-          # for each hsp of the curent hit
-          # iterate through the alignment and count the matching residues
-          [*(0..hit_alignment.length - 1)].each do |i|
-            residue_hit   = hit_alignment[i]
-            residue_query = query_alignment[i]
-            next if residue_hit == ' ' || residue_hit == '+' ||
-                    residue_hit == '-' || residue_hit != residue_query
-            # indexing in blast starts from 1
-            idx_hit   = i + (hsp.hit_from - 1) -
-                        hit_alignment[0..i].scan(/-/).length
-            idx_query = i + (hsp.match_query_from - 1) -
-                        query_alignment[0..i].scan(/-/).length
-            unless in_range?(ranges_prediction, idx_query)
-              coverage[idx_hit] += 1
-            end
-          end
+          coverage = check_multiple_coverage(hit_alignment, query_alignment,
+                                             hsp, coverage, ranges_prediction)
 
-          ranges_prediction.push((hsp.match_query_from..hsp.match_query_to))
+          ranges_prediction << (hsp.match_query_from..hsp.match_query_to)
         end
-        overlap = coverage.reject { |x| x == 0 }
+        overlap = coverage.reject(&:zero?)
         if overlap != []
           averages.push((overlap.inject(:+) / (overlap.length + 0.0)).round(2))
         end
@@ -225,7 +174,6 @@ module GeneValidator
                                                            averages)
       @run_time = Time.now - start
       @validation_report
-
     rescue NotEnoughHitsError
       @validation_report = ValidationReport.new('Not enough evidence', :warning,
                                                 @short_header, @header,
@@ -240,22 +188,75 @@ module GeneValidator
                                                 @short_header, @header,
                                                 @description)
       @validation_report.errors.push NoInternetError
-    rescue
+    rescue StandardError
       @validation_report = ValidationReport.new('Unexpected error', :error,
                                                 @short_header, @header,
                                                 @description)
       @validation_report.errors.push 'Unexpected Error'
     end
 
+    # Only run if the BLAST output does not contain hit alignmment
+    def find_local_alignment(hit, prediction, hsp)
+      # indexing in blast starts from 1
+      hit_local   = hit.raw_sequence[hsp.hit_from - 1..hsp.hit_to - 1]
+      query_local = prediction.raw_sequence[hsp.match_query_from -
+                                            1..hsp.match_query_to - 1]
+
+      # in case of nucleotide prediction sequence translate into protein
+      # use translate with reading frame 1 because
+      # to/from coordinates of the hsp already correspond to the
+      # reading frame in which the prediction was read to match this hsp
+      if @type == :nucleotide
+        s = Bio::Sequence::NA.new(query_local)
+        query_local = s.translate
+      end
+
+      opt = ['--maxiterate', '1000', '--localpair', '--anysymbol', '--quiet',
+             '--thread', @num_threads.to_s]
+      mafft = Bio::MAFFT.new('mafft', opt)
+
+      # local alignment for hit and query
+      seqs = [hit_local, query_local]
+      report = mafft.query_align(seqs)
+      report.alignment.map(&:to_s)
+    rescue StandardError
+      raise NoMafftInstallationError
+    end
+
+    def check_multiple_coverage(hit_alignment, query_alignment, hsp, coverage,
+                                ranges_prediction)
+      # for each hsp of the curent hit
+      # iterate through the alignment and count the matching residues
+      [*(0..hit_alignment.length - 1)].each do |i|
+        residue_hit   = hit_alignment[i]
+        residue_query = query_alignment[i]
+        next if [' ', '+', '-'].include?(residue_hit)
+        next if residue_hit != residue_query
+        # indexing in blast starts from 1
+        idx_hit   = i + (hsp.hit_from - 1) -
+                    hit_alignment[0..i].scan(/-/).length
+        idx_query = i + (hsp.match_query_from - 1) -
+                    query_alignment[0..i].scan(/-/).length
+        coverage[idx_hit] += 1 unless in_range?(ranges_prediction, idx_query)
+      end
+      coverage
+    end
+
+    def in_range?(ranges, idx)
+      ranges.each { |range| return true if range.member?(idx) }
+      false
+    end
+
     ##
     # wilcox test implementation from statsample ruby gem
     # many thanks to Claudio for helping us with the implementation!
     def wilcox_test(averages)
-      wilcox = Statsample::Test.wilcoxon_signed_rank(Daru::Vector.new(averages),
-                                                     Daru::Vector.new(Array.new(averages.length,
-                                                               1)))
+      wilcox = Statsample::Test.wilcoxon_signed_rank(
+        Daru::Vector.new(averages),
+        Daru::Vector.new(Array.new(averages.length, 1))
+      )
 
-      (averages.length < 15) ? wilcox.probability_exact : wilcox.probability_z
+      averages.length < 15 ? wilcox.probability_exact : wilcox.probability_z
     end
   end
 end

data/lib/genevalidator/validation_gene_merge.rb

@@ -22,7 +22,9 @@ module GeneValidator
 
     def initialize(short_header, header, description, slope, unimodality,
                    expected = :no)
-      @short_header, @header, @description = short_header, header, description
+      @short_header = short_header
+      @header = header
+      @description = description
       @slope          = slope.round(1)
       @slope          = @slope.abs if @slope == -0.0
       @unimodality    = unimodality
@@ -56,30 +58,30 @@ module GeneValidator
       if @unimodality
         'This suggest that the query sequence represents a single gene.'
       else
-        diff = (@result == :yes) ? ' within' : ' outside'
+        diff = @result == :yes ? ' within' : ' outside'
         t = "This slope is #{diff} our empirically calculated thresholds" \
             ' (0.4 and 1.2).'
-        if @result == :yes
-          t << ' This suggests the query contains sequence from two or more' \
-               ' different genes.'
-        else
-          t << ' There is no evidence that the query contains sequence from' \
-               ' multiple genes.'
-        end
+        t << if @result == :yes
+               ' This suggests the query contains sequence from two or more' \
+                    ' different genes.'
+             else
+               ' There is no evidence that the query contains sequence from' \
+                    ' multiple genes.'
+             end
         t
       end
     end
 
     def print
-      (@slope.nan?) ? 'Inf' : "#{@slope}"
+      @slope.nan? ? 'Inf' : @slope.to_s
     end
 
     def validation
-      (@slope > threshold_down && @slope < threshold_up) ? :yes : :no
+      @slope > threshold_down && @slope < threshold_up ? :yes : :no
     end
 
     def color
-      (validation == :no) ? 'success' : 'danger'
+      validation == :no ? 'success' : 'danger'
     end
   end
 
@@ -88,6 +90,9 @@ module GeneValidator
   # checking whether there is evidence that the
   # prediction is a merge of multiple genes
   class GeneMergeValidation < ValidationTest
+    extend Forwardable
+    def_delegators GeneValidator, :opt
+
     attr_reader :prediction
     attr_reader :hits
 
@@ -113,18 +118,20 @@ module GeneValidator
     # Output:
     # +GeneMergeValidationOutput+ object
     def run
-      fail NotEnoughHitsError unless hits.length >= 5
-      fail unless prediction.is_a?(Query) && hits[0].is_a?(Query)
+      raise NotEnoughHitsError if hits.length < opt[:min_blast_hits]
+      raise unless prediction.is_a?(Query) && hits[0].is_a?(Query)
 
       start = Time.now
 
-      pairs = hits.map { |hit| Pair.new(hit.hsp_list.map{ |hsp| hsp.match_query_from }.min,
-                                        hit.hsp_list.map{ |hsp| hsp.match_query_to }.max) }
+      pairs = hits.map do |hit|
+        Pair.new(hit.hsp_list.map(&:match_query_from).min,
+                 hit.hsp_list.map(&:match_query_to).max)
+      end
       xx_0 = pairs.map(&:x)
       yy_0 = pairs.map(&:y)
 
       # minimum start shoud be at 'boundary' residues
-      xx = xx_0.map { |x| (x < @boundary) ? @boundary : x }
+      xx = xx_0.map { |x| x < @boundary ? @boundary : x }
 
       # maximum end should be at length - 'boundary' residues
       yy = yy_0.map do |y|
@@ -151,23 +158,22 @@ module GeneValidator
       @validation_report = GeneMergeValidationOutput.new(@short_header, @header,
                                                          @description, lm_slope,
                                                          unimodality)
-      if unimodality
-        plot1 = plot_2d_start_from
-      else
-        plot1 = plot_2d_start_from(lm_slope, y_intercept)
-      end
+      plot1 = if unimodality
+                plot_2d_start_from
+              else
+                plot_2d_start_from(lm_slope, y_intercept)
+              end
 
       @validation_report.plot_files.push(plot1)
       plot2 = plot_matched_regions
       @validation_report.plot_files.push(plot2)
       @validation_report.run_time = Time.now - start
       @validation_report
-
     rescue NotEnoughHitsError
       @validation_report = ValidationReport.new('Not enough evidence', :warning,
                                                 @short_header, @header,
                                                 @description)
-    rescue
+    rescue StandardError
       @validation_report = ValidationReport.new('Unexpected error', :error,
                                                 @short_header, @header,
                                                 @description)
@@ -186,18 +192,21 @@ module GeneValidator
 
       hits_less = hits[0..[no_lines, hits.length - 1].min]
 
-      data = hits_less.each_with_index.map { |hit, i|
+      data = hits_less.each_with_index.map do |hit, i|
         { 'y' => i,
           'start' => hit.hsp_list.map(&:match_query_from).min,
           'stop' => hit.hsp_list.map(&:match_query_to).max,
           'color' => 'black',
-          'dotted' => 'true' } }.flatten +
-        hits_less.each_with_index.map { |hit, i|
-          hit.hsp_list.map { |hsp|
-            { 'y' => i,
-              'start' => hsp.match_query_from,
-              'stop' => hsp.match_query_to,
-              'color' => 'orange' } } }.flatten
+          'dotted' => 'true' }
+      end .flatten +
+             hits_less.each_with_index.map do |hit, i|
+               hit.hsp_list.map do |hsp|
+                 { 'y' => i,
+                   'start' => hsp.match_query_from,
+                   'stop' => hsp.match_query_to,
+                   'color' => 'orange' }
+               end
+             end .flatten
 
       Plot.new(data,
                :lines,
@@ -223,9 +232,11 @@ module GeneValidator
                  hit.hsp_list.map(&:match_query_to).max)
       end
 
-      data = hits.map { |hit| { 'x' => hit.hsp_list.map(&:match_query_from).min,
-                                'y' => hit.hsp_list.map(&:match_query_to).max,
-                                'color' => 'red' } }
+      data = hits.map do |hit|
+        { 'x' => hit.hsp_list.map(&:match_query_from).min,
+          'y' => hit.hsp_list.map(&:match_query_to).max,
+          'color' => 'red' }
+      end
 
       Plot.new(data,
                :scatter,