gfa 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d8694c80555e4fae39fb77a245428ec8e7ce19a2
-  data.tar.gz: ab29f1249a26d28082e0380fc96edec934acb0e5
+SHA256:
+  metadata.gz: cde4a3e432409c7a2967832dcebd502ddc54b1f6cb25856b6d9d21ce53f67b32
+  data.tar.gz: 91213d63365dd3608c28e30115cbfc8621e78bbe34936832bcee2ac7e6f460fb
 SHA512:
-  metadata.gz: fe2d1bb08aeaca8cb0b3d588a6b02965ec612d6201bf19b96927df9a2f18b4c2974829a6f9b6da608fae5ac8fd4f9c62b2acd3c8d29718ec2251afdb08ceccba
-  data.tar.gz: c5ce23b34bc1b890e8d9c7de19a1f4cd0a2766897530b9e2563f667d5d81017b5c1245fd39bb52db3f3960513fb47670210df39124c556753874e01feeac03c0
+  metadata.gz: 321634c28ec8927bd38286a84a02783b9f915dcbabb7941233583dda7f41b66e952ff9611c9158bd7baca09d7d3d6c254a036f1c9f2169e5e24e6e964d292e71
+  data.tar.gz: 3698d16ab5953ffd70bf2c102d154bc1f61e5a13a752bc317a756df13762c3668c1bf6e8144821e53e395783f36c45185249c7fc206694be19145200310c3f48

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,201 @@
+                    The Artistic License 2.0
+
+           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.
+
+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,108 @@
+[![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
+```
+
+Or add the following line to your Gemfile:
+
+```ruby
+gem "gfa"
+```
+
+and run `bundle install` from your shell.
+
+
+# Author
+
+[Luis M. Rodriguez-R][lrr].
+
+
+# License
+
+[Artistic License 2.0](LICENSE).
+
+[GFA-spec]: https://github.com/pmelsted/GFA-spec
+[lrr]: https://rodriguez-r.com/
+[rgl]: https://github.com/monora/rgl

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler/gem_tasks'
+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/common.rb

@@ -0,0 +1,39 @@
+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) { 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

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

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

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

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

@@ -0,0 +1,47 @@
+class GFA::Field
+  # Class-level
+  CODES = {
+    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|
+    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/generator.rb

@@ -0,0 +1,35 @@
+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.1') 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| !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,99 @@
+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] && 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