rgfa 1.2.1

data/lib/rgfa/byte_array.rb

@@ -0,0 +1,74 @@
+require_relative "error.rb"
+
+#
+# Array of positive integers <= 255;
+# representation of the data contained in an H field
+#
+class RGFA::ByteArray < Array
+
+  # Validates the byte array content
+  # @raise [RGFA::ByteArray::ValueError] if any value is not a
+  #   positive integer <= 255
+  # @return [void]
+  def validate!
+    each do |x|
+      unless x.kind_of?(Integer) and (0..255).include?(x)
+        raise RGFA::ByteArray::ValueError,
+          "Value incompatible with byte array: #{x.inspect}\n"+
+          "in array: #{self.inspect}"
+      end
+    end
+    self.trust
+    return nil
+  end
+
+  # Returns self
+  # @return [RGFA::ByteArray] self
+  def to_byte_array
+    self
+  end
+
+  # GFA datatype H representation of the byte array
+  # @raise [RGFA::ByteArray::ValueError] if the
+  #   array is not a valid byte array
+  # @return [String]
+  def to_s
+    validate!
+    map do |elem|
+      str = elem.to_s(16).upcase
+      elem < 16 ? "0#{str}" : str
+    end.join
+  end
+
+end
+
+# Exception raised if any value is not a positive integer <= 255
+class RGFA::ByteArray::ValueError < RGFA::Error; end
+
+# Exception raised if string is not a valid representation of byte array
+class RGFA::ByteArray::FormatError < RGFA::Error; end
+
+# Method to create a RGFA::ByteArray from an Array
+class Array
+  # Create a RGFA::ByteArray from an Array instance
+  # @return [RGFA::ByteArray] the byte array
+  def to_byte_array
+    RGFA::ByteArray.new(self)
+  end
+end
+
+# Method to parse the string representation of a RGFA::ByteArray
+class String
+  # Convert a GFA string representation of a byte array to a byte array
+  # @return [RGFA::ByteArray] the byte array
+  # @raise [RGFA::ByteArray::FormatError] if the string size is not > 0
+  #   and even
+  def to_byte_array
+    if (size < 2) or (size % 2 == 1)
+      raise RGFA::ByteArray::FormatError,
+        "Invalid byte array string #{self}; "+
+        "each element must be represented by two letters [0-9A-F]"
+    end
+    scan(/..?/).map {|x|Integer(x,16)}.to_byte_array
+  end
+end

data/lib/rgfa/cigar.rb

@@ -0,0 +1,157 @@
+require_relative "error.rb"
+
+# Array of {RGFA::CIGAR::Operation CIGAR operations}.
+# Represents the contents of a CIGAR string.
+class RGFA::CIGAR < Array
+
+  # Compute the CIGAR for the segments in reverse direction.
+  #
+  # @example Reversing a CIGAR
+  #
+  #   RGFA::CIGAR.from_string("2M1D3M").reverse.to_s
+  #   # => "3M1I2M"
+  #
+  #   # S1 + S2 + 2M1D3M
+  #   #
+  #   # S1+  ACGACTGTGA
+  #   # S2+      CT-TGACGG
+  #   #
+  #   # S2-  CCGTCA-AG
+  #   # S1-     TCACAGTCGT
+  #   #
+  #   # S2 - S1 - 3M1I2M
+  #
+  # @return [RGFA::CIGAR] (empty if CIGAR string is *)
+  def reverse
+    super.map do |op|
+      if op.code == :I
+        op.code = :D
+      elsif op.code == :D
+        op.code = :I
+      end
+      op
+    end
+  end
+
+  # Parse a CIGAR string into an array of CIGAR operations.
+  #
+  # Each operation is represented by a {RGFA::CIGAR::Operation},
+  # i.e. a tuple of operation length and operation
+  # symbol (one of MIDNSHPX=).
+  #
+  # @return [RGFA::CIGAR] (empty if string is *)
+  # @raise [RGFA::CIGAR::ValueError] if the string is not a valid CIGAR string
+  def self.from_string(str)
+    a = RGFA::CIGAR.new
+    if str != "*"
+      raise RGFA::CIGAR::ValueError if str !~ /^([0-9]+[MIDNSHPX=])+$/
+      str.scan(/[0-9]+[MIDNSHPX=]/).each do |op|
+        len = op[0..-2].to_i
+        code = op[-1..-1].to_sym
+        a << RGFA::CIGAR::Operation.new(len, code)
+      end
+    end
+    return a
+  end
+
+  # String representation of the CIGAR
+  # @return [String] CIGAR string
+  def to_s
+    if empty?
+      return "*"
+    else
+      map(&:to_s).join
+    end
+  end
+
+  # Validate the instance
+  # @raise if any component of the CIGAR array is invalid.
+  # @return [void]
+  def validate!
+    any? do |op|
+      op.to_cigar_operation.validate!
+    end
+  end
+
+  # @return [RGFA::CIGAR] self
+  def to_cigar
+    self
+  end
+
+  # Create a copy
+  # @return [RGFA::CIGAR]
+  def clone
+    map{|x|x.clone}
+  end
+
+end
+
+# Exception raised by invalid CIGAR string content
+class RGFA::CIGAR::ValueError < RGFA::Error; end
+
+# An operation in a CIGAR string
+class RGFA::CIGAR::Operation
+  attr_accessor :len
+  attr_accessor :code
+
+  # CIGAR operation code
+  CODE = [:M, :I, :D, :N, :S, :H, :P, :X, :"="]
+
+  # @param len [Integer] length of the operation
+  # @param code [RGFA::CIGAR::Operation::CODE] code of the operation
+  def initialize(len, code)
+    @len = len
+    @code = code
+  end
+
+  # The string representation of the operation
+  # @return [String]
+  def to_s
+    "#{len}#{code}"
+  end
+
+  # Compare two operations
+  # @return [Boolean]
+  def ==(other)
+    other.len == len and other.code == code
+  end
+
+  # Validate the operation
+  # @return [void]
+  # @raise [RGFA::CIGAR::ValueError] if the code is invalid or the length is not
+  #   an integer larger than zero
+  def validate!
+    if Integer(len) <= 0 or
+         !RGFA::CIGAR::Operation::CODE.include?(code)
+      raise RGFA::CIGAR::ValueError
+    end
+  end
+
+  # @return [RGFA::CIGAR::Operation] self
+  def to_cigar_operation
+    self
+  end
+end
+
+class Array
+  # Create a {RGFA::CIGAR} instance from the content of the array.
+  # @return [RGFA::CIGAR]
+  def to_cigar
+    RGFA::CIGAR.new(self)
+  end
+  # Create a {RGFA::CIGAR::Operation} instance from the content of the array.
+  # @return [RGFA::CIGAR::Operation]
+  def to_cigar_operation
+    RGFA::CIGAR::Operation.new(Integer(self[0]), self[1].to_sym)
+  end
+end
+
+class String
+  # Parse CIGAR string and return an array of CIGAR operations
+  # @return [RGFA::CIGAR] CIGAR operations (empty if string is "*")
+  # @raise [RGFA::CIGAR::ValueError] if the string is not a valid CIGAR string
+  def to_cigar
+    RGFA::CIGAR.from_string(self)
+  end
+end
+

data/lib/rgfa/connectivity.rb

@@ -0,0 +1,131 @@
+#
+# Methods which analyse the connectivity of the graph.
+#
+module RGFA::Connectivity
+
+  require "set"
+
+  # Computes the connectivity of a segment from its number of links.
+  #
+  # @param segment [String|RGFA::Line::Segment] segment name or instance
+  #
+  # @return [Array<conn_symbol,conn_symbol>]
+  #  conn. symbols respectively of the :B and :E ends of +segment+.
+  #
+  # <b>Connectivity symbol:</b> (+conn_symbol+)
+  # - Let _n_ be the number of links to an end (+:B+ or +:E+) of a segment.
+  #   Then the connectivity symbol is +:M+ if <i>n > 1</i>, otherwise _n_.
+  #
+  def connectivity(segment)
+    connectivity_symbols(links_of([segment, :B]).size,
+                         links_of([segment, :E]).size)
+  end
+
+  # Does the removal of the link alone divide a component
+  # of the graph into two?
+  # @return [Boolean]
+  # @param link [RGFA::Line::Link] a link
+  def cut_link?(link)
+    return false if link.circular?
+    return true if links_of(link.from_end.invert_end_type).size == 0
+    return true if links_of(link.to_end.invert_end_type).size == 0
+    c = {}
+    [:from, :to].each do |et|
+      c[et] = Set.new
+      visited = Set.new
+      segend = link.send(:"#{et}_end")
+      visited << segend.name
+      visited << link.other_end(segend).name
+      traverse_component(segend, c[et], visited)
+    end
+    return c[:from] != c[:to]
+  end
+
+  # Does the removal of the segment and its links divide a
+  # component of the graph into two?
+  # @param segment [String, RGFA::Line::Segment] a segment name or instance
+  # @return [Boolean]
+  def cut_segment?(segment)
+    segment_name = segment.kind_of?(RGFA::Line) ? segment.name : segment
+    cn = connectivity(segment_name)
+    return false if [[0,0],[0,1],[1,0]].include?(cn)
+    start_points = []
+    [:B, :E].each do |et|
+      start_points += links_of([segment_name, et]).map do |l|
+        l.other_end([segment_name, et]).invert_end_type
+      end
+    end
+    cc = []
+    start_points.uniq.each do |start_point|
+      cc << Set.new
+      visited = Set.new
+      visited << segment_name
+      traverse_component(start_point, cc.last, visited)
+    end
+    return cc.any?{|c|c != cc[0]}
+  end
+
+  # Find the connected component of the graph in which a segment is included
+  # @return [Array<String>]
+  #   array of segment names
+  # @param segment [String, RGFA::Line::Segment] a segment name or instance
+  # @param visited [Set<String>] a set of segments to ignore during graph
+  #   traversal; all segments in the found component will be added to it
+  def segment_connected_component(segment, visited = Set.new)
+    segment_name = segment.kind_of?(RGFA::Line) ? segment.name : segment
+    visited << segment_name
+    c = [segment_name]
+    traverse_component([segment_name, :B], c, visited)
+    traverse_component([segment_name, :E], c, visited)
+    return c
+  end
+
+  # Find the connected components of the graph
+  # @return [Array<Array<String>>]
+  #   array of components, each an array of segment names
+  def connected_components
+    components = []
+    visited = Set.new
+    segment_names.each do |sn|
+      next if visited.include?(sn)
+      components << segment_connected_component(sn, visited)
+    end
+    return components
+  end
+
+  # Split connected components of the graph into single-component RGFAs
+  # @return [Array<RGFA>]
+  def split_connected_components
+    retval = []
+    ccs = connected_components
+    ccs.each do |cc|
+      gfa2 = self.clone
+      gfa2.rm(gfa2.segment_names - cc)
+      retval << gfa2
+    end
+    return retval
+  end
+
+  private
+
+  def traverse_component(segment_end, c, visited)
+    links_of(segment_end).each do |l|
+      oe = l.other_end(segment_end)
+      sn = oe.name
+      next if visited.include?(sn)
+      visited << sn
+      c << sn
+      traverse_component([sn, :B], c, visited)
+      traverse_component([sn, :E], c, visited)
+    end
+  end
+
+  def connectivity_symbols(n,m)
+    [connectivity_symbol(n), connectivity_symbol(m)]
+  end
+
+  def connectivity_symbol(n)
+    n > 1 ? :M : n
+  end
+
+end

data/lib/rgfa/containments.rb

@@ -0,0 +1,97 @@
+require_relative "error"
+
+#
+# Methods for the RGFA class, which allow to handle containments in the graph.
+#
+module RGFA::Containments
+
+  def add_containment(gfa_line)
+    gfa_line = gfa_line.to_rgfa_line(validate: @validate)
+    @containments << gfa_line
+    [:from, :to].each do |dir|
+      segment_name = gfa_line.send(dir)
+      orient = gfa_line.send(:"#{dir}_orient")
+      if !@segments.has_key?(segment_name)
+        raise RGFA::LineMissingError if @segments_first_order
+        @segments[segment_name] =
+          RGFA::Line::Segment.new({:name => segment_name},
+                                  virtual: true)
+      end
+      s = @segments[segment_name]
+      s.containments[dir][orient] << gfa_line
+      gfa_line.send(:"#{dir}=", s)
+    end
+  end
+  protected :add_containment
+
+  # Delete a containment
+  #
+  # @param c [RGFA::Line::Containment] containment instance
+  # @return [RGFA] self
+  def delete_containment(c)
+    @containments.delete(c)
+    segment(c.from).containments[:from][c.from_orient].delete(c)
+    segment(c.to).containments[:to][c.to_orient].delete(c)
+  end
+
+  # All containments in the graph
+  # @return [Array<RGFA::Line::Containment>]
+  def containments
+    @containments
+  end
+
+  # Find containment lines whose +from+ segment name is +segment_name+
+  # @!macro segment_or_name
+  # @return [Array<RGFA::Line::Containment>]
+  def contained_in(s)
+    s = segment!(s)
+    s.containments[:from][:+] + s.containments[:from][:-]
+  end
+
+  # Find containment lines whose +to+ segment name is +segment_name+
+  # @return [Array<RGFA::Line::Containment>]
+  # @!macro segment_or_name
+  def containing(s)
+    s = segment!(s)
+    s.containments[:to][:+] + s.containments[:to][:-]
+  end
+
+  # Searches all containments of +contained+ in +container+.
+  # Returns a possibly empty array of containments.
+  #
+  # @return [Array<RGFA::Line::Containment>]
+  # @!macro [new] container_contained
+  #   @param container [RGFA::Line::Segment, Symbol] a segment instance or name
+  #   @param contained [RGFA::Line::Segment, Symbol] a segment instance or name
+  #
+  def containments_between(container, contained)
+    contained_in(container).select {|l| l.to.to_sym == contained.to_sym }
+  end
+
+  # Searches a containment of +contained+ in +container+.
+  # Returns the first containment found or nil if none found.
+  #
+  # @return [RGFA::Line::Containment, nil]
+  # @!macro container_contained
+  def containment(container, contained)
+    contained_in(container).each do |l|
+      if l.to.to_sym == contained.to_sym
+        return l
+      end
+    end
+    return nil
+  end
+
+  # Searches a containment of +contained+ in +container+.
+  # Raises an exception if no such containment was found.
+  #
+  # @return [RGFA::Line::Containment]
+  # @raise [RGFA::LineMissingError] if no such containment found
+  # @!macro container_contained
+  def containment!(container, contained)
+    c = containment(container, contained)
+    raise RGFA::LineMissingError, "No containment was found" if c.nil?
+    c
+  end
+
+end