gfa 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 8388ee28f1d71339d701b32e2a4fa1538b0f391f
-  data.tar.gz: 520590efdc7170cf805db8427574e6e6fb5a8ac1
+SHA256:
+  metadata.gz: cde4a3e432409c7a2967832dcebd502ddc54b1f6cb25856b6d9d21ce53f67b32
+  data.tar.gz: 91213d63365dd3608c28e30115cbfc8621e78bbe34936832bcee2ac7e6f460fb
 SHA512:
-  metadata.gz: c8e8366d01006fbffc22ae49f3b4d619d8e8fbf25ef2c6173b427f05382a28c8a9efd7798f791d05c890e3057d3115ca8d3a6bc6d330551bf0915569c89ecc5c
-  data.tar.gz: c6bcd711d7841585e6452cca87564b5d2e41a673e1bc4869df632db6193b928bbc6374ca370d8033db8df70e377234f3aa0a5f3a9ae96c56f053b771dff78060
+  metadata.gz: 321634c28ec8927bd38286a84a02783b9f915dcbabb7941233583dda7f41b66e952ff9611c9158bd7baca09d7d3d6c254a036f1c9f2169e5e24e6e964d292e71
+  data.tar.gz: 3698d16ab5953ffd70bf2c102d154bc1f61e5a13a752bc317a756df13762c3668c1bf6e8144821e53e395783f36c45185249c7fc206694be19145200310c3f48

data/Gemfile

@@ -1,3 +1,9 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 gemspec
-gem "codeclimate-test-reporter", group: :test, require: nil
+
+group :test do
+  gem "simplecov"
+  gem "codeclimate-test-reporter", "~> 1.0.0"
+end
+
+gem 'rake', '~> 13.0'

data/LICENSE

@@ -1,6 +1,6 @@
-               The Artistic License 2.0
+                    The Artistic License 2.0
 
-           Copyright (c) 2016 Luis M Rodriguez-R
+           Copyright (c) 2016-2023 Luis M Rodriguez-R
 
      Everyone is permitted to copy and distribute verbatim copies
       of this license document, but changing it is not allowed.

data/README.md

@@ -13,20 +13,20 @@ This implementation follows the specifications of [GFA-spec][].
 To parse a file in GFA format:
 
 ```ruby
-require "gfa"
+require 'gfa'
 
-my_gfa = GFA.load("assembly.gfa")
+my_gfa = GFA.load('assembly.gfa')
 ```
 
 To load GFA strings line-by-line:
 
 ```ruby
-require "gfa"
+require 'gfa'
 
 my_gfa = GFA.new
-fh = File.open("assembly.gfa", "r")
+fh = File.open('assembly.gfa', 'r')
 fh.each do |ln|
-   my_gfa << ln
+  my_gfa << ln
 end
 fh.close
 ```
@@ -37,15 +37,15 @@ fh.close
 After altering a GFA object, you can simply save it in a file as:
 
 ```ruby
-my_gfa.save("alt-assembly.gfa")
+my_gfa.save('alt-assembly.gfa')
 ```
 
 Or line-by-line as:
 
 ```ruby
-fh = File.open("alt-assembly.gfa", "w")
+fh = File.open('alt-assembly.gfa', 'w')
 my_gfa.each_line do |ln|
-   fh.puts ln
+  fh.puts ln
 end
 fh.close
 ```
@@ -85,6 +85,14 @@ ug.write_to_graphic_file("jpg")
 gem install gfa
 ```
 
+Or add the following line to your Gemfile:
+
+```ruby
+gem "gfa"
+```
+
+and run `bundle install` from your shell.
+
 
 # Author
 
@@ -96,5 +104,5 @@ gem install gfa
 [Artistic License 2.0](LICENSE).
 
 [GFA-spec]: https://github.com/pmelsted/GFA-spec
-[lrr]: http://lmrodriguezr.github.io/
+[lrr]: https://rodriguez-r.com/
 [rgl]: https://github.com/monora/rgl

data/Rakefile

@@ -1,16 +1,17 @@
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-$:.unshift File.join(File.dirname(__FILE__), "lib")
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
 
-require "gfa/version"
+require 'gfa/version'
 
-SOURCES = FileList["lib/**/*.rb"]
+SOURCES = FileList['lib/**/*.rb']
 
-desc "Default Task"
+desc 'Default Task'
 task :default => :test
 
 Rake::TestTask.new do |t|
-   t.libs << "test"
-   t.pattern = "test/*_test.rb"
-   t.verbose = true
+  t.libs << 'test'
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
 end

data/lib/gfa/common.rb

@@ -1,45 +1,39 @@
-require "gfa/version"
-require "gfa/record"
-require "gfa/field"
+require 'gfa/version'
+require 'gfa/record'
+require 'gfa/field'
 
 class GFA
-   
-   # Class-level
-   def self.assert_format(value, regex, message)
-      unless value =~ regex
-         raise "#{message}: #{value}."
-      end
-   end
-
-   # Instance-level
-   attr :gfa_version, :records
-   GFA::Record.TYPES.each do |r_type|
-      plural = "#{r_type.downcase}s"
-      singular = "#{r_type.downcase}"
-      define_method(plural) do
-         records[r_type]
-      end
-      define_method(singular) do |k|
-         records[r_type][k]
-      end
-      define_method("add_#{singular}") do |v|
-         @records[r_type] << v
-      end
-   end
-
-   def initialize
-      @records = {}
-      GFA::Record.TYPES.each { |t| @records[t] = [] }
-   end
-   
-   def empty?
-      records.values.all? { |r| r.empty? }
-   end
-
-   def eql?(gfa)
-      records == gfa.records
-   end
-
-   alias == eql?
-   
+  # Class-level
+  def self.assert_format(value, regex, message)
+    unless value =~ regex
+      raise "#{message}: #{value}."
+    end
+  end
+
+  # Instance-level
+  attr :gfa_version, :records
+
+  GFA::Record.TYPES.each do |r_type|
+    plural = "#{r_type.downcase}s"
+    singular = "#{r_type.downcase}"
+
+    define_method(plural) { records[r_type] }
+    define_method(singular) { |k| records[r_type][k] }
+    define_method("add_#{singular}") { |v| @records[r_type] << v }
+  end
+
+  def initialize
+    @records = {}
+    GFA::Record.TYPES.each { |t| @records[t] = [] }
+  end
+
+  def empty?
+    records.empty? || records.values.all?(&:empty?)
+  end
+
+  def eql?(gfa)
+    records == gfa.records
+  end
+
+  alias == eql?
 end

data/lib/gfa/field/char.rb

@@ -6,5 +6,4 @@ class GFA::Field::Char < GFA::Field
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
-
 end

data/lib/gfa/field/float.rb

@@ -6,5 +6,4 @@ class GFA::Field::Float < GFA::Field
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_f
   end
-
 end

data/lib/gfa/field/hex.rb

@@ -6,5 +6,4 @@ class GFA::Field::Hex < GFA::Field
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
-
 end

data/lib/gfa/field/json.rb

@@ -0,0 +1,9 @@
+class GFA::Field::Json < GFA::Field
+  CODE = :J
+  REGEX = /^[ !-~]+$/
+
+  def initialize(f)
+    GFA.assert_format(f, regex, "Bad #{type}")
+    @value = f
+  end
+end

data/lib/gfa/field/numarray.rb

@@ -10,7 +10,15 @@ class GFA::Field::NumArray < GFA::Field
   def modifier ; value[0] ; end
 
   def array ; value[2..-1].split(/,/) ; end
-  
+
   alias as_a array
 
+  def number_type
+    {
+      c: 'int8_t',   C: 'uint8_t',
+      s: 'int16_t',  S: 'uint16_t',
+      i: 'int32_t',  I: 'uint32_t',
+      f: 'float'
+    }[modifier.to_sym]
+  end
 end

data/lib/gfa/field/sigint.rb

@@ -1,10 +1,9 @@
 class GFA::Field::SigInt < GFA::Field
   CODE = :i
   REGEX = /^[-+]?[0-9]+$/
-   
+
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_i
   end
-
 end

data/lib/gfa/field/string.rb

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

data/lib/gfa/field.rb

@@ -1,17 +1,15 @@
 class GFA::Field
-  
   # Class-level
-
   CODES = {
-    :A => :Char,
-    :i => :SigInt,
-    :f => :Float,
-    :Z => :String,
-    :H => :Hex,
-    :B => :NumArray
+    A: :Char,
+    i: :SigInt,
+    f: :Float,
+    Z: :String,
+    J: :Json, # Excluding new-line and tab characters
+    H: :Hex,
+    B: :NumArray
   }
   TYPES = CODES.values
-
   TYPES.each { |t| require "gfa/field/#{t.downcase}" }
 
   [:CODES, :TYPES].each do |x|

data/lib/gfa/generator.rb

@@ -1,31 +1,35 @@
 class GFA
-   def save(file)
-      fh = File.open(file, "w")
-      each_line do |ln|
-	 fh.puts ln
+  def save(file)
+    fh = File.open(file, 'w')
+    each_line do |ln|
+      fh.puts ln
+    end
+    fh.close
+  end
+
+  def each_line(&blk)
+    set_version_header('1.1') if gfa_version.nil?
+    GFA::Record.TYPES.each do |r_type|
+      records[r_type].each do |record|
+        blk[record.to_s]
       end
-      fh.close
-   end
-   def each_line(&blk)
-      set_version_header("1.0") if gfa_version.nil?
-      GFA::Record.TYPES.each do |r_type|
-	 records[r_type].each do |record|
-	    blk[record.to_s]
-	 end
-      end
-   end
-   def set_version_header(v)
-      unset_version
-      @records[:Header] << GFA::Record::Header.new("VN:Z:#{v}")
-      @gfa_version = v
-   end
-   def unset_version
-      @records[:Header].delete_if { |o| not o.fields[:VN].nil? }
-      @gfa_version = nil
-   end
-   def to_s
-      o = ""
-      each_line{ |ln| o += ln + "\n" }
-      o
-   end
+    end
+  end
+
+  def set_version_header(v)
+    unset_version
+    @records[:Header] << GFA::Record::Header.new("VN:Z:#{v}")
+    @gfa_version = v
+  end
+
+  def unset_version
+    @records[:Header].delete_if { |o| !o.fields[:VN].nil? }
+    @gfa_version = nil
+  end
+
+  def to_s
+    o = ''
+    each_line { |ln| o += ln + "\n" }
+    o
+  end
 end

data/lib/gfa/graph.rb

@@ -1,5 +1,5 @@
-require "rgl/adjacency"
-require "rgl/implicit"
+require 'rgl/adjacency'
+require 'rgl/implicit'
 
 class GFA
    
@@ -11,7 +11,7 @@ class GFA
   #   true.
   # * :directed => bool. If false, ignores direction of the links. By defaut
   #   the same value as :orient.
-  def implicit_graph(opts={})
+  def implicit_graph(opts = {})
     rgl_implicit_graph(opts)
   end
 
@@ -19,7 +19,7 @@ class GFA
   # Generates a RGL::DirectedAdjacencyGraph or RGL::AdjacencyGraph object.
   # The +opts+ argument is a hash with the same supported key-value pairs as
   # in #implicit_graph.
-  def adjacency_graph(opts={})
+  def adjacency_graph(opts = {})
     implicit_graph(opts).to_adjacency
   end
    
@@ -27,7 +27,7 @@ class GFA
    
     def segment_names_with_orient
       segments.flat_map do |s|
-        %w[+ -].map{ |orient| GFA::GraphVertex.idx(s, orient) }
+        %w[+ -].map { |orient| GFA::GraphVertex.idx(s, orient) }
       end.to_set
     end
 
@@ -44,8 +44,8 @@ class GFA
           (opts[:orient] ? segment_names_with_orient :
                   segment_names).each(&b)
         end
-        g.adjacent_iterator do |x,b|
-          rgl_implicit_adjacent_iterator(x,b,opts)
+        g.adjacent_iterator do |x, b|
+          rgl_implicit_adjacent_iterator(x, b, opts)
         end
         g.directed = opts[:directed]
       end
@@ -62,20 +62,20 @@ class GFA
         if l.from?(x.segment, x.orient)
           orient = opts[:orient] ? l.to_orient : nil
           b.call(GFA::GraphVertex.idx(l.to, orient))
-        elsif opts[:orient] and l.to?(x.segment, orient_rc(x.orient))
+        elsif opts[:orient] && l.to?(x.segment, orient_rc(x.orient))
           orient = orient_rc(l.from_orient.value)
           b.call(GFA::GraphVertex.idx(l.from, orient))
         end
       end
     end
 
-    def orient_rc(o) o=="+" ? "-" : "+" ; end
-
+    def orient_rc(o)
+      o == '+' ? '-' : '+'
+    end
 end
 
 
 class GFA::GraphVertex # :nodoc:
-   
   # Class-level
   @@idx = {}
   def self.idx(segment, orient)
@@ -83,10 +83,10 @@ class GFA::GraphVertex # :nodoc:
     @@idx[n.to_s] ||= n
     @@idx[n.to_s]
   end
-   
+
   # Instance-level
   attr :segment, :orient
-   
+
   def initialize(segment, orient)
     @segment = segment.is_a?(GFA::Record::Segment) ? segment.name.value :
 		segment.is_a?(GFA::Field) ? segment.value : segment
@@ -96,5 +96,4 @@ class GFA::GraphVertex # :nodoc:
   def to_s
     "#{segment}#{orient}"
   end
-
 end

data/lib/gfa/parser.rb

@@ -1,13 +1,13 @@
-require "gfa/record"
+require 'gfa/record'
 
 class GFA
   # Class-level
-  MIN_VERSION = "1.0"
-  MAX_VERSION = "1.0"
+  MIN_VERSION = '1.0'
+  MAX_VERSION = '1.2'
    
   def self.load(file)
     gfa = GFA.new
-    fh = File.open(file, "r")
+    fh = File.open(file, 'r')
     fh.each { |ln| gfa << ln }
     fh.close
     gfa
@@ -20,17 +20,19 @@ class GFA
   # Instance-level
   def <<(obj)
     obj = parse_line(obj) unless obj.is_a? GFA::Record
-    return if obj.nil? or obj.empty?
+    return if obj.nil? || obj.empty?
     @records[obj.type] << obj
-    if obj.type==:Header and not obj.fields[:VN].nil?
+
+    if obj.type == :Header && !obj.fields[:VN].nil?
       set_gfa_version(obj.fields[:VN].value)
     end
   end
 
   def set_gfa_version(v)
     @gfa_version = v
-    raise "GFA version currently unsupported: #{v}." unless
-      GFA::supported_version? gfa_version
+    unless GFA::supported_version? gfa_version
+      raise "GFA version currently unsupported: #{v}."
+    end
   end
    
   private
@@ -41,5 +43,4 @@ class GFA
       cols = ln.split("\t")
       GFA::Record.code_class(cols.shift).new(*cols)
     end
-
 end

data/lib/gfa/record/comment.rb

@@ -0,0 +1,10 @@
+class GFA::Record::Comment < GFA::Record
+  CODE = :'#'
+  REQ_FIELDS = []
+  OPT_FIELDS = {}
+   
+  def initialize(*opt_fields)
+    @fields = {}
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
+end

data/lib/gfa/record/containment.rb

@@ -1,14 +1,20 @@
 class GFA::Record::Containment < GFA::Record
   CODE = :C
-  REQ_FIELDS = [:from, :from_orient, :to, :to_orient, :pos, :overlap]
+  REQ_FIELDS = %i[from from_orient to to_orient pos overlap]
   OPT_FIELDS = {
-    :RC => :i,
-    :NM => :i
+    RC: :i, # Read coverage
+    NM: :i, # Number of mismatches/gaps
+    ID: :Z  # Edge identifier
   }
 
   REQ_FIELDS.each_index do |i|
-    define_method(REQ_FIELDS[i]) { fields[i+2] }
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
+
+  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 = {}
@@ -18,7 +24,6 @@ class GFA::Record::Containment < GFA::Record
     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) }
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
-
 end

data/lib/gfa/record/header.rb

@@ -1,13 +1,12 @@
 class GFA::Record::Header < GFA::Record
-   CODE = :H
-   REQ_FIELDS = []
-   OPT_FIELDS = {
-      :VN => :Z
-   }
+  CODE = :H
+  REQ_FIELDS = []
+  OPT_FIELDS = {
+    VN: :Z # Version number
+  }
    
-   def initialize(*opt_fields)
-      @fields = {}
-      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
-   end
-
+  def initialize(*opt_fields)
+    @fields = {}
+    opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
+  end
 end

data/lib/gfa/record/jump.rb

@@ -0,0 +1,45 @@
+class GFA::Record::Jump < GFA::Record
+  CODE = :J
+  REQ_FIELDS = %i[from from_orient to to_orient distance]
+  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
+
+  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]+$/)
+    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
+
+  private
+
+    def links_from_to?(segment, orient, from)
+      segment = segment_name(segment)
+      orient  = orient.value if orient.is_a? GFA::Field
+      base_k  = from ? 2 : 4
+      segment==fields[base_k].value &&
+        (orient.nil? || orient==fields[base_k + 1].value)
+    end
+
+    def segment_name(segment)
+      segment.is_a?(GFA::Record::Segment) ? segment.name.value :
+        segment.is_a?(GFA::Field) ? segment.value : segment
+    end
+end

data/lib/gfa/record/link.rb

@@ -1,50 +1,49 @@
 class GFA::Record::Link < GFA::Record
-   CODE = :L
-   REQ_FIELDS = [:from, :from_orient, :to, :to_orient, :overlap]
-   OPT_FIELDS = {
-      :MQ => :i,
-      :NM => :i,
-      :EC => :i,
-      :FC => :i,
-      :KC => :i
-   }
+  CODE = :L
+  REQ_FIELDS = %i[from from_orient to to_orient overlap]
+  OPT_FIELDS = {
+    MQ: :i, # Mapping quality
+    NM: :i, # Number of mismatches/gaps
+    EC: :i, # Read count
+    FC: :i, # Fragment count
+    KC: :i, # k-mer count
+    ID: :Z  # Edge identifier
+  }
    
-   REQ_FIELDS.each_index do |i|
-      define_method(REQ_FIELDS[i]) { fields[i+2] }
-   end
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
 
-   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=])+$/)
-      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
-   end
+  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=])+$/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
 
+  def from?(segment, orient = nil)
+    links_from_to?(segment, orient, true)
+  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
-
-   private
+  def to?(segment, orient = nil)
+    links_from_to?(segment, orient, false)
+  end
 
-      def links_from_to?(segment, orient, from)
-         segment = segment_name(segment)
-         orient  = orient.value if orient.is_a? GFA::Field
-         base_k  = from ? 2 : 4
-         segment==fields[base_k].value and
-            (orient.nil? or orient==fields[base_k + 1].value)
-      end
+  private
 
-      def segment_name(segment)
-         segment.is_a?(GFA::Record::Segment) ? segment.name.value :
-            segment.is_a?(GFA::Field) ? segment.value : segment
-      end
+    def links_from_to?(segment, orient, from)
+      segment = segment_name(segment)
+      orient  = orient.value if orient.is_a? GFA::Field
+      base_k  = from ? 2 : 4
+      segment==fields[base_k].value &&
+        (orient.nil? || orient==fields[base_k + 1].value)
+    end
 
+    def segment_name(segment)
+      segment.is_a?(GFA::Record::Segment) ? segment.name.value :
+        segment.is_a?(GFA::Field) ? segment.value : segment
+    end
 end

data/lib/gfa/record/path.rb

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

data/lib/gfa/record/segment.rb

@@ -1,22 +1,25 @@
 class GFA::Record::Segment < GFA::Record
-   CODE = :S
-   REQ_FIELDS = [:name, :sequence]
-   OPT_FIELDS = {
-      :LN => :i,
-      :RC => :i,
-      :FC => :i,
-      :KC => :i
-   }
+  CODE = :S
+  REQ_FIELDS = %i[name sequence]
+  OPT_FIELDS = {
+    LN: :i, # Segment length
+    RC: :i, # Read count
+    FC: :i, # Fragment count
+    KC: :i, # k-mer count
+    SH: :H, # SHA-256 checksum of the sequence
+    UR: :Z, # URI or local file-system path of the sequence
+    # Non-cannonical
+    DP: :f  # (From SAM)
+  }
 
-   REQ_FIELDS.each_index do |i|
-      define_method(REQ_FIELDS[i]) { fields[i+2] }
-   end
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
    
-   def initialize(name, sequence, *opt_fields)
-      @fields = {}
-      add_field(2, :Z, name, /^[!-)+-<>-~][!-~]*$/)
-      add_field(3, :Z, sequence, /^\*|[A-Za-z=.]+$/)
-      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
-   end
-
+  def initialize(name, sequence, *opt_fields)
+    @fields = {}
+    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

@@ -0,0 +1,20 @@
+class GFA::Record::Walk < GFA::Record
+  CODE = :W
+  REQ_FIELDS = %i[sample_id hap_index seq_id seq_start seq_end walk]
+  OPT_FIELDS = {}
+
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i + 2] }
+  end
+
+  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, /^([><][!-;=?-~]+)+$/)
+    opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
+  end
+end

data/lib/gfa/record.rb

@@ -1,18 +1,18 @@
 class GFA::Record
-  
   # Class-level
-
   CODES = {
-    :H => :Header,
-    :S => :Segment,
-    :L => :Link,
-    :C => :Containment,
-    :P => :Path
+    :'#' => :Comment,
+    H: :Header,
+    S: :Segment,
+    L: :Link,
+    J: :Jump, # Since 1.2
+    C: :Containment,
+    P: :Path,
+    W: :Walk # Since 1.1
   }
   REQ_FIELDS = []
   OPT_FIELDS = {}
   TYPES = CODES.values
-
   TYPES.each { |t| require "gfa/record/#{t.downcase}" }
 
   [:CODES, :REQ_FIELDS, :OPT_FIELDS, :TYPES].each do |x|
@@ -44,9 +44,9 @@ class GFA::Record
   def to_s
     o = [code.to_s]
     self.class.REQ_FIELDS.each_index do |i|
-      o << fields[i+2].to_s(false)
+      o << fields[i + 2].to_s(false)
     end
-    fields.each do |k,v|
+    fields.each do |k, v|
       next if k.is_a? Integer
       o << "#{k}:#{v}"
     end
@@ -54,7 +54,7 @@ class GFA::Record
   end
    
   def hash
-    {code => fields}.hash
+    { code => fields }.hash
   end
 
   def eql?(rec)
@@ -65,26 +65,32 @@ class GFA::Record
 
   private
       
-    def add_field(f_tag, f_type, f_value, format=nil)
+    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)
     end
       
     def add_opt_field(f, known)
-      m = /^([A-Za-z]+):([A-Za-z]+):(.*)$/.match(f) or
-        raise "Cannot parse field: '#{f}'."
+      m = /^([A-Za-z]+):([A-Za-z]+):(.*)$/.match(f)
+      raise "Cannot parse field: '#{f}'." unless m
+
       f_tag = m[1].to_sym
       f_type = m[2].to_sym
       f_value = m[3]
-      raise "Unknown reserved tag #{f_tag} for a #{type} record." if
-        known[f_tag].nil? and f_tag =~ /^[A-Z]+$/
-      raise "Wrong field type #{f_type} for a #{f_tag} tag," +
-        " expected #{known[f_tag]}" unless
-        known[f_tag].nil? or known[f_tag] == f_type
+
+      if known[f_tag].nil? && f_tag =~ /^[A-Z]+$/
+        raise "Unknown reserved tag #{f_tag} for a #{type} record."
+      end
+
+      unless known[f_tag].nil? || known[f_tag] == f_type
+        raise "Wrong field type #{f_type} for a #{f_tag} tag," \
+          " expected #{known[f_tag]}"
+      end
+
       add_field(f_tag, f_type, f_value)
     end
-
 end

data/lib/gfa/version.rb

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

data/lib/gfa.rb

@@ -1,4 +1,4 @@
-require "gfa/common"
-require "gfa/parser"
-require "gfa/generator"
-require "gfa/graph"
+require 'gfa/common'
+require 'gfa/parser'
+require 'gfa/generator'
+require 'gfa/graph'

data/test/parser_test.rb

@@ -4,7 +4,7 @@ require "gfa/parser"
 class ParserTest < Test::Unit::TestCase
    
   def test_load
-    sample_f = File.expand_path("../fixtures/sample.gfa",__FILE__)
+    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)
@@ -20,18 +20,18 @@ class ParserTest < Test::Unit::TestCase
   
   def test_version_suppport
     gfa = GFA.new
-    assert_raise { gfa.set_gfa_version("0.9") }
-    assert_raise { gfa.set_gfa_version("1.1") }
-    assert_nothing_raised { gfa.set_gfa_version("1.0") }
+    assert_raise { gfa.set_gfa_version('0.9') }
+    assert_raise { gfa.set_gfa_version('2.1') }
+    assert_nothing_raised { gfa.set_gfa_version('1.0') }
   end
   
   def test_line_by_line
     gfa = GFA.new
     assert_respond_to(gfa, :<<)
     # Empty
-    gfa << " "
+    gfa << ' '
     assert(gfa.empty?)
-    gfa << "H"
+    gfa << 'H'
     assert(gfa.empty?)
     # Segment
     assert_equal(0, gfa.segments.size)
@@ -40,8 +40,8 @@ class ParserTest < Test::Unit::TestCase
     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)
+    gfa << GFA::Record::Header.new('VN:Z:1.0')
+    assert_equal('1.0', gfa.gfa_version)
   end
 
 end

data/test/test_helper.rb

@@ -1,6 +1,6 @@
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
+require 'simplecov'
+SimpleCov.start
 
-require "rubygems"
-require "test/unit"
-require "gfa/common"
+require 'rubygems'
+require 'test/unit'
+require 'gfa/common'

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: gfa
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-03-25 00:00:00.000000000 Z
+date: 2023-02-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgl
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: GFA is a graph representation of fragment assemblies
@@ -59,61 +59,64 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/gfa.rb
 - lib/gfa/common.rb
+- lib/gfa/field.rb
 - lib/gfa/field/char.rb
 - lib/gfa/field/float.rb
 - lib/gfa/field/hex.rb
+- lib/gfa/field/json.rb
 - lib/gfa/field/numarray.rb
 - lib/gfa/field/sigint.rb
 - lib/gfa/field/string.rb
-- lib/gfa/field.rb
 - lib/gfa/generator.rb
 - lib/gfa/graph.rb
 - lib/gfa/parser.rb
+- lib/gfa/record.rb
+- lib/gfa/record/comment.rb
 - lib/gfa/record/containment.rb
 - lib/gfa/record/header.rb
+- lib/gfa/record/jump.rb
 - lib/gfa/record/link.rb
 - lib/gfa/record/path.rb
 - lib/gfa/record/segment.rb
-- lib/gfa/record.rb
+- lib/gfa/record/walk.rb
 - lib/gfa/version.rb
-- lib/gfa.rb
 - test/common_test.rb
 - test/field_test.rb
 - test/parser_test.rb
 - test/record_test.rb
 - test/test_helper.rb
-- Gemfile
-- Rakefile
-- README.md
-- LICENSE
 homepage: https://github.com/lmrodriguezr/gfa
 licenses: []
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - lib
 - README.md
-- --main
+- "--main"
 - README.md
-- --title
+- "--title"
 - Graphical Fragment Assembly (GFA) for Ruby
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.14
-signing_key: 
+rubygems_version: 3.2.3
+signing_key:
 specification_version: 4
 summary: Graphical Fragment Assembly (GFA) for Ruby
 test_files: []