parse_fasta 1.9.2 → 2.0.0

data/lib/parse_fasta/seq_file.rb

@@ -1,4 +1,4 @@
-# Copyright 2014, 2015 Ryan Moore
+# Copyright 2014 - 2016 Ryan Moore
 # Contact: moorer@udel.edu
 #
 # This file is part of parse_fasta.
@@ -16,132 +16,239 @@
 # You should have received a copy of the GNU General Public License
 # along with parse_fasta.  If not, see <http://www.gnu.org/licenses/>.
 
-# Provides a class that will parse either fastA or fastQ files,
-# depending on what the user provides. Handles, gzipped files.
-class SeqFile < File
-
-  # Returns the records in the sequence file as a hash map with the
-  # headers as keys and the Sequences as values. For a fastq file,
-  # acts the same as `FastaFile#to_hash`
-  #
-  # @example Read a fastA into a hash table.
-  #   seqs = SeqFile.open('reads.fa').to_hash
-  #
-  # @return [Hash] A hash with headers as keys, sequences as the
-  #   values (Sequence objects)
-  #
-  # @raise [ParseFasta::SequenceFormatError] if sequence has a '>',
-  #   and file is a fastA file
-  def to_hash
-    first_char = get_first_char(self)
-
-    if first_char == '>'
-      FastaFile.open(self).to_hash
-    elsif first_char == '@'
-      FastqFile.open(self).to_hash
-    else
-      raise ArgumentError, "Input does not look like FASTA or FASTQ"
+require "zlib"
+
+def get_first_char fname
+  if File.exists? fname
+    begin
+      f = Zlib::GzipReader.open fname
+    rescue Zlib::GzipFile::Error
+      f = File.open fname
+    ensure
+      # f.close
     end
+
+    first_char = f.each_char.peek[0]
+    f.close
+    return first_char
+  else
+    raise ParseFasta::Error::FileNotFoundError,
+          "No such file or directory -- #{fname}"
+  end
+end
+
+def check_file fname
+  first_char = get_first_char fname
+
+  if first_char == ">"
+    :fasta
+  elsif first_char == "@"
+    :fastq
+  else
+    raise ParseFasta::Error::DataFormatError,
+          "The file does not look like fastA or fastQ " +
+              "-- #{fname}"
   end
+end
+
+module ParseFasta
+  class SeqFile
+    # @!attribute type
+    #   @return [Symbol] the type of the SeqFile (:fasta or :fastq)
+    attr_accessor :type
+
+    # @param fname [String] the name of the fastA or fastQ file to
+    #   parse
+    #
+    # @raise [ParseFasta::Error::FileNotFoundError] if the file is not
+    #   found
+    # @raise [ParseFasta::Error::DataFormatError] if the file doesn't
+    #   start with a '>' or a '@'
+    def initialize fname
+      type = check_file fname
+
+      @fname = fname
+      @type = type
+    end
 
-  # Analagous to IO#each_line, #each_record will go through a fastA or
-  # fastQ file record by record.
-  #
-  # This #each_record is used in a similar fashion as
-  # FastaFile#each_record except that it yields the header and the
-  # sequence regardless of whether the input is a fastA file or a
-  # fastQ file.
-  #
-  # If the input is a fastQ file, this method will yield the header
-  # and the sequence and ignore the description and the quality
-  # string. This SeqFile class should only be used if your program
-  # needs to work on either fastA or fastQ files, thus it ignores the
-  # quality string and description and treats either file type as if
-  # it were a fastA file.
-  #
-  # If you need the description or quality, you should use
-  # FastqFile#each_record instead.
-  #
-  # @example Parse a gzipped fastA file
-  #   SeqFile.open('reads.fa.gz').each_record do |head, seq|
-  #     puts [head, seq.length].join "\t"
-  #   end
-  #
-  # @example Parse an uncompressed fastQ file
-  #   SeqFile.open('reads.fq.gz').each_record do |head, seq|
-  #     puts [head, seq.length].join "\t"
-  #   end
-  #
-  # @yieldparam header [String] The header of the record without the
-  #   leading '>' or '@'
-  #
-  # @yieldparam sequence [Sequence] The sequence of the record.
-  #
-  # @raise [ParseFasta::SequenceFormatError] if sequence has a '>',
-  #   and file is a fastA file
-  def each_record
-    first_char = get_first_char(self)
-
-    if first_char == '>'
-      FastaFile.open(self).each_record do |header, sequence|
-        yield(header, sequence)
+    # An alias for SeqFile.new
+    #
+    # @return [SeqFile] a SeqFile object
+    def self.open fname
+      self.new fname
+    end
+
+    # Analagous to IO#each_line, SeqFile#each_record is used to go
+    # through a fastA or fastQ file record by record. It will accept
+    # gzipped files as well.
+    #
+    # If the input is a fastA file, then the record that is yielded
+    # will have the desc and qual instance variables be nil. If it is
+    # a fastQ record then those instance variables will not be nil.
+    #
+    # @example Parsing a fastA file
+    #   ParseFasta::SeqFile.open("seqs.fa").each_record do |rec|
+    #     puts [rec.header, rec.seq].join "\t"
+    #
+    #     rec.desc.nil? #=> true
+    #     rec.qual.nil? #=> true
+    #   end
+    # @example Parsing a gzipped fastQ file
+    #   ParseFasta::SeqFile.open("seqs.fq.gz").each_record do |rec|
+    #     puts [rec.header, rec.seq, rec.desc, rec.qual].join "\t"
+    #   end
+    #
+    # @yieldparam record [ParseFasta::Record] A Record object with all
+    #   the info of the record
+    #
+    # @raise [ParseFasta::Error::SequenceFormatError] if a fastA file
+    #   contains a record with a '>' character in the header
+    def each_record &b
+      line_parser = "parse_#{@type}_lines"
+
+      if gzipped? @fname
+        each_record_gzipped line_parser, &b
+      else
+        each_record_non_gzipped line_parser, &b
       end
-    elsif first_char == '@'
-      FastqFile.open(self).each_record do |head, seq, desc, qual|
-        yield(head, seq)
+    end
+
+
+    private
+
+    def each_record_non_gzipped line_parser, &b
+      File.open(@fname, "rt") do |f|
+        self.send line_parser, f, &b
       end
-    else
-      raise ArgumentError, "Input does not look like FASTA or FASTQ"
     end
-  end
 
-  # Fast version of #each_record
-  #
-  # @note If the sequence file has spaces in the sequence, they will
-  #   be retained. If this is a problem, use #each_record instead.
-  #
-  # @example Parse a gzipped fastA file
-  #   SeqFile.open('reads.fa.gz').each_record_fast do |head, seq|
-  #     puts [head, seq.length].join "\t"
-  #   end
-  #
-  # @example Parse an uncompressed fastQ file
-  #   SeqFile.open('reads.fq.gz').each_record_fast do |head, seq|
-  #     puts [head, seq.length].join "\t"
-  #   end
-  #
-  # @yieldparam header [String] The header of the record without the
-  #   leading '>' or '@'
-  #
-  # @yieldparam sequence [String] The sequence of the record.
-  #
-  # @raise [ParseFasta::SequenceFormatError] if sequence has a '>',
-  #   and file is a fastA file
-  def each_record_fast
-    first_char = get_first_char(self)
-
-    if first_char == '>'
-      FastaFile.open(self).each_record_fast do |header, sequence|
-        yield(header, sequence)
+    def each_record_gzipped line_parser, &b
+      File.open(@fname, "rt") do |file|
+        loop do
+          begin
+            gz_reader = Zlib::GzipReader.new file
+
+            self.send line_parser, gz_reader, &b
+
+            # check if there are any more blobs to read
+            if (unused = gz_reader.unused)
+              # rewind to the start of the last blob
+              file.seek -unused.length, IO::SEEK_END
+            else
+              # there are no more blobs to read
+              break
+            end
+          end
+        end
+      end
+    end
+
+    def parse_fasta_line line, header, sequence, &b
+      line.chomp!
+      len = line.length
+
+      if header.empty? && line.start_with?(">")
+        header = line[1, len] # drop the '>'
+      elsif line.start_with? ">"
+        yield Record.new(header: header.strip, seq: sequence)
+
+        header = line[1, len]
+        sequence = ""
+      else
+        sequence << line
       end
-    elsif first_char == '@'
-      FastqFile.open(self).each_record_fast do |head, seq, desc, qual|
-        yield(head, seq)
+
+      [header, sequence]
+    end
+
+    def parse_fastq_line line, header, seq, desc, qual, count, &b
+      line.chomp!
+
+      case count
+        when 0
+          header = line[1..-1]
+        when 1
+          seq = line
+        when 2
+          desc = line[1..-1]
+        when 3
+          count = -1
+          qual = line
+
+          yield Record.new(header: header,
+                           seq:    seq,
+                           desc:   desc,
+                           qual:   qual)
+        else
+          raise ParseFasta::Error::ParseFastaError,
+                "Something went wrong in parse_fastq_line"
       end
-    else
-      raise ArgumentError, "Input does not look like FASTA or FASTQ"
+
+      count += 1
+
+      [header, seq, desc, qual, count]
     end
-  end
 
-  private
+    def parse_fasta_lines file_reader, &b
+      header = ""
+      sequence = ""
 
-  def get_first_char(f)
-    begin
-      handle = Zlib::GzipReader.open(f)
-    rescue Zlib::GzipFile::Error => e
-      handle = f
+      line_reader = which_line_reader file_reader
+      file_reader.send(*line_reader) do |line|
+        header, sequence = parse_fasta_line line, header, sequence, &b
+      end
+
+      # yield the final seq
+      yield Record.new(header: header.strip, seq: sequence)
+    end
+
+    def parse_fastq_lines file_reader, &b
+      count  = 0
+      header = ""
+      seq    = ""
+      desc   = ""
+      qual   = ""
+
+      line_reader = which_line_reader file_reader
+      file_reader.send(*line_reader) do |line|
+        header, seq, desc, qual, count =
+            parse_fastq_line line, header, seq, desc, qual, count, &b
+      end
     end
 
-    handle.each_line.peek[0]
+    def gzipped? fname
+      begin
+        f = Zlib::GzipReader.open fname
+        return true
+      rescue Zlib::GzipFile::Error => e
+        return false
+      ensure
+        f.close if f
+      end
+    end
+
+    # The Zlib::GzipReader can't handle files where the line separator
+    # is \r. This could all be avoided by using IO.popen("gzip -cd
+    # #{fname}", "rt"), but will gzip always be available?
+    def which_line_reader file_reader
+      line_reader = [:each_line]
+      # a valid fasta file must have at least two lines, the header
+      # and the sequence
+      begin
+        enum = file_reader.each_line
+        # if this was ruby v2.3, then we could just call .size on enum
+        2.times do
+          enum.next
+        end
+      rescue StopIteration
+        # Zlib::GzipReader can handle \n and \r\n, but not \r, so if
+        # we get here, the file has \r only for line endings
+        line_reader = [:each, "\r"]
+      ensure
+        file_reader.rewind
+      end
+
+      line_reader
+    end
   end
 end

data/lib/parse_fasta/version.rb

@@ -1,4 +1,4 @@
-# Copyright 2014, 2015 Ryan Moore
+# Copyright 2014 - 2016 Ryan Moore
 # Contact: moorer@udel.edu
 #
 # This file is part of parse_fasta.
@@ -17,5 +17,5 @@
 # along with parse_fasta.  If not, see <http://www.gnu.org/licenses/>.
 
 module ParseFasta
-  VERSION = "1.9.2"
+  VERSION = "2.0.0"
 end

data/lib/parse_fasta.rb

@@ -1,4 +1,4 @@
-# Copyright 2014, 2015 Ryan Moore
+# Copyright 2014 - 2016 Ryan Moore
 # Contact: moorer@udel.edu
 #
 # This file is part of parse_fasta.
@@ -16,25 +16,10 @@
 # You should have received a copy of the GNU General Public License
 # along with parse_fasta.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'parse_fasta/version'
-require 'parse_fasta/fasta_file'
-require 'parse_fasta/fastq_file'
-require 'parse_fasta/seq_file'
-require 'parse_fasta/sequence'
-require 'parse_fasta/quality'
+require "parse_fasta/version"
+require "parse_fasta/record"
+require "parse_fasta/seq_file"
+require "parse_fasta/error"
 
 module ParseFasta
-
-  class Error < StandardError
-  end
-
-  # Error raised when FASTA file is malformed
-  class DataFormatError < IOError
-    def message
-      "Data format error -- check input file"
-    end
-  end
-
-  class SequenceFormatError < Error
-  end
 end

data/spec/parse_fasta/record_spec.rb

@@ -0,0 +1,115 @@
+# Copyright 2014 - 2016 Ryan Moore
+# Contact: moorer@udel.edu
+#
+# This file is part of parse_fasta.
+#
+# parse_fasta 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 3 of the License, or
+# (at your option) any later version.
+#
+# parse_fasta 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 parse_fasta.  If not, see <http://www.gnu.org/licenses/>.
+
+require "spec_helper"
+
+module ParseFasta
+  describe Record do
+    let(:header)  { "apple pie is good"}
+    let(:seq)     { "ACTG" }
+    let(:desc) { "apple" }
+    let(:qual)    { "abcd" }
+
+    let(:fasta_rec) {
+      Record.new header: header,
+                 seq:    "A C\t\t   T   G\r"
+    }
+    let(:fastq_rec) {
+      Record.new header: header,
+                 seq:    "A C\t\t   T   G\r",
+                 desc:   desc,
+                 qual:   " a  b \tcd "
+    }
+
+    describe "::new" do
+      context "fastA input" do
+        it "sets :header" do
+          expect(fasta_rec.header).to eq header
+        end
+
+        it "sets :seq" do
+          expect(fasta_rec.seq).to eq seq
+        end
+
+        it "sets :desc to nil" do
+          expect(fasta_rec.desc).to eq nil
+        end
+
+        it "sets :qual to nil" do
+          expect(fasta_rec.qual).to eq nil
+        end
+
+        context "when seq has a '>' in it" do
+          it "raises SequenceFormatError" do
+            str = "actg>sequence 3"
+
+            expect { Record.new header: header, seq: str }.
+                to raise_error ParseFasta::Error::SequenceFormatError
+          end
+        end
+      end
+
+      context "fastQ input" do
+        it "sets :header" do
+          expect(fastq_rec.header).to eq header
+        end
+
+        it "sets :seq" do
+          expect(fastq_rec.seq).to eq seq
+        end
+
+        it "sets :desc to nil" do
+          expect(fastq_rec.desc).to eq desc
+        end
+
+        it "sets :qual to nil" do
+          expect(fastq_rec.qual).to eq qual
+        end
+
+        context "when seq has a '>' in it" do
+          it "does NOT rais SequenceFormatError" do
+            str = "actg>sequence 3"
+
+            expect { Record.new header: header,
+                                seq:    str,
+                                desc:   desc,
+                                qual:   qual }.
+                not_to raise_error
+          end
+        end
+      end
+    end
+
+    describe "#==" do
+      it "returns true if each of the attr_accessors are ==" do
+        rec1 = Record.new header: "a", seq: "a", desc: "", qual: "A"
+        rec2 = Record.new header: "a", seq: "a", desc: "", qual: "A"
+
+        expect(rec1 == rec2).to eq true
+      end
+
+      it "returns false otherwise" do
+        rec1 = Record.new header: "a", seq: "a", desc: "", qual: "A"
+        rec2 = Record.new header: "a", seq: "a", desc: "", qual: "b"
+
+        expect(rec1 == rec2).to eq false
+      end
+
+    end
+  end
+end