Class Bio::GFF::GFF3::Record::Gap
In: lib/bio/db/gff.rb
Parent: Object

Bio:GFF::GFF3::Record::Gap is a class to store data of "Gap" attribute.

Methods

==   new   new_from_sequences_na   new_from_sequences_na_aa   parse   process_sequences_na   process_sequences_na_aa   to_s  

Classes and Modules

Class Bio::GFF::GFF3::Record::Gap::Code

Constants

Code = Struct.new(:code, :length)   Code is a class to store length of single-letter code.

Attributes

data  [R]  Internal data. Users must not use it.

Public Class methods

new(str = nil)

Creates a new Gap object.

Arguments:

  • str: a formatted string, or nil.

[Source]

      # File lib/bio/db/gff.rb, line 1246
1246:           def initialize(str = nil)
1247:             if str then
1248:               @data = str.split(/ +/).collect do |x|
1249:                 if /\A([A-Z])([0-9]+)\z/ =~ x.strip then
1250:                   Code.new($1.intern, $2.to_i)
1251:                 else
1252:                   warn "ignored unknown token: #{x}.inspect" if $VERBOSE
1253:                   nil
1254:                 end
1255:               end
1256:               @data.compact!
1257:             else
1258:               @data = []
1259:             end
1260:           end
new_from_sequences_na(reference, target, gap_regexp = /[^a-zA-Z]/)

Creates a new Gap object from given sequence alignment.

Note that sites of which both reference and target are gaps are silently removed.

Arguments:

  • reference: reference sequence (nucleotide sequence)
  • target: target sequence (nucleotide sequence)
  • gap_regexp: regexp to identify gap

[Source]

      # File lib/bio/db/gff.rb, line 1362
1362:           def self.new_from_sequences_na(reference, target,
1363:                                          gap_regexp = /[^a-zA-Z]/)
1364:             gap = self.new
1365:             gap.instance_eval { 
1366:               __initialize_from_sequences_na(reference, target,
1367:                                              gap_regexp)
1368:             }
1369:             gap
1370:           end
new_from_sequences_na_aa(reference, target, gap_regexp = /[^a-zA-Z]/, space_regexp = /\s/, forward_frameshift_regexp = /\>/, reverse_frameshift_regexp = /\</)

Creates a new Gap object from given sequence alignment.

Note that sites of which both reference and target are gaps are silently removed.

For incorrect alignments that break 3:1 rule, gap positions will be moved inside codons, unwanted gaps will be removed, and some forward or reverse frameshift will be inserted.

For example, 

   atgg-taagac-att
   M  V  K  -  I

is treated as: 

   atggt<aagacatt
   M  V  K  >>I

Incorrect combination of frameshift with frameshift or gap may cause undefined behavior.

Forward frameshifts are recomended to be indicated in the target sequence. Reverse frameshifts can be indicated in the reference sequence or the target sequence.

Priority of regular expressions: 

  space > forward/reverse frameshift > gap

Arguments:

  • reference: reference sequence (nucleotide sequence)
  • target: target sequence (amino acid sequence)
  • gap_regexp: regexp to identify gap
  • space_regexp: regexp to identify space character which is completely ignored
  • forward_frameshift_regexp: regexp to identify forward frameshift
  • reverse_frameshift_regexp: regexp to identify reverse frameshift

[Source]

      # File lib/bio/db/gff.rb, line 1558
1558:           def self.new_from_sequences_na_aa(reference, target,
1559:                                             gap_regexp = /[^a-zA-Z]/,
1560:                                             space_regexp = /\s/,
1561:                                             forward_frameshift_regexp = /\>/,
1562:                                             reverse_frameshift_regexp = /\</)
1563:             gap = self.new
1564:             gap.instance_eval { 
1565:               __initialize_from_sequences_na_aa(reference, target,
1566:                                                 gap_regexp,
1567:                                                 space_regexp,
1568:                                                 forward_frameshift_regexp,
1569:                                                 reverse_frameshift_regexp)
1570:             }
1571:             gap
1572:           end
parse(str)

Same as new(str).

[Source]

      # File lib/bio/db/gff.rb, line 1263
1263:           def self.parse(str)
1264:             self.new(str)
1265:           end

Public Instance methods

==(other)

If self == other, returns true. otherwise, returns false.

[Source]

      # File lib/bio/db/gff.rb, line 1586
1586:           def ==(other)
1587:             if other.class == self.class and
1588:                 @data == other.data then
1589:               true
1590:             else
1591:               false
1592:             end
1593:           end
process_sequences_na(reference, target, gap_char = '-')

Processes nucleotide sequences and returns gapped sequences as an array of sequences.

Note for forward/reverse frameshift: Forward/Reverse_frameshift is simply treated as gap insertion to the target/reference sequence.

Arguments:

  • reference: reference sequence (nucleotide sequence)
  • target: target sequence (nucleotide sequence)
  • gap_char: gap character

[Source]

      # File lib/bio/db/gff.rb, line 1686
1686:           def process_sequences_na(reference, target, gap_char = '-')
1687:             s_ref, s_tgt = dup_seqs(reference, target)
1688: 
1689:             s_ref, s_tgt = __process_sequences(s_ref, s_tgt,
1690:                                                gap_char, gap_char,
1691:                                                1, 1,
1692:                                                gap_char, gap_char)
1693: 
1694:             if $VERBOSE and s_ref.length != s_tgt.length then
1695:               warn "returned sequences not equal length"
1696:             end
1697:             return s_ref, s_tgt
1698:           end
process_sequences_na_aa(reference, target, gap_char = '-', space_char = ' ', forward_frameshift = '>', reverse_frameshift = '<')

Processes sequences and returns gapped sequences as an array of sequences. reference must be a nucleotide sequence, and target must be an amino acid sequence.

Note for reverse frameshift: Reverse_frameshift characers are inserted in the reference sequence. For example, alignment of "Gap=M3 R1 M2" is: 

    atgaagat<aatgtc
    M  K  I  N  V

Alignment of "Gap=M3 R3 M3" is: 

    atgaag<<<attaatgtc
    M  K  I  I  N  V

Arguments:

  • reference: reference sequence (nucleotide sequence)
  • target: target sequence (amino acid sequence)
  • gap_char: gap character
  • space_char: space character inserted to amino sequence for matching na-aa alignment
  • forward_frameshift: forward frameshift character
  • reverse_frameshift: reverse frameshift character

[Source]

      # File lib/bio/db/gff.rb, line 1723
1723:           def process_sequences_na_aa(reference, target,
1724:                                       gap_char = '-',
1725:                                       space_char = ' ',
1726:                                       forward_frameshift = '>',
1727:                                       reverse_frameshift = '<')
1728:             s_ref, s_tgt = dup_seqs(reference, target)
1729:             s_tgt = s_tgt.gsub(/./, "\\0#{space_char}#{space_char}")
1730:             ref_increment = 3
1731:             tgt_increment = 1 + space_char.length * 2
1732:             ref_gap = gap_char * 3
1733:             tgt_gap = "#{gap_char}#{space_char}#{space_char}"
1734:             return __process_sequences(s_ref, s_tgt,
1735:                                        ref_gap, tgt_gap,
1736:                                        ref_increment, tgt_increment,
1737:                                        forward_frameshift,
1738:                                        reverse_frameshift)
1739:           end
to_s()

string representation

[Source]

      # File lib/bio/db/gff.rb, line 1575
1575:           def to_s
1576:             @data.collect { |x| x.to_s }.join(" ")
1577:           end

[Validate]