finishm 0.0.1

data/lib/assembly/c_probe_node_finder.rb

@@ -0,0 +1,38 @@
+class Bio::FinishM::CProbeNodeFinder
+  include Bio::FinishM::Logging
+
+  # Return an array of [best_node, best_noded_read] that represent the probes in the graph
+  def find_probes(velvet_underground_graph, probe_read_ids)
+    # First use the C method to extract the set of interesting nodes
+    log.debug "Extracting target nodes using the C method.." if log.debug?
+    target_node_ids = find_probe_nodes(velvet_underground_graph, probe_read_ids)
+
+    # Then iterate over just those nodes we know are interesting
+    log.debug "Extracting from only those #{target_node_ids.length} nodes that are interesting.." if log.debug?
+    target_node_ids_set = Set.new target_node_ids
+    return Bio::AssemblyGraphAlgorithms::NodeFinder.new.find_unique_nodes_with_sequence_ids(
+      velvet_underground_graph, probe_read_ids, :target_node_ids => target_node_ids_set
+      )
+  end
+
+  # Return a minimal Array of node IDs that contain all probe read IDs
+  def find_probe_nodes(velvet_underground_graph, probe_read_ids)
+    @bindings ||= Bio::FinishM::VelvetCBinding.new
+
+    c_probe_read_ids = FFI::MemoryPointer.new(:int32, probe_read_ids.length)
+    c_probe_read_ids.write_array_of_int32(probe_read_ids)
+
+    probe_nodes = @bindings.extract_best_probe_reads(
+      velvet_underground_graph.internal_graph_struct,
+      c_probe_read_ids,
+      probe_read_ids.length)
+    probe_nodes2 = probe_nodes.read_array_of_int32(probe_read_ids.length).collect{|n| n.abs}.uniq
+
+    #clean up
+    c_probe_read_ids.free
+
+    return probe_nodes2
+  end
+end
+
+

data/lib/assembly/connection_interpreter.rb

@@ -0,0 +1,350 @@
+require 'yargraph'
+
+
+class Bio::FinishM::ConnectionInterpreter
+  include Bio::FinishM::Logging
+
+  # connections is an Enumerable of Probe object , sequences is a hash of name => DNA string
+  def initialize(connections, sequence_ids)
+    @graph = Yargraph::UndirectedGraph.new
+    @circular_probes = []
+    @sequence_ids = sequence_ids
+
+    # Setup hash of setable to original
+    # Assume there is only 1 connection between two contig ends
+    @connection_hash = {}
+    connections.each do |conn|
+      key = conn.to_settable
+      raise "Duplicate connections not handled (yet?), found #{conn} => #{key}" if @connection_hash.key?(key)
+      @connection_hash[key] = conn
+    end
+
+    # Add connections
+    connections.each do |conn|
+      if conn.probe1.to_settable == conn.probe2.to_settable
+        @circular_probes.push con..probe1
+      else
+        @graph.add_edge conn.probe1.to_settable, conn.probe2.to_settable
+      end
+    end
+
+    log.debug "Created a graph with #{@graph.vertices.to_a.length} vertices and #{@graph.edges.length} edges" if log.debug?
+  end
+
+  def connections
+    @connection_hash.values
+  end
+
+  # Return sequences that exclusively connect the start to the end. In particular,
+  # return an Array of sequence names
+  def circular_sequences
+    to_return = []
+    connections.each do |conn|
+      if conn.probe1.sequence_index == conn.probe2.sequence_index and
+        conn.probe1.side != conn.probe2.side and
+        @graph.edges[conn.probe1.to_settable].length == 1 and
+        @graph.edges[conn.probe2.to_settable].length == 1
+
+        to_return.push conn.probe1.sequence_index
+      end
+    end
+    return to_return
+  end
+
+
+  # Return an Array of Connection objects that represent edges where
+  # there is only a single connection from both side
+  def doubly_single_contig_connections
+    likelies = []
+
+    already_seen_connections = Set.new
+
+    @graph.vertices.each do |v|
+      # If there is only 1 connection on both sides, then go with that
+      neighbours = @graph.neighbours(v)
+      log.debug "Testing connection between #{v} and #{neighbours}"
+      if neighbours.length == 1 and @graph.neighbours(neighbours[0]).length == 1
+        log.debug "Connection passed the doubly-test" if log.debug?
+        neighbour = neighbours[0]
+
+        conn = Connection.new
+        conn.probe1 = Probe.new(v)
+        conn.probe2 = Probe.new(neighbour)
+        settable = conn.to_settable
+        # Record the connection unless it is duplicate
+        unless already_seen_connections.include?(settable)
+          likelies.push @connection_hash[settable]
+          already_seen_connections << settable
+        end
+      end
+    end
+
+    return likelies
+  end
+
+  # Single linkage cluster the likely_inter_contig_connections
+  # and the start to ends for each of the contigs. Assumes
+  def scaffolds(contig_connections)
+    # It is like an (easy)
+    # assembly problem because each vertex can only be connected to
+    # two others - 1 intra-contig and 1 inter-contig (unless it is circular)
+    likelies_edge_set = Yargraph::UndirectedGraph::EdgeSet.new
+    contig_connections.each do |conn|
+      likelies_edge_set.add_edge conn.probe1.to_settable, conn.probe2.to_settable
+    end
+
+    scaffolded_paths = []
+    circular_single_contigs = Set.new
+
+    # while there is more elements in the likelies set,
+    # 'pop' an arbitrary edge out of the graph
+    while starting_edge = likelies_edge_set.pop
+      log.debug "starting to scaffold from #{starting_edge}" if log.debug?
+
+      # Ignore likelies that are circular
+      if starting_edge[0][0] == starting_edge[1][0]
+        log.debug "Not scaffolding contig #{starting_edge[0][0] } since it appears to be circular" if log.debug?
+        circular_single_contigs << starting_edge[0][0]
+        next
+      end
+
+      circular = false
+
+      # go 'left'. Connect the other side of the left.
+      lefts = [Probe.new(starting_edge[0])]
+      rights = [Probe.new(starting_edge[1])]
+      log.debug "rights was #{rights[0].to_s}" if log.debug?
+      # while there is another node to the left
+      while next_probe = likelies_edge_set[lefts[-1].companion.to_settable].to_a[0]
+        next_probe_probe = Probe.new(next_probe)
+        companion = lefts[-1].companion
+
+        likelies_edge_set.delete next_probe, companion.to_settable
+        if next_probe_probe.companion.to_settable == rights[0].to_settable
+          log.debug "Found multi-contig circularity between #{next_probe_probe.companion} and #{rights[0] }" if log.debug?
+          circular = true
+          break
+        end
+
+        lefts.push companion
+        lefts.push next_probe_probe
+        log.debug "Adding node to the left: #{next_probe} and companion #{companion}" if log.debug?
+      end
+      # and go right
+      while next_probe = likelies_edge_set[rights[-1].companion.to_settable].to_a[0]
+        companion = rights[-1].companion
+        rights.push companion
+        rights.push Probe.new(next_probe)
+        log.debug "Adding node to the right: #{next_probe} and companion #{companion}" if log.debug?
+        likelies_edge_set.delete next_probe, companion.to_settable
+      end
+
+      # Add the left and the right together into one path
+      scaffolded_paths.push(
+        PossiblyCircularArray.new(
+          [lefts[-1].companion]+
+            lefts.reverse+
+            rights+
+            [rights[-1].companion],
+          circular)
+        )
+    end
+    if log.debug?
+      log.debug "Found #{scaffolded_paths.length} multi-contig scaffold(s):"
+      scaffolded_paths.each do |path|
+        log.debug "Scaffold: #{path.collect{|e| e.to_s}.join(', ') }"
+      end
+    end
+
+    # for each scaffolded set, create new scaffold object
+    scaffolds = []
+    scaffolded_contigs = Set.new
+    scaffolded_paths.each do |path|
+      raise if path.length % 2 != 0
+      scaffold = Scaffold.new
+      scaffold.circular = path.circular
+      previous_probe = nil
+      path.each_with_index do |probe, i|
+        if i % 2 == 1
+          previous_probe = probe
+          next
+        end
+        contig = UnscaffoldedContig.new
+        contig.sequence_index = probe.sequence_index
+        if probe.side == :start
+          contig.direction = true
+        else
+          contig.direction = false
+        end
+        scaffold.contigs ||= []
+        unless scaffold.contigs.empty?
+          dummy_conn = Connection.new
+          dummy_conn.probe1 = previous_probe
+          dummy_conn.probe2 = probe
+          original_connection = @connection_hash[dummy_conn.to_settable]
+          scaffold.gap_lengths.push original_connection.distance
+        end
+        scaffold.contigs.push contig
+        scaffolded_contigs << probe.sequence_index
+      end
+      scaffolds.push scaffold
+    end
+
+    # for each contig that is not in a contig, add as singleton
+    @sequence_ids.each do |i|
+      unless scaffolded_contigs.include?(i)
+        scaff = Scaffold.new
+        contig = UnscaffoldedContig.new
+        contig.sequence_index = i
+        contig.direction = true
+        scaff.contigs = [contig]
+        if circular_single_contigs.include?(i)
+          scaff.circular = true
+        else
+          scaff.circular = false
+        end
+        scaffolds.push scaff
+      end
+    end
+
+    return scaffolds
+  end
+
+  # Assuming the sequence_ids given in the initialize
+  # are the same as the sequence_index
+  def unconnected_probes
+    observed_connections = Set.new
+    connections.each do |conn|
+      observed_connections << conn.probe1.to_settable
+      observed_connections << conn.probe2.to_settable
+    end
+    to_return = []
+    @sequence_ids.each do |index|
+      [:start, :end].each do |side|
+        probe = Probe.new
+        probe.sequence_index = index
+        probe.side = side
+        unless observed_connections.include?(probe.to_settable)
+          to_return.push probe
+        end
+      end
+    end
+    return to_return
+  end
+
+  # Return an Array of sequence indices that did not have any connections
+  # to any others.
+  def unconnected_sequences
+    observed_sequences = Set.new
+    connections.each do |conn|
+      observed_sequences << conn.probe1.sequence_index
+      observed_sequences << conn.probe2.sequence_index
+    end
+    return @sequence_ids.to_a - observed_sequences.to_a
+  end
+
+  class Connection
+    # Probe objects
+    attr_accessor :probe1, :probe2
+
+    attr_accessor :distance
+
+    def to_s
+      [@probe1, @probe2].join('/')+":#{@distance}"
+    end
+
+    def to_settable
+      if @probe1.sequence_index < @probe2.sequence_index
+        return [@probe1.to_settable, @probe2.to_settable].flatten
+      elsif @probe1.sequence_index == @probe2.sequence_index
+        if @probe1.side < @probe2.side
+          return [@probe1.to_settable, @probe2.to_settable].flatten
+        else
+          return [@probe2.to_settable, @probe1.to_settable].flatten
+        end
+      else
+        return [@probe2.to_settable, @probe1.to_settable].flatten
+      end
+    end
+  end
+
+  class Probe
+    attr_accessor :side #:start or :end
+    attr_accessor :sequence_index #ID of the underlying sequence as an Integer
+
+    def initialize(settable_representation=nil)
+      unless settable_representation.nil?
+        @sequence_index = settable_representation[0]
+        @side = settable_representation[1]
+      end
+    end
+
+    def to_settable
+      [@sequence_index, @side]
+    end
+
+    def to_s
+      side = @side == :start ? 's' : 'e'
+      "#{@sequence_index}#{side}"
+    end
+
+    # Return a probe representing the other side of the contig
+    def companion
+      companion = Probe.new
+      companion.sequence_index = @sequence_index
+      companion.side = @side == :start ? :end : :start
+      return companion
+    end
+  end
+
+  class Scaffold
+    attr_accessor :contigs, :gap_lengths
+
+    attr_accessor :circular
+    def circular?
+      @circular
+    end
+
+    def initialize
+      @contigs = []
+      @gap_lengths = []
+    end
+
+    def sequence(sequence_id_to_nucleotides_hash)
+      raise "Programming error" unless @contigs.length == @gap_lengths.length + 1
+      parts = []
+
+      add_sequence_of = lambda do |contig|
+        seq = sequence_id_to_nucleotides_hash[contig.sequence_index]
+        if contig.direction == true
+          parts.push seq
+        elsif contig.direction == false
+          parts.push Bio::Sequence::NA.new(seq).reverse_complement.to_s.upcase
+        else
+          raise "Programming error"
+        end
+      end
+
+      add_sequence_of.call @contigs[0]
+
+      @gap_lengths.each_with_index do |gap_length, i|
+        parts.push 'N'*gap_length
+        add_sequence_of.call @contigs[i+1]
+      end
+      return parts.join('')
+    end
+  end
+
+  class UnscaffoldedContig
+    attr_accessor :sequence_index, :direction
+  end
+
+  class PossiblyCircularArray < Array
+    attr_accessor :circular
+
+    def initialize(array, circular)
+      @circular = circular
+      super(array)
+    end
+  end
+end

data/lib/assembly/contig_printer.rb

@@ -0,0 +1,400 @@
+require 'bio'
+
+class Bio::Velvet::Graph::NodedRead
+  def adjusted_position(parent_node)
+    if @direction == true
+      return @offset_from_start_of_node
+    elsif @direction == false
+      return parent_node.length - @offset_from_start_of_node
+    else
+      raise "programming error"
+    end
+  end
+end
+
+module Bio
+  module AssemblyGraphAlgorithms
+    class ContigPrinter
+      include Bio::FinishM::Logging
+
+      class AnchoredConnection
+        # The identifiers of the probe reads in the velvet assembly graph
+        attr_accessor :start_probe_noded_read, :end_probe_noded_read
+
+        # number of nucleotides between the start of the start probe read and the start of the end of the contig
+        attr_accessor :start_probe_contig_offset
+
+        # number of nucleotides until the end of the end probe read in the start of the second contig
+        attr_accessor :end_probe_contig_offset
+
+        # Length of the start and end probe sequences
+        attr_accessor :start_probe_read_length
+        attr_accessor :end_probe_read_length
+
+        # Enumerable of Enumerables of OrientedNode objects, each list of OrientedNode objects
+        # corresponds to a path that forms the connection
+        attr_accessor :paths
+      end
+
+      # Given two contigs, return a consensus path and variants of the path.
+      #
+      #          ---------->         <--------           start and end probes (ends of probe sequences may not form part of final path). Directions not variable.
+      #  --------------------->NNNN------------------->  original sequence to be gapfilled (contig1, NNNN, contig2). Directions not variable
+      #      -----------                 ------->        path across the gap. Direction not variable
+      #                 \               /
+      #                  --------------
+      #      ---------->|<-----|----->|--------->        nodes that make up the path (directions and boundaries variable)
+      #    stage1|           stage2           |stage3    stages of sequence construction in this method
+      # Much like one_connection_between_two_contigs except can handle multiple connections
+      # (but cannot handle 0 connections)
+      def ready_two_contigs_and_connections(graph, contig1, anchored_connection, contig2, sequences)
+        to_return = ''
+        variants = []
+
+        log.debug "Working with anchored_connection: #{anchored_connection.inspect}" if log.debug?
+
+        # Stage1 - contig1 before the path begins
+        to_return = nil
+        if anchored_connection.start_probe_contig_offset == 0
+          # 0 is a special case because negative 0 doesn't make sense
+          to_return = contig1
+        else
+          to_return = contig1[0...-(anchored_connection.start_probe_contig_offset)]
+        end
+        log.debug "After first chunk of sequence added, sequence is #{to_return.length}bp long" if log.debug?
+
+        # Stage2 - path sequence, beginning and ending with
+        # beginning and ending probes
+        begin
+          example_path = anchored_connection.paths[0]
+          path_sequence, variants = sequences_to_variants_conservative(
+            anchored_connection.paths.collect{|path| path.sequence}
+            )
+          log.debug "Reference path has a sequence length #{path_sequence.length}" if log.debug?
+
+          # Find start index
+          begin_onode = example_path[0]
+          begin_noded_read = anchored_connection.start_probe_noded_read
+          raise if begin_noded_read.nil?
+          extra_bit_on_start = ''
+          if begin_noded_read.start_coord != 0
+            log.warn "Unexpectedly the start of the start probe not did not form part of the path, which is a little suspicious"
+            extra_bit_on_start = sequences[begin_noded_read.read_id][0...begin_noded_read.start_coord]
+          end
+          offset_of_begin_probe_on_path = nil
+          # xor read direction on node, and node direction on path
+          if (begin_noded_read.direction == true) ^ begin_onode.starts_at_start?
+            offset_of_begin_probe_on_path = begin_onode.node.corresponding_contig_length - begin_noded_read.offset_from_start_of_node
+            # extra bit on read needs to be reverse complemented
+            extra_bit_on_start = Bio::Sequence::NA.new(extra_bit_on_start).reverse_complement.to_s.upcase unless extra_bit_on_start == ''
+          else
+            offset_of_begin_probe_on_path = begin_noded_read.offset_from_start_of_node
+          end
+
+          # Correct variants' positions to be relative to the full contig,
+          # not just the path sequence
+          variants.each do |variant|
+            variant.position = variant.position - offset_of_begin_probe_on_path + to_return.length + 1
+          end
+
+          # Find end index
+          end_onode = example_path[-1]
+          end_noded_read = anchored_connection.end_probe_noded_read
+          raise if end_noded_read.nil?
+          extra_bit_on_end = ''
+          if end_noded_read.start_coord != 0
+            log.warn "Unexpectedly the end of the end probe not did not form part of the path, which is a little suspicious"
+            extra_bit_on_end = sequences[end_noded_read.read_id][0...end_noded_read.start_coord]
+          end
+          # Potentially the example_path has a different length than the reference sequence in bp.
+          # Correct this ? Or not a bug? confused. I hate this method. TODO. There is a test for this which is unwritten but it fails
+          offset_of_end_node_on_path = example_path[0...-1].reduce(0){|sum, onode| sum += onode.node.length_alone}
+          if (end_noded_read.direction == false) ^ end_onode.starts_at_start?
+            offset_of_end_node_on_path += end_noded_read.offset_from_start_of_node
+            extra_bit_on_end = Bio::Sequence::NA.new(extra_bit_on_end).reverse_complement.to_s.upcase unless extra_bit_on_end == ''
+          else
+            offset_of_end_node_on_path += end_onode.node.corresponding_contig_length - end_noded_read.offset_from_start_of_node
+          end
+
+          log.debug "Found start index #{offset_of_begin_probe_on_path} and end index #{offset_of_end_node_on_path}" if log.debug?
+          to_return += extra_bit_on_start+
+            path_sequence[offset_of_begin_probe_on_path...offset_of_end_node_on_path]+
+            extra_bit_on_end
+          log.debug "After path chunk of sequence added, sequence is #{to_return.length}bp long" if log.debug?
+        end #end stage 2
+
+        # Stage 3
+        to_return += contig2[anchored_connection.end_probe_contig_offset..-1]
+        log.debug "After last chunk of sequence added, sequence is #{to_return.length}bp long" if log.debug?
+
+        return to_return, variants
+      end
+
+      # Like ready_two_contigs_and_connections except assumes that there is only a single
+      # connection between the two sides
+      def one_connection_between_two_contigs(graph, contig1, anchored_connection, contig2, sequences)
+        raise "programming error: only one path expected here" if anchored_connection.paths.length > 1
+        return ready_two_contigs_and_connections(graph, contig1, anchored_connection, contig2, sequences)[0]
+      end
+
+      private
+      # Given an Array of sequences (each representing a path), do a MSA and return as a list of
+      # variants from a sequence that is defintely true. A little hard to define.
+      def sequences_to_variants_conservative(sequences)
+        if sequences.length == 1
+          # No variants here
+          return sequences[0], []
+        end
+
+        # Do alignment
+        # Run multiple sequence alignment of each sequence, with the reference sequence first
+        log.debug "Running MSA with #{sequences.length} sequences.." if log.debug?
+        original_alignments = clustalo(sequences)
+        log.debug "Finished running MSA" if log.debug?
+        if log.debug?
+          log.debug "Alignment found was:"
+          original_alignments.each do |align|
+            log.debug align
+          end
+        end
+
+        # Work out reference path
+        ref = []
+        original_alignments[0].split('').each_index do |i|
+          base_counts = {}
+          original_alignments.each do |aln|
+            base = aln[i]
+            base_counts[base] ||= 0
+            base_counts[base] += 1
+          end
+
+          if base_counts.length == 1
+            # where all paths agree, use that base
+            ref.push base_counts.keys[0]
+          else
+            # otherwise use - or N, depending on how many things have a base at each position.
+            num_gaps = base_counts['-']
+            if num_gaps.nil? or num_gaps < base_counts.values.reduce(:+).to_f / 2
+              ref.push 'N'
+            else
+              ref.push '-'
+            end
+          end
+        end
+
+        # return reference path, and variants
+        reference_sequence = ref.join('')
+        return reference_sequence, alignment_to_variants(reference_sequence, original_alignments)
+      end
+
+      # Given a MSA (as a single reference and an array of alternates),
+      # return a condensed set of variants
+      def alignment_to_variants(reference_alignment, alternate_sequences_alignment)
+        return [] if alternate_sequences_alignment.empty?
+
+        # Collect the variants at each sequence at each column
+        variants = [] #Array of empty arrays
+        reference_position = 0
+        i = 0
+        reference_alignment.each_char do |ref_base|
+          alternate_sequences_alignment.each_with_index do |alignment, sequence_id|
+            nonref = alignment[i]
+            if nonref != ref_base
+              variant = nil
+              if ref_base == '-'
+                variant = Variant.new reference_position, nonref, Variant::INSERT
+              elsif nonref == '-'
+                variant = Variant.new reference_position, 1, Variant::DELETION
+              else
+                variant = Variant.new reference_position, nonref, Variant::SWAP
+              end
+              variants[sequence_id] ||= []
+              variants[sequence_id].push variant
+            end
+          end
+          reference_position += 1 unless ref_base == '-'
+          i += 1
+        end
+
+        # Condense the single column, single species variants into a condensed set
+        return condense_variants!(variants)
+      end
+
+      # Sometimes several paths will contain the same variant. Remove these duplications.
+      def condense_variants!(variant_array_of_arrays)
+        all_variants = {}
+
+        variant_array_of_arrays.each_with_index do |variant_array, i|
+          last_variant = nil
+          current_variants = []
+          variant_array.each do |variant|
+            # Combine last_variant and this one if
+            # their positions are consecutive and their types are the same
+            if !last_variant.nil? and last_variant.type == variant.type
+
+              if variant.type == Variant::INSERT and last_variant.position == variant.position
+                last_variant.sequence += variant.sequence
+
+              elsif variant.type == Variant::DELETION and last_variant.position == variant.position - last_variant.deletion_length
+                last_variant.deletion_length += 1
+
+              elsif variant.type == Variant::SWAP and last_variant.position + last_variant.sequence.length == variant.position
+                last_variant.sequence += variant.sequence
+
+              else
+                # Start a new variant
+                last_variant = variant
+                current_variants.push variant
+              end
+            else
+              last_variant = variant
+              current_variants.push variant
+            end
+          end
+          if log.debug?
+            log.debug "Found #{current_variants.length} variants in sequence #{i}:"
+            current_variants.each do |variant|
+              log.debug variant.to_shorthand
+            end
+          end
+
+          # Multiple paths can have the same variant. Don't duplicate
+          current_variants.each do |variant|
+            key = [
+              variant.position,
+              variant.sequence,
+              variant.deletion_length,
+              variant.type
+              ]
+            all_variants[key] ||= variant
+          end
+        end
+
+        return all_variants.values
+      end
+
+      #       # Given an Enumerable of nucleic acid sequences, align them with MAFFT,
+      #       # and return an Array of the same size as the input
+      #       def mafft(sequences)
+      #         i = 0
+      #         stdin = sequences.collect{|s| i+=1; ">#{i}\n#{s}\n"}.join('')
+      #         stdout = Bio::Commandeer.run "mafft --retree 1 --quiet --nuc /dev/stdin", {:stdin => stdin, :log => log}
+      #         to_return = []
+      #         header = true
+      #         stdout.each_line do |line|
+      #           if !header
+      #             to_return.push line.strip
+      #           end
+      #           header = !header
+      #         end
+      #         return to_return
+      #       end
+
+      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?
+        stdout = Bio::Commandeer.run "clustalo -t DNA -i - --output-order=input-order", {:stdin => stdin, :log => log}
+        to_return = []
+        header = true
+        Bio::FlatFile.foreach(Bio::FastaFormat, StringIO.new(stdout)) do |seq|
+          to_return.push seq.seq.to_s
+        end
+        return to_return
+      end
+
+
+
+
+      class Variant
+        #Types:
+        INSERT = :insert
+        DELETION = :deletion
+        SWAP = :swap #n bases swapped for another n bases
+
+        attr_accessor :reference_name
+
+        # 0-based position on the contig
+        attr_accessor :position
+
+        # sequence (or nil if variant is a deletion)
+        attr_accessor :sequence
+
+        # length of deletion (or nil if not a deletion)
+        attr_accessor :deletion_length
+
+        # See constants in this class
+        attr_accessor :type
+
+        def initialize(position=nil, sequence_or_deletion_length=nil, type=nil)
+          @position = position
+          @type = type
+          if type == DELETION
+            @deletion_length = sequence_or_deletion_length
+          else
+            @sequence = sequence_or_deletion_length
+          end
+        end
+
+        def base_number
+          @position+1
+        end
+
+        def to_shorthand
+          if type == DELETION
+            "#{base_number}D:#{deletion_length}"
+          elsif type == SWAP
+            "#{base_number}S:#{sequence.upcase}"
+          elsif type == INSERT
+            "#{base_number}I:#{sequence.upcase}"
+          else
+            raise
+          end
+        end
+
+        # The reference sequence has been reverse complemented. Fix this
+        # variant so it makes sense again (position aside)
+        def reverse!
+          if type == SWAP or type == INSERT
+            @sequence = Bio::Sequence::NA.new(@sequence).reverse_complement.to_s.upcase
+          end
+        end
+
+        #CHROM POS     ID        REF    ALT     QUAL FILTER INFO
+        def vcf_array(reference_sequence)
+          bits = [
+            @reference_name,
+            @position+1,
+            '.',
+            ]
+          case type
+          when SWAP then
+            bits.push reference_sequence[@position...(@position+@sequence.length) ]
+            bits.push @sequence
+          when INSERT then
+            bits.push '.'
+            bits.push @sequence
+          when DELETION then
+            bits.push reference_sequence[@position...(@position+@deletion_length) ]
+            bits.push '.'
+          else
+            raise
+          end
+
+            bits.push '20'
+            bits.push 'PASS'
+            bits.push 'finishm'
+            return bits
+        end
+
+            def vcf(reference_sequence)
+              vcf_array(reference_sequence).join("\t")
+            end
+      end
+
+      class PrintableConnection
+        attr_accessor :reference_path, :variants
+      end
+    end
+  end
+end