genevalidator 1.6.1 → 1.6.2

data/lib/genevalidator/arg_validation.rb

@@ -1,26 +1,39 @@
+require 'forwardable'
+
+require 'genevalidator/blast'
+
 # A module to validate the command line Arguments
 ## CREDIT: some of these methods have been adapted from SequenceServer
 module GeneValidator
   # TODO: If a tabular file is provided, ensure that a tabular file has the
   #       right number of columns
   # TODO: assert_if_ruby_version_is_supported
-  # A module to validate the arguments passed to the Validation Class
-  module GVArgValidation
+  # A class to validate the arguments passed to the Validation Class
+  class GVArgValidation
     class << self
-      def validate_args(opt)
+      extend Forwardable
+      def_delegators GeneValidator, :opt
+
+      def validate_args
         @opt = opt
         assert_output_dir_does_not_exist
         assert_file_present('input file', opt[:input_fasta_file])
         assert_input_file_probably_fasta
-        assert_input_contains_single_type_sequence
+        assert_input_sequence
         assert_BLAST_output_files
 
         assert_validations_arg
         check_num_threads
 
+        export_bin_dirs unless @opt[:bin].nil?
+
         Blast.validate(opt) unless @opt[:test]
-        Mafft.assert_mafft_installation(opt)
-        @opt
+        assert_mafft_installation
+      end
+
+      # Return `true` if the given command exists and is executable.
+      def command?(command)
+        system("which #{command} > /dev/null 2>&1")
       end
 
       private
@@ -37,10 +50,10 @@ module GeneValidator
       def check_num_threads
         @opt[:num_threads] = Integer(@opt[:num_threads])
         unless @opt[:num_threads] > 0
-          puts 'Number of threads can not be lower than 0'
+          $stderr.puts 'Number of threads can not be lower than 0'
         end
         return unless @opt[:num_threads] > 256
-        puts "Number of threads set at #{@opt[:num_threads]} is unusually high."
+        $stderr.puts "Number of threads set at #{@opt[:num_threads]} is unusually high."
       end
 
       def assert_BLAST_output_files
@@ -56,18 +69,18 @@ module GeneValidator
       def assert_output_dir_does_not_exist
         output_dir = "#{@opt[:input_fasta_file]}.html"
         return unless File.exist?(output_dir)
-        puts "The output directory already exists for this fasta file.\n"
-        puts "Please remove the following directory: #{output_dir}\n"
-        puts "You can run the following command to remove the folder.\n"
-        puts "\n   $ rm -r #{output_dir} \n"
+        $stderr.puts "The output directory already exists for this fasta file.\n"
+        $stderr.puts "Please remove the following directory: #{output_dir}\n"
+        $stderr.puts "You can run the following command to remove the folder.\n"
+        $stderr.puts "\n   $ rm -r #{output_dir} \n"
         exit 1
       end
 
       def assert_tabular_options_exists
         return if @opt[:blast_tabular_options]
-        puts '*** Error: BLAST tabular options (-o) have not been set.'
-        puts '    Please set the "-o" option with the custom format'
-        puts '    used in the BLAST -outfmt argument'
+        $stderr.puts '*** Error: BLAST tabular options (-o) have not been set.'
+        $stderr.puts '    Please set the "-o" option with the custom format'
+        $stderr.puts '    used in the BLAST -outfmt argument'
         exit 1
       end
 
@@ -79,20 +92,45 @@ module GeneValidator
 
       def assert_file_present(desc, file, exit_code = 1)
         return if file && File.exist?(File.expand_path(file))
-        puts "*** Error: Couldn't find the #{desc}: #{file}."
+        $stderr.puts "*** Error: Couldn't find the #{desc}: #{file}."
         exit exit_code
       end
 
       alias_method :assert_dir_present, :assert_file_present
 
-      def assert_input_contains_single_type_sequence
+      def assert_input_sequence
         fasta_content = IO.binread(@opt[:input_fasta_file])
         type = BlastUtils.type_of_sequences(fasta_content)
         return if type == :nucleotide || type == :protein
-        puts '*** Error: The input files does not contain just protein or'
-        puts '    nucleotide data. Please correct this and try again.'
+        $stderr.puts '*** Error: The input files does not contain just protein or'
+        $stderr.puts '    nucleotide data. Please correct this and try again.'
         exit 1
       end
+
+      def export_bin_dirs
+        @opt[:bin].each do |bin|
+          if File.directory?(bin)
+            add_to_path(bin)
+          else
+            $stderr.puts '*** The following bin directory does not exist:'
+            $stderr.puts "    #{bin}"
+          end
+        end
+      end
+
+      ## Checks if dir is in $PATH and if not, it adds the dir to the $PATH.
+      def add_to_path(bin_dir)
+        return if ENV['PATH'].split(':').include?(bin_dir)
+        ENV['PATH'] = "#{bin_dir}:#{ENV['PATH']}"
+      end
+
+      def assert_mafft_installation
+        return if command?('mafft')
+        $stderr.puts '*** Could not find Mafft binaries.'
+        $stderr.puts '    Ignoring error and continuing - Please note that' \
+                     ' some validations may be skipped.'
+        $stderr.puts # a blank line
+      end
     end
 
     # Validates BLAST Installation (And BLAST databases)
@@ -106,40 +144,32 @@ module GeneValidator
         EXIT_NO_BLAST_DATABASE          = 4
 
         def validate(opt)
-          @opt = opt
           assert_blast_installation
-          assert_blast_database_provided
-          assert_local_blast_database_exists if @opt[:db] !~ /remote/
+          warn_if_remote_database(opt[:db])
+          assert_local_blast_database_exists(opt[:db]) if opt[:db] !~ /remote/
         end
 
         def assert_blast_installation
           # Validate BLAST installation
-          if @opt[:blast_bin].nil?
-            assert_blast_installed
-            assert_blast_compatible
-          else
-            export_bin_dir
-          end
+          assert_blast_installed
+          assert_blast_compatible
         end
 
-        def assert_blast_database_provided
-          return unless @opt[:db].nil?
-          puts '*** Error: A BLAST database is required. Please pass a local or'
-          puts '    remote BLAST database to GeneValidator as follows:'
-          puts # a blank line
-          puts "      $ genevalidator -d '~/blastdb/SwissProt' Input_File"
-          puts # a blank line
-          puts '    Or use a remote database:'
-          puts # a blank line
-          puts "      $ genevalidator -d 'swissprot -remote' Input_File"
-          exit 1
+        def warn_if_remote_database(db)
+          return if db !~ /remote/
+          $stderr.puts # a blank line
+          $stderr.puts 'Warning: BLAST will be carried out on remote servers.'
+          $stderr.puts 'This may take quite a bit of time.'
+          $stderr.puts 'You may want to install a local BLAST database for' \
+                       ' faster analyses.'
+          $stderr.puts # a blank line
         end
 
-        def assert_local_blast_database_exists
-          return if system("blastdbcmd -db #{@opt[:db]} -info > /dev/null 2>&1")
-          puts '*** No BLAST database found at the provided path.'
-          puts '    Please ensure that the provided path is correct and then' \
-               ' try again.'
+        def assert_local_blast_database_exists(db)
+          return if system("blastdbcmd -db #{db} -info > /dev/null 2>&1")
+          $stderr.puts '*** No BLAST database found at the provided path.'
+          $stderr.puts '    Please ensure that the provided path is correct' \
+                       ' and then try again.'
           exit EXIT_NO_BLAST_DATABASE
         end
 
@@ -147,77 +177,18 @@ module GeneValidator
 
         def assert_blast_installed
           return if GVArgValidation.command?('blastdbcmd')
-          puts '*** Could not find BLAST+ binaries.'
+          $stderr.puts '*** Could not find BLAST+ binaries.'
           exit EXIT_BLAST_NOT_INSTALLED
         end
 
         def assert_blast_compatible
           version = `blastdbcmd -version`.split[1]
           return if version >= MINIMUM_BLAST_VERSION
-          puts "*** Your BLAST+ version #{version} is outdated."
-          puts '    GeneValidator needs NCBI BLAST+ version' \
-               " #{MINIMUM_BLAST_VERSION} or higher."
+          $stderr.puts "*** Your BLAST+ version #{version} is outdated."
+          $stderr.puts '    GeneValidator needs NCBI BLAST+ version' \
+                       " #{MINIMUM_BLAST_VERSION} or higher."
           exit EXIT_BLAST_NOT_COMPATIBLE
         end
-
-        def export_bin_dir
-          if File.directory?(@opt[:blast_bin])
-            GVArgValidation.add_to_path(@opt[:blast_bin])
-          else
-            puts '*** The provided BLAST bin directory does not exist.'
-            puts '    Please ensure that the provided BLAST bin directory is' \
-                 ' correct and try again.'
-            exit EXIT_BLAST_NOT_INSTALLED
-          end
-        end
-      end
-    end
-
-    # Validates Mafft installation
-    class Mafft
-      class << self
-        def assert_mafft_installation(opt)
-          @opt = opt
-          if @opt[:mafft_bin].nil?
-            assert_mafft_installed
-          else
-            export_bin_dir
-          end
-        end
-
-        private
-
-        def assert_mafft_installed
-          return if GVArgValidation.command?('mafft')
-          puts '*** Could not find Mafft binaries.'
-          puts '    Ignoring error and continuing - Please note that some' \
-               ' validations may be skipped.'
-          puts # a blank line
-        end
-
-        def export_bin_dir
-          if File.directory?(@opt[:mafft_bin])
-            GVArgValidation.add_to_path(@opt[:mafft_bin])
-          else
-            puts '*** The provided Mafft bin directory does not exist.'
-            puts '    Ignoring error and continuing - Please note that some' \
-                 ' validations may be skipped.'
-            puts # a blank line
-          end
-        end
-      end
-    end
-
-    class << self
-      ## Checks if dir is in $PATH and if not, it adds the dir to the $PATH.
-      def add_to_path(bin_dir)
-        return if ENV['PATH'].split(':').include?(bin_dir)
-        ENV['PATH'] = "#{bin_dir}:#{ENV['PATH']}"
-      end
-
-      # Return `true` if the given command exists and is executable.
-      def command?(command)
-        system("which #{command} > /dev/null 2>&1")
       end
     end
   end

data/lib/genevalidator/blast.rb

@@ -1,19 +1,19 @@
-require 'genevalidator/sequences'
+require 'bio'
+require 'bio-blastxmlparser'
+require 'forwardable'
+
+require 'genevalidator/exceptions'
 require 'genevalidator/hsp'
+require 'genevalidator/sequences'
 require 'genevalidator/output'
-require 'genevalidator/exceptions'
-require 'bio-blastxmlparser'
-require 'net/http'
-require 'open-uri'
-require 'uri'
-require 'io/console'
-require 'yaml'
-require 'bio'
 
 module GeneValidator
   # Contains methods that run BLAST and methods that analyse sequences
   class BlastUtils
     class << self
+      extend Forwardable
+      def_delegators GeneValidator, :opt, :config
+
       EVALUE = 1e-5
 
       ##
@@ -25,7 +25,10 @@ module GeneValidator
       # +num_threads+: The number of threads to run BLAST with.
       # Output:
       # String with the blast xml output
-      def run_blast(blast_type, query, db, num_threads)
+      def run_blast(query, db = opt[:db], seq_type = config[:type],
+                    num_threads = opt[:num_threads])
+
+        blast_type = (seq_type == :protein) ? 'blastp' : 'blastx'
         # -num_threads is not supported on remote databases
         threads = (db !~ /remote/) ? "-num_threads #{num_threads}" : ''
 
@@ -46,20 +49,26 @@ module GeneValidator
       # +nr_hits+: max number of hits
       # Output:
       # XML file
-      def run_blast_on_file(opt)
-        seq_type   = guess_sequence_type_from_file(opt[:input_fasta_file])
+      def run_blast_on_input_file(input_file = opt[:input_fasta_file],
+                                  db = opt[:db], seq_type = config[:type],
+                                  num_threads = opt[:num_threads])
+        return if opt[:blast_xml_file] || opt[:blast_tabular_file]
+
+        $stderr.puts 'Running BLAST'
+        opt[:blast_xml_file] = input_file + '.blast_xml'
+
         blast_type = (seq_type == :protein) ? 'blastp' : 'blastx'
         # -num_threads is not supported on remote databases
-        threads = (opt[:db] !~ /remote/) ? "-num_threads #{opt[:num_threads]}" : ''
+        threads = (opt[:db] !~ /remote/) ? "-num_threads #{num_threads}" : ''
 
-        blastcmd = "#{blast_type} -query '#{opt[:input_fasta_file]}'" \
-                   " -out '#{opt[:blast_xml_file]}' -db #{opt[:db]} " \
+        blastcmd = "#{blast_type} -query '#{input_file}'" \
+                   " -out '#{opt[:blast_xml_file]}' -db #{db} " \
                    " -evalue #{EVALUE} -outfmt 5 #{threads}"
 
         `#{blastcmd}`
         return unless File.zero?(opt[:blast_xml_file])
-        puts 'Blast failed to run on the input file. Please ensure that the'
-        puts 'BLAST database exists and try again'
+        $stderr.puts 'Blast failed to run on the input file. Please ensure that the'
+        $stderr.puts 'BLAST database exists and try again'
         exit 1
       end
 
@@ -70,9 +79,7 @@ module GeneValidator
       # +type+: the type of the sequence: :nucleotide or :protein
       # Outputs:
       # Array of +Sequence+ objects corresponding to the list of hits
-      def parse_next(iterator, type)
-        fail TypeError unless iterator.is_a? Enumerator
-
+      def parse_next(iterator, type = config[:type])
         hits = []
         iter = iterator.next
 
@@ -85,7 +92,6 @@ module GeneValidator
           seq.type           = :protein
           seq.identifier     = hit.hit_id
           seq.definition     = hit.hit_def
-          # puts seq.identifier
           seq.accession_no = hit.accession
 
           # get all high-scoring segment pairs (hsp)
@@ -93,7 +99,7 @@ module GeneValidator
 
           hit.hsps.each do |hsp|
             current_hsp            = Hsp.new
-            current_hsp.hsp_evalue = '%.0e' % hsp.evalue
+            current_hsp.hsp_evalue = format('%.0e', hsp.evalue)
 
             current_hsp.hit_from         = hsp.hit_from.to_i
             current_hsp.hit_to           = hsp.hit_to.to_i
@@ -102,20 +108,20 @@ module GeneValidator
 
             if type == :nucleotide
               current_hsp.match_query_from /= 3
-              current_hsp.match_query_to   /= 3
+              current_hsp.match_query_to /= 3
               current_hsp.match_query_from += 1
-              current_hsp.match_query_to   += 1
+              current_hsp.match_query_to += 1
             end
 
             current_hsp.query_reading_frame = hsp.query_frame.to_i
 
             current_hsp.hit_alignment = hsp.hseq.to_s
-            if BlastUtils.guess_sequence_type(current_hsp.hit_alignment) != :protein
+            if guess_sequence_type(current_hsp.hit_alignment) != :protein
               fail SequenceTypeError
             end
 
             current_hsp.query_alignment = hsp.qseq.to_s
-            if BlastUtils.guess_sequence_type(current_hsp.query_alignment) != :protein
+            if guess_sequence_type(current_hsp.query_alignment) != :protein
               fail SequenceTypeError
             end
             current_hsp.align_len = hsp.align_len.to_i
@@ -129,23 +135,35 @@ module GeneValidator
           hits.push(seq)
         end
 
-        return hits
-
-      rescue TypeError => error
-        line = error.backtrace[0].scan(/\/([^\/]+:\d+):.*/)[0][0]
-        $stderr.print "Type error at #{line}. Possible cause: you didn't call" \
-                      " parse method first!\n"
-        exit 1
-      rescue SequenceTypeError => error
-        line = error.backtrace[0].scan(/\/([^\/]+:\d+):.*/)[0][0]
-        $stderr.print "Sequence Type error at #{line}. Possible cause: the" \
-                      'blast output was not obtained against a protein' \
-                      " database.\n"
+        hits
+      rescue SequenceTypeError => e
+        $stderr.puts e
         exit 1
       rescue StopIteration
         nil
       end
 
+      ##
+      # Method copied from sequenceserver/sequencehelpers.rb
+      # Splits input at putative fasta definition lines (like ">adsfadsf");
+      # then 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
+      # Params:
+      # +sequence_string+: String to validate
+      # Output:
+      # nil, :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(&:empty?)
+        # get all sequence types
+        sequence_types = sequences.collect { |seq| guess_sequence_type(seq) }.uniq.compact
+
+        return nil if sequence_types.empty?
+        return sequence_types.first if sequence_types.length == 1
+      end
+
       ##
       # Strips all non-letter characters. guestimates sequence based on that.
       # If less than 10 useable characters... returns nil
@@ -165,7 +183,7 @@ module GeneValidator
 
       ##
       #
-      def guess_sequence_type_from_file(file)
+      def guess_sequence_type_from_input_file(file = opt[:input_fasta_file])
         lines = File.foreach(file).first(10)
         seqs = ''
         lines.each do |l|
@@ -173,27 +191,6 @@ module GeneValidator
         end
         guess_sequence_type(seqs)
       end
-
-      ##
-      # Method copied from sequenceserver/sequencehelpers.rb
-      # Splits input at putative fasta definition lines (like ">adsfadsf");
-      # then 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
-      # Params:
-      # +sequence_string+: String to validate
-      # Output:
-      # nil, :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(&:empty?)
-        # get all sequence types
-        sequence_types = sequences.collect { |seq| BlastUtils.guess_sequence_type(seq) }.uniq.compact
-
-        return nil if sequence_types.empty?
-        return sequence_types.first if sequence_types.length == 1
-      end
     end
   end
 end