finishm 0.0.1

data/spec/graph_generator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe 'graph_generator' do
+  it 'should run using minimal options' do
+    probes = [
+      'AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC',
+      'ACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGCGTAACGCGTATGCAATCTGCCTTGTACTAAGGGATAGCCCAGAGA',
+      ]
+    read_inputs = Bio::FinishM::ReadInput.new
+    read_inputs.fasta_singles_gz = [
+      File.join(File.dirname(__FILE__),'data','gapfilling','3','reads.fa.gz')
+      ]
+    probed_graph = Bio::FinishM::GraphGenerator.new.generate_graph(probes, read_inputs, {
+      :assembly_coverage_cutoff => 0,
+      :velvet_kmer_size => 31,
+      })
+
+    expect(probed_graph).to be_kind_of(Bio::FinishM::ProbedGraph)
+    expect(probed_graph.velvet_sequences).to be_kind_of(Bio::Velvet::Underground::BinarySequenceStore)
+    expect(probed_graph.velvet_sequences[1]).to eq('AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC')
+    expect(probed_graph.velvet_sequences[2]).to eq('ACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGCGTAACGCGTATGCAATCTGCCTTGTACTAAGGGATAGCCCAGAGA')
+  end
+
+  it 'should check probe sequences are present in the assembly' do
+    Dir.mktmpdir do |tmpdir|
+      probes = [
+        'AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC',
+        'ACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGCGTAACGCGTATGCAATCTGCCTTGTACTAAGGGATAGCCCAGAGA',
+        ]
+      read_inputs = Bio::FinishM::ReadInput.new
+      read_inputs.fasta_singles_gz = [
+        File.join(File.dirname(__FILE__),'data','gapfilling','3','reads.fa.gz')
+        ]
+      # First assembly run is fine
+      probed_graph = Bio::FinishM::GraphGenerator.new.generate_graph(probes, read_inputs, {
+        :assembly_coverage_cutoff => 0,
+        :velvet_kmer_size => 31,
+        :output_assembly_path => tmpdir,
+        })
+      expect(probed_graph).to be_kind_of(Bio::FinishM::ProbedGraph)
+      expect(probed_graph.velvet_sequences[1]).to eq('AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC')
+
+      # Reading in the last assembly with the same probes should work
+      probed_graph = Bio::FinishM::GraphGenerator.new.generate_graph(probes, read_inputs, {
+        :previous_assembly => tmpdir,
+        })
+      expect(probed_graph).to be_kind_of(Bio::FinishM::ProbedGraph)
+      expect(probed_graph.velvet_sequences[1]).to eq('AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC')
+
+      # Reading assembly expecting a different probe read should fail
+      expect {Bio::FinishM::GraphGenerator.new.generate_graph(['AAAAAAAAAAA'], read_inputs, {
+        :previous_assembly => tmpdir,
+        })}.to raise_exception
+
+      expect {Bio::FinishM::GraphGenerator.new.generate_graph(['AGAGTTTGATCATGGCTCAGGATGAACGCTAGCGGCAGGCCTAACACATGCAAGTCGAGGGGTAGAGGCTTTCGGGCCTTGAGACCGGCGCACGGGTGC',
+        'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
+        ], read_inputs, {
+        :previous_assembly => tmpdir,
+        })}.to raise_error
+    end
+  end
+
+  it 'should find probes by probe names' do
+    # >32_1   63      0
+    # >32_2   64      0
+    # >33_1   65      0
+    # >33_2   66      0
+    # >34_1   67      0
+    # >34_2   68      0
+    # >35_1   69      0
+    # >35_2   70      0
+    names = %w(32_1 35_2)
+
+    Dir.mktmpdir do |tmpdir|
+      read_inputs = Bio::FinishM::ReadInput.new
+      read_inputs.fasta_singles_gz = [
+        File.join(File.dirname(__FILE__),'data','gapfilling','3','reads.fa.gz')
+        ]
+      # First assembly run is fine
+      probed_graph = Bio::FinishM::GraphGenerator.new.generate_graph([], read_inputs, {
+        :assembly_coverage_cutoff => 0,
+        :velvet_kmer_size => 31,
+        :output_assembly_path => tmpdir,
+        :probe_read_names => names,
+        })
+      probed_graph.probe_node_reads.collect{|read| read.read_id}.should == [63,70]
+    end
+  end
+
+  describe 'check_probe_sequences' do
+    it 'should check_probe_sequences' do
+      graph_gen = Bio::FinishM::GraphGenerator.new
+      expect(graph_gen.check_probe_sequences(['AAA'],['','AAA'])).to eq(true)
+      expect(graph_gen.check_probe_sequences(['AAA'],['','ATA'])).to eq(false)
+      expect(graph_gen.check_probe_sequences(['TTTA','AAA'],['','TTTA','AAA'])).to eq(true)
+      expect(graph_gen.check_probe_sequences(['TTTA','AAA'],['','TTTA','ATA'])).to eq(false)
+    end
+  end
+end

data/spec/height_finder_spec.rb

@@ -0,0 +1,306 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class GraphTesting
+  def self.array_of_sorted_nodes(nodes_array)
+    nodes_array.collect do |nodes|
+      nodes.collect{|n| n.node_id}.sort
+    end
+  end
+
+  def self.array_of_sorted_nodes_in(nodes_array)
+    to_return = {}
+    nodes_array.flatten.each do |node|
+      to_return[node.node_id] = node.nodes_in.collect{|n| n.node_id}.sort
+    end
+    return to_return
+  end
+
+  def self.array_of_sorted_nodes_out(nodes_array)
+    to_return = {}
+    nodes_array.flatten.each do |node|
+      to_return[node.node_id] = node.nodes_out.collect{|n| n.node_id}.sort
+    end
+    return to_return
+  end
+end
+
+describe "HeightFinder" do
+  it 'should return maximum number of paths through simple graph' do
+    f = GraphTesting.finishm_graph([[1,2],[1,3],[2,3]])
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[1], true) #forwards
+    height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+    by_height, cycles = height_finder.traverse(f.graph, [onode])
+    GraphTesting.array_of_sorted_nodes(by_height).should == [
+      [3],
+      [2],
+      [1]
+      ]
+    GraphTesting.array_of_sorted_nodes_out(by_height).should == {
+      3=>[],
+      2=>[3],
+      1=>[2,3]
+      }
+    GraphTesting.array_of_sorted_nodes_in(by_height).should == {
+      3=>[1,2],
+      2=>[1],
+      1=>[]
+      }
+    height_finder.max_paths_through(by_height).should == 2
+    height_finder.min_paths_through(by_height).should == 1
+    cycles.should == []
+  end
+
+  it 'should go in reverse' do
+    f = GraphTesting.finishm_graph([
+      [1,2],
+      [1,3],
+      [2,3]
+      ])
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new f.graph.nodes[3], true # forwards
+    height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+    by_height, cycles = height_finder.traverse(f.graph, [onode], :reverse=>true)
+    GraphTesting.array_of_sorted_nodes(by_height).should == [
+      [1],
+      [2],
+      [3]
+      ]
+    GraphTesting.array_of_sorted_nodes_in(by_height).should == {
+      1=>[2,3],
+      2=>[3],
+      3=>[]
+      }
+    GraphTesting.array_of_sorted_nodes_out(by_height).should == {
+      1=>[],
+      2=>[1],
+      3=>[1,2]
+      }
+    height_finder.min_paths_through(by_height).should == 1
+    height_finder.max_paths_through(by_height).should == 2
+    cycles.should == []
+  end
+
+  it 'should respect range' do
+    f = GraphTesting.finishm_graph([
+      [1,2],
+      [1,3],
+      [2,3],
+      [3,4]
+    ])
+    range = [1, 3, 4].collect{|id| f.graph.nodes[id]}
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[1], true) # forwards
+    height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+    by_height, cycles = height_finder.traverse(f.graph, [onode], { :range=>range })
+    GraphTesting.array_of_sorted_nodes(by_height).should == [
+      [4],
+      [3],
+      [1]
+      ]
+    GraphTesting.array_of_sorted_nodes_in(by_height).should == {
+      4=>[3],
+      3=>[1],
+      1=>[]
+      }
+    GraphTesting.array_of_sorted_nodes_out(by_height).should == {
+      4=>[],
+      3=>[4],
+      1=>[3]
+      }
+  end
+
+  it 'should cope with multiple initial nodes' do
+    f = GraphTesting.finishm_graph([
+      [1,3],
+      [2,3],
+      [3,4],
+      [3,5],
+      [4,6],
+      [5,6],
+      [6,7]
+      ])
+    onodes = [2, 7, 3, 1, 5].collect{|id| Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new f.graph.nodes[id], true} #begin in random order
+    height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+    by_height, cycles = height_finder.traverse(f.graph, onodes)
+    GraphTesting.array_of_sorted_nodes(by_height).should == [
+      [7],
+      [6],
+      [4,5],
+      [3],
+      [1,2]
+      ]
+    GraphTesting.array_of_sorted_nodes_in(by_height).should == {
+      7=>[6],
+      6=>[4,5],
+      5=>[3],
+      4=>[3],
+      3=>[1,2],
+      2=>[],
+      1=>[]
+      }
+    GraphTesting.array_of_sorted_nodes_out(by_height).should == {
+      7=>[],
+      6=>[7],
+      5=>[6],
+      4=>[6],
+      3=>[4,5],
+      2=>[3],
+      1=>[3]
+      }
+    height_finder.max_paths_through(by_height).should == 4
+    height_finder.min_paths_through(by_height).should == 2
+    cycles.should == []
+  end
+
+  it 'should cope with multiple bubbling paths' do
+    f = GraphTesting.finishm_graph([
+      [1,2],
+      [1,3],
+      [1,4],
+      [2,8],
+      [3,5],
+      [4,5],
+      [5,6],
+      [5,7],
+      [6,8],
+      [7,8],
+      ])
+    onodes = [1, 2, 3].collect{|id| Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new f.graph.nodes[id], true}
+    height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+    by_height, cycles = height_finder.traverse(f.graph, onodes)
+    GraphTesting.array_of_sorted_nodes(by_height).should == [
+      [8],
+      [2,6,7],
+      [5],
+      [3,4],
+      [1]
+      ]
+    GraphTesting.array_of_sorted_nodes_out(by_height).should == {
+      8=>[],
+      7=>[8],
+      6=>[8],
+      5=>[6,7],
+      4=>[5],
+      3=>[5],
+      2=>[8],
+      1=>[2,3,4]
+      }
+    GraphTesting.array_of_sorted_nodes_in(by_height).should == {
+      8=>[2,6,7],
+      7=>[5],
+      6=>[5],
+      5=>[3,4],
+      4=>[1],
+      3=>[1],
+      2=>[1],
+      1=>[]
+      }
+    height_finder.max_paths_through(by_height).should == 5
+    height_finder.min_paths_through(by_height).should == 3
+    cycles.should == []
+  end
+
+  it 'should report cycles and then ignore them' do
+    f = GraphTesting.finishm_graph([
+      [1,2],
+      [2,3],
+      [2,4],
+      [3,2],
+      [3,4]
+      ])
+    onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(f.graph.nodes[1], true)
+    height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+    by_height, cycles = height_finder.traverse(f.graph, [onode])
+    height_finder.max_paths_through(by_height).should == 2
+    height_finder.min_paths_through(by_height).should == 1
+    GraphTesting.array_of_sorted_nodes(cycles).should == [
+      [2,3]
+      ]
+  end
+
+  it 'should report nested cycles' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3],
+      [3,2],
+      [3,4],
+      [4,2],
+      [4,5]
+      ])
+      onode = Bio::Velvet::Graph::OrientedNodeTrail::OrientedNode.new(graph.nodes[1], true)
+      height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+      by_height, cycles = height_finder.traverse(graph, [onode])
+      GraphTesting.array_of_sorted_nodes(cycles).should == [
+        [2,3],
+        [2,3,4]
+        ]
+
+  end
+
+  describe 'find_oriented_edge_of_range' do
+    it 'should find start and end points of a trail' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3]
+        ])
+      height_finder = Bio::AssemblyGraphAlgorithms::HeightFinder.new
+      start_and_end_onodes = height_finder.find_oriented_edge_of_range(graph)
+      GraphTesting.array_of_sorted_nodes(start_and_end_onodes).sort.should == [
+        [1],
+        [3]
+        ]
+    end
+
+    it 'should find multiple start and end points' do
+      graph = GraphTesting.emit([
+        [3,4],
+        [3,5],
+        [1,3],
+        [2,3]
+        ])
+      start_and_end_onodes = Bio::AssemblyGraphAlgorithms::HeightFinder.new.find_oriented_edge_of_range(graph)
+      GraphTesting.array_of_sorted_nodes(start_and_end_onodes).sort.should == [
+        [1,2],
+        [4,5]
+        ]
+    end
+
+    it 'should respect range argument' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+        [2,4]
+        ])
+      nodes = [1,2,3].collect{|id| graph.nodes[id]}
+      start_and_end_onodes = Bio::AssemblyGraphAlgorithms::HeightFinder.new.find_oriented_edge_of_range(graph, nodes)
+      GraphTesting.array_of_sorted_nodes(start_and_end_onodes).sort.should == [
+        [1],
+        [3]
+        ]
+    end
+
+    it 'should deal with cyclic paths' do
+      graph = GraphTesting.emit([
+        [1,3],
+        [2,3],
+        [3,4],
+        [4,3],
+        [4,5],
+        [4,6]
+        ])
+      start_and_end_onodes = Bio::AssemblyGraphAlgorithms::HeightFinder.new.find_oriented_edge_of_range(graph)
+      GraphTesting.array_of_sorted_nodes(start_and_end_onodes).sort.should == [
+        [1,2],
+        [5,6]
+        ]
+    end
+
+    it 'should cope with a ring graph' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+        [3,1]
+        ])
+      start_and_end_nodes = Bio::AssemblyGraphAlgorithms::HeightFinder.new.find_oriented_edge_of_range(graph)
+      start_and_end_nodes.should == [[],[]]
+    end
+  end
+end

data/spec/kmer_abundance_pattern_spec.rb

@@ -0,0 +1,56 @@
+require 'rspec'
+require 'pp'
+require 'systemu'
+require 'spec_helper'
+
+require 'kmer_abundance_pattern'
+
+
+describe 'kmer_abundance_pattern' do
+  it 'should parse from human' do
+    pat = KmerAbundancePattern.new
+    pat.length.should eq(0)
+
+    pat.parse_from_human '0111'
+    pat.should eq([false, true, true, true])
+
+    pat.parse_from_human '101'
+    pat.should eq([true, false, true])
+  end
+
+  it 'should same_as?' do
+    pat = KmerAbundancePattern.new
+    exp = KmerAbundancePattern.new
+    pat.parse_from_human '101'
+
+    exp.parse_from_human '101'
+    pat.same_as?(exp).should eq(true)
+
+    exp.parse_from_human '111'
+    pat.same_as?(exp).should eq(false)
+
+    exp.parse_from_human '110'
+    pat.same_as?(exp).should eq(false)
+  end
+
+  it 'should consistent_with?' do
+    pat = KmerAbundancePattern.new
+    exp = KmerAbundancePattern.new
+    pat.parse_from_human '101'
+
+    exp.parse_from_human '101'
+    pat.consistent_with?(exp).should eq(true)
+
+    exp.parse_from_human '111'
+    pat.consistent_with?(exp).should eq(true)
+
+    exp.parse_from_human '110'
+    pat.consistent_with?(exp).should eq(false)
+
+    exp.parse_from_human '11-'
+    pat.consistent_with?(exp).should eq(true)
+
+    exp.parse_from_human '1-0'
+    pat.consistent_with?(exp).should eq(false)
+  end
+end