gfa 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e8e61ff97b34654b7a660b011826ad5549f66933a91a09658facf58c3fd56b1
-  data.tar.gz: 8f85f07955e71cd38a9dfa28011c70433473ad6a1137ed3e6e217d63eeba20a8
+  metadata.gz: 9eaaaf8bcac372e7d6b63d96aee94493faa51d78f5cc2b7edb525c3fbd7efaa2
+  data.tar.gz: 950e9ffa9cd07cdea8ef5cc80b6c162bf009ff3bef5ab757dcda51c443925043
 SHA512:
-  metadata.gz: 5b9f8fd92cd30d9e4e5c0263e938169141749c7be43011b574f937c9645608d8e72189bfe9072d7321e3acdf7e8288cecf42c90abe3ceef2bf001780bdb3e472
-  data.tar.gz: ee33c0b9c0dc9adb2df96d95b792b060b248e2f991ed5a0e4b4c136d66f04b9be6cf5ca58462bce046c6cfd9e7fed6c4c6949cb5e8923eb71e3d5f53f0da2703
+  metadata.gz: 92e53b9d6c09b1814f3feda86b67dcea6192bd935e3c04dcca7b6ee9c0e7eed919c711941985313c2918f02772f3598883f037638e6e1b7cc9cf8897fec80caf
+  data.tar.gz: 4c14ce2bd91582b7b81bc6123443bd5b0cffe8c83550fb85dc48c8da030d35dafaf393506d537c5df7550b25b87ab10003a938c407bd6210983e5f8841552317

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,7 +65,6 @@ 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'
 
 my_gfa = GFA.load('data/tiny.gfa')
@@ -91,8 +97,6 @@ Or add the following line to your Gemfile:
 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-greedy-modules

@@ -0,0 +1,50 @@
+#!/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, base, min_len, threads = ARGV
+
+unless base
+  $stderr.puts <<~HELP
+    Split a GFA into multiple independent GFA files that have no links between
+    them by greedily identifying all individual modules in the graph
+
+    gfa-greedy-modules <input> <base> [<min_len> [<threads>]]
+
+    <input>      Input GFA file to read
+    <base>       Prefix of the output GFA files to write
+    <min_len>    Minimum length (in bp) to report a module
+                 By default: 0 (all modules are reported)
+    <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 'Splitting graph into modules'
+gfas = gfa.split_modules
+
+min_len = min_len.to_i
+if min_len > 0
+  $stderr.puts 'Filtering out small modules'
+  gfas.select! { |gfa| gfa.total_length > min_len }
+end
+
+if gfas.empty?
+  $stderr.puts "No modules found"
+else
+  $stderr.puts "Saving #{gfas.size} GFA files: #{base}.*"
+  int_len = Math.log10(gfas.size).ceil
+  gfas.each_with_index do |gfa, k|
+    gfa.save("%s.%0#{int_len}i.gfa" % [base, k])
+  end
+end
+

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

@@ -14,8 +14,8 @@ class GFA
   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] }
@@ -24,7 +24,7 @@ class GFA
 
   def initialize(opts = {})
     @records = {}
-    @opts = { index: true, comments: false }.merge(opts)
+    @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
@@ -38,5 +38,33 @@ 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
+
+  ##
+  # Computes the sum of all individual segment lengths
+  def total_length
+    segments.total_length
+  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
 

data/lib/gfa/graph.rb

@@ -21,9 +21,145 @@ class GFA
   def adjacency_graph(opts = {})
     implicit_graph(opts).to_adjacency
   end
-   
+
+  ##
+  # Extracts the subset of records associated to +segments+, which is an Array
+  # with values of any class in: Integer (segment index),
+  # String or GFA::Field::String (segment names), or GFA::Record::Segment.
+  #
+  # +degree+ indicates the maximum degree of separation between the original
+  # segment set and any additional segments. Use 0 to include only the segments
+  # in the set. Use 1 to include those, the records linking to them, and the
+  # additional segments linked by those records. Use any integer greater than 1
+  # to prompt additional rounds of greedy graph expansion.
+  #
+  # If +headers+, it includes all the original headers. Otherwise it only
+  # only includes the version header (might be inferred).
+  #
+  # All comments are ignored even if originally parsed. Walks are currently
+  # ignored too. If the current GFA object doesn't have an index, it builds one
+  # and forces +index: true+. The output object inherits all options.
+  def subgraph(segments, degree: 1, headers: true)
+    # Prepare objects
+    unless opts[:index]
+      opts[:index] = true
+      rebuild_index!
+    end
+    gfa = GFA.new(opts)
+    segments =
+      segments.map do |i|
+        i.is_a?(GFA::Record::Segment) ? i :
+          segment(i) or raise "Cannot find segment: #{i}"
+      end
+
+    # Headers
+    if headers
+      self.headers.set.each { |record| gfa << record }
+    else
+      gfa << GFA::Record::Header.new("VN:Z:#{gfa_version}")
+    end
+
+    # Original segments
+    segments.each { |segment| gfa << segment }
+
+    # Expand graph
+    linking, edges = linking_records(gfa.segments, degree: degree)
+    linking += internally_linking_records(segments, edges)
+    linking.each { |record| gfa << record }
+
+    # Return
+    gfa
+  end
+
+  ##
+  # Finds all the records linking to any segments in +segments+, a
+  # GFA::RecordSet::SegmentSet object, and expands to links with up to
+  # +degree+ degrees of separation
+  #
+  # It only evaluates the edges given in the +edges+ Array of GFA::Record
+  # values. If +edges+ is +nil+, it uses the full set of edges in the gfa.
+  # Edge GFA::Record objects can be of type Link, Containment, Jump, or Path
+  #
+  # If +_ignore+ is passed, it ignores this number of segments at the beginning
+  # of the +segments+ set (assumes they have already been evaluated). This is
+  # only used for internal heuristics
+  #
+  # Returns an Array of with two elements:
+  # 0. An array of GFA::Record objects with all the identified linking records
+  # 1. An array of GFA::Record objects with all edges that were not identified
+  #
+  # IMPORTANT NOTE 1: The object +segments+ will be modified to include all
+  # linked segments. If you don't want this behaviour, please make sure to pass
+  # a duplicate of the object instead.
+  #
+  # IMPORTANT NOTE 2: The list of linking records may not comprehensively
+  # include all records linking the identified expanded segment set. To ensure
+  # a consistent set is identified, use:
+  # linking, edges = gfa.linking_records(segments)
+  # linking += gfa.internally_linking_records(segments, edges)
+  # 
+  def linking_records(segments, degree: 1, edges: nil, _ignore: 0)
+    unless segments.is_a? GFA::RecordSet::SegmentSet
+      raise "Unrecognised class: #{segments.class}"
+    end
+
+    # Gather edges to evaluate
+    edges ||= all_edges
+    return [[], edges] if degree <= 0
+
+    # Links, Containments, Jumps (from, to) and Paths (segment_names)
+    linking = []
+    eval_set = _ignore == 0 ? segments.set : segments.set[_ignore..]
+    edges.delete_if do |edge|
+      if eval_set.any? { |segment| edge.include? segment }
+        linking << edge
+        true  # Remove from the edge set to speed up future recursions
+      else
+        false # Keep it, possibly linking future recursions 
+      end
+    end
+
+    # Recurse and return
+    if degree >= 1
+      pre = segments.size
+
+      # Add additional linked segments
+      linking.each do |record|
+        record.segments(self).each do |other_seg|
+          segments << other_seg unless segments[other_seg.name]
+        end
+      end
+
+      # Recurse only if new segments were discovered
+      if segments.size > pre
+        $stderr.puts "- Recursion [#{degree}]: " \
+                     "#{pre} -> #{segments.size}\t(#{edges.size})"
+        linking +=
+          linking_records(
+            segments,
+            degree: degree - 1, edges: edges, _ignore: pre
+          )[0]
+      end
+    end
+    [linking, edges]
+  end
+
+  def internally_linking_records(segments, edges)
+    $stderr.puts '- Gathering internally linking records'
+    segments = Hash[segments.set.map { |i| [i.name.value, true]}]
+    edges.select { |record| record.segment_names_a.all? { |s| segments[s] } }
+  end
+
+  ##
+  # Returns an array of GFA::Record objects including all possible edges
+  # from the GFA. I.e., all links, jumps, containments, and paths.
+  def all_edges
+    edge_t = %i[Link Jump Containment Path]
+    edges = edge_t.flat_map { |t| records[t].set } if edges.nil?
+  end
+
   private
-   
+
     def segment_names_with_orient
       segments.flat_map do |s|
         %w[+ -].map { |orient| GFA::GraphVertex.idx(s, orient) }

data/lib/gfa/modules.rb

@@ -0,0 +1,96 @@
+
+class GFA
+  ##
+  # Find all independent modules by greedily crawling the linking entries for
+  # each segment, and returns an Array of GFA objects containing each individual
+  # module. If +recalculate+ is false, it trusts the current calculated
+  # matrix unless none exists
+  def split_modules(recalculate = true)
+    recalculate_matrix if recalculate || @matrix.nil?
+    missing_segments = (0 .. @matrix_segment_names.size - 1).to_a
+    modules = []
+    until missing_segments.empty?
+      mod = matrix_find_module(missing_segments[0])
+      mod.segments.set.map(&:name).map(&:value).each do |name|
+        missing_segments.delete(@matrix_segment_names.index(name))
+      end
+      modules << mod
+    end
+    modules
+  end
+
+  ##
+  # Finds the entire module containing the segment with index +segment_index+
+  # in the matrix (requires calling +recalculate_matrix+ first!). Returns the
+  # module as a new GFA
+  def matrix_find_module(segment_index)
+    # Initialize
+    segs = [segment_index]
+    edges = []
+    new_segs = true
+
+    # Iterate until no new segments are found
+    while new_segs
+      new_segs = false
+      segs.each do |seg|
+        @matrix.size.times do |k|
+          next if seg == k
+          v = @matrix[[seg, k].max][[seg, k].min]
+          next if v.empty?
+          edges += v
+          unless segs.include?(k)
+            new_segs = true
+            segs << k
+          end
+        end
+      end
+    end
+
+    # Save as GFA and return
+    o = GFA.new
+    segs.each { |k| o << segments[k] }
+    edges.uniq.each { |k| o << @matrix_edges[k] }
+    o
+  end
+
+  ##
+  # Calculates a matrix where all links between segments are represented by the
+  # following variables:
+  # 
+  # +@matrix_segment_names+ includes the names of all segments (as String) with
+  # the order indicating the segment index in the matrix
+  #
+  # +@matrix+ is an Array of Arrays of Arrays, where the first index indicates
+  # the row index segment, the second index indicates the column index segment,
+  # and the third index indicates each of the links between those two. Note that
+  # matrix only stores the lower triangle, so the row index must be stictly less
+  # than the column index. For example, +@matrix[3][1]+ returns an Array of all
+  # index links between the segment with index 3 and the segment with index 1:
+  # ```
+  # [
+  #   [             ], # Row 0 is always empty
+  #   [[]           ], # Row 1 stores connections to column 0
+  #   [[], []       ], # Row 2 stores connections to columns 0 and 1
+  #   [[], [], []   ], # Row 3 stores connections to columns 0, 1, and 2
+  #   ...              # &c
+  # ]
+  # ```
+  #
+  # +@matrix_edges+ is an Array of GFA::Record objects representing all edges in
+  # the GFA. The order indicates the index used by the values of +@matrix+
+  def recalculate_matrix
+    @matrix_segment_names = segments.set.map(&:name).map(&:value)
+    @matrix = @matrix_segment_names.size.times.map { |i| Array.new(i) { [] } }
+    @matrix_edges = all_edges
+    @matrix_edges.each_with_index do |edge, k|
+      names = edge.segments(self).map(&:name).map(&:value)
+      indices = names.map { |i| @matrix_segment_names.index(i) }
+      indices.each do |a|
+        indices.each do |b|
+          break if a == b
+          @matrix[[a, b].max][[a, b].min] << k
+        end
+      end
+    end
+  end
+end

data/lib/gfa/parser.rb

@@ -6,16 +6,74 @@ class GFA
   MAX_VERSION = '1.2'
 
   ##
-  # Load a GFA object from a +gfa+ file with options +opts+:
-  # - index: If the records should be indexed as loaded (default: true)
+  # Load a GFA object from a gfa +file+ with options +opts+:
+  # - index: If the  records should be indexed as loaded (default: true)
+  # - index_id: If the records should also be index by ID (default: false)
   # - comments: If the comment records should be saved (default: false)
+  # - line_range: Two-integer array indicating the first and last lines to read
+  #   (default: nil, read the entire file)
   def self.load(file, opts = {})
     gfa = GFA.new(opts)
-    fh = File.open(file, 'r')
-    fh.each { |ln| gfa << ln }
+    read_records(file, opts) do |record|
+      gfa << record
+    end
     gfa
-  ensure
-    fh&.close
+  end
+
+  def self.read_records(file, opts = {})
+    rng = opts[:line_range]
+    File.open(file, 'r') do |fh|
+      lno = -1
+      fh.each do |ln|
+        lno += 1
+        next if !rng.nil? && (lno < rng[0] || lno > rng[1])
+        next if !opts[:comments] && ln[0] == '#'
+
+        yield(GFA::Record[ln])
+      end
+    end
+  end
+
+  ##
+  # Load a GFA object from a gfa +file+ in parallel using +thr+ threads,
+  # and the same +opts+ supported by +load+. Defaults to the +load+ method
+  # instead if +thr <= 1+.
+  def self.load_parallel(file, thr, opts = {})
+    return self.load(file, opts) if thr <= 1
+
+    # Prepare data
+    lno = 0
+    File.open(file, 'r') { |fh| fh.each { lno += 1 } }
+    thr = lno if thr > lno
+    blk = (lno.to_f / thr).ceil
+
+    # Launch children processes
+    io  = []
+    pid = []
+    thr.times do |i|
+      io[i] = IO.pipe
+      pid << fork do
+        io[i][0].close
+        o = opts.merge(line_range: [i * blk, (i + 1) * blk - 1])
+        records = []
+        read_records(file, o) { |record| records << record }
+        Marshal.dump(records, io[i][1])
+        exit!(0)
+      end
+      io[i][1].close
+    end
+
+    # Collect and merge results
+    gfa = GFA.new(opts)
+    io.each_with_index do |pipe, k|
+      result = pipe[0].read
+      Process.wait(pid[k])
+      raise "Child process failed: #{k}" if result.empty?
+      Marshal.load(result).each { |record| gfa << record }
+      pipe[0].close
+    end
+
+    return gfa
   end
 
   def self.supported_version?(v)
@@ -24,7 +82,7 @@ class GFA
 
   # Instance-level
   def <<(obj)
-    obj = parse_line(obj) unless obj.is_a? GFA::Record
+    obj = GFA::Record[obj] unless obj.is_a? GFA::Record
     return if obj.nil? || obj.empty?
     @records[obj.type] << obj
 
@@ -41,14 +99,4 @@ class GFA
 
     @gfa_version = v
   end
-
-  private
-
-    def parse_line(string)
-      string = string.chomp
-      return nil if string =~ /^\s*$/
-      return nil if !opts[:comments] && string[0] == '#'
-
-      GFA::Record[string]
-    end
 end

data/lib/gfa/record/containment.rb

@@ -1,3 +1,5 @@
+require 'gfa/record/has_from_to'
+
 class GFA::Record::Containment < GFA::Record
   CODE = :C
   REQ_FIELDS = %i[from from_orient to to_orient pos overlap]
@@ -12,6 +14,8 @@ class GFA::Record::Containment < GFA::Record
   end
   OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
 
+  include GFA::Record::HasFromTo
+
   alias container from
   alias container_orient from_orient
   alias contained to

data/lib/gfa/record/has_from_to.rb

@@ -0,0 +1,47 @@
+module GFA::Record::HasFromTo
+  def from?(segment, orient = nil)
+    links_from_to?(segment, orient, true)
+  end
+
+  def to?(segment, orient = nil)
+    links_from_to?(segment, orient, false)
+  end
+
+  ##
+  # Extracts all linked segments from +gfa+ (which *must* be indexed)
+  def segments(gfa)
+    raise "Unindexed GFA" unless gfa.indexed?
+    [gfa.segments[from.value], gfa.segments[to.value]]
+  end
+
+  ##
+  # Include a GFA::Record::Segment +segment+?
+  def include?(segment)
+    # unless segment.is_a? GFA::Record::Segment
+    #   raise "Unrecognized class: #{segment.class}"
+    # end
+    segment.name == from || segment.name == to
+  end
+
+  ##
+  # Array of strings with the names of the segments linked by the
+  # record
+  def segment_names_a
+    [from.value, to.value]
+  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/jump.rb

@@ -1,3 +1,5 @@
+require 'gfa/record/has_from_to'
+
 class GFA::Record::Jump < GFA::Record
   CODE = :J
   REQ_FIELDS = %i[from from_orient to to_orient distance]
@@ -10,6 +12,8 @@ class GFA::Record::Jump < GFA::Record
   end
   OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
 
+  include GFA::Record::HasFromTo
+
   def initialize(from, from_orient, to, to_orient, distance, *opt_fields)
     @fields = {}
     add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
@@ -19,27 +23,4 @@ class GFA::Record::Jump < GFA::Record
     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

@@ -1,3 +1,5 @@
+require 'gfa/record/has_from_to'
+
 class GFA::Record::Link < GFA::Record
   CODE = :L
   REQ_FIELDS = %i[from from_orient to to_orient overlap]
@@ -15,6 +17,8 @@ class GFA::Record::Link < GFA::Record
   end
   OPT_FIELDS.each_key { |i| define_method(i) { fields[i] } }
 
+  include GFA::Record::HasFromTo
+
   def initialize(from, from_orient, to, to_orient, overlap, *opt_fields)
     @fields = {}
     add_field(2, :Z, from,        /[!-)+-<>-~][!-~]*/)
@@ -24,27 +28,4 @@ class GFA::Record::Link < GFA::Record
     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

@@ -1,19 +1,45 @@
 class GFA::Record::Path < GFA::Record
   CODE = :P
-  REQ_FIELDS = %i[path_name segment_name overlaps]
+  REQ_FIELDS = %i[path_name segment_names overlaps]
   OPT_FIELDS = {}
 
   REQ_FIELDS.each_index do |i|
     define_method(REQ_FIELDS[i]) { fields[i + 2] }
   end
 
+  alias segment_name segment_names
   alias cigar overlaps
 
-  def initialize(path_name, segment_name, overlaps, *opt_fields)
+  def initialize(path_name, segment_names, overlaps, *opt_fields)
     @fields = {}
-    add_field(2, :Z, path_name,    /[!-)+-<>-~][!-~]*/)
-    add_field(3, :Z, segment_name, /[!-)+-<>-~][!-~]*/)
-    add_field(4, :Z, overlaps,     /\*|([0-9]+[MIDNSHPX=]|[-+]?[0-9]+J|.)+/)
+    add_field(2, :Z, path_name,     /[!-)+-<>-~][!-~]*/)
+    add_field(3, :Z, segment_names, /[!-)+-<>-~][!-~]*/)
+    add_field(4, :Z, overlaps,      /\*|([0-9]+[MIDNSHPX=]|[-+]?[0-9]+J|.)+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
+
+  ##
+  # Array of segment names (without orientations) as strings
+  def segment_names_a
+    segment_names.value.split(/[,;]/).map { |i| i.gsub(/[+-]$/, '') }
+  end
+
+  ##
+  # Extracts all linked segments from +gfa+ (which *must* be indexed)
+  def segments(gfa)
+    raise "Unindexed GFA" unless gfa.indexed?
+    segment_names_a.map do |name|
+      gfa.segments[name]
+    end
+  end
+
+  ##
+  # Includes a GFA::Record::Segment +segment+?
+  def include?(segment)
+    # unless segment.is_a? GFA::Record::Segment
+    #   raise "Unrecognized class: #{segment.class}"
+    # end
+
+    segment_names_a.any? { |name| segment.name == name }
+  end
 end

data/lib/gfa/record/segment.rb

@@ -8,8 +8,11 @@ class GFA::Record::Segment < GFA::Record
     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)
+    # Non-cannonical but uppercase (thus, reserved)
+    DP: :f, # SAM
+    SN: :Z, # rGFA: Name of stable sequence from which the segment is derived
+    SO: :i, # rGFA: Offset on the stable sequence
+    SR: :i  # rGFA: Rank. 0 if on a linear reference genome; >0 otherwise
   }
 
   REQ_FIELDS.each_index do |i|
@@ -23,4 +26,10 @@ class GFA::Record::Segment < GFA::Record
     add_field(3, :Z, sequence, /\*|[A-Za-z=.]+/)
     opt_fields.each { |f| add_opt_field(f, OPT_FIELDS) }
   end
+
+  ##
+  # Returns the length of the sequence represented in this segment
+  def length
+    sequence.value.length
+  end
 end

data/lib/gfa/record.rb

@@ -30,6 +30,8 @@ class GFA::Record
   end
 
   def self.[](string)
+    return nil if string.nil? || string =~ /^\s*$/
+
     split = string[0] == '#' ? ['', 2] : ["\t", 0]
     code, *values = string.chomp.split(*split)
     code_class(code).new(*values)
@@ -67,6 +69,10 @@ class GFA::Record
     o.join("\t")
   end
 
+  def dup
+    self.class[to_s]
+  end
+
   def hash
     { code => fields }.hash
   end

data/lib/gfa/record_set/segment_set.rb

@@ -1,4 +1,10 @@
 class GFA::RecordSet::SegmentSet < GFA::RecordSet
   CODE = :S
   INDEX_FIELD = 2 # Name: Segment name
+
+  ##
+  # Computes the sum of all individual segment lengths
+  def total_length
+    set.map(&:length).reduce(0, :+)
+  end
 end

data/lib/gfa/record_set.rb

@@ -23,12 +23,12 @@ class GFA::RecordSet
 
   # Instance-level
 
-  attr_reader :set, :gfa
+  attr_reader :set, :index, :gfa
 
-  def initialize(gfa)
+  def initialize(gfa = nil)
     @set   = []
     @index = {}
-    @gfa   = gfa
+    @gfa   = gfa || GFA.new
   end
 
   def [](k)
@@ -69,25 +69,37 @@ class GFA::RecordSet
     raise "Wrong type of record: #{v.type}" if v.type != type
 
     @set << v
-    index(v)
+    index!(v)
+  end
+
+  def indexed?
+    (empty? || !index_field) ? gfa.opts[:index] : !index.empty?
+  end
+
+  def rebuild_index!
+    @index = {}
+    set.each { |v| index!(v) }
   end
 
   def index_id(v)
     v[index_field]&.value
   end
 
-  def index(v)
+  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)
+    if gfa.opts[:index_id] && v[:ID] && v[:ID].value =~ index_id(v)
+      save_index(v[:ID].value, v)
+    end
   end
 
   def save_index(k, v)
     return unless gfa.opts[:index] && k
 
     if @index[k]
-      warn "#{type} already registered with field #{index_field}: #{k}"
+      f = index_field.is_a?(Integer) ? '' : "#{index_field}: "
+      raise "#{type} already registered: #{f}#{k}"
     end
     @index[k] = v
   end
@@ -96,4 +108,14 @@ class GFA::RecordSet
     k = k.value if k.is_a? GFA::Field
     @index[k]
   end
+
+  def merge!(record_set)
+    raise "Not a record set" unless record_set.is_a?(GFA::RecordSet)
+    if record_set.type != type
+      raise "Wrong type of record set: #{record_set.type}"
+    end
+
+    record_set.set.each { |i| @set << i }
+    record_set.index.each { |k, v| save_index(k, v) }
+  end
 end

data/lib/gfa/version.rb

@@ -1,5 +1,5 @@
 class GFA
-  VERSION       = '0.3.1'
+  VERSION       = '0.5.0'
   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

@@ -2,3 +2,4 @@ require 'gfa/common'
 require 'gfa/parser'
 require 'gfa/generator'
 require 'gfa/graph'
+require 'gfa/modules'

data/test/parser_test.rb

@@ -49,8 +49,10 @@ class ParserTest < Test::Unit::TestCase
     assert(sample.path('first').is_a?(GFA::Record))
     assert(sample.paths['first'].is_a?(GFA::Record))
     assert_equal('first', sample.path('first')[2]&.value)
+    assert(sample.indexed?)
     sample = GFA.load(path, index: false)
     assert_nil(sample.path('first'))
+    assert(!sample.indexed?)
   end
   
   def test_version_suppport

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gfa
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Luis M. Rodriguez-R
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-23 00:00:00.000000000 Z
+date: 2023-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgl
@@ -63,6 +63,9 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/gfa-add-gaf
+- bin/gfa-greedy-modules
+- bin/gfa-subgraph
 - lib/gfa.rb
 - lib/gfa/common.rb
 - lib/gfa/field.rb
@@ -75,10 +78,12 @@ files:
 - lib/gfa/field/string.rb
 - lib/gfa/generator.rb
 - lib/gfa/graph.rb
+- lib/gfa/modules.rb
 - lib/gfa/parser.rb
 - lib/gfa/record.rb
 - lib/gfa/record/comment.rb
 - lib/gfa/record/containment.rb
+- lib/gfa/record/has_from_to.rb
 - lib/gfa/record/header.rb
 - lib/gfa/record/jump.rb
 - lib/gfa/record/link.rb