bioinform 0.1.17 → 0.2.0

data/spec/fabricators/collection_fabricator.rb

@@ -1,8 +0,0 @@
-Fabricator(:three_elements_collection, class_name: Bioinform::Collection, aliases: [:pm_collection]) do
-  name 'PM_collection'
-  after_build{|collection| collection << Fabricate(:pm_1) << Fabricate(:pm_2) << Fabricate(:pm_3) }
-end
-
-Fabricator(:unnamed_pm_collection, from: :pm_collection) do
-  name nil
-end

data/spec/fabricators/motif_fabricator.rb

@@ -1,33 +0,0 @@
-Fabricator(:motif, class_name: Bioinform::Motif) do
-end
-
-Fabricator(:motif_with_name, from: :motif) do
-  name 'Motif name'
-end
-
-Fabricator(:motif_pcm, from: :motif) do
-  pcm(fabricator: :pcm)
-end
-
-Fabricator(:motif_pwm, from: :motif) do
-  pwm(fabricator: :pwm)
-end
-
-Fabricator(:motif_ppm, from: :motif) do
-  ppm(fabricator: :ppm)
-end
-
-Fabricator(:motif_pcm_and_ppm, from: :motif) do
-  pcm(fabricator: :pcm)
-  ppm(fabricator: :ppm)
-end
-
-Fabricator(:motif_pwm_and_ppm, from: :motif) do
-  pwm(fabricator: :pwm)
-  ppm(fabricator: :ppm)
-end
-
-Fabricator(:motif_pcm_and_pwm, from: :motif) do
-  pcm(fabricator: :pcm)
-  pwm(fabricator: :pwm)
-end

data/spec/fabricators/pcm_fabricator.rb

@@ -1,25 +0,0 @@
-Fabricator(:pcm, class_name: Bioinform::PCM) do
-  initialize_with{ Bioinform::PCM.new(matrix: [[1, 2, 3, 1],[4, 0, 1, 2]], name: 'PCM_name') }
-end
-
-Fabricator(:pcm_with_floats, from: :pcm) do
-  matrix [[1, 2.3, 3.2, 1],[4.4, 0.1, 0.9, 2.1]]
-end
-
-Fabricator(:completely_different_pcm, from: :pcm) do
-  matrix [[101,207,138,248],[85,541,7,61]]
-  name 'PCM_another_name'
-end
-
-Fabricator(:pcm_1, from: :pcm) do
-  matrix [[7,10,2,3],[4,5,6,7]]
-  name 'motif_1'
-end
-Fabricator(:pcm_2, from: :pcm) do
-  matrix [[5,7,4,6],[11,6,2,3],[10,3,3,6]]
-  name 'motif_2'
-end
-Fabricator(:pcm_3, from: :pcm) do
-  matrix [[3,4,1,14],[9,2,9,2]]
-  name 'motif_3'
-end

data/spec/fabricators/pm_fabricator.rb

@@ -1,52 +0,0 @@
-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 +0,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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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

data/spec/parsers/string_parser_spec.rb

@@ -1,77 +0,0 @@
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/parsers/string_parser'
-
-module Bioinform
-  describe StringParser do
-
-    describe '#each' do
-      it 'should yield consequent results of #parse! while it returns result' do
-        parser = StringParser.new("1 2 3 4\n5 6 7 8\n\n1 2 3 4\n1 2 3 4\nName\n4 3 2 1\n1 1 1 1\n0 0 0 0")
-        expect{|b| parser.each(&b)}.to yield_successive_args(OpenStruct.new(matrix:[[1,2,3,4],[5,6,7,8]], name:nil),
-                                                             OpenStruct.new(matrix:[[1,2,3,4],[1,2,3,4]], name:nil),
-                                                             OpenStruct.new(matrix:[[4,3,2,1],[1,1,1,1],[0,0,0,0]], name:'Name') )
-      end
-      it 'should restart parser from the beginning each time' do
-        parser = StringParser.new("1 2 3 4\n5 6 7 8\n\n1 2 3 4\n1 2 3 4\nName\n4 3 2 1\n1 1 1 1\n0 0 0 0")
-        3.times do
-          expect{|b| parser.each(&b)}.to yield_successive_args(OpenStruct.new(matrix:[[1,2,3,4],[5,6,7,8]], name:nil),
-                                                               OpenStruct.new(matrix:[[1,2,3,4],[1,2,3,4]], name:nil),
-                                                               OpenStruct.new(matrix:[[4,3,2,1],[1,1,1,1],[0,0,0,0]], name:'Name') )
-        end
-      end
-    end
-
-    context '::split_on_motifs' do
-      it 'should be able to get a single PM' do
-        StringParser.split_on_motifs("1 2 3 4 \n 5 6 7 8").should == [ Fabricate(:pm_unnamed) ]
-      end
-      it 'should be able to split several PMs separated with an empty line' do
-        StringParser.split_on_motifs("1 2 3 4 \n 5 6 7 8 \n\n 15 16 17 18 \n 11 21 31 41").should ==
-                                                                [ Fabricate(:pm_first, name: nil), Fabricate(:pm_second, name: nil) ]
-      end
-      it 'should be able to split several PMs separated with name' do
-        StringParser.split_on_motifs("1 2 3 4 \n 5 6 7 8 \nPM_second\n 15 16 17 18 \n 11 21 31 41").should ==
-                                                                [ Fabricate(:pm_first, name: nil), Fabricate(:pm_second) ]
-      end
-      it 'should be able to split several PMs separated with both name and empty line' do
-        StringParser.split_on_motifs("PM_first\n1 2 3 4 \n 5 6 7 8 \n\nPM_second\n 15 16 17 18 \n 11 21 31 41\n\n\n").should ==
-                                                                [ Fabricate(:pm_first), Fabricate(:pm_second) ]
-      end
-      it 'should create PMs by default' do
-        result = StringParser.split_on_motifs("1 2 3 4 \n 5 6 7 8 \n 9 10 11 12 \nName\n 9 10 11 12 \n 1 2 3 4 \n 5 6 7 8")
-        result.each{|pm| pm.class.should == PM}
-      end
-      it 'should create PM subclass when it\'s specified' do
-        result = StringParser.split_on_motifs("1 2 3 4 \n 5 6 7 8 \n 9 10 11 12 \nName\n 9 10 11 12 \n 1 2 3 4 \n 5 6 7 8", PWM)
-        result.each{|pm| pm.class.should == PWM}
-      end
-    end
-
-    good_cases = {
-      'Nx4 string' => {input: "1 2 3 4\n5 6 7 8",  result: Fabricate(:pm_unnamed) },
-      '4xN string' => {input: "1 5\n2 6\n3 7\n 4 8",  result: Fabricate(:pm_unnamed) },
-      'string with name' => {input: "PM_name\n1 5\n2 6\n3 7\n 4 8",  result: Fabricate(:pm) },
-      'string with name (with introduction sign)' => {input: ">\t PM_name\n1 5\n2 6\n3 7\n 4 8",  result: Fabricate(:pm) },
-      'string with name (with special characters)' => {input: "Testmatrix_first:subname+sub-subname\n1 5\n2 6\n3 7\n 4 8",
-                                                       result: Fabricate(:pm, 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: Fabricate(:pm_with_floats) },
-      'string with exponents' => {input: "123e-2 0.456e+1 7.8 9.0\n9 -87000000000E-10 6.54 -3.210e3",  result: Fabricate(:pm_with_floats) },
-      'string with multiple spaces and tabs' => {input: "1 \t\t 2 3 4\n 5 6   7 8",  result: Fabricate(:pm_unnamed) },
-      'string with preceeding and terminating newlines' => {input: "\n\n\t 1 2 3 4\n5 6 7 8  \n\t\n",  result: Fabricate(:pm_unnamed) },
-      'string with windows crlf' => {input: "1 2 3 4\r\n5 6 7 8",  result: Fabricate(:pm_unnamed) },
-      'Nx4 string with acgt-header' => {input: "A C G T\n1 2 3 4\n5 6 7 8",  result: Fabricate(:pm_unnamed) },
-      'Nx4 string with name and acgt-header' => {input: "PM_name\nA C G T\n1 2 3 4\n5 6 7 8",  result: Fabricate(:pm)},
-      'Nx4 string with acgt-row-markers' => {input: "A 1 5\nC : 2 6\nG3 7\nT |4 8",  result: Fabricate(:pm_unnamed) },
-      '4x4 string with acgt-header' => {input: "A C G T\n1 2 3 4\n5 6 7 8\n9 10 11 12\n13 14 15 16",  result: Fabricate(:pm_4x4_unnamed) },
-      '4x4 string with acgt-row-markers' => {input: "A|1 5 9 13\nC|2 6 10 14\nG|3 7 11 15\nT|4 8 12 16",  result: Fabricate(:pm_4x4_unnamed) },
-      '4x4 string with name and acgt-row-markers' => {input: "PM_name\nA:1 5 9 13\nC:2 6 10 14\nG:3 7 11 15\nT:4 8 12 16",  result: Fabricate(:pm_4x4) }
-    }
-
-    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