bio-restriction_enzyme 1.0.0

data/lib/bio/util/restriction_enzyme/single_strand/cut_locations_in_enzyme_notation.rb

@@ -0,0 +1,127 @@
+# bio/util/restriction_enzyme/single_strand/cut_locations_in_enzyme_notation.rb - The cut locations, in enzyme notation
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+class SingleStrand
+
+# Stores the cut location in thier enzyme index notation
+#
+# May be initialized with a series of cuts or an enzyme pattern marked
+# with cut symbols.
+#
+# Enzyme index notation:: 1.._n_, value before 1 is -1
+#
+# example:: [-3][-2][-1][1][2][3][4][5]
+#
+# Negative values are used to indicate when a cut may occur at a specified
+# distance before the sequence begins.  This would be padded with 'n'
+# nucleotides to represent wildcards.
+#
+# Notes:
+# * <code>0</code> is invalid as it does not refer to any index
+# * +nil+ is not allowed here as it has no meaning
+# * +nil+ values are kept track of in DoubleStranded::CutLocations as they
+#   need a reference point on the correlating strand.  In
+#   DoubleStranded::CutLocations +nil+ represents no cut or a partial
+#   digestion.
+#
+class CutLocationsInEnzymeNotation < Array
+  include CutSymbol
+  extend CutSymbol
+
+  # First cut, in enzyme-index notation
+  attr_reader :min
+
+  # Last cut, in enzyme-index notation
+  attr_reader :max
+
+  # Constructor for CutLocationsInEnzymeNotation
+  #
+  # ---
+  # *Arguments*
+  # * +a+: Locations of cuts represented as a string with cuts or an array of values
+  # Examples:
+  # * n^ng^arraxt^n
+  # * 2
+  # * -1, 5
+  # * [-1, 5]
+  # *Returns*:: nothing
+  def initialize(*a)
+    a.flatten! # in case an array was passed as an argument
+
+    if a.size == 1 and a[0].kind_of? String and a[0] =~ re_cut_symbol
+      # Initialize with a cut symbol pattern such as 'n^ng^arraxt^n'
+      s = a[0]
+      a = []
+      i = -( s.tr(cut_symbol, '') =~ %r{[^n]} )  # First character that's not 'n'
+      s.each_byte { |c| (a << i; next) if c.chr == cut_symbol; i += 1 }
+      a.collect! { |n| n <= 0 ? n-1 : n } # 0 is not a valid enzyme index, decrement from 0 and all negative
+    else
+      a.collect! { |n| n.to_i } # Cut locations are always integers
+    end
+
+    validate_cut_locations( a )
+    super(a)
+    self.sort!
+    @min = self.first
+    @max = self.last
+    self.freeze
+  end
+
+  # Transform the cut locations from enzyme index notation to 0-based index
+  # notation.
+  #
+  #   input -> output
+  #   [  1, 2, 3 ] -> [ 0, 1, 2 ]
+  #   [  1, 3, 5 ] -> [ 0, 2, 4 ]
+  #   [ -1, 1, 2 ] -> [ 0, 1, 2 ]
+  #   [ -2, 1, 3 ] -> [ 0, 2, 4 ]
+  #
+  # ---
+  # *Arguments*
+  # * _none_
+  # *Returns*:: +Array+ of cuts in 0-based index notation
+  def to_array_index
+    return [] if @min == nil
+    if @min < 0
+      calc = lambda do |n|
+        n -= 1 unless n < 0
+        n + @min.abs
+      end
+    else
+      calc = lambda { |n| n - 1 }
+    end
+    self.collect(&calc)
+  end
+
+  #########
+  protected
+  #########
+
+  def validate_cut_locations( input_cut_locations )
+    unless input_cut_locations == input_cut_locations.uniq
+      err = "The cut locations supplied contain duplicate values.  Redundant / undefined meaning.\n"
+      err += "cuts: #{input_cut_locations.inspect}\n"
+      err += "unique: #{input_cut_locations.uniq.inspect}"
+      raise ArgumentError, err
+    end
+
+    if input_cut_locations.include?(nil)
+      err = "The cut locations supplied contained a nil.  nil has no index for enzyme notation, alternative meaning is 'no cut'.\n"
+      err += "cuts: #{input_cut_locations.inspect}"
+      raise ArgumentError, err
+    end
+
+    if input_cut_locations.include?(0)
+      err = "The cut locations supplied contained a '0'.  '0' has no index for enzyme notation, alternative meaning is 'no cut'.\n"
+      err += "cuts: #{input_cut_locations.inspect}"
+      raise ArgumentError, err
+    end
+
+  end
+end # CutLocationsInEnzymeNotation
+end # SingleStrand
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/single_strand_complement.rb

@@ -0,0 +1,15 @@
+# bio/util/restriction_enzyme/single_strand_complement.rb - Single strand restriction enzyme sequence in complement orientation
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+
+# A single strand of restriction enzyme sequence pattern with a 3' to 5' orientation.
+#
+class SingleStrandComplement < SingleStrand
+  # Orientation of the strand, 3' to 5'
+  def orientation; [3, 5]; end
+end # SingleStrandComplement
+end # RestrictionEnzyme
+end # Bio

data/lib/bio/util/restriction_enzyme/string_formatting.rb

@@ -0,0 +1,103 @@
+# bio/util/restriction_enzyme/string_formatting.rb - Useful functions for string manipulation
+
+require 'bio/util/restriction_enzyme'
+
+module Bio
+class RestrictionEnzyme
+
+module StringFormatting
+  include CutSymbol
+  extend CutSymbol
+
+  # Return the sequence with spacing for alignment.  Does not add whitespace
+  # around cut symbols.
+  #
+  # Example:
+  #   pattern = 'n^ng^arraxt^n'
+  #   add_spacing( pattern )      # => "n^n g^a r r a x t^n"
+  #
+  # ---
+  # *Arguments*
+  # * +seq+: sequence with cut symbols
+  # * +cs+: (_optional_) Cut symbol along the string.  The reason this is
+  #   definable outside of CutSymbol is that this is a utility function used
+  #   to form vertical and horizontal cuts such as:
+  #
+  #     a|t g c
+  #      +---+
+  #     t a c|g
+  # *Returns*:: +String+ sequence with single character distance between bases
+  def add_spacing( seq, cs = cut_symbol )
+    str = ''
+    flag = false
+    seq.each_byte do |c|
+      c = c.chr
+      if c == cs
+        str += c
+        flag = false
+      elsif flag
+        str += ' ' + c
+      else
+        str += c
+        flag = true
+      end
+    end
+    str
+  end
+
+  # Remove extraneous nucleic acid wildcards ('n' padding) from the
+  # left and right sides
+  #
+  # ---
+  # *Arguments*
+  # * +s+: sequence with extraneous 'n' padding
+  # *Returns*:: +String+ sequence without 'n' padding on the sides
+  def strip_padding( s )
+    if s[0].chr == 'n'
+      s =~ %r{(n+)(.+)}
+      s = $2
+    end
+    if s[-1].chr == 'n'
+      s =~ %r{(.+?)(n+)$}
+      s = $1
+    end
+    s
+  end
+
+  # Remove extraneous nucleic acid wildcards ('n' padding) from the
+  # left and right sides and remove cut symbols
+  #
+  # ---
+  # *Arguments*
+  # * +s+: sequence with extraneous 'n' padding and cut symbols
+  # *Returns*:: +String+ sequence without 'n' padding on the sides or cut symbols
+  def strip_cuts_and_padding( s )
+    strip_padding( s.tr(cut_symbol, '') )
+  end
+
+  # Return the 'n' padding on the left side of the strand
+  #
+  # ---
+  # *Arguments*
+  # * +s+: sequence with extraneous 'n' padding on the left side of the strand
+  # *Returns*:: +String+ the 'n' padding from the left side
+  def left_padding( s )
+    s =~ %r{^n+}
+    ret = $&
+    ret ? ret : ''  # Don't pass nil values
+  end
+
+  # Return the 'n' padding on the right side of the strand
+  #
+  # ---
+  # *Arguments*
+  # * +s+: sequence with extraneous 'n' padding on the right side of the strand
+  # *Returns*:: +String+ the 'n' padding from the right side
+  def right_padding( s )
+    s =~ %r{n+$}
+    ret = $&
+    ret ? ret : ''  # Don't pass nil values
+  end
+end # StringFormatting
+end # RestrictionEnzyme
+end # Bio

data/test/bio-restriction_enzyme/analysis/test_calculated_cuts.rb

@@ -0,0 +1,281 @@
+load Pathname.new(File.join(File.dirname(__FILE__), ['..']*2, 'helper.rb')).cleanpath.to_s
+
+require 'bio/util/restriction_enzyme/range/sequence_range/calculated_cuts'
+require 'bio/util/restriction_enzyme/range/cut_range'
+require 'bio/util/restriction_enzyme/range/cut_ranges'
+require 'bio/util/restriction_enzyme/range/horizontal_cut_range'
+require 'bio/util/restriction_enzyme/range/vertical_cut_range'
+
+class TestBioRestrictionEnzymeAnalysisCalculatedCuts < Test::Unit::TestCase
+
+  def setup
+    @t = Bio::RestrictionEnzyme::Range::SequenceRange::CalculatedCuts
+    @vcr = Bio::RestrictionEnzyme::Range::VerticalCutRange
+    @crs = Bio::RestrictionEnzyme::Range::CutRanges
+    @hcr = Bio::RestrictionEnzyme::Range::HorizontalCutRange
+
+    #a.add_cut_range(p_cut_left, p_cut_right, c_cut_left, c_cut_right )
+
+    @obj_1 = @t.new(6)
+    @obj_1.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(0,nil,nil,3), @vcr.new(nil,2,nil,nil)] ))
+    @obj_1b = @obj_1.dup
+    @obj_1b.remove_incomplete_cuts
+
+    @obj_2 = @t.new(6)
+    @obj_2.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(0,2,nil,nil), @vcr.new(3,nil,4,nil)] ))
+    @obj_2b = @obj_2.dup
+    @obj_2b.remove_incomplete_cuts
+
+    @obj_3 = @t.new(6)
+    @obj_3.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(0,2,nil,nil), @vcr.new(3,nil,4,nil)] ))
+    @obj_3.add_cuts_from_cut_ranges( @crs.new( [@hcr.new(0), @hcr.new(5)] ))
+    @obj_3b = @obj_3.dup
+    @obj_3b.remove_incomplete_cuts
+
+    @obj_4 = @t.new(6)
+    @obj_4.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(0,2,1,3)] ))
+    @obj_4b = @obj_4.dup
+    @obj_4b.remove_incomplete_cuts
+
+    # Same thing, declared a different way
+    @obj_4_c1 = @t.new(6)
+    @obj_4_c1.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(nil,nil,1,3), @vcr.new(0,2,nil,nil)] ))
+    @obj_4b_c1 = @obj_4_c1.dup
+    @obj_4b_c1.remove_incomplete_cuts
+
+    # Same thing, declared a different way
+    @obj_4_c2 = @t.new(6)
+    @obj_4_c2.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(0,nil,nil,3), @vcr.new(nil,2,1,nil)] ))
+    @obj_4b_c2 = @obj_4_c2.dup
+    @obj_4b_c2.remove_incomplete_cuts
+
+    @obj_5 = @t.new(6)
+    @obj_5.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(0,nil,nil,nil), @vcr.new(nil,4,3,nil), @hcr.new(1,2)] ))
+    @obj_5b = @obj_5.dup
+    @obj_5b.remove_incomplete_cuts
+
+    @obj_6 = @t.new(6)
+    @obj_6.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(nil,nil,0,nil), @hcr.new(1,2), @vcr.new(nil,4,3,nil)] ))
+    @obj_6b = @obj_6.dup
+    @obj_6b.remove_incomplete_cuts
+
+    @obj_7 = @t.new(6)
+    @obj_7.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(nil,2,nil,nil), @hcr.new(0,2)] ))
+    @obj_7b = @obj_7.dup
+    @obj_7b.remove_incomplete_cuts
+
+    @obj_8 = @t.new(12)
+    @obj_8.add_cuts_from_cut_ranges( @crs.new( [@hcr.new(0,1), @vcr.new(nil,nil,nil,5), @hcr.new(7,8), @hcr.new(10), @vcr.new(nil,10,nil,nil)] ))
+    @obj_8b = @obj_8.dup
+    @obj_8b.remove_incomplete_cuts
+
+    @obj_9 = @t.new(6)
+    @obj_9.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(nil,3,nil,3)] ))
+    @obj_9b = @obj_9.dup
+    @obj_9b.remove_incomplete_cuts
+
+    @obj_10 = @t.new(6)
+    @obj_10.add_cuts_from_cut_ranges( @crs.new( [@vcr.new(0,nil,nil,3), @vcr.new(nil,2,nil,2)] ))
+    @obj_10b = @obj_10.dup
+    @obj_10b.remove_incomplete_cuts
+
+
+  end
+
+  def test_cuts
+    x = @obj_1
+    assert_equal([0,2], x.vc_primary)
+    assert_equal([3], x.vc_complement)
+    assert_equal([1,2,3], x.hc_between_strands)
+
+    x = @obj_2
+    assert_equal([0,2,3], x.vc_primary)
+    assert_equal([4], x.vc_complement)
+    assert_equal([1,2,4], x.hc_between_strands)
+
+    x = @obj_3
+    assert_equal([0,2,3], x.vc_primary)
+    assert_equal([4], x.vc_complement)
+    assert_equal([0,1,2,4,5], x.hc_between_strands)
+
+    x = @obj_4
+    assert_equal([0,2], x.vc_primary)
+    assert_equal([1,3], x.vc_complement)
+    assert_equal([1,2,3], x.hc_between_strands)
+
+    x = @obj_4_c1
+    assert_equal([0,2], x.vc_primary)
+    assert_equal([1,3], x.vc_complement)
+    assert_equal([1,2,3], x.hc_between_strands)
+
+    x = @obj_4_c2
+    assert_equal([0,2], x.vc_primary)
+    assert_equal([1,3], x.vc_complement)
+    assert_equal([1,2,3], x.hc_between_strands)
+
+    x = @obj_5
+    assert_equal([0,4], x.vc_primary)
+    assert_equal([3], x.vc_complement)
+    assert_equal([1,2,4], x.hc_between_strands)
+
+    x = @obj_6
+    assert_equal([4], x.vc_primary)
+    assert_equal([0,3], x.vc_complement)
+    assert_equal([1,2,4], x.hc_between_strands)
+
+    x = @obj_7
+    assert_equal([2], x.vc_primary)
+    assert_equal([], x.vc_complement)
+    assert_equal([0,1,2], x.hc_between_strands)
+
+    x = @obj_8
+    assert_equal([10], x.vc_primary)
+    assert_equal([5], x.vc_complement)
+    assert_equal([0,1,7,8,10], x.hc_between_strands)
+
+    x = @obj_9
+    assert_equal([3], x.vc_primary)
+    assert_equal([3], x.vc_complement)
+    assert_equal([], x.hc_between_strands)
+
+    x = @obj_10
+    assert_equal([0,2], x.vc_primary)
+    assert_equal([2,3], x.vc_complement)
+    assert_equal([1,2,3], x.hc_between_strands)
+  end
+
+  def test_cuts_after_remove_incomplete_cuts
+    x = @obj_1b
+    assert_equal([0,2], x.vc_primary)
+    assert_equal([3], x.vc_complement)
+    assert_equal([1,2,3], x.hc_between_strands)
+  end
+
+  def test_strands_for_display_current
+  #check object_id
+  end
+
+  def test_strands_for_display
+    x = @obj_1
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +---+-+   ', x.strands_for_display[1])
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_1b
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +---+-+   ', x.strands_for_display[1])
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_2
+    assert_equal('0|1 2|3|4 5', x.strands_for_display[0])
+    assert_equal(' +---+ +-+ ', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4|5', x.strands_for_display[2])
+
+    x = @obj_2b
+    assert_equal('0|1 2|3|4 5', x.strands_for_display[0])
+    assert_equal(' +---+ +-+ ', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4|5', x.strands_for_display[2])
+
+    x = @obj_3
+    assert_equal('0|1 2|3|4 5', x.strands_for_display[0])
+    assert_equal('-+---+ +-+-', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4|5', x.strands_for_display[2])
+
+    x = @obj_3b
+    assert_equal('0|1 2|3|4 5', x.strands_for_display[0])
+    assert_equal('-+---+ +-+-', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4|5', x.strands_for_display[2])
+
+    x = @obj_4
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +-+-+-+   ', x.strands_for_display[1])
+    assert_equal('0 1|2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_4b
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +-+-+-+   ', x.strands_for_display[1])
+    assert_equal('0 1|2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_4_c1
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +-+-+-+   ', x.strands_for_display[1])
+    assert_equal('0 1|2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_4b_c1
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +-+-+-+   ', x.strands_for_display[1])
+    assert_equal('0 1|2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_4_c2
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +-+-+-+   ', x.strands_for_display[1])
+    assert_equal('0 1|2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_4b_c2
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +-+-+-+   ', x.strands_for_display[1])
+    assert_equal('0 1|2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_5
+    assert_equal('0|1 2 3 4|5', x.strands_for_display[0])
+    assert_equal(' +---  +-+ ', x.strands_for_display[1])
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_5b
+    assert_equal('0 1 2 3 4|5', x.strands_for_display[0])
+    assert_equal('       +-+ ', x.strands_for_display[1])
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_6
+    assert_equal('0 1 2 3 4|5', x.strands_for_display[0])
+    assert_equal(' +---  +-+ ', x.strands_for_display[1])
+    assert_equal('0|1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_6b
+    assert_equal('0 1 2 3 4|5', x.strands_for_display[0])
+    assert_equal('       +-+ ', x.strands_for_display[1])
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_7
+    assert_equal('0 1 2|3 4 5', x.strands_for_display[0])
+    assert_equal('-----+     ', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4 5', x.strands_for_display[2])
+
+    x = @obj_7b
+    assert_equal('0 1 2|3 4 5', x.strands_for_display[0])
+    assert_equal('-----+     ', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4 5', x.strands_for_display[2])
+
+    x = @obj_8
+    assert_equal('0 1 2 3 4 5 6 7 8 9 0|1', x.strands_for_display[0])
+    assert_equal('---        +  ---   -+ ', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4 5|6 7 8 9 0 1', x.strands_for_display[2])
+
+    x = @obj_8b
+    assert_equal('0 1 2 3 4 5 6 7 8 9 0 1', x.strands_for_display[0])
+    assert_equal('                       ', x.strands_for_display[1])
+    assert_equal('0 1 2 3 4 5 6 7 8 9 0 1', x.strands_for_display[2])
+
+    x = @obj_9
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[0])
+    assert_equal('       +   ', x.strands_for_display[1])
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_9b
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[0])
+    assert_equal('       +   ', x.strands_for_display[1])
+    assert_equal('0 1 2 3|4 5', x.strands_for_display[2])
+
+    x = @obj_10
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +---+-+   ', x.strands_for_display[1])
+    assert_equal('0 1 2|3|4 5', x.strands_for_display[2])
+
+    x = @obj_10b
+    assert_equal('0|1 2|3 4 5', x.strands_for_display[0])
+    assert_equal(' +---+-+   ', x.strands_for_display[1])
+    assert_equal('0 1 2|3|4 5', x.strands_for_display[2])
+
+  end
+
+end