bio-alignment 0.0.5 → 0.0.6

data/features/edit/del_short_sequences.feature

@@ -0,0 +1,25 @@
+Feature: Alignment editing; remove short sequences
+  Remove rows that are too short (short sequences)
+
+  The dropped sequences are tracked by the row state objects
+
+  Scenario: Apply short sequence rule to an amino acid alignment
+    Given I have a bridged alignment
+      """
+      SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
+      SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
+      ----------PTIIFSGCSKACSGK-----VCGIFHAVRSFM
+      ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
+      -------------IFHAVR-TC-HP-----------------
+      """
+    When I apply the short sequence rule
+    Then it should have removed one row
+      """
+      SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
+      SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
+      ----------PTIIFSGCSKACSGK-----VCGIFHAVRSFM
+      ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
+      """
+    Then I should be able to track removed rows
+
+

data/features/edit/gblocks-feature.rb

@@ -1,5 +1,5 @@
 When /^I apply GBlocks$/ do
-  pending # express the regexp above with the code you wish you had
+  # pending # express the regexp above with the code you wish you had
 end
 
 Then /^it should return the GBlocks cleaned alignment$/ do
@@ -7,7 +7,7 @@ Then /^it should return the GBlocks cleaned alignment$/ do
 end
 
 Then /^return a list of removed columns$/ do
-  pending # express the regexp above with the code you wish you had
+  # pending # express the regexp above with the code you wish you had
 end
 
 

data/features/edit/mask_islands-feature.rb

@@ -1,12 +1,25 @@
 require 'bio-alignment'
+require 'bio-alignment/edit/mask_islands'
 
-When /^I apply island rule with max_gap_size (\d+)$/ do |arg1|
-  pending # express the regexp above with the code you wish you had
+
+Given /^I have an alignment with islands$/ do |string|
+  @aln = Alignment.new(string.split(/\n/))
 end
 
-Then /^it should result in$/ do |string|
-  pending # express the regexp above with the code you wish you had
+When /^I apply island rule with max_gap_size (\d+)$/ do |arg1|
+  @aln.extend MaskIslands
+  @marked_aln = @aln.mark_islands
 end
 
+Then /^it should have masked islands$/ do |string|
+  check_aln = Alignment.new(string.split(/\n/))
+  new_aln = @marked_aln.update_each_element { |e| (e.state.masked? ? Element.new("X"):e)}
+  new_aln.to_s.should == check_aln.to_s
+end
 
+Then /^it should also be able to delete islands$/ do |string|
+  check_aln = Alignment.new(string.split(/\n/))
+  new_aln = @marked_aln.update_each_element { |e| (e.state.masked? ? Element.new("-"):e)}
+  new_aln.to_s.should == check_aln.to_s
+end
 

data/features/edit/mask_islands.feature

@@ -1,42 +1,53 @@
+@dev
 Feature: Alignment editing with the Island rule
-  The idea is to drop hypervariable floating sequences, as they are probably
-  misaligned.
+  The idea is to drop hypervariable 'floating' sequences, or islands, as 
+  they are possibly/probably misaligned.
 
-  Drop all 'islands' in a sequence with low island consensus, that show a gap
-  larger than 'max_gap_size' (default 6) on both sides, and are shorter than
-  'min_island_size' (default 30). The latter may be a large size, as an island
-  needs to loop in and out several times to be (arguably) functional. We also
-  add a parameter 'max_gap_size_inside' (default 2) which allows for small gaps
-  inside the island - though the total island size is calculated including
-  those small gaps. 
+  Drop all 'islands' in a sequence with low consensus, that show a gap larger
+  than 'min_gap_size' (default 3) on both sides, and are shorter than
+  'max_island_size' (default 30). An island larger than 30 elements is arguably
+  no longer an island, and low consensus stretches may be loops - it is up to
+  the alignment procedure to get that right. We also allow for micro deletions
+  inside an alignment (1 or 2 elements).
   
-  The island consensus is calculated by column.
-  'max_island_elements_unique_percentage' (default 10%) of elements in the
-  island should have a 'min_island_column_matched' (default 1) somewhere in the
-  element's column.
+  The island consensus is calculated by column. If more than 50% of the island
+  shows consensus, the island is retained. Consensus for each element is
+  defined here as the number of matches in the column (default 1).
 
   Scenario: Apply island rule to an amino acid alignment
-    Given I have an alignment
+    Given I have an alignment with islands
       """
       ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
       SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
       SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
       ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
       ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
-      ----------PTIIFSGCSKACSGK-----FRSFRSFMLSAV
+      ----------PTIIFSGCSKACSGK-----FRSFRSFRSFRS
       ----------PTIIFSGCSKACSGK-----VCGIFHAVRSFM
       ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
       -------------IFHAVR-TC-HP-----------------
       """
     When I apply island rule with max_gap_size 4
-    Then it should have removed 2 islands
+    Then it should have masked islands
       """
       ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
       SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
       SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
       ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
       ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
-      ----------PTIIFSGCSKACSGK-----VCGFRSFMLSAV
+      ----------PTIIFSGCSKACSGK-----XXXXXXXXXXXX
+      ----------PTIIFSGCSKACSGK-----XXXXXXXXXXXX
+      ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
+      -------------XXXXXX-XX-XX-----------------
+      """
+    Then it should also be able to delete islands
+      """
+      ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
+      SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
+      SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
+      ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
+      ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
+      ----------PTIIFSGCSKACSGK-----------------
       ----------PTIIFSGCSKACSGK-----------------
       ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
       ------------------------------------------

data/features/edit/mask_serial_mutations-feature.rb

@@ -1,16 +1,18 @@
 require 'bio-alignment'
+require 'bio-alignment/edit/mask_serial_mutations'
 
 Given /^I have an alignment$/ do |string|
   @aln = Alignment.new(string.split(/\n/))
-  p @aln
 end
 
-When /^I apply rule masking with X and max_gap_size (\d+)$/ do |arg1|
-  pending # express the regexp above with the code you wish you had
+When /^I apply rule masking with X$/ do 
+  @aln.extend MaskSerialMutations
+  @marked_aln = @aln.mark_serial_mutations
 end
 
-Then /^it should have removed (\d+) islands$/ do |arg1, string|
-  pending # express the regexp above with the code you wish you had
+Then /^mask serial mutations should result in$/ do |string|
+  check_aln = Alignment.new(string.split(/\n/))
+  new_aln = @marked_aln.update_each_element { |e| (e.state.masked ? Element.new("X"):e)}
+  new_aln.to_s.should == check_aln.to_s
 end
 
-

data/features/edit/mask_serial_mutations.feature

@@ -2,34 +2,34 @@ Feature: Alignment editing masking serial mutations
   Edit an alignment removing or masking unique elements column-wise. 
   
   If a sequence has a unique AA in a column it is a single mutation event. If
-  multiple neighbouring AA's are also unique we suspect the sequence is an
-  outlier. This rule masks, or deletes, stretches of unique AAs. The stretch of
-  unique AA's is defined in 'max_serial_unique' (default 5, so two bordering
-  unique AA's are allowed).
+  multiple neighbouring AA's are also unique we suspect the (partial) sequence
+  may be an outlier. This rule masks, or deletes, stretches of totally unique
+  AAs. The stretch of unique AA's is defined in 'max_serial_unique' (default 5,
+  so two bordering unique AA's are allowed). Gaps within a series are allowed.
 
   Scenario: Apply rule to an amino acid alignment
     Given I have an alignment
       """
       ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
       SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
-      SSIISNSFSRPTIIFSGCSTACSQQKLTSEQVCFR---LSDV
+      SSIISNSFSRPTIIFSGCSTACSQQKKTSEQVCFR---LSDV
       ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
       ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
       ----------PTIIFSGCSKACSGK-----FRSFRSFMLSAV
       ----------PTIIFSGCSKACSGK-----VCGIFHAVRSFM
       ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
-      -------------IFHAVR-TC-HP-----------------
+      -------------TTTTTT-TT-HP-----------------
       """
-    When I apply rule masking with X and max_gap_size 5
-    Then it should result in
+    When I apply rule masking with X
+    Then mask serial mutations should result in
       """
       ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
       SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
-      SSIISNSFSRPTIIFSGCSTACXXXXXXXXXXXFR---LSDV
+      SSIISNSFSRPTIIFSGCSTACSXXXXXXXXXXFR---LSDV
       ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
       ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
-      ----------PTIIFSGCSKACSGK-----VCGFRSFMLSAV
-      ----------PTIIFSGCSKACSGK-----------------
+      ----------PTIIFSGCSKACSGK-----FRSFRSFMLSAV
+      ----------PTIIFSGCSKACSGK-----VCGXXXXXXSXX
       ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
       -------------XXXXXX-XX-XX-----------------
       """

data/features/tree-feature.rb

@@ -0,0 +1,66 @@
+require 'bio'  # for the Newick tree parser
+require 'bio-alignment'
+
+Given /^I have a multiple sequence alignment \(MSA\)$/ do |string|
+  list = string.split(/\n/) 
+  seqs = list.map { | line | line.split('  ')[1] }
+  ids = list.map { | line | line.split('  ')[0] }
+  @aln = Alignment.new(seqs, ids)
+  print @aln
+end
+
+Given /^I have a phylogenetic tree in Newick format$/ do |string|
+  @tree = Bio::Newick.new(string).tree
+  tree = @tree
+  tree.children(tree.root).size.should == 2
+  tree.descendents(tree.root).size.should == 14
+  tree.leaves.size.should == 8
+  leaf = tree.get_node_by_name('seq8')
+  leaf.name.should == "seq8"
+  tree.ancestors(leaf).size.should == 5
+  tree.get_edge(leaf, tree.parent(leaf)).distance.should == 1.1904755
+  tree.get_edge(tree.parent(leaf), tree.parent(tree.parent(leaf))).distance.should == 1.7857151
+end
+
+Then /^I should be able to traverse the tree$/ do
+  tree = @aln.attach_tree(@tree)
+  root = @aln.root # get the root of the tree
+  root.leaf?.should == false
+  children = root.children
+  children.map { |n| n.name }.sort.should == ["","seq7"]
+  seq7 = children.last
+  seq7.name.should == 'seq7'
+  seq7.leaf?.should == true
+  seq7.parent.should == root
+  seq4 = tree.find("seq4")
+  seq4.leaf?.should == true
+  seq4.distance(seq7).should == 19.387756600000003  # that is nice!
+end
+
+Then /^fetch elements from the MSA from each end node in the tree$/ do
+  # walk the tree
+  tree = @aln.attach_tree(@tree)
+  ids = []
+  column20 = tree.map { | leaf |
+    ids << leaf.name
+    seq = @aln.find(leaf.name) 
+    # p seq
+    seq[19]
+  }
+  ids.should == ["seq6", "seq4", "seq8", "seq5", "seq3", "seq2", "seq1", "seq7"]
+  column20.should == ["K", "T", "K", "K", "T", "T", "T", "K"]
+end
+
+Then /^calculate the phylogenetic distance between each element$/ do
+  pending # express the regexp above with the code you wish you had
+end
+
+Then /^draw the MSA with the tree$/ do | string |
+  # textual drawing, like tabtree, or http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/149701
+  print string
+  pending # express the regexp above with the code you wish you had
+end
+
+Then /^draw MSA with the short tree$/ do |string|
+  pending # express the regexp above with the code you wish you had
+end

data/features/tree.feature

@@ -0,0 +1,45 @@
+@tree
+Feature: Tree support for alignments
+  Alignments are often accompanied by phylogenetic trees.
+
+  Scenario: Get ordered elements from a tree
+    Given I have a multiple sequence alignment (MSA)
+      """
+      seq1  ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
+      seq2  SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
+      seq3  SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
+      seq4  ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
+      seq5  ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
+      seq6  ----------PTIIFSGCSKACSGK-----FRSFRSFMLSAV
+      seq7  ----------PTIIFSGCSKACSGK-----VCGIFHAVRSFM
+      seq8  ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
+      """
+    And I have a phylogenetic tree in Newick format
+      """
+      ((seq6:5.3571434,(seq4:4.04762,((seq8:1.1904755,seq5:1.1904755):1.7857151,((seq3:0.0,seq2:0.0):1.1904755,seq1:1.1904755):1.7857151):1.0714293):1.3095236):4.336735,seq7:9.693878);
+      """
+    Then I should be able to traverse the tree
+    And fetch elements from the MSA from each end node in the tree
+    And calculate the phylogenetic distance between each element
+    And draw the MSA with the tree
+      """
+      ,--9.69----------------------------------------- seq7  ----------PTIIFSGCSKACSGK-----VCGIFHAVRSFM
+      |                                   ,--1.19----- seq1  ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
+      |                          ,--1.79--|        ,-- seq2  SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
+      |                 ,--1.07--|        `--1.19--+-- seq3  SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
+      |                 |        `--1.79--+--1.19----- seq5  ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
+      |        ,--1.31--|                 `--1.19----- seq8  ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
+      `--4.34--|        `--4.05----------------------- seq4  ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
+               `--5.36-------------------------------- seq6  ----------PTIIFSGCSKACSGK-----FRSFRSFMLSAV
+      """
+    Then draw MSA with the short tree
+      """
+      ,----------------- seq7  ----------PTIIFSGCSKACSGK-----VCGIFHAVRSFM
+      |           ,----- seq1  ----SNSFSRPTIIFSGCSTACSGK--SELVCGFRSFMLSDV
+      |        ,--|  ,-- seq2  SSIISNSFSRPTIIFSGCSTACSGK--SEQVCGFR---LSDV
+      |     ,--|  `--+-- seq3  SSIISNSFSRPTIIFSGCSTACSGKLTSEQVCGFR---LSDV
+      |     |  `--+----- seq5  ----------PTIIFSGCSKACSGKGLSELVCGFRSFMLSDV
+      |  ,--|     `----- seq8  ----------PTIIFSGCSKACSGK--SELVCGFRSFMLSAV
+      `--|  `----------- seq4  ----PKLFSRPTIIFSGCSTACSGK--SEPVCGFRSFMLSDV
+         `-------------- seq6  ----------PTIIFSGCSKACSGK-----FRSFRSFMLSAV
+      """

data/lib/bio-alignment.rb

@@ -2,6 +2,9 @@
 # bioruby directory tree.
 #
 
-require 'bio-alignment/alignment'
+require 'bio-alignment/state'
+require 'bio-alignment/elements'
 require 'bio-alignment/sequence'
 require 'bio-alignment/codonsequence'
+require 'bio-alignment/tree'
+require 'bio-alignment/alignment'

data/lib/bio-alignment/alignment.rb

@@ -1,7 +1,8 @@
 # Alignment
 
 require 'bio-alignment/pal2nal'
-require 'bio-alignment/column'
+require 'bio-alignment/columns'
+require 'bio-alignment/rows'
 
 module Bio
  
@@ -10,6 +11,7 @@ module Bio
     class Alignment
       include Enumerable
       include Pal2Nal
+      include Rows
       include Columns
 
       attr_accessor :sequences
@@ -17,16 +19,22 @@ module Bio
       # Create alignment. seqs can be a list of sequences. If these
       # are String types, they get converted to the library Sequence 
       # container
-      def initialize seqs = nil
+      def initialize seqs = nil, ids = nil
         @sequences = []
         if seqs 
+          num = 0
           seqs.each_with_index do | seq, i |
+            next if seq == nil or seq.to_s.strip == ""
+            id = num
+            id = ids[i] if ids and ids[i]
             @sequences << 
               if seq.kind_of?(String)
-                Sequence.new(i,seq)
+                seq1 = Sequence.new(id,seq.strip)
+                seq1
               else
                 seq
               end
+            num += 1
           end
         end
       end
@@ -39,8 +47,55 @@ module Bio
 
       def each
         rows.each { | seq | yield seq }
+        self
       end
 
+      def each_element
+        each { |seq| seq.each { |e| yield e }}
+        self
+      end
+
+      def find name
+        each do | seq |
+          return seq if seq.id == name
+        end
+        raise "ERROR: Sequence not found by its name #{name}"
+      end
+     
+      # clopy alignment and allow updating elements
+      def update_each_element
+        aln = self.clone
+        aln.each { |seq| seq.each_with_index { |e,i| seq.seq[i] = yield e }}
+      end
+
+      def to_s
+        res = ""
+        res += "\t" + columns_to_s + "\n" if @columns
+        res += map{ |seq| seq.id.to_s + "\t" + seq.to_s }.join("\n")
+        res
+      end
+
+      # Return a deep cloned alignment. This method clones sequences,
+      # and the state objects
+      def clone
+        aln = super
+        # clone the sequences
+        aln.sequences = []
+        each do | seq |
+          aln.sequences << seq.clone
+        end
+        aln.clone_columns! if @columns
+        aln
+      end
+
+      # extend BioAlignment with Tree functionality - this method adds 
+      # a tree and pulls in the functionality of the Tree module. Returns
+      # the tree traverser
+      def attach_tree tree
+        extend Tree
+        @tree = Tree::init(tree)
+        @tree
+      end
     end
   end
 end

data/lib/bio-alignment/codonsequence.rb

@@ -6,6 +6,9 @@ module Bio
 
     # Codon element for the matrix, used by CodonSequence.
     class Codon
+      GAP = '---'
+      UNDEFINED = 'X'
+
       attr_reader :codon_table
 
       def initialize codon, codon_table = 1
@@ -14,7 +17,7 @@ module Bio
       end
 
       def gap?
-        @codon == '---'
+        @codon == GAP
       end
 
       def undefined?
@@ -36,7 +39,7 @@ module Bio
           if gap?
             return '-'
           elsif undefined?
-            return 'X'
+            return UNDEFINED
           else
             raise 'What?'
           end
@@ -46,6 +49,7 @@ module Bio
 
     private
 
+      # lazy translation of codon to amino acid
       def translate
         @aa ||= Bio::CodonTable[@codon_table][@codon]
         @aa
@@ -95,6 +99,14 @@ module Bio
       def to_aa
         @seq.map { |codon| codon.to_aa }.join('')
       end
+
+      def empty_copy
+        CodonSequence.new(@id,"")
+      end
+
+      def << codon
+        @seq << codon
+      end
         
     end