gfa 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e8e61ff97b34654b7a660b011826ad5549f66933a91a09658facf58c3fd56b1
-  data.tar.gz: 8f85f07955e71cd38a9dfa28011c70433473ad6a1137ed3e6e217d63eeba20a8
+  metadata.gz: 97e6400338884b4ceb1161778c26c5d6de6ee71616be1b5caae6aa0691d88395
+  data.tar.gz: 2fe8103598246724d98e3ceeecce92b5564f45bf029bf034978277cde59b4caa
 SHA512:
-  metadata.gz: 5b9f8fd92cd30d9e4e5c0263e938169141749c7be43011b574f937c9645608d8e72189bfe9072d7321e3acdf7e8288cecf42c90abe3ceef2bf001780bdb3e472
-  data.tar.gz: ee33c0b9c0dc9adb2df96d95b792b060b248e2f991ed5a0e4b4c136d66f04b9be6cf5ca58462bce046c6cfd9e7fed6c4c6949cb5e8923eb71e3d5f53f0da2703
+  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,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-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,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/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 |record|
+      if eval_set.any? { |segment| record.include? segment }
+        linking << record
+        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/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|

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.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.4.0'
   VERSION_ARRAY = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
   VERSION_MAJOR = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR = VERSION_ARRAY[1] # :nodoc:

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.4.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-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rgl
@@ -63,6 +63,8 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/gfa-add-gaf
+- bin/gfa-subgraph
 - lib/gfa.rb
 - lib/gfa/common.rb
 - lib/gfa/field.rb
@@ -79,6 +81,7 @@ files:
 - 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