Class: Bio::RestrictionEnzyme::Range::SequenceRange::CalculatedCuts

Inherits:
Object
  • Object
show all
Includes:
CutSymbol, StringFormatting
Defined in:
lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb

Overview

cc = CalculatedCuts.new(@size) cc.add_cuts_from_cut_ranges(@cut_ranges) cc.remove_incomplete_cuts

1 2 3 4 5 6 7
G A|T T A C A
   +-----+
C T A A T|G T
1 2 3 4 5 6 7

Primary cut = 2 Complement cut = 5 Horizontal cuts = 3, 4, 5

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from StringFormatting

#add_spacing, #left_padding, #right_padding, #strip_cuts_and_padding, #strip_padding

Methods included from CutSymbol

#cut_symbol, #escaped_cut_symbol, #re_cut_symbol, #re_cut_symbol_adjacent, #set_cut_symbol

Constructor Details

#initialize(size = nil, circular = false) ⇒ CalculatedCuts

Returns a new instance of CalculatedCuts.



60
61
62
63
64
65
66
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 60

def initialize(size=nil, circular=false)
  @size = size
  @circular = circular
  @vc_primary = []
  @vc_complement = []
  @hc_between_strands = []
end

Instance Attribute Details

#circular ⇒ Object

Set to true if the fragment CalculatedCuts is working on is circular



46
47
48
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 46

def circular
  @circular
end

#hc_between_strands ⇒ Object (readonly)

Array of horizontal cuts between strands in 0-based index notation



43
44
45
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 43

def hc_between_strands
  @hc_between_strands
end

#size ⇒ Object (readonly)

Size of the sequence being digested.



58
59
60
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 58

def size
  @size
end

#strands_for_display_current ⇒ Object (readonly)

If false the strands_for_display method needs to be called to update the contents of @strands_for_display. Becomes out of date whenever add_cuts_from_cut_ranges is called.



55
56
57
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 55

def strands_for_display_current
  @strands_for_display_current
end

#vc_complement ⇒ Object (readonly)

Array of vertical cuts on the complementary strand in 0-based index notation



40
41
42
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 40

def vc_complement
  @vc_complement
end

#vc_primary ⇒ Object (readonly)

Array of vertical cuts on the primary strand in 0-based index notation



37
38
39
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 37

def vc_primary
  @vc_primary
end

Instance Method Details

#add_cuts_from_cut_ranges(cut_ranges) ⇒ Object

Accepts an Array of CutRange type objects and applies them to @vc_complement, @vc_primary, and @hc_between_strands.

Arguments

  • cut_ranges: An Array of HorizontalCutRange or VerticalCutRange objects

Returns

nothing



75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 75

def add_cuts_from_cut_ranges(cut_ranges)
  @strands_for_display_current = false

  cut_ranges.each do |cut_range|
    @vc_primary += [cut_range.p_cut_left, cut_range.p_cut_right]
    @vc_complement += [cut_range.c_cut_left, cut_range.c_cut_right]

    # Add horizontal cut ranges.  This may happen from cuts made inbetween a
    # VerticalCutRange or may be specifically defined by a HorizontalCutRange.
    if cut_range.class == VerticalCutRange
      ( cut_range.min + 1 ).upto( cut_range.max ){|i| @hc_between_strands << i} if cut_range.min < cut_range.max
    elsif cut_range.class == HorizontalCutRange
      ( cut_range.hcuts.first ).upto( cut_range.hcuts.last ){|i| @hc_between_strands << i}
    end
  end
  clean_all
  #return
end

#remove_incomplete_cuts(size = nil) ⇒ Object

There may be incomplete cuts made, this method removes the cuts that don’t create sub-sequences for easier processing.

For example, stray horizontal cuts that do not end with a left and right separation:

G A T T A C A
   +--  ---
C T|A A T G T

Or stray vertical cuts:

G A T T A C A
   +--   +
C T|A A T|G T

However note that for non-circular sequences this would be a successful cut which would result in a floating ‘GT’ sub-sequence:

G A T T A C A
         +---
C T A A T|G T

Blunt cuts are also complete cuts.

Arguments

  • size: (optional) Size of the sequence being digested. Defined here or during initalization of CalculatedCuts.

Returns

nothing

Raises:

  • (IndexError) 


122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 122

def remove_incomplete_cuts(size=nil)
  @strands_for_display_current = false
  @size = size if size
  raise IndexError, "Size of the strand must be provided here or during initalization." if !@size.kind_of?(Fixnum) and not @circular

  vcuts = (@vc_primary + @vc_complement).uniq.sort
  hcuts = @hc_between_strands
  last_index = @size - 1
  good_hcuts = []
  potential_hcuts = []

  if @circular
  # NOTE
  # if it's circular we should start at the beginning of a cut for orientation,
  # scan for it, hack off the first set of hcuts and move them to the back
  else
    vcuts.unshift(-1) unless vcuts.include?(-1)
    vcuts.push(last_index) unless vcuts.include?(last_index)
  end

  hcuts.each do |hcut|
    raise IndexError if hcut < -1 or hcut > last_index
    # skipped a nucleotide
    potential_hcuts.clear if !potential_hcuts.empty? and (hcut - potential_hcuts.last).abs > 1

    if potential_hcuts.empty?
      if vcuts.include?( hcut ) and vcuts.include?( hcut - 1 )
        good_hcuts += [hcut]
      elsif vcuts.include?( hcut - 1 )
        potential_hcuts << hcut
      end
    else
      if vcuts.include?( hcut )
        good_hcuts += potential_hcuts + [hcut]
        potential_hcuts.clear
      else
        potential_hcuts << hcut
      end
    end
  end

  check_vc = lambda do |vertical_cuts, opposing_vcuts|
    # opposing_vcuts is here only to check for blunt cuts, so there shouldn't
    # be any out-of-order problems with this
    good_vc = []
    vertical_cuts.each { |vc| good_vc << vc if good_hcuts.include?( vc ) or good_hcuts.include?( vc + 1 ) or opposing_vcuts.include?( vc ) }
    good_vc
  end

  @vc_primary = check_vc.call(@vc_primary, @vc_complement)
  @vc_complement = check_vc.call(@vc_complement, @vc_primary)
  @hc_between_strands = good_hcuts

  clean_all
end

#strands_for_display(str1 = nil, str2 = nil, vcp = nil, vcc = nil, hc = nil) ⇒ Object

Sets @strands_for_display_current to true and populates @strands_for_display.

Arguments

  • str1: (optional) For displaying a primary strand. If nil a numbered sequence will be used in place.

  • str2: (optional) For displaying a complementary strand. If nil a numbered sequence will be used in place.

  • vcp: (optional) An array of vertical cut locations on the primary strand. If nil the contents of @vc_primary is used.

  • vcc: (optional) An array of vertical cut locations on the complementary strand. If nil the contents of @vc_complementary is used.

  • hc: (optional) An array of horizontal cut locations between strands. If nil the contents of @hc_between_strands is used.

Returns

Array An array with the primary strand with vertical cuts, the horizontal cuts, and the complementary strand with vertical cuts.



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
 
# File 'lib/bio/util/restriction_enzyme/range/sequence_range/calculated_cuts.rb', line 189

def strands_for_display(str1 = nil, str2 = nil, vcp=nil, vcc=nil, hc=nil)
  return @strands_for_display if @strands_for_display_current
  vcs = '|'   # Vertical cut symbol
  hcs = '-'   # Horizontal cut symbol
  vhcs = '+'  # Intersection of vertical and horizontal cut symbol
    
  num_txt_repeat = lambda { num_txt = '0123456789'; (num_txt * ( @size / num_txt.size.to_f ).ceil)[0..@size-1] }
  (str1 == nil) ? a = num_txt_repeat.call : a = str1.dup
  (str2 == nil) ? b = num_txt_repeat.call : b = str2.dup

  vcp = @vc_primary if vcp==nil
  vcc = @vc_complement if vcc==nil
  hc = @hc_between_strands if hc==nil

  vcuts = (vcp + vcc).uniq.sort

  vcp.reverse.each { |c| a.insert(c+1, vcs) }
  vcc.reverse.each { |c| b.insert(c+1, vcs) }

  between = ' ' * @size
  hc.each {|hcut| between[hcut,1] = hcs }

  s_a = add_spacing(a, vcs)
  s_b = add_spacing(b, vcs)
  s_bet = add_spacing(between)

  # NOTE watch this for circular
  i = 0
  0.upto( s_a.size-1 ) do
    if (s_a[i,1] == vcs) or (s_b[i,1] == vcs)
      s_bet[i] = vhcs 
    elsif i != 0 and s_bet[i-1,1] == hcs and s_bet[i+1,1] == hcs
      s_bet[i] = hcs 
    end
    i+=1
  end

  @strands_for_display_current = true
  @strands_for_display = [s_a, s_bet, s_b]
end