neurohmmerapp 0.0.1

data/README.md

@@ -0,0 +1,96 @@
+# NeuroHmmerApp
+[![Build Status](https://travis-ci.org/wurmlab/neurohmmerapp.svg?branch=master)](https://travis-ci.org/wurmlab/neurohmmerapp)
+[![Gem Version](https://badge.fury.io/rb/neurohmmerapp.svg)](http://badge.fury.io/rb/neurohmmerapp)
+[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/wurmlab/neurohmmerapp/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/wurmlab/neurohmmerapp/?branch=master)
+
+
+
+
+
+
+
+## Introduction
+
+This is a online web application for [Neurohmmer](https://github.com/wurmlab/neurohmmer). This app is currently hosted at: ... 
+
+
+If you use Neurohmmer in your work, please cite us as follows:
+> "Moghul MI, Elphick M & Wurm Y (<em>in prep.</em>) NeuroHmmer: identify Neuropeptide Precursors"
+
+
+
+
+
+
+-
+## Installation
+### Installation Requirements
+* Ruby (>= 2.0.0)
+* HMMer (>=3.0)
+ 
+
+### Installation
+Simply run the following command in the terminal.
+
+```bash
+gem install neurohmmerapp
+```
+
+If that doesn't work, try `sudo gem install neurohmmerapp` instead.
+
+##### Running From Source (Not Recommended)
+It is also possible to run from source. However, this is not recommended.
+
+```bash
+# Clone the repository.
+git clone https://github.com/wurmlab/neurohmmerapp.git
+
+# Move into GeneValidatorApp source directory.
+cd neurohmmerapp
+
+# Install bundler
+gem install bundler
+
+# Use bundler to install dependencies
+bundle install
+
+# Optional: run tests and build the gem from source
+bundle exec rake
+
+# Run NeuroHmmer.
+bundle exec neurohmmerapp -h
+# note that `bundle exec` executes NeuroHmmerApp in the context of the bundle
+
+# Alternativaly, install NeuroHmmerApp as a gem
+bundle exec rake install
+neurohmmerapp -h
+```
+
+
+
+
+## Launch NeuroHmmer
+
+To configure and launch NeuroHmmerApp, run the following from a command line.
+
+```bash
+neurohmmerapp
+```
+
+NeuroHmmerApp will automatically guide you through an interactive setup process to help locate BLAST+ binaries and ask for the location of BLAST+ databases.
+
+That's it! Open http://localhost:4567/ and start using NeuroHmmer!
+
+
+
+
+
+
+## Advanced Usage
+
+See `$ neurohmmerapp -h` for more information on all the options available when running NeuroHmmerApp.
+
+
+<hr>
+
+This program was developed at [Wurm Lab](https://wurmlab.github.io), [QMUL](http://sbcs.qmul.ac.uk).

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler/gem_tasks'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task default: [:build]
+
+desc 'Builds and installs'
+task install: [:build] do
+  require_relative 'lib/genevalidatorapp/version'
+  sh "gem install ./genevalidatorapp-#{GeneValidatorApp::VERSION}.gem"
+end
+
+desc 'Runs tests and builds gem (default)'
+task build: [:test] do
+  sh 'gem build genevalidatorapp.gemspec'
+end
+
+task test: :spec
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end

data/bin/neurohmmerapp

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+require 'readline'
+require 'English'
+require 'slop'
+
+ENV['RACK_ENV'] ||= 'production'
+
+# display name for tools like `ps`
+$PROGRAM_NAME = 'neurohmmerapp'
+
+begin
+  Slop.parse!(strict: true, help: true) do
+    banner <<BANNER
+SUMMARY:
+  NeuroHmmer - Identify Neuropeptide Precursors 
+
+USAGE:
+  $ neurohmmerapp [options]
+
+Examples:
+  # Launch NeuroHmmerApp with the given config file
+  $ neurohmmerapp --config ~/.neurohmmerapp.conf
+
+  # Launch NeuroHmmerApp with 8 threads at port 8888
+  $ neurohmmerapp --num_threads 8 --port 8888
+
+  # Create a config file with the other arguments
+  $ neurohmmerapp -s -d ~/database_dir
+
+BANNER
+    on 'c', 'config_file=',
+       'Use the given configuration file',
+       argument: true
+
+    on 'g', 'public_dir=',
+       'dhe public directory that is served to the web application.',
+       argument: true
+
+    on 'b', 'bin=',
+       'Load HMMER 3.0 binaries from this directory',
+       argument: true,
+       as: Array
+
+    on 'n', 'num_threads=',
+       'Number of threads to use to run a BLAST search',
+       argument: true
+
+    on 'H', 'host=',
+       'Host to run NeuroHmmerApp on',
+       argument: true
+
+    on 'p', 'port=',
+       'Port to run NeuroHmmerApp on',
+       argument: true
+
+    on 's', 'set',
+       'Set configuration value in default or given config file'
+
+    on 'D', 'devel',
+       'Start NeuroHmmerApp in development mode'
+
+    on '-v', '--version',
+       'Print version number of NeuroHmmerApp that will be loaded'
+
+    on '-h', '--help',
+       'Display this help message'
+
+    clean_opts = lambda do |hash|
+      hash.delete_if { |k, v| k == :set || v.nil? }
+      hash
+    end
+
+    run do
+      if version?
+        require 'neurohmmerapp/version'
+        puts NeuroHmmerApp::VERSION
+        exit
+      end
+
+      ENV['RACK_ENV'] = 'development' if devel?
+
+      # Exit gracefully on SIGINT.
+      stty = `stty -g`.chomp
+      trap('INT') do
+        puts ''
+        puts 'Aborted.'
+        system('stty', stty)
+        exit
+      end
+
+      require 'neurohmmerapp'
+
+      begin
+        NeuroHmmerApp.init clean_opts[to_h]
+
+      # The aim of following error recovery scenarios is to guide user to a
+      # working NeuroHmmerApp installation. We expect to land following
+      # error scenarios either when creating a new NeuroHmmerApp (first
+      # time or later), or updating config values using -s CLI option.
+
+      rescue NeuroHmmerApp::CONFIG_FILE_ERROR => e
+
+        puts e
+        exit!
+
+      rescue NeuroHmmerApp::BIN_DIR_NOT_FOUND => e
+
+        puts e
+
+        unless bin?
+          puts 'You can set the correct value by running:'
+          puts
+          puts '  neurohmmerapp -s -b <value>'
+          puts
+        end
+
+        exit!
+
+
+      rescue NeuroHmmerApp::NUM_THREADS_INCORRECT => e
+
+        puts e
+
+        unless num_threads?
+          puts 'You can set the correct value by running:'
+          puts
+          puts '  neurohmmerapp -s -n <value>'
+          puts
+        end
+
+        exit!
+
+      rescue => e
+        # This will catch any unhandled error and some very special errors.
+        # Ideally we will never hit this block. If we do, there's a bug in
+        # NeuroHmmerApp or something really weird going on. If we hit this
+        # error block we show the stacktrace to the user requesting them to
+        # post the same to our Google Group.
+        puts <<MSG
+Something went wonky
+
+Looks like you have encountered a bug in NeuroHmmerApp. Please could you
+report this incident here -
+https://github.com/wurmlab/neurohmmerapp/issues
+
+Error:
+#{e.backtrace.unshift(e.message).join("\n")}
+MSG
+        exit
+      end
+
+      if set?
+        NeuroHmmerApp.config.write_config_file
+        exit
+      end
+
+      NeuroHmmerApp.config.write_config_file if fetch_option(:set).value
+
+      NeuroHmmerApp.run
+    end
+  end
+rescue Slop::Error => e
+  puts e
+  puts "Run '#{$PROGRAM_NAME} -h' for help with command line options."
+  exit
+end

data/config.ru

@@ -0,0 +1,3 @@
+require 'genevalidatorapp'
+GeneValidatorApp.init
+run GeneValidatorApp

data/lib/neurohmmerapp/config.rb

@@ -0,0 +1,87 @@
+require 'forwardable'
+
+# Define Config class.
+module NeuroHmmerApp
+  # Capture our configuration system.
+  class Config
+    extend Forwardable
+
+    def_delegators NeuroHmmerApp, :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',
+        :public_dir     => File.join(Dir.home, '.neurohmmerapp/'),
+        :max_characters => 'undefined',
+      }
+    end
+
+    def default_config_file
+      '~/.neurohmmerapp.conf'
+    end
+  end
+end

data/lib/neurohmmerapp/exceptions.rb

@@ -0,0 +1,77 @@
+# This file defines all possible exceptions that can be thrown by
+# NeuroHmmerApp on startup.
+#
+# Exceptions only ever inform another entity (downstream code or users) of an
+# issue. Exceptions may or may not be recoverable.
+#
+# Error classes should be seen as: the error code (class name), human readable
+# message (to_s method), and necessary attributes to act on the error.
+#
+# We define as many error classes as needed to be precise about the issue, thus
+# making it easy for downstream code (bin/genevalidatorapp or config.ru) to act
+# on them.
+
+module NeuroHmmerApp
+  # Error in config file.
+  class CONFIG_FILE_ERROR < StandardError
+    def initialize(ent, err)
+      @ent = ent
+      @err = err
+    end
+
+    attr_reader :ent, :err
+
+    def to_s
+      <<MSG
+Error reading config file: #{ent}.
+#{err}
+MSG
+    end
+  end
+
+  ## ENOENT ##
+
+  # Name borrowed from standard Errno::ENOENT, this class serves as a template
+  # for defining errors that mean "expected to find <entity> at <path>, but
+  # didn't".
+  #
+  # ENOENT is raised if and only if an entity was set, either using CLI or
+  # config file. For instance, it's compulsory to set database_dir. But ENOENT
+  # is not raised if database_dir is not set. ENOENT is raised if database_dir
+  # was set, but does not exist.
+  class ENOENT < StandardError
+    def initialize(des, ent)
+      @des = des
+      @ent = ent
+    end
+
+    attr_reader :des, :ent
+
+    def to_s
+      "Could not find #{des}: #{ent}"
+    end
+  end
+
+  # Raised if bin dir set, but does not exist.
+  class BIN_DIR_NOT_FOUND < ENOENT
+    def initialize(ent)
+      super 'bin dir', ent
+    end
+  end
+
+  # Raised if extension file set, but does not exist.
+  class EXTENSION_FILE_NOT_FOUND < ENOENT
+    def initialize(ent)
+      super 'extension file', ent
+    end
+  end
+
+  ## NUM THREADS ##
+
+  # Raised if num_threads set by the user is incorrect.
+  class NUM_THREADS_INCORRECT < StandardError
+    def to_s
+      'Number of threads should be a number greater than or equal to 1.'
+    end
+  end
+end

data/lib/neurohmmerapp/logger.rb

@@ -0,0 +1,24 @@
+require 'logger'
+
+module NeuroHmmerApp
+  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

data/lib/neurohmmerapp/neurohmmer.rb

@@ -0,0 +1,158 @@
+require 'forwardable'
+require 'neurohmmer'
+
+module NeuroHmmerApp
+  # Module that runs NeuroHmmer
+  module RunNeuroHmmer
+    # 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 NeuroHmmerApp, :config, :logger, :public_dir
+
+      attr_reader :gv_dir, :input_file, :xml_file, :raw_seq, :unique_id, :params
+
+      # Setting the scene
+      def init(base_url, params)
+        create_unique_id
+        create_run_dir
+        @params = params
+        validate_params
+        # @url = produce_result_url_link(base_url)
+      end
+
+      # Runs genevalidator & Returns parsed JSON, or link to JSON/results file
+      def run
+        write_seqs_to_file
+        run_neurohmmer
+      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')
+        @run_dir   = File.join(NeuroHmmerApp.public_dir, 'NeuroHmmer',
+                               @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?(@run_dir)
+          @unique_id = create_unique_id
+          @run_dir   = File.join(NeuroHmmerApp.public_dir, 'NeuroHmmer',
+                                 @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_run_dir
+        logger.debug("NeuroHmmerApp Tempdir = #{@run_dir}")
+        FileUtils.mkdir_p(@run_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
+        logger.debug("Input Paramaters: #{@params}")
+        check_seq_param_present
+        check_seq_length
+        check_nps_param_present
+      end
+
+      # Simply asserts whether that the seq param is present
+      def check_seq_param_present
+        return if @params[:seq]
+        fail ArgumentError, 'No input sequence provided.'
+      end
+
+      def check_seq_length
+        return unless config[:max_characters] != 'undefined'
+        return if @params[:seq].length < config[:max_characters]
+        fail ArgumentError, 'The input sequence is too long.'
+      end
+
+      def check_nps_param_present
+        return if @params[:neuropeptides]
+        fail ArgumentError, 'No neuropeptides groups specified'
+      end
+
+      # Writes the input sequences to a file with the sub_dir in the temp_dir
+      def write_seqs_to_file
+        @input_file = File.join(@run_dir, 'input_file.fa')
+        logger.debug("Writing input seqs to: '#{@input_file}'")
+        ensure_unix_line_ending
+        ensure_fasta_valid
+        File.open(@input_file, 'w+') { |f| f.write(@params[:seq]) }
+        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 that the input file has been generated and is not empty
+      def assert_input_file_present
+        return if File.exist?(@input_file) && !File.zero?(@input_file)
+        fail 'NeuroHmmerApp was unable to create the input file.'
+      end
+
+      def run_neurohmmer
+        opt = {
+          temp_dir: File.join(@run_dir, 'tmp'),
+          input_file: @input_file,
+          num_threads: config[:num_threads]
+        }
+        Neurohmmer.init(opt)
+        Neurohmmer::Hmmer.search
+        hmm_results = Neurohmmer::Hmmer.analyse_output
+        Neurohmmer::Output.format_seqs_for_html(hmm_results)
+      end
+
+      def create_log_file
+        @log_file = File.join(@run_dir, 'log_file.txt')
+        logger.debug("Log file: #{@log_file}")
+      end
+    end
+  end
+end