genevalidator 1.6.12 → 2.1.3

data/lib/genevalidator/output.rb

@@ -1,15 +1,10 @@
-require 'erb'
-require 'fileutils'
 require 'forwardable'
 require 'json'
 
-require 'genevalidator/version'
-
 module GeneValidator
   class Output
     extend Forwardable
-    def_delegators GeneValidator, :opt, :config, :mutex, :mutex_html,
-                   :mutex_json
+    def_delegators GeneValidator, :opt, :config, :dirs, :mutex
     attr_accessor :prediction_def
     attr_accessor :nr_hits
 
@@ -27,9 +22,12 @@ module GeneValidator
     # Params:
     # +current_idx+: index of the current query
     def initialize(current_idx, no_of_hits, definition)
-      @opt            = opt
-      @config         = config
+      @opt             = opt
+      @dirs            = dirs
+      @config          = config
       @config[:run_no] += 1
+      output_dir       = @dirs[:output_dir]
+      @output_filename = File.join(output_dir, "#{@dirs[:filename]}_results")
 
       @prediction_def = definition
       @nr_hits        = no_of_hits
@@ -37,62 +35,38 @@ module GeneValidator
     end
 
     def print_output_console
+      return unless @opt[:output_formats].include? 'stdout'
+      c_fmt = "%3s\t%5s\t%20s\t%7s\t"
       mutex.synchronize do
-        print_console_header unless @config[:console_header_printed]
-        short_def = @prediction_def.scan(/([^ ]+)/)[0][0]
-        print format("%3s\t%5s\t%20s\t%7s\t", @idx, @overall_score, short_def,
-                     @nr_hits)
+        print_console_header(c_fmt)
+        short_def = @prediction_def.split(' ')[0]
+        print format(c_fmt, @idx, @overall_score, short_def, @nr_hits)
         puts validations.map(&:print).join("\t").gsub(' ', ' ')
       end
     end
 
-    def print_console_header
-      @config[:console_header_printed] = true
-      print format("%3s\t%5s\t%20s\t%7s\t", 'No', 'Score', 'Identifier',
-                   'No_Hits')
-      puts validations.map(&:short_header).join("\t")
-    end
-
-    def generate_html
-      mutex_html.synchronize do
-        output_html   = output_filename
-        query_erb     = File.join(@config[:aux], 'template_query.erb')
-        template_file = File.open(query_erb, 'r').read
-        erb           = ERB.new(template_file, 0, '>')
-        File.open(output_html, 'a') { |f| f.write(erb.result(binding)) }
-      end
-    end
-
-    def output_filename
-      idx         = (@config[:run_no].to_f / @config[:output_max]).ceil
-      output_html = File.join(@config[:html_path], "results#{idx}.html")
-      write_html_header(output_html)
-      output_html
-    end
-
-    def write_html_header(output_html)
-      head_erb       = File.join(@config[:aux], 'template_header.erb')
-      set_up_html(head_erb, output_html) unless File.exist?(output_html)
+    def generate_json
+      fname = File.join(@dirs[:json_dir], "#{@dirs[:filename]}_#{@idx}.json")
+      row_data = { idx: @idx, overall_score: @overall_score,
+                   definition: @prediction_def, no_hits: @nr_hits }
+      row = create_validation_hash(row_data)
+      arr_idx = @idx - 1
+      @config[:json_output][arr_idx] = row
+      File.open(fname, 'w') { |f| f.write(row.to_json) }
     end
 
-    def set_up_html(erb_file, output_file)
-      return if File.exist?(output_file)
-      template_contents = File.open(erb_file, 'r').read
-      erb               = ERB.new(template_contents, 0, '>')
-      File.open(output_file, 'w+') { |f| f.write(erb.result(binding)) }
-    end
+    private
 
-    def generate_json
-      mutex_json.synchronize do
-        row = { idx: @idx, overall_score: @overall_score,
-                definition: @prediction_def, no_hits: @nr_hits }
-        row = create_validation_hashes(row)
-        write_row_json(row)
-        @config[:json_output] << row
-      end
+    def print_console_header(c_fmt)
+      return if @config[:console_header_printed]
+      @config[:console_header_printed] = true
+      warn '==> Validating input sequences'
+      warn '' # blank line
+      print format(c_fmt, 'No', 'Score', 'Identifier', 'No_Hits')
+      puts validations.map(&:short_header).join("\t")
     end
 
-    def create_validation_hashes(row)
+    def create_validation_hash(row)
       row[:validations] = {}
       @validations.each do |item|
         val     = add_basic_validation_info(item)
@@ -106,7 +80,8 @@ module GeneValidator
 
     def add_basic_validation_info(item)
       { header: item.header, description: item.description, status: item.color,
-        print: item.print.gsub('&nbsp;', ' ') }
+        print: item.print.gsub('&nbsp;', ' '), run_time: item.run_time,
+        validation: item.validation }
     end
 
     def add_explanation_data(item)
@@ -124,138 +99,149 @@ module GeneValidator
       graphs
     end
 
-    def write_row_json(row)
-      row_json = File.join(@config[:plot_dir],
-                           "#{@config[:filename]}_#{@idx}.json")
-      File.open(row_json, 'w') { |f| f.write(row.to_json) }
-    end
-
-    def self.write_json_file(array, json_file)
-      File.open(json_file, 'w') { |f| f.write(array.to_json) }
-    end
-
-    ##
-    # Method that closes the gas in the html file and writes the overall
-    # evaluation
-    # Param:
-    # +all_query_outputs+: array with +ValidationTest+ objects
-    # +html_path+: path of the html folder
-    # +filemane+: name of the fasta input file
-    def self.print_footer(overview, config)
-      set_overall_evaluation(overview, config)
-
-      footer_erb          = File.join(config[:aux], 'template_footer.erb')
-
-      no_of_results_files = (config[:run_no].to_f / config[:output_max]).ceil
-      template_file       = File.open(footer_erb, 'r').read
-      erb                 = ERB.new(template_file, 0, '>')
-
-      output_files = []
-      (1..no_of_results_files).each { |i| output_files << "results#{i}.html" }
-
-      (1..no_of_results_files).each do |i|
-        results_html = File.join(config[:html_path], "results#{i}.html")
-        File.open(results_html, 'a+') { |f| f.write(erb.result(binding)) }
+    class <<self
+      def print_console_footer(overall_evaluation, opt)
+        return unless (opt[:output_formats].include? 'stdout') ||
+                      opt[:hide_summary]
+        warn ''
+        warn "==> #{overall_evaluation.join("\n")}"
+        warn ''
       end
 
-      turn_off_sorting(config[:html_path]) if no_of_results_files > 1
-    end
-
-    def self.set_overall_evaluation(overview, config)
-      overall_evaluation = overview(overview)
-      less = overall_evaluation[0].gsub("\n", '<br>').gsub("'", %q(\\\'))
-
-      eval = print_summary_to_console(overall_evaluation, config[:summary])
-      evaluation     = eval.gsub("\n", '<br>').gsub("'", %q(\\\'))
-
-      create_overview_json(overview[:scores], config[:plot_dir], less,
-                           evaluation)
-    end
-
-    def self.turn_off_sorting(html_path)
-      script_file = File.join(html_path,
-                              'files/js/genevalidator.compiled.min.js')
-      content     = File.read(script_file).gsub(',initTableSorter(),', ',')
-      File.open("#{script_file}.tmp", 'w') { |f| f.puts content }
-      FileUtils.mv("#{script_file}.tmp", script_file)
-    end
-
-    def self.print_summary_to_console(overall_evaluation, summary)
-      # print to console
-      eval = ''
-      overall_evaluation.each { |e| eval << "#{e}\n" }
-      $stderr.puts eval if summary
-      $stderr.puts ''
-      eval
-    end
+      def generate_overview(json_data, min_blast_hits)
+        scores_from_json = json_data.map { |e| e[:overall_score] }
+        quartiles = scores_from_json.all_quartiles
+        nee = calculate_no_quries_with_no_evidence(json_data)
+        no_mafft = count_mafft_errors(json_data)
+        no_internet = count_internet_errors(json_data)
+        map_errors = map_errors(json_data)
+        run_time = calculate_run_time(json_data)
+        min_hits = json_data.count { |e| e[:no_hits] < min_blast_hits }
+        overview_hash(scores_from_json, quartiles, nee, no_mafft, no_internet,
+                      map_errors, run_time, min_hits)
+      end
 
-    # make the historgram with the resulted scores
-    def self.create_overview_json(scores, plot_dir, less, evaluation)
-      plot_file = File.join(plot_dir, 'overview.json')
-      data = [scores.group_by { |a| a }.map { |k, vs| { 'key' => k, 'value' => vs.length, 'main' => false } }]
-      hash = { data: data, type: :simplebars,
-               title: 'Overall GeneValidator Score Evaluation',
-               footer: '', xtitle: 'Validation Score',
-               ytitle: 'Number of Queries', aux1: 10, aux2: '', less: less,
-               evaluation: evaluation }
-      File.open(plot_file, 'w') { |f| f.write hash.to_json }
-    end
+      def overview_hash(scores_from_json, quartiles, nee, no_mafft, no_internet,
+                        map_errors, run_time, insufficient_BLAST_hits)
+        {
+          scores: scores_from_json,
+          no_queries: scores_from_json.length,
+          good_scores: scores_from_json.count { |s| s >= 75 },
+          bad_scores: scores_from_json.count { |s| s < 75 },
+          nee: nee, no_mafft: no_mafft, no_internet: no_internet,
+          map_errors: map_errors, run_time: run_time,
+          first_quartile_of_scores: quartiles[0],
+          second_quartile_of_scores: quartiles[1],
+          third_quartile_of_scores: quartiles[2],
+          insufficient_BLAST_hits: insufficient_BLAST_hits
+        }
+      end
 
-    ##
-    # Calculates an overall evaluation of the output
-    # Params:
-    # +all_query_outputs+: Array of +ValidationTest+ objects
-    # Output
-    # Array of Strigs with the reports
-    def self.overview(o)
-      eval       = general_overview(o)
-      error_eval = errors_overview(o)
-      time_eval  = time_overview(o)
+      # calculate number of queries that had warnings for all validations.
+      def calculate_no_quries_with_no_evidence(json_data)
+        all_warnings = 0
+        json_data.each do |row|
+          status = row[:validations].map { |_, h| h[:status] }
+          if status.count { |r| r == 'warning' } == status.length
+            all_warnings += 1
+          end
+        end
+        all_warnings
+      end
 
-      overall_evaluation = [eval, error_eval, time_eval]
-      overall_evaluation.select { |e| e != '' }
-    end
+      def count_mafft_errors(json_data)
+        json_data.count do |row|
+          num = row[:validations].count { |_, h| h[:print] == 'Mafft error' }
+          num.zero? ? false : true
+        end
+      end
 
-    def self.general_overview(o)
-      good_pred = (o[:good_scores] == 1) ? 'One' : "#{o[:good_scores]} are"
-      bad_pred  = (o[:bad_scores] == 1) ? 'One' : "#{o[:bad_scores]} are"
+      def count_internet_errors(json_data)
+        json_data.count do |row|
+          num = row[:validations].count { |_, h| h[:print] == 'Internet error' }
+          num.zero? ? false : true
+        end
+      end
 
-      eval = "Overall Query Score Evaluation:\n" \
-             "#{o[:no_queries]} predictions were validated, from which there" \
-             " were:\n" \
-             "#{good_pred} good prediction(s),\n" \
-             "#{bad_pred} possibly weak prediction(s).\n"
+      def map_errors(json_data)
+        errors = Hash.new(0)
+        json_data.each do |row|
+          e = row[:validations].map { |s, h| s if h[:validation] == 'error' }
+          e.compact.each { |err| errors[err] += 1 }
+        end
+        errors
+      end
 
-      if o[:nee] != 0 # nee = no evidence
-        eval << "#{o[:nee]} could not be evaluated due to the lack of" \
-                ' evidence.'
+      def calculate_run_time(json_data)
+        run_time = Hash.new(Pair1.new(0, 0))
+        json_data.map do |row|
+          row[:validations].each do |short_header, v|
+            next if v[:run_time].nil? || v[:run_time].zero?
+            next if v[:validation] == 'unapplicable' || v[:validation] == 'error'
+            p = Pair1.new(run_time[short_header.to_s].x + v[:run_time],
+                          run_time[short_header.to_s].y + 1)
+            run_time[short_header.to_s] = p
+          end
+        end
+        run_time
       end
-      eval
-    end
 
-    # errors per validation
-    def self.errors_overview(o)
-      error_eval = ''
-      o[:map_errors].each do |k, v|
-        error_eval << "\nWe couldn't run #{k} Validation for #{v} queries"
+      ##
+      # Calculates an overall evaluation of the output
+      # Params:
+      # +all_query_outputs+: Array of +ValidationTest+ objects
+      # Output
+      # Array of Strigs with the reports
+      def generate_evaluation_text(overview)
+        eval       = general_overview(overview)
+        error_eval = errors_overview(overview)
+        time_eval  = time_overview(overview)
+
+        [eval, error_eval, time_eval].reject(&:empty?)
       end
-      if o[:no_mafft] >= (o[:no_queries] - o[:nee])
-        error_eval << "\nWe couldn't run MAFFT multiple alignment"
+
+      private
+
+      def general_overview(o)
+        good_pred = o[:good_scores] == 1 ? 'One' : "#{o[:good_scores]} are"
+        bad_pred  = o[:bad_scores] == 1 ? 'One' : "#{o[:bad_scores]} are"
+
+        plural = 'prediction was' if o[:insufficient_BLAST_hits] == 1
+        plural = 'predictions were' if o[:insufficient_BLAST_hits] >= 2
+        b = "#{o[:insufficient_BLAST_hits]} #{plural} not evaluated due to an" \
+            ' insufficient number of BLAST hits.'
+        blast_hits = o[:insufficient_BLAST_hits].zero? ? '' : b
+
+        ['Overall Query Score Evaluation:',
+         "#{o[:no_queries]} predictions were validated, from which there were:",
+         "#{good_pred} good prediction(s),",
+         "#{bad_pred} possibly weak prediction(s).", blast_hits,
+         "The median overall score was #{o[:second_quartile_of_scores]} with" \
+         " an upper quartile of #{o[:third_quartile_of_scores]}" \
+         " and a lower quartile of #{o[:first_quartile_of_scores]}."]
       end
-      if o[:no_internet] >= (o[:no_queries] - o[:nee])
-        error_eval << "\nWe couldn't make use of your internet connection"
+
+      # errors per validation
+      def errors_overview(o)
+        error_eval = o[:map_errors].map do |k, v|
+          "We couldn't run #{k} Validation for #{v} queries"
+        end
+        if o[:no_mafft] >= (o[:no_queries] - o[:nee])
+          error_eval << "We couldn't run MAFFT multiple alignment"
+        end
+        if o[:no_internet] >= (o[:no_queries] - o[:nee])
+          error_eval << "\nWe couldn't make use of your internet connection"
+        end
+        error_eval
       end
-      error_eval
-    end
 
-    def self.time_overview(o)
-      time_eval = ''
-      o[:run_time].each do |key, value|
-        average_time = value.x / (value.y).to_f
-        time_eval << "\nAverage running time for #{key} Validation:" \
-                     " #{average_time.round(3)}s per validation"
+      def time_overview(o)
+        o[:run_time].map do |key, value|
+          mean_time = value.x / value.y.to_f
+          "Average running time for #{key} Validation: #{mean_time.round(3)}s" \
+          ' per validation'
+        end
       end
-      time_eval
     end
   end
 end

data/lib/genevalidator/output_files.rb

@@ -0,0 +1,134 @@
+require 'csv'
+require 'slim'
+require 'fileutils'
+require 'forwardable'
+require 'json'
+
+require 'genevalidator/version'
+
+module GeneValidator
+  # A Class for creating output files
+  class OutputFiles
+    extend Forwardable
+    def_delegators GeneValidator, :opt, :config, :dirs, :overview
+
+    def initialize()
+      @config    = config
+      @opt       = opt
+      @dirs      = dirs
+      @overview  = overview
+      @json_data = @config[:json_output]
+    end
+
+    def write_html(overall_eval)
+      return unless @opt[:output_formats].include? 'html'
+      @all_html_fnames = all_html_filenames
+      @json_data.each_slice(@config[:output_max]).with_index do |data, i|
+        @json_data_section = data
+        template_file = File.join(@dirs[:aux_dir], 'gv_results.slim')
+        template_contents = File.open(template_file, 'r').read
+        html_output = Slim::Template.new { template_contents }.render(self)
+        File.open(@all_html_fnames[i], 'w') { |f| f.write(html_output) }
+      end
+      create_overview_json_file(overall_eval)
+    end
+
+    def write_json
+      return unless @opt[:output_formats].include? 'json'
+      File.open(@dirs[:json_file], 'w') { |f| f.write(@json_data.to_json) }
+    end
+
+    def write_csv
+      return unless @opt[:output_formats].include? 'csv'
+      File.open(@dirs[:csv_file], 'a') do |file|
+        file.puts csv_header.join(',')
+        @json_data.each do |data|
+          short_def = data[:definition].split(' ')[0]
+          line = [data[:idx], data[:overall_score], short_def, data[:nr_hits]]
+          line += data[:validations].values.map { |e| e[:print] }
+                                    .each { |e| e.gsub!(' ', ' ') }
+          line.map { |e| e.gsub!(',', ' -') if e.is_a? String }
+          file.puts line.join(',')
+        end
+      end
+    end
+
+    def write_summary
+      return unless @opt[:output_formats].include? 'summary'
+      data = generate_summary_data
+      File.open(@dirs[:summary_file], 'w') do |f|
+        f.write data.map(&:to_csv).join
+      end
+    end
+
+    def print_best_fasta
+      return unless @opt[:select_single_best]
+      top_data = @json_data.max_by { |e| [e[:overall_score], e[:no_hits]] }
+      query = GeneValidator.extract_input_fasta_sequence(top_data[:idx])
+      File.open(@dirs[:fasta_file], 'w') { |f| f.write(query) }
+      puts query
+    end
+
+    private
+
+    def all_html_filenames
+      result_parts = (@json_data.length / @config[:output_max]).ceil
+      (0..result_parts).map do |idx|
+        multiple_files_needed = @json_data.length < @config[:output_max]
+        part = multiple_files_needed ? '' : "_#{idx + 1}"
+        fname = File.join(@dirs[:output_dir], "#{@dirs[:filename]}_results")
+        fname + part + '.html'
+      end
+    end
+
+    # By default, on page load, the results are automatically sorted by the
+    # index. However since the whole idea is that users would sort by JSON,
+    # this is not wanted here.
+    def turn_off_automated_sorting
+      js_file = File.join(@dirs[:output_dir], 'html_files/js/gv.compiled.min.js')
+      original_content = File.read(js_file)
+      # removes the automatic sort on page load
+      updated_content = original_content.gsub(',sortList:[[0,0]]', '')
+      File.open("#{script_file}.tmp", 'w') { |f| f.puts updated_content }
+      FileUtils.mv("#{script_file}.tmp", script_file)
+    end
+
+    def create_overview_json_file(overall_eval)
+      evaluation = overall_eval.flatten.join('<br>').gsub("'", %q(\\\'))
+      less = overall_eval[0].join('<br>')
+      hash = overview_html_hash(evaluation, less)
+      json = File.join(@dirs[:json_dir], 'overview.json')
+      File.open(json, 'w') { |f| f.write hash.to_json }
+    end
+
+    # make the historgram with the resulted scores
+    def overview_html_hash(evaluation, less)
+      data = [@overview[:scores].group_by { |a| a }.map do |k, vs|
+        { 'key': k, 'value': vs.length, 'main': false }
+      end]
+      { data: data, type: :simplebars, aux1: 10, aux2: '',
+        title: 'Overall GeneValidator Score Evaluation', footer: '',
+        xtitle: 'Validation Score', ytitle: 'Number of Queries',
+        less: less, evaluation: evaluation }
+    end
+
+    def csv_header
+      header = %w[AnalysisNumber GVScore Identifier NumberOfHits]
+      header += @json_data[0][:validations].keys
+      header
+    end
+
+    def generate_summary_data
+      [
+        ['num_predictions', @overview[:no_queries]],
+        ['num_good_predictions', @overview[:good_scores]],
+        ['num_bad_predictions', @overview[:bad_scores]],
+        ['num_predictions_with_insufficient_blast_hits',
+         @overview[:insufficient_BLAST_hits]],
+        ['first_quartile_of_scores', @overview[:first_quartile_of_scores]],
+        ['second_quartile_of_scores', @overview[:second_quartile_of_scores]],
+        ['third_quartile_of_scores', @overview[:third_quartile_of_scores]]
+      ]
+    end
+  end
+end