gfa 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d8694c80555e4fae39fb77a245428ec8e7ce19a2
-  data.tar.gz: ab29f1249a26d28082e0380fc96edec934acb0e5
+  metadata.gz: 8388ee28f1d71339d701b32e2a4fa1538b0f391f
+  data.tar.gz: 520590efdc7170cf805db8427574e6e6fb5a8ac1
 SHA512:
-  metadata.gz: fe2d1bb08aeaca8cb0b3d588a6b02965ec612d6201bf19b96927df9a2f18b4c2974829a6f9b6da608fae5ac8fd4f9c62b2acd3c8d29718ec2251afdb08ceccba
-  data.tar.gz: c5ce23b34bc1b890e8d9c7de19a1f4cd0a2766897530b9e2563f667d5d81017b5c1245fd39bb52db3f3960513fb47670210df39124c556753874e01feeac03c0
+  metadata.gz: c8e8366d01006fbffc22ae49f3b4d619d8e8fbf25ef2c6173b427f05382a28c8a9efd7798f791d05c890e3057d3115ca8d3a6bc6d330551bf0915569c89ecc5c
+  data.tar.gz: c6bcd711d7841585e6452cca87564b5d2e41a673e1bc4869df632db6193b928bbc6374ca370d8033db8df70e377234f3aa0a5f3a9ae96c56f053b771dff78060

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+gemspec
+gem "codeclimate-test-reporter", group: :test, require: nil

data/LICENSE

@@ -0,0 +1,201 @@
+               The Artistic License 2.0
+
+           Copyright (c) 2016 Luis M Rodriguez-R
+
+     Everyone is permitted to copy and distribute verbatim copies
+      of this license document, but changing it is not allowed.
+
+Preamble
+
+This license establishes the terms under which a given free software
+Package may be copied, modified, distributed, and/or redistributed.
+The intent is that the Copyright Holder maintains some artistic
+control over the development of that Package while still keeping the
+Package available as open source and free software.
+
+You are always permitted to make arrangements wholly outside of this
+license directly with the Copyright Holder of a given Package.  If the
+terms of this license do not permit the full use that you propose to
+make of the Package, you should contact the Copyright Holder and seek
+a different licensing arrangement.
+
+Definitions
+
+    "Copyright Holder" means the individual(s) or organization(s)
+    named in the copyright notice for the entire Package.
+
+    "Contributor" means any party that has contributed code or other
+    material to the Package, in accordance with the Copyright Holder's
+    procedures.
+
+    "You" and "your" means any person who would like to copy,
+    distribute, or modify the Package.
+
+    "Package" means the collection of files distributed by the
+    Copyright Holder, and derivatives of that collection and/or of
+    those files. A given Package may consist of either the Standard
+    Version, or a Modified Version.
+
+    "Distribute" means providing a copy of the Package or making it
+    accessible to anyone else, or in the case of a company or
+    organization, to others outside of your company or organization.
+
+    "Distributor Fee" means any fee that you charge for Distributing
+    this Package or providing support for this Package to another
+    party.  It does not mean licensing fees.
+
+    "Standard Version" refers to the Package if it has not been
+    modified, or has been modified only in ways explicitly requested
+    by the Copyright Holder.
+
+    "Modified Version" means the Package, if it has been changed, and
+    such changes were not explicitly requested by the Copyright
+    Holder.
+
+    "Original License" means this Artistic License as Distributed with
+    the Standard Version of the Package, in its current version or as
+    it may be modified by The Perl Foundation in the future.
+
+    "Source" form means the source code, documentation source, and
+    configuration files for the Package.
+
+    "Compiled" form means the compiled bytecode, object code, binary,
+    or any other form resulting from mechanical transformation or
+    translation of the Source form.
+
+
+Permission for Use and Modification Without Distribution
+
+(1)  You are permitted to use the Standard Version and create and use
+Modified Versions for any purpose without restriction, provided that
+you do not Distribute the Modified Version.
+
+
+Permissions for Redistribution of the Standard Version
+
+(2)  You may Distribute verbatim copies of the Source form of the
+Standard Version of this Package in any medium without restriction,
+either gratis or for a Distributor Fee, provided that you duplicate
+all of the original copyright notices and associated disclaimers.  At
+your discretion, such verbatim copies may or may not include a
+Compiled form of the Package.
+
+(3)  You may apply any bug fixes, portability changes, and other
+modifications made available from the Copyright Holder.  The resulting
+Package will still be considered the Standard Version, and as such
+will be subject to the Original License.
+
+
+Distribution of Modified Versions of the Package as Source
+
+(4)  You may Distribute your Modified Version as Source (either gratis
+or for a Distributor Fee, and with or without a Compiled form of the
+Modified Version) provided that you clearly document how it differs
+from the Standard Version, including, but not limited to, documenting
+any non-standard features, executables, or modules, and provided that
+you do at least ONE of the following:
+
+    (a)  make the Modified Version available to the Copyright Holder
+    of the Standard Version, under the Original License, so that the
+    Copyright Holder may include your modifications in the Standard
+    Version.
+
+    (b)  ensure that installation of your Modified Version does not
+    prevent the user installing or running the Standard Version. In
+    addition, the Modified Version must bear a name that is different
+    from the name of the Standard Version.
+
+    (c)  allow anyone who receives a copy of the Modified Version to
+    make the Source form of the Modified Version available to others
+    under
+
+    (i)  the Original License or
+
+    (ii)  a license that permits the licensee to freely copy,
+    modify and redistribute the Modified Version using the same
+    licensing terms that apply to the copy that the licensee
+    received, and requires that the Source form of the Modified
+    Version, and of any works derived from it, be made freely
+    available in that license fees are prohibited but Distributor
+    Fees are allowed.
+
+
+Distribution of Compiled Forms of the Standard Version
+or Modified Versions without the Source
+
+(5)  You may Distribute Compiled forms of the Standard Version without
+the Source, provided that you include complete instructions on how to
+get the Source of the Standard Version.  Such instructions must be
+valid at the time of your distribution.  If these instructions, at any
+time while you are carrying out such distribution, become invalid, you
+must provide new instructions on demand or cease further distribution.
+If you provide valid instructions or cease distribution within thirty
+days after you become aware that the instructions are invalid, then
+you do not forfeit any of your rights under this license.
+
+(6)  You may Distribute a Modified Version in Compiled form without
+the Source, provided that you comply with Section 4 with respect to
+the Source of the Modified Version.
+
+
+Aggregating or Linking the Package
+
+(7)  You may aggregate the Package (either the Standard Version or
+Modified Version) with other packages and Distribute the resulting
+aggregation provided that you do not charge a licensing fee for the
+Package.  Distributor Fees are permitted, and licensing fees for other
+components in the aggregation are permitted. The terms of this license
+apply to the use and Distribution of the Standard or Modified Versions
+as included in the aggregation.
+
+(8) You are permitted to link Modified and Standard Versions with
+other works, to embed the Package in a larger work of your own, or to
+build stand-alone binary or bytecode versions of applications that
+include the Package, and Distribute the result without restriction,
+provided the result does not expose a direct interface to the Package.
+
+
+Items That are Not Considered Part of a Modified Version
+
+(9) Works (including, but not limited to, modules and scripts) that
+merely extend or make use of the Package, do not, by themselves, cause
+the Package to be a Modified Version.  In addition, such works are not
+considered parts of the Package itself, and are not subject to the
+terms of this license.
+
+
+General Provisions
+
+(10)  Any use, modification, and distribution of the Standard or
+Modified Versions is governed by this Artistic License. By using,
+modifying or distributing the Package, you accept this license. Do not
+use, modify, or distribute the Package, if you do not accept this
+license.
+
+(11)  If your Modified Version has been derived from a Modified
+Version made by someone other than you, you are nevertheless required
+to ensure that your Modified Version complies with the requirements of
+this license.
+
+(12)  This license does not grant you the right to use any trademark,
+service mark, tradename, or logo of the Copyright Holder.
+
+(13)  This license includes the non-exclusive, worldwide,
+free-of-charge patent license to make, have made, use, offer to sell,
+sell, import and otherwise transfer the Package with respect to any
+patent claims licensable by the Copyright Holder that are necessarily
+infringed by the Package. If you institute patent litigation
+(including a cross-claim or counterclaim) against any party alleging
+that the Package constitutes direct or contributory patent
+infringement, then this Artistic License to you shall terminate on the
+date that such litigation is filed.
+
+(14)  Disclaimer of Warranty:
+THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS
+IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
+NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL
+LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL
+BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,100 @@
+[![Code Climate](https://codeclimate.com/github/lmrodriguezr/gfa/badges/gpa.svg)](https://codeclimate.com/github/lmrodriguezr/gfa)
+[![Test Coverage](https://codeclimate.com/github/lmrodriguezr/gfa/badges/coverage.svg)](https://codeclimate.com/github/lmrodriguezr/gfa/coverage)
+[![Build Status](https://travis-ci.org/lmrodriguezr/gfa.svg?branch=master)](https://travis-ci.org/lmrodriguezr/gfa)
+[![Gem Version](https://badge.fury.io/rb/gfa.svg)](https://badge.fury.io/rb/gfa)
+
+# Graphical Fragment Assembly (GFA) for Ruby
+
+This implementation follows the specifications of [GFA-spec][].
+
+
+## Parsing GFA
+
+To parse a file in GFA format:
+
+```ruby
+require "gfa"
+
+my_gfa = GFA.load("assembly.gfa")
+```
+
+To load GFA strings line-by-line:
+
+```ruby
+require "gfa"
+
+my_gfa = GFA.new
+fh = File.open("assembly.gfa", "r")
+fh.each do |ln|
+   my_gfa << ln
+end
+fh.close
+```
+
+
+## Saving GFA
+
+After altering a GFA object, you can simply save it in a file as:
+
+```ruby
+my_gfa.save("alt-assembly.gfa")
+```
+
+Or line-by-line as:
+
+```ruby
+fh = File.open("alt-assembly.gfa", "w")
+my_gfa.each_line do |ln|
+   fh.puts ln
+end
+fh.close
+```
+
+
+## Visualizing GFA
+
+Any `GFA` object can be exported as an [`RGL`][rgl] graph using the methods
+`adjacency_graph` and `implicit_graph`. For example, you can render
+[tiny.gfa](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.gfa):
+
+```ruby
+require "gfa"
+require "rgl/dot"
+
+my_gfa = GFA.load("data/tiny.gfa")
+dg = my_gfa.implicit_graph
+dg.write_to_graphic_file("jpg")
+```
+
+![tiny_dg](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.jpg)
+
+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")
+```
+
+![tiny_ug](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny_undirected.jpg)
+
+
+# Installation
+
+```
+gem install gfa
+```
+
+
+# Author
+
+[Luis M. Rodriguez-R][lrr].
+
+
+# License
+
+[Artistic License 2.0](LICENSE).
+
+[GFA-spec]: https://github.com/pmelsted/GFA-spec
+[lrr]: http://lmrodriguezr.github.io/
+[rgl]: https://github.com/monora/rgl

data/Rakefile

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

data/lib/gfa.rb

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

data/lib/gfa/common.rb

@@ -0,0 +1,45 @@
+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?
+   
+end

data/lib/gfa/field.rb

@@ -0,0 +1,49 @@
+class GFA::Field
+  
+  # Class-level
+
+  CODES = {
+    :A => :Char,
+    :i => :SigInt,
+    :f => :Float,
+    :Z => :String,
+    :H => :Hex,
+    :B => :NumArray
+  }
+  TYPES = CODES.values
+
+  TYPES.each { |t| require "gfa/field/#{t.downcase}" }
+
+  [:CODES, :TYPES].each do |x|
+    define_singleton_method(x) { const_get(x) }
+  end
+  
+  def self.code_class(code)
+    name = CODES[code.to_sym]
+    raise "Unknown field type: #{code}." if name.nil?
+    name_class(name)
+  end
+
+  def self.name_class(name)
+    const_get(name)
+  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)
+    "#{"#{code}:" if with_type}#{value}"
+  end
+   
+  def hash
+    value.hash
+  end
+
+end

data/lib/gfa/field/char.rb

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

data/lib/gfa/field/float.rb

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

data/lib/gfa/field/hex.rb

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

data/lib/gfa/field/numarray.rb

@@ -0,0 +1,16 @@
+class GFA::Field::NumArray < GFA::Field
+  CODE = :B
+  REGEX = /^[cCsSiIf](,[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+$/
+
+  def initialize(f)
+    GFA.assert_format(f, regex, "Bad #{type}")
+    @value = f
+  end
+
+  def modifier ; value[0] ; end
+
+  def array ; value[2..-1].split(/,/) ; end
+  
+  alias as_a array
+
+end

data/lib/gfa/field/sigint.rb

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,10 @@
+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/generator.rb

@@ -0,0 +1,31 @@
+class GFA
+   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.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

data/lib/gfa/graph.rb

@@ -0,0 +1,100 @@
+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:
+  #
+  # * :orient => bool. If false, ignores strandness of the links. By default
+  #   true.
+  # * :directed => bool. If false, ignores direction of the links. By defaut
+  #   the same value as :orient.
+  def implicit_graph(opts={})
+    rgl_implicit_graph(opts)
+  end
+
+  ##
+  # 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={})
+    implicit_graph(opts).to_adjacency
+  end
+   
+  private
+   
+    def segment_names_with_orient
+      segments.flat_map do |s|
+        %w[+ -].map{ |orient| GFA::GraphVertex.idx(s, orient) }
+      end.to_set
+    end
+
+    def segment_names
+      segments.map do |s|
+        GFA::GraphVertex.idx(s, nil)
+      end.to_set
+    end
+
+    def rgl_implicit_graph(opts)
+      opts = rgl_implicit_options(opts)
+      RGL::ImplicitGraph.new do |g|
+        g.vertex_iterator do |b|
+          (opts[:orient] ? segment_names_with_orient :
+                  segment_names).each(&b)
+        end
+        g.adjacent_iterator do |x,b|
+          rgl_implicit_adjacent_iterator(x,b,opts)
+        end
+        g.directed = opts[:directed]
+      end
+    end
+
+    def rgl_implicit_options(opts)
+      opts[:orient] = true if opts[:orient].nil?
+      opts[:directed] = opts[:orient] if opts[:directed].nil?
+      opts
+    end
+
+    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
+          b.call(GFA::GraphVertex.idx(l.to, orient))
+        elsif opts[:orient] and 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
+
+end
+
+
+class GFA::GraphVertex # :nodoc:
+   
+  # Class-level
+  @@idx = {}
+  def self.idx(segment, orient)
+    n = GFA::GraphVertex.new(segment, orient)
+    @@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
+    @orient  = orient.is_a?(GFA::Field) ? orient.value : orient
+  end
+
+  def to_s
+    "#{segment}#{orient}"
+  end
+
+end

data/lib/gfa/parser.rb

@@ -0,0 +1,45 @@
+require "gfa/record"
+
+class GFA
+  # Class-level
+  MIN_VERSION = "1.0"
+  MAX_VERSION = "1.0"
+   
+  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? or obj.empty?
+    @records[obj.type] << obj
+    if obj.type==:Header and not 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
+  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.rb

@@ -0,0 +1,90 @@
+class GFA::Record
+  
+  # Class-level
+
+  CODES = {
+    :H => :Header,
+    :S => :Segment,
+    :L => :Link,
+    :C => :Containment,
+    :P => :Path
+  }
+  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) or
+        raise "Cannot parse field: '#{f}'."
+      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
+      add_field(f_tag, f_type, f_value)
+    end
+
+end

data/lib/gfa/record/containment.rb

@@ -0,0 +1,24 @@
+class GFA::Record::Containment < GFA::Record
+  CODE = :C
+  REQ_FIELDS = [:from, :from_orient, :to, :to_orient, :pos, :overlap]
+  OPT_FIELDS = {
+    :RC => :i,
+    :NM => :i
+  }
+
+  REQ_FIELDS.each_index do |i|
+    define_method(REQ_FIELDS[i]) { fields[i+2] }
+  end
+   
+  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,13 @@
+class GFA::Record::Header < GFA::Record
+   CODE = :H
+   REQ_FIELDS = []
+   OPT_FIELDS = {
+      :VN => :Z
+   }
+   
+   def initialize(*opt_fields)
+      @fields = {}
+      opt_fields.each{ |f| add_opt_field(f, OPT_FIELDS) }
+   end
+
+end

data/lib/gfa/record/link.rb

@@ -0,0 +1,50 @@
+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
+   }
+   
+   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 and
+            (orient.nil? or 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,18 @@
+class GFA::Record::Path < GFA::Record
+   CODE = :P
+   REQ_FIELDS = [:path_name, :segment_name, :cigar]
+   OPT_FIELDS = {}
+
+   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
+
+end

data/lib/gfa/record/segment.rb

@@ -0,0 +1,22 @@
+class GFA::Record::Segment < GFA::Record
+   CODE = :S
+   REQ_FIELDS = [:name, :sequence]
+   OPT_FIELDS = {
+      :LN => :i,
+      :RC => :i,
+      :FC => :i,
+      :KC => :i
+   }
+
+   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/version.rb

@@ -0,0 +1,7 @@
+class GFA
+  VERSION       = "0.1.2"
+  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/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("1.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 "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require "rubygems"
+require "test/unit"
+require "gfa/common"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gfa
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
@@ -56,13 +56,48 @@ description: GFA is a graph representation of fragment assemblies
 email: lmrodriguezr@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
-files: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/gfa/common.rb
+- lib/gfa/field/char.rb
+- lib/gfa/field/float.rb
+- lib/gfa/field/hex.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/containment.rb
+- lib/gfa/record/header.rb
+- lib/gfa/record/link.rb
+- lib/gfa/record/path.rb
+- lib/gfa/record/segment.rb
+- lib/gfa/record.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: 
-rdoc_options: []
+rdoc_options:
+- lib
+- README.md
+- --main
+- README.md
+- --title
+- Graphical Fragment Assembly (GFA) for Ruby
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement