gfa 0.1.1 → 0.2.0

data/lib/gfa/parser.rb

@@ -0,0 +1,46 @@
+require 'gfa/record'
+
+class GFA
+  # Class-level
+  MIN_VERSION = '1.0'
+  MAX_VERSION = '1.2'
+   
+  def self.load(file)
+    gfa = GFA.new
+    fh = File.open(file, 'r')
+    fh.each { |ln| gfa << ln }
+    fh.close
+    gfa
+  end
+   
+  def self.supported_version?(v)
+    v.to_f >= MIN_VERSION.to_f and v.to_f <= MAX_VERSION.to_f
+  end
+
+  # Instance-level
+  def <<(obj)
+    obj = parse_line(obj) unless obj.is_a? GFA::Record
+    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)
+    end
+  end
+
+  def set_gfa_version(v)
+    @gfa_version = v
+    unless GFA::supported_version? gfa_version
+      raise "GFA version currently unsupported: #{v}."
+    end
+  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)
+    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

@@ -0,0 +1,29 @@
+class GFA::Record::Containment < GFA::Record
+  CODE = :C
+  REQ_FIELDS = %i[from from_orient to to_orient pos overlap]
+  OPT_FIELDS = {
+    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] }
+  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 = {}
+    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

@@ -0,0 +1,12 @@
+class GFA::Record::Header < GFA::Record
+  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
+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

@@ -0,0 +1,49 @@
+class GFA::Record::Link < GFA::Record
+  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
+
+  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 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/path.rb

@@ -0,0 +1,19 @@
+class GFA::Record::Path < GFA::Record
+  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
+
+  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

@@ -0,0 +1,25 @@
+class GFA::Record::Segment < GFA::Record
+  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
+   
+  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

@@ -0,0 +1,96 @@
+class GFA::Record
+  # Class-level
+  CODES = {
+    :'#' => :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|
+    define_singleton_method(x) { const_get(x) }
+  end
+
+  def self.code_class(code)
+    name = CODES[code.to_sym]
+    raise "Unknown record type: #{code}." if name.nil?
+    name_class(name)
+  end
+
+  def self.name_class(name)
+    const_get(name)
+  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 to_s
+    o = [code.to_s]
+    self.class.REQ_FIELDS.each_index do |i|
+      o << fields[i + 2].to_s(false)
+    end
+    fields.each do |k, v|
+      next if k.is_a? Integer
+      o << "#{k}:#{v}"
+    end
+    o.join("\t")
+  end
+   
+  def hash
+    { code => fields }.hash
+  end
+
+  def eql?(rec)
+    hash == rec.hash
+  end
+
+  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)
+    end
+      
+    def add_opt_field(f, known)
+      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]
+
+      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

@@ -0,0 +1,7 @@
+class GFA
+  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:
+  VERSION_BUILD = VERSION_ARRAY[2] # :nodoc:
+end

data/lib/gfa.rb

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

data/test/common_test.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class CommonTest < Test::Unit::TestCase
+   
+  def test_assert_format
+    assert_raise do
+      GFA.assert_format("tsooq", /^.$/, "Not a char")
+    end
+    assert_nothing_raised do
+      GFA.assert_format("z", /^.$/, "Not a char")
+    end
+  end
+   
+  def test_empty
+    gfa = GFA.new
+    assert(gfa.empty?)
+    assert_equal(GFA.new, gfa)
+  end
+
+  def test_record_getters
+    gfa = GFA.new
+    assert_respond_to(gfa, :headers)
+    assert_equal([], gfa.links)
+    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)
+  end
+
+end

data/test/field_test.rb

@@ -0,0 +1,50 @@
+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
+  end
+
+  def test_sigint
+  end
+
+  def test_float
+    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
+  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
+  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
+  end
+
+end

data/test/parser_test.rb

@@ -0,0 +1,47 @@
+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? }
+    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_version_suppport
+    gfa = GFA.new
+    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 << ' '
+    assert(gfa.empty?)
+    gfa << 'H'
+    assert(gfa.empty?)
+    # Segment
+    assert_equal(0, gfa.segments.size)
+    gfa << "S\t1\tACTG"
+    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

@@ -0,0 +1,73 @@
+require "test_helper"
+
+class RecordTest < Test::Unit::TestCase
+
+  def setup
+    $rec_h = GFA::Record::Header.new("VN:Z:1.0")
+    $rec_p = GFA::Record::Path.new("a", "b", "*")
+  end
+
+  def test_class_methods
+    assert_respond_to(GFA::Record, :CODES)
+    assert_respond_to(GFA::Record, :TYPES)
+  end
+
+  def test_to_s
+    assert_equal("H\tVN:Z:1.0", $rec_h.to_s)
+    assert_equal("P\ta\tb\t*",  $rec_p.to_s)
+  end
+
+  def test_hash
+    other_h = GFA::Record::Header.new("VN:Z:1.0")
+    assert_equal($rec_h.hash, other_h.hash)
+    assert_equal($rec_h, other_h)
+  end
+  
+  def test_reserved_fields
+    assert_nothing_raised do
+      GFA::Record::Path.new("a", "b", "*", "smile:Z:(-:")
+      GFA::Record::Header.new("Ooo:i:3")
+      GFA::Record::Header.new("oOo:i:2")
+      GFA::Record::Header.new("ooO:i:1")
+    end
+    assert_raise do
+      GFA::Record::Header.new("OOPS:i:3")
+    end
+  end
+
+  def test_header
+  end
+
+  def test_segment
+  end
+
+  def test_link
+    l = GFA::Record::Link.new("Seg1","+","Seg2","-","*","NM:i:123")
+    assert_equal("+", l.from_orient.value)
+    assert_equal(123, l[:NM].value)
+    assert(l.from?("Seg1"))
+    assert(l.from?("Seg1", "+"))
+    assert(l.to?("Seg2", "-"))
+    assert(! l.from?("Seg2"))
+    assert(! l.from?("Seg1", "-"))
+  end
+
+  def test_containment
+    assert_raise do
+      GFA::Record::Containment.new("Seg1","+","Seg2","-","*","RC:i:123")
+    end
+    c = GFA::Record::Containment.new("Seg1","+","Seg2","-","10","*","RC:i:123")
+    assert_equal("+", c.from_orient.value)
+    assert_equal(10, c.pos.value)
+    assert_equal(123, c[:RC].value)
+  end
+
+  def test_path
+    assert_raise do
+      GFA::Record::Path.new("PathA","SegB\t","*")
+    end
+    p = GFA::Record::Path.new("PathA","SegB","*")
+    assert_equal("*", p.cigar.value)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'rubygems'
+require 'test/unit'
+require 'gfa/common'