finishm 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4185d82df8d5de264dee94a05867f051d0332b1
-  data.tar.gz: 313d7fd065da5b8fb74e3acd1ed0ed6a20f2b827
+  metadata.gz: ce5a708f7e7dbd95e357c0e58f94ef29c49d0cbf
+  data.tar.gz: ddf1f623a8045f626455e6c25bf78176c792407d
 SHA512:
-  metadata.gz: 0e74180aa4d37ee0307d86ab8352d63531612a76be161366d83e4dbc09a7bfc71d42f0152bafc3e503a5ae5bba6bd00040299d2d0a38717266c8a36a5f873a9c
-  data.tar.gz: 42237938390eb63124b5e9cc33fd01fc69d6ca354117c4745b13980d6f149fbeb0f9759eb36b91701d2f97bfb02a47a9e5cd800837e87d578eb712e06a889581
+  metadata.gz: 6d73d9bbbc21761606fc5503d8818792d5a083f766e6a8c62336e17b50505c4c9c1897b79307f16f1e30b9f97b484695baf7ee46e009de5a375ba3660e26ede4
+  data.tar.gz: 718ad349ab3c87b1d370ed22eb4d7c68574f67ba6c0ab7a477db94211d12b9920e259c2f0aa05194df0e6e5ca79b5167f22f82708c65d50f2adc613b2a180ee1

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.4

data/bin/finishm

@@ -18,12 +18,16 @@ global = OptionParser.new do |opts|
   opts.banner = "
     Usage: #{SCRIPT_NAME} <command> [<arguments>]
 
-  FinishM is a collection of tasks related to assembly and metagenome assembly. Available commands:
+  FinishM is a collection of tasks related to assembly and metagenome assembly. Common commands:
+
+    roundup\tImprove a genome by connecting scaffolds and gapfilling
+    visualise\tVisualise the DeBruijn graph
+
+  Other available commands:
 
     wander\tTry to connect contigs (experimental)
     gapfill\tFill assembly gaps (N characters) (experimental)
     explore\tWhat happens in the graph beyond the end of my contig(s)? (experimental)
-    visualise\tVisualise the DeBruijn graph (experimental)
 
   Commands for PCR finishing:
 

data/finishm.gemspec

@@ -2,17 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: finishm 0.0.2 ruby lib
+# stub: finishm 0.0.4 ruby lib
 # stub: ext/mkrf_conf.rb
 
 Gem::Specification.new do |s|
   s.name = "finishm"
-  s.version = "0.0.2"
+  s.version = "0.0.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib"]
   s.authors = ["Ben J. Woodcroft"]
-  s.date = "2015-07-30"
+  s.date = "2015-08-30"
   s.description = "De-novo assemblies generally only provide draft genomes. FinishM is aimed at improving these draft assemblies."
   s.email = "donttrustben near gmail.com"
   s.executables = ["finishm"]

data/lib/assembly/all_orfs.rb

@@ -9,6 +9,32 @@ module Bio
       CODON_LENGTH = 3
       START_CODONS = ['ATG']
       STOP_CODONS = ['TAG', 'TAA', 'TGA']
+      CODONS = {
+        'A' => ['GCT', 'GCC', 'GCA', 'GCG'],
+        'R' => ['CGT', 'CGC', 'CGA','CGG', 'AGA', 'AGG'],
+        'N' => ['AAT', 'AAC'],
+        'D' => ['GAT', 'GAC'],
+        'C' => ['TGT', 'TGC'],
+        'Q' => ['CAA', 'CAG'],
+        'E' => ['GAA', 'GAG'],
+        'G' => ['GGT', 'GGC', 'GGA', 'GGG'],
+        'H' => ['CAT', 'CAC'],
+        'I' => ['ATT', 'ATC', 'ATA'],
+        'L' => ['TTA', 'TTG', 'CTT', 'CTC', 'CTA', 'CTG'],
+        'K' => ['AAA', 'AAG'],
+        'M' => ['ATG'],
+        'F' => ['TTT', 'TTC'],
+        'P' => ['CCT', 'CCC', 'CCA', 'CCG'],
+        'S' => ['TCT', 'TCC', 'TCA', 'TCG', 'AGT', 'AGC'],
+        'T' => ['ACT', 'ACC', 'ACA', 'ACG'],
+        'W' => ['TGG'],
+        'Y' => ['TAT', 'TAC'],
+        'V' => ['GTT', 'GTC', 'GTA', 'GTG']
+        }
+      TRANSLATOR = CODONS.reduce({}) do |memo, pair|
+        pair[1].each{|key| memo[key] = pair[0]}
+        memo
+      end
 
       # Search for open reading frames in a graph, in all the paths begining at a set of
       # nodes through a graph (or a subset defined by range)
@@ -78,7 +104,7 @@ module Bio
         max_num_paths = options[:max_gapfill_paths]
         max_num_paths ||= 2196
         max_cycles = options[:max_cycles] || 1
-        min_orf_length = options[:minimum_orf_length] || 0
+        min_orf_length = options[:min_orf_length] || 0
 
         counter = SingleCoherentPathsBetweenNodesFinder::CycleCounter.new(max_cycles)
         decide_stack = lambda do |to_push|
@@ -474,10 +500,11 @@ module Bio
         return to_return
       end
 
-      def orf_sequences_from_trails(trails)
-        to_return = {}
+      def orf_sequences_from_trails(trails, min_orf_length=nil)
+        to_return = []
         trails.each do |trail|
           fwd_sequence, twin_sequence = trail.otrail.sequences_within_path
+          trail_length = fwd_sequence.length
           # forward / twin directions
           [
           [fwd_sequence, trail.fwd_orfs_result],
@@ -500,10 +527,12 @@ module Bio
                 end
                 name = "(#{onodes[0].to_shorthand}:#{pair[0].position_in_node}),#{onodes[1...-1].collect{|onode| onode.to_shorthand}.join(',')},(#{onodes[-1].to_shorthand}:#{pair[1].position_in_node})"
 
-                to_return[name] ||= sequence[start_position...end_position]
+                to_return.push [name, sequence[start_position...end_position]]
               end
               result.initial_stop_markers.each do |marker|
                 end_position = marker.position_in_trail
+                start_position = end_position % 3 #trim sequence to multiple of 3
+                next if min_orf_length and end_position - start_position < min_orf_length
 
                 # orf_name
                 last_node = nil
@@ -514,20 +543,29 @@ module Bio
                 end
                 name = "#{onodes[0...-1].collect{|onode| onode.to_shorthand}.join(',')},(#{onodes[-1].to_shorthand}:#{marker.position_in_node})"
 
-                to_return[name] ||= sequence[0...end_position]
+                to_return.push [name, sequence[start_position...end_position]]
               end
               result.final_start_markers.each do |marker|
                 start_position = marker.position_in_trail - 3
+                end_position = (trail_length - start_position) % 3
+                next if min_orf_length and trail_length - end_position - start_position < min_orf_length
 
                 # orf_name
                 onodes = trail.otrail.trail.drop_while{|onode| onode.node != marker.node}
                 name = "(#{onodes[0].to_shorthand}:#{marker.position_in_node}),#{onodes[1..-1].collect{|onode| onode.to_shorthand}.join(',')}"
+                to_return.push [name, sequence[start_position..-1-end_position]]
               end
             end
             if result.nil? or (result.start_stop_pairs.empty? and result.final_start_markers.empty? and result.initial_stop_markers.empty?)
-              name = "#{trail.otrail.to_shorthand}"
+              (0..2).each do |frame|
+                start_position = frame
+                end_position = (trail_length - start_position) % 3
+                next if min_orf_length and trail_length - end_position - start_position < min_orf_length
 
-              to_return[name] ||= sequence
+                # orf_name
+                name = "#{trail.otrail.to_shorthand}"
+                to_return.push [name, sequence[start_position..-1-end_position]]
+              end
             end
           end
         end
@@ -535,6 +573,22 @@ module Bio
         return to_return
       end
 
+      def sequence2AA(sequence)
+        remaining = sequence
+        aa = ""
+        while remaining.length > 0
+          codon = remaining[0...3]
+          log.debug "Found next codon #{codon}" if log.debug?
+          if not TRANSLATOR.has_key?(codon)
+            raise "Cannot translate invalid codon #{codon} in sequence #{sequence}."
+          end
+          log.debug "Codon translated to #{TRANSLATOR[codon]}" if log.debug?
+          aa += TRANSLATOR[codon]
+          remaining = remaining[3..-1]
+        end
+        return aa
+      end
+
       # positions of last base of codons
       class Marker
         attr_accessor :position_in_trail, :position_in_node, :node

data/lib/assembly/contig_printer.rb

@@ -34,6 +34,23 @@ module Bio
         # Enumerable of Enumerables of OrientedNode objects, each list of OrientedNode objects
         # corresponds to a path that forms the connection
         attr_accessor :paths
+
+        # Remove all except the path with maximal coverage from @paths
+        def collapse_paths_to_maximal_coverage_path!
+          return if @paths.nil? or @paths.empty?
+          get_coverage = lambda do |path|
+            numerator = 0
+            denominator = 0
+            path.each do |onode|
+              numerator += onode.node.coverage * onode.node.length_alone
+              denominator += onode.node.length_alone
+            end
+            numerator.to_f / denominator
+          end
+          @paths = [@paths.max do |path1, path2|
+            get_coverage.call(path1) <=> get_coverage.call(path2)
+          end]
+        end
       end
 
       # Given two contigs, return a consensus path and variants of the path.
@@ -293,7 +310,7 @@ module Bio
       def clustalo(sequences)
         i = 0
         stdin = sequences.collect{|s| i+=1; ">#{i}\n#{s}\n"}.join('')
-        log.info "Running clustalo with #{sequences.length} sequences, specifically: #{stdin}" #if log.debug?
+        log.info "Running clustalo with #{sequences.length} sequences, specifically: #{stdin}" if log.debug?
         stdout = Bio::Commandeer.run "clustalo -t DNA -i - --output-order=input-order", {:stdin => stdin, :log => log}
         to_return = []
         header = true

data/lib/assembly/scaffold_breaker.rb

@@ -101,7 +101,8 @@ class Bio::FinishM::ScaffoldBreaker
 
       unless seq.seq.match(/^[ATGCN]+$/i)
         example = seq.seq.match(/([^ATGCN])/i)[1]
-        log.warn "Found unexpected characters in the sequence #{seq.definition} e.g. #{example}, continuing optimistically, but not quite sure what will happen.. good luck"
+        log.warn "Found unexpected characters in the sequence #{seq.definition} e.g. #{example}. Replacing them with Ns"
+        seq.seq.gsub! /[^ATGCN]/i, 'N'
       end
 
       if seq.seq.match(/^N+$/i)

data/lib/finishm/orfs_finder.rb

@@ -2,21 +2,39 @@ class Bio::FinishM::ORFsFinder
   include Bio::FinishM::Logging
 
   DEFAULT_OPTIONS = {
-    :min_orf_length => 100
+    :min_orf_length => 96
     }
 
   def add_options(optparse_object, options)
     options.merge! Bio::FinishM::Visualise::DEFAULT_OPTIONS
     options.merge! DEFAULT_OPTIONS
-    optparse_object.banner = "\nUsage: finishm find_orfs --assembly-???
+    optparse_object.banner = "\nUsage: finishm find_orfs [--orf-amino-acids OUTPUT_FAA --orf-nucleotides OUTPUT_FNA]
 
     Find possible open reading frames in assembly graph
     \n\n"
 
-    optparse_object.separator "Input genome information"
+    optparse_object.separator "\nOutput sequence files\n\n"
+    optparse_object.on("--orf-amino-acids OUTPUT_FAA", "Output ORF amino acid sequences [default: orf.faa unless --orf-nucleotides is specified]") do |arg|
+      options[:output_faa] = arg
+    end
+    optparse_object.on("--orf-nucleotides OUTPUT_FNA", "Output ORF nucleotide sequences [default: orf.fna unless --orf-amino-acids is specified]") do |arg|
+      options[:output_fna] = arg
+    end
+
+    optparse_object.separator "\nInput genome information"
     optparse_object.separator "\nIf an assembly is to be done, there must be some definition of reads:\n\n" #TODO improve this help
     Bio::FinishM::ReadInput.new.add_options(optparse_object, options)
 
+    optparse_object.separator "\nOptional arguments:\n\n"
+    optparse_object.on("--min-orf-length", "Minimum ORF length [default: 96]") do |arg|
+      length = arg.to_i
+      if length.to_s != arg or length.nil? or length < 1
+        raise "Unable to parse minimum orf length parameter #{arg}, cannot continue"
+      end
+      options[:min_orf_length] = length
+    end
+
+
     optparse_object.separator "\nOptional graph-exploration arguments:\n\n"
     Bio::FinishM::Visualise.new.add_probe_options(optparse_object, options)
 
@@ -59,7 +77,18 @@ class Bio::FinishM::ORFsFinder
     end
 
     initial_onodes = Bio::FinishM::PathCounter.new.get_leash_start_nodes(finishm_graph, options[:range])
-    find_orfs_in_graph(finishm_graph, initial_onodes, options)
+    orfs = find_orfs_in_graph(finishm_graph, initial_onodes, options)
+    log.info "Found #{orfs.length} open reading frames longer than #{options[:min_orf_length]}."
+    if not options[:output_fna] and not options[:output_faa]
+        options[:output_fna] = 'orfs.fna'
+    end
+
+    if options[:output_fna]
+        write_orfs_to_file(orfs, options[:output_fna])
+    end
+    if options[:output_faa]
+        write_orfs_to_file(orfs, options[:output_faa], translate=true)
+    end
   end
 
   def find_orfs_in_graph(finishm_graph, initial_onodes, options={})
@@ -73,11 +102,24 @@ class Bio::FinishM::ORFsFinder
     orf_trails = orfer.find_orfs_in_graph(finishm_graph.graph, initial_paths,
         options[:min_orf_length], options[:range])
 
-    found_orfs = orfer.orf_sequences_from_trails(orf_trails)
+    orfer.orf_sequences_from_trails(orf_trails, options[:min_orf_length])
+  end
 
-    found_orfs.each_pair do |name, sequence|
-      puts ">#{name}"
-      puts sequence
+  def write_orfs_to_file(found_orfs, orfs_file, translate=false)
+    if translate
+        translator = Bio::AssemblyGraphAlgorithms::AllOrfsFinder.new
+    end
+    File.open(orfs_file,'w') do |f|
+      counter = 0
+      found_orfs.each do |name_and_sequence|
+        counter += 1
+        f.puts ">finishm_orf_#{counter} #{name_and_sequence[0]}"
+        if translate
+          f.puts translator.sequence2AA(name_and_sequence[1][0...-3])
+        else
+          f.puts name_and_sequence[1]
+        end
+      end
     end
   end
 

data/lib/finishm/roundup.rb

@@ -10,6 +10,7 @@ class Bio::FinishM::RoundUp
     :gapfill_only => false,
     :max_explore_nodes => 10000,
     :max_gapfill_paths => 10,
+    :gapfill_with_max_coverage => false,
     }
 
   def add_options(optparse_object, options)
@@ -64,6 +65,9 @@ the finishm_roundup_results directory in FASTA format. The procedure is then rep
     optparse_object.on("--max-explore-nodes NUM", Integer, "Only explore this many nodes. If max is reached, do not make connections. [default: #{options[:max_explore_nodes] }]") do |arg|
       options[:max_explore_nodes] = arg
     end
+    optparse_object.on("--gapfill-with-max-coverage", "When gapfilling, take the path with maximal coverage and do not print variants [default: #{options[:gapfill_with_max_coverage] }]") do
+      options[:gapfill_with_max_coverage] = true
+    end
     optparse_object.on("--debug", "Build the graph, then drop to a pry console. [default: #{options[:debug] }]") do
       options[:debug] = true
     end
@@ -193,6 +197,7 @@ the finishm_roundup_results directory in FASTA format. The procedure is then rep
                     # Just arbitrarily put in 100 N characters, to denote a join, but no gapfill
                     scaffold_sequence = scaffold_sequence+('N'*100)+rhs_sequence
                   else
+                    acon.collapse_paths_to_maximal_coverage_path! if options[:gapfill_with_max_coverage]
                     scaffold_sequence, variants = printer.ready_two_contigs_and_connections(
                       master_graph.graph,
                       scaffold_sequence,
@@ -321,7 +326,7 @@ the finishm_roundup_results directory in FASTA format. The procedure is then rep
     return gapfilled_sequence, num_gapfills, all_variants
   end
 
-  def piece_together_gapfill(printer, master_graph, first_sequence, aconn, second_sequence, gap_length, max_gapfill_paths)
+  def piece_together_gapfill(printer, master_graph, first_sequence, aconn, second_sequence, gap_length, max_gapfill_paths, options)
     scaffold_sequence = nil
     gapfilled = -1
     if aconn.paths.length == 0 or aconn.paths.length > max_gapfill_paths
@@ -329,6 +334,7 @@ the finishm_roundup_results directory in FASTA format. The procedure is then rep
       scaffold_sequence = first_sequence + 'N'*gap_length + second_sequence
       gapfilled = false
     else
+      acon.collapse_paths_to_maximal_coverage_path! if options[:gapfill_with_max_coverage]
       scaffold_sequence, variants = printer.ready_two_contigs_and_connections(
         master_graph.graph, first_sequence, aconn, second_sequence, master_graph.velvet_sequences
         )

data/lib/finishm/visualise.rb

@@ -38,7 +38,8 @@ class Bio::FinishM::Visualise
     return validate_argv_length(argv) ||
         validate_visualisation_options(options) ||
         validate_probe_options(options) ||
-        validate_assembly_options(options)
+        validate_assembly_options(options) ||
+        validate_scaffold_options(options)
   end
 
   def add_visualisation_options(optparse_object, options)
@@ -79,8 +80,8 @@ class Bio::FinishM::Visualise
 
   def validate_scaffold_options(options)
     # If scaffolds are defined, then probe genomes must also be defined
-    if options[:scaffolds] and !options[:assembly_files]
-      return "If --scaffolds is defined, so then must --genomes"
+    if options[:scaffold_sides] and !options[:assembly_files]
+      return "If --scaffolds is given, then --genomes must also be given"
     end
   end
 

data/spec/all_orfs_spec.rb

@@ -195,6 +195,127 @@ describe "AllOrfs" do
     res.collect{|result| result.initial_start_markers}.should == [[],[]]
   end
 
+  it 'should find two same-phase orfs along a trail' do
+    graph, = GraphTesting.emit_otrails([
+      [1,2,3]
+      ])
+    graph.nodes[1].ends_of_kmers_of_node = 'TAAATGGAAA' #stop codon 'TAA', start codon 'ATG'
+    graph.nodes[2].ends_of_kmers_of_node = 'AATAAATGGA' #stop codon 'TAA', start codon 'ATG'
+    graph.nodes[3].ends_of_kmers_of_node = 'AAAAAAATAA' #stop codon 'TAA'
+    initial_path = GraphTesting.make_onodes(graph, %w(1s))
+
+    orfer = Bio::AssemblyGraphAlgorithms::AllOrfsFinder.new
+    problems = orfer.find_all_problems(graph, [initial_path])
+    #pp problems
+
+    paths = orfer.find_orfs_from_problems(problems)
+    #pp paths
+    GraphTesting.sorted_paths(paths.trails).should == [
+      [1,2,3]
+      ]
+    res = paths.trails[0].fwd_orfs_result
+    GraphTesting.sorted_marker_pair_positions(res.start_stop_pairs).should == [
+      [6,15],
+      [18,30]
+      ]
+    GraphTesting.sorted_marker_pair_node_positions(res.start_stop_pairs).should == [
+      [[1,6],[2,5]],
+      [[2,8], [3,10]]
+      ]
+    res.initial_start_markers.should == []
+    GraphTesting.marker_positions(res.initial_stop_markers).should == [3]
+    GraphTesting.marker_node_positions(res.initial_stop_markers).should == [[1,3]]
+    res.final_start_markers.should == []
+  end
+
+  it 'should end orfs at first stop codon in forward direction' do
+    graph, = GraphTesting.emit_otrails([
+      [1,2,3]
+      ])
+    graph.nodes[1].ends_of_kmers_of_node = 'TAAATGGAAA' #stop codon 'TAA', start codon 'ATG'
+    graph.nodes[2].ends_of_kmers_of_node = 'AATAAAAAGA' #stop codon 'TAA'
+    graph.nodes[3].ends_of_kmers_of_node = 'AAAAAAATAA' #stop codon 'TAA'
+    initial_path = GraphTesting.make_onodes(graph, %w(1s))
+
+    orfer = Bio::AssemblyGraphAlgorithms::AllOrfsFinder.new
+    problems = orfer.find_all_problems(graph, [initial_path])
+    #pp problems
+
+    paths = orfer.find_orfs_from_problems(problems)
+    #pp paths
+    GraphTesting.sorted_paths(paths.trails).should == [
+      [1,2,3]
+      ]
+    res = paths.trails[0].fwd_orfs_result
+    GraphTesting.sorted_marker_pair_positions(res.start_stop_pairs).should == [
+      [6,15]
+      ]
+    GraphTesting.sorted_marker_pair_node_positions(res.start_stop_pairs).should == [
+      [[1,6],[2,5]]
+      ]
+    res.initial_start_markers.should == []
+    GraphTesting.marker_positions(res.initial_stop_markers).should == [3]
+    GraphTesting.marker_node_positions(res.initial_stop_markers).should == [[1,3]]
+    res.final_start_markers.should == []
+  end
+
+  it 'should end orfs at first stop codon in twin direction' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3]
+      ])
+    graph.nodes[1].ends_of_kmers_of_twin_node = 'TTAGTTTTTT' # stop codon 'TAG'
+    graph.nodes[2].ends_of_kmers_of_twin_node = 'TTTAGTTTTT' # stop codon 'TAG'
+    graph.nodes[3].ends_of_kmers_of_twin_node = 'TAAATGTTTT' # stop codon 'TAA', start codon 'ATG'
+    initial_path = GraphTesting.make_onodes(graph, %w(1s))
+
+    orfer = Bio::AssemblyGraphAlgorithms::AllOrfsFinder.new
+    problems = orfer.find_all_problems(graph, [initial_path])
+    #pp problems
+
+    paths = orfer.find_orfs_from_problems(problems)
+    #pp paths
+    GraphTesting.sorted_paths(paths.trails).should == [
+      [1,2,3]
+      ]
+    res = paths.trails[0].twin_orfs_result
+    GraphTesting.sorted_marker_pair_positions(res.start_stop_pairs).should == [
+      [6,15]
+      ]
+    GraphTesting.sorted_marker_pair_node_positions(res.start_stop_pairs).should == [
+      [[3,6],[2,5]]
+      ]
+    res.initial_start_markers.should == []
+    GraphTesting.marker_positions(res.initial_stop_markers).should == [3]
+    GraphTesting.marker_node_positions(res.initial_stop_markers).should == [[3,3]]
+    res.final_start_markers.should == []
+  end
+
+  it 'should return the first initial stop codon in forward direction' do
+    graph = GraphTesting.emit([
+      [1,2],
+      [2,3]
+      ])
+    graph.nodes[1].ends_of_kmers_of_node = 'AAATAGAAAA' # stop codon 'TAG'
+    graph.nodes[2].ends_of_kmers_of_node = 'AATAGAAAAA' # stop codon 'TAG'
+    initial_path = GraphTesting.make_onodes(graph, %w(1s))
+
+    orfer = Bio::AssemblyGraphAlgorithms::AllOrfsFinder.new
+    problems = orfer.find_all_problems(graph, [initial_path])
+    #pp problems
+
+    paths = orfer.find_orfs_from_problems(problems)
+    #pp paths
+    GraphTesting.sorted_paths(paths.trails).should == [
+      [1,2,3]
+      ]
+    res = paths.trails[0].fwd_orfs_result
+    res.start_stop_pairs.should == []
+    res.initial_start_markers.should == []
+    GraphTesting.marker_positions(res.initial_stop_markers).should == [6]
+    GraphTesting.marker_node_positions(res.initial_stop_markers).should == [[1,6]]
+    res.final_start_markers.should == []
+  end
 
   it 'should respect terminal nodes' do
     fail '#todo'
@@ -433,11 +554,79 @@ describe "AllOrfs" do
 
       paths = orfer.find_orfs_from_problems(problems)
       #pp paths
-      orfer.orf_sequences_from_trails(paths.trails).should == {
-        '(1s:6),2s,(3s:10)' => 'ATGGAAAAAAAAAAAAAAAAAAAATAA',
-        '1s,2s,3s' => 'T'*30,
-        ',(1s:3)' => 'TAA'
-        }
+      orfer.orf_sequences_from_trails(paths.trails).should == [
+        ['(1s:6),2s,(3s:10)', 'ATGGAAAAAAAAAAAAAAAAAAAATAA'],
+        [',(1s:3)', 'TAA'],
+        ['1s,2s,3s', 'T'*30],
+        ['1s,2s,3s', 'T'*27],
+        ['1s,2s,3s', 'T'*27]
+        ]
+    end
+
+    it 'should respect minimum orf length' do
+      graph = GraphTesting.emit([
+        [1,2],
+        [2,3]
+        ])
+      graph.nodes[1].ends_of_kmers_of_node = 'TAAATGGAAA' #stop codon 'TAA', start codon 'ATG'
+      graph.nodes[3].ends_of_kmers_of_node = 'AAAAAAATAA' #stop codon 'TAA'
+      initial_path = GraphTesting.make_onodes(graph, %w(1s))
+
+      orfer = Bio::AssemblyGraphAlgorithms::AllOrfsFinder.new
+      problems = orfer.find_all_problems(graph, [initial_path])
+
+      paths  =  orfer.find_orfs_from_problems(problems, :min_orf_length => 30)
+      orfer.orf_sequences_from_trails(paths.trails, 30).should == [
+        ['1s,2s,3s', 'T'*30]
+        ]
+
+      paths  =  orfer.find_orfs_from_problems(problems, :min_orf_length => 20)
+      orfer.orf_sequences_from_trails(paths.trails, 20).should == [
+        ['(1s:6),2s,(3s:10)', 'ATGGAAAAAAAAAAAAAAAAAAAATAA'],
+        ['1s,2s,3s', 'T'*30],
+        ['1s,2s,3s', 'T'*27],
+        ['1s,2s,3s', 'T'*27]
+        ]
+
+      paths  =  orfer.find_orfs_from_problems(problems, :min_orf_length => 0)
+      orfer.orf_sequences_from_trails(paths.trails, 0).should == [
+        ['(1s:6),2s,(3s:10)', 'ATGGAAAAAAAAAAAAAAAAAAAATAA'],
+        [',(1s:3)', 'TAA'],
+        ['1s,2s,3s', 'T'*30],
+        ['1s,2s,3s', 'T'*27],
+        ['1s,2s,3s', 'T'*27]
+        ]
+
+    end
+  end
+
+  describe 'sequence2AA' do
+    it 'should return corresponding amino acids for an orf sequence' do
+      orfer = Bio::AssemblyGraphAlgorithms::AllOrfsFinder.new
+      orfer.sequence2AA('GCTGCCGCAGCG').should == 'AAAA'
+      orfer.sequence2AA('CGTCGCCGACGGAGAAGG').should == 'RRRRRR'
+      orfer.sequence2AA('AATAAC').should == 'NN'
+      orfer.sequence2AA('GATGAC').should == 'DD'
+      orfer.sequence2AA('TGTTGC').should == 'CC'
+      orfer.sequence2AA('CAACAG').should == 'QQ'
+      orfer.sequence2AA('GAAGAG').should == 'EE'
+      orfer.sequence2AA('GGTGGCGGAGGG').should == 'GGGG'
+      orfer.sequence2AA('CATCAC').should == 'HH'
+      orfer.sequence2AA('ATTATCATA').should == 'III'
+      orfer.sequence2AA('TTATTGCTTCTCCTACTG').should == 'LLLLLL'
+      orfer.sequence2AA('AAAAAG').should == 'KK'
+      orfer.sequence2AA('ATG').should == 'M'
+      orfer.sequence2AA('TTTTTC').should == 'FF'
+      orfer.sequence2AA('CCTCCCCCACCG').should == 'PPPP'
+      orfer.sequence2AA('TCTTCCTCATCGAGTAGC').should == 'SSSSSS'
+      orfer.sequence2AA('ACTACCACAACG').should == 'TTTT'
+      orfer.sequence2AA('TGG').should == 'W'
+      orfer.sequence2AA('TATTAC').should == 'YY'
+      orfer.sequence2AA('GTTGTCGTAGTG').should == 'VVVV'
+      lambda { orfer.sequence2AA('TAA') }.should raise_error
+      lambda { orfer.sequence2AA('TGA') }.should raise_error
+      lambda { orfer.sequence2AA('TAG') }.should raise_error
+      lambda { orfer.sequence2AA('ABCXYZ') }.should raise_error
     end
   end
 end

data/spec/contig_printer_spec.rb

@@ -42,7 +42,7 @@ describe "ContigPrinter" do
                    '14S:GTT',
                   ].sort
     end
-    
+
     it 'should handle not variants' do
       seqs = [
               'ATGAATATGTGCATAGGATT',
@@ -235,7 +235,7 @@ describe "ContigPrinter" do
         GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 11e 2s 10s 4e)),#highest coverage
         GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 1e 2e 10s 4e)),
         ]
-      expected = 
+      expected =
         'ATGAACGAACGCTGGCGGCATGCCTAACACATGCAAGTCGAACGAGACCTTCGGGTCTAGTGGCGCACGGGTGCGTAACGCGTGGGAATCTGCCCTTGGGTACGG'+
         'AATAACAGTTAGAAATGACTGCTAATACCGTATAATGACTTCGGTCCAAAGATTTATCGCCCAGGGATGAGCCCGCGTAGGATTAGCTTGTTGGTGAGGTAAANN'+
         'NTNNCNNANNNNNNNNNNNNTNNNNNGNNNNNNNNNNNGNTNAGNNNCNNNGNNNNNGNGANNTGGCCCAGACTCCTACGGGAGGCAGCAGTGGGGAATATTGGACAATGGGC'+
@@ -283,9 +283,27 @@ describe "ContigPrinter" do
     it 'should handle when start_coord is not == 0 and both reads are outwards facing' do
       raise
     end
-    
+
     it 'should handle when the example path is not the same length as the reference path' do
       fail
     end
   end
+
+  describe 'AnchoredConnection' do
+    it 'should collapse_paths_to_maximal_coverage_path!' do
+      graph = Bio::Velvet::Graph.parse_from_file(File.join TEST_DATA_DIR, 'contig_printer','1','seq.fa.velvet','LastGraph')
+      graph.nodes.length.should == 13
+      acon = Bio::AssemblyGraphAlgorithms::ContigPrinter::AnchoredConnection.new
+      acon.start_probe_noded_read = graph.nodes[9].short_reads.select{|nr| nr.read_id == 161}[0] #Found these by using bwa and inspecting the Sequence velvet file
+      acon.end_probe_noded_read = graph.nodes[4].short_reads.select{|nr| nr.read_id == 1045}[0]
+      acon.start_probe_contig_offset = 2
+      acon.end_probe_contig_offset = 3
+      acon.paths = [
+        GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 11e 2s 10s 4e)),#highest coverage
+        GraphTesting.make_onodes(graph, %w(9s 12s 7e 13s 5e 1e 2e 10s 4e)),
+        ]
+      acon.collapse_paths_to_maximal_coverage_path!
+      acon.paths.collect{|path| path.to_shorthand}.should == [%w(9s 12s 7e 13s 5e 11e 2s 10s 4e).join(',')]
+    end
+  end
 end

data/spec/scaffold_breaker_spec.rb

@@ -141,4 +141,18 @@ describe "ScaffoldBreaker" do
       brokes[0].sequence.should == seq
     end
   end
+
+  it 'should replace non-ATGC characters with N' do
+    breaker = Bio::FinishM::ScaffoldBreaker.new
+    Tempfile.open('a') do |tmp|
+      tmp.puts '>ab'
+      seq = 'AAAAANNNGGGYYYTTNNAA'
+      tmp.puts seq
+      #         1234567890123456789
+      tmp.close
+
+      brokes = breaker.break_scaffolds(tmp.path)
+      brokes[0].sequence.should == 'AAAAANNNGGGNNNTTNNAA'
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: finishm
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Ben J. Woodcroft
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-30 00:00:00.000000000 Z
+date: 2015-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bio-ipcress