rgfa 1.2.1 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2f8b7edb6df7ada4a6f53db674a3b306e00e2861
-  data.tar.gz: 87d224980a807f6b8e98917b845d48a12ec11e4b
+  metadata.gz: 492cbcdfb283859725e35bc0586bbdebe1db4efb
+  data.tar.gz: 1a23616c8b8c3f00384fac70c2d147cfa84ba6d7
 SHA512:
-  metadata.gz: c38a9ef751a5220dd59991a4b0788d8860d66ead6880c03de53ab047970cb3ad4719b23c4dd1b7b1d262dfe29cc84b82e105d10e938e83231ad3969efdf86edd
-  data.tar.gz: b87e1dcd4f7ddccb77bdb03edad2a52ae23e8b5c9f22629f4aa57206c75306b7e7f813e5154c76245de14113d532e983795957721bd0ecce9d772a7e95ee6259
+  metadata.gz: f4498bd2b97520366f5bfa537cce2874ec0ccceb72ee3222fcddcdda1de4899ffd14397ae0ac2a9a0ac9b2bb3df9951519f3c57e8e8e183f01c9a09e9216749f
+  data.tar.gz: c955e4647ecc1b250f62bf2f1d5246a48fcd097b6cf0d6ce76426971701643143e7a7dd78ba2ecf4f303132b939596433632493cd4dbbb32032c831b7010a113

data/lib/rgfa/cigar.rb

@@ -4,11 +4,11 @@ require_relative "error.rb"
 # Represents the contents of a CIGAR string.
 class RGFA::CIGAR < Array
 
-  # Compute the CIGAR for the segments in reverse direction.
+  # Compute the CIGAR for the segments when these are switched.
   #
-  # @example Reversing a CIGAR
+  # @example Computing the complement CIGAR
   #
-  #   RGFA::CIGAR.from_string("2M1D3M").reverse.to_s
+  #   RGFA::CIGAR.from_string("2M1D3M").complement.to_s
   #   # => "3M1I2M"
   #
   #   # S1 + S2 + 2M1D3M
@@ -22,8 +22,8 @@ class RGFA::CIGAR < Array
   #   # S2 - S1 - 3M1I2M
   #
   # @return [RGFA::CIGAR] (empty if CIGAR string is *)
-  def reverse
-    super.map do |op|
+  def complement
+    reverse.map do |op|
       if op.code == :I
         op.code = :D
       elsif op.code == :D

data/lib/rgfa/field_parser.rb

@@ -19,11 +19,17 @@ module RGFA::FieldParser
                       fieldname: nil,
                       frozen: false)
     case datatype
+    when :cmt
+      return self
     when :A, :Z, :seq
       validate_gfa_field!(datatype, fieldname: fieldname) if validate_strings
       self.freeze if frozen
       return self
-    when :lbl, :orn
+    when :lbl
+      validate_segment_name!
+      validate_gfa_field!(datatype, fieldname: fieldname) if validate_strings
+      return to_sym.freeze
+    when :orn
       validate_gfa_field!(datatype, fieldname: fieldname) if validate_strings
       return to_sym.freeze
     when :i

data/lib/rgfa/field_validator.rb

@@ -27,6 +27,7 @@ module RGFA::FieldValidator
     :cig => /^(\*|(([0-9]+[MIDNSHPX=])+))$/, # CIGAR string
     :cgs => /^(\*|(([0-9]+[MIDNSHPX=])+))(,(\*|(([0-9]+[MIDNSHPX=])+)))*$/,
                                        # multiple CIGARs, comma-sep
+    :cmt => /.*/, # content of comment line, everything is allowed
   }
 
   # Validates the string according to the provided datatype
@@ -49,6 +50,19 @@ module RGFA::FieldValidator
     end
   end
 
+  # Validates segment names, to check that they do not contain + or -
+  # followed by comma
+  # @raise [RGFA::FieldParser::FormatError] if the segment name is invalid
+  # @return [void]
+  # @api private
+  def validate_segment_name!
+    if self =~ /.*[+-],.*/
+      raise RGFA::FieldParser::FormatError,
+      "Segment names are not allowed to contain +/- followed by comma "+
+      "(found: #{self})"
+    end
+  end
+
 end
 
 class String

data/lib/rgfa/line.rb

@@ -126,6 +126,7 @@ class RGFA::Line
     when :L then RGFA::Line::Link
     when :C then RGFA::Line::Containment
     when :P then RGFA::Line::Path
+    when :"#" then RGFA::Line::Comment
     else
       raise RGFA::Line::UnknownRecordTypeError,
         "Record type unknown: '#{record_type}'"
@@ -684,6 +685,7 @@ require_relative "line/segment.rb"
 require_relative "line/path.rb"
 require_relative "line/link.rb"
 require_relative "line/containment.rb"
+require_relative "line/comment.rb"
 
 # Extensions to the String core class.
 #
@@ -696,7 +698,11 @@ class String
   # @param validate [Integer] <i>(defaults to: 2)</i>
   #   see RGFA::Line#initialize
   def to_rgfa_line(validate: 2)
-    split(RGFA::Line::SEPARATOR).to_rgfa_line(validate: validate)
+    if self[0] == "#"
+      return RGFA::Line::Comment.new([self[1..-1]], validate: 0)
+    else
+      split(RGFA::Line::SEPARATOR).to_rgfa_line(validate: validate)
+    end
   end
 
 end

data/lib/rgfa/line/comment.rb

@@ -0,0 +1,13 @@
+# A comment line of a RGFA file
+class RGFA::Line::Comment < RGFA::Line
+
+  RECORD_TYPE = :"#"
+  REQFIELDS = [:content]
+  PREDEFINED_OPTFIELDS = []
+  DATATYPE = {
+    :content => :cmt,
+  }
+
+  define_field_methods!
+
+end

data/lib/rgfa/line/containment.rb

@@ -56,11 +56,15 @@ class RGFA::Line::Containment < RGFA::Line
     return rpos
   end
 
-  # Returns true if the containment is normal, false otherwise
+  # Returns true if the containment is canonical, false otherwise
   #
-  # <b> Definition of normal containment </b>
+  # == Definition of canonical containment
   #
-  # Each containment has an equivalent reverse containment.
+  # A containment is canonical if the from orientation is +
+  #
+  # === Details
+  #
+  # Each containment has an equivalent complement containment.
   # Consider a containment of B (length:8) in A (length:100) at position 9 of A
   # with a cigar 1M1I2M3D4M (i.e. rpos = 19).
   #
@@ -69,18 +73,18 @@ class RGFA::Line::Containment < RGFA::Line
   #   A- B+ 1M1I2M3D4M 9 == A+ B- 4M3D2M1I1M 80
   #   A- B- 1M1I2M3D4M 9 == A+ B+ 4M3D2M1I1M 80
   #
-  # Pos in the reverse is equal to the length of A minus the right pos
+  # Pos in the complement is equal to the length of A minus the right pos
   # of B before reversing.
   #
   # We require here that A != B as A == B makes no sense for containments.
   # Thus it is always possible to express the containment using a positive
   # from orientation.
   #
-  # For this reason the normality is simply defined as + from orientation.
+  # For this reason the canon is simply defined as + from orientation.
   #
   # @return [Boolean]
   #
-  def normal?
+  def canonical?
     from_orient == :+
   end
 

data/lib/rgfa/line/link.rb

@@ -112,108 +112,99 @@ class RGFA::Line::Link < RGFA::Line
     to.to_sym
   end
 
-  # Returns true if the link is normal, false otherwise
+  # Returns true if the link is canonical, false otherwise
   #
-  # == Definition of normal link
+  # == Definition of canonical link
   #
-  # Each link has an equivalent reverse link. Consider a link of A to B
-  # with a overlap 1M1I2M:
+  # A link if canonical if:
+  # - from != to and from < to (lexicographically); or
+  # - from == to and at least one of from_orient or to_orient is +
   #
-  #   from+ to to+ (1M1I2M) == to- to from- (2M1D1M)
-  #   from- to to- (1M1I2M) == to+ to from+ (2M1D1M)
-  #   from+ to to- (1M1I2M) == to+ to from- (2M1D1M)
-  #   from- to to+ (1M1I2M) == to- to from+ (2M1D1M)
+  # === Details
   #
-  # Consider also the special case, where from == to and the overlap is not
-  # specified, or equal to its reverse:
+  # In the special case in which from == to (== s) we have the
+  # following equivalences:
   #
-  #   from+ to from+ (*) == from- to from- (*) # left has a +; right has no +
-  #   from- to from- (*) == from+ to from+ (*) # left has no +; right has a +
-  #   from+ to from- (*) == from+ to from- (*) # left == right
-  #   from- to from+ (*) == from- to from+ (*) # left == right
+  #   s + s + == s - s -
+  #   s - s - == s + s + (same as previous case)
+  #   s + s - == s + s - (equivalent to itself)
+  #   s - s + == s - s + (equivalent to itself)
   #
-  # Thus we define a link as normal if:
-  # - from < to (lexicographical comparison of segments)
-  # - from == to and overlap.to_s < reverse_overlap.to_s
-  # - from == to, overlap == reverse_overlap and at least one orientation is +
+  # Considering the values on the left, the first one can be taken as
+  # canonical, the second not, because it can be transformed in the first
+  # one; the other two values are canonical, as they are only equivalent
+  # to themselves.
   #
   # @return [Boolean]
   #
-  def normal?
+  def canonical?
     if from_name < to_name
       return true
     elsif from_name > to_name
       return false
     else
-      overlap_s = overlap.to_s
-      reverse_overlap_s = reverse_overlap.to_s
-      if overlap_s < reverse_overlap_s
-        return true
-      elsif overlap_s > reverse_overlap_s
-        return false
-      else
-        return [from_orient, to_orient].include?(:+)
-      end
+      return [from_orient, to_orient].include?(:+)
     end
   end
 
-  # Returns the unchanged link if the link is normal,
-  # otherwise reverses the link and returns it.
+  # Returns the unchanged link if the link is canonical,
+  # otherwise complements the link and returns it.
   #
   # @note The path references are not corrected by this method; therefore
   #   the method shall be used before the link is embedded in a graph.
   #
   # @return [RGFA::Line::Link] self
-  def normalize!
-    reverse! if !normal?
+  def canonicize!
+    complement! if !canonical?
   end
 
-  # Creates a link with both strands of the sequences inverted.
+  # Creates the equivalent link with from/to inverted.
+  #
   # The CIGAR operations (order/type) are inverted as well.
   # Optional fields are left unchanged.
   #
-  # @note The path references are not copied to the reverse link.
+  # @note The path references are not copied to the complement link.
   #
   # @note This method shall be overridden if custom optional fields
-  #   are defined, which have a ``reverse'' operation which determines
-  #   their value in the equivalent but reverse link.
+  #   are defined, which have a ``complementation'' operation which determines
+  #   their value in the equivalent complement link.
   #
   # @return [RGFA::Line::Link] the inverted link.
-  def reverse
+  def complement
     l = self.clone
     l.from = to
     l.from_orient = (to_orient == :+ ? :- : :+)
     l.to = from
     l.to_orient = (from_orient == :+ ? :- : :+)
-    l.overlap = reverse_overlap
+    l.overlap = complement_overlap
     l
   end
 
-  # Reverses the link inplace, i.e. sets:
+  # Complements the link inplace, i.e. sets:
   #   from = to
   #   from_orient = other_orient(to_orient)
   #   to = from
   #   to_orient = other_orient(from_orient)
-  #   overlap = reverse_overlap.
+  #   overlap = complement_overlap.
   #
   # The optional fields are left unchanged.
   #
-  # @note The path references are not reversed by this method; therefore
+  # @note The path references are not complemented by this method; therefore
   #   the method shall be used before the link is embedded in a graph.
   #
   # @note This method shall be overridden if custom optional fields
-  #   are defined, which have a ``reverse'' operation which determines
-  #   their value in the equivalent but reverse link.
+  #   are defined, which have a ``complementation'' operation which determines
+  #   their value in the complement link.
   #
   # @return [RGFA::Line::Link] self
-  def reverse!
+  def complement!
     tmp = self.from
     self.from = self.to
     self.to = tmp
     tmp = self.from_orient
     self.from_orient = (self.to_orient == :+) ? :- : :+
     self.to_orient = (tmp == :+) ? :- : :+
-    self.overlap = self.reverse_overlap
+    self.overlap = self.complement_overlap
     return self
   end
 
@@ -224,7 +215,7 @@ class RGFA::Line::Link < RGFA::Line
   #
   # Otherwise, an array of tuples path/boolean is returned.
   # The boolean value tells
-  # if the link is used in direct (true) or reverse direction (false)
+  # if the link is used (true) or its complement (false)
   # in the path.
   # @return [Array<Array<(RGFA::Line::Path, Boolean)>>]
   def paths
@@ -235,8 +226,8 @@ class RGFA::Line::Link < RGFA::Line
   # Compute the overlap when the strand of both sequences is inverted.
   #
   # @return [RGFA::CIGAR]
-  def reverse_overlap
-    self.overlap.reverse
+  def complement_overlap
+    self.overlap.to_cigar.complement
   end
 
   #
@@ -244,23 +235,23 @@ class RGFA::Line::Link < RGFA::Line
   # Thereby, optional fields are not considered.
   #
   # @note Inverting the strand of both links and reversing
-  #   the CIGAR operations (order/type), one obtains a
-  #   reverse but equivalent link.
+  #   the CIGAR operations (order/type), one obtains an
+  #   equivalent complement link.
   #
   # @param other [RGFA::Line::Link] a link
   # @return [Boolean] are self and other equivalent?
   # @see #==
   # @see #same?
-  # @see #reverse?
+  # @see #complement?
   def eql?(other)
-    same?(other) or reverse?(other)
+    same?(other) or complement?(other)
   end
 
   # Compares the optional fields of two links.
   #
   # @note This method shall be overridden if custom optional fields
-  #   are defined, which have a ``reverse'' operation which determines
-  #   their value in the equivalent but reverse link.
+  #   are defined, which have a ``complementation'' operation which determines
+  #   their value in the equivalent but complement link.
   #
   # @param other [RGFA::Line::Link] a link
   # @return [Boolean] are self and other equivalent?
@@ -291,7 +282,7 @@ class RGFA::Line::Link < RGFA::Line
   # @param other [RGFA::Line::Link] a link
   # @return [Boolean] are self and other equivalent?
   # @see #eql?
-  # @see #reverse?
+  # @see #complement?
   # @see #==
   def same?(other)
     (from_end == other.from_end and
@@ -299,37 +290,37 @@ class RGFA::Line::Link < RGFA::Line
       overlap == other.overlap)
   end
 
-  # Compares the reverse of the link to another link
+  # Compares the link to the complement of another link
   # and determine their equivalence.
   # Thereby, optional fields are not considered.
   #
   # @param other [RGFA::Line::Link] the other link
-  # @return [Boolean] are the reverse of self and other equivalent?
+  # @return [Boolean] are self and the complement of other equivalent?
   # @see #eql?
   # @see #same?
   # @see #==
-  def reverse?(other)
+  def complement?(other)
     (from_end == other.to_end and
       to_end == other.from_end and
-      overlap == other.reverse_overlap)
+      overlap == other.complement_overlap)
   end
 
   # Computes an hash for including a link in an Hash tables,
-  # so that the hash of a link and its reverse is the same.
+  # so that the hash of a link and its complement is the same.
   # Thereby, optional fields are not considered.
   # @see #eql?
   def hash
-    from_end.hash + to_end.hash + overlap.hash + reverse_overlap.to_s.hash
+    from_end.hash + to_end.hash + overlap.hash + complement_overlap.to_s.hash
   end
 
-  # Compares a link and optionally the reverse link,
+  # Compares a link and optionally the complement link,
   # with two oriented_segments and optionally an overlap.
   # @param [RGFA::OrientedSegment] other_oriented_from
   # @param [RGFA::OrientedSegment] other_oriented_to
-  # @param equivalent [Boolean] shall the reverse link also be considered?
+  # @param equivalent [Boolean] shall the complement link also be considered?
   # @param [RGFA::CIGAR] other_overlap compared only if not empty
   # @return [Boolean] does the link or, if +equivalent+,
-  #   the reverse link go from the first
+  #   the complement link go from the first
   #   oriented segment to the second with an overlap equal to the provided one
   #   (if not empty)?
   def compatible?(other_oriented_from, other_oriented_to, other_overlap = [],
@@ -340,7 +331,7 @@ class RGFA::Line::Link < RGFA::Line
     if is_direct
       return true
     elsif equivalent
-      return compatible_reverse?(other_oriented_from, other_oriented_to,
+      return compatible_complement?(other_oriented_from, other_oriented_to,
                           other_overlap)
     else
       return false
@@ -361,15 +352,15 @@ class RGFA::Line::Link < RGFA::Line
      (overlap.empty? or other_overlap.empty? or (overlap == other_overlap))
   end
 
-  # Compares the reverse link with two oriented segments and optionally an
+  # Compares the complement link with two oriented segments and optionally an
   # overlap.
   # @param [RGFA::OrientedSegment] other_oriented_from
   # @param [RGFA::OrientedSegment] other_oriented_to
   # @param [RGFA::CIGAR] other_overlap compared only if not empty
-  # @return [Boolean] does the reverse link go from the first
+  # @return [Boolean] does the complement link go from the first
   #   oriented segment to the second with an overlap equal to the provided one
   #   (if not empty)?
-  def compatible_reverse?(other_oriented_from, other_oriented_to,
+  def compatible_complement?(other_oriented_from, other_oriented_to,
                           other_overlap = [])
     (oriented_to == other_oriented_from.invert_orient and
      oriented_from == other_oriented_to.invert_orient) and

data/lib/rgfa/line/path.rb

@@ -2,12 +2,12 @@
 class RGFA::Line::Path < RGFA::Line
 
   RECORD_TYPE = :P
-  REQFIELDS = [:path_name, :segment_names, :cigars]
+  REQFIELDS = [:path_name, :segment_names, :overlaps]
   PREDEFINED_OPTFIELDS = []
   DATATYPE = {
     :path_name => :lbl,
     :segment_names => :lbs,
-    :cigars => :cgs,
+    :overlaps => :cgs,
   }
 
   define_field_methods!
@@ -30,7 +30,7 @@ class RGFA::Line::Path < RGFA::Line
   # equal to the number of segments.
   # @return [Boolean]
   def circular?
-    self.cigars.size == self.segment_names.size
+    self.overlaps.size == self.segment_names.size
   end
 
   # Is the path linear? This is the case when the number of CIGARs
@@ -40,11 +40,11 @@ class RGFA::Line::Path < RGFA::Line
     !circular?
   end
 
-  # Are the cigars a single "*"? This is a compact representation of
+  # Are the overlaps a single "*"? This is a compact representation of
   # a linear path where all CIGARs are "*"
   # @return [Boolean]
-  def undef_cigars?
-    self.cigars.size == 1 and self.cigars[0].empty?
+  def undef_overlaps?
+    self.overlaps.size == 1 and self.overlaps[0].empty?
   end
 
   # The links to which the path refers; it can be an empty array
@@ -62,14 +62,14 @@ class RGFA::Line::Path < RGFA::Line
   #   an array, which elements are 3-tuples (from oriented segment,
   #   to oriented segment, cigar)
   def required_links
-    has_undef_cigars = self.undef_cigars?
+    has_undef_overlaps = self.undef_overlaps?
     retval = []
     self.segment_names.size.times do |i|
       j = i+1
       if j == self.segment_names.size
         circular? ? j = 0 : break
       end
-      cigar = has_undef_cigars ? [] : self.cigars[i]
+      cigar = has_undef_overlaps ? [] : self.overlaps[i]
       retval << [self.segment_names[i], self.segment_names[j], cigar]
     end
     retval
@@ -78,20 +78,20 @@ class RGFA::Line::Path < RGFA::Line
   private
 
   def validate_lists_size!
-    n_cigars = self.cigars.size
+    n_overlaps = self.overlaps.size
     n_segments = self.segment_names.size
-    if n_cigars == n_segments - 1
+    if n_overlaps == n_segments - 1
       # case 1: linear path
       return true
-    elsif n_cigars == 1 and self.cigars[0].empty?
-      # case 2: linear path, single "*" to represent cigars which are all "*"
+    elsif n_overlaps == 1 and self.overlaps[0].empty?
+      # case 2: linear path, single "*" to represent overlaps which are all "*"
       return true
-    elsif n_cigars == n_segments
+    elsif n_overlaps == n_segments
       # case 3: circular path
     else
       raise RGFA::Line::Path::ListLengthsError,
         "Path has #{n_segments} oriented segments, "+
-        "but #{n_cigars} CIGARs"
+        "but #{n_overlaps} overlaps"
     end
   end
 
@@ -102,5 +102,5 @@ class RGFA::Line::Path < RGFA::Line
 
 end
 
-# Error raised if number of segments and cigars are not consistent
+# Error raised if number of segments and overlaps are not consistent
 class RGFA::Line::Path::ListLengthsError < RGFA::Error; end

data/lib/rgfa/lines.rb

@@ -28,6 +28,9 @@ module RGFA::Lines
       add_containment(gfa_line)
     when :P
       add_path(gfa_line)
+    when :"#"
+      # do nothing, as the spec says these shall be ignored
+      # maybe we want to store them and output them again in a future version
     else
       raise # this never happens, as already catched by gfa_line init
     end

data/lib/rgfa/links.rb

@@ -7,7 +7,7 @@ module RGFA::Links
 
   def add_link(gfa_line)
     gfa_line = gfa_line.to_rgfa_line(validate: @validate)
-    gfa_line.normalize!
+    gfa_line.canonicize!
     l = nil
     if segment(gfa_line.from) and segment(gfa_line.to)
       l = link_from_to(gfa_line.oriented_from,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgfa
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.1
 platform: ruby
 authors:
 - Giorgio Gonnella
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-21 00:00:00.000000000 Z
+date: 2016-09-26 00:00:00.000000000 Z
 dependencies: []
 description: |2
       The Graphical Fragment Assembly (GFA) is a proposed format which allow
@@ -39,6 +39,7 @@ files:
 - lib/rgfa/field_parser.rb
 - lib/rgfa/field_validator.rb
 - lib/rgfa/headers.rb
+- lib/rgfa/line/comment.rb
 - lib/rgfa/line/containment.rb
 - lib/rgfa/line/header.rb
 - lib/rgfa/line/link.rb
@@ -65,10 +66,10 @@ files:
 - lib/rgfatools/superfluous_links.rb
 - lib/rgfatools/linear_paths.rb
 - lib/rgfatools/p_bubbles.rb
-- bin/gfadiff.rb
-- bin/rgfa-mergelinear.rb
-- bin/rgfa-simdebruijn.rb
-- bin/rgfa-findcrisprs.rb
+- bin/gfadiff
+- bin/rgfa-mergelinear
+- bin/rgfa-simdebruijn
+- bin/rgfa-findcrisprs
 homepage: http://github.com/ggonnella/rgfa
 licenses:
 - CC-BY-SA