demultiplexer 0.0.1

data/lib/demultiplexer/version.rb

@@ -0,0 +1,26 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2014-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                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+class Demultiplexer
+  VERSION = "0.0.1"
+end

data/lib/index_builder.rb

@@ -0,0 +1,181 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2014-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                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+# Class containing methods for building an search index.
+class IndexBuilder
+  # Class method that build a search index from a given Array of samples.
+  #
+  # samples - Array of samples (Sample objects with id, index1 and index2).
+  #
+  # Examples
+  #
+  #   IndexBuilder.build(samples)
+  #     # => <Google Hash>
+  #
+  # Returns a Google Hash where the key is the index and the value is the TODO
+  def self.build(samples, mismatches_max)
+    index_builder = new(samples, mismatches_max)
+    index_hash    = index_builder.index_init
+    index_builder.index_populate(index_hash)
+  end
+
+  # Constructor method for IndexBuilder object. The given Array of samples and
+  # mismatches_max are saved as an instance variable.
+  #
+  # samples        - Array of Sample objects.
+  # mismatches_max - Integer denoting the maximum number of misses allowed in
+  #                  an index sequence.
+  #
+  # Examples
+  #
+  #   IndexBuilder.new(samples, 2)
+  #     # => <IndexBuilder>
+  #
+  # Returns an IndexBuilder object.
+  def initialize(samples, mismatches_max)
+    @samples        = samples
+    @mismatches_max = mismatches_max
+  end
+
+  # Method to initialize the index. If @mismatches_max is <= then
+  # GoogleHashSparseLongToInt is used else GoogleHashDenseLongToInt due to
+  # memory and performance.
+  #
+  # Returns a Google Hash.
+  def index_init
+    if @mismatches_max <= 1
+      index_hash = GoogleHashSparseLongToInt.new
+    else
+      index_hash = GoogleHashDenseLongToInt.new
+    end
+
+    index_hash
+  end
+
+  # Method to populate the index.
+  #
+  # index_hash - Google Hash with initialized index.
+  #
+  # Returns a Google Hash.
+  def index_populate(index_hash)
+    @samples.each_with_index do |sample, i|
+      index_list1 = permutate([sample.index1], @mismatches_max)
+      index_list2 = permutate([sample.index2], @mismatches_max)
+
+      # index_check_list_sizes(index_list1, index_list2)
+
+      index_list1.product(index_list2).each do |index1, index2|
+        key = "#{index1}#{index2}".hash
+
+        index_check_existing(index_hash, key)
+
+        index_hash[key] = i
+      end
+    end
+
+    index_hash
+  end
+
+  private
+
+  # Method to check if two index lists differ in size, if so an exception is
+  # raised.
+  #
+  # index_list1 - Array with index1
+  # index_list2 - Array with index2
+  #
+  # Returns nothing.
+  def index_check_list_sizes(index_list1, index_list2)
+    return if index_list1.size == index_list2.size
+
+    fail "Permutated list sizes differ: \
+    #{index_list1.size} != #{index_list2.size}"
+  end
+
+  # Method to check if a index key already exists in the index, and if so an
+  # exception is raised.
+  #
+  # index_hash - Google Hash with index
+  # key        - Integer from Google Hash's #hash method
+  #
+  # Returns nothing.
+  def index_check_existing(index_hash, key)
+    return unless index_hash[key]
+
+    fail "Index combo of #{index1} and #{index2} already exists for \
+         sample id: #{@samples[index_hash[key]].id} and #{sample.id}"
+  end
+
+  # Method that for each word in a given Array of word permutates each word a
+  # given number (permuate) of times using a given alphabet, such that an Array
+  # of words with all possible combinations is returned.
+  #
+  # list     - Array of words (Strings) to permutate.
+  # permuate - Number of permutations (Integer).
+  # alphabet - String with alphabet used for permutation.
+  #
+  # Examples
+  #
+  #   permutate(["AA"], 1, "ATCG")
+  #   # => ["AA", "TA", "CA", "GA", "AA", "AT", "AC, "AG"]
+  #
+  # Returns an Array with permutated words (Strings).
+  def permutate(list, permutations = 2, alphabet = 'ATCG')
+    permutations.times do
+      set = list.each_with_object(Set.new) { |e, a| a.add(e.to_sym) }
+
+      list.each do |word|
+        new_words = permutate_word(word, alphabet)
+        new_words.map { |new_word| set.add(new_word.to_sym) }
+      end
+
+      list = set.map(&:to_s)
+    end
+
+    list
+  end
+
+  # Method that permutates a given word using a given alphabet, such that an
+  # Array of words with all possible combinations is returned.
+  #
+  # word     - String with word to permutate.
+  # alphabet - String with alphabet used for permutation.
+  #
+  # Examples
+  #
+  #   permutate("AA", "ATCG")
+  #   # => ["AA", "TA", "CA", "GA", "AA", "AT", "AC, "AG"]
+  #
+  # Returns an Array with permutated words (Strings).
+  def permutate_word(word, alphabet)
+    new_words = []
+
+    (0...word.size).each do |pos|
+      alphabet.each_char do |char|
+        new_words << "#{word[0...pos]}#{char}#{word[pos + 1..-1]}"
+      end
+    end
+
+    new_words
+  end
+end

data/lib/sample_reader.rb

@@ -0,0 +1,198 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2014-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                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+# Class containing methods for reading and checking sample information.
+class SampleReader
+  # Class method that reads sample information from a samples file, which
+  # consists of ASCII text in three tab separated columns: The first column is
+  # the sample_id, the second column is index1 and the third column is index2.
+  #
+  # If revcomp1 or revcomp2 is set then index1 and index2 are
+  # reverse-complemented accordingly.
+  #
+  # file     - String with path to sample file.
+  # revcomp1 - Flag indicating that index1 should be reverse-complemented.
+  # revcomp2 - Flag indicating that index2 should be reverse-complemented.
+  #
+  # Examples
+  #
+  #   SampleReader.read("samples.txt", false, false)
+  #   # => [<Sample>, <Sample>, <Sample> ...]
+  #
+  # Returns an Array of Sample objects.
+  def self.read(file, revcomp1, revcomp2)
+    sample_reader = new(revcomp1, revcomp2)
+    sample_reader.samples_parse(file)
+  end
+
+  # Constructor method for SampleReader object. The given revcomp1 and revcomp2
+  # flags are stored as instance variables.
+  #
+  # revcomp1 - Flag indicating that index1 should be reverse-complemented.
+  # revcomp2 - Flag indicating that index2 should be reverse-complemented.
+  #
+  # Examples
+  #
+  #   SampleReader.new(false, false)
+  #   # => <SampleReader>
+  #
+  # Returns SampleReader object.
+  def initialize(revcomp1, revcomp2)
+    @revcomp1 = revcomp1
+    @revcomp2 = revcomp2
+  end
+
+  # Method that reads sample information from a samples file, which consists
+  # of ASCII text in three tab separated columns: The first column is the
+  # sample_id, the second column is index1 and the third column is index2.
+  #
+  # file - String with path to sample file.
+  #
+  # Examples
+  #
+  #   samples_parse("samples.txt")
+  #   # => [<Sample>, <Sample>, <Sample> ...]
+  #
+  # Returns an Array of Sample objects.
+  def samples_parse(file)
+    samples = samples_read(file)
+    samples_reverse_complement(samples)
+    errors = []
+    errors.push(*samples_check_index_combo(samples))
+    errors.push(*samples_check_uniq_id(samples))
+
+    unless errors.empty?
+      pp errors
+      fail 'errors found in sample file.'
+    end
+
+    samples
+  end
+
+  private
+
+  # Method that reads sample information form a samples file, which consists
+  # of ASCII text in three tab separated columns: The first column is the
+  # sample_id, the second column is index1 and the third column is index2.
+  #
+  # If @options[:revcomp_index1] or @options[:revcomp_index2] is set then
+  # index1 and index2 are reverse-complemented accordingly.
+  #
+  # file - String with path to sample file.
+  #
+  # Examples
+  #
+  #   samples_read("samples.txt")
+  #   # => [<Sample>, <Sample>, <Sample> ...]
+  #
+  # Returns an Array of Sample objects.
+  def samples_read(file)
+    samples = []
+
+    CSV.read(file, col_sep: "\t").each do |id, index1, index2|
+      samples << Sample.new(id, index1, index2)
+    end
+
+    samples
+  end
+
+  # Method that iterates over the a given Array of sample Objects, and if
+  # @options[:revcomp_index1] or @options[:revcomp_index2] is set then
+  # index1 and index2 are reverse-complemented accordingly.
+  #
+  # samples - Array of Sample objects.
+  #
+  # Returns nothing.
+  def samples_reverse_complement(samples)
+    samples.each do |sample|
+      sample.index1 = index_reverse_complement(sample.index1) if @revcomp1
+      sample.index2 = index_reverse_complement(sample.index2) if @revcomp2
+    end
+  end
+
+  # Method that reverse-complements a given index sequence.
+  #
+  # index - Index String.
+  #
+  # Returns reverse-complemented index String.
+  def index_reverse_complement(index)
+    BioPieces::Seq.new(seq: index, type: :dna).reverse.complement.seq
+  end
+
+  # Method that iterates over the a given Array of sample Objects, and if
+  # the combination of index1 and index2 is non-unique an error is pushed
+  # on an error Array.
+  #
+  # samples - Array of Sample objects.
+  #
+  # Returns an Array of found errors.
+  def samples_check_index_combo(samples)
+    errors = []
+    lookup = {}
+
+    samples.each do |sample|
+      if (id2 = lookup["#{sample.index1}#{sample.index2}"])
+        errors << ['Samples with same index combo', sample.id, id2].join("\t")
+      else
+        lookup["#{sample.index1}#{sample.index2}"] = sample.id
+      end
+    end
+
+    errors
+  end
+
+  # Method that iterates over the a given Array of sample Objects, and if
+  # a sample id is non-unique an error is pushed  on an error Array.
+  #
+  # samples - Array of Sample objects.
+  #
+  # Returns an Array of found errors.
+  def samples_check_uniq_id(samples)
+    errors = []
+    lookup = Set.new
+
+    samples.each do |sample|
+      if lookup.include? sample.id
+        errors << ['Non-unique sample id', sample.id].join("\t")
+      end
+
+      lookup << sample.id
+    end
+
+    errors
+  end
+
+  # Struct for holding sample information.
+  #
+  # id     - Sample id.
+  # index1 - Index1 sequence.
+  # index2 - Index2 sequence.
+  #
+  # Examples
+  #
+  #   Sample.new("test1", "atcg", "gcta")
+  #     # => <Sample>
+  #
+  # Returns Sample object.
+  Sample = Struct.new(:id, :index1, :index2)
+end

data/lib/screen.rb

@@ -0,0 +1,39 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2014-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                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+# Module containing class methods for clearing and resetting a terminal screen.
+module Screen
+  # Method that uses console code to clear the screen.
+  #
+  # Returns nothing.
+  def self.clear
+    print "\e[H\e[2J"
+  end
+
+  # Method that uses console code to move cursor to 1,1 coordinate.
+  #
+  # Returns nothing.
+  def self.reset
+    print "\e[1;1H"
+  end
+end

data/lib/status.rb

@@ -0,0 +1,101 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2014-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                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+# Class containing methods to records demultiplexing status.
+class Status
+  attr_accessor :count, :match, :undetermined, :index1_bad_mean,
+                :index2_bad_mean, :index1_bad_min, :index2_bad_min
+  # Method to initialize a Status object, which contains the following instance
+  # variables initialized to 0:
+  #
+  #   @count           - Number or reads.
+  #   @match           - Number of reads found in index.
+  #   @undetermined    - Number of reads not found in index.
+  #   @index1_bad_mean - Number of reads dropped due to bad mean in index1.
+  #   @index2_bad_mean - Number of reads dropped due to bad mean in index2.
+  #   @index1_bad_min  - Number of reads dropped due to bad min in index1.
+  #   @index2_bad_min  - Number of reads dropped due to bad min in index2.
+  #
+  # Examples
+  #
+  #   Status.new
+  #   # => <Status>
+  #
+  # Returns a Status object.
+  def initialize
+    @count           = 0
+    @match           = 0
+    @undetermined    = 0
+    @index1_bad_mean = 0
+    @index2_bad_mean = 0
+    @index1_bad_min  = 0
+    @index2_bad_min  = 0
+    @time_start      = Time.now
+  end
+
+  # Method to format a String from a Status object. This is done by adding the
+  # relevant instance variables to a Hash and return this as an YAML String.
+  #
+  # Returns a YAML String.
+  def to_s
+    { count:                @count,
+      match:                @match,
+      undetermined:         @undetermined,
+      undetermined_percent: undetermined_percent,
+      index1_bad_mean:      @index1_bad_mean,
+      index2_bad_mean:      @index2_bad_mean,
+      index1_bad_min:       @index1_bad_min,
+      index2_bad_min:       @index2_bad_min,
+      time:                 time }.to_yaml
+  end
+
+  # Method that calculate the percentage of undetermined reads.
+  #
+  # Returns a Float with the percentage of undetermined reads.
+  def undetermined_percent
+    (100 * @undetermined / @count.to_f).round(1)
+  end
+
+  # Method that calculates the elapsed time and formats a nice Time String.
+  #
+  # Returns String with elapsed time.
+  def time
+    time_elapsed = Time.now - @time_start
+    (Time.mktime(0) + time_elapsed).strftime('%H:%M:%S')
+  end
+
+  # Method to save stats to the log file 'Demultiplex.log' in the output
+  # directory.
+  #
+  # Returns nothing.
+  def save(file)
+    @stats[:sample_id] = @samples.map(&:id)
+
+    @stats[:index1] = uniq_index1
+    @stats[:index2] = uniq_index2
+
+    File.open(file, 'w') do |ios|
+      ios.puts @status
+    end
+  end
+end