BioDSL 1.0.0

data/lib/BioDSL/commands/trim_primer.rb

@@ -0,0 +1,314 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of the BioDSL framework (www.BioDSL.org).        #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # == Trim sequence ends in the stream matching a specified primer.
+  #
+  # +trim_primer+ can trim full or partial primer sequence from sequence ends.
+  # This is done by matching the primer at the end specified by the +direction+
+  # option:
+  #
+  # Forward clip:
+  #     sequence       ATCGACTGCATCACGACG
+  #     primer    CATGAATCGA
+  #     result              CTGCATCACGACG
+  #
+  # Reverse clip:
+  #     sequence  ATCGACTGCATCACGACG
+  #     primer                  GACGATAGCA
+  #     result    ATCGACTGCATCAC
+  #
+  # The primer sequence can be reverse complemented using the
+  # +reverse_complement+ option. Also, a minimum overlap for trimming can be
+  # specified using the +overlap_min+ option (default=1).
+  #
+  # Non-perfect matching can be allowed by setting the allowed
+  # +mismatch_percent+, +insertion_percent+ and +deletion_percent+.
+  #
+  # The following keys are added to clipped records:
+  #
+  # * TRIM_PRIMER_DIR - Direction of clip.
+  # * TRIM_PRIMER_POS - Sequence position of clip (0 based).
+  # * TRIM_PRIMER_LEN - Length of clip match.
+  # * TRIM_PRIMER_PAT - Clip match pattern.
+  # == Usage
+  #
+  #    trim_primer(<primer: <string>>, <direction: <:forward|:reverse>
+  #                [, reverse_complement: <bool>[, overlap_min: <uint>
+  #                [, mismatch_percent: <uint>
+  #                [, insertion_percent: <uint>
+  #                [, deletion_percent: <uint>]]]]])
+  #
+  # === Options
+  #
+  # * primer: <string>               - Primer sequence to search for.
+  # * direction: <:forward|:reverse> - Clip direction.
+  # * reverse_complement: <bool>     - Reverse complement primer (default=false)
+  # * overlap_min: <uint>            - Minimum primer length used (default=1)
+  # * mismatch_percent: <unit>       - Allowed percent mismatches (default=0)
+  # * insertion_percent: <unit>      - Allowed percent insertions (default=0)
+  # * deletion_percent: <unit>       - Allowed percent mismatches (default=0)
+  #
+  # == Examples
+  #
+  # Consider the following FASTA entry in the file test.fna:
+  #
+  #     >test
+  #     ACTGACTGATGACTACGACTACGACTACTACTACGT
+  #
+  # The forward end can be trimmed like this:
+  #
+  #     BP.new.
+  #     read_fasta(input: "test.fna").
+  #     trim_primer(primer: "ATAGAACTGAC", direction: :forward).
+  #     dump.
+  #     run
+  #
+  #     {:SEQ_NAME=>"test",
+  #      :SEQ=>"TGATGACTACGACTACGACTACTACTACGT",
+  #      :SEQ_LEN=>30,
+  #      :TRIM_PRIMER_DIR=>"FORWARD",
+  #      :TRIM_PRIMER_POS=>0,
+  #      :TRIM_PRIMER_LEN=>6,
+  #      :TRIM_PRIMER_PAT=>"ACTGAC"}
+  #
+  # And trimming a reverse primer:
+  #
+  #     BP.new.
+  #     read_fasta(input: "test.fna").
+  #     trim_primer(primer: "ACTACGTGCGGAT", direction: :reverse).
+  #     dump.
+  #     run
+  #
+  #     {:SEQ_NAME=>"test",
+  #      :SEQ=>"ACTGACTGATGACTACGACTACGACTACT",
+  #      :SEQ_LEN=>29,
+  #      :TRIM_PRIMER_DIR=>"REVERSE",
+  #      :TRIM_PRIMER_POS=>29,
+  #      :TRIM_PRIMER_LEN=>7,
+  #      :TRIM_PRIMER_PAT=>"ACTACGT"}
+  #
+  # rubocop: disable ClassLength
+  class TrimPrimer
+    STATS = %i(records_in records_out sequences_in sequences_out pattern_hits
+               pattern_misses residues_in residues_out)
+
+    # Constructor for TrimPrimer.
+    #
+    # @param options [Hash] Options hash.
+    # @option options [String]   :primer
+    # @option options [Symbol]   :direction
+    # @option options [Boolean]  :overlap_min
+    # @option options [Boolean]  :reverse_complement
+    # @option options [Integer]  :mismatch_percent
+    # @option options [Ingetger] :insertion_percent
+    # @option options [Integer]  :deletion_percent
+    #
+    # @return [TrimPrimer] Class instance.
+    def initialize(options)
+      @options = options
+      @options[:overlap_min]       ||= 1
+      @options[:mismatch_percent]  ||= 0
+      @options[:insertion_percent] ||= 0
+      @options[:deletion_percent]  ||= 0
+      @pattern = pattern
+      @hit     = false
+
+      check_options
+    end
+
+    # Return command lambda for trim_primer.
+    #
+    # @return [Proc] Command lambda.
+    def lmb
+      lambda do |input, output, status|
+        status_init(status, STATS)
+
+        input.each do |record|
+          @status[:records_in] += 1
+
+          if record[:SEQ] && record[:SEQ].length > 0
+            @status[:sequences_in] += 1
+
+            case @options[:direction]
+            when :forward then trim_forward(record)
+            when :reverse then trim_reverse(record)
+            end
+          end
+
+          output << record
+
+          @status[:records_out] += 1
+        end
+      end
+    end
+
+    private
+
+    # Check options.
+    def check_options
+      options_allowed(@options, :primer, :direction, :overlap_min,
+                      :reverse_complement, :mismatch_percent,
+                      :insertion_percent, :deletion_percent)
+      options_required(@options, :primer, :direction)
+      options_allowed_values(@options, direction: [:forward, :reverse])
+      options_allowed_values(@options, reverse_complement: [true, false])
+      options_assert(@options, ':overlap_min        >  0')
+      options_assert(@options, ':mismatch_percent  >= 0')
+      options_assert(@options, ':insertion_percent >= 0')
+      options_assert(@options, ':deletion_percent  >= 0')
+    end
+
+    # Determine the pattern from the sequence and reverse complement if need be.
+    def pattern
+      if @options[:reverse_complement]
+        Seq.new(seq: @options[:primer], type: :dna).reverse.complement.seq
+      else
+        @options[:primer]
+      end
+    end
+
+    # Trim record with sequence in the forward direction.
+    #
+    # @param record [Hash] BioDSL record
+    def trim_forward(record)
+      entry = BioDSL::Seq.new_bp(record)
+
+      @status[:residues_in]  += entry.length
+
+      while @pattern.length >= @options[:overlap_min]
+        if (match = match_forward(entry))
+          merge_forward(record, entry, match)
+          @hit = true
+          break
+        end
+
+        @pattern = @pattern[1...@pattern.length]
+      end
+
+      @hit ? @status[:pattern_hits] += 1 : @status[:pattern_misses] += 1
+    end
+
+    # Search a given entry and return match data.
+    #
+    # @param entry [BioDSL::Seq] Sequence entry.
+    #
+    # @return [BioDSL::Seq::Match,nil] Match result.
+    def match_forward(entry)
+      match_opt         = match_options(@pattern.length)
+      match_opt[:start] = 0
+      match_opt[:stop]  = 0
+
+      entry.patmatch(@pattern, match_opt)
+    end
+
+    # Use given match data to extract subsequence from given entry and merge to
+    # the given record.
+    #
+    # @param record [Hash] BioDSL record
+    # @param entry [BioDSL::Seq] Sequence entry.
+    # @param match [BioDSL::Seq::Match] Match data.
+    def merge_forward(record, entry, match)
+      entry = entry[match.pos + match.length..-1]
+
+      record.merge!(entry.to_bp)
+      record[:TRIM_PRIMER_DIR] = 'FORWARD'
+      record[:TRIM_PRIMER_POS] = match.pos
+      record[:TRIM_PRIMER_LEN] = match.length
+      record[:TRIM_PRIMER_PAT] = match.match
+    end
+
+    # Trim record with sequence in the reverse direction.
+    #
+    # @param record [Hash] BioDSL record
+    def trim_reverse(record)
+      entry = BioDSL::Seq.new_bp(record)
+
+      @status[:residues_in]  += entry.length
+
+      while @pattern.length >= @options[:overlap_min]
+        if (match = match_reverse(entry))
+          merge_reverse(record, entry, match)
+          @hit = true
+          break
+        end
+
+        @pattern = @pattern[0...@pattern.length - 1]
+      end
+
+      @hit ? @status[:pattern_hits] += 1 : @status[:pattern_misses] += 1
+    end
+
+    # Search a given entry and return match data.
+    #
+    # @param entry [BioDSL::Seq] Sequence entry.
+    #
+    # @return [BioDSL::Seq::Match,nil] Match result.
+    def match_reverse(entry)
+      match_opt = match_options(@pattern.length)
+
+      start = entry.length - @pattern.length
+      start = 0 if start < 0
+
+      match_opt[:start] = start
+
+      entry.patmatch(@pattern, match_opt)
+    end
+
+    # Use given match data to extract subsequence from given entry and merge to
+    # the given record.
+    #
+    # @param record [Hash] BioDSL record
+    # @param entry [BioDSL::Seq] Sequence entry.
+    # @param match [BioDSL::Seq::Match] Match data.
+    def merge_reverse(record, entry, match)
+      entry = entry[0...match.pos]
+
+      record.merge!(entry.to_bp)
+      record[:TRIM_PRIMER_DIR] = 'REVERSE'
+      record[:TRIM_PRIMER_POS] = match.pos
+      record[:TRIM_PRIMER_LEN] = match.length
+      record[:TRIM_PRIMER_PAT] = match.match
+    end
+
+    # Calculate from the given pattern lenght the absolue mismatches, insertions
+    # and deletions allowed and return a hash with these values.
+    #
+    # @param length [Integer] Pattern length.
+    #
+    # @return [Hash] Match options hash.
+    def match_options(length)
+      mis = (length * @options[:mismatch_percent]  * 0.01).round
+      ins = (length * @options[:insertion_percent] * 0.01).round
+      del = (length * @options[:deletion_percent]  * 0.01).round
+
+      {max_mismatches: mis,
+       max_insertions: ins,
+       max_deletions:  del}
+    end
+  end
+end

data/lib/BioDSL/commands/trim_seq.rb

@@ -0,0 +1,192 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of the BioDSL framework (www.BioDSL.org).        #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # == Trim sequence ends removing residues with a low quality score.
+  #
+  # +trim_seq+ removes subquality residues from the ends of sequences in the
+  # stream based on quality SCORES in a FASTQ type quality score string.
+  # Trimming progresses until a stretch, specified with the +length_min+
+  # option, is found thus preventing premature termination of the trimming
+  # by e.g. a single good quality residue at the end. It is possible, using
+  # the +mode+ option to indicate if the sequence should be trimmed from the
+  # left or right end or both (default=:both).
+  #
+  # == Usage
+  #
+  #    trim_seq([quality_min: <uint>[, length_min: <uint>
+  #             [, mode: <:left|:right|:both>]]])
+  #
+  # === Options
+  #
+  # * quality_min: <uint> - Minimum quality (default=20).
+  # * length_min: <uint>  - Minimum stretch length (default=3).
+  # * mode: <string>      - Trim mode :left|:right|:both (default=:both).
+  #
+  # == Examples
+  #
+  # Consider the following FASTQ entry in the file test.fq:
+  #
+  #    @test
+  #    gatcgatcgtacgagcagcatctgacgtatcgatcgttgattagttgctagctatgcagtctacgacgagcat
+  #    +
+  #    @ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghhgfedcba`_^]\[ZYXWVUTSRQPONMLKJI
+  #
+  # To trim both ends simply do:
+  #
+  #    BP.new.read_fastq(input: "test.fq").trim_seq.trim_seq.run
+  #
+  #    SEQ_NAME: test
+  #    SEQ: tctgacgtatcgatcgttgattagttgctagctatgcagtctacgacgagcat
+  #    SEQ_LEN: 62
+  #    SCORES: TUVWXYZ[\]^_`abcdefghhgfedcba`_^]\[ZYXWVUTSRQPONMLKJI
+  #    ---
+  #
+  # Use the +quality_min+ option to change the minimum value to discard:
+  #
+  #    BP.new.
+  #    read_fastq(input: "test.fq").
+  #    trim_seq(quality_min: 25).
+  #    trim_seq.
+  #    run
+  #
+  #    SEQ_NAME: test
+  #    SEQ: cgtatcgatcgttgattagttgctagctatgcagtctacgacgagcatgctagctag
+  #    SEQ_LEN: 57
+  #    SCORES: YZ[\]^_`abcdefghhgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDChhh
+  #    ---
+  #
+  # To trim the left end only (use :rigth for right end only), do:
+  #
+  #    BP.new.read_fastq(input: "test.fq").trim_seq(mode: :left).trim_seq.run
+  #
+  #    SEQ_NAME: test
+  #    SEQ: tctgacgtatcgatcgttgattagttgctagctatgcagtctacgacgagcatgctagctag
+  #    SEQ_LEN: 62
+  #    SCORES: TUVWXYZ[\]^_`abcdefghhgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDChhh
+  #    ---
+  #
+  # To increase the length of stretch of good quality residues to match, use
+  # the +length_min+ option:
+  #
+  #    BP.new.read_fastq(input: "test.fq").trim_seq(length_min: 4).trim_seq.run
+  #
+  #    SEQ_NAME: test
+  #    SEQ: tctgacgtatcgatcgttgattagttgctagctatgcagtct
+  #    SEQ_LEN: 42
+  #    SCORES: TUVWXYZ[\]^_`abcdefghhgfedcba`_^]\[ZYXWVUT
+  #    ---
+  class TrimSeq
+    STATS = %i(records_in records_out sequences_in sequences_out residues_in
+               residues_out)
+
+    # Constructor for the TrimSeq class.
+    #
+    # @param [Hash] options Options hash.
+    #
+    # @option options [Integer] :quality_min
+    #   TrimSeq minimum quality (default=20).
+    #
+    # @option options [Symbol] :mode
+    #   TrimSeq mode (default=:both).
+    #
+    # @option options [Integer] :length_min
+    #   TrimSeq stretch length triggering trim (default=3).
+    #
+    # @return [Proc] Returns the trim_seq command lambda.
+    #
+    # @return [TrimSeq] Returns an instance of the TrimSeq class.
+    def initialize(options)
+      @options = options
+
+      check_options
+      defaults
+
+      @mode = @options[:mode].to_sym
+      @min  = @options[:quality_min]
+      @len  = @options[:length_min]
+    end
+
+    # Return a lambda for the trim_seq command.
+    #
+    # @return [Proc] Returns the trim_seq command lambda.
+    def lmb
+      lambda do |input, output, status|
+        status_init(status, STATS)
+
+        input.each do |record|
+          @status[:records_in] += 1
+
+          trim_seq(record) if record[:SEQ] && record[:SCORES]
+
+          output << record
+
+          @status[:records_out] += 1
+        end
+      end
+    end
+
+    private
+
+    # Check the options.
+    def check_options
+      options_allowed(@options, :quality_min, :length_min, :mode)
+      options_allowed_values(@options, mode: [:left, :right, :both])
+      options_assert(@options, ':quality_min >= 0')
+      options_assert(@options, ':quality_min <= 40')
+      options_assert(@options, ':length_min > 0')
+    end
+
+    # Set defaul options.
+    def defaults
+      @options[:quality_min] ||= 20
+      @options[:mode]        ||= :both
+      @options[:length_min]  ||= 3
+    end
+
+    # Trim sequence in a given record with sequence info.
+    #
+    # @param record [Hash] BioDSL record
+    def trim_seq(record)
+      entry = BioDSL::Seq.new_bp(record)
+
+      @status[:sequences_in] += 1
+      @status[:residues_in]  += entry.length
+
+      case @mode
+      when :both  then entry.quality_trim!(@min, @len)
+      when :left  then entry.quality_trim_left!(@min, @len)
+      when :right then entry.quality_trim_right!(@min, @len)
+      end
+
+      @status[:sequences_out] += 1
+      @status[:residues_out]  += entry.length
+
+      record.merge! entry.to_bp
+    end
+  end
+end

data/lib/BioDSL/commands/uchime_ref.rb

@@ -0,0 +1,170 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of the BioDSL framework (www.BioDSL.org).        #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # == Run uchime_ref on sequences in the stream.
+  #
+  # This is a wrapper for the +usearch+ tool to run the program uchime_ref.
+  # Basically sequence type records are searched against a reference database or
+  # non-chimeric sequences, and chimirec sequences are filtered out so only
+  # non-chimeric sequences are output.
+  #
+  # Please refer to the manual:
+  #
+  # http://drive5.com/usearch/manual/uchime_ref.html
+  #
+  # Usearch 7.0 must be installed for +usearch+ to work. Read more here:
+  #
+  # http://www.drive5.com/usearch/
+  #
+  # == Usage
+  #
+  #    uchime_ref(<database: <file>[cpus: <uint>])
+  #
+  # === Options
+  #
+  # * database: <file> - Database to search (in FASTA format).
+  # * cpus:     <uint> - Number of CPU cores to use (default=1).
+  #
+  # == Examples
+  #
+  class UchimeRef
+    require 'BioDSL/helpers/aux_helper'
+
+    include AuxHelper
+
+    STATS = %i(records_in records_out sequences_in sequences_out residues_in
+               residues_out)
+
+    # Constructor for UchimeRef.
+    #
+    # @param options [Hash] Options hash.
+    # @option options [String] :database
+    # @option options [Integer] :cpus
+    #
+    # @return [UchimeRef] Class instance.
+    def initialize(options)
+      @options = options
+      aux_exist('usearch')
+      check_options
+      @options[:cpus]   ||= 1
+      @options[:strand] ||= 'plus'  # This option cant be changed in usearch7.0
+    end
+
+    # Return command lambda for uchime_ref.
+    #
+    # @return [Proc] Command lambda.
+    def lmb
+      lambda do |input, output, status|
+        status_init(status, STATS)
+
+        TmpDir.create('input', 'output') do |tmp_in, tmp_out|
+          process_input(input, output, tmp_in)
+          run_uchime_ref(tmp_in, tmp_out)
+
+          process_output(output, tmp_out)
+        end
+      end
+    end
+
+    private
+
+    # Check options.
+    def check_options
+      options_allowed(@options, :database, :cpus)
+      options_required(@options, :database)
+      options_files_exist(@options, :database)
+      options_assert(@options, ':cpus >= 1')
+      options_assert(@options, ":cpus <= #{BioDSL::Config::CORES_MAX}")
+    end
+
+    # Process input stream and save records with sequences to a temporary FASTA
+    # file or emit non-sequence containing records to the output stream.
+    #
+    # @param input  [Enumerator] Input stream.
+    # @param output [Enumerator::Yielder] Output stream.
+    # @param tmp_in [String] Path to temporary FASTA file.
+    def process_input(input, output, tmp_in)
+      BioDSL::Fasta.open(tmp_in, 'w') do |ios|
+        input.each_with_index do |record, i|
+          @status[:records_in] += 1
+
+          if record[:SEQ]
+            @status[:sequences_in] += 1
+            @status[:residues_in]  += record[:SEQ].length
+            seq_name = record[:SEQ_NAME] || i.to_s
+
+            entry = BioDSL::Seq.new(seq_name: seq_name, seq: record[:SEQ])
+
+            ios.puts entry.to_fasta
+          else
+            output << record
+            @status[:records_out] += 1
+          end
+        end
+      end
+    end
+
+    # Run uchime_ref on input file and save result input file.
+    #
+    # @param tmp_in [String] Path to input file.
+    # @param tmp_out [String] Path to output file.
+    #
+    # @raise [BioDSL::UsearchError] If command fails.
+    def run_uchime_ref(tmp_in, tmp_out)
+      uchime_opts = {
+        input: tmp_in,
+        output: tmp_out,
+        database: @options[:database],
+        strand: @options[:strand],
+        cpus: @options[:cpus],
+        verbose: @options[:verbose]
+      }
+
+      BioDSL::Usearch.uchime_ref(uchime_opts)
+    rescue BioDSL::UsearchError => e
+      raise unless e.message =~ /Empty input file/
+    end
+
+    # Process uchime_ref output data and emit to output stream.
+    #
+    # @param output [Enumerator::Yielder] Output stream.
+    # @param tmp_out [String] Path to file with uchime_ref data.
+    def process_output(output, tmp_out)
+      Fasta.open(tmp_out) do |ios|
+        ios.each do |entry|
+          record = entry.to_bp
+
+          output << record
+          @status[:sequences_out] += 1
+          @status[:residues_out]  += entry.length
+          @status[:records_out]   += 1
+        end
+      end
+    end
+  end
+end