genevalidatorapp 1.4.12

data/lib/GeneValidatorApp/config.rb

@@ -0,0 +1,86 @@
+require 'forwardable'
+
+# Define Config class.
+module GeneValidatorApp
+  # Capture our configuration system.
+  class Config
+    extend Forwardable
+
+    def_delegators GeneValidatorApp, :logger
+
+    def initialize(data = {})
+      @data = symbolise data
+      @config_file = @data.delete(:config_file) || default_config_file
+      @config_file = File.expand_path(@config_file)
+      @data = parse_config_file.update @data
+      @data = defaults.update @data
+    end
+
+    attr_reader :data, :config_file
+
+    # Get.
+    def [](key)
+      data[key]
+    end
+
+    # Set.
+    def []=(key, value)
+      data[key] = value
+    end
+
+    # Exists?
+    def include?(key)
+      data.include? key
+    end
+
+    # Write config data to config file.
+    def write_config_file
+      return unless config_file
+      File.open(config_file, 'w') do |f|
+        f.puts(data.delete_if { |_, v| v.nil? }.to_yaml)
+      end
+    end
+
+    private
+
+    # Symbolizes keys. Changes `database` key to `database_dir`.
+    def symbolise(data)
+      return {} unless data
+      # Symbolize keys.
+      Hash[data.map { |k, v| [k.to_sym, v] }]
+    end
+
+    # Parses and returns data from config_file if it exists. Returns {}
+    # otherwise.
+    def parse_config_file
+      unless file? config_file
+        logger.debug "Configuration file not found: #{config_file}"
+        return {}
+      end
+
+      logger.debug "Reading configuration file: #{config_file}."
+      symbolise YAML.load_file(config_file)
+    rescue => error
+      raise CONFIG_FILE_ERROR.new(config_file, error)
+    end
+
+    def file?(file)
+      file && File.exist?(file) && File.file?(file)
+    end
+
+    # Default configuration data.
+    def defaults
+      {
+        :num_threads  => 1,
+        :port         => 4567,
+        :host         => '0.0.0.0',
+        :web_dir      => Dir.pwd
+      }
+    end
+
+    def default_config_file
+      '~/.genevalidatorapp.conf'
+    end
+  end
+
+end

data/lib/GeneValidatorApp/database.rb

@@ -0,0 +1,114 @@
+require 'find'
+require 'digest/md5'
+require 'forwardable'
+
+module GeneValidatorApp
+  # Captures a directory containing FASTA files and BLAST databases.
+  #
+  # It is important that formatted BLAST database files have the same dirname and
+  # basename as the source FASTA for GeneValidatorApp to be able to tell formatted
+  # FASTA from unformatted. And that FASTA files be formatted with `parse_seqids`
+  # option of `makeblastdb` for sequence retrieval to work.
+  #
+  # GeneValidatorApp will always place BLAST database files alongside input FASTA,
+  # and use `parse_seqids` option of `makeblastdb` to format databases.
+  class Database < Struct.new(:name, :title, :type)
+    class << self
+      extend Forwardable
+
+      def_delegators GeneValidatorApp, :config, :logger
+
+      def collection
+        @collection ||= {}
+      end
+
+      private :collection
+
+      def <<(database)
+        collection[database.id] = database
+      end
+
+      def [](ids)
+        ids = Array ids
+        collection.values_at(*ids)
+      end
+
+      def ids
+        collection.keys
+      end
+
+      def all
+        collection.values
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def include?(path)
+        collection.include? Digest::MD5.hexdigest path
+      end
+
+      def group_by(&block)
+        all.group_by(&block)
+      end
+
+      def first
+        all.first
+      end
+
+      def default_db
+        if config[:default_db] && Database.include?(config[:default_db])
+          all.find { |a| a.name == config[:default_db] }
+        else
+          all.first
+        end
+      end
+
+      def non_default_dbs
+        all.find_all { |a| a != Database.default_db }
+      end
+
+      # Returns the original structure that the title is within.
+      def obtain_original_structure(db_title)
+        all.find_all { |a| a.title.chomp == db_title }
+      end
+
+      # Recurisvely scan `database_dir` for blast databases.
+      def scan_databases_dir
+        database_dir = config[:database_dir]
+        list = `blastdbcmd -recursive -list #{database_dir} -list_outfmt "%p	%f	%t" 2>&1`
+        list.each_line do |line|
+          type, name, title =  line.split('	')
+          next if multipart_database_name?(name)
+          next unless type.downcase == 'protein' # to ensure we only have protein dbs
+          self << Database.new(name, title, type)
+        end
+      end
+
+      # Returns true if the database name appears to be a multi-part database name.
+      #
+      # e.g.
+      # /home/ben/pd.ben/sequenceserver/db/nr.00 => yes
+      # /home/ben/pd.ben/sequenceserver/db/nr => no
+      # /home/ben/pd.ben/sequenceserver/db/img3.5.finished.faa.01 => yes
+      def multipart_database_name?(db_name)
+        !(db_name.match(/.+\/\S+\d{2}$/).nil?)
+      end
+    end
+
+    def initialize(*args)
+      args.last.downcase!
+      args.each(&:freeze)
+      super
+
+      @id = Digest::MD5.hexdigest args.first
+    end
+
+    attr_reader :id
+
+    def to_s
+      "#{type}: #{title} #{name}"
+    end
+  end
+end

data/lib/GeneValidatorApp/genevalidator.rb

@@ -0,0 +1,241 @@
+require 'forwardable'
+require 'bio'
+require 'fileutils'
+require 'genevalidator'
+
+module GeneValidatorApp
+  # Module that runs GeneValidator
+  module RunGeneValidator
+    # To signal error in query sequence or options.
+    #
+    # ArgumentError is raised when BLAST+'s exit status is 1; see [1].
+    class ArgumentError < ArgumentError
+    end
+
+    # To signal internal errors.
+    #
+    # RuntimeError is raised when there is a problem in writing the input file,
+    # in running BLAST, get_raw_sequence or genevalidator. These are rare,
+    # infrastructure errors, used internally, and of concern only to the
+    # admins/developers.
+    class RuntimeError < RuntimeError
+    end
+
+    class << self
+      extend Forwardable
+
+      def_delegators GeneValidatorApp, :config, :logger
+
+      attr_reader :gv_dir, :tmp_gv_dir, :input_file, :xml_file, :raw_seq,
+                  :unique_id, :params
+
+      # Setting the scene
+      def init(url, params)
+        create_unique_id
+        create_subdir_in_main_tmpdir
+        create_soft_link_from_tmpdir_to_GV_dir
+        @params = params
+        validate_params
+        obtain_db_path
+        @url = produce_result_url_link(url)
+      end
+
+      # Run BLAST(X/P), get_raw_sequence and genevalidator
+      #  Returns html for just the table or a link to the page produced by GV
+      def run
+        write_seq_to_file
+        run_genevalidator
+        (@params[:result_link]) ? @url : produce_table_html
+      end
+
+      private
+
+      # Creates a unique run ID (based on time),
+      def create_unique_id
+        @unique_id = Time.new.strftime('%Y-%m-%d_%H-%M-%S_%L-%N')
+        @gv_tmpdir = GeneValidatorApp.tempdir + unique_id
+        ensure_unique_id
+      end
+
+      # Ensures that the Unique id is unique (if a sub dir is present in the
+      #  temp dir with the unique id, it simply creates a new one)
+      def ensure_unique_id
+        while File.exist?(@gv_tmpdir)
+          @unique_id = create_unique_id
+          @gv_tmpdir = GeneValidatorApp.tempdir + @unique_id
+        end
+        logger.debug("Unique ID = #{@unique_id}")
+      end
+
+      # Create a sub_dir in the Tempdir (name is based on unique id)
+      def create_subdir_in_main_tmpdir
+        logger.debug("GV Tempdir = #{@gv_tmpdir}")
+        FileUtils.mkdir_p(@gv_tmpdir)
+      end
+
+      # Create the Tmp Dir and the create a soft link to it.
+      def create_soft_link_from_tmpdir_to_GV_dir
+        @gv_dir = GeneValidatorApp.public_dir + 'GeneValidator' + @unique_id
+        logger.debug("Local GV dir = #{@gv_dir}")
+        FileUtils.ln_s "#{@gv_tmpdir}", "#{@gv_dir}"
+      end
+
+      # Validates the paramaters provided via the app.
+      #  Only important if POST request is sent via API - Web APP also validates
+      #  all params via Javascript.
+      def validate_params
+        check_seq_param_present
+        check_seq_length
+        check_validations_param_present
+        check_database_params_present
+      end
+
+      # Simply asserts whether that the seq param is present
+      def check_seq_param_present
+        unless @params[:seq]
+          fail ArgumentError, 'No input sequence provided.'
+        end
+      end
+
+      def check_seq_length
+        return unless config[:max_characters]
+        unless @params[:seq].length < config[:max_characters]
+          fail ArgumentError, 'The input sequence is too long.'
+        end
+      end
+
+      # Asserts whether the validations param are specified
+      def check_validations_param_present
+        unless @params[:validations]
+          fail ArgumentError, 'No validations specified'
+        end
+      end
+
+      # Asserts whether the database parameter is present
+      def check_database_params_present
+        fail ArgumentError, 'No database specified' unless @params[:database]
+      end
+
+      def obtain_db_path
+        Database.obtain_original_structure(@params[:database]).each do |db|
+          @db = db.name
+        end
+      end
+
+      # Writes the input sequences to a file with the sub_dir in the temp_dir
+      def write_seq_to_file
+        @input_fasta_file = @gv_tmpdir + 'input_file.fa'
+        logger.debug("Writing input seqs to: '#{@input_fasta_file}'")
+        ensure_unix_line_ending
+        ensure_fasta_valid
+        File.open(@input_fasta_file, 'w+') do |f|
+          f.write(@params[:seq])
+        end
+        assert_input_file_present
+      end
+
+      def ensure_unix_line_ending
+        @params[:seq].gsub!(/\r\n?/, "\n")
+      end
+
+      # Adds a ID (based on the time when submitted) to sequences that are not
+      #  in fasta format.
+      def ensure_fasta_valid
+        logger.debug('Adding an ID to sequences that are not in fasta format.')
+        unique_queries = {}
+        sequence       = @params[:seq].lstrip
+        if sequence[0] != '>'
+          sequence.insert(0, ">Submitted:#{Time.now.strftime('%H:%M-%B_%d_%Y')}\n")
+        end
+        sequence.gsub!(/^\>(\S+)/) do |s|
+          if unique_queries.key?(s)
+            unique_queries[s] += 1
+            s + '_' + (unique_queries[s] - 1).to_s
+          else
+            unique_queries[s] = 1
+            s
+          end
+        end
+        @params[:seq] = sequence
+      end
+
+      # Asserts whether the input file has been generated and whether it is
+      #  empty
+      def assert_input_file_present
+        unless File.exist?(@input_fasta_file) || File.zero?(@input_fasta_file)
+          fail RuntimeError, 'GeneValidatorApp was unable to create the input' \
+                             ' file.'
+        end
+      end
+
+      # Returns 'blastp' if sequence contains amino acids or returns 'blastx'
+      #   if it contains nucleic acids.
+      def get_blast_type(sequences)
+        (check_seq_type(sequences) == Bio::Sequence::AA) ? 'blastp' : 'blastx'
+      end
+
+      def check_seq_type(sequences)
+        Bio::Sequence.new(Bio::FastaFormat.new(sequences).seq).guess(0.9)
+      end
+
+      # Runs GeneValidator
+      def run_genevalidator
+        opts = set_up_gv_opts
+        logger.debug("Running GeneValidator with options: #{opts}")
+        create_gv_log_file
+        run_gv
+        assert_table_output_file_produced
+      rescue SystemExit
+        raise RuntimeError, 'GeneValidator failed to run properly'
+      end
+
+      def run_gv
+        original_stdout = $stdout.clone unless logger.debug?
+        $stdout.reopen(@gv_log_file, 'w') unless logger.debug?
+        (GeneValidator::Validation.new(opts, 1, true, true)).run
+        $stdout = original_stdout unless logger.debug?
+      end
+
+      def set_up_gv_opts
+        {
+          validations: @params[:validations],
+          db: @db,
+          num_threads: config[:num_threads],
+          fast: true,
+          input_fasta_file: @input_fasta_file.to_s
+        }
+      end
+
+      def create_gv_log_file
+        @gv_log_file = (@gv_tmpdir + 'log_file.txt').to_s
+        logger.debug("Log file: #{@gv_log_file}")
+      end
+
+      # Assets whether the results file is produced by GeneValidator.
+      def assert_table_output_file_produced
+        @table_file = @gv_dir + 'input_file.fa.html/files/table.html'
+        unless File.exist?(@table_file)
+          fail RuntimeError, 'GeneValidator did not produce the required' \
+                             ' output file.'
+        end
+      end
+
+      # Reads the GV output table file.
+      # Updates links to the plots with relative links to plot jsons.
+      def produce_table_html
+        orig_plots_dir  = 'files/json/input_file.fa_'
+        local_plots_dir = Pathname.new('GeneValidator') + @unique_id +
+                          'input_file.fa.html/files/json/input_file.fa_'
+        full_html = IO.binread(@table_file)
+        full_html.gsub(/#{orig_plots_dir}/, local_plots_dir.to_s).gsub(
+                  '#Place_external_results_link_here', @url)
+      end
+
+      # Reuturns the URL of the results page.
+      def produce_result_url_link(url)
+        url.gsub(/input/, '').gsub(/\/*$/, '') +
+          "/GeneValidator/#{@unique_id}/input_file.fa.html/results.html"
+      end
+    end
+  end
+end

data/lib/GeneValidatorApp/logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+module GeneValidatorApp
+  class Logger < Logger
+    def initialize(dev, verbose = false)
+      super dev
+      self.level     = verbose ? DEBUG : INFO
+      self.formatter = Formatter.new
+    end
+
+    # We change Logging format so that it is consistent with Sinatra's
+    class Formatter < Formatter
+      Format = "[%s] %s  %s\n"
+
+      def initialize
+        self.datetime_format = '%Y-%m-%d %H:%M:%S'
+      end
+
+      def call(severity, time, _progname, msg)
+        Format % [format_datetime(time), severity, msg2str(msg)]
+      end
+    end
+  end
+end