Class: Bio::RestrictionEnzyme::DoubleStranded

Inherits:
Object
  • Object
show all
Extended by:
CutSymbol, StringFormatting
Includes:
CutSymbol, StringFormatting
Defined in:
lib/bio/util/restriction_enzyme/double_stranded.rb,
lib/bio/util/restriction_enzyme/double_stranded/cut_locations.rb,
lib/bio/util/restriction_enzyme/double_stranded/aligned_strands.rb,
lib/bio/util/restriction_enzyme/double_stranded/cut_location_pair.rb,
lib/bio/util/restriction_enzyme/double_stranded/cut_locations_in_enzyme_notation.rb,
lib/bio/util/restriction_enzyme/double_stranded/cut_location_pair_in_enzyme_notation.rb

Overview

A pair of SingleStrand and SingleStrandComplement objects with methods to add utility to their relation.

Notes

  • This is created by Bio::RestrictionEnzyme.new for convenience.

  • The two strands accessible are primary and complement.

  • SingleStrand methods may be used on DoubleStranded and they will be passed to primary.

FIXME needs better docs

Defined Under Namespace

Classes: AlignedStrands, CutLocationPair, CutLocationPairInEnzymeNotation, CutLocations, CutLocationsInEnzymeNotation, EnzymeAction

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from CutSymbol

cut_symbol, escaped_cut_symbol, re_cut_symbol, re_cut_symbol_adjacent, set_cut_symbol

Methods included from StringFormatting

add_spacing, left_padding, right_padding, strip_cuts_and_padding, strip_padding

Constructor Details

#initialize(erp, *raw_cut_pairs) ⇒ DoubleStranded

erp

One of three possible parameters: The name of an enzyme, a REBASE::EnzymeEntry object, or a nucleotide pattern with a cut mark.

raw_cut_pairs

The cut locations in enzyme index notation.

Enzyme index notation

1..n, value before 1 is -1

Examples of the allowable cut locations for raw_cut_pairs follows. ‘p’ and ‘c’ refer to a cut location on the ‘p’rimary and ‘c’omplement strands.

1, [3,2], [20,22], 57
p, [p,c], [p, c],  p

Which is the same as:

1, (3..2), (20..22), 57
p, (p..c), (p..c),   p

Examples of partial cuts:

1, [nil,2], [20,nil], 57
p, [p,  c], [p, c],   p



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 71

def initialize(erp, *raw_cut_pairs)
  # 'erp' : 'E'nzyme / 'R'ebase / 'P'attern
  k = erp.class

  if k == Bio::REBASE::EnzymeEntry
    # Passed a Bio::REBASE::EnzymeEntry object

    unless raw_cut_pairs.empty?
      err = "A Bio::REBASE::EnzymeEntry object was passed, however the cut locations contained values.  Ambiguous or redundant.\n"
      err += "inspect = #{raw_cut_pairs.inspect}"
      raise ArgumentError, err
    end
    initialize_with_rebase( erp )

  elsif erp.kind_of? String
    # Passed something that could be an enzyme pattern or an anzyme name

    # Decide if this String is an enzyme name or a pattern
    if Bio::RestrictionEnzyme.enzyme_name?( erp )
      # FIXME we added this to rebase...
      # Check if it's a known name
      known_enzyme = false
      known_enzyme = true if Bio::RestrictionEnzyme.rebase[ erp ]

      # Try harder to find the enzyme
      unless known_enzyme
        re = %r"^#{erp}$"i
        Bio::RestrictionEnzyme.rebase.each { |name, v| (known_enzyme = true; erp = name; break) if name =~ re }
      end

      if known_enzyme
        initialize_with_rebase( Bio::RestrictionEnzyme.rebase[erp] )
      else
        raise IndexError, "No entry found for enzyme named '#{erp}'"
      end

    else
      # Not an enzyme name, so a pattern is assumed
      if erp =~ re_cut_symbol
        initialize_with_pattern_and_cut_symbols( erp )
      else
        initialize_with_pattern_and_cut_locations( erp, raw_cut_pairs )
      end
    end

  elsif k == NilClass
    err = "Passed a nil value.  Perhaps you tried to pass a Bio::REBASE::EnzymeEntry that does not exist?\n"
    err += "inspect = #{erp.inspect}"
    raise ArgumentError, err
  else
    err = "I don't know what to do with class #{k} for erp.\n"
    err += "inspect = #{erp.inspect}"
    raise ArgumentError, err
  end

end

Instance Attribute Details

#complement ⇒ Object (readonly)

The complement strand



43
44
45
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 43

def complement
  @complement
end

#cut_locations ⇒ Object (readonly)

Cut locations in 0-based index format, DoubleStranded::CutLocations object



46
47
48
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 46

def cut_locations
  @cut_locations
end

#cut_locations_in_enzyme_notation ⇒ Object (readonly)

Cut locations in enzyme index notation, DoubleStranded::CutLocationsInEnzymeNotation object



49
50
51
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 49

def cut_locations_in_enzyme_notation
  @cut_locations_in_enzyme_notation
end

#primary ⇒ Object (readonly)

The primary strand



40
41
42
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 40

def primary
  @primary
end

Instance Method Details

#aligned_strands ⇒ Object

See AlignedStrands.align



129
130
131
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 129

def aligned_strands
  AlignedStrands.align(@primary.pattern, @complement.pattern)
end

#aligned_strands_with_cuts ⇒ Object

See AlignedStrands.align_with_cuts



134
135
136
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 134

def aligned_strands_with_cuts
  AlignedStrands.align_with_cuts(@primary.pattern, @complement.pattern, @primary.cut_locations, @complement.cut_locations)
end

#blunt? ⇒ Boolean

Returns true if the cut pattern creates blunt fragments. (opposite of sticky)

Returns:

  • (Boolean) 


140
141
142
143
144
145
146
147
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 140

def blunt?
  as = aligned_strands_with_cuts
  ary = [as.primary, as.complement]
  ary.collect! { |seq| seq.split( cut_symbol ) }
  # convert the cut sections to their lengths
  ary.each { |i| i.collect! { |c| c.length } }
  ary[0] == ary[1]
end

#create_action_at(offset) ⇒ Object

Takes a RestrictionEnzyme object and a numerical offset to the sequence and returns an EnzymeAction

restriction_enzyme

RestrictionEnzyme

offset

Numerical offset of where the enzyme action occurs on the seqeunce



160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 160

def create_action_at( offset )
  # x is the size of the fully aligned sequence with maximum padding needed
  # to make a match on the primary and complement strand.
  #
  # For example -
  # Note how EcoRII needs extra padding on the beginning and ending of the
  # sequence 'ccagg' to make the match since the cut must occur between 
  # two nucleotides and can not occur on the very end of the sequence.
  #   
  #   EcoRII:
  #     :blunt: "0"
  #     :c2: "5"
  #     :c4: "0"
  #     :c1: "-1"
  #     :pattern: CCWGG
  #     :len: "5"
  #     :name: EcoRII
  #     :c3: "0"
  #     :ncuts: "2"
  #   
  #        -1 1 2 3 4 5
  #   5' - n^c c w g g n - 3'
  #   3' - n g g w c c^n - 5'
  #   
  #   (w == [at])
  
  x = aligned_strands.primary.size
  
  enzyme_action = EnzymeAction.new( offset,
                                    offset + x-1,
                                    offset,
                                    offset + x-1)

  @cut_locations.each do |cut_location_pair|
    # cut_pair is a DoubleStranded::CutLocationPair
    p, c = cut_location_pair.primary, cut_location_pair.complement
    if c >= p
      enzyme_action.add_cut_range(offset+p, nil, nil, offset+c)
    else
      enzyme_action.add_cut_range(nil, offset+p, offset+c, nil)
    end
  end

  enzyme_action
end

#sticky? ⇒ Boolean

Returns true if the cut pattern creates sticky fragments. (opposite of blunt)

Returns:

  • (Boolean) 


151
152
153
 
# File 'lib/bio/util/restriction_enzyme/double_stranded.rb', line 151

def sticky?
  !blunt?
end