bioinform 0.1.3 → 0.1.4

data/spec/data_models/pm_spec.rb

@@ -3,96 +3,22 @@ require 'bioinform/data_models/pm'
 
 module Bioinform
   describe PM do 
-    include Parser::Helpers
-    
     describe '#valid?' do
       it 'should be true iff an argument is an array of arrays of 4 numerics in a column' do
-        PM.new.instance_eval{@matrix = [[1,2,3,4],[1,4,5,6.5]]; self }.valid?.should be_true
-        PM.new.instance_eval{@matrix = {A: [1,1], C: [2,4], G: [3,5], T: [4, 6.5]}; self }.valid?.should be_false
-        PM.new.instance_eval{@matrix = [{A:1,C:2,G:3,T:4},{A:1,C:4,G:5,T: 6.5}]; self }.valid?.should be_false
-        PM.new.instance_eval{@matrix = [[1,2,3,4],[1,4,6.5]]; self }.valid?.should be_false
-        PM.new.instance_eval{@matrix = [[1,2,3],[1,4,6.5]]; self }.valid?.should be_false
-        PM.new.instance_eval{@matrix = [[1,2,'3','4'],[1,'4','5',6.5]]; self }.valid?.should be_false
-      end
-    end
-    
-    describe '#initialize' do
-      context 'when parser specified' do
-        before :each do
-          parser_stub :ParserBad, false, { matrix: [[0,0,0,0],[1,1,1,1]], name: 'Bad' }
-          parser_stub :ParserGood, true, { matrix: [[1,1,1,1],[1,1,1,1]], name: 'Good' }
-          parser_stub :ParserWithIncompleteOutput, true, { name: 'Without `matrix` key' }
-          parser_stub :ParserGoodWithoutName, true, { matrix: [[1,1,1,1],[1,1,1,1]] }
-          parser_stub :ParserWithInvalidMatrix, true, { matrix: [[1,1,1],[1,1,1]] }
-        end
-        after :each do  
-          parser_subclasses_cleanup 
-        end
-        
-        it 'should raise an ArgumentError if parser cannot parse input' do
-          expect{ PM.new('my stub input', ParserBad) }.to raise_error ArgumentError
-        end
-        it 'should raise an ArgumentError if parser output doesn\'t have `matrix` key' do
-          expect{ PM.new('my stub input', ParserWithIncompleteOutput) }.to raise_error ArgumentError
-        end
-        it 'should raise an ArgumentError if parser output has invalid matrix' do
-          expect{ PM.new('my stub input', ParserWithInvalidMatrix) }.to raise_error ArgumentError
-        end
-        
-        context 'when parse was successful' do
-          it 'should load matrix from parser\'s resulting hash' do
-            pm = PM.new('my stub input', ParserGoodWithoutName)
-            pm.matrix.should == [[1,1,1,1],[1,1,1,1]]
-            pm.name.should be_nil
-          end
-          it 'should set other available attributes from parse resulting hash' do
-            pm = PM.new('my stub input', ParserGood)
-            pm.matrix.should == [[1,1,1,1],[1,1,1,1]]
-            pm.name.should == 'Good'
-          end
-        end
-      end
-      
-      context 'when parser not specified' do
-        after :each do
-          parser_subclasses_cleanup 
-        end
-        it 'should raise an ArgumentError if no one parser can parse input' do
-          parser_stub :ParserBad, false, { matrix: [[0,0,0,0],[1,1,1,1]], name: 'Bad' }
-          expect{ PM.new('my stub input') }.to raise_error ArgumentError
-        end
-        it 'should use first parsed which can parse input' do
-          parser_stub :ParserBad, false, { matrix: [[0,0,0,0],[1,1,1,1]], name: 'Bad' }
-          parser_stub :ParserGoodFirst, true, { matrix: [[1,1,1,1],[1,1,1,1]], name: 'GoodFirst' }
-          parser_stub :ParserGoodSecond, true, { matrix: [[1,1,1,1],[1,1,1,1]], name: 'GoodSecond' }
-          
-          pm = PM.new('my stub input')
-          pm.name.should == 'GoodFirst'
-        end
-      end
-    end
-    
-    describe '#matrix=' do
-      it 'should replace matrix if argument is a valid matrix' do
-        @pm = PM.new()
-        @pm.matrix.should be_nil
-        
-        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
-        @pm.matrix.should == [[1,2,3,4],[1,4,5,6.5]]
-        
-        @pm.matrix = [[1,4,5,6.5], [2,2,2,2]]
-        @pm.matrix.should == [[1,4,5,6.5],[2,2,2,2]]
-      end
-      it 'should raise an exception if argument isn\'t valid matrix' do
-        @pm = PM.new
-        expect{  @pm.matrix = [[1,2,3,4],[1,4,5]]  }.to raise_error
+
+        PM.new([[0,0,0,0]]).instance_eval{@matrix = [[1,2,3,4],[1,4,5,6.5]]; self }.valid?.should be_true
+        PM.new([[0,0,0,0]]).instance_eval{@matrix = {A: [1,1], C: [2,4], G: [3,5], T: [4, 6.5]}; self }.valid?.should be_false
+        PM.new([[0,0,0,0]]).instance_eval{@matrix = [{A:1,C:2,G:3,T:4},{A:1,C:4,G:5,T: 6.5}]; self }.valid?.should be_false
+        PM.new([[0,0,0,0]]).instance_eval{@matrix = [[1,2,3,4],[1,4,6.5]]; self }.valid?.should be_false
+        PM.new([[0,0,0,0]]).instance_eval{@matrix = [[1,2,3],[1,4,6.5]]; self }.valid?.should be_false
+        PM.new([[0,0,0,0]]).instance_eval{@matrix = [[1,2,'3','4'],[1,'4','5',6.5]]; self }.valid?.should be_false
+
       end
-    end
+    end        
     
     describe '#to_s' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+        @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
       end
       it 'should return string with single-tabulated multiline matrix' do
         @pm.to_s.should == "1\t2\t3\t4\n1\t4\t5\t6.5"
@@ -115,28 +41,52 @@ module Bioinform
     end
     
     describe '#pretty_string' do
-      it 'should return a string formatted with spaces'
-      it 'should contain first string of ACGT letters'
+      it 'should format string with 7-chars fields' do
+        PM.new( [[1,2,3,4],[5,6,7,8]] ).pretty_string.should == "   A      C      G      T   \n   1.0    2.0    3.0    4.0\n   5.0    6.0    7.0    8.0"
+      end
+      it 'should return a string of floats formatted with spaces' do
+        PM.new( [[1,2,3,4],[5,6,7,8]] ).pretty_string.should match(/1.0 +2.0 +3.0 +4.0 *\n *5.0 +6.0 +7.0 +8.0/)
+      end
+      it 'should contain first string of ACGT letters' do
+        PM.new( [[1,2,3,4],[5,6,7,8]] ).pretty_string.lines.first.should match(/A +C +G +T/)
+      end
+      it 'should round floats upto 3 digits' do
+        PM.new( [[1.1,2.22,3.333,4.4444],[5.5,6.66,7.777,8.8888]] ).pretty_string.should match(/1.1 +2.22 +3.333 +4.444 *\n *5.5 +6.66 +7.777 +8.889/)
+      end
+      
       context 'with name specified' do
-        it 'should contain name if parameter isn\'t false'
+        before :each do
+          @pm = PM.new( [[1.1,2.22,3.333,4.4444],[5.5,6.66,7.777,8.8888]] )
+          @pm.name = 'MyName'
+        end
+        it 'should contain name if parameter `with_name` isn\'t false' do
+          @pm.pretty_string.should match(/MyName\n/)
+        end
+        it 'should not contain name if parameter `with_name` is false' do
+          @pm.pretty_string(false).should_not match(/MyName\n/)
+        end
       end
       context 'without name specified' do
-        it 'should not contain name'
+        before :each do
+          @pm = PM.new( [[1.1,2.22,3.333,4.4444],[5.5,6.66,7.777,8.8888]] )
+        end
+        it 'should not contain name whether parameter `with_name` is or isn\'t false' do
+          @pm.pretty_string.should_not match(/MyName\n/)
+          @pm.pretty_string(false).should_not match(/MyName\n/)
+        end
       end
     end
     
     describe '#size' do
       it 'should return number of positions' do
-        @pm = PM.new
-        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+        @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
         @pm.size.should == 2
       end
     end
     
     describe '#to_hash' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+        @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
         @hsh = @pm.to_hash
       end
       it 'should return a hash with keys A, C, G, T' do
@@ -159,8 +109,7 @@ module Bioinform
     
     describe '#background' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1,2,3,4],[1,4,5,6.5]]
+        @pm = PM.new( [[1,2,3,4],[1,4,5,6.5]] )
       end
       context 'when none arguments passed' do
         context 'when pm just created' do
@@ -169,7 +118,7 @@ module Bioinform
           end
         end
         it 'should return background' do
-          @pm.instance_eval { @background = [0.2, 0.3, 0.3, 0.2] }
+          @pm.background = [0.2, 0.3, 0.3, 0.2]
           @pm.background.should == [0.2, 0.3, 0.3, 0.2]
         end
       end
@@ -181,15 +130,14 @@ module Bioinform
       end
       context 'when more than one argument passed' do
         it 'should raise an ArgumentError' do
-          expect { @pm.background(:first, :second, :third) }.to raise_error ArgumentError
+          expect { @pm.background(:first, :second) }.to raise_error ArgumentError
         end
       end
     end
     
     describe '#reverse_complement!' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1, 2, 3, 4], [1, 4, 5, 6.5]]
+        @pm = PM.new( [[1, 2, 3, 4], [1, 4, 5, 6.5]] )
       end
       it 'should return pm object itself' do
         @pm.reverse_complement!.should be_equal(@pm)
@@ -202,8 +150,7 @@ module Bioinform
     
     describe '#left_augment!' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1, 2, 3, 4], [1, 4, 5, 6.5]]
+        @pm = PM.new( [[1, 2, 3, 4], [1, 4, 5, 6.5]] )
       end
       it 'should return pm object itself' do
         @pm.left_augment!(2).should be_equal(@pm)
@@ -216,8 +163,7 @@ module Bioinform
     
     describe '#right_augment!' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1, 2, 3, 4], [1, 4, 5, 6.5]]
+        @pm = PM.new( [[1, 2, 3, 4], [1, 4, 5, 6.5]] )
       end
       it 'should return pm object itself' do
         @pm.right_augment!(2).should be_equal(@pm)
@@ -230,8 +176,7 @@ module Bioinform
     
     describe '#shift_to_zero!' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1, 2, 3, 4], [5, 6.5, 3, 4]]
+        @pm = PM.new( [[1, 2, 3, 4], [5, 6.5, 3, 4]] )
       end
       it 'should return pm object itself' do
         @pm.shift_to_zero!.should be_equal(@pm)
@@ -244,8 +189,7 @@ module Bioinform
     
     describe '#discrete!' do
       before :each do
-        @pm = PM.new
-        @pm.matrix = [[1.3, 2.0, 3.2, 4.9], [6.51, 6.5, 3.25, 4.633]]
+        @pm = PM.new( [[1.3, 2.0, 3.2, 4.9], [6.51, 6.5, 3.25, 4.633]] )
       end
       it 'should return pm object itself' do
         @pm.discrete!(10).should be_equal(@pm)
@@ -262,28 +206,10 @@ module Bioinform
       end
     end
     
-    describe '#background_sum' do
-      before :each do
-        @pm = PM.new
-        @pm.matrix = [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6]]
-      end
-      context 'when background is [1,1,1,1]' do
-        it 'should be 4' do
-          @pm.background_sum.should == 4
-        end
-      end
-      it 'should be sum of background' do
-        @pm.background( [0.2, 0.3, 0.3, 0.2] )
-        @pm.background_sum.should == 1.0
-      end
-    end
-    
     describe '#vocabulary_volume' do
       before :each do
-        @pm_2_positions = PM.new
-        @pm_2_positions.matrix = [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6]]
-        @pm_3_positions = PM.new
-        @pm_3_positions.matrix = [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6], [1, 2, 3, 4]]
+        @pm_2_positions = PM.new( [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6]] )
+        @pm_3_positions = PM.new( [[1.3, 2.0, 3.2, 4.9], [5.0, 6.5, 3.2, 4.6], [1, 2, 3, 4]] )
       end
       context 'when background is [1,1,1,1]' do
         it 'should be equal to number of words' do
@@ -294,33 +220,30 @@ module Bioinform
       context 'when background is normalized probabilities' do
         it 'should be 1.0' do
           @pm_2_positions.background( [0.2, 0.3, 0.3, 0.2] )
-          @pm_2_positions.background_sum.should == 1.0
+          @pm_2_positions.vocabulary_volume.should == 1.0
           
           @pm_3_positions.background( [0.2, 0.3, 0.3, 0.2] )
-          @pm_3_positions.background_sum.should == 1.0
+          @pm_3_positions.vocabulary_volume.should == 1.0
         end
       end
     end
     
     describe '#best_score' do
       it 'should be equal to best score' do
-        @pm = PM.new
-        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
         @pm.best_score.should == 4.9 + 7.13 + (-1.0)
       end
     end
     describe '#worst_score' do
       it 'should be equal to worst score' do
-        @pm = PM.new
-        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
         @pm.worst_score.should == 1.3 + 3.25 + (-1.5)
       end
     end
     
     describe '#best_suffix' do
       it 'should return maximal score of suffices from i-th position inclusively i.e. [i..end]' do
-        @pm = PM.new
-        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
         @pm.best_suffix(0).should == (4.9 + 7.13 - 1.0)
         @pm.best_suffix(1).should == (7.13 - 1.0)
         @pm.best_suffix(2).should == (-1.0)
@@ -329,8 +252,7 @@ module Bioinform
     end
     describe '#worst_suffix' do
       it 'should return minimal score of suffices from i-th position inclusively i.e. [i..end]' do
-        @pm = PM.new
-        @pm.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+        @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
         @pm.worst_suffix(0).should == (1.3 + 3.25 - 1.5)
         @pm.worst_suffix(1).should == (3.25 - 1.5)
         @pm.worst_suffix(2).should == (- 1.5)
@@ -341,10 +263,8 @@ module Bioinform
     [:shift_to_zero, :reverse_complement].each do |meth|
       describe "nonbang method #{meth}" do
         before :each do
-          @pm = PM.new
-          @pm.matrix =   [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
-          @pm_2 = PM.new
-          @pm_2.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+          @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
+          @pm_2 = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
         end
         it 'should return copy of object not object itself' do
           @pm.send(meth).should_not be_equal @pm
@@ -358,10 +278,8 @@ module Bioinform
     [:discrete , :left_augment, :right_augment].each do |meth|
       describe "nonbang method #{meth}" do
         before :each do
-          @pm = PM.new
-          @pm.matrix =   [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
-          @pm_2 = PM.new
-          @pm_2.matrix = [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]]
+          @pm = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
+          @pm_2 = PM.new( [[1.3, 2.0, 4.9, 3.2], [7.13, 6.5, 3.25, 4.633], [-1.0, -1.0, -1.5, -1.0]] )
         end
         it 'should return copy of object not object itself' do
           @pm.send(meth, 2).should_not be_equal @pm

data/spec/data_models/pwm_spec.rb

@@ -5,13 +5,11 @@ module Bioinform
   describe PWM do
     describe '#score_mean' do
       it 'should be equal to a mean score of pwm' do
-        pwm = PWM.new
-        pwm.matrix = [[1,2,1,2],[4,6,8,6],[2,2,2,2]]
+        pwm = PWM.new( [[1,2,1,2],[4,6,8,6],[2,2,2,2]] )
         pwm.score_mean.should == 1.5 + 6 + 2
       end
       it 'should be equal to a mean score of pwm by measure induced from background probability mean' do
-        pwm = PWM.new.background([0.2, 0.3, 0.3, 0.2])
-        pwm.matrix = [[1,2,1,2],[4,6,8,6],[2,2,2,2]]
+        pwm = PWM.new( [[1,2,1,2],[4,6,8,6],[2,2,2,2]] ).background([0.2, 0.3, 0.3, 0.2])
         pwm.score_mean.should == ((0.2*1+0.3*2+0.3*1+0.2*2) + (0.2*4+0.3*6+0.3*8+0.2*6) + (0.2*2+0.3*2+0.3*2+0.2*2)) / (0.2+0.3+0.3+0.2)
       end
     end
@@ -24,9 +22,7 @@ module Bioinform
 
     describe '#score' do
       let(:pwm) do
-        pwm = PWM.new
-        pwm.matrix = [[10000,20000,30000,40000],[1000,2000,3000,4000],[100,200,300,400],[10,20,30,40],[1,2,3,4]]
-        pwm
+        PWM.new( [[10000,20000,30000,40000],[1000,2000,3000,4000],[100,200,300,400],[10,20,30,40],[1,2,3,4]] )
       end
       it 'should evaluate to score of given word' do
         pwm.score('aAAAA').should == 11111

data/spec/parsers/parser_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'bioinform/parsers/parser'
+
+module Bioinform
+  describe Parser do
+    good_cases = {
+      'Array Nx4' => {input: [[0,1,2,3],[10,11,12,13]], 
+                        matrix: [[0,1,2,3],[10,11,12,13]] },
+                        
+      'Array 4xN' => {input: [[0,10],[1,11],[2,12],[3,13]],
+                        matrix: [[0,1,2,3],[10,11,12,13]] },
+                        
+      'Hash A,C,G,T => Arrays' => { input: {:A => [0,10], :c => [1,11],'g' => [2,12],'T' => [3,13]}, 
+                                    matrix: [[0,1,2,3],[10,11,12,13]] },
+                                    
+      'Hash array of hashes' => { input: [{:A => 0,:c => 1,'g' => 2,'T' => 3}, {:A => 10,:c => 11,'g' => 12,'T' => 13}],
+                                  matrix: [[0,1,2,3],[10,11,12,13]] },
+                                  
+      'Array 4x4 (rows treated as positions, columns are treated as letter)' => { input: [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]],
+                                                                                  matrix: [[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]] },
+                                                                                  
+      'Hash A,C,G,T => 4-Arrays' => { input: {:A => [0,10,100,1000], :c => [1,11,101,1001],'g' => [2,12,102,1002],'T' => [3,13,103,1003]},
+                                      matrix: [[0,1,2,3],[10,11,12,13],[100,101,102,103],[1000,1001,1002,1003]] },
+                                      
+      '4-Arrays of A,C,G,T hashes' => { input: [{:A => 0, :c => 1, 'g' => 2, 'T' => 3},
+                                                {:A => 10, :c => 11, 'g' => 12, 'T' => 13},
+                                                {:A => 100, :c => 101, 'g' => 102, 'T' => 103},
+                                                {:A => 1000, :c => 1001, 'g' => 1002, 'T' => 1003}],
+                                        matrix: [[0,1,2,3],[10,11,12,13],[100,101,102,103],[1000,1001,1002,1003]] }
+    }
+    
+    bad_cases = {
+      'Different sizes of row arrays' => {input: [[1,2,3,4],[5,6,7,8,9]] },
+      
+      'Different sizes of column arrays' => {input: [[0,10],[1,11],[2,12],[3]] },
+      
+      'No one dimension have size 4' => {input: [[0,1,2,3,4],[10,11,12,13,14], [0,1,2,3,4]] },
+      
+      'Missing keys in column hashes' => {input: [{:A => 0, :c => 1, 'g' => 2, 'T' => 3},
+                                                     {:A => 10, :c => 11, 'g' => 12}] },
+      'Bad keys in column hashes' => {input: [{:A => 0, :c => 1, 'g' => 2, 'T' => 3},
+                                                  {:A => 10, :c => 11, 'g' => 12, :X =>1000}] },
+                                                  
+      'Excessing keys in column hashes' => { input: [{:A => 0,:c => 1,'g' => 2,'T' => 3},
+                                                     {:A => 10,:c => 11,'g' => 12,'T' => 13, :X => 1000}] },
+
+      'Different sizes of row hashes' => {input: {:A => [0,10], :c => [1,11],'g' => [2,12],'T' => [3,13,14]} },
+      
+      'Missing keys in row hashes' => {input: {:A => [0,10], :c => [1,11],'g' => [2,12]} },
+      
+      'Wrong keys in row hashes' => {input: {:A => [0,10], :c => [1,11],'X' => [2,12]} },
+      
+      'Excessing keys in row hashes' => {input: {:A => [0,10], :c => [1,11],'g' => [2,12], 'T' => [3,12], :X => [4,14]} }
+    }
+    
+    parser_specs(Parser, good_cases, bad_cases)
+  end
+end

data/spec/parsers/string_fantom_parser_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'bioinform/parsers/string_fantom_parser'
+
+module Bioinform    
+  describe StringFantomParser do
+    good_cases = {
+      'string in Fantom-format' => {input: "
+          NA  motif_CTNCAG					
+          P0	A	C	G	T	
+          P1	0	1878368	0	0	
+          P2	0	0	0	1878368	
+          P3	469592	469592	469592	469592	
+          P4	0	1878368	0	0	
+          P5	1878368	0	0	0	
+          P6	0	0	1878368	0",
+          matrix: [[0.0, 1878368.0, 0.0, 0.0], 
+                    [0.0, 0.0, 0.0, 1878368.0], 
+                    [469592.0, 469592.0, 469592.0, 469592.0], 
+                    [0.0, 1878368.0, 0.0, 0.0], 
+                    [1878368.0, 0.0, 0.0, 0.0], 
+                    [0.0, 0.0, 1878368.0, 0.0]] }      
+    }
+    
+    bad_cases = { }
+  
+    parser_specs(StringFantomParser, good_cases, bad_cases)
+  end
+end

data/spec/parsers/string_parser_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'bioinform/parsers/string_parser'
+
+module Bioinform
+  describe StringParser do
+    good_cases = {
+      'Nx4 string' => {input: "1 2 3 4\n5 6 7 8", 
+                      matrix: [[1,2,3,4],[5,6,7,8]] },
+                      
+      '4xN string' => {input: "1 5\n2 6\n3 7\n 4 8", 
+                      matrix: [[1,2,3,4],[5,6,7,8]] },
+                      
+      'string with name' => {input: "TestMatrix\n1 5\n2 6\n3 7\n 4 8", 
+                            matrix: [[1,2,3,4],[5,6,7,8]], name: 'TestMatrix' },
+                            
+      'string with name (with introduction sign)' => {input: ">\t TestMatrix\n1 5\n2 6\n3 7\n 4 8",
+                                                      matrix: [[1,2,3,4],[5,6,7,8]],
+                                                      name: 'TestMatrix' },
+                                                      
+      'string with name (with special characters)' => {input: "Testmatrix_first:subname+sub-subname\n1 5\n2 6\n3 7\n 4 8", 
+                            matrix: [[1,2,3,4],[5,6,7,8]], name: 'Testmatrix_first:subname+sub-subname' },
+
+      'string with float numerics' => {input: "1.23 4.56 7.8 9.0\n9 -8.7 6.54 -3210",
+                                      matrix: [[1.23, 4.56, 7.8, 9.0], [9, -8.7, 6.54, -3210]]},
+      
+      'string with exponents' => {input: "123e-2 0.456e+1 7.8 9.0\n9 -87000000000E-10 6.54 -3.210e3",
+                                  matrix: [[1.23, 4.56, 7.8, 9.0], [9, -8.7, 6.54, -3210]]},
+
+      'string with multiple spaces and tabs' => {input: "1 \t\t 2 3 4\n 5 6   7 8", 
+                                                matrix: [[1,2,3,4],[5,6,7,8]] },
+      
+      'string with preceeding and terminating newlines' => {input: "\n\n\t 1 2 3 4\n5 6 7 8  \n\t\n", 
+                      matrix: [[1,2,3,4],[5,6,7,8]] },
+      
+      'string with windows crlf' => {input: "1 2 3 4\r\n5 6 7 8",
+                      matrix: [[1,2,3,4],[5,6,7,8]] }      
+    }
+    
+    bad_cases = {
+      'string with non-numeric input' =>  {input: "1.23 4.56 78aaa 9.0\n9 -8.7 6.54 -3210" },
+      'string with empty exponent sign' => {input: "1.23 4.56 7.8 9.0\n 9e -8.7 6.54 3210" }
+    }
+  
+    parser_specs(StringParser, good_cases, bad_cases)
+  end
+end

data/spec/spec_helper.rb

@@ -2,27 +2,19 @@ $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
 $LOAD_PATH.unshift File.dirname(__FILE__)
 
 require 'rspec'
-module Bioinform
-  class Parser
-    module Helpers
-      def parser_stub(class_name, can_parse, result)
-        klass = Class.new(Parser) do
-          define_method :can_parse? do can_parse end
-          define_method :parse do result end
-        end
-        #class_levels = class_name.to_s.split('::')
-        #class_levels[0..-2].inject(Object){|klass, level| klass.const_get level}.const_set(class_name, class_levels.last)
-        Bioinform.const_set(class_name.to_s.split('::').last, klass)
-      end
-      def parser_subclasses_cleanup          
-        Parser.subclasses.each do |klass|
-          #class_levels = klass.to_s.split('::')
-          #class_levels[0..-2].inject(Object){|klass, level| klass.const_get level}.const_set(class_name, class_levels.last)
-          
-          Bioinform.send :remove_const, klass.name.split('::').last
-        end
-        Parser.subclasses.clear
-      end
+
+def parser_specs(parser_klass, good_cases, bad_cases)
+  good_cases.each do |case_description, input_and_result|
+    it "should be able to parse #{case_description}" do
+      result = parser_klass.new(input_and_result[:input]).parse
+      result[:matrix].should == input_and_result[:matrix]
+      result[:name].should == input_and_result[:name] if input_and_result.has_key?(:name)
+    end
+  end
+  
+  bad_cases.each do |case_description, input|
+    it "should fail silently returning {} on parsing #{case_description}" do
+      parser_klass.new(input[:input]).parse.should == {}
     end
   end
 end

data/spec/support/multiline_squish_spec.rb

@@ -3,9 +3,17 @@ require 'bioinform/support/multiline_squish'
 
 describe String do
   describe '#multiline_squish' do
-    it 'should replace multiple spaces with one space'
-    it 'should replace tabs with a space'
-    it 'should replace \r\n with \n'
-    it 'should preserve rows pagination'
+    it 'should replace multiple spaces with one space' do
+      "abc def   ghi\n  jk  lmn".multiline_squish.should == "abc def ghi\njk lmn"
+    end
+    it 'should replace tabs with a space' do
+      "abc\tdef   ghi \t jk".multiline_squish.should == 'abc def ghi jk'
+    end
+    it 'should replace \r\n with \n' do
+      "abc def ghi\r\njk lmn".multiline_squish.should == "abc def ghi\njk lmn"
+    end
+    it 'should preserve rows pagination' do
+      "abc def ghi\njk lmn".multiline_squish.should == "abc def ghi\njk lmn"
+    end
   end
 end

data/spec/support/partial_sums_spec.rb

@@ -1,3 +1,6 @@
+require 'spec_helper'
+require 'bioinform/support/partial_sums'
+
 describe 'Array#partial_sums' do
   context 'when no initial value given' do
     it 'should return an array of the same size with partial sums of elements 0..ind inclusive with float elements' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bioinform
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-19 00:00:00.000000000 Z
+date: 2012-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -59,16 +59,14 @@ files:
 - lib/bioinform.rb
 - lib/bioinform/data_models.rb
 - lib/bioinform/data_models/collection.rb
-- lib/bioinform/data_models/parser.rb
-- lib/bioinform/data_models/parsers.rb
-- lib/bioinform/data_models/parsers/array_parser.rb
-- lib/bioinform/data_models/parsers/hash_parser.rb
-- lib/bioinform/data_models/parsers/string_fantom_parser.rb
-- lib/bioinform/data_models/parsers/string_parser.rb
 - lib/bioinform/data_models/pcm.rb
 - lib/bioinform/data_models/pm.rb
 - lib/bioinform/data_models/ppm.rb
 - lib/bioinform/data_models/pwm.rb
+- lib/bioinform/parsers.rb
+- lib/bioinform/parsers/parser.rb
+- lib/bioinform/parsers/string_fantom_parser.rb
+- lib/bioinform/parsers/string_parser.rb
 - lib/bioinform/support.rb
 - lib/bioinform/support/array_product.rb
 - lib/bioinform/support/array_zip.rb
@@ -83,13 +81,12 @@ files:
 - lib/bioinform/support/same_by.rb
 - lib/bioinform/support/yaml_dump_file.rb
 - lib/bioinform/version.rb
-- spec/data_models/parser_spec.rb
-- spec/data_models/parsers/array_parser_spec.rb
-- spec/data_models/parsers/hash_parser_spec.rb
-- spec/data_models/parsers/string_fantom_parser_spec.rb
-- spec/data_models/parsers/string_parser_spec.rb
+- spec/data_models/pcm_spec.rb
 - spec/data_models/pm_spec.rb
 - spec/data_models/pwm_spec.rb
+- spec/parsers/parser_spec.rb
+- spec/parsers/string_fantom_parser_spec.rb
+- spec/parsers/string_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/array_product_spec.rb
 - spec/support/array_zip_spec.rb
@@ -129,13 +126,12 @@ summary: Classes for work with different input formats of positional matrices an
   several useful extensions for Enumerable module like parametric map and callable
   symbols
 test_files:
-- spec/data_models/parser_spec.rb
-- spec/data_models/parsers/array_parser_spec.rb
-- spec/data_models/parsers/hash_parser_spec.rb
-- spec/data_models/parsers/string_fantom_parser_spec.rb
-- spec/data_models/parsers/string_parser_spec.rb
+- spec/data_models/pcm_spec.rb
 - spec/data_models/pm_spec.rb
 - spec/data_models/pwm_spec.rb
+- spec/parsers/parser_spec.rb
+- spec/parsers/string_fantom_parser_spec.rb
+- spec/parsers/string_parser_spec.rb
 - spec/spec_helper.rb
 - spec/support/array_product_spec.rb
 - spec/support/array_zip_spec.rb