bioinform 0.1.17 → 0.2.0

data/spec/formatters/consensus_formatter_spec.rb

@@ -0,0 +1,26 @@
+require 'bioinform/data_models/pm'
+require 'bioinform/formatters/consensus_formatter'
+
+describe Bioinform::ConsensusFormatter do
+  let(:pm) { Bioinform::MotifModel::PM.new([[10,30,10,28], [30,16,16,16], [12,30,10,26], [26,27,27,1]]) }
+
+  specify('.new without a block raises error') { expect{ Bioinform::ConsensusFormatter.new }.to raise_error Bioinform::Error }
+
+  context 'custom formatter' do
+    let(:formatter){ Bioinform::ConsensusFormatter.new{|pos, el, ind| (pos.max - el) < pos.max * 0.1 } }
+    specify{ expect(formatter.format_string(pm)).to eq 'YACV' }
+  end
+
+  context 'standard formatter' do
+    let(:formatter){ Bioinform::ConsensusFormatter.by_maximal_elements }
+    specify{ expect(formatter.format_string(pm)).to eq 'CACS' }
+  end
+
+  specify do
+    expect{|b|
+      Bioinform::ConsensusFormatter.new(&b).format_string(pm)
+      }.to yield_successive_args( *([ [[10,30,10,28],10,0],     # col,el,ind
+                                      [[10,30,10,28],30,1] ] +  # col,el,ind
+                                      [Array]*14 ) )            # rest triples
+  end
+end

data/spec/formatters/raw_formatter_spec.rb

@@ -0,0 +1,169 @@
+require 'bioinform/formatters/motif_formatter'
+require 'bioinform/data_models/pm'
+
+describe Bioinform::MotifFormatter do
+  let(:matrix) { [[1,2.345,6.7,8.99],
+                  [10,11.123,-15.678,16]] }
+  let(:motif) { Bioinform::MotifModel::PM.new(matrix) }
+  let(:default_matrix_string) { "1	2.345	6.7	8.99\n"+
+                                "10	11.123	-15.678	16" }
+
+  context 'with default configuration' do
+    let(:formatter) { Bioinform::MotifFormatter.new }
+    specify { expect(formatter.with_name).to eq :auto }
+    specify { expect(formatter.nucleotides_in).to eq :columns }
+    specify { expect(formatter.precision).to be_falsy }
+    specify { expect(formatter.with_nucleotide_header).to eq false }
+    specify { expect(formatter.with_position_header).to eq false }
+  end
+
+  context 'with with_name equal to false' do
+    let(:formatter) { Bioinform::MotifFormatter.new(with_name: false) }
+    specify { expect( formatter.format(motif) ).to eq default_matrix_string }
+    specify { expect( formatter.format(motif.named('Stub name')) ).to eq default_matrix_string }
+  end
+  context 'with with_name equal to true' do
+    let(:formatter) { Bioinform::MotifFormatter.new(with_name: true) }
+    specify { expect{ formatter.format(motif) }.to raise_error Bioinform::Error }
+    specify { expect( formatter.format(motif.named('')) ).to eq ">\n" +
+                                                              default_matrix_string }
+    specify { expect( formatter.format(motif.named('Stub name')) ).to eq ">Stub name\n" +
+                                                                       default_matrix_string }
+  end
+  context 'with with_name equal to :auto' do
+    let(:formatter) { Bioinform::MotifFormatter.new(with_name: :auto) }
+    specify { expect( formatter.format(motif) ).to eq default_matrix_string }
+    specify { expect( formatter.format(motif.named('')) ).to eq default_matrix_string }
+    specify { expect( formatter.format(motif.named('Stub name')) ).to eq ">Stub name\n" +
+                                                                      default_matrix_string }
+  end
+  context 'with with_name value different from true/false/:auto' do
+    specify{ expect { Bioinform::MotifFormatter.new(with_name: :somewhat) }.to raise_error Bioinform::Error }
+  end
+
+  context 'with nucleotides_in :columns' do
+    let(:formatter) { Bioinform::MotifFormatter.new(nucleotides_in: :columns) }
+    specify { expect( formatter.format(motif) ).to eq "1	2.345	6.7	8.99\n" +
+                                                      "10	11.123	-15.678	16" }
+  end
+  context 'with nucleotides_in :rows' do
+    let(:formatter) { Bioinform::MotifFormatter.new(nucleotides_in: :rows) }
+    specify { expect( formatter.format(motif) ).to eq "1	10\n" +
+                                                      "2.345	11.123\n" +
+                                                      "6.7	-15.678\n" +
+                                                      "8.99	16" }
+  end
+  context 'with nucleotides_in not equal to :rows or :columns' do
+    specify { expect{ Bioinform::MotifFormatter.new(nucleotides_in: :somewhat) }.to raise_error(Bioinform::Error) }
+  end
+
+  context 'with precision equal to false' do
+    let(:formatter) { Bioinform::MotifFormatter.new(precision: false) }
+    specify { expect( formatter.format(motif) ).to eq "1	2.345	6.7	8.99\n" +
+                                                      "10	11.123	-15.678	16" }
+  end
+  context 'with precision equal to a number' do
+    let(:formatter) { Bioinform::MotifFormatter.new(precision: 3) }
+    specify { expect( formatter.format(motif) ).to eq "1	2.35	6.7	8.99\n" +
+                                                      "10	11.1	-15.7	16" }
+  end
+
+  context 'with nucleotide header' do
+    context 'with nucleotides in columns' do
+      let(:formatter) { Bioinform::MotifFormatter.new(with_nucleotide_header: true, nucleotides_in: :columns) }
+      specify { expect( formatter.format(motif) ).to eq "A	C	G	T\n" +
+                                                        "1	2.345	6.7	8.99\n" +
+                                                        "10	11.123	-15.678	16" }
+
+    end
+    context 'with nucleotides in rows' do
+      let(:formatter) { Bioinform::MotifFormatter.new(with_nucleotide_header: true, nucleotides_in: :rows) }
+      specify { expect( formatter.format(motif) ).to eq "A	1	10\n" +
+                                                        "C	2.345	11.123\n" +
+                                                        "G	6.7	-15.678\n" +
+                                                        "T	8.99	16" }
+    end
+  end
+
+  context 'with position header' do
+    context 'with nucleotides in columns' do
+      let(:formatter) { Bioinform::MotifFormatter.new(with_position_header: true, nucleotides_in: :columns) }
+      let(:long_motif) { Bioinform::MotifModel::PM.new([[1,2,3,4]] * 12) }
+      specify { expect( formatter.format(motif) ).to eq "01	1	2.345	6.7	8.99\n" +
+                                                        "02	10	11.123	-15.678	16" }
+      specify { expect( formatter.format(long_motif) ).to eq  "01	1	2	3	4\n" +
+                                                              "02	1	2	3	4\n" +
+                                                              "03	1	2	3	4\n" +
+                                                              "04	1	2	3	4\n" +
+                                                              "05	1	2	3	4\n" +
+                                                              "06	1	2	3	4\n" +
+                                                              "07	1	2	3	4\n" +
+                                                              "08	1	2	3	4\n" +
+                                                              "09	1	2	3	4\n" +
+                                                              "10	1	2	3	4\n" +
+                                                              "11	1	2	3	4\n" +
+                                                              "12	1	2	3	4" }
+    end
+    context 'with nucleotides in rows' do
+      let(:formatter) { Bioinform::MotifFormatter.new(with_position_header: true, nucleotides_in: :rows) }
+      specify { expect( formatter.format(motif) ).to eq "01	02\n" +
+                                                        "1	10\n" +
+                                                        "2.345	11.123\n" +
+                                                        "6.7	-15.678\n" +
+                                                        "8.99	16" }
+    end
+  end
+
+  context 'with both headers' do
+    context 'with nucleotides in columns' do
+      let(:formatter) { Bioinform::MotifFormatter.new(with_position_header: true, with_nucleotide_header: true, nucleotides_in: :columns) }
+      specify { expect( formatter.format(motif) ).to eq "	A	C	G	T\n" +
+                                                        "01	1	2.345	6.7	8.99\n" +
+                                                        "02	10	11.123	-15.678	16" }
+    end
+    context 'with nucleotides in rows' do
+      let(:formatter) { Bioinform::MotifFormatter.new(with_position_header: true, with_nucleotide_header: true, nucleotides_in: :rows) }
+      specify { expect( formatter.format(motif) ).to eq "	01	02\n" +
+                                                        "A	1	10\n" +
+                                                        "C	2.345	11.123\n" +
+                                                        "G	6.7	-15.678\n" +
+                                                        "T	8.99	16" }
+    end
+  end
+
+  context 'on different alphabet' do
+    let(:matrix_15) { [[1,2,3,1.567,  12,-11,12,0,-1.1,0.6,  0.4,0.321,0.11,-1.23, 2.0],
+                       [0,0,0,0,       0,0,0,0,0,0, 0,0,0,0, 0]] }
+    let(:motif) { Bioinform::MotifModel::PM.new(matrix_15, alphabet: Bioinform::IUPACAlphabet) }
+
+    specify {
+      expect( Bioinform::MotifFormatter.new.format(motif) )
+        .to eq  "1	2	3	1.567	12	-11	12	0	-1.1	0.6	0.4	0.321	0.11	-1.23	2.0\n" +
+                "0	0	0	0	0	0	0	0	0	0	0	0	0	0	0"
+    }
+    specify {
+      expect( Bioinform::MotifFormatter.new(with_nucleotide_header: true).format(motif) )
+        .to eq  "A	C	G	T	M	R	W	S	Y	K	V	H	D	B	N\n" +
+                "1	2	3	1.567	12	-11	12	0	-1.1	0.6	0.4	0.321	0.11	-1.23	2.0\n" +
+                "0	0	0	0	0	0	0	0	0	0	0	0	0	0	0"
+    }
+    specify {
+      expect( Bioinform::MotifFormatter.new(with_nucleotide_header: true, nucleotides_in: :rows).format(motif) )
+        .to eq  "A	1	0\n" +
+                "C	2	0\n" +
+                "G	3	0\n" +
+                "T	1.567	0\n" +
+                "M	12	0\n" +
+                "R	-11	0\n" +
+                "W	12	0\n" +
+                "S	0	0\n" +
+                "Y	-1.1	0\n" +
+                "K	0.6	0\n" +
+                "V	0.4	0\n" +
+                "H	0.321	0\n" +
+                "D	0.11	0\n" +
+                "B	-1.23	0\n" +
+                "N	2.0	0"
+    }
+  end
+end

data/spec/parsers/matrix_parser_spec.rb

@@ -0,0 +1,216 @@
+require 'bioinform/parsers/matrix_parser'
+
+describe Bioinform::MatrixParser do
+  specify { expect{ Bioinform::MatrixParser.new(nucleotides_in: :somewhat) }.to raise_error Bioinform::Error }
+
+  context 'with default options' do
+    subject(:parser) { Bioinform::MatrixParser.new }
+    specify { expect(parser.has_name).to eq :auto }
+    specify { expect(parser.has_header_row).to eq false }
+    specify { expect(parser.has_header_column).to eq false }
+    specify { expect(parser.nucleotides_in).to eq :auto }
+    specify { expect(parser.fix_nucleotides_number).to eq 4 }
+
+    specify { expect(parser.name_pattern).to match ">Motif_name" }
+    specify { expect(parser.name_pattern).to match ">Motif name" }
+    specify { expect(parser.name_pattern).to match "> Motif name" }
+    specify { expect(parser.name_pattern).to match "Motif name" }
+    specify { expect(parser.name_pattern).to match "Motif name\tother info" }
+
+    specify { expect(parser.name_pattern.match(">Motif_name")[:name]).to eq "Motif_name" }
+    specify { expect(parser.name_pattern.match(">Motif name")[:name]).to eq "Motif name" }
+    specify { expect(parser.name_pattern.match("> Motif name")[:name]).to eq "Motif name" }
+    specify { expect(parser.name_pattern.match("Motif name")[:name]).to eq "Motif name" }
+    specify { expect(parser.name_pattern.match("Motif name\tother info")[:name]).to eq "Motif name" }
+  end
+
+  context 'parser having name' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns,has_name: true) }
+    let(:input) {">PM name\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+
+    specify 'trims empty lines' do
+      expect( parser.parse!("\n   \t  \n" + input + "\n\n") ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} )
+    end
+  end
+  context 'parser having neither name nor header' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_name: false) }
+    let(:input_allowed) {"1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    let(:input_not_allowed) {">PM Name\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    let(:input_not_allowed_2) {"A\tC\tG\tT\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    let(:input_not_allowed_3) {"##01\t1\t2\t3\t4\n" + "##02\t11\t12\t13\t14" }
+    specify { expect( parser.parse!(input_allowed) ).to eq( {name: nil, matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+    specify { expect{ parser.parse!(input_not_allowed) }.to raise_error Bioinform::Error }
+    specify { expect{ parser.parse!(input_not_allowed_2) }.to raise_error Bioinform::Error }
+    specify { expect{ parser.parse!(input_not_allowed_3) }.to raise_error Bioinform::Error }
+  end
+  context 'with has_name equal to :auto parser can either have name or not' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_name: :auto) }
+    let(:input_without_name) {"1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    let(:input_with_name) {">PM Name\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    let(:input_with_bad_name) {"-Name\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    specify { expect( parser.parse!(input_without_name) ).to eq( {name: nil, matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+    specify { expect( parser.parse!(input_with_name) ).to eq( {name: 'PM Name', matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+    specify { expect{ parser.parse!(input_with_bad_name) }.to raise_error Bioinform::Error }
+  end
+  context 'parser having name and header row' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_name: true, has_header_row: true) }
+    let(:input) {">PM name\n" + "A\tC\tG\tT\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+  context 'parser having header row' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_name: false, has_header_row: true) }
+    let(:input) {"A\tC\tG\tT\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: nil, matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+    specify { expect{ parser.parse!("Motif name\n" + input) }.to raise_error Bioinform::Error }
+  end
+  context 'parser having header column' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_header_column: true) }
+    let(:input) {">PM name\n" + "##01\t1\t2\t3\t4\n" + "##02\t11\t12\t13\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+  context 'parser having both headers' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_header_row: true, has_header_column: true) }
+    let(:input) {">PM name\n" + "X\tA\tC\tG\tT\n" + "##01\t1\t2\t3\t4\n" + "##02\t11\t12\t13\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+
+  context 'parser for transposed matrix' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :rows) }
+    let(:input) {">PM name\n" + "1\t11\n" + "2\t12\n" + "3\t13\n" + "4\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: 'PM name', matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+  context 'parser for transposed matrix with row header' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :rows, has_header_row: true) }
+    let(:input) {">PM name\n" + "##01\t##02\n" + "1\t11\n" + "2\t12\n" + "3\t13\n" + "4\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+  context 'parser for transposed matrix with column header' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :rows, has_header_column: true) }
+    let(:input) {">PM name\n" + "A\t1\t11\n" + "C\t2\t12\n" + "G\t3\t13\n" + "T\t4\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+  context 'parser for transposed matrix with both header' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :rows, has_header_column: true, has_header_row: true) }
+    let(:input) {">PM name\n" + "X\t##01\t##02\n" + "A\t1\t11\n" + "C\t2\t12\n" + "G\t3\t13\n" + "T\t4\t14" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+
+  context 'parser having custom name pattern' do
+    subject(:parser) { Bioinform::MatrixParser.new(has_name: true, name_pattern: /^NA>(?<name>.+)$/) }
+    let(:input_allowed) {"NA>Motif name\tother info\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    let(:input_not_allowed) {"Motif name\tother info\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    specify { expect( parser.parse!(input_allowed) ).to eq( {name: "Motif name\tother info", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+    specify { expect{ parser.parse!(input_not_allowed) }.to raise_error Bioinform::Error }
+  end
+
+  context 'parser reducing number of nucleotides' do
+    subject(:parser) { Bioinform::MatrixParser.new(has_name: true) }
+    let(:input) {">PM name\n" + "1\t2\t3\t4\t5\n" + "11\t12\t13\t14\t15" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+  context 'parser for transposed matrix reducing number of nucleotides' do
+    subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :rows) }
+    let(:input) {">PM name\n" + "1\t11\n" + "2\t12\n" + "3\t13\n" + "4\t14\n" + "5\t15"}
+    specify { expect( parser.parse!(input) ).to eq( {name: 'PM name', matrix: [[1,2,3,4],[11,12,13,14]]} ) }
+  end
+  context 'parser not reducing number of nucleotides' do
+    subject(:parser) { Bioinform::MatrixParser.new(has_name: true, fix_nucleotides_number: false) }
+    let(:input) {">PM name\n" + "1\t2\t3\t4\t5\n" + "11\t12\t13\t14\t15" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3,4,5],[11,12,13,14,15]]} ) }
+  end
+  context 'parser reducing number of nucleotides to a non-standard one' do
+    subject(:parser) { Bioinform::MatrixParser.new(has_name: true, fix_nucleotides_number: 3) }
+    let(:input) {">PM name\n" + "1\t2\t3\t4\t5\n" + "11\t12\t13\t14\t15" }
+    specify { expect( parser.parse!(input) ).to eq( {name: "PM name", matrix: [[1,2,3],[11,12,13]]} ) }
+  end
+  context 'parser which hasn\'t enough number of nucleotides' do
+    subject(:parser) { Bioinform::MatrixParser.new(has_name: true, fix_nucleotides_number: 4) }
+    let(:input) {">PM name\n" + "1\t2\t3\n" + "11\t12\t13" }
+    specify { expect{ parser.parse!(input) }.to raise_error Bioinform::Error }
+  end
+
+  context 'parser with auto transposition' do
+    let(:input_not_transposed) {">PM Name\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
+    let(:input_transposed) {">PM Name\n" + "1\t11\n" + "2\t12\n" + "3\t13\n"  + "4\t14"}
+    let(:input_4x4) {">PM Name\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14"}
+    context 'with fixed nucleotides number' do
+      subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :auto, fix_nucleotides_number: 4) }
+      specify { expect(parser.parse(input_not_transposed)).to eq({name:'PM Name', matrix: [[1,2,3,4],[11,12,13,14]]}) }
+      specify { expect(parser.parse(input_transposed)).to eq({name:'PM Name', matrix: [[1,2,3,4],[11,12,13,14]]}) }
+      specify { expect(parser.parse(input_4x4)).to eq({name:'PM Name', matrix: [[1,2,3,4],[11,12,13,14],[1,2,3,4],[11,12,13,14]]}) }
+    end
+    context 'with non fixed nucleotides number' do
+      subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :auto, fix_nucleotides_number: false) }
+      specify { expect(parser.parse(input_not_transposed)).to eq({name:'PM Name', matrix: [[1,2,3,4],[11,12,13,14]]}) }
+      specify { expect(parser.parse(input_transposed)).to eq({name:'PM Name', matrix: [[1,11],[2,12],[3,13],[4,14]]}) }
+      specify { expect(parser.parse(input_4x4)).to eq({name:'PM Name', matrix: [[1,2,3,4],[11,12,13,14],[1,2,3,4],[11,12,13,14]]}) }
+    end
+  end
+
+  context 'FANTOM-formatted motifs' do
+    let(:parser) do
+      Bioinform::MatrixParser.new( has_name: true, name_pattern: /^NA\s+(?<name>.+)$/,
+                        has_header_row: true, has_header_column: true, nucleotides_in: :columns,
+                        reduce_to_n_nucleotides: 4 )
+    end
+
+    specify 'parse strings in FANTOM format' do
+      input = "NA  PM_name\n" +
+              "P0  A C G T\n" +
+              "P1  1 2 3 4\n" +
+              "P2  5 6 7 8"
+      expect(parser.parse(input)).to eq({matrix: [[1,2,3,4],[5,6,7,8]], name: 'PM_name'})
+    end
+
+
+    specify 'ignores additional columns' do
+      input = "NA  PM_name\n" +
+              "P0  A C G T S P\n" +
+              "P1  1 2 3 4 5 10\n" +
+              "P2  5 6 7 8 5 11"
+      expect(parser.parse(input)).to eq({matrix: [[1,2,3,4],[5,6,7,8]], name: 'PM_name'})
+    end
+
+    specify 'parses string with more than 10 positions(2-digit row numbers)' do
+      input = "NA  PM_name\n" +
+              "P0  A C G T\n" +
+              "P1  1 2 3 4\n" +
+              "P2  5 6 7 8\n" +
+              "P3  1 2 3 4\n" +
+              "P4  5 6 7 8\n" +
+              "P5  1 2 3 4\n" +
+              "P6  5 6 7 8\n" +
+              "P7  1 2 3 4\n" +
+              "P8  5 6 7 8\n" +
+              "P9  1 2 3 4\n" +
+              "P10 5 6 7 8\n" +
+              "P11 1 2 3 4\n" +
+              "P12 5 6 7 8"
+      expect(parser.parse(input)).to eq({matrix: [[1,2,3,4],[5,6,7,8]]*6, name: 'PM_name'})
+    end
+
+    good_cases = {
+      'Nx4 string' => {input: "1 2 3 4\n5 6 7 8",  result: {matrix: [[1,2,3,4],[5,6,7,8]], name: nil} },
+      '4xN string' => {input: "1 5\n2 6\n3 7\n 4 8",  result: {matrix: [[1,2,3,4],[5,6,7,8]], name: nil} },
+      'string with name' => {input: "PM_name\n1 5\n2 6\n3 7\n 4 8",  result: {matrix: [[1,2,3,4],[5,6,7,8]], name: 'PM_name'} },
+      'string with name (with introduction sign)' => {input: ">\t PM_name\n1 5\n2 6\n3 7\n 4 8",  result: {matrix: [[1,2,3,4],[5,6,7,8]], name: 'PM_name'} },
+      'string with name (with special characters)' => {input: "Testmatrix_first:subname+sub-subname\n1 5\n2 6\n3 7\n 4 8",
+                                                       result: {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",  result: {matrix: [[1.23, 4.56, 7.8, 9.0],[9, -8.7, 6.54, -3210]], name: nil} },
+      'string with exponents' => {input: "123e-2 0.456e+1 7.8 9.0\n9 -87000000000E-10 6.54 -3.210e3",  result: {matrix: [[1.23, 4.56, 7.8, 9.0],[9, -8.7, 6.54, -3210]], name: nil} },
+      'string with multiple spaces and tabs' => {input: "1 \t\t 2 3 4\n 5 6   7 8",  result: {matrix: [[1,2,3,4],[5,6,7,8]], name: nil} },
+      'string with preceeding and terminating newlines' => {input: "\n\n\t 1 2 3 4\n5 6 7 8  \n\t\n", result: {matrix: [[1,2,3,4],[5,6,7,8]], name: nil} },
+      'string with windows crlf' => {input: "1 2 3 4\r\n5 6 7 8",  result: {matrix: [[1,2,3,4],[5,6,7,8]], name: nil} },
+    }
+
+    bad_cases = {
+      'string with non-numeric input' =>  {input: "1.23 4.56 78aaa 9.0\n9 -8.7 6.54 -3210" },
+      'string with non-numeric input at the end of line' =>  {input: "1.23 4.56 78 9.0aaa\n9 -8.7 6.54 -3210" },
+      'string with non-numeric input at a separate line' =>  {input: "1.23 4.56 78 9.0\naaa\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(Bioinform::MatrixParser.new, good_cases, bad_cases)
+  end
+end

data/spec/parsers/motif_splitter_spec.rb

@@ -0,0 +1,87 @@
+require 'bioinform/parsers/motif_splitter'
+
+describe Bioinform::MotifSplitter do
+  let(:motif_unnamed) { "1 2 3 4\n"+"5\t6\t7\t8" }
+  let(:motif_with_floats) { "motif2\n  1.0 1.1 1.2 1.3\n  14 15 16 17\n  19 20 21 22" }
+  let(:motif_with_signs_and_exponents) { "> motif3\n-2.0 1.3e-3 -5.47 5.2\n+3.4 7 3 3" }
+
+  context 'default splitter\n' do
+    let(:motif_splitter) { Bioinform::MotifSplitter.new }
+
+    specify do
+      input = motif_unnamed + "\n" + motif_with_floats + "\n" + motif_with_signs_and_exponents
+      expect(motif_splitter.split(input)).to eq [motif_unnamed, motif_with_floats, motif_with_signs_and_exponents]
+    end
+
+    specify do
+      input = motif_unnamed + "\n" + motif_with_floats + "\n" + motif_with_signs_and_exponents + "\n"
+      expect(motif_splitter.split(input)).to eq [motif_unnamed, motif_with_floats, motif_with_signs_and_exponents]
+    end
+
+    specify do
+      input = "Motif1 name\n" + motif_unnamed + "\n" + motif_with_floats + "\n" + motif_with_signs_and_exponents
+      expect(motif_splitter.split(input)).to eq ["Motif1 name\n" + motif_unnamed, motif_with_floats, motif_with_signs_and_exponents]
+    end
+
+    specify { expect(motif_splitter.split(motif_unnamed + "\n\n" + motif_unnamed)).to eq [motif_unnamed, motif_unnamed] }
+
+    specify { expect(motif_splitter.split(motif_unnamed + "\n\n\n" + motif_unnamed)).to eq [motif_unnamed, motif_unnamed] }
+  end
+
+  context 'with specified pattern' do
+    let(:motif_splitter) { Bioinform::MotifSplitter.new(start_motif_pattern: /^NA\s+\w+$/, splitter_pattern: /^\/\/\s$/) }
+
+    let(:input_1) {
+      "NA  motif_1\n" +
+      "P0  A C G T\n" +
+      "P1  0 1 2 3\n" +
+      "P2  4 5 6 7"
+    }
+
+    let(:input_2) {
+      "NA  motif_2\n" +
+      "P0  A C G T\n" +
+      "P1  1 2 3 4\n" +
+      "P2  5 6 7 8\n" +
+      "P3  9 10 11 12"
+    }
+
+    let(:input_3) {
+      "NA  motif_3\n" +
+      "P0  A C G T\n" +
+      "P1  2 3 4 5\n" +
+      "P2  6 7 8 9"
+    }
+
+    # this input doesn't have pattern of start motif
+    let(:input_wo_name) {
+      "P0  A C G T\n" +
+      "P1  3 4 5 6\n" +
+      "P2  7 8 9 10"
+    }
+
+    specify do
+      input = "//\n" +
+              input_1 + "\n" +
+              "//\n" +
+              "//\n" +
+              input_2 + "\n" +
+              "//\n" +
+              input_3
+      expect(motif_splitter.split(input)).to eq [input_1, input_2, input_3]
+    end
+
+    specify 'splitter (w/o motif starter) is enough to split motifs' do
+      input = input_1 + "\n" +
+              "//\n" +
+              input_wo_name
+      expect(motif_splitter.split(input)).to eq [input_1, input_wo_name]
+    end
+
+    specify 'motif starter (w/o splitter) is enough to split motifs' do
+      input = input_1 + "\n" +
+              input_2
+      expect(motif_splitter.split(input)).to eq [input_1, input_2]
+    end
+  end
+end