gfa 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cde4a3e432409c7a2967832dcebd502ddc54b1f6cb25856b6d9d21ce53f67b32
-  data.tar.gz: 91213d63365dd3608c28e30115cbfc8621e78bbe34936832bcee2ac7e6f460fb
+  metadata.gz: 0e8e61ff97b34654b7a660b011826ad5549f66933a91a09658facf58c3fd56b1
+  data.tar.gz: 8f85f07955e71cd38a9dfa28011c70433473ad6a1137ed3e6e217d63eeba20a8
 SHA512:
-  metadata.gz: 321634c28ec8927bd38286a84a02783b9f915dcbabb7941233583dda7f41b66e952ff9611c9158bd7baca09d7d3d6c254a036f1c9f2169e5e24e6e964d292e71
-  data.tar.gz: 3698d16ab5953ffd70bf2c102d154bc1f61e5a13a752bc317a756df13762c3668c1bf6e8144821e53e395783f36c45185249c7fc206694be19145200310c3f48
+  metadata.gz: 5b9f8fd92cd30d9e4e5c0263e938169141749c7be43011b574f937c9645608d8e72189bfe9072d7321e3acdf7e8288cecf42c90abe3ceef2bf001780bdb3e472
+  data.tar.gz: ee33c0b9c0dc9adb2df96d95b792b060b248e2f991ed5a0e4b4c136d66f04b9be6cf5ca58462bce046c6cfd9e7fed6c4c6949cb5e8923eb71e3d5f53f0da2703

data/README.md

@@ -58,12 +58,12 @@ Any `GFA` object can be exported as an [`RGL`][rgl] graph using the methods
 [tiny.gfa](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.gfa):
 
 ```ruby
-require "gfa"
-require "rgl/dot"
+require 'gfa'
+require 'rgl/dot'
 
-my_gfa = GFA.load("data/tiny.gfa")
+my_gfa = GFA.load('data/tiny.gfa')
 dg = my_gfa.implicit_graph
-dg.write_to_graphic_file("jpg")
+dg.write_to_graphic_file('jpg')
 ```
 
 ![tiny_dg](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.jpg)
@@ -72,8 +72,8 @@ If you don't care about orientation, you can also build an undirected graph
 without orientation:
 
 ```ruby
-ug = my_gfa.implicit_graph(orient:false)
-ug.write_to_graphic_file("jpg")
+ug = my_gfa.implicit_graph(orient: false)
+ug.write_to_graphic_file('jpg')
 ```
 
 ![tiny_ug](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny_undirected.jpg)
@@ -88,7 +88,7 @@ gem install gfa
 Or add the following line to your Gemfile:
 
 ```ruby
-gem "gfa"
+gem 'gfa'
 ```
 
 and run `bundle install` from your shell.

data/lib/gfa/common.rb

@@ -1,17 +1,17 @@
 require 'gfa/version'
-require 'gfa/record'
+require 'gfa/record_set'
 require 'gfa/field'
 
 class GFA
   # Class-level
   def self.assert_format(value, regex, message)
-    unless value =~ regex
-      raise "#{message}: #{value}."
+    unless value =~ /^(?:#{regex})$/
+      raise "#{message}: #{value}"
     end
   end
 
   # Instance-level
-  attr :gfa_version, :records
+  attr :gfa_version, :records, :opts
 
   GFA::Record.TYPES.each do |r_type|
     plural = "#{r_type.downcase}s"
@@ -22,9 +22,12 @@ class GFA
     define_method("add_#{singular}") { |v| @records[r_type] << v }
   end
 
-  def initialize
+  def initialize(opts = {})
     @records = {}
-    GFA::Record.TYPES.each { |t| @records[t] = [] }
+    @opts = { index: true, comments: false }.merge(opts)
+    GFA::Record.TYPES.each do |t|
+      @records[t] = GFA::RecordSet.name_class(t).new(self)
+    end
   end
 
   def empty?

data/lib/gfa/field/char.rb

@@ -1,6 +1,7 @@
 class GFA::Field::Char < GFA::Field
   CODE = :A
-  REGEX = /^[!-~]$/
+  REGEX = /[!-~]/
+  NATIVE_FUN = :to_s
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")

data/lib/gfa/field/float.rb

@@ -1,9 +1,26 @@
 class GFA::Field::Float < GFA::Field
   CODE = :f
-  REGEX = /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/
+  REGEX = /[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/
+  NATIVE_FUN = :to_f
+
+  def to_f
+    value
+  end
+
+  def to_i
+    value.to_i
+  end
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_f
   end
+
+  def equivalent?(field)
+    if field.is_a?(GFA::Field::NumArray)
+      return field.size == 1 && field.first.to_f == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/hex.rb

@@ -1,9 +1,26 @@
 class GFA::Field::Hex < GFA::Field
   CODE = :H
-  REGEX = /^[0-9A-F]+$/
+  REGEX = /[0-9A-F]+/
+  NATIVE_FUN = :to_i
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
+
+  def to_i
+    value.to_i(16)
+  end
+
+  def to_f
+    to_i.to_f
+  end
+
+  def equivalent?(field)
+    if field.is_a? GFA::Field::NumArray
+      return field.size == 1 && field.first.to_i == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/json.rb

@@ -1,9 +1,18 @@
 class GFA::Field::Json < GFA::Field
   CODE = :J
-  REGEX = /^[ !-~]+$/
+  REGEX = /[ !-~]+/
+  NATIVE_FUN = :to_s
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
+
+  def equivalent?(field)
+    # TODO
+    # We should parse the contents when comparing two GFA::Field::Json to
+    # evaluate equivalencies such as 'J:{ "a" : 1 }' ~ 'J:{"a":1}' (spaces)
+    # or 'J:{"a":1,"b":2}' ~ 'J:{"b":2,"a":1}' (element order)
+    super
+  end
 end

data/lib/gfa/field/numarray.rb

@@ -1,17 +1,30 @@
 class GFA::Field::NumArray < GFA::Field
   CODE = :B
-  REGEX = /^[cCsSiIf](,[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+$/
+  REGEX = /[cCsSiIf](,[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+/
+  NATIVE_FUN = :to_a
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
 
-  def modifier ; value[0] ; end
+  def modifier
+    value[0]
+  end
 
-  def array ; value[2..-1].split(/,/) ; end
+  def modifier_fun
+    modifier == 'f' ? :to_f : :to_i
+  end
 
-  alias as_a array
+  def array
+    @array ||= value[2..-1].split(',').map(&modifier_fun)
+  end
+
+  alias to_a array
+
+  %i[empty? size count length first last].each do |i|
+    define_method(i) { array.send(i) }
+  end
 
   def number_type
     {
@@ -21,4 +34,16 @@ class GFA::Field::NumArray < GFA::Field
       f: 'float'
     }[modifier.to_sym]
   end
+
+  def equivalent?(field)
+    return true if eql?(field)
+
+    if field.respond_to?(:to_a)
+      field.to_a.map(&modifier_fun) == array
+    elsif size == 1 && field.respond_to?(modifier_fun)
+      field.send(modifier_fun) == first
+    else
+      false
+    end
+  end
 end

data/lib/gfa/field/sigint.rb

@@ -1,9 +1,22 @@
 class GFA::Field::SigInt < GFA::Field
   CODE = :i
-  REGEX = /^[-+]?[0-9]+$/
+  REGEX = /[-+]?[0-9]+/
+  NATIVE_FUN = :to_i
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_i
   end
+
+  def to_i
+    value
+  end
+
+  def equivalent?(field)
+    if field.is_a?(GFA::Field::NumArray)
+      return field.size == 1 && field.first.to_i == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/string.rb

@@ -1,6 +1,15 @@
 class GFA::Field::String < GFA::Field
   CODE = :Z
-  REGEX = /^[ !-~]+$/
+  REGEX = /[ !-~]+/
+  NATIVE_FUN = :to_s
+
+  def to_f
+    value.to_f
+  end
+
+  def to_i(base = 10)
+    value.to_i(base)
+  end
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")

data/lib/gfa/field.rb

@@ -12,7 +12,7 @@ class GFA::Field
   TYPES = CODES.values
   TYPES.each { |t| require "gfa/field/#{t.downcase}" }
 
-  [:CODES, :TYPES].each do |x|
+  %i[CODES TYPES].each do |x|
     define_singleton_method(x) { const_get(x) }
   end
   
@@ -25,23 +25,95 @@ class GFA::Field
   def self.name_class(name)
     const_get(name)
   end
-   
+
+  def self.[](string)
+    code, value = string.split(':', 2)
+    code_class(code).new(value)
+  end
+
   # Instance-level
 
   attr :value
 
-  def type ; CODES[code] ; end
-   
-  def code ; self.class::CODE ; end
-   
-  def regex ; self.class::REGEX ; end
-   
-  def to_s(with_type=true)
+  def type
+    CODES[code]
+  end
+
+  def code
+    self.class::CODE
+  end
+
+  def regex
+    self.class::REGEX
+  end
+
+  def native_fun
+    self.class::NATIVE_FUN
+  end
+
+  def to_native
+    native_fun == :to_s ? to_s(false) : send(native_fun)
+  end
+
+  def to_s(with_type = true)
     "#{"#{code}:" if with_type}#{value}"
   end
-   
+
   def hash
     value.hash
   end
 
+  ##
+  # Evaluate equivalency of contents. All the following fields are distinct but
+  # contain the same information, and are therefore considered equivalent:
+  # Z:123, i:123, f:123.0, B:i,123, H:7b
+  #
+  # Note that the information content is determined by the class of the first
+  # operator. For example:
+  # - 'i:123' ~ 'f:123.4' is true because values are compared as integers
+  # - 'f:123.4' ~ 'i:123' if false because values are compared as floats
+  def equivalent?(field)
+    return true if eql?(field) # Might be faster, so testing this first
+
+    if field.respond_to?(native_fun)
+      if field.is_a?(GFA::Field) && native_fun == :to_s
+        field.to_s(false) == to_native
+      else
+        field.send(native_fun) == to_native
+      end
+    else
+      field == value
+    end
+  end
+
+  ##
+  # Non-equivalent to +field+, same as +!equivalent?+
+  def !~(field)
+    !self.~(field)
+  end
+
+  ##
+  # Same as +equivalent?+
+  def ~(field)
+    equivalent?(field)
+  end
+
+  ##
+  # Evaluate equality. Note that fields with equivalent values evaluate as
+  # different. For example, the following fields have equivalent information,
+  # but they all evaluate as different: Z:123, i:123, f:123.0, B:i,123, H:7b.
+  # To test equivalency of contents instead, use +equivalent?+
+  def eql?(field)
+    if field.is_a?(GFA::Field)
+      type == field.type && value == field.value
+    else
+      field.is_a?(value.class) && value == field
+    end
+  end
+
+  ##
+  # Same as +eql?+
+  def ==(field)
+    eql?(field)
+  end
 end

data/lib/gfa/graph.rb

@@ -2,7 +2,6 @@ require 'rgl/adjacency'
 require 'rgl/implicit'
 
 class GFA
-   
   ##
   # Generates a RGL::ImplicitGraph object describing the links in the GFA.
   # The +opts+ argument is a hash with any of the following key-value pairs:
@@ -57,7 +56,7 @@ class GFA
       opts
     end
 
-    def rgl_implicit_adjacent_iterator(x,b,opts)
+    def rgl_implicit_adjacent_iterator(x, b, opts)
       links.each do |l|
         if l.from?(x.segment, x.orient)
           orient = opts[:orient] ? l.to_orient : nil

data/lib/gfa/parser.rb

@@ -4,15 +4,20 @@ class GFA
   # Class-level
   MIN_VERSION = '1.0'
   MAX_VERSION = '1.2'
-   
-  def self.load(file)
-    gfa = GFA.new
+
+  ##
+  # Load a GFA object from a +gfa+ file with options +opts+:
+  # - index: If the records should be indexed as loaded (default: true)
+  # - comments: If the comment records should be saved (default: false)
+  def self.load(file, opts = {})
+    gfa = GFA.new(opts)
     fh = File.open(file, 'r')
     fh.each { |ln| gfa << ln }
-    fh.close
     gfa
+  ensure
+    fh&.close
   end
-   
+
   def self.supported_version?(v)
     v.to_f >= MIN_VERSION.to_f and v.to_f <= MAX_VERSION.to_f
   end
@@ -23,24 +28,27 @@ class GFA
     return if obj.nil? || obj.empty?
     @records[obj.type] << obj
 
-    if obj.type == :Header && !obj.fields[:VN].nil?
-      set_gfa_version(obj.fields[:VN].value)
+    if obj.type == :Header && !obj.VN.nil?
+      set_gfa_version(obj.VN.value)
     end
   end
 
   def set_gfa_version(v)
-    @gfa_version = v
-    unless GFA::supported_version? gfa_version
-      raise "GFA version currently unsupported: #{v}."
+    v = v.value if v.is_a? GFA::Field
+    unless GFA::supported_version? v
+      raise "GFA version currently unsupported: #{v}"
     end
+
+    @gfa_version = v
   end
-   
+
   private
-      
-    def parse_line(ln)
-      ln.chomp!
-      return nil if ln =~ /^\s*$/
-      cols = ln.split("\t")
-      GFA::Record.code_class(cols.shift).new(*cols)
+
+    def parse_line(string)
+      string = string.chomp
+      return nil if string =~ /^\s*$/
+      return nil if !opts[:comments] && string[0] == '#'
+
+      GFA::Record[string]
     end
 end

data/lib/gfa/record/comment.rb

@@ -1,10 +1,15 @@
 class GFA::Record::Comment < GFA::Record
   CODE = :'#'
-  REQ_FIELDS = []
+  REQ_FIELDS = %i[comment]
   OPT_FIELDS = {}
+
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
    
-  def initialize(*opt_fields)
+  def initialize(comment, *opt_fields)
     @fields = {}
+    add_field(2, :Z, comment, /.*/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
 end

data/lib/gfa/record/containment.rb

@@ -10,20 +10,21 @@ class GFA::Record::Containment < GFA::Record
   REQ_FIELDS.each_index do |i|
     define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
 
   alias container from
   alias container_orient from_orient
   alias contained to
   alias contained_orient to_orient
-   
+
   def initialize(from, from_orient, to, to_orient, pos, overlap, *opt_fields)
     @fields = {}
-    add_field(2, :Z, from, /^[!-)+-<>-~][!-~]*$/)
-    add_field(3, :Z, from_orient, /^+|-$/)
-    add_field(4, :Z, to, /^[!-)+-<>-~][!-~]*$/)
-    add_field(5, :Z, to_orient, /^+|-$/)
-    add_field(6, :i, pos, /^[0-9]*$/)
-    add_field(7, :Z, overlap, /^\*|([0-9]+[MIDNSHPX=])+$/)
+    add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, from_orient, /[+-]/)
+    add_field(4, :Z, to,          /[!-)+-<>-~][!-~]*/)
+    add_field(5, :Z, to_orient,   /[+-]/)
+    add_field(6, :i, pos,         /[0-9]*/)
+    add_field(7, :Z, overlap,     /\*|([0-9]+[MIDNSHPX=])+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
 end

data/lib/gfa/record/header.rb

@@ -4,6 +4,8 @@ class GFA::Record::Header < GFA::Record
   OPT_FIELDS = {
     VN: :Z # Version number
   }
+
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
    
   def initialize(*opt_fields)
     @fields = {}

data/lib/gfa/record/jump.rb

@@ -4,26 +4,26 @@ class GFA::Record::Jump < GFA::Record
   OPT_FIELDS = {
     SC: :i  # 1 indicates indirect shortcut connections. Only 0/1 allowed.
   }
-   
+
   REQ_FIELDS.each_index do |i|
     define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
 
   def initialize(from, from_orient, to, to_orient, distance, *opt_fields)
     @fields = {}
-    add_field(2, :Z, from,        /^[!-)+-<>-~][!-~]*$/)
-    add_field(3, :Z, from_orient, /^+|-$/)
-    add_field(4, :Z, to,          /^[!-)+-<>-~][!-~]*$/)
-    add_field(5, :Z, to_orient,   /^+|-$/)
-    add_field(6, :Z, distance,    /^\*|[-+]?[0-9]+$/)
+    add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, from_orient, /[+-]/)
+    add_field(4, :Z, to,          /[!-)+-<>-~][!-~]*/)
+    add_field(5, :Z, to_orient,   /[+-]/)
+    add_field(6, :Z, distance,    /\*|[-+]?[0-9]+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
 
-   
   def from?(segment, orient = nil)
     links_from_to?(segment, orient, true)
   end
-   
+
   def to?(segment, orient = nil)
     links_from_to?(segment, orient, false)
   end

data/lib/gfa/record/link.rb

@@ -9,25 +9,26 @@ class GFA::Record::Link < GFA::Record
     KC: :i, # k-mer count
     ID: :Z  # Edge identifier
   }
-   
+
   REQ_FIELDS.each_index do |i|
     define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
 
   def initialize(from, from_orient, to, to_orient, overlap, *opt_fields)
     @fields = {}
-    add_field(2, :Z, from, /^[!-)+-<>-~][!-~]*$/)
-    add_field(3, :Z, from_orient, /^+|-$/)
-    add_field(4, :Z, to, /^[!-)+-<>-~][!-~]*$/)
-    add_field(5, :Z, to_orient, /^+|-$/)
-    add_field(6, :Z, overlap, /^\*|([0-9]+[MIDNSHPX=])+$/)
+    add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, from_orient, /[+-]/)
+    add_field(4, :Z, to,          /[!-)+-<>-~][!-~]*/)
+    add_field(5, :Z, to_orient,   /[+-]/)
+    add_field(6, :Z, overlap,     /\*|([0-9]+[MIDNSHPX=])+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
 
   def from?(segment, orient = nil)
     links_from_to?(segment, orient, true)
   end
-   
+
   def to?(segment, orient = nil)
     links_from_to?(segment, orient, false)
   end

data/lib/gfa/record/path.rb

@@ -1,19 +1,19 @@
 class GFA::Record::Path < GFA::Record
   CODE = :P
-  REQ_FIELDS = %i[path_name segment_name cigar]
+  REQ_FIELDS = %i[path_name segment_name overlaps]
   OPT_FIELDS = {}
 
   REQ_FIELDS.each_index do |i|
     define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
 
-  alias overlaps cigar
+  alias cigar overlaps
 
-  def initialize(path_name, segment_name, cigar, *opt_fields)
+  def initialize(path_name, segment_name, overlaps, *opt_fields)
     @fields = {}
-    add_field(2, :Z, path_name, /^[!-)+-<>-~][!-~]*$/)
-    add_field(3, :Z, segment_name, /^[!-)+-<>-~][!-~]*$/)
-    add_field(4, :Z, cigar, /^\*|([0-9]+[MIDNSHPX=])+$/)
+    add_field(2, :Z, path_name,    /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, segment_name, /[!-)+-<>-~][!-~]*/)
+    add_field(4, :Z, overlaps,     /\*|([0-9]+[MIDNSHPX=]|[-+]?[0-9]+J|.)+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
 end

data/lib/gfa/record/segment.rb

@@ -15,11 +15,12 @@ class GFA::Record::Segment < GFA::Record
   REQ_FIELDS.each_index do |i|
     define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
+  OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
    
   def initialize(name, sequence, *opt_fields)
     @fields = {}
-    add_field(2, :Z, name, /^[!-)+-<>-~][!-~]*$/)
-    add_field(3, :Z, sequence, /^\*|[A-Za-z=.]+$/)
+    add_field(2, :Z, name,     /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, sequence, /\*|[A-Za-z=.]+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
 end

data/lib/gfa/record/walk.rb

@@ -9,12 +9,12 @@ class GFA::Record::Walk < GFA::Record
 
   def initialize(sample_id, hap_index, seq_id, seq_start, seq_end, walk, *opt_fields)
     @fields = {}
-    add_field(2, :Z, sample_id, /^[!-)+-<>-~][!-~]*$/)
-    add_field(3, :i, hap_index, /^[0-9]+$/)
-    add_field(4, :Z, seq_id, /^[!-)+-<>-~][!-~]*$/)
-    add_field(5, :i, seq_start, /^\*|[0-9]+$/)
-    add_field(6, :i, seq_end, /^\*|[0-9]+$/)
-    add_field(7, :Z, walk, /^([><][!-;=?-~]+)+$/)
+    add_field(2, :Z, sample_id, /[!-)+-<>-~][!-~]*/)
+    add_field(3, :i, hap_index, /[0-9]+/)
+    add_field(4, :Z, seq_id,    /[!-)+-<>-~][!-~]*/)
+    add_field(5, :i, seq_start, /\*|[0-9]+/)
+    add_field(6, :i, seq_end,   /\*|[0-9]+/)
+    add_field(7, :Z, walk,      /([><][!-;=?-~]+)+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
 end

data/lib/gfa/record.rb

@@ -15,7 +15,7 @@ class GFA::Record
   TYPES = CODES.values
   TYPES.each { |t| require "gfa/record/#{t.downcase}" }
 
-  [:CODES, :REQ_FIELDS, :OPT_FIELDS, :TYPES].each do |x|
+  %i[CODES REQ_FIELDS OPT_FIELDS TYPES].each do |x|
     define_singleton_method(x) { const_get(x) }
   end
 
@@ -29,18 +29,32 @@ class GFA::Record
     const_get(name)
   end
 
+  def self.[](string)
+    split = string[0] == '#' ? ['', 2] : ["\t", 0]
+    code, *values = string.chomp.split(*split)
+    code_class(code).new(*values)
+  end
+
   # Instance-level
 
   attr :fields
 
-  def [](k) fields[k] ; end
-   
-  def type ; CODES[code] ; end
-   
-  def code ; self.class.const_get(:CODE) ; end
-   
-  def empty? ; fields.empty? ; end
-   
+  def [](k)
+    fields[k]
+  end
+
+  def type
+    CODES[code]
+  end
+
+  def code
+    self.class.const_get(:CODE)
+  end
+
+  def empty?
+    fields.empty?
+  end
+
   def to_s
     o = [code.to_s]
     self.class.REQ_FIELDS.each_index do |i|
@@ -52,7 +66,7 @@ class GFA::Record
     end
     o.join("\t")
   end
-   
+
   def hash
     { code => fields }.hash
   end
@@ -64,19 +78,19 @@ class GFA::Record
   alias == eql?
 
   private
-      
+
     def add_field(f_tag, f_type, f_value, format = nil)
       unless format.nil?
         msg = (f_tag.is_a?(Integer) ? "column #{f_tag}" : "#{f_tag} field")
         GFA.assert_format(f_value, format, "Bad #{type} #{msg}")
       end
 
-      @fields[ f_tag ] = GFA::Field.code_class(f_type).new(f_value)
+      @fields[f_tag] = GFA::Field.code_class(f_type).new(f_value)
     end
-      
+
     def add_opt_field(f, known)
       m = /^([A-Za-z]+):([A-Za-z]+):(.*)$/.match(f)
-      raise "Cannot parse field: '#{f}'." unless m
+      raise "Cannot parse field: '#{f}'" unless m
 
       f_tag = m[1].to_sym
       f_type = m[2].to_sym

data/lib/gfa/record_set/comment_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::CommentSet < GFA::RecordSet
+  CODE = :'#'
+end

data/lib/gfa/record_set/containment_set.rb

@@ -0,0 +1,4 @@
+class GFA::RecordSet::ContainmentSet < GFA::RecordSet
+  CODE = :C
+  INDEX_FIELD = 2 # Container: Name of container segment
+end

data/lib/gfa/record_set/header_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::HeaderSet < GFA::RecordSet
+  CODE = :H
+end

data/lib/gfa/record_set/jump_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::JumpSet < GFA::RecordSet
+  CODE = :J
+end

data/lib/gfa/record_set/link_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::LinkSet < GFA::RecordSet
+  CODE = :L
+end

data/lib/gfa/record_set/path_set.rb

@@ -0,0 +1,4 @@
+class GFA::RecordSet::PathSet < GFA::RecordSet
+  CODE = :P
+  INDEX_FIELD = 2 # PathName: Path name
+end

data/lib/gfa/record_set/segment_set.rb

@@ -0,0 +1,4 @@
+class GFA::RecordSet::SegmentSet < GFA::RecordSet
+  CODE = :S
+  INDEX_FIELD = 2 # Name: Segment name
+end

data/lib/gfa/record_set/walk_set.rb

@@ -0,0 +1,3 @@
+class GFA::RecordSet::WalkSet < GFA::RecordSet
+  CODE = :W
+end

data/lib/gfa/record_set.rb

@@ -0,0 +1,99 @@
+
+require 'gfa/record'
+
+class GFA::RecordSet
+  INDEX_FIELD = nil
+  TYPES = GFA::Record.TYPES.map { |i| :"#{i}Set" }
+  GFA::Record.TYPES.each { |t| require "gfa/record_set/#{t.downcase}_set" }
+
+  %i[TYPES].each do |x|
+    define_singleton_method(x) { const_get(x) }
+  end
+
+  def self.code_class(code)
+    name = GFA::Record.CODES[code.to_sym]
+    raise "Unknown record type: #{code}." if name.nil?
+    name_class(name)
+  end
+
+  def self.name_class(name)
+    name = "#{name}Set" unless name =~ /Set$/
+    const_get(name)
+  end
+
+  # Instance-level
+
+  attr_reader :set, :gfa
+
+  def initialize(gfa)
+    @set   = []
+    @index = {}
+    @gfa   = gfa
+  end
+
+  def [](k)
+    return set[k] if k.is_a?(Integer)
+    find_index(k)
+  end
+
+  def type
+    GFA::Record.CODES[code]
+  end
+
+  def code
+    self.class.const_get(:CODE)
+  end
+
+  def index_field
+    self.class.const_get(:INDEX_FIELD)
+  end
+
+  %i[empty? hash size count length first last].each do |i|
+    define_method(i) { set.send(i) }
+  end
+
+  def to_s
+    set.map(&:to_s).join("\n")
+  end
+
+  def eql?(rec)
+    hash == rec.hash
+  end
+
+  alias == eql?
+
+  def <<(v)
+    v = v.split("\t") if v.is_a? String
+    v = GFA::Record.code_class(code).new(*v) if v.is_a? Array
+    raise "Not a GFA Record: #{v}" unless v.is_a? GFA::Record
+    raise "Wrong type of record: #{v.type}" if v.type != type
+
+    @set << v
+    index(v)
+  end
+
+  def index_id(v)
+    v[index_field]&.value
+  end
+
+  def index(v)
+    save_index(index_id(v), v) if index_field
+
+    # Whenever present, index also by ID
+    save_index(v[:ID].value, v) if v[:ID] && v[:ID].value =~ index_id(v)
+  end
+
+  def save_index(k, v)
+    return unless gfa.opts[:index] && k
+
+    if @index[k]
+      warn "#{type} already registered with field #{index_field}: #{k}"
+    end
+    @index[k] = v
+  end
+
+  def find_index(k)
+    k = k.value if k.is_a? GFA::Field
+    @index[k]
+  end
+end

data/lib/gfa/version.rb

@@ -1,5 +1,5 @@
 class GFA
-  VERSION       = '0.2.0'
+  VERSION       = '0.3.1'
   VERSION_ARRAY = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR = VERSION_ARRAY[1] # :nodoc:

data/test/common_test.rb

@@ -4,10 +4,10 @@ class CommonTest < Test::Unit::TestCase
    
   def test_assert_format
     assert_raise do
-      GFA.assert_format("tsooq", /^.$/, "Not a char")
+      GFA.assert_format('tsooq', /^.$/, 'Not a char')
     end
     assert_nothing_raised do
-      GFA.assert_format("z", /^.$/, "Not a char")
+      GFA.assert_format('z', /^.$/, 'Not a char')
     end
   end
    
@@ -20,15 +20,15 @@ class CommonTest < Test::Unit::TestCase
   def test_record_getters
     gfa = GFA.new
     assert_respond_to(gfa, :headers)
-    assert_equal([], gfa.links)
+    assert_equal([], gfa.links.set)
     assert_nil( gfa.segment(0) )
   end
 
   def test_record_setters
     gfa = GFA.new
     assert_respond_to(gfa, :add_path)
-    gfa.add_containment("zooq")
-    assert_equal("zooq", gfa.records[:Containment].first)
+    gfa.add_containment("zooq\t+\ttsuk\t-\t1\t*")
+    assert_equal('zooq', gfa.records[:Containment].first.from.value)
   end
 
 end

data/test/field_test.rb

@@ -3,48 +3,74 @@ require "test_helper"
 class FieldTest < Test::Unit::TestCase
 
   def test_char
-    f = GFA::Field::Char.new("%")
-    assert_equal("%", f.value)
-    assert_raise do
-      GFA::Field::Char.new(" ")
-    end
-    assert_raise do
-      GFA::Field::Char.new("")
-    end
-    assert_raise do
-      GFA::Field::Char.new("^.^")
-    end
+    f = GFA::Field::Char.new('%')
+    assert_equal('%', f.value)
+    assert_raise { GFA::Field::Char.new(' ') }
+    assert_raise { GFA::Field::Char.new('') }
+    assert_raise { GFA::Field::Char.new('^.^') }
   end
 
   def test_sigint
   end
 
   def test_float
-    f = GFA::Field::Float.new("1.3e-5")
+    f = GFA::Field::Float.new('1.3e-5')
     assert_equal(1.3e-5, f.value)
-    assert_raise do
-       GFA::Field::Float.new("e-5")
-    end
+    assert_raise { GFA::Field::Float.new('e-5') }
   end
 
   def test_string
   end
 
   def test_hex
-     f = GFA::Field::Hex.new("C3F0")
-     assert_equal("C3F0", f.value)
-     assert_raise do
-       GFA::Field::Hex.new("C3PO")
-     end
+     f = GFA::Field::Hex.new('C3F0')
+     assert_equal('C3F0', f.value)
+     assert_raise { GFA::Field::Hex.new('C3PO') }
   end
 
   def test_numarray
-    f = GFA::Field::NumArray.new("i,1,2,3")
-    assert_equal(%w[1 2 3], f.array)
-    assert_equal("i", f.modifier)
-    assert_raise do
-      GFA::Field::NumArray.new("c,1,e,3")
-    end
+    f = GFA::Field::NumArray.new('i,1,2,3')
+    assert_equal([1, 2, 3], f.array)
+    assert_equal('i', f.modifier)
+    assert_raise { GFA::Field::NumArray.new('c,1,e,3') }
   end
 
+  def test_equal
+    f = GFA::Field::SigInt.new('123')
+    j = GFA::Field::String.new('123')
+    k = GFA::Field::Float.new('123')
+    assert(f == 123)
+    assert(123 == f)
+    assert(f != 123.0)
+    assert(f != '123')
+    assert(f.eql?(123))
+    assert(f != j)
+    assert(f != k)
+    assert(f != k.value)
+    assert(f.value == k.value)
+  end
+
+  def test_equivalent
+    # String comparisons
+    assert(GFA::Field['Z:a'].~ GFA::Field['A:a'])
+    assert(GFA::Field['Z:ab'] !~ GFA::Field['A:a'])
+    assert(GFA::Field['Z:{"a":1}'].~ GFA::Field['J:{"a":1}'])
+    assert(GFA::Field['J:{"a":1}'].~ GFA::Field['Z:{"a":1}'])
+
+    # Numeric comparisons
+    assert(GFA::Field['Z:123'].~ GFA::Field['i:123'])
+    assert(GFA::Field['Z:123'].~ GFA::Field['i:123'])
+    assert(GFA::Field['i:123'].~ GFA::Field['f:123'])
+    assert(GFA::Field['f:123'].~ GFA::Field['B:i,123'])
+    assert(GFA::Field['B:i,123'].~ GFA::Field['H:7B'])
+    assert(GFA::Field['H:7B'].~ GFA::Field['f:123.0'])
+    assert(GFA::Field['Z:123'] !~ GFA::Field['H:7B']) # In hex-space!
+    assert(GFA::Field['f:1e3'].~ GFA::Field['f:1000'])
+    assert(GFA::Field['f:1e3'].~ 1e3)
+    assert(GFA::Field['B:i,123,456'].~ [123, 456.0])
+
+    # Non-commutative
+    assert(GFA::Field['i:123'].~ GFA::Field['f:123.4'])
+    assert(GFA::Field['f:123.4'] !~ GFA::Field['i:123'])
+  end
 end

data/test/parser_test.rb

@@ -2,20 +2,55 @@ require "test_helper"
 require "gfa/parser"
 
 class ParserTest < Test::Unit::TestCase
-   
+
   def test_load
-    sample_f = File.expand_path('../fixtures/sample.gfa', __FILE__)
     assert_respond_to(GFA, :load)
-    pre_fhs  = ObjectSpace.each_object(IO).count{ |i| not i.closed? }
-    sample   = GFA.load(sample_f)
-    post_fhs = ObjectSpace.each_object(IO).count{ |i| not i.closed? }
+
+    # Can load files and close pointers properly
+    pre_fhs  = ObjectSpace.each_object(IO).count { |i| not i.closed? }
+    assert_nothing_raised do
+      GFA.load(fixture_path('sample1.gfa'))
+    end
+    assert_nothing_raised do
+      GFA.load(fixture_path('sample2.gfa'))
+    end
+    assert_nothing_raised do
+      GFA.load(fixture_path('sample3.gfa'))
+    end
+    assert_raise do
+      GFA.load(fixture_path('sample4.gfa'))
+    end
+    post_fhs = ObjectSpace.each_object(IO).count { |i| not i.closed? }
     assert_equal(pre_fhs, post_fhs)
-    assert_equal(1, sample.headers.size)
-    assert_equal(6, sample.segments.size)
-    assert_equal(4, sample.links.size)
-    assert(sample.containments.empty?)
-    assert(sample.paths.empty?)
-    assert_respond_to(sample, :records)
+  end
+
+  def test_records
+    # Samples are properly parsed
+    sample1 = GFA.load(fixture_path('sample1.gfa'))
+    assert_equal(1, sample1.headers.size)
+    assert_equal(6, sample1.segments.size)
+    assert_equal(4, sample1.links.size)
+    assert(sample1.containments.empty?)
+    assert(sample1.paths.empty?)
+    assert_respond_to(sample1, :records)
+  end
+
+  def test_comments
+    path = fixture_path('sample2.gfa')
+    sample = GFA.load(path)
+    assert(sample.comments.empty?)
+    sample = GFA.load(path, comments: true)
+    assert(!sample.comments.empty?)
+  end
+
+  def test_index
+    path = fixture_path('sample3.gfa')
+    sample = GFA.load(path)
+    assert(sample.path('first').is_a?(GFA::Record))
+    assert(sample.paths['first'].is_a?(GFA::Record))
+    assert_equal('first', sample.path('first')[2]&.value)
+    sample = GFA.load(path, index: false)
+    assert_nil(sample.path('first'))
   end
   
   def test_version_suppport
@@ -28,20 +63,22 @@ class ParserTest < Test::Unit::TestCase
   def test_line_by_line
     gfa = GFA.new
     assert_respond_to(gfa, :<<)
+
     # Empty
     gfa << ' '
     assert(gfa.empty?)
     gfa << 'H'
     assert(gfa.empty?)
+
     # Segment
     assert_equal(0, gfa.segments.size)
-    gfa << "S\t1\tACTG"
+    gfa << "S\t1\tACTG\n"
     assert(!gfa.empty?)
     assert_equal(1, gfa.segments.size)
+
     # Version
     assert_nil(gfa.gfa_version)
     gfa << GFA::Record::Header.new('VN:Z:1.0')
     assert_equal('1.0', gfa.gfa_version)
   end
-
 end

data/test/record_test.rb

@@ -17,6 +17,13 @@ class RecordTest < Test::Unit::TestCase
     assert_equal("P\ta\tb\t*",  $rec_p.to_s)
   end
 
+  def test_init_by_string
+    p = GFA::Record["P\ta\tb\t*"]
+    assert_equal('a', p.path_name&.value)
+    c = GFA::Record["# doink!\n"]
+    assert_equal(' doink!', c.comment&.value)
+  end
+
   def test_hash
     other_h = GFA::Record::Header.new("VN:Z:1.0")
     assert_equal($rec_h.hash, other_h.hash)

data/test/test_helper.rb

@@ -4,3 +4,8 @@ SimpleCov.start
 require 'rubygems'
 require 'test/unit'
 require 'gfa/common'
+
+def fixture_path(file)
+  File.expand_path("../fixtures/#{file}", __FILE__)
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gfa
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-22 00:00:00.000000000 Z
+date: 2023-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgl
@@ -85,6 +85,15 @@ files:
 - lib/gfa/record/path.rb
 - lib/gfa/record/segment.rb
 - lib/gfa/record/walk.rb
+- lib/gfa/record_set.rb
+- lib/gfa/record_set/comment_set.rb
+- lib/gfa/record_set/containment_set.rb
+- lib/gfa/record_set/header_set.rb
+- lib/gfa/record_set/jump_set.rb
+- lib/gfa/record_set/link_set.rb
+- lib/gfa/record_set/path_set.rb
+- lib/gfa/record_set/segment_set.rb
+- lib/gfa/record_set/walk_set.rb
 - lib/gfa/version.rb
 - test/common_test.rb
 - test/field_test.rb
@@ -94,7 +103,7 @@ files:
 homepage: https://github.com/lmrodriguezr/gfa
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options:
 - lib
 - README.md
@@ -115,8 +124,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: Graphical Fragment Assembly (GFA) for Ruby
 test_files: []