parse_fasta 1.9.2 → 2.0.0

data/spec/lib/seq_file_spec.rb

@@ -1,357 +0,0 @@
-# Copyright 2014, 2015 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'
-
-describe SeqFile do
-
-  describe "#to_hash" do
-    context "when input is a fasta file" do
-      let(:records) { Helpers::RECORDS_MAP }
-      let(:fname) { "#{File.dirname(__FILE__)}/../../test_files/test.fa.gz" }
-      let(:fasta) { SeqFile.open(fname) }
-
-      context "with badly catted fasta" do
-        it "raises ParseFasta::SequenceFormatError" do
-          fname = "#{File.dirname(__FILE__)}/../../test_files/bad.fa"
-
-          expect { FastaFile.open(fname).to_hash }.
-            to raise_error ParseFasta::SequenceFormatError
-        end
-      end
-
-      it "reads the records into a hash: header as key and seq as val" do
-        expect(fasta.to_hash).to eq records
-      end
-
-      it "passes the values as Sequence objects" do
-        expect(
-          fasta.to_hash.values.all? { |val| val.instance_of? Sequence }
-        ).to eq true
-      end
-    end
-
-    context "when input is a fastq file" do
-      let(:records) {
-        { "seq1" => { head: "seq1",
-                      seq: "AACCTTGG",
-                      desc: "",
-                      qual: ")#3gTqN8" },
-          "seq2 apples" => { head: "seq2 apples",
-                             seq: "ACTG",
-                             desc: "seq2 apples",
-                             qual: "*ujM" }
-        }
-      }
-      let(:fname) { "#{File.dirname(__FILE__)}/../../test_files/test.fq.gz" }
-      let(:fastq) { SeqFile.open(fname) }
-
-      it "reads the records into a hash: header as key and seq as val" do
-        expect(fastq.to_hash).to eq records
-      end
-
-      it "passes the seqs as Sequence objects" do
-        expect(
-          fastq.to_hash.values.all? { |val| val[:seq].instance_of? Sequence }
-        ).to eq true
-      end
-
-      it "passes the quals as Quality objects" do
-        expect(
-          fastq.to_hash.values.all? { |val| val[:qual].instance_of? Quality }
-        ).to eq true
-      end
-    end
-  end
-
-  context "when input is a fasta file" do
-    describe "#each_record" do
-      let(:records) { Helpers::RECORDS }
-
-      let(:f_handle) { SeqFile.open(@fname).each_record { |s| } }
-
-      context "with badly catted fasta" do
-        it "raises ParseFasta::SequenceFormatError" do
-          fname = "#{File.dirname(__FILE__)}/../../test_files/bad.fa"
-
-          expect { FastaFile.open(fname).to_hash }.
-            to raise_error ParseFasta::SequenceFormatError
-        end
-      end
-
-      shared_examples_for "parsing a fasta file" do
-        it "yields proper header and sequence for each record" do
-          expect { |b|
-            SeqFile.open(@fname).each_record(&b)
-          }.to yield_successive_args(*records)
-        end
-
-        it "yields the sequence as a Sequence class" do
-          SeqFile.open(@fname).each_record do |_, seq|
-            expect(seq).to be_an_instance_of Sequence
-          end
-        end
-      end
-
-      context "with a gzipped file" do
-        before(:each) do
-          @fname = "#{File.dirname(__FILE__)}/../../test_files/test.fa.gz"
-        end
-
-        it_behaves_like "parsing a fasta file"
-
-        it "closes the GzipReader" do
-          expect(f_handle).to be_closed
-        end
-
-        it "returns GzipReader object" do
-          expect(f_handle).to be_an_instance_of Zlib::GzipReader
-        end
-      end
-
-      context "with a non-gzipped file" do
-        before(:each) do
-          @fname = "#{File.dirname(__FILE__)}/../../test_files/test.fa"
-        end
-
-        it_behaves_like "parsing a fasta file"
-
-        it "doesn't close the File (approx regular file behavior)" do
-          expect(f_handle).not_to be_closed
-        end
-
-        it "returns FastaFile object" do
-          expect(f_handle).to be_a FastaFile
-        end
-      end
-    end
-  end
-
-  context "when input is a fastq file" do
-    let(:records) {
-      [["seq1", "AACCTTGG"],
-       ["seq2 apples", "ACTG"]] }
-    let(:f_handle) { SeqFile.open(@fname).each_record { |s| } }
-
-    shared_examples_for "parsing a fastq file" do
-      it "yields only header & sequence" do
-        expect { |b|
-          SeqFile.open(@fname).each_record(&b)
-        }.to yield_successive_args(records[0], records[1])
-      end
-
-      it "yields the sequence as a Sequence class" do
-        SeqFile.open(@fname).each_record do |_, seq, _, _|
-          expect(seq).to be_an_instance_of Sequence
-        end
-      end
-    end
-
-    context "with a 4 line per record fastq file" do
-      describe "#each_record" do
-        context "with a gzipped file" do
-          before(:each) do
-            @fname =
-              "#{File.dirname(__FILE__)}/../../test_files/test.fq.gz"
-          end
-
-          it_behaves_like "parsing a fastq file"
-
-          it "closes the GzipReader" do
-            expect(f_handle).to be_closed
-          end
-
-          it "returns GzipReader object" do
-            expect(f_handle).to be_an_instance_of Zlib::GzipReader
-          end
-        end
-
-        context "with a non-gzipped file" do
-          before(:each) do
-            @fname =
-              "#{File.dirname(__FILE__)}/../../test_files/test.fq"
-          end
-
-          it_behaves_like "parsing a fastq file"
-
-          it "doesn't close the SeqFile (approx reg file behav)" do
-            expect(f_handle).not_to be_closed
-          end
-
-          it "returns FastqFile object" do
-            expect(f_handle).to be_a FastqFile
-          end
-        end
-      end
-    end
-  end
-
-  context "when input is bogus" do
-    describe "#each_record" do
-      it "raises an ArgumentError with message" do
-        fname = "#{File.dirname(__FILE__)}/../../test_files/bogus.txt"
-        err_msg = "Input does not look like FASTA or FASTQ"
-
-        expect { SeqFile.open(fname).each_record do |h, s|
-                   puts [h, s].join ' '
-                 end
-        }.to raise_error(ArgumentError, err_msg)
-      end
-    end
-  end
-
-  #####
-
-  context "when input is a fasta file" do
-    describe "#each_record_fast" do
-      let(:records) { Helpers::RECORDS_FAST }
-
-      let(:f_handle) { SeqFile.open(@fname).each_record_fast { |s| } }
-
-      context "with badly catted fasta" do
-        it "raises ParseFasta::SequenceFormatError" do
-          fname = "#{File.dirname(__FILE__)}/../../test_files/bad.fa"
-
-          expect { FastaFile.open(fname).to_hash }.
-            to raise_error ParseFasta::SequenceFormatError
-        end
-      end
-
-      shared_examples_for "parsing a fasta file" do
-        it "yields proper header and sequence for each record" do
-          expect { |b|
-            SeqFile.open(@fname).each_record_fast(&b)
-          }.to yield_successive_args(*records)
-        end
-
-        it "yields the sequence as a String class" do
-          SeqFile.open(@fname).each_record_fast do |_, seq|
-            expect(seq).to be_an_instance_of String
-          end
-        end
-      end
-
-      context "with a gzipped file" do
-        before(:each) do
-          @fname = "#{File.dirname(__FILE__)}/../../test_files/test.fa.gz"
-        end
-
-        it_behaves_like "parsing a fasta file"
-
-        it "closes the GzipReader" do
-          expect(f_handle).to be_closed
-        end
-
-        it "returns GzipReader object" do
-          expect(f_handle).to be_an_instance_of Zlib::GzipReader
-        end
-      end
-
-      context "with a non-gzipped file" do
-        before(:each) do
-          @fname = "#{File.dirname(__FILE__)}/../../test_files/test.fa"
-        end
-
-        it_behaves_like "parsing a fasta file"
-
-        it "doesn't close the File (approx regular file behavior)" do
-          expect(f_handle).not_to be_closed
-        end
-
-        it "returns FastaFile object" do
-          expect(f_handle).to be_a FastaFile
-        end
-      end
-    end
-  end
-
-  context "when input is a fastq file" do
-    let(:records) {
-      [["seq1", "AA CC TT GG"],
-       ["seq2 apples", "ACTG"]] }
-    let(:f_handle) { SeqFile.open(@fname).each_record_fast { |s| } }
-
-    shared_examples_for "parsing a fastq file" do
-      it "yields only header & sequence" do
-        expect { |b|
-          SeqFile.open(@fname).each_record_fast(&b)
-        }.to yield_successive_args(records[0], records[1])
-      end
-
-      it "yields the sequence as a String class" do
-        SeqFile.open(@fname).each_record_fast do |_, seq, _, _|
-          expect(seq).to be_an_instance_of String
-        end
-      end
-    end
-
-    context "with a 4 line per record fastq file" do
-      describe "#each_record_fast" do
-        context "with a gzipped file" do
-          before(:each) do
-            @fname =
-              "#{File.dirname(__FILE__)}/../../test_files/test.fq.gz"
-          end
-
-          it_behaves_like "parsing a fastq file"
-
-          it "closes the GzipReader" do
-            expect(f_handle).to be_closed
-          end
-
-          it "returns GzipReader object" do
-            expect(f_handle).to be_an_instance_of Zlib::GzipReader
-          end
-        end
-
-        context "with a non-gzipped file" do
-          before(:each) do
-            @fname =
-              "#{File.dirname(__FILE__)}/../../test_files/test.fq"
-          end
-
-          it_behaves_like "parsing a fastq file"
-
-          it "doesn't close the SeqFile (approx reg file behav)" do
-            expect(f_handle).not_to be_closed
-          end
-
-          it "returns FastqFile object" do
-            expect(f_handle).to be_a FastqFile
-          end
-        end
-      end
-    end
-  end
-
-  context "when input is bogus" do
-    describe "#each_record_fast" do
-      it "raises an ArgumentError with message" do
-        fname = "#{File.dirname(__FILE__)}/../../test_files/bogus.txt"
-        err_msg = "Input does not look like FASTA or FASTQ"
-
-        expect { SeqFile.open(fname).each_record_fast do |h, s|
-                   puts [h, s].join ' '
-                 end
-        }.to raise_error(ArgumentError, err_msg)
-      end
-    end
-  end
-
-
-end

data/spec/lib/sequence_spec.rb

@@ -1,188 +0,0 @@
-# Copyright 2014, 2015 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'
-require 'bio'
-
-describe Sequence do
-
-  # it "has AmbiguousSequenceError" do
-  #   expect(Sequence::AmbiguousSequenceError).not_to be nil
-  # end
-
-  it "inherits from String" do
-    expect(Sequence.new('ACTG')).to be_a String
-  end
-
-  describe "::new" do
-    it "removes any spaces in the sequence" do
-      s = "ACT ACT ACT    GCT  "
-      s_no_spaces = "ACTACTACTGCT"
-      expect(Sequence.new(s)).to eq s_no_spaces
-    end
-
-    context "when sequence has a '>' in it" do
-      it "raises SequenceFormatError" do
-        s = "actg>sequence 3"
-        expect { Sequence.new(s) }.
-          to raise_error ParseFasta::SequenceFormatError
-      end
-    end
-  end
-
-  describe "#gc" do
-    it "gives the same answer as BioRuby" do
-      s = 'ACtgcGAtcgCgAaTtGgCcnNuU'
-      bioruby_gc = Bio::Sequence::NA.new(s).gc_content
-      expect(Sequence.new(s).gc).to eq bioruby_gc
-    end
-
-    context "when sequence isn't empty" do
-      it "calculates gc" do
-        s = Sequence.new('ActGnu')
-        expect(s.gc).to eq(2 / 5.to_f)
-      end
-    end
-
-    context "when sequence is empty" do
-      it "returns 0" do
-        s = Sequence.new('')
-        expect(s.gc).to eq 0
-      end
-    end
-
-    context "there are no A, C, T, G or U (ie only N)" do
-      it "returns 0" do
-        s = Sequence.new('NNNNNnn')
-        expect(s.gc).to eq 0
-      end
-    end
-  end
-
-  describe "#base_counts" do
-    context "for a DNA sequence with default or falsy argument" do
-      it "returns a map of A, C, T, and G counts" do
-        s = Sequence.new('ACTGactg')
-        expect(s.base_counts).to eq({ a: 2, c: 2, t: 2, g: 2 })
-      end
-    end
-
-    context "for a DNA sequence with truthy argument" do
-      it "returns a map of A, C, T, G and N counts" do
-        s = Sequence.new('ACTGNactgn')
-        expect(s.base_counts(1)).to eq({ a: 2, c: 2, t: 2, g: 2, n: 2 })
-      end
-    end
-
-    context "for an RNA sequence with falsy or default argument" do
-      it "returns a map of A, C, U, G counts" do
-        s = Sequence.new('ACUGacug')
-        expect(s.base_counts).to eq({ a: 2, c: 2, u: 2, g: 2 })
-      end
-    end
-
-    context "for an RNA sequence with truthy argument" do
-      it "returns a map of A, C, U, G and N counts" do
-        s = Sequence.new('ACUGNacugn')
-        expect(s.base_counts(1)).to eq({ a: 2, c: 2, u: 2, g: 2, n: 2 })
-      end
-    end
-
-    context "for a sequence with both U and T present" do
-      s = Sequence.new('AaCcTtGgNnUu')
-      err_message = 'ERROR: A sequence contains both T and U'
-
-      it "warns the user about having both U and T present" do
-        expect(s).to receive(:warn).with(err_message)
-        s.base_counts
-      end
-
-      it "returns a map that counts both U's and T's" do
-        expect(s.base_counts).to eq({ a: 2, c: 2, t: 2, u: 2, g: 2 })
-      end
-
-      it "returns a map with T, U and N if truthy argument given" do
-        base_counts = { a: 2, c: 2, t: 2, u: 2, g: 2, n: 2 }
-        expect(s.base_counts(1)).to eq(base_counts)
-      end
-    end
-  end
-
-  describe "#base_frequencies" do
-    context "with falsy argument" do
-      it "doesn't count ambiguous bases in total bases" do
-        s = Sequence.new('ACTTn')
-        base_freqs = { a: 0.25, c: 0.25, t: 0.5, g: 0.0 }
-        expect(s.base_frequencies).to eq(base_freqs)
-      end
-    end
-
-    context "when counting ambiguous bases" do
-      it "does count ambiguous bases in total bases" do
-        s = Sequence.new('ACTTn')
-        base_freqs = { a: 0.2, c: 0.2, t: 0.4, g: 0.0, n: 0.2 }
-        expect(s.base_frequencies(1)).to eq(base_freqs)
-      end
-    end
-  end
-
-  describe "#rev_comp" do
-    # it "raises error if both T and U are present" do
-    #   s = Sequence.new("actGU")
-    #   err = Sequence::AmbiguousSequenceError
-    #   msg = "Sequence is ambiguous -- both T and U present"
-    #   expect { s.rev_comp }.to raise_error(err, msg)
-    # end
-
-    # it "warns if non iupac characters are present" do
-    #   s = Sequence.new("--..9284ldkjfalsjf")
-    #   msg = "WARNING: Sequence contains non IUPAC characters"
-    #   expect(s).to receive(:warn).with(msg)
-    #   s.rev_comp
-    # end
-    it "returns a reverse complement of the Sequence" do
-      s = Sequence.new("gARKbdctymvhu").rev_comp
-      expect(s).to eq "adbkraghvMYTc"
-
-      s = Sequence.new("ctyMVhgarKBda").rev_comp
-      expect(s).to eq "thVMytcdBKrag"
-    end
-
-    it "leaves non-IUPAC characters alone" do
-      s = Sequence.new("cccc--CCCcccga").rev_comp
-      expect(s).to eq "tcgggGGG--gggg"
-    end
-
-    it "returns a Sequence" do
-      s = Sequence.new("cccc--CCCcccga")
-      expect(s.rev_comp).to be_an_instance_of(Sequence)
-    end
-
-    it "gives back original sequence when called in succession" do
-      s = Sequence.new("cccc--CCCcccga")
-      expect(s.rev_comp.rev_comp).to eq s
-    end
-
-    context "with an empty sequence" do
-      it "returns an empty sequence" do
-        s = Sequence.new("")
-        expect(s.rev_comp).to be_empty
-      end
-    end
-  end
-end

data/test_files/benchmark.rb

@@ -1,99 +0,0 @@
-#!/usr/bin/env ruby
-
-# Copyright 2014, 2015 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 'parse_fasta'
-require 'bio'
-require 'benchmark'
-
-def this_parse_fasta fname
-  FastaFile.open(fname, 'r').each_record do |header, sequence|
-    [header, sequence.length].join("\t")
-  end
-end
-
-def this_parse_fasta_fast fname
-  FastaFile.open(fname, 'r').each_record_fast do |header, sequence|
-    [header, sequence.length].join("\t")
-  end
-end
-
-def bioruby_parse_fasta fname
-  Bio::FastaFormat.open(fname).each do |entry|
-    [entry.definition, entry.seq.length].join("\t")
-  end
-end
-
-Benchmark.bmbm do |x|
-  x.report('parse_fasta') { this_parse_fasta(ARGV.first) }
-  x.report('parse_fasta fast') { this_parse_fasta_fast(ARGV.first) }
-  x.report('bioruby')     { bioruby_parse_fasta(ARGV.first) }
-end
-
-####
-
-def this_gc(str)
-  Sequence.new(str).gc
-end
-
-def bioruby_gc(str)
-  Bio::Sequence::NA.new(str).gc_content
-end
-
-# make a random sequence of given length
-def make_seq(num)
-  num.times.reduce('') { |str, n| str << %w[A a C c T t G g N n].sample }
-end
-
-# s1 = make_seq(2000000)
-# s2 = make_seq(4000000)
-# s3 = make_seq(8000000)
-
-# Benchmark.bmbm do |x|
-#   x.report('this_gc 1') { this_gc(s1) }
-#   x.report('bioruby_gc 1') { bioruby_gc(s1) }
-
-#   x.report('this_gc 2') { this_gc(s2) }
-#   x.report('bioruby_gc 2') { bioruby_gc(s2) }
-
-#   x.report('this_gc 3') { this_gc(s3) }
-#   x.report('bioruby_gc 3') { bioruby_gc(s3) }
-# end
-
-# fastq = ARGV.first
-
-def bioruby_fastq(fastq)
-  Bio::FlatFile.open(Bio::Fastq, fastq) do |fq|
-    fq.each do |entry|
-      [entry.definition, entry.seq.length].join("\t")
-    end
-  end
-end
-
-def this_fastq(fastq)
-  FastqFile.open(fastq).each_record do |head, seq, desc, qual|
-    [head, seq.length].join("\t")
-  end
-end
-
-# file is 4 million illumina reads (16,000,000 lines) 1.4gb
-# Benchmark.bmbm do |x|
-#   x.report('this_fastq') { this_fastq(ARGV.first) }
-#   x.report('bioruby_fastq') { bioruby_fastq(ARGV.first) }
-# end

data/test_files/bogus.txt

@@ -1,2 +0,0 @@
-this header is missing the '>'
-ACTGACTGATCGATCGTAGCTACGTAGCTACG

data/test_files/test.fq

@@ -1,8 +0,0 @@
-@seq1
-AA CC TT GG
-+
-)# 3g Tq N8
-@seq2 apples
-ACTG
-+seq2 apples
-*ujM