sequenceserver 1.0.0.pre.2 → 1.0.0.pre.3

data/lib/sequenceserver/config.rb

@@ -0,0 +1,94 @@
+require 'forwardable'
+
+# Define Config class.
+module SequenceServer
+  # Capture our configuration system.
+  class Config
+    extend Forwardable
+
+    def_delegators SequenceServer, :logger
+
+    def initialize(data = {})
+      @data = normalize 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 normalize(data)
+      return {} unless data
+
+      # Symbolize keys.
+      data = Hash[data.map { |k, v| [k.to_sym, v] }]
+
+      # The newer config file version replaces the older database key with
+      # database_dir for correctness. Let's honour the old version as well.
+      if data[:database]
+        database_dir = data.delete(:database)
+        data[:database_dir] ||= database_dir
+      end
+
+      data
+    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}."
+      normalize 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'
+      }
+    end
+
+    def default_config_file
+      '~/.sequenceserver.conf'
+    end
+  end
+end

data/lib/sequenceserver/database.rb

@@ -4,24 +4,45 @@ require 'forwardable'
 
 require 'sequenceserver/sequence'
 
+# Define Database class.
 module SequenceServer
-
   # Captures a directory containing FASTA files and BLAST databases.
   #
   # Formatting a FASTA for use with BLAST+ will create 3 or 6 files,
   # collectively referred to as a BLAST database.
   #
-  # It is important that formatted BLAST database files have the same dirname and
-  # basename as the source FASTA for SequenceServer 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.
+  # It is important that formatted BLAST database files have the same dirname
+  # and basename as the source FASTA for SequenceServer 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.
   #
   # SequenceServer 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, :nsequences, :ncharacters, :updated_on)
+  Database = Struct.new(:name, :title, :type, :nsequences, :ncharacters,
+                        :updated_on) do
+    def initialize(*args)
+      args[2].downcase!   # database type
+      args.each(&:freeze)
+      super
 
-    class << self
+      @id = Digest::MD5.hexdigest args.first
+    end
+
+    attr_reader :id
+
+    def include?(accession)
+      out = `blastdbcmd -entry '#{accession}' -db #{name} 2> /dev/null`
+      !out.empty?
+    end
 
+    def to_s
+      "#{type}: #{title} #{name}"
+    end
+  end
+
+  # Model Database's eigenclass as a collection of Database objects.
+  class Database
+    class << self
       include Enumerable
 
       extend Forwardable
@@ -68,10 +89,17 @@ module SequenceServer
         all.first
       end
 
+      # Intended to be used only for testing.
+      def clear
+        collection.clear
+      end
+
       # Recurisvely scan `database_dir` for blast databases.
       def scan_databases_dir
         database_dir = config[:database_dir]
-        list = %x|blastdbcmd -recursive -list #{database_dir} -list_outfmt "%f	%t	%p	%n	%l	%d" 2>&1|
+        cmd = "blastdbcmd -recursive -list #{database_dir}" \
+              ' -list_outfmt "%f	%t	%p	%n	%l	%d" 2>&1'
+        list = `#{cmd}`
         list.each_line do |line|
           name = line.split('	')[0]
           next if multipart_database_name?(name)
@@ -82,13 +110,13 @@ module SequenceServer
       # Recursively scan `database_dir` for un-formatted FASTA and format them
       # for use with BLAST+.
       def make_blast_databases
-        unformatted_fastas.each do |file, sequence_type|
+        unformatted_fastas.select do |file, sequence_type|
           make_blast_database(file, sequence_type)
         end
       end
 
-      # Returns an Array of FASTA files that may require formatting, and the type
-      # of sequence contained in each FASTA.
+      # Returns an Array of FASTA files that may require formatting, and the
+      # type of sequence contained in each FASTA.
       #
       #   > unformatted_fastas
       #   => [['/foo/bar.fasta', :nulceotide], ...]
@@ -96,13 +124,12 @@ module SequenceServer
         list = []
         database_dir = config[:database_dir]
         Find.find database_dir do |file|
-          next if File.directory?(file)
+          next if File.directory? file
           next if Database.include? file
-          if probably_fasta? file
-            sequence_type = guess_sequence_type_in_fasta file
-            if [:protein, :nucleotide].include?(sequence_type)
-              list << [file, sequence_type]
-            end
+          next unless probably_fasta? file
+          sequence_type = guess_sequence_type_in_fasta file
+          if [:protein, :nucleotide].include?(sequence_type)
+            list << [file, sequence_type]
           end
         end
         list
@@ -110,24 +137,46 @@ module SequenceServer
 
       # Create BLAST database, given FASTA file and sequence type in FASTA file.
       def make_blast_database(file, type)
+        return unless make_blast_database? file, type
+        title = get_database_title(file)
+        _make_blast_database(file, type, title)
+      end
+
+      def _make_blast_database(file, type, title, quiet = false)
+        cmd = 'makeblastdb -parse_seqids -hash_index ' \
+              "-in #{file} -dbtype #{type.to_s.slice(0, 4)} -title '#{title}'"
+        cmd << ' &> /dev/null' if quiet
+        system cmd
+      end
+
+      # Show file path and guessed sequence type to the user and obtain a y/n
+      # response.
+      #
+      # Returns true if the user entered anything but 'n' or 'N'.
+      def make_blast_database?(file, type)
+        puts
+        puts
         puts "FASTA file: #{file}"
         puts "FASTA type: #{type}"
+        print 'Proceed? [y/n] (Default: y): '
 
-        print "Proceed? [y/n] (Default: y): "
         response = STDIN.gets.to_s.strip
+        !response.match(/n/i)
+      end
 
-        unless response.match(/n/i)
-          default_title = make_db_title(File.basename(file))
-          print "Enter a database title or will use '#{default_title}': "
-          title = STDIN.gets.to_s
-          title = default_title if title.strip.empty?
-
-          `makeblastdb -parse_seqids -hash_index \
-            -in #{file} -dbtype #{type.to_s.slice(0,4)} -title "#{title}"`
-        end
+      # Generate a title for the given database and show it to the user for
+      # confirmation.
+      #
+      # Returns user input if any. Auto-generated title otherwise.
+      def get_database_title(path)
+        default = make_db_title(File.basename(path))
+        print "Enter a database title or will use '#{default}': "
+        from_user = STDIN.gets.to_s
+        from_user.strip.empty? && default || from_user
       end
 
-      # Returns true if the database name appears to be a multi-part database name.
+      # 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
@@ -166,30 +215,21 @@ module SequenceServer
       # NOTE: 2^15 == 32786. Approximately 546 lines, assuming 60 characters on
       # each line.
       def guess_sequence_type_in_fasta(file)
-        sample = File.read(file, 32768)
-        sequences = sample.split(/^>.+$/).delete_if { |seq| seq.empty? }
-        sequence_types = sequences.map {|seq| Sequence.guess_type(seq)}.uniq.compact
+        sequences = sample_sequences(file)
+        sequence_types = sequences.map { |seq| Sequence.guess_type(seq) }
+        sequence_types = sequence_types.uniq.compact
         (sequence_types.length == 1) && sequence_types.first
       end
-    end
 
-    def initialize(*args)
-      args[2].downcase!   # database type
-      args.each(&:freeze)
-      super
-
-      @id = Digest::MD5.hexdigest args.first
-    end
-
-    attr_reader :id
-
-    def include?(accession)
-      out = `blastdbcmd -entry '#{accession}' -db #{name} 2> /dev/null`
-      not out.empty?
-    end
-
-    def to_s
-      "#{type}: #{title} #{name}"
+      # Read first 32768 characters of the file. Split on fasta def line
+      # pattern and return.
+      #
+      # If the given file is FASTA, returns Array of as many different
+      # sequences in the portion of the file read. Returns the portion
+      # of the file read wrapped in an Array otherwise.
+      def sample_sequences(file)
+        File.read(file, 32_768).split(/^>.+$/).delete_if(&:empty?)
+      end
     end
   end
 end

data/lib/sequenceserver/exceptions.rb

@@ -0,0 +1,154 @@
+# This file defines all possible exceptions that can be thrown by
+# SequenceServer 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/sequenceserver or config.ru) to act
+# on them.
+
+module SequenceServer
+  # 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 in 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 database dir set, but does not exist.
+  class DATABASE_DIR_NOT_FOUND < ENOENT
+    def initialize(ent)
+      super 'database 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
+
+  ## BLAST NOT INSTALLED OR NOT COMPATIBLE ##
+
+  # Raised if SequenceServer could not locate NCBI BLAST+ installation on
+  # user's system.
+  class BLAST_NOT_INSTALLED < StandardError
+    def to_s
+      'Could not locate BLAST+ binaries.'
+    end
+  end
+
+  # Raised if SequenceServer determined NCBI BLAST+ present on the user's
+  # system but not meeting SequenceServer's minimum version requirement.
+  class BLAST_NOT_COMPATIBLE < StandardError
+    def initialize(version)
+      @version  = version
+    end
+
+    attr_reader :version
+
+    def to_s
+      <<MSG
+Your BLAST+ version #{version} is outdated.
+SequenceServer needs NCBI BLAST+ version #{MINIMUM_BLAST_VERSION} or higher.
+MSG
+    end
+  end
+
+  ## BLAST+ DATABASE RELATED ##
+
+  # Raised if 'database_dir' not set.
+  class DATABASE_DIR_NOT_SET < StandardError
+    def to_s
+      'Database dir not set.'
+    end
+  end
+
+  # Raised if not even one BLAST+ database was found in database_dir.
+  class NO_BLAST_DATABASE_FOUND < StandardError
+    def initialize(database_dir)
+      @database_dir = database_dir
+    end
+
+    attr_reader :database_dir
+
+    def to_s
+      "Could not find BLAST+ databases in: #{database_dir}."
+    end
+  end
+
+  # Raised if there was an error determining BLAST+ databases in database_dir.
+  class BLAST_DATABASE_ERROR
+    def initialize(cmd, out)
+      @cmd = cmd
+      @out = out
+    end
+
+    attr_reader :cmd, :out
+
+    def to_s
+      <<MSG
+Error obtaining BLAST databases.
+Tried: #{cmd}
+Error:
+#{out.strip}
+
+Please could you report this to 'https://groups.google.com/forum/#!forum/sequenceserver'?
+MSG
+    end
+  end
+end