rgfa 1.2.1

data/lib/rgfatools/multiplication.rb

@@ -0,0 +1,194 @@
+#
+# Methods which edit the graph components without traversal
+#
+module RGFATools::Multiplication
+
+  # Allowed values for the links_distribution_policy option
+  LINKS_DISTRIBUTION_POLICY = [:off, :auto, :equal, :E, :B]
+
+  # @overload multiply(segment, factor, copy_names: :lowcase, distribute: :auto, conserve_components: true, origin_tag: :or)
+  # Create multiple copies of a segment.
+  #
+  # Complements the multiply method of gfatools with additional functionality.
+  # These extensions are used only after #enable_extensions is called on the
+  # RGFA object. After that, you may still call the original method
+  # using #multiply_without_rgfatools.
+  #
+  # For more information on the additional functionality, see
+  # #multiply_extended.
+  #
+  # @return [RGFA] self
+  def multiply_with_rgfatools(segment, factor,
+                       copy_names: :lowcase,
+                       distribute: :auto,
+                       conserve_components: true,
+                       origin_tag: :or)
+    if !@extensions_enabled
+      return multiply_without_rgfatools(segment, factor,
+                       copy_names: copy_names,
+                       conserve_components: conserve_components)
+    else
+      multiply_extended(segment, factor,
+                       copy_names: copy_names,
+                       distribute: distribute,
+                       conserve_components: conserve_components,
+                       origin_tag: origin_tag)
+    end
+  end
+
+  # Create multiple copies of a segment.
+  #
+  # Complements the multiply method of gfatools with additional functionality.
+  # To always run the additional functionality when multiply is called,
+  # use RGFA#enable_extensions.
+  #
+  # @!macro [new] copynames_text
+  #
+  #   <b>Automatic computation of the copy names:</b>
+  #
+  #   - First, itis checked if the name of the original segment ends with a
+  #     relevant
+  #     string, i.e. a lower case letter (for +:lowcase+), an upper case letter
+  #     (for +:upcase+), a digit (for +:number+), or the string +"_copy"+
+  #     plus one or more optional digits (for +:copy+).
+  #   - If so, it is assumed, it was already a copy, and it is not
+  #     altered.
+  #   - If not, then +a+ (for +:lowcase+), +A+ (for +:upcase+), +1+ (for
+  #     +:number+), +_copy+ (for +:copy+) is appended to the string.
+  #   - Then, in all
+  #     cases, next (*) is called on the string, until a valid, non-existant
+  #     name is found for each of the segment copies
+  #   - (*) = except for +:copy+, where
+  #     for the first copy no digit is present, but for the following is,
+  #     i.e. the segment names will be +:copy+, +:copy2+, +:copy3+, etc.
+  # - Can be overridden, by providing an array of copy names.
+  #
+  # @!macro [new] ldp_text
+  #
+  #   <b>Links distribution policy</b>
+  #
+  #   Depending on the value of the option +distribute+, an end
+  #   is eventually selected for distribution of the links.
+  #
+  #   - +:off+: no distribution performed
+  #   - +:E+: links of the E end are distributed
+  #   - +:B+: links of the B end are distributed
+  #   - +:equal+: select an end for which the number of links is equal to
+  #     +factor+, if any; if both, then the E end is selected
+  #   - +:auto+: automatically select E or B, trying to maximize the number of
+  #     links which can be deleted
+  #
+  # @param [Integer] factor multiplication factor; if 0, delete the segment;
+  #   if 1; do nothing; if > 1; number of copies to create
+  # @!macro [new] segment_param
+  #   @param segment [String, RGFA::Line::Segment] segment name or instance
+  # @param [:lowcase, :upcase, :number, :copy, Array<String>] copy_names
+  #   <i>(Defaults to: +:lowcase+)</i>
+  #   Array of names for the copies of the segment,
+  #   or a symbol, which defines a system to compute the names from the name of
+  #   the original segment. See "Automatic computation of the copy names".
+  # @!macro [new] conserve_components
+  #   @param [Boolean] conserve_components <i>(Defaults to: +true+)</i>
+  #     If factor == 0 (i.e. deletion), delete segment only if
+  #     #cut_segment?(segment) is +false+ (see RGFA API).
+  # @!macro [new] ldp_param
+  #   @param distribute
+  #     [RGFATools::Multiplication::LINKS_DISTRIBUTION_POLICY]
+  #     <i>(Defaults to: +:auto+)</i>
+  #     Determines if and for which end of the segment, links are distributed
+  #     among the copies. See "Links distribution policy".
+  # @!macro [new] origin_tag
+  #   @param origin_tag [Symbol] <i>(Defaults to: +:or+)</i>
+  #     Name of the custom tag to use for storing origin information.
+  #
+  # @return [RGFA] self
+  def multiply_extended(segment, factor,
+                       copy_names: :lowcase,
+                       distribute: :auto,
+                       conserve_components: true,
+                       origin_tag: :or)
+    s, sn = segment_and_segment_name(segment)
+    s.set(origin_tag, sn) if !s.get(origin_tag)
+    copy_names = compute_copy_names(copy_names, sn, factor)
+    multiply_without_rgfatools(sn, factor,
+                               copy_names: copy_names,
+                               conserve_components: conserve_components)
+    distribute_links(distribute, sn, copy_names, factor)
+    return self
+  end
+
+  private
+
+  Redefined = [:multiply]
+
+  def select_distribute_end(links_distribution_policy, segment_name, factor)
+    accepted = RGFATools::Multiplication::LINKS_DISTRIBUTION_POLICY
+    if !accepted.include?(links_distribution_policy)
+      raise "Unknown links distribution policy #{links_distribution_policy}, "+
+        "accepted values are: "+
+        accepted.inspect
+    end
+    return nil if links_distribution_policy == :off
+    if [:B, :E].include?(links_distribution_policy)
+      return links_distribution_policy
+    end
+    esize = links_of([segment_name, :E]).size
+    bsize = links_of([segment_name, :B]).size
+    auto_select_distribute_end(factor, bsize, esize,
+                               links_distribution_policy == :equal)
+  end
+
+  # (keep separate for testing)
+  def auto_select_distribute_end(factor, bsize, esize, equal_only)
+    if esize == factor
+      return :E
+    elsif bsize == factor
+      return :B
+    elsif equal_only
+      return nil
+    elsif esize < 2
+      return (bsize < 2) ? nil : :B
+    elsif bsize < 2
+      return :E
+    elsif esize < factor
+      return ((bsize <= esize) ? :E :
+        ((bsize < factor) ? :B : :E))
+    elsif bsize < factor
+      return :B
+    else
+      return ((bsize <= esize) ? :B : :E)
+    end
+  end
+
+  def distribute_links(links_distribution_policy, segment_name,
+                       copy_names, factor)
+    return if factor < 2
+    end_type = select_distribute_end(links_distribution_policy,
+                                     segment_name, factor)
+    return nil if end_type.nil?
+    et_links = links_of([segment_name, end_type])
+    diff = [et_links.size - factor, 0].max
+    links_signatures = et_links.map do |l|
+      l.other_end([segment_name, end_type]).join
+    end
+    ([segment_name]+copy_names).each_with_index do |sn, i|
+      links_of([sn, end_type]).each do |l|
+        l_sig = l.other_end([sn, end_type]).join
+        to_save = links_signatures[i..i+diff].to_a
+        delete_link(l) unless to_save.include?(l_sig)
+      end
+    end
+  end
+
+  def segment_and_segment_name(segment_or_segment_name)
+    if segment_or_segment_name.kind_of?(RGFA::Line)
+      s = segment_or_segment_name
+      sn = segment_or_segment_name.name
+    else
+      sn = segment_or_segment_name.to_sym
+      s = segment(sn)
+    end
+    return s, sn
+  end
+
+end

data/lib/rgfatools/p_bubbles.rb

@@ -0,0 +1,66 @@
+#
+# Methods for the RGFA class, which involve a traversal of the graph following
+# links
+#
+module RGFATools::PBubbles
+
+  require "set"
+
+  # Removes all p-bubbles in the graph
+  # @return [RGFA] self
+  def remove_p_bubbles
+    visited = Set.new
+    segment_names.each do |sn|
+      next if visited.include?(sn)
+      if connectivity(sn) == [1,1]
+        s1 = neighbours([sn, :B])[0]
+        s2 = neighbours([sn, :E])[0]
+        n1 = neighbours(s1).sort
+        n2 = neighbours(s2).sort
+        n1.each {|se| visited << se[0].name}
+        if n1 == n2.map{|se| se.invert_end_type}
+          remove_proven_p_bubble(s1, s2, n1)
+        end
+      end
+    end
+    return self
+  end
+
+  # Removes a p-bubble between segment_end1 and segment_end2
+  # @param [RGFA::SegmentEnd] segment_end1 a segment end
+  # @param [RGFA::SegmentEnd] segment_end2 another segment end
+  # @!macro [new] count_tag
+  #   @param count_tag [Symbol] <i>(defaults to: +:RC+ or the value set by
+  #     {#set_default_count_tag})</i> the count tag to use for coverage
+  #     computation
+  # @!macro [new] unit_length
+  #   @param unit_length [Integer] <i>(defaults to: 1 or the value set by
+  #     {#set_count_unit_length})</i> the unit length to use for coverage
+  #     computation
+  # @return [RGFA] self
+  #
+  def remove_p_bubble(segment_end1, segment_end2,
+                      count_tag: @default[:count_tag],
+                      unit_length: @default[:unit_length])
+    n1 = neighbours(segment_end1).sort
+    n2 = neighbours(segment_end2).sort
+    raise if n1 != n2.map{|se| se.invert_end_type}
+    raise if n1.any? {|se| connectivity(se[0]) != [1,1]}
+    remove_proven_p_bubble(segment_end1, segment_end2, n1,
+                           count_tag: count_tag,
+                           unit_length: unit_length)
+    return self
+  end
+
+  private
+
+  def remove_proven_p_bubble(segment_end1, segment_end2, alternatives,
+                             count_tag: @default[:count_tag],
+                             unit_length: @default[:unit_length])
+    coverages = alternatives.map{|s|segment!(s[0]).coverage(
+      count_tag: count_tag, unit_length: unit_length)}
+    alternatives.delete_at(coverages.index(coverages.max))
+    alternatives.each {|s| delete_segment(s[0])}
+  end
+
+end

data/lib/rgfatools/superfluous_links.rb

@@ -0,0 +1,64 @@
+#
+# Methods which edit the graph components without traversal
+#
+module RGFATools::SuperfluousLinks
+
+  # Remove superfluous links in the presence of mandatory links
+  # for a single segment
+  # @return [RGFA] self
+  # @!macro segment_param
+  # @!macro [new] conserve_components_links
+  #   @param [Boolean] conserve_components <i>(Defaults to: +true+)</i>
+  #     delete links only if #cut_link?(link) is +false+ (see RGFA API).
+  def enforce_segment_mandatory_links(segment, conserve_components: true)
+    sn = segment_and_segment_name(segment)[1]
+    se = {}
+    l = {}
+    [:B, :E].each do |et|
+      se[et] = [sn, et]
+      l[et] = links_of(se[et])
+    end
+    cs = connectivity_symbols(l[:B].size, l[:E].size)
+    if cs == [1, 1]
+      oe = {}
+      [:B, :E].each {|et| oe[et] = l[et][0].other_end(se[et])}
+      return if oe[:B] == oe[:E]
+      [:B, :E].each {|et| delete_other_links(oe[et], se[et],
+                                    conserve_components: conserve_components)}
+    else
+      i = cs.index(1)
+      return if i.nil?
+      et = [:B, :E][i]
+      oe = l[et][0].other_end(se[et])
+      delete_other_links(oe, se[et], conserve_components: conserve_components)
+    end
+    self
+  end
+
+  # Remove superfluous links in the presence of mandatory links
+  # in the entire graph
+  # @!macro conserve_components_links
+  # @return [RGFA] self
+  def enforce_all_mandatory_links(conserve_components: true)
+    segment_names.each {|sn| enforce_segment_mandatory_links(sn,
+                               conserve_components: conserve_components)}
+    self
+  end
+
+  # Remove links of segment to itself
+  # @!macro segment_param
+  # @return [RGFA] self
+  def remove_self_link(segment)
+    segment_name = segment.kind_of?(RGFA::Line) ? segment.name : segment
+    unconnect_segments(segment_name, segment_name)
+    self
+  end
+
+  # Remove all links of segments to themselves
+  # @return [RGFA] self
+  def remove_self_links
+    segment_names.each {|sn| remove_self_link(sn)}
+    self
+  end
+
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: rgfa
+version: !ruby/object:Gem::Version
+  version: 1.2.1
+platform: ruby
+authors:
+- Giorgio Gonnella
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-21 00:00:00.000000000 Z
+dependencies: []
+description: |2
+      The Graphical Fragment Assembly (GFA) is a proposed format which allow
+      to describe the product of sequence assembly.
+      This gem implements the proposed specifications for the GFA format
+      described under https://github.com/pmelsted/GFA-spec/blob/master/GFA-spec.md
+      as close as possible.
+      The library allows to create an RGFA object from a file in the GFA format
+      or from scratch, to enumerate the graph elements (segments, links,
+      containments, paths and header lines), to traverse the graph (by
+      traversing all links outgoing from or incoming to a segment), to search for
+      elements (e.g. which links connect two segments) and to manipulate the
+      graph (e.g. to eliminate a link or a segment or to duplicate a segment
+      distributing the read counts evenly on the copies).
+email: gonnella@zbh.uni-hamburg.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rgfa.rb
+- lib/rgfa/byte_array.rb
+- lib/rgfa/cigar.rb
+- lib/rgfa/connectivity.rb
+- lib/rgfa/containments.rb
+- lib/rgfa/error.rb
+- lib/rgfa/field_array.rb
+- lib/rgfa/field_writer.rb
+- lib/rgfa/field_parser.rb
+- lib/rgfa/field_validator.rb
+- lib/rgfa/headers.rb
+- lib/rgfa/line/containment.rb
+- lib/rgfa/line/header.rb
+- lib/rgfa/line/link.rb
+- lib/rgfa/line/path.rb
+- lib/rgfa/line/segment.rb
+- lib/rgfa/line.rb
+- lib/rgfa/linear_paths.rb
+- lib/rgfa/lines.rb
+- lib/rgfa/links.rb
+- lib/rgfa/logger.rb
+- lib/rgfa/multiplication.rb
+- lib/rgfa/numeric_array.rb
+- lib/rgfa/paths.rb
+- lib/rgfa/rgl.rb
+- lib/rgfa/segment_ends_path.rb
+- lib/rgfa/segment_info.rb
+- lib/rgfa/segments.rb
+- lib/rgfa/sequence.rb
+- lib/rgfatools.rb
+- lib/rgfatools/artifacts.rb
+- lib/rgfatools/copy_number.rb
+- lib/rgfatools/invertible_segments.rb
+- lib/rgfatools/multiplication.rb
+- lib/rgfatools/superfluous_links.rb
+- lib/rgfatools/linear_paths.rb
+- lib/rgfatools/p_bubbles.rb
+- bin/gfadiff.rb
+- bin/rgfa-mergelinear.rb
+- bin/rgfa-simdebruijn.rb
+- bin/rgfa-findcrisprs.rb
+homepage: http://github.com/ggonnella/rgfa
+licenses:
+- CC-BY-SA
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Parse, edit and write GFA-format graphs in Ruby
+test_files: []
+has_rdoc: