finishm 0.0.1

data/spec/single_coherent_wanderer_spec.rb

@@ -0,0 +1,120 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "SingleCoherentWanderer" do
+  describe 'wander' do
+    it 'should calculate connections using a simple depth first search' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+      ])
+      finishm_graph = Bio::FinishM::ProbedGraph.new
+      finishm_graph.graph = graph
+      finishm_graph.probe_nodes = [graph.nodes[1],graph.nodes[2]]
+      finishm_graph.probe_node_directions = [true, false]
+
+      cartographer = Bio::AssemblyGraphAlgorithms::SingleCoherentWanderer.new
+      cartographer.wander(finishm_graph, 10000, 1, {}).should == {
+        [0,1] => 10
+      }
+    end
+
+    it 'should calculate connections using a simple depth first search multiple singly connected' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+        [4,5]
+      ])
+      finishm_graph = Bio::FinishM::ProbedGraph.new
+      finishm_graph.graph = graph
+      finishm_graph.probe_nodes = [
+        graph.nodes[1],graph.nodes[3],
+        graph.nodes[4],graph.nodes[5],
+      ]
+      finishm_graph.probe_node_directions = [true, false, true, false]
+
+      cartographer = Bio::AssemblyGraphAlgorithms::SingleCoherentWanderer.new
+      cartographer.wander(finishm_graph, 10000, 1, {}).should == {
+        [0,1] => 20,
+        [2,3] => 10,
+      }
+    end
+
+    it 'should calculate connections using a simple depth first search multiply connected' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+        [3,4],
+        [4,5],
+      ])
+      finishm_graph = Bio::FinishM::ProbedGraph.new
+      finishm_graph.graph = graph
+      finishm_graph.probe_nodes = [
+        graph.nodes[1],graph.nodes[3],
+        graph.nodes[4],graph.nodes[5],
+      ]
+      finishm_graph.probe_node_directions = [true, false, true, false]
+
+      cartographer = Bio::AssemblyGraphAlgorithms::SingleCoherentWanderer.new
+      cartographer.wander(finishm_graph, 10000, 1, {}).should == {
+        [0,1] => 20,
+        [0,3] => 40,
+        [2,3] => 10,
+      }
+    end
+
+    it 'should calculate connections using a simple depth first search respect leash' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+        [3,4],
+        [4,5],
+      ])
+      finishm_graph = Bio::FinishM::ProbedGraph.new
+      finishm_graph.graph = graph
+      finishm_graph.probe_nodes = [
+        graph.nodes[1],graph.nodes[3],
+        graph.nodes[4],graph.nodes[5],
+      ]
+      finishm_graph.probe_node_directions = [true, false, true, false]
+
+      cartographer = Bio::AssemblyGraphAlgorithms::SingleCoherentWanderer.new
+      cartographer.wander(finishm_graph, 20, 1, {}).should == {
+        [0,1] => 20,
+        #[0,3] => 40,
+        [2,3] => 10,
+      }
+    end
+
+    it 'should respect recoherence in the simplest case' do
+      graph, initial_path, terminal_onode = GraphTesting.emit_ss([
+        [1,2],
+
+        [2,3],
+        [3,4],
+        [4,5],
+
+        [2,6],
+        [6,5],
+      ], 1, 5)
+      GraphTesting.add_noded_reads(graph,[
+        [1,2,3,4,5],
+        [2,6,5], #1,2,6 won't survive recoherence
+        ])
+      finishm_graph = Bio::FinishM::ProbedGraph.new
+      finishm_graph.graph = graph
+      finishm_graph.probe_nodes = [
+        graph.nodes[1],graph.nodes[5],
+      ]
+      finishm_graph.probe_node_directions = [true, false]
+
+      cartographer = Bio::AssemblyGraphAlgorithms::SingleCoherentWanderer.new
+      cartographer.wander(finishm_graph, 100, 100, {}).should == {
+        [0,1] => 40,
+        } #with real recoherence have to take the longer way
+      cartographer.wander(finishm_graph, 100, 1, {}).should == {
+        [0,1] => 30,
+        }#with no recoherence have to take the shorter way
+    end
+  end
+end
+

data/spec/single_ended_assembler_spec.rb

@@ -0,0 +1,398 @@
+require 'ds'
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+#Bio::Log::CLI.logger('stderr'); Bio::Log::CLI.trace('debug'); log = Bio::Log::LoggerPlus.new('finishm'); Bio::Log::CLI.configure('finishm')
+
+describe "SingleEndedAssembler" do
+  describe 'is_short_tip?' do
+    it 'should clip short tips correctly' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new(graph)
+      assembler.assembly_options[:max_tip_length] = 35
+      assembler.is_short_tip?(initial_path[0]).should == [true, [[2, :start_is_first], [3,:start_is_first]]]
+      assembler.is_short_tip?(initial_path[0])[0].should == true
+      assembler.assembly_options[:max_tip_length] = 25
+      assembler.is_short_tip?(initial_path[0])[0].should == false
+    end
+
+    it 'should clip short tips in a harder situation' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [3,4],
+        [1,4]
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 35
+      assembler.is_short_tip?(initial_path[0])[0].should == false
+      assembler.assembly_options[:max_tip_length] = 45
+      assembler.is_short_tip?(initial_path[0])[0].should == true
+    end
+
+    it 'should clip when there is only 1 node' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 25
+      assembler.is_short_tip?(initial_path[0])[0].should == true
+      assembler.assembly_options[:max_tip_length] = 15
+      assembler.is_short_tip?(initial_path[0])[0].should == false
+    end
+  end
+
+
+
+
+  describe 'assemble_from' do
+    it 'should hello world' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s,3s'
+    end
+
+    it 'should ignore short tips' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [2,4],
+        [4,5],
+        [5,6],
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 15
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s,4s,5s,6s'
+    end
+
+    it 'should stop at a proper fork' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [2,4],
+        [4,5],
+        [5,6],
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 5
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s'
+    end
+
+    it 'should use single read decoherence' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [2,4]
+        ], 1)
+      GraphTesting.add_noded_reads(graph,[
+        [1,2,4],
+        [2,3]
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 5
+      assembler.assembly_options[:recoherence_kmer] = 22
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s,4s'
+    end
+
+    it 'should fail when single read decoherence fails' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [2,4]
+        ], 1)
+      GraphTesting.add_noded_reads(graph,[
+        [1,2],
+        [2,3],
+        [2,4],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 5
+      assembler.assembly_options[:recoherence_kmer] = 22
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s'
+    end
+
+    it 'should fail when still forked when single read decoherence fails' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [2,4]
+        ], 1)
+      GraphTesting.add_noded_reads(graph,[
+        [1,2,3],
+        [1,2,4],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 5
+      assembler.assembly_options[:recoherence_kmer] = 22
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s'
+    end
+
+    it 'should recognise circles' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [3,1],
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s,3s,1s'
+    end
+
+
+    it 'should respect the leash length' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [2,3],
+        [3,1],
+        ], 1)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:leash_length] = 15
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,2s'
+    end
+
+    it 'should take the longest path at the end of the contig' do
+      graph, initial_path, terminal = GraphTesting.emit_ss([
+        [1,2],
+        [1,3],
+        ], 1, 4)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      graph.nodes[3].ends_of_kmers_of_node = 'T'*100 #make this long so it is chosen
+      assembler.assembly_options[:max_tip_length] = 200
+      observed, visits = assembler.assemble_from(initial_path)
+      observed.to_shorthand.should == '1s,3s'
+    end
+  end
+
+
+
+
+  describe 'assemble' do
+    it 'should hello world' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 2
+      assembler.assembly_options[:min_contig_size] = 0
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      paths.collect{|path| path.to_shorthand}.should == [
+        '1s,2s,3s'
+        ]
+    end
+
+    it 'should assemble two disconnected components' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+
+        [4,5],
+        [5,6],
+        [6,7],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 2
+      assembler.assembly_options[:min_contig_size] = 0
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      paths.collect{|path| path.to_shorthand}.should == [
+        '1s,2s,3s',
+        '4s,5s,6s,7s',
+        ]
+    end
+
+    it 'should yield correctly' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+
+        [4,5],
+        [5,6],
+        [6,7],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 2
+      assembler.assembly_options[:min_contig_size] = 0
+      expecteds = DS::Queue.new
+      expecteds.enqueue '1s,2s,3s'
+      expecteds.enqueue '4s,5s,6s,7s'
+      assembler.assemble do |path|
+        path.to_shorthand.should == expecteds.dequeue
+      end
+    end
+
+    it 'should respect the minimum starting node coverage option' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3],
+
+        [4,5],
+        [5,6],
+        [6,7],
+        ])
+      graph.nodes.each do |node|
+        node.coverages = [10]
+      end
+      graph.nodes[1].coverages[0] = 100
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 2
+      assembler.assembly_options[:min_contig_size] = 0
+      assembler.assembly_options[:min_coverage_of_start_nodes] = 2
+
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      paths.collect{|path| path.to_shorthand}.should == [
+        '1s,2s,3s',
+        ]
+    end
+
+    it 'should not start assembling from short tips' do
+      graph = GraphTesting.emit([
+        [1,4], #this is the short tip
+        [2,3],
+        [3,4],
+        [4,5],
+        [5,6],
+        [6,7],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 15
+      assembler.assembly_options[:min_contig_size] = 0
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      GraphTesting.sorted_fwd_shorthand_paths(paths).should == [
+        '2s,3s,4s,5s,6s,7s',
+        ]
+    end
+
+    it 'should not start assembling from complex short tips' do
+      graph = GraphTesting.emit([
+        [1,10], #this is the short tip
+        [10,11],
+        [10,12],
+        [11,6],
+        [12,6],
+
+        [2,3],
+        [3,4],
+        [4,5],
+        [5,6],
+        [6,7],
+        [7,8],
+        [8,9],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = 35
+      assembler.assembly_options[:min_contig_size] = 40
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      GraphTesting.sorted_fwd_shorthand_paths(paths).should == [
+        '2s,3s,4s,5s,6s,7s,8s,9s',
+        ]
+    end
+
+    it 'should not throw out large single node paths' do
+      graph = GraphTesting.emit([
+        [1,2],
+        ])
+      graph.delete_nodes_if{|node| node.node_id == 2}
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = -1
+      assembler.assembly_options[:min_contig_size] = 0
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      paths.collect{|path| path.to_shorthand}.should == [
+        '1s'
+        ]
+    end
+
+    it 'should not choke when the starting node is itself forked' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [3,1],
+        [3,4],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = -1
+      assembler.assembly_options[:min_contig_size] = 5
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      GraphTesting.sorted_fwd_shorthand_paths(paths).should == [
+        "2e,1e,3e",
+        '4s',
+        ]
+    end
+
+    it 'should not choke when two nodes along the starting trail are legitimate forks' do
+      # a nasty one. Starts at node 1, which then leads to starting at node 3.
+      # both node 3 and node 2 have in-arcs
+      graph = GraphTesting.emit([
+        [3,2],
+        [2,1],
+        [7,2],
+        [6,3],
+        [3,8],
+        [3,4],
+        [3,5],
+        ])
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      assembler.assembly_options[:max_tip_length] = -1
+      assembler.assembly_options[:min_contig_size] = 5
+      paths = assembler.assemble
+      paths.kind_of?(Array).should == true
+      GraphTesting.sorted_fwd_shorthand_paths(paths).should == [
+        '1e,2e',
+        '3e,6e',
+        '4s',
+        '5s',
+        '7s',
+        '8s',
+        ]
+    end
+
+    it 'should be able to deal with recoherence when getting out of a short tip' do
+      fail
+    end
+  end
+
+  describe 'remove_tips' do
+    it 'should remove one of two short tips' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [3,1],
+        [3,4],
+        ], 3, 2)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      non_tips, visiteds = assembler.remove_tips(initial_path.neighbours_of_last_node(graph), 15)
+      non_tips.collect{|n| n.to_shorthand}.should == ['1s']
+      visiteds.sort.should == [[4, :start_is_first]]
+    end
+
+    it 'should work on bubbles (possibly it shouldn\'t though)' do
+      graph, initial_path = GraphTesting.emit_ss([
+        [1,2],
+        [1,3],
+        [2,4],
+        [3,4],
+        ], 1, 2)
+      assembler = Bio::AssemblyGraphAlgorithms::SingleEndedAssembler.new graph
+      graph.nodes[3].ends_of_kmers_of_node = 'T'*11 #make this long so it is chosen
+      non_tips, visiteds = assembler.remove_tips(initial_path.neighbours_of_last_node(graph), 25)
+      non_tips.collect{|n| n.to_shorthand}.should == ['3s']
+      visiteds.sort.should == [[2, :start_is_first], [4, :start_is_first]]
+    end
+  end
+end