bio-maf 0.1.0

data/spec/bio/maf/parser_spec.rb

@@ -0,0 +1,354 @@
+require 'spec_helper'
+
+module Bio
+  module MAF
+
+    describe Header do
+      before(:each) do
+        @p = Parser.new(TestData + 't1.maf')
+      end
+
+      it "provides version information" do
+        @p.header.version.should == '1'
+      end
+      it "provides the scoring scheme" do
+        @p.header.scoring.should == 'humor.v4'
+      end
+      it "provides alignment parameters" do
+        @p.header.alignment_params.should =~ /humor.v4 R=30/
+      end
+
+      it "presents multiline parameters correctly" do
+        @p.header.alignment_params.should == "humor.v4 R=30 M=10 /cluster/data/hg15/bed/blastz.mm3/axtNet300/chr1.maf /cluster/data/hg15/bed/blastz.rn3/axtNet300/chr1.maf"
+      end
+
+      it "provides arbitrary parameters"
+    end
+
+    describe ParseContext do
+      it "tracks the last block position"
+    end
+
+    describe ChunkReader do
+      before(:each) do
+        @f = (TestData + 'mm8_chr7_tiny.maf').open
+      end
+      describe "#initialize" do
+        it "rejects a chunk size of zero" do
+          expect {
+            ChunkReader.new(@f, 0)
+          }.to raise_error(/Invalid chunk size/)
+        end
+        it "rejects a negative chunk size" do
+          expect {
+            ChunkReader.new(@f, 0)
+          }.to raise_error(/Invalid chunk size/)
+        end
+        it "rejects a chunk size not a power of 2" do
+          expect {
+            ChunkReader.new(@f, 1000)
+          }.to raise_error(/Invalid chunk size/)
+        end
+        it "accepts a 4k chunk size" do
+          expect {
+            ChunkReader.new(@f, 4096)
+          }.not_to raise_error
+        end
+        it "accepts an 8M chunk size" do
+          expect {
+            ChunkReader.new(@f, 8 * 1024 * 1024)
+          }.not_to raise_error
+        end
+      end
+      context "with 1K ChunkReader" do
+        before(:each) do
+          @r = ChunkReader.new(@f, 1024)
+        end
+ 
+        describe "#chunk_size=" do
+          it "sets the chunk size" do
+            @r.chunk_size = 8192
+            @r.chunk_size.should == 8192
+          end
+          # it "sets the chunk shift" do
+          #   @r.chunk_size = 8192
+          #   @r.chunk_shift.should == 13
+          # end
+        end
+
+        describe "#read_chunk" do
+          it "returns a chunk of the specified length" do
+            @r.read_chunk.bytesize == 1024
+          end
+          it "starts at position 0" do
+            @r.pos.should == 0
+          end
+          it "advances the position" do
+            @r.read_chunk
+            @r.pos.should == 1024
+          end
+        end
+
+        describe "#read_chunk_at" do
+          it "returns data starting at the specified offset" do
+            c = @r.read_chunk_at(59)
+            c.start_with?("80082334").should be_true
+          end
+          it "handles a read starting exactly at a chunk boundary" do
+            c = @r.read_chunk_at(1024)
+            c.start_with?("   594").should be_true
+          end
+        end
+      end
+      after(:each) do
+        @f.close
+      end
+    end
+
+    shared_examples "parsers" do
+      
+      describe "creation" do
+        it "opens a file specified as a String argument"
+        it "takes an IO object as an open file"
+        it "raises an error when the file does not exist" do
+          expect {
+            described_class.new("/doesnotexist")
+          }.to raise_error(Errno::ENOENT)
+        end
+        it "raises an error when the file is not in MAF format" do
+          expect {
+            described_class.new(TestData + '../../Rakefile')
+          }.to raise_error
+        end
+      end
+
+      describe "#header" do
+        it "parses the MAF header" do
+          p = described_class.new(TestData + 't1.maf')
+          p.header.should_not be_nil
+        end
+      end
+
+      describe "#fetch_blocks" do
+        shared_examples_for "any chunk size" do
+          it "parses a single block" do
+            fl = [[16, 1087]]
+            blocks = @p.fetch_blocks(fl).to_a
+            blocks.size.should == 1
+            blocks[0].offset.should == 16
+          end
+          it "parses several consecutive blocks" do
+            fl = [[16, 1087], [1103, 1908], [3011, 2027]]
+            blocks = @p.fetch_blocks(fl).to_a
+            blocks.size.should == 3
+            blocks.collect {|b| b.offset}.should == [16, 1103, 3011]
+          end
+          it "parses consecutive blocks further ahead" do
+            fl = [[5038, 1647], [6685, 829]]
+            blocks = @p.fetch_blocks(fl).to_a
+            blocks.size.should == 2
+            blocks.collect {|b| b.offset}.should == [5038, 6685]
+          end
+          it "parses nonconsecutive blocks" do
+            fl = [[16, 1087], [3011, 2027]]
+            blocks = @p.fetch_blocks(fl).to_a
+            blocks.size.should == 2
+            blocks.collect {|b| b.offset}.should == [16, 3011]
+          end
+        end
+        context "with 4K chunk size" do
+          before(:each) do
+            @p = described_class.new(TestData + 'mm8_chr7_tiny.maf',
+                                     :chunk_size => 4096,
+                                     :random_chunk_size => 4096)
+          end
+          it_behaves_like "any chunk size"
+        end
+        context "with 1K chunk size" do
+          before(:each) do
+            @p = described_class.new(TestData + 'mm8_chr7_tiny.maf',
+                                     :chunk_size => 1024,
+                                     :random_chunk_size => 1024)
+          end
+          it_behaves_like "any chunk size"
+        end
+        context "after parsing to end" do
+          before(:each) do
+            @p = described_class.new(TestData + 'mm8_chr7_tiny.maf',
+                                     :chunk_size => 4096,
+                                     :random_chunk_size => 4096)
+            @p.each_block { |b| nil }
+          end
+          it_behaves_like "any chunk size"
+        end
+        context "with 8M chunk size" do
+          before(:each) do
+            @p = described_class.new(TestData + 'mm8_chr7_tiny.maf',
+                                     :chunk_size => 8 * 1024 * 1024,
+                                     :random_chunk_size => 8 * 1024 * 1024)
+          end
+          it_behaves_like "any chunk size"
+        end
+        after(:each) do
+          @p.f.close
+        end
+      end
+
+      describe "sequence_filter" do
+        before(:each) do
+          @p = described_class.new(TestData + 'mm8_mod_a.maf')
+        end
+        it "restricts sequences parsed" do
+          @p.sequence_filter = { :only_species => %w(mm8 rn4) }
+          @p.parse_block.sequences.size.should == 2
+        end
+        it "matches at the species delimiter rather than a prefix" do
+          @p.sequence_filter = { :only_species => %w(mm8 hg18) }
+          @p.parse_block.sequences.size.should == 2
+        end
+      end
+
+      context "at end of file" do
+        describe "#parse_block" do
+          it "returns nil"
+        end
+      end
+
+      describe "#parse_block" do
+        it "returns an alignment block" do
+          p = described_class.new(TestData + 't1.maf')
+          b = p.parse_block()
+          b.should_not be_nil
+        end
+        it "raises an exception for malformed data"
+      end
+
+      it "gives the correct number of sequences" do
+        p = described_class.new(TestData + 'mm8_chr7_tiny.maf')
+        block = p.parse_block
+        block.sequences.size.should == 10
+      end
+
+      it "handles absent alignment parameters" do
+        p = described_class.new(TestData + 'chrY-1block.maf')
+        b = p.parse_block()
+        b.should_not be_nil
+      end
+
+      it "parses larger files" do
+        p = described_class.new(TestData + 'mm8_chr7_tiny.maf')
+        expect {
+          p.each_block { |block| block }
+        }.not_to raise_error
+      end
+
+      it "handles trailing comments" do
+        p = described_class.new(TestData + 't1a.maf')
+        expect {
+          p.each_block { |block| block }
+        }.not_to raise_error
+      end
+
+      it "raises an exception on inconsistent sequence length" do
+        pending
+        ## can't just do string length, have to skip over hyphens
+      end
+
+      it "tracks block start offsets correctly" do
+        pa = []
+        p = described_class.new(TestData + 'mm8_chr7_tiny.maf')
+        p.each_block { |b| pa << b.offset }
+        pa.should == [16, 1103, 3011, 5038, 6685, 7514, 9022, 10113]
+      end
+
+      it "reports block sizes correctly" do
+        p = described_class.new(TestData + 'mm8_chr7_tiny.maf')
+        block = p.parse_block
+        block.size.should == 1087
+      end
+
+      it "parses very large blocks" do
+        p = described_class.new(TestData + 'big-block.maf')
+        n = 0
+        p.each_block { |b| n += 1 }
+        n.should == 490
+      end
+
+    end
+
+    describe Parser do
+      include_examples "parsers"
+
+      def with_const_value(mod, sym, value)
+        old = mod.const_get(sym)
+        mod.const_set(sym, value)
+        begin
+          yield
+        ensure
+          mod.const_set(sym, old)
+        end
+      end
+
+      describe "#merge_fetch_list" do
+        before(:each) do
+          @p = described_class.new(TestData + 'mm8_chr7_tiny.maf')
+        end
+        it "passes through single records" do
+          fl = [[16, 1087]]
+          @p.merge_fetch_list(fl).should == [[16, 1087, [16]]]
+        end
+        it "passes through non-contiguous records" do
+          fl = [[16, 1087], [3011, 2027]]
+          @p.merge_fetch_list(fl).should == [[16, 1087, [16]],
+                                             [3011, 2027, [3011]]]
+        end
+        it "merges contiguous records" do
+          fl = [[16, 1087], [1103, 1908], [3011, 2027]]
+          @p.merge_fetch_list(fl).should == [[16, 5022, [16, 1103, 3011]]]
+        end
+        after(:each) do
+          @p.f.close
+        end
+      end
+
+      it "sets last block position correctly" do
+        p = Parser.new(TestData + 'mm8_subset_a.maf')
+        p.last_block_pos.should == 1103
+      end
+
+      context "with 2k chunk size" do
+        before(:each) do
+          @p = Parser.new(TestData + 'mm8_chr7_tiny.maf',
+                          :chunk_size => 2048)
+        end
+        it "yields the correct number of blocks over chunk boundaries" do
+          ref_scores = %w(10542.0 -33148.0 87527.0 185399.0
+                          30120.0 58255.0 2607.0 8132.0)
+          scores = []
+          @p.each_block do |block|
+            scores << block.vars[:score]
+          end
+          scores.should == ref_scores
+        end
+        it "sets last_block_pos correctly" do
+          @p.last_block_pos.should == 1103
+        end
+        it "handles sequence lines over chunk boundaries" do
+          @p.parse_block
+          block = @p.parse_block
+          break_seq = block.raw_seq(4)
+          break_seq.text.size.should == 156
+        end
+
+        it "tracks block start offsets correctly over chunk boundaries" do
+          pa = []
+          @p.each_block { |b| pa << b.offset }
+          pa.should == [16, 1103, 3011, 5038, 6685, 7514, 9022, 10113]
+        end
+      end
+
+    end
+
+  end
+  
+end

data/spec/bio/maf/struct_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Bio
+  module MAF
+
+    describe Struct do
+
+      describe "#fmt" do
+        it "presents all members in order" do
+          @s = Struct.new([[:a, :uint16],
+                           [:b, :uint32],
+                           [:c, :uint32],
+                           [:d, :uint8]])
+          @s.fmt.should == "S>L>L>C"
+        end
+      end
+
+      describe "#extractor_fmt" do
+        it "handles uint8" do
+          @s = Struct.new([[:marker, :uint8]])
+          @s.extractor_fmt(:marker).should == "C"
+        end
+        it "handles uint16" do
+          @s = Struct.new([[:a, :uint16]])
+          @s.extractor_fmt(:a).should == "S>"
+        end
+        it "handles uint32" do
+          @s = Struct.new([[:a, :uint32]])
+          @s.extractor_fmt(:a).should == "L>"
+        end
+        it "handles uint64" do
+          @s = Struct.new([[:a, :uint64]])
+          @s.extractor_fmt(:a).should == "Q>"
+        end
+        it "skips uint8" do
+          @s = Struct.new([[:dummy, :uint8],
+                           [:a, :uint64]])
+          @s.extractor_fmt(:a).should == "@1Q>"
+        end
+        it "skips uint16" do
+          @s = Struct.new([[:dummy, :uint16],
+                           [:a, :uint64]])
+          @s.extractor_fmt(:a).should == "@2Q>"
+        end
+        it "skips uint32" do
+          @s = Struct.new([[:dummy, :uint32],
+                           [:a, :uint64]])
+          @s.extractor_fmt(:a).should == "@4Q>"
+        end
+        it "skips uint64" do
+          @s = Struct.new([[:dummy, :uint64],
+                           [:a, :uint64]])
+          @s.extractor_fmt(:a).should == "@8Q>"
+        end
+        it "extracts multiple leading elements" do
+          @s = Struct.new([[:a, :uint16],
+                           [:b, :uint32],
+                           [:c, :uint32]])
+          @s.extractor_fmt(:a, :b).should == "S>L>"
+        end
+        it "extracts multiple offset elements" do
+          @s = Struct.new([[:a, :uint16],
+                           [:b, :uint32],
+                           [:c, :uint32],
+                           [:d, :uint8]])
+          @s.extractor_fmt(:b, :c).should == "@2L>L>"
+        end
+      end
+
+      describe ""
+
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+unless ENV.has_key?('TRAVIS') || RUBY_PLATFORM == 'java'
+  begin
+    require 'simplecov'
+  rescue LoadError
+    $stderr.puts "WARNING: could not require 'simplecov': #{$!}"
+  end
+end
+
+require 'rspec'
+require 'pathname'
+
+require 'bio-maf'
+
+TestData = Pathname.new(__FILE__) + '../../test/data'