rgfa 1.2.1

data/lib/rgfa/rgl.rb

@@ -0,0 +1,194 @@
+begin
+  require "rgl/adjacency"
+  require "rgl/implicit"
+  require_relative "error"
+
+  #
+  # Conversion to RGL graphs
+  #
+  module RGFA::RGL
+
+    # Creates an RGL graph.
+    #
+    # @param oriented [Boolean] (defaults to: <i>+true+</i>) may the graph
+    #   contain links of segments in different orientation?
+    # @return [RGL::ImplicitGraph] an rgl implicit directed graph
+    def to_rgl(oriented: true)
+      if oriented
+        to_rgl_oriented
+      else
+        to_rgl_unoriented
+      end
+    end
+
+    # Creates an RGL graph, including links orientations.
+    #
+    # @return [RGL::ImplicitGraph] an rgl implicit directed graph;
+    #   where vertices are [RGFA::Segment, orientation] pairs
+    #   (instances of the RGFA::OrientedSegment subclass of Array)
+    def to_rgl_oriented
+      RGL::ImplicitGraph.new do |g|
+        g.vertex_iterator do |block|
+          self.each_segment do |segment|
+            [:+, :-].each do |orient|
+              block.call([segment, orient].to_oriented_segment)
+            end
+          end
+        end
+        g.adjacent_iterator do |oriented_segment, block|
+          s = segment(oriented_segment.segment)
+          o = oriented_segment.orient
+          s.links[:from][o].each do |l|
+            os = [segment(l.to), l.to_orient].to_oriented_segment
+            block.call(os)
+          end
+          o = oriented_segment.invert_orient
+          s.links[:to][o].each do |l|
+            os = [segment(l.from), l.from_orient].to_oriented_segment
+            block.call(os.invert_orient)
+          end
+        end
+        g.directed = true
+      end
+    end
+
+    # Creates an RGL graph, assuming that all links orientations
+    # are "+".
+    #
+    # @raise [RGFA::RGL::ValueError] if the graph contains any link where
+    #   from_orient or to_orient is :-
+    # @return [RGL::ImplicitGraph] an rgl implicit directed graph;
+    #   where vertices are RGFA::Segment objects
+    def to_rgl_unoriented
+      RGL::ImplicitGraph.new do |g|
+        g.vertex_iterator {|block| self.each_segment {|s| block.call(s)}}
+        g.adjacent_iterator do |s, bl|
+          s = segment(s)
+          s.links[:from][:+].each do |l|
+            if l.to_orient == :-
+              raise RGFA::RGL::ValueError,
+                "Graph contains links with segments in reverse orientations"
+            end
+            bl.call(segment(l.to))
+          end
+          if s.links[:from][:-].size > 0
+            raise RGFA::RGL::ValueError,
+              "Graph contains links with segments in reverse orientations"
+          end
+        end
+        g.directed = true
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # @param g [RGL::ImplicitGraph, RGL::DirectedAdjacencyGraph] an RGL graph.
+      #
+      # @!macro[new] from_rgl
+      #   <b>Accepted vertex formats</b>:
+      #
+      #   - RGFA::OrientedSegment, or Array which can be converted to it;
+      #     where the first element is a <i>segment specifier</i> (see below)
+      #   - <i>segment specifier</i> alone: the orientation is assumed to be :+
+      #
+      #   The <i>segment specifier</i> can be:
+      #   - RGFA::Segment instance
+      #   - String, segment representation (e.g. "S\tsegment\t*")
+      #   - String, valid segment name (e.g. "segment")
+      #
+      #   @raise [RGFA::RGL::InvalidFormatError] if the graph cannot be
+      #     converted
+      #
+      #   @return [RGFA] a new RGFA instance
+      def from_rgl(g)
+        gfa = RGFA.new
+        if not (g.respond_to?(:each_vertex) and
+                g.respond_to?(:each_edge))
+          raise RGFA::RGL::InvalidFormatError,
+            "#{g} is not a valid RGL graph"
+        end
+        if not g.directed?
+          raise RGFA::RGL::InvalidFormatError,
+            "#{g} is not a directed graph"
+        end
+        g.each_vertex {|v| add_segment_if_new(gfa, v)}
+        g.each_edge do |s, t|
+          gfa << RGFA::Line::Link.new(segment_name_and_orient(s) +
+                                      segment_name_and_orient(t) +
+                                      ["*"])
+        end
+        gfa
+      end
+
+      private
+
+      def add_segment_if_new(gfa, v)
+        # RGFA::OrientedSegment or GFA::GraphVertex
+        v = v.segment if v.respond_to?(:segment)
+        if v.kind_of?(Symbol)
+          # segment name as symbol
+          return if gfa.segment_names.include?(v)
+          v = RGFA::Line::Segment.new([v.to_s, "*"])
+        elsif v.kind_of?(String)
+          a = v.split("\t")
+          if a[0] == "S"
+            # string representation of segment
+            return if gfa.segment_names.include?(a[1].to_sym)
+            v = RGFA::Line::Segment.new(a[1..-1])
+          else
+            # segment name as string
+            return if gfa.segment_names.include?(v.to_sym)
+            v = RGFA::Line::Segment.new([v, "*"])
+          end
+        end
+        return if gfa.segment_names.include?(v.name)
+        gfa << v
+      end
+
+      def segment_name_and_orient(s)
+        # default orientation
+        o = s.respond_to?(:orient) ? s.orient.to_s : "+"
+        # RGFA::Line::Segment (also embedded in RGFA::OrientedSegment)
+        if s.respond_to?(:name)
+          s = s.name.to_s
+        elsif s.respond_to?(:segment)
+          # GFA::GraphVertex
+          s = s.segment.to_s
+        elsif s.respond_to?(:split)
+          a = s.split("\t")
+          s = a[1] if a[0] == "S"
+        else
+          s = s.to_s
+        end
+        return s, o
+      end
+
+    end
+
+  end
+
+  module RGL::Graph
+
+    # @!macro from_rgl
+    def to_rgfa
+      RGFA.from_rgl(self)
+    end
+
+  end
+
+  # Exception raised if conversion is impossible due to unexpected values
+  class RGFA::RGL::ValueError < RGFA::Error; end
+
+  # Exception raised if conversion is impossible due to general format problems
+  class RGFA::RGL::InvalidFormatError < RGFA::Error; end
+
+rescue LoadError
+
+  module RGFA::RGL
+  end
+
+end

data/lib/rgfa/segment_ends_path.rb

@@ -0,0 +1,9 @@
+# An array containing {RGFA::SegmentEnd} elements, which defines a path
+# in the graph
+class RGFA::SegmentEndsPath < Array
+  # Create a reverse direction path
+  # @return [RGFA::SegmentEndsPath]
+  def reverse
+    super.map {|segment_end| segment_end.to_segment_end.invert_end_type}
+  end
+end

data/lib/rgfa/segment_info.rb

@@ -0,0 +1,162 @@
+require_relative "error"
+
+# A segment or segment name plus an additional boolean attribute
+#
+# This class shall not be initialized directly.
+# @api private
+#
+class RGFA::SegmentInfo < Array
+
+  # Check that the elements of the array are compatible with the definition.
+  #
+  # @!macro [new] segment_info_validation_errors
+  #   @raise [RGFA::SegmentInfo::InvalidSizeError] if size is not 2
+  #   @raise [RGFA::SegmentInfo::InvalidAttributeError] if second element
+  #     is not a valid info
+  # @return [void]
+  def validate!
+    if size != 2
+      raise RGFA::SegmentInfo::InvalidSizeError,
+        "Wrong n of elements, 2 expected (#{inspect})"
+    end
+    if !self.class::ATTR.include?(self[1])
+      raise RGFA::SegmentInfo::InvalidAttributeError,
+        "Invalid attribute (#{self[1].inspect})"
+    end
+    return nil
+  end
+
+  # @return [Symbol, RGFA::Line::Segment] the segment instance or name
+  def segment
+    self[0]
+  end
+
+  # Set the segment
+  # @param value [Symbol, RGFA::Line::Segment] the segment instance or name
+  # @return Symbol, RGFA::Line::Segment] +value+
+  def segment=(value)
+    self[0]=value
+  end
+
+  # @return [Symbol] the segment name
+  def name
+    self[0].kind_of?(RGFA::Line::Segment) ? self[0].name : self[0].to_sym
+  end
+
+  # @return [Symbol] the attribute
+  def attribute
+    self[1]
+  end
+
+  # Set the attribute
+  # @param value [Symbol] the attribute
+  # @return [Symbol] +value+
+  def attribute=(value)
+    self[1]=(value)
+  end
+
+  # @return [Symbol] the other possible value of the attribute
+  def attribute_inverted
+    self.class::ATTR[self.class::ATTR[0] == self[1] ? 1 : 0]
+  end
+
+  # @return [RGFA::SegmentInfo] same segment, inverted attribute
+  def invert_attribute
+    self.class.new([self[0], self.attribute_inverted])
+  end
+
+  # @param [Symbol] attribute an attribute value
+  # @return [Symbol] the other attribute value
+  def self.invert(attribute)
+    i = self::ATTR.index(attribute.to_sym)
+    if i.nil?
+      raise RGFA::SegmentInfo::InvalidAttributeError,
+        "Invalid attribute (#{self[1].inspect})"
+    end
+    return self::ATTR[i-1]
+  end
+
+  # @return [String] name of the segment and attribute
+  def to_s
+    "#{name}#{attribute}"
+  end
+
+  # @return [Symbol] name of the segment and attribute
+  def to_sym
+    to_s.to_sym
+  end
+
+  # Compare the segment names and attributes of two instances
+  #
+  # @param [RGFA::SegmentInfo] other the other instance
+  # @return [Boolean]
+  def ==(other)
+    to_s == other.to_segment_info(self.class).to_s
+  end
+
+  # Compare the segment names and attributes of two instances
+  #
+  # @param [RGFA::SegmentInfo] other the other instance
+  # @return [Boolean]
+  def <=>(other)
+    to_s <=> other.to_segment_info(self.class).to_s
+  end
+
+end
+
+# Error raised if the size of the array is wrong
+class RGFA::SegmentInfo::InvalidSizeError < RGFA::Error; end
+
+# Error raised if an unknown value for attribute is used
+class RGFA::SegmentInfo::InvalidAttributeError < RGFA::Error; end
+
+# A representation of a segment end
+class RGFA::SegmentEnd < RGFA::SegmentInfo
+  # Segment end type (begin or end)
+  ATTR = [ END_TYPE_BEGIN = :B, END_TYPE_END = :E ]
+  alias_method :end_type, :attribute
+  alias_method :end_type=, :attribute=
+  alias_method :invert_end_type, :invert_attribute
+  alias_method :end_type_inverted, :attribute_inverted
+end
+
+# A segment plus orientation
+class RGFA::OrientedSegment < RGFA::SegmentInfo
+  # Segment orientation
+  ATTR = [ ORIENT_FWD = :+, ORIENT_REV = :- ]
+  alias_method :orient, :attribute
+  alias_method :orient=, :attribute=
+  alias_method :invert_orient, :invert_attribute
+  alias_method :orient_inverted, :attribute_inverted
+end
+
+class Array
+
+  # Create and validate a segment end from an array
+  # @!macro segment_info_validation_errors
+  # @return [RGFA::SegmentEnd]
+  def to_segment_end
+    to_segment_info(RGFA::SegmentEnd)
+  end
+
+  # Create and validate a segment end from an array
+  # @!macro segment_info_validation_errors
+  # @return [RGFA::OrientedSegment]
+  def to_oriented_segment
+    to_segment_info(RGFA::OrientedSegment)
+  end
+
+  protected
+
+  def to_segment_info(subclass)
+    return self if self.kind_of?(subclass)
+    # support converting from gfa gem GraphVertex objects:
+    if respond_to?(:segment) and respond_to?(:orient)
+      return RGFA::OrientedSegment.new([segment.to_sym, orient.to_sym])
+    end
+    se = subclass.new(map {|e| e.kind_of?(String) ? e.to_sym : e})
+    se.validate!
+    return se
+  end
+
+end

data/lib/rgfa/segments.rb

@@ -0,0 +1,99 @@
+require_relative "error"
+
+#
+# Methods for the RGFA class, which allow to handle segments in the graph.
+#
+module RGFA::Segments
+
+  def add_segment(gfa_line)
+    gfa_line = gfa_line.to_rgfa_line(validate: @validate)
+    segment_name = gfa_line.name
+    if @paths.has_key?(segment_name)
+      raise RGFA::DuplicatedLabelError,
+        "Error when adding line: #{gfa_line}\n"+
+        "a path already exists with the name: #{segment_name}\n"+
+        "Path: #{@paths[segment_name]}"
+    elsif @segments.has_key?(segment_name)
+      if @segments[segment_name].virtual?
+        @segments[segment_name].real!(gfa_line)
+      else
+        raise RGFA::DuplicatedLabelError,
+          "Error when adding line: #{gfa_line}\n"+
+          "a segment already exists with the name: #{segment_name}\n"+
+          "Segment: #{@segments[segment_name]}"
+      end
+    else
+      @segments[segment_name] = gfa_line
+    end
+  end
+  protected :add_segment
+
+  # Delete a segment from the RGFA graph
+  # @return [RGFA] self
+  # @param s [String, RGFA::Line::Segment] segment name or instance
+  def delete_segment(s, cascade=true)
+    s = segment!(s)
+    if cascade
+      connected_segments(s).each {|cs| unconnect_segments(s, cs)}
+      [:+, :-].each do |o|
+        s.paths[o].each {|pt| delete_path(pt)}
+      end
+    end
+    @segments.delete(s.name)
+    return self
+  end
+
+  # All segment lines of the graph
+  # @return [Array<RGFA::Line::Segment>]
+  def segments
+    @segments.values
+  end
+
+  # @!macro [new] segment
+  #   Searches the segment with name equal to +segment_name+.
+  #   @param s [String, RGFA::Line::Segment] a segment or segment name
+  #   @return [RGFA::Line::Segment] if a segment is found
+  # @return [nil] if no such segment exists in the RGFA instance
+  #
+  def segment(s)
+    return s if s.kind_of?(RGFA::Line)
+    @segments[s.to_sym]
+  end
+
+  # @!macro segment
+  # @raise [RGFA::LineMissingError] if no such segment exists
+  def segment!(s)
+    seg = segment(s)
+    if seg.nil?
+      raise RGFA::LineMissingError, "No segment has name #{s}"+
+             "#{segment_names.size < 10 ?
+               "\nSegment names: "+segment_names.inspect : ''}"
+    end
+    seg
+  end
+
+  # @return [Array<String>] list of names of segments connected to +segment+
+  #   by links or containments
+  def connected_segments(segment)
+    (neighbours([segment, :B]).map{|s, e| s} +
+      neighbours([segment, :E]).map{|s, e| s} +
+        contained_in(segment).map{|c| c.to} +
+          containing(segment).map{|c| c.from}).uniq
+  end
+
+  # Delete all links/containments involving two segments
+  # @return [RGFA] self
+  # @param segment1 [String, RGFA::Line::Segment] segment 1 name or instance
+  # @param segment2 [String, RGFA::Line::Segment] segment 2 name or instance
+  def unconnect_segments(segment1, segment2)
+    containments_between(segment1, segment2).each {|c| delete_containment(c)}
+    containments_between(segment2, segment1).each {|c| delete_containment(c)}
+    [[:B, :E], [:B, :B], [:E, :B], [:E, :E]].each do |end1, end2|
+      links_between([segment1, end1], [segment2, end2]).each do |l|
+        delete_link(l)
+      end
+    end
+    return self
+  end
+
+end