gfa 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cde4a3e432409c7a2967832dcebd502ddc54b1f6cb25856b6d9d21ce53f67b32
-  data.tar.gz: 91213d63365dd3608c28e30115cbfc8621e78bbe34936832bcee2ac7e6f460fb
+  metadata.gz: 97e6400338884b4ceb1161778c26c5d6de6ee71616be1b5caae6aa0691d88395
+  data.tar.gz: 2fe8103598246724d98e3ceeecce92b5564f45bf029bf034978277cde59b4caa
 SHA512:
-  metadata.gz: 321634c28ec8927bd38286a84a02783b9f915dcbabb7941233583dda7f41b66e952ff9611c9158bd7baca09d7d3d6c254a036f1c9f2169e5e24e6e964d292e71
-  data.tar.gz: 3698d16ab5953ffd70bf2c102d154bc1f61e5a13a752bc317a756df13762c3668c1bf6e8144821e53e395783f36c45185249c7fc206694be19145200310c3f48
+  metadata.gz: 3beac70ac4c3d4e46bd01399351fbc5e5ffcdaac5bd2a653b7f17c8f29df5c13e48a11575c42fa0ec78cba62485528148687614e9373ac6cc5dd773f97cd67a6
+  data.tar.gz: c488a4b26604ffc95228d5aa454399b4da8facecb9a90c2579be3c36446637bc60b89578c5a5443047ac020c4c9fb9b980fd3943fdb56e7993ebfcc7c4e60876

data/README.md

@@ -7,28 +7,35 @@
 
 This implementation follows the specifications of [GFA-spec][].
 
+To load the library:
+
+```ruby
+require 'gfa'
+```
 
 ## 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:
+For large GFA files, you can also parse them in parallel:
 
 ```ruby
-require 'gfa'
+my_gfa = GFA.load_parallel('large-graph.gfa', 4)
+```
+
+To load GFA strings line-by-line:
 
+```ruby
 my_gfa = GFA.new
-fh = File.open('assembly.gfa', 'r')
-fh.each do |ln|
-  my_gfa << ln
+File.open('assembly.gfa', 'r') do |fh|
+  fh.each do |ln|
+    my_gfa << ln
+  end
 end
-fh.close
 ```
 
 
@@ -58,12 +65,11 @@ Any `GFA` object can be exported as an [`RGL`][rgl] graph using the methods
 [tiny.gfa](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.gfa):
 
 ```ruby
-require "gfa"
-require "rgl/dot"
+require 'rgl/dot'
 
-my_gfa = GFA.load("data/tiny.gfa")
+my_gfa = GFA.load('data/tiny.gfa')
 dg = my_gfa.implicit_graph
-dg.write_to_graphic_file("jpg")
+dg.write_to_graphic_file('jpg')
 ```
 
 ![tiny_dg](https://github.com/lmrodriguezr/gfa/raw/master/data/tiny.jpg)
@@ -72,8 +78,8 @@ 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")
+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)
@@ -88,11 +94,9 @@ gem install gfa
 Or add the following line to your Gemfile:
 
 ```ruby
-gem "gfa"
+gem 'gfa'
 ```
 
-and run `bundle install` from your shell.
-
 
 # Author
 
@@ -103,6 +107,6 @@ and run `bundle install` from your shell.
 
 [Artistic License 2.0](LICENSE).
 
-[GFA-spec]: https://github.com/pmelsted/GFA-spec
+[GFA-spec]: https://github.com/GFA-spec/GFA-spec
 [lrr]: https://rodriguez-r.com/
 [rgl]: https://github.com/monora/rgl

data/bin/gfa-add-gaf

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+
+# @package MiGA
+# @license Artistic-2.0
+
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../../lib', File.realpath(__FILE__))
+
+require 'gfa'
+
+input_gfa, input_gaf, output, degree, threads = ARGV
+
+unless degree
+  $stderr.puts <<~HELP
+    gfa-add-gaf <input-gfa> <input-gaf> <output> <degree> [<pref> [<threads>]]
+
+    <input-gfa>  Input GFA file to read
+    <input-gaf>  Input GAF file to read
+    <output>     Output GFA file to write
+    <degree>     Maximum degree of separation between the segment set in the GAF
+                 and any other included segments. If 0, only segments are
+                 included. If 1, only the target segments, records linking to
+                 them, and segments linked by those records. Any integer > 1
+                 includes additional expansion rounds for those linked segments.
+                 Use -1 to include the complete original GAF without subsetting.
+    <pref>       A prefix to name all recorded paths
+                 By default: Based on the GAF file name
+    <threads>    If passed, parallelize process with these many threads
+  HELP
+  exit(1)
+end
+
+$stderr.puts "Loading GFA: #{input_gfa}"
+gfa = GFA.load_parallel(input_gfa, (threads || 1).to_i)
+
+$stderr.puts "Loading GAF: #{input_gaf}"
+$stderr.puts "- Minimum identity: #{0.95}"
+pref ||= File.basename(input_gaf, '.gaf').gsub(/[^!-)+-<>-~]/, '_')
+segments  = []
+File.open(input_gaf, 'r') do |fh|
+  fh.each do |ln|
+    row = ln.chomp.split("\t")
+    opt = Hash[row[12..].map { |i| i.split(':', 2) }]
+    opt.each { |k, v| opt[k] = GFA::Field[v] }
+    next if opt['id'] && opt['id'].value < 0.95
+
+    gaf_path = row[5]
+    seg_names = []
+    gaf_path.scan(/[><]?[^><]+/).each do |seg|
+      seg_orient = seg.match?(/^</) ? '-' : '+'
+      seg_name   = seg.sub(/^[><]/, '')
+      seg_names << "#{seg_name}#{seg_orient}"
+      segments << seg_name unless segments.include?(seg_name)
+    end
+    gfa << GFA::Record::Path.new(
+      "#{pref}_#{$.}", seg_names.join(','), opt['cg']&.value || '*'
+    )
+  end
+end
+$stderr.puts "- Found #{segments.size} linked segments"
+
+degree = degree.to_i
+if degree >= 0
+  $stderr.puts 'Subsetting graph'
+  gfa = gfa.subgraph(segments, degree: degree)
+end
+
+$stderr.puts "Saving GFA: #{output}"
+gfa.save(output)
+

data/bin/gfa-subgraph

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+# @package MiGA
+# @license Artistic-2.0
+
+$LOAD_PATH.push File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('../../lib', File.realpath(__FILE__))
+
+require 'gfa'
+
+input, output, degree, segments, threads = ARGV
+
+unless segments
+  $stderr.puts <<~HELP
+    Select a set of segments and include only elements of the GFA linked to
+    those segments (directly or indirectly)
+
+    gfa-subgraph <input> <output> <degree> <segments> [<threads>]
+
+    <input>      Input GFA file to read
+    <output>     Output GFA file to write
+    <degree>     Maximum degree of separation between the segment set and any
+                 other included segments. If 0, only segments are included.
+                 If 1, only the target segments, records linking to them, and
+                 segments linked by those records. Any integer > 1 includes
+                 additional expansion rounds for those linked segments.
+    <segments>   Comma-delimited list of segment segments
+    <threads>    If passed, parallelize process with these many threads
+  HELP
+  exit(1)
+end
+
+$stderr.puts "Loading GFA: #{input}"
+gfa = GFA.load_parallel(input, (threads || 1).to_i)
+
+$stderr.puts 'Subsetting graph'
+gfa = gfa.subgraph(segments.split(','), degree: degree.to_i)
+
+$stderr.puts "Saving GFA: #{output}"
+gfa.save(output)
+

data/lib/gfa/common.rb

@@ -1,30 +1,33 @@
 require 'gfa/version'
-require 'gfa/record'
+require 'gfa/record_set'
 require 'gfa/field'
 
 class GFA
   # Class-level
   def self.assert_format(value, regex, message)
-    unless value =~ regex
-      raise "#{message}: #{value}."
+    unless value =~ /^(?:#{regex})$/
+      raise "#{message}: #{value}"
     end
   end
 
   # Instance-level
-  attr :gfa_version, :records
+  attr :gfa_version, :records, :opts
 
   GFA::Record.TYPES.each do |r_type|
-    plural = "#{r_type.downcase}s"
     singular = "#{r_type.downcase}"
+    plural = "#{singular}s"
 
     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
+  def initialize(opts = {})
     @records = {}
-    GFA::Record.TYPES.each { |t| @records[t] = [] }
+    @opts = { index: true, index_id: false, comments: false }.merge(opts)
+    GFA::Record.TYPES.each do |t|
+      @records[t] = GFA::RecordSet.name_class(t).new(self)
+    end
   end
 
   def empty?
@@ -35,5 +38,27 @@ class GFA
     records == gfa.records
   end
 
-  alias == eql?
+  def ==(gfa)
+    eql?(gfa)
+  end
+
+  def size
+    records.values.map(&:size).inject(0, :+)
+  end
+
+  def merge!(gfa)
+    raise "Unsupported object: #{gfa}" unless gfa.is_a? GFA
+
+    GFA::Record.TYPES.each do |t|
+      @records[t].merge!(gfa.records[t])
+    end
+  end
+
+  def indexed?
+    records.values.all?(&:indexed?)
+  end
+
+  def rebuild_index!
+    @records.each_value(&:rebuild_index!)
+  end
 end

data/lib/gfa/field/char.rb

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

data/lib/gfa/field/float.rb

@@ -1,9 +1,26 @@
 class GFA::Field::Float < GFA::Field
   CODE = :f
-  REGEX = /^[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?$/
+  REGEX = /[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/
+  NATIVE_FUN = :to_f
+
+  def to_f
+    value
+  end
+
+  def to_i
+    value.to_i
+  end
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_f
   end
+
+  def equivalent?(field)
+    if field.is_a?(GFA::Field::NumArray)
+      return field.size == 1 && field.first.to_f == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/hex.rb

@@ -1,9 +1,26 @@
 class GFA::Field::Hex < GFA::Field
   CODE = :H
-  REGEX = /^[0-9A-F]+$/
+  REGEX = /[0-9A-F]+/
+  NATIVE_FUN = :to_i
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
+
+  def to_i
+    value.to_i(16)
+  end
+
+  def to_f
+    to_i.to_f
+  end
+
+  def equivalent?(field)
+    if field.is_a? GFA::Field::NumArray
+      return field.size == 1 && field.first.to_i == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/json.rb

@@ -1,9 +1,18 @@
 class GFA::Field::Json < GFA::Field
   CODE = :J
-  REGEX = /^[ !-~]+$/
+  REGEX = /[ !-~]+/
+  NATIVE_FUN = :to_s
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
+
+  def equivalent?(field)
+    # TODO
+    # We should parse the contents when comparing two GFA::Field::Json to
+    # evaluate equivalencies such as 'J:{ "a" : 1 }' ~ 'J:{"a":1}' (spaces)
+    # or 'J:{"a":1,"b":2}' ~ 'J:{"b":2,"a":1}' (element order)
+    super
+  end
 end

data/lib/gfa/field/numarray.rb

@@ -1,17 +1,30 @@
 class GFA::Field::NumArray < GFA::Field
   CODE = :B
-  REGEX = /^[cCsSiIf](,[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+$/
+  REGEX = /[cCsSiIf](,[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?)+/
+  NATIVE_FUN = :to_a
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f
   end
 
-  def modifier ; value[0] ; end
+  def modifier
+    value[0]
+  end
 
-  def array ; value[2..-1].split(/,/) ; end
+  def modifier_fun
+    modifier == 'f' ? :to_f : :to_i
+  end
 
-  alias as_a array
+  def array
+    @array ||= value[2..-1].split(',').map(&modifier_fun)
+  end
+
+  alias to_a array
+
+  %i[empty? size count length first last].each do |i|
+    define_method(i) { array.send(i) }
+  end
 
   def number_type
     {
@@ -21,4 +34,16 @@ class GFA::Field::NumArray < GFA::Field
       f: 'float'
     }[modifier.to_sym]
   end
+
+  def equivalent?(field)
+    return true if eql?(field)
+
+    if field.respond_to?(:to_a)
+      field.to_a.map(&modifier_fun) == array
+    elsif size == 1 && field.respond_to?(modifier_fun)
+      field.send(modifier_fun) == first
+    else
+      false
+    end
+  end
 end

data/lib/gfa/field/sigint.rb

@@ -1,9 +1,22 @@
 class GFA::Field::SigInt < GFA::Field
   CODE = :i
-  REGEX = /^[-+]?[0-9]+$/
+  REGEX = /[-+]?[0-9]+/
+  NATIVE_FUN = :to_i
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")
     @value = f.to_i
   end
+
+  def to_i
+    value
+  end
+
+  def equivalent?(field)
+    if field.is_a?(GFA::Field::NumArray)
+      return field.size == 1 && field.first.to_i == value
+    end
+
+    super
+  end
 end

data/lib/gfa/field/string.rb

@@ -1,6 +1,15 @@
 class GFA::Field::String < GFA::Field
   CODE = :Z
-  REGEX = /^[ !-~]+$/
+  REGEX = /[ !-~]+/
+  NATIVE_FUN = :to_s
+
+  def to_f
+    value.to_f
+  end
+
+  def to_i(base = 10)
+    value.to_i(base)
+  end
 
   def initialize(f)
     GFA.assert_format(f, regex, "Bad #{type}")

data/lib/gfa/field.rb

@@ -12,7 +12,7 @@ class GFA::Field
   TYPES = CODES.values
   TYPES.each { |t| require "gfa/field/#{t.downcase}" }
 
-  [:CODES, :TYPES].each do |x|
+  %i[CODES TYPES].each do |x|
     define_singleton_method(x) { const_get(x) }
   end
   
@@ -25,23 +25,95 @@ class GFA::Field
   def self.name_class(name)
     const_get(name)
   end
-   
+
+  def self.[](string)
+    code, value = string.split(':', 2)
+    code_class(code).new(value)
+  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)
+  def type
+    CODES[code]
+  end
+
+  def code
+    self.class::CODE
+  end
+
+  def regex
+    self.class::REGEX
+  end
+
+  def native_fun
+    self.class::NATIVE_FUN
+  end
+
+  def to_native
+    native_fun == :to_s ? to_s(false) : send(native_fun)
+  end
+
+  def to_s(with_type = true)
     "#{"#{code}:" if with_type}#{value}"
   end
-   
+
   def hash
     value.hash
   end
 
+  ##
+  # Evaluate equivalency of contents. All the following fields are distinct but
+  # contain the same information, and are therefore considered equivalent:
+  # Z:123, i:123, f:123.0, B:i,123, H:7b
+  #
+  # Note that the information content is determined by the class of the first
+  # operator. For example:
+  # - 'i:123' ~ 'f:123.4' is true because values are compared as integers
+  # - 'f:123.4' ~ 'i:123' if false because values are compared as floats
+  def equivalent?(field)
+    return true if eql?(field) # Might be faster, so testing this first
+
+    if field.respond_to?(native_fun)
+      if field.is_a?(GFA::Field) && native_fun == :to_s
+        field.to_s(false) == to_native
+      else
+        field.send(native_fun) == to_native
+      end
+    else
+      field == value
+    end
+  end
+
+  ##
+  # Non-equivalent to +field+, same as +!equivalent?+
+  def !~(field)
+    !self.~(field)
+  end
+
+  ##
+  # Same as +equivalent?+
+  def ~(field)
+    equivalent?(field)
+  end
+
+  ##
+  # Evaluate equality. Note that fields with equivalent values evaluate as
+  # different. For example, the following fields have equivalent information,
+  # but they all evaluate as different: Z:123, i:123, f:123.0, B:i,123, H:7b.
+  # To test equivalency of contents instead, use +equivalent?+
+  def eql?(field)
+    if field.is_a?(GFA::Field)
+      type == field.type && value == field.value
+    else
+      field.is_a?(value.class) && value == field
+    end
+  end
+
+  ##
+  # Same as +eql?+
+  def ==(field)
+    eql?(field)
+  end
 end

data/lib/gfa/generator.rb

@@ -8,9 +8,9 @@ class GFA
   end
 
   def each_line(&blk)
-    set_version_header('1.1') if gfa_version.nil?
+    set_version_header('1.2') if gfa_version.nil?
     GFA::Record.TYPES.each do |r_type|
-      records[r_type].each do |record|
+      records[r_type].set.each do |record|
         blk[record.to_s]
       end
     end
@@ -23,7 +23,7 @@ class GFA
   end
 
   def unset_version
-    @records[:Header].delete_if { |o| !o.fields[:VN].nil? }
+    headers.set.delete_if { |o| !o.fields[:VN].nil? }
     @gfa_version = nil
   end