gfa 0.2.0 → 0.4.0

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,34 @@ class GFA::Record
     const_get(name)
   end
 
+  def self.[](string)
+    return nil if string.nil? || string =~ /^\s*$/
+
+    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 +68,11 @@ class GFA::Record
     end
     o.join("\t")
   end
-   
+
+  def dup
+    self.class[to_s]
+  end
+
   def hash
     { code => fields }.hash
   end
@@ -64,19 +84,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,121 @@
+
+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, :index, :gfa
+
+  def initialize(gfa = nil)
+    @set   = []
+    @index = {}
+    @gfa   = gfa || GFA.new
+  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 indexed?
+    (empty? || !index_field) ? gfa.opts[:index] : !index.empty?
+  end
+
+  def rebuild_index!
+    @index = {}
+    set.each { |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
+    if gfa.opts[:index_id] && v[:ID] && v[:ID].value =~ index_id(v)
+      save_index(v[:ID].value, v)
+    end
+  end
+
+  def save_index(k, v)
+    return unless gfa.opts[:index] && k
+
+    if @index[k]
+      f = index_field.is_a?(Integer) ? '' : "#{index_field}: "
+      raise "#{type} already registered: #{f}#{k}"
+    end
+    @index[k] = v
+  end
+
+  def find_index(k)
+    k = k.value if k.is_a? GFA::Field
+    @index[k]
+  end
+
+  def merge!(record_set)
+    raise "Not a record set" unless record_set.is_a?(GFA::RecordSet)
+    if record_set.type != type
+      raise "Wrong type of record set: #{record_set.type}"
+    end
+
+    record_set.set.each { |i| @set << i }
+    record_set.index.each { |k, v| save_index(k, v) }
+  end
+end

data/lib/gfa/version.rb

@@ -1,5 +1,5 @@
 class GFA
-  VERSION       = '0.2.0'
+  VERSION       = '0.4.0'
   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,57 @@ 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)
+    assert(sample.indexed?)
+    sample = GFA.load(path, index: false)
+    assert_nil(sample.path('first'))
+    assert(!sample.indexed?)
   end
   
   def test_version_suppport
@@ -28,20 +65,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.4.0
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-22 00:00:00.000000000 Z
+date: 2023-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgl
@@ -63,6 +63,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/gfa-add-gaf
+- bin/gfa-subgraph
 - lib/gfa.rb
 - lib/gfa/common.rb
 - lib/gfa/field.rb
@@ -79,12 +81,22 @@ files:
 - lib/gfa/record.rb
 - lib/gfa/record/comment.rb
 - lib/gfa/record/containment.rb
+- lib/gfa/record/has_from_to.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/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 +106,7 @@ files:
 homepage: https://github.com/lmrodriguezr/gfa
 licenses: []
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options:
 - lib
 - README.md
@@ -115,8 +127,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: []