bioinform 0.1.12 → 0.1.13

data/spec/fabricators/pm_fabricator.rb

@@ -1,52 +1,52 @@
-Fabricator(:pm, class_name: Bioinform::PM) do
-  initialize_with{ Bioinform::PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'PM_name') }
-end
-
-Fabricator(:pm_unnamed, from: :pm) do
-  name nil
-end
-
-
-Fabricator(:pm_first, from: :pm) do
-  name 'PM_first'
-end
-
-Fabricator(:pm_second, from: :pm) do
-  matrix [[15,16,17,18],[11,21,31,41]]
-  name 'PM_second'
-end
-
-
-Fabricator(:pm_4x4, from: :pm) do
-  matrix [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
-end
-
-Fabricator(:pm_4x4_unnamed, from: :pm_4x4) do
-  name nil
-end
-
-Fabricator(:pm_with_floats, from: :pm_unnamed) do
-  matrix [[1.23, 4.56, 7.8, 9.0], [9, -8.7, 6.54, -3210]]
-end
-
-Fabricator(:pm_1, from: :pm) do
-  matrix [[0,1,2,3],[4,5,6,7]]
-  name 'motif_1'
-end
-Fabricator(:pm_2, from: :pm) do
-  matrix [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
-  name 'motif_2'
-end
-Fabricator(:pm_3, from: :pm) do
-  matrix [[2,3,4,5],[6,7,8,9]]
-  name 'motif_3'
-end
-
-Fabricator(:pm_4,from: :pm) do
-  matrix [[1,0,1,0],[0,0,0,0],[1,2,3,4]]
-  name 'pm 4'
-end
-Fabricator(:pm_5, from: :pm) do
-  matrix [[1,2,1,2],[0,3,6,9],[1,2,3,4]]
-  name 'pm 5'
+Fabricator(:pm, class_name: Bioinform::PM) do
+  initialize_with{ Bioinform::PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'PM_name') }
+end
+
+Fabricator(:pm_unnamed, from: :pm) do
+  name nil
+end
+
+
+Fabricator(:pm_first, from: :pm) do
+  name 'PM_first'
+end
+
+Fabricator(:pm_second, from: :pm) do
+  matrix [[15,16,17,18],[11,21,31,41]]
+  name 'PM_second'
+end
+
+
+Fabricator(:pm_4x4, from: :pm) do
+  matrix [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
+end
+
+Fabricator(:pm_4x4_unnamed, from: :pm_4x4) do
+  name nil
+end
+
+Fabricator(:pm_with_floats, from: :pm_unnamed) do
+  matrix [[1.23, 4.56, 7.8, 9.0], [9, -8.7, 6.54, -3210]]
+end
+
+Fabricator(:pm_1, from: :pm) do
+  matrix [[0,1,2,3],[4,5,6,7]]
+  name 'motif_1'
+end
+Fabricator(:pm_2, from: :pm) do
+  matrix [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+  name 'motif_2'
+end
+Fabricator(:pm_3, from: :pm) do
+  matrix [[2,3,4,5],[6,7,8,9]]
+  name 'motif_3'
+end
+
+Fabricator(:pm_4,from: :pm) do
+  matrix [[1,0,1,0],[0,0,0,0],[1,2,3,4]]
+  name 'pm 4'
+end
+Fabricator(:pm_5, from: :pm) do
+  matrix [[1,2,1,2],[0,3,6,9],[1,2,3,4]]
+  name 'pm 5'
 end

data/spec/fabricators/ppm_fabricator.rb

@@ -1,14 +1,14 @@
-Fabricator(:ppm, class_name: Bioinform::PPM) do
-  initialize_with{ Bioinform::PPM.new(matrix: [[0.2, 0.3, 0.3, 0.2],[0.7, 0.2, 0.0, 0.1]]) }
-  name 'PPM_name'
-end
-
-# It has the same name as original pcm because PCM#to_ppm doesn't change the name
-Fabricator(:ppm_by_pcm, class_name: Bioinform::PPM) do
-  initialize_with{ Fabricate(:pcm).to_ppm }
-end
-
-Fabricator(:ppm_pcm_divided_by_count, from: :ppm) do
-# this matrix should be initialized manually - it's used for spec checking PCM#to_ppm
-  matrix [[1.0/7.0, 2.0/7.0, 3.0/7.0, 1.0/7.0], [4.0/7.0, 0.0/7.0, 1.0/7.0, 2.0/7.0]]
+Fabricator(:ppm, class_name: Bioinform::PPM) do
+  initialize_with{ Bioinform::PPM.new(matrix: [[0.2, 0.3, 0.3, 0.2],[0.7, 0.2, 0.0, 0.1]]) }
+  name 'PPM_name'
+end
+
+# It has the same name as original pcm because PCM#to_ppm doesn't change the name
+Fabricator(:ppm_by_pcm, class_name: Bioinform::PPM) do
+  initialize_with{ Fabricate(:pcm).to_ppm }
+end
+
+Fabricator(:ppm_pcm_divided_by_count, from: :ppm) do
+# this matrix should be initialized manually - it's used for spec checking PCM#to_ppm
+  matrix [[1.0/7.0, 2.0/7.0, 3.0/7.0, 1.0/7.0], [4.0/7.0, 0.0/7.0, 1.0/7.0, 2.0/7.0]]
 end

data/spec/fabricators/pwm_fabricator.rb

@@ -1,16 +1,16 @@
-Fabricator(:pwm, class_name: Bioinform::PWM) do
-  initialize_with{ Bioinform::PWM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'PWM_name')}
-end
-
-# It has name 'PCM_name' because name isn't converted during #to_pwm
-Fabricator(:pwm_by_pcm, class_name: Bioinform::PWM) do
-  initialize_with{ Fabricate(:pcm).to_pwm }
-end
-
-Fabricator(:rounded_upto_3_digits_pwm_by_pcm_with_pseudocount_1, from: :pwm) do
-  matrix [[-0.47, 0.118, 0.486, -0.47],[0.754, -2.079, -0.47, 0.118]]
-end
-
-Fabricator(:rounded_upto_3_digits_pwm_by_pcm_with_pseudocount_10, from: :pwm) do
-  matrix [[-0.194, 0.057, 0.258, -0.194],[0.425, -0.531, -0.194, 0.057]]
-end
+Fabricator(:pwm, class_name: Bioinform::PWM) do
+  initialize_with{ Bioinform::PWM.new(matrix: [[1,2,3,4],[5,6,7,8]], name: 'PWM_name')}
+end
+
+# It has name 'PCM_name' because name isn't converted during #to_pwm
+Fabricator(:pwm_by_pcm, class_name: Bioinform::PWM) do
+  initialize_with{ Fabricate(:pcm).to_pwm }
+end
+
+Fabricator(:rounded_upto_3_digits_pwm_by_pcm_with_pseudocount_1, from: :pwm) do
+  matrix [[-0.47, 0.118, 0.486, -0.47],[0.754, -2.079, -0.47, 0.118]]
+end
+
+Fabricator(:rounded_upto_3_digits_pwm_by_pcm_with_pseudocount_10, from: :pwm) do
+  matrix [[-0.194, 0.057, 0.258, -0.194],[0.425, -0.531, -0.194, 0.057]]
+end

data/spec/parsers/parser_spec.rb

@@ -1,152 +1,152 @@
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/parsers/parser'
-
-module Bioinform
-  describe Parser do
-    context '#initialize' do
-      it 'should accept an array correctly' do
-        Parser.new([[1,2,3,4],[5,6,7,8]]).parse.matrix.should == [[1,2,3,4],[5,6,7,8]]
-      end
-      it 'should treat several arguments as an array composed of them' do
-        Parser.new([1,2,3,4],[5,6,7,8]).parse.should == Parser.new([[1,2,3,4],[5,6,7,8]]).parse
-      end
-      it 'should treat one Array of numbers as an Array(with 1 element) of Arrays' do
-        Parser.new([1,2,3,4]).parse.should == Parser.new([[1,2,3,4]]).parse
-      end
-    end
-
-    context '::parse!' do
-      it 'should behave like Parser.new(input).parse!' do
-        Parser.parse!([1,2,3,4],[5,6,7,8]).should  == Parser.new([1,2,3,4],[5,6,7,8]).parse!
-        expect{ Parser.parse!([1,2,3],[4,5,6]) }.to raise_error
-      end
-    end
-
-    context '::parse' do
-      it 'should behave like Parser.new(input).parse!' do
-        Parser.parse([1,2,3,4],[5,6,7,8]).should  == Parser.new([1,2,3,4],[5,6,7,8]).parse
-        Parser.parse([1,2,3],[4,5,6]).should be_nil
-      end
-    end
-
-    context '::choose' do
-      it 'should create parser of appropriate type' do
-        Parser.choose([[1,2,3,4],[5,6,7,8]]).should be_kind_of(Parser)
-        Parser.choose([[1,2,3,4],[5,6,7,8]]).input.should == [[1,2,3,4],[5,6,7,8]]
-        Parser.choose(matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name').should be_kind_of(TrivialParser)
-        Parser.choose(matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name').input.should == {matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name'}
-        Parser.choose("1 2 3 4\n5 6 7 8").should be_kind_of(StringParser)
-        Parser.choose("1 2 3 4\n5 6 7 8").input.should == "1 2 3 4\n5 6 7 8"
-      end
-    end
-
-    context '::split_on_motifs' do
-      it 'should be able to get a single PM' do
-        Parser.split_on_motifs([[1,2,3,4],[5,6,7,8]], PM).should == [ PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name:nil) ]
-      end
-    end
-
-    context '::normalize_hash_keys' do
-      it 'should convert both symbolic and string keys, in both upcase and downcase to symbolic upcases' do
-        Parser.normalize_hash_keys( {a: 1, C: 2, 'g' => 3, 'T' => 4} ).should == {A: 1, C: 2, G: 3, T: 4}
-      end
-    end
-
-    context '::need_transpose?' do
-      it 'should point whether matrix have positions(need not be transposed -- false) or letters(true) as first index' do
-        Parser.need_tranpose?([[1,3,5,7], [2,4,6,8]]).should be_false
-        Parser.need_tranpose?([[1,2],[3,4],[5,6],[7,8]]).should be_true
-      end
-    end
-    context '::array_from_acgt_hash' do
-      it 'should convert hash of arrays to a transposed array of arrays' do
-        input = {A: [1,2,3], C: [2,3,4], G: [3,4,5], T: [4,5,6]}
-        Parser.array_from_acgt_hash(input).should == [[1,2,3], [2,3,4], [3,4,5], [4,5,6]].transpose
-      end
-      it 'should convert hash of numbers to an array of numbers' do
-        input = {A: 1, C: 2, G: 3, T: 4}
-        Parser.array_from_acgt_hash(input).should == [1,2,3,4]
-      end
-      it 'should process both symbolic and string keys, in both upcase and downcase' do
-        input_normal_keys = {A: 1, C: 2, G: 3, T: 4}
-        input_different_keys = {:A => 1, :c => 2, 'g' => 3, 'T' => 4}
-        Parser.array_from_acgt_hash(input_different_keys).should == Parser.array_from_acgt_hash(input_normal_keys)
-      end
-    end
-
-    context '::try_convert_to_array' do
-      it 'should not change array' do
-        inputs = []
-        inputs << [[1,2,3,4], [2,3,4,5], [3,4,5,6]]
-        inputs << [{A:1, C:2, G:3, T:4}, {A:2, C:3, G:4, T:5}, {A:3, C:4, G:5, T:6}]
-        inputs.each do |input|
-          Parser.try_convert_to_array( input ).should == input
-        end
-      end
-      it 'should convert ACGT-Hashes to an array of positions (not letters)' do
-        Parser.try_convert_to_array( {:A => [1,2,3], :c => [2,3,4], 'g' => [3,4,5], 'T' => [4,5,6]} ).should == [[1,2,3],[2,3,4],[3,4,5],[4,5,6]].transpose
-      end
-    end
-
-    context '#parse' do
-      it 'should give the same result as #parse!' do
-        parser = Parser.new('stub parser')
-        parser.stub(:parse!).and_return('stub result')
-        parser.parse.should == 'stub result'
-      end
-      it 'should return nil if #parse! raised an exception' do
-        parser = Parser.new('stub parser')
-        parser.stub(:parse!).and_raise
-        parser.parse.should be_nil
-      end
-    end
-
-    good_cases = {
-      'Array Nx4' => {input: [[1,2,3,4],[5,6,7,8]],
-                      result: Fabricate(:pm_unnamed) },
-
-      'Array 4xN' => {input: [[1,5],[2,6],[3,7],[4,8]],
-                      result: Fabricate(:pm_unnamed) },
-
-      'Hash A,C,G,T => Arrays' => { input: {:A => [1,5], :c => [2,6],'g' => [3,7],'T' => [4,8]},
-                                    result: Fabricate(:pm_unnamed) },
-
-      'Hash array of hashes' => { input: [{:A => 1,:c => 2,'g' => 3,'T' => 4}, {:A => 5,:c => 6,'g' => 7,'T' => 8}],
-                                  result: Fabricate(:pm_unnamed) },
-
-      'Array 4x4 (rows treated as positions, columns are treated as letter)' => { input: [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]],
-                                                                                  result: Fabricate(:pm_4x4_unnamed) },
-
-      'Hash A,C,G,T => 4-Arrays' => { input: {:A => [1,5,9,13], :c => [2,6,10,14],'g' => [3,7,11,15],'T' => [4,8,12,16]},
-                                      result: Fabricate(:pm_4x4_unnamed) },
-
-      '4-Arrays of A,C,G,T hashes' => { input: [{:A => 1, :c => 2, 'g' => 3, 'T' => 4},
-                                                {:A => 5, :c => 6, 'g' => 7, 'T' => 8},
-                                                {:A => 9, :c => 10, 'g' => 11, 'T' => 12},
-                                                {:A => 13, :c => 14, 'g' => 15, 'T' => 16}],
-                                        result: Fabricate(:pm_4x4_unnamed) }
-    }
-
-    bad_cases = {
-      'Nil object on input' => {input: nil},
-      'Empty array on input' => {input: []},
-      '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)
-    context '#parser!' do
-      it "should raise an exception on parsing empty list to parser" do
-        expect{ Parser.new().parse! }.to raise_error
-      end
-    end
-  end
-end
+require_relative '../spec_helper'
+require_relative '../../lib/bioinform/parsers/parser'
+
+module Bioinform
+  describe Parser do
+    context '#initialize' do
+      it 'should accept an array correctly' do
+        Parser.new([[1,2,3,4],[5,6,7,8]]).parse.matrix.should == [[1,2,3,4],[5,6,7,8]]
+      end
+      it 'should treat several arguments as an array composed of them' do
+        Parser.new([1,2,3,4],[5,6,7,8]).parse.should == Parser.new([[1,2,3,4],[5,6,7,8]]).parse
+      end
+      it 'should treat one Array of numbers as an Array(with 1 element) of Arrays' do
+        Parser.new([1,2,3,4]).parse.should == Parser.new([[1,2,3,4]]).parse
+      end
+    end
+
+    context '::parse!' do
+      it 'should behave like Parser.new(input).parse!' do
+        Parser.parse!([1,2,3,4],[5,6,7,8]).should  == Parser.new([1,2,3,4],[5,6,7,8]).parse!
+        expect{ Parser.parse!([1,2,3],[4,5,6]) }.to raise_error
+      end
+    end
+
+    context '::parse' do
+      it 'should behave like Parser.new(input).parse!' do
+        Parser.parse([1,2,3,4],[5,6,7,8]).should  == Parser.new([1,2,3,4],[5,6,7,8]).parse
+        Parser.parse([1,2,3],[4,5,6]).should be_nil
+      end
+    end
+
+    context '::choose' do
+      it 'should create parser of appropriate type' do
+        Parser.choose([[1,2,3,4],[5,6,7,8]]).should be_kind_of(Parser)
+        Parser.choose([[1,2,3,4],[5,6,7,8]]).input.should == [[1,2,3,4],[5,6,7,8]]
+        Parser.choose(matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name').should be_kind_of(TrivialParser)
+        Parser.choose(matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name').input.should == {matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name'}
+        Parser.choose("1 2 3 4\n5 6 7 8").should be_kind_of(StringParser)
+        Parser.choose("1 2 3 4\n5 6 7 8").input.should == "1 2 3 4\n5 6 7 8"
+      end
+    end
+
+    context '::split_on_motifs' do
+      it 'should be able to get a single PM' do
+        Parser.split_on_motifs([[1,2,3,4],[5,6,7,8]], PM).should == [ PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name:nil) ]
+      end
+    end
+
+    context '::normalize_hash_keys' do
+      it 'should convert both symbolic and string keys, in both upcase and downcase to symbolic upcases' do
+        Parser.normalize_hash_keys( {a: 1, C: 2, 'g' => 3, 'T' => 4} ).should == {A: 1, C: 2, G: 3, T: 4}
+      end
+    end
+
+    context '::need_transpose?' do
+      it 'should point whether matrix have positions(need not be transposed -- false) or letters(true) as first index' do
+        Parser.need_tranpose?([[1,3,5,7], [2,4,6,8]]).should be_false
+        Parser.need_tranpose?([[1,2],[3,4],[5,6],[7,8]]).should be_true
+      end
+    end
+    context '::array_from_acgt_hash' do
+      it 'should convert hash of arrays to a transposed array of arrays' do
+        input = {A: [1,2,3], C: [2,3,4], G: [3,4,5], T: [4,5,6]}
+        Parser.array_from_acgt_hash(input).should == [[1,2,3], [2,3,4], [3,4,5], [4,5,6]].transpose
+      end
+      it 'should convert hash of numbers to an array of numbers' do
+        input = {A: 1, C: 2, G: 3, T: 4}
+        Parser.array_from_acgt_hash(input).should == [1,2,3,4]
+      end
+      it 'should process both symbolic and string keys, in both upcase and downcase' do
+        input_normal_keys = {A: 1, C: 2, G: 3, T: 4}
+        input_different_keys = {:A => 1, :c => 2, 'g' => 3, 'T' => 4}
+        Parser.array_from_acgt_hash(input_different_keys).should == Parser.array_from_acgt_hash(input_normal_keys)
+      end
+    end
+
+    context '::try_convert_to_array' do
+      it 'should not change array' do
+        inputs = []
+        inputs << [[1,2,3,4], [2,3,4,5], [3,4,5,6]]
+        inputs << [{A:1, C:2, G:3, T:4}, {A:2, C:3, G:4, T:5}, {A:3, C:4, G:5, T:6}]
+        inputs.each do |input|
+          Parser.try_convert_to_array( input ).should == input
+        end
+      end
+      it 'should convert ACGT-Hashes to an array of positions (not letters)' do
+        Parser.try_convert_to_array( {:A => [1,2,3], :c => [2,3,4], 'g' => [3,4,5], 'T' => [4,5,6]} ).should == [[1,2,3],[2,3,4],[3,4,5],[4,5,6]].transpose
+      end
+    end
+
+    context '#parse' do
+      it 'should give the same result as #parse!' do
+        parser = Parser.new('stub parser')
+        parser.stub(:parse!).and_return('stub result')
+        parser.parse.should == 'stub result'
+      end
+      it 'should return nil if #parse! raised an exception' do
+        parser = Parser.new('stub parser')
+        parser.stub(:parse!).and_raise
+        parser.parse.should be_nil
+      end
+    end
+
+    good_cases = {
+      'Array Nx4' => {input: [[1,2,3,4],[5,6,7,8]],
+                      result: Fabricate(:pm_unnamed) },
+
+      'Array 4xN' => {input: [[1,5],[2,6],[3,7],[4,8]],
+                      result: Fabricate(:pm_unnamed) },
+
+      'Hash A,C,G,T => Arrays' => { input: {:A => [1,5], :c => [2,6],'g' => [3,7],'T' => [4,8]},
+                                    result: Fabricate(:pm_unnamed) },
+
+      'Hash array of hashes' => { input: [{:A => 1,:c => 2,'g' => 3,'T' => 4}, {:A => 5,:c => 6,'g' => 7,'T' => 8}],
+                                  result: Fabricate(:pm_unnamed) },
+
+      'Array 4x4 (rows treated as positions, columns are treated as letter)' => { input: [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]],
+                                                                                  result: Fabricate(:pm_4x4_unnamed) },
+
+      'Hash A,C,G,T => 4-Arrays' => { input: {:A => [1,5,9,13], :c => [2,6,10,14],'g' => [3,7,11,15],'T' => [4,8,12,16]},
+                                      result: Fabricate(:pm_4x4_unnamed) },
+
+      '4-Arrays of A,C,G,T hashes' => { input: [{:A => 1, :c => 2, 'g' => 3, 'T' => 4},
+                                                {:A => 5, :c => 6, 'g' => 7, 'T' => 8},
+                                                {:A => 9, :c => 10, 'g' => 11, 'T' => 12},
+                                                {:A => 13, :c => 14, 'g' => 15, 'T' => 16}],
+                                        result: Fabricate(:pm_4x4_unnamed) }
+    }
+
+    bad_cases = {
+      'Nil object on input' => {input: nil},
+      'Empty array on input' => {input: []},
+      '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)
+    context '#parser!' do
+      it "should raise an exception on parsing empty list to parser" do
+        expect{ Parser.new().parse! }.to raise_error
+      end
+    end
+  end
+end

data/spec/parsers/string_fantom_parser_spec.rb

@@ -1,70 +1,70 @@
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/parsers/string_fantom_parser'
-
-module Bioinform
-  describe StringFantomParser do
-    describe '#split_on_motifs' do
-      it 'should be able to parse several motifs' do
-        input = "
-//
-NA  motif_1
-P0	A	C	G	T
-P1	0 1	2	3
-P2	4 5	6	7
-//
-//
-NA  motif_2
-P0	A	C	G	T
-P1  1 2 3 4
-P2  5 6 7 8
-P3  9 10 11 12
-//
-NA  motif_3
-P0	A	C	G	T
-P1	2 3	4 5
-P2	6 7 8 9"
-        StringFantomParser.split_on_motifs(input).should == [ Fabricate(:pm_1), Fabricate(:pm_2), Fabricate(:pm_3) ]
-      end
-    end
-
-    good_cases = {
-      'string in Fantom-format' => {input: "
-        NA  PM_name
-        P0	A	C	G	T
-        P1	1	2	3 4
-        P2	5	6	7 8",
-        result: Fabricate(:pm)
-      },
-
-      'motif with additional rows' => {input: "
-        NA  PM_name
-        P0	A C G T S P
-        P1	1 2 3 4 5 10
-        P2	5 6 7 8 5 11",
-        result: Fabricate(:pm)
-      },
-      
-      'string with more than 10 positions(2-digit row numbers)' => {input: "
-        NA  PM_name
-        P0	A	C	G	T
-        P1	1	2	3	4
-        P2	5	6	7	8
-        P3	1	2	3	4
-        P4	5	6	7	8
-        P5	1	2	3	4
-        P6	5	6	7	8
-        P7	1	2	3	4
-        P8	5	6	7	8
-        P9	1	2	3	4
-        P10	5	6	7	8
-        P11	1	2	3	4
-        P12	5	6	7	8",
-        result: Fabricate(:pm, matrix: [[1,2,3,4],[5,6,7,8]] * 6 )
-      }
-    }
-
-    bad_cases = { }
-
-    parser_specs(StringFantomParser, good_cases, bad_cases)
-  end
+require_relative '../spec_helper'
+require_relative '../../lib/bioinform/parsers/string_fantom_parser'
+
+module Bioinform
+  describe StringFantomParser do
+    describe '#split_on_motifs' do
+      it 'should be able to parse several motifs' do
+        input = "
+//
+NA  motif_1
+P0	A	C	G	T
+P1	0 1	2	3
+P2	4 5	6	7
+//
+//
+NA  motif_2
+P0	A	C	G	T
+P1  1 2 3 4
+P2  5 6 7 8
+P3  9 10 11 12
+//
+NA  motif_3
+P0	A	C	G	T
+P1	2 3	4 5
+P2	6 7 8 9"
+        StringFantomParser.split_on_motifs(input).should == [ Fabricate(:pm_1), Fabricate(:pm_2), Fabricate(:pm_3) ]
+      end
+    end
+
+    good_cases = {
+      'string in Fantom-format' => {input: "
+        NA  PM_name
+        P0	A	C	G	T
+        P1	1	2	3 4
+        P2	5	6	7 8",
+        result: Fabricate(:pm)
+      },
+
+      'motif with additional rows' => {input: "
+        NA  PM_name
+        P0	A C G T S P
+        P1	1 2 3 4 5 10
+        P2	5 6 7 8 5 11",
+        result: Fabricate(:pm)
+      },
+      
+      'string with more than 10 positions(2-digit row numbers)' => {input: "
+        NA  PM_name
+        P0	A	C	G	T
+        P1	1	2	3	4
+        P2	5	6	7	8
+        P3	1	2	3	4
+        P4	5	6	7	8
+        P5	1	2	3	4
+        P6	5	6	7	8
+        P7	1	2	3	4
+        P8	5	6	7	8
+        P9	1	2	3	4
+        P10	5	6	7	8
+        P11	1	2	3	4
+        P12	5	6	7	8",
+        result: Fabricate(:pm, matrix: [[1,2,3,4],[5,6,7,8]] * 6 )
+      }
+    }
+
+    bad_cases = { }
+
+    parser_specs(StringFantomParser, good_cases, bad_cases)
+  end
 end