gfa 0.1.2 → 0.3.1

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.1.2"
+  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/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/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,46 +2,83 @@ 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
     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)
-    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)
+    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

@@ -1,6 +1,11 @@
-require "codeclimate-test-reporter"
-CodeClimate::TestReporter.start
+require 'simplecov'
+SimpleCov.start
+
+require 'rubygems'
+require 'test/unit'
+require 'gfa/common'
+
+def fixture_path(file)
+  File.expand_path("../fixtures/#{file}", __FILE__)
+end
 
-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.3.1
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-25 00:00:00.000000000 Z
+date: 2023-02-23 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,34 +59,47 @@ 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/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
-- 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: {}
@@ -94,25 +107,24 @@ 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
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Graphical Fragment Assembly (GFA) for Ruby