bioinform 0.1.17 → 0.2.0

data/spec/cli/shared_examples/convert_motif/motif_list_empty.rb

@@ -15,4 +15,4 @@ shared_examples 'motif list is empty' do
       include_examples 'yield help string'
     end
   end
-end
+end

data/spec/cli/shared_examples/convert_motif/several_motifs_specified.rb

@@ -9,6 +9,6 @@ shared_examples 'several motifs specified' do
     Given(:motif_list) { [sp1_f1, klf4_f2] }  
     Given(:model_from) { 'pcm' }
     Given(:model_to) { 'pwm' }
-    Then { resulting_stdout.should == [sp1_f1.pwm, klf4_f2.pwm].join("\n") }
+    Then { expect(resulting_stdout).to eq [sp1_f1.pwm, klf4_f2.pwm].join("\n") }
   end
 end

data/spec/cli/shared_examples/convert_motif/single_motif_specified.rb

@@ -12,12 +12,12 @@ shared_examples 'single motif specified' do
 
       context 'pwm conversion invoked' do
         Given(:model_to) { 'pwm' }
-        Then { resulting_stdout.should == sp1_f1.pwm }
+        Then { expect(resulting_stdout).to eq sp1_f1.pwm }
       end
 
       context 'ppm conversion invoked' do
         Given(:model_to) { 'ppm' }
-        Then { resulting_stdout.should == sp1_f1.ppm }
+        Then { expect(resulting_stdout).to eq sp1_f1.ppm }
       end
     end
     
@@ -42,9 +42,9 @@ shared_examples 'single motif specified' do
       }
       Given(:model_from) { 'pcm' }
       Given(:model_to) { 'pwm' }
-      Then { resulting_stdout.should == sp1_f1.pwm }
-      Then { resulting_stdout.should_not match(klf4_f2.pwm) }
+      Then { expect(resulting_stdout).to eq sp1_f1.pwm }
+      Then { expect(resulting_stdout).not_to match(klf4_f2.pwm) }
     end
     
   end
-end
+end

data/spec/cli/shared_examples/convert_motif/yield_help_string.rb

@@ -1,5 +1,5 @@
 require_relative '../../../spec_helper'
 
 shared_examples 'yield help string' do
-  Then { resulting_stdout.should match(/Usage:.*Options:/m) }
-end
+  Then { expect(resulting_stdout).to match(/Usage:.*Options:/m) }
+end

data/spec/cli/shared_examples/convert_motif/yield_motif_conversion_error.rb

@@ -1,4 +1,4 @@
 shared_examples 'yields motif conversion error' do
-  Then { resulting_stderr.should match "One can't convert from #{model_from} data-model to #{model_to} data-model" }
-  Then { resulting_stderr.should match "Error! Conversion wasn't performed" }
-end
+  Then { expect(resulting_stderr).to match "One can't convert from #{model_from} data-model to #{model_to} data-model" }
+  Then { expect(resulting_stderr).to match "Error! Conversion wasn't performed" }
+end

data/spec/cli/split_motifs_spec.rb

@@ -1,5 +1,5 @@
 require_relative '../spec_helper'
-require_relative '../../lib/bioinform/cli/split_motifs'
+require 'bioinform/cli/split_motifs'
 
 def run_split_motifs(cmd)
   Bioinform::CLI::SplitMotifs.main(cmd.shellsplit)
@@ -23,14 +23,14 @@ describe Bioinform::CLI::SplitMotifs do
   it 'splits plain text into separate files' do
     run_split_motifs('plain_collection.txt')
     @motifs_in_collection.each do |motif_name|
-      File.exist?("#{motif_name}.mat").should be_true
+      expect(File.exist?("#{motif_name}.mat")).to be_truthy
       File.read("#{motif_name}.mat") == File.read("#{motif_name}.mat.result")
     end
   end
   it 'create files with specified extension' do
     run_split_motifs('plain_collection.txt -e pwm')
     @motifs_in_collection.each do |motif_name|
-      File.exist?("#{motif_name}.pwm").should be_true
+      expect(File.exist?("#{motif_name}.pwm")).to be_truthy
       File.read("#{motif_name}.pwm") == File.read("#{motif_name}.mat.result")
     end
   end
@@ -42,7 +42,7 @@ describe Bioinform::CLI::SplitMotifs do
     it 'create files in specified folder' do
       run_split_motifs('plain_collection.txt -f result_folder')
       @motifs_in_collection.each do |motif_name|
-        File.exist?(File.join('result_folder', "#{motif_name}.mat")).should be_true
+        expect(File.exist?(File.join('result_folder', "#{motif_name}.mat"))).to be_truthy
         File.read(File.join('result_folder', "#{motif_name}.mat")) == File.read("#{motif_name}.mat.result")
       end
     end
@@ -54,24 +54,9 @@ describe Bioinform::CLI::SplitMotifs do
     it 'create files in specified folder' do
       run_split_motifs('plain_collection.txt -f result_folder')
       @motifs_in_collection.each do |motif_name|
-        File.exist?(File.join('result_folder', "#{motif_name}.mat")).should be_true
+        expect(File.exist?(File.join('result_folder', "#{motif_name}.mat"))).to be_truthy
         File.read(File.join('result_folder', "#{motif_name}.mat")) == File.read("#{motif_name}.mat.result")
       end
     end
   end
-  
-  it 'splits motifs from Collections (yamled Bioinform::Collection instances) with appropriate extension' do
-    run_split_motifs('collection.yaml')
-    @motifs_in_collection.each do |motif_name|
-      File.exist?("#{motif_name}.pwm").should be_true
-      File.read("#{motif_name}.pwm") == File.read("#{motif_name}.mat.result")
-    end
-  end
-  it 'splits motifs from Collections with specified extension' do
-    run_split_motifs('collection.yaml -e pat')
-    @motifs_in_collection.each do |motif_name|
-      File.exist?("#{motif_name}.pat").should be_true
-      File.read("#{motif_name}.pat") == File.read("#{motif_name}.mat.result")
-    end
-  end
-end
+end

data/spec/converters/pcm2ppm_converter_spec.rb

@@ -0,0 +1,32 @@
+require 'bioinform/conversion_algorithms/pcm2ppm_converter'
+
+describe Bioinform::ConversionAlgorithms::PCM2PPMConverter do
+  let(:pcm) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4]]) }
+  let(:pwm) { Bioinform::MotifModel::PWM.new([[1,2,3,4],[2,2,2,4]]) }
+  let(:ppm) { Bioinform::MotifModel::PPM.new([[0.1,0.2,0.3,0.4],[0.2,0.2,0.2,0.4]]) }
+  let(:pcm_different_counts) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4],[3,3,3,4]]) }
+
+  let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
+  let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
+
+  let(:converter) { Bioinform::ConversionAlgorithms::PCM2PPMConverter.new }
+
+  specify { expect(converter.convert(pcm)).to be_kind_of Bioinform::MotifModel::PPM }
+
+  specify do
+    expect(converter.convert(pcm).matrix).to eq [ [0.1,0.2,0.3,0.4],
+                                                  [0.2,0.2,0.2,0.4] ]
+  end
+  specify do
+    expect(converter.convert(pcm_different_counts).matrix).to eq [ [0.1,0.2,0.3,0.4],
+                                                                   [0.2,0.2,0.2,0.4],
+                                                                   [3.0/13, 3.0/13, 3.0/13, 4.0/13] ]
+  end
+
+  specify { expect(converter.convert(named_pcm)).to be_kind_of Bioinform::MotifModel::NamedModel }
+  specify { expect(converter.convert(named_pcm).model).to be_kind_of Bioinform::MotifModel::PPM }
+  specify { expect(converter.convert(named_pcm).name).to eq 'motif name' }
+  specify { expect{ converter.convert(pwm) }.to raise_error Bioinform::Error }
+  specify { expect{ converter.convert(named_pwm) }.to raise_error Bioinform::Error }
+  specify { expect{ converter.convert(ppm) }.to raise_error Bioinform::Error }
+end

data/spec/converters/pcm2pwm_converter_spec.rb

@@ -0,0 +1,71 @@
+require 'bioinform/conversion_algorithms/pcm2pwm_converter'
+
+describe Bioinform::ConversionAlgorithms::PCM2PWMConverter do
+  let(:pcm) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4]]) }
+  let(:pwm) { Bioinform::MotifModel::PWM.new([[1,2,3,4],[2,2,2,4]]) }
+  let(:ppm) { Bioinform::MotifModel::PPM.new([[0.1,0.2,0.3,0.4],[0.2,0.2,0.2,0.4]]) }
+  let(:pcm_different_counts) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4],[3,3,3,4]]) }
+
+  let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
+  let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
+
+  context 'with default converter' do
+    let(:converter) { Bioinform::ConversionAlgorithms::PCM2PWMConverter.new }
+
+    specify { expect(converter.pseudocount).to eq :log }
+    specify { expect(converter.background).to eq Bioinform::Background::Uniform }
+
+    specify { expect(converter.convert(pcm)).to be_kind_of Bioinform::MotifModel::PWM }
+    specify { expect(converter.calculate_pseudocount(pcm)).to eq Math.log(10) }
+
+    specify do
+      cnt = 10
+      k = Math.log(cnt)
+      den = 0.25 * (cnt + k)
+      expect(converter.convert(pcm).matrix).to eq [
+            [Math.log((1+k*0.25)/den), Math.log((2+k*0.25)/den), Math.log((3+k*0.25)/den), Math.log((4+k*0.25)/den)],
+            [Math.log((2+k*0.25)/den), Math.log((2+k*0.25)/den), Math.log((2+k*0.25)/den), Math.log((4+k*0.25)/den)] ]
+    end
+
+    specify { expect{ converter.convert(pcm_different_counts) }.to raise_error Bioinform::Error }
+
+    specify { expect(converter.convert(named_pcm)).to be_kind_of Bioinform::MotifModel::NamedModel }
+    specify { expect(converter.convert(named_pcm).model).to be_kind_of Bioinform::MotifModel::PWM }
+    specify { expect(converter.convert(named_pcm).name).to eq 'motif name' }
+    specify { expect{ converter.convert(pwm) }.to raise_error Bioinform::Error }
+    specify { expect{ converter.convert(named_pwm) }.to raise_error Bioinform::Error }
+    specify { expect{ converter.convert(ppm) }.to raise_error Bioinform::Error }
+  end
+
+  context 'with specified explicitly pseudocount' do
+    let(:specified_pseudocount) { 5 }
+    let(:converter) { Bioinform::ConversionAlgorithms::PCM2PWMConverter.new(pseudocount: specified_pseudocount) }
+
+    specify { expect(converter.pseudocount).to eq 5 }
+
+    specify 'allows PCM-s with different column counts (because pseudocount specified, pcm\'s count not used for pseudocount calculation)' do
+      k = specified_pseudocount
+      den_1_2 = 0.25 * (10 + k)
+      den_3 = 0.25 * (13 + k)
+      expect(converter.convert(pcm_different_counts).matrix).to eq [
+            [Math.log((1+k*0.25)/den_1_2),  Math.log((2+k*0.25)/den_1_2), Math.log((3+k*0.25)/den_1_2), Math.log((4+k*0.25)/den_1_2)],
+            [Math.log((2+k*0.25)/den_1_2),  Math.log((2+k*0.25)/den_1_2), Math.log((2+k*0.25)/den_1_2), Math.log((4+k*0.25)/den_1_2)],
+            [Math.log((3+k*0.25)/den_3),    Math.log((3+k*0.25)/den_3),   Math.log((3+k*0.25)/den_3),   Math.log((4+k*0.25)/den_3)] ]
+    end
+  end
+
+  context 'with specified explicitly background' do
+    let(:background_to_set) { Bioinform::Frequencies.new([0.1, 0.4, 0.4, 0.1]) }
+    let(:converter) { Bioinform::ConversionAlgorithms::PCM2PWMConverter.new(background: background_to_set) }
+
+    specify { expect(converter.background).to eq background_to_set }
+    specify 'allows PCM-s with different column counts (because pseudocount specified, pcm\'s count not used for pseudocount calculation)' do
+      k = Math.log(10)
+      den_at = 0.1 * (10 + k)
+      den_cg = 0.4 * (10 + k)
+      expect(converter.convert(pcm).matrix).to eq [
+            [Math.log((1+k*0.1)/den_at), Math.log((2+k*0.4)/den_cg), Math.log((3+k*0.4)/den_cg), Math.log((4+k*0.1)/den_at)],
+            [Math.log((2+k*0.1)/den_at), Math.log((2+k*0.4)/den_cg), Math.log((2+k*0.4)/den_cg), Math.log((4+k*0.1)/den_at)] ]
+    end
+  end
+end

data/spec/converters/ppm2pcm_converter_spec.rb

@@ -0,0 +1,32 @@
+require 'bioinform/conversion_algorithms/ppm2pcm_converter'
+
+describe Bioinform::ConversionAlgorithms::PPM2PCMConverter do
+  let(:pcm) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4]]) }
+  let(:pwm) { Bioinform::MotifModel::PWM.new([[1,2,3,4],[2,2,2,4]]) }
+  let(:ppm) { Bioinform::MotifModel::PPM.new([[0.1,0.2,0.3,0.4],[0.2,0.2,0.2,0.4]]) }
+
+  let(:named_ppm) { Bioinform::MotifModel::NamedModel.new(ppm, 'motif name') }
+  let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
+  let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
+
+  let(:converter) { Bioinform::ConversionAlgorithms::PPM2PCMConverter.new }
+  let(:converter_explicit_count) { Bioinform::ConversionAlgorithms::PPM2PCMConverter.new(count: 10) }
+
+  specify { expect(converter.count).to eq 100 }
+  specify { expect(converter_explicit_count.count).to eq 10 }
+
+  specify { expect(converter.convert(ppm)).to be_kind_of Bioinform::MotifModel::PCM }
+
+  specify { expect(converter.convert(ppm).matrix).to eq [[10,20,30,40],[20,20,20,40]] }
+
+  specify { expect(converter_explicit_count.convert(ppm).matrix).to eq [[1,2,3,4],[2,2,2,4]] }
+
+  specify { expect(converter.convert(named_ppm)).to be_kind_of Bioinform::MotifModel::NamedModel }
+  specify { expect(converter.convert(named_ppm).model).to be_kind_of Bioinform::MotifModel::PCM }
+  specify { expect(converter.convert(named_ppm).name).to eq 'motif name' }
+
+  specify { expect{ converter.convert(pcm) }.to raise_error Bioinform::Error }
+  specify { expect{ converter.convert(pwm) }.to raise_error Bioinform::Error }
+  specify { expect{ converter.convert(named_pcm) }.to raise_error Bioinform::Error }
+  specify { expect{ converter.convert(named_pwm) }.to raise_error Bioinform::Error }
+end

data/spec/converters/pwm2iupac_pwm_converter_spec.rb

@@ -0,0 +1,65 @@
+require 'bioinform/conversion_algorithms/pwm2iupac_pwm_converter'
+
+describe Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter do
+  let(:matrix) { [[1,2,3,1.567],[12,-11,12,0],[-1.1, 0.6, 0.4, 0.321]] }
+  let(:pwm) { Bioinform::MotifModel::PWM.new(matrix) }
+  context 'with default parameters' do
+    let(:converter) { Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter.new }
+    specify{ expect(converter.iupac_alphabet).to eq Bioinform::NucleotideAlphabetWithN }
+    specify 'can convert only PWMs' do
+      pcm = Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4]])
+      expect { converter.convert(pcm) }.to raise_error Bioinform::Error
+    end
+  end
+
+  context 'with A,C,G,T,N-alphabet' do
+    let(:converter) { Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter.new(alphabet: Bioinform::NucleotideAlphabetWithN) }
+    specify { expect( converter.convert(pwm) ).to be_kind_of Bioinform::MotifModel::PWM }
+    specify { expect( converter.convert(pwm).alphabet ).to eq Bioinform::NucleotideAlphabetWithN }
+
+    specify do
+      expect( converter.convert(pwm).matrix ).to eq [
+          [1,2,3,1.567, (1+2+3+1.567)/4.0],
+          [12,-11,12,0, (12-11+12+0)/4.0],
+          [-1.1, 0.6, 0.4, 0.321, (-1.1+0.6+0.4+0.321)/4.0]]
+    end
+
+    specify do
+      custom_alphabet = Bioinform::ComplementableAlphabet.new([:A,:C,:G,:T,:N], [:T,:G,:C,:A,:N])
+      custom_matrix = [[1,2,3,1.567, 0.1],[12,-11,12,0, 0.1],[-1.1, 0.6, 0.4, 0.321, 0.1]]
+      pwm_w_custom_alphabet = Bioinform::MotifModel::PWM.new(custom_matrix, alphabet: custom_alphabet)
+      expect { converter.convert(pwm_w_custom_alphabet) }.to raise_error Bioinform::Error
+    end
+    specify do
+      custom_alphabet = Bioinform::ComplementableAlphabet.new([:A,:X,:Y,:T], [:T,:Y,:X,:A])
+      pwm_w_custom_alphabet = Bioinform::MotifModel::PWM.new(matrix, alphabet: custom_alphabet)
+      expect { converter.convert(pwm_w_custom_alphabet) }.to raise_error Bioinform::Error
+    end
+
+  end
+
+  context 'with full-iupac alphabet' do
+    let(:converter) { Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter.new(alphabet: Bioinform::IUPACAlphabet) }
+    specify { expect( converter.convert(pwm) ).to be_kind_of Bioinform::MotifModel::PWM }
+    specify { expect( converter.convert(pwm).alphabet ).to eq Bioinform::IUPACAlphabet }
+
+    specify do
+      expect( converter.convert(pwm).matrix ).to eq [
+          [1,2,3,1.567, (1+2)/2.0, (1+3)/2.0, (1+1.567)/2.0, (2+3)/2.0, (2+1.567)/2.0, (3+1.567)/2.0, (1+2+3)/3.0, (1+2+1.567)/3.0, (1+3+1.567)/3.0, (2+3+1.567)/3.0, (1+2+3+1.567)/4.0],
+          [12,-11,12,0, (12-11)/2.0, (12+12)/2.0, (12+0)/2.0, (-11+12)/2.0, (-11+0)/2.0, (12+0)/2.0, (12-11+12)/3.0, (12-11+0)/3.0, (12+12+0)/3.0, (-11+12+0)/3.0, (12-11+12+0)/4.0],
+          [-1.1, 0.6, 0.4, 0.321, (-1.1+0.6)/2.0, (-1.1+0.4)/2.0, (-1.1+0.321)/2.0, (0.6+0.4)/2.0, (0.6+0.321)/2.0, (0.4+0.321)/2.0, (-1.1+0.6+0.4)/3.0, (-1.1+0.6+0.321)/3.0, (-1.1+0.4+0.321)/3.0, (0.6+0.4+0.321)/3.0, (-1.1+0.6+0.4+0.321)/4.0]]
+    end
+
+    specify do
+      custom_alphabet = Bioinform::ComplementableAlphabet.new([:A,:C,:G,:T,:N], [:T,:G,:C,:A,:N])
+      custom_matrix = [[1,2,3,1.567, 0.1],[12,-11,12,0, 0.1],[-1.1, 0.6, 0.4, 0.321, 0.1]]
+      pwm_w_custom_alphabet = Bioinform::MotifModel::PWM.new(custom_matrix, alphabet: custom_alphabet)
+      expect { converter.convert(pwm_w_custom_alphabet) }.to raise_error Bioinform::Error
+    end
+    specify do
+      custom_alphabet = Bioinform::ComplementableAlphabet.new([:A,:X,:Y,:T], [:T,:Y,:X,:A])
+      pwm_w_custom_alphabet = Bioinform::MotifModel::PWM.new(matrix, alphabet: custom_alphabet)
+      expect { converter.convert(pwm_w_custom_alphabet) }.to raise_error Bioinform::Error
+    end
+  end
+end

data/spec/converters/pwm2pcm_converter_spec.rb

@@ -0,0 +1,57 @@
+require 'bioinform/conversion_algorithms/pwm2pcm_converter'
+
+describe Bioinform::ConversionAlgorithms::PWM2PCMConverter do
+  specify { expect(Bioinform::ConversionAlgorithms::PWM2PCMConverter.new(count: 137).count).to eq 137 }
+  specify { expect(Bioinform::ConversionAlgorithms::PWM2PCMConverter.new(pseudocount: 5).pseudocount).to eq 5 }
+  specify {
+    bckgr = Bioinform::Frequencies.new([0.1,0.4,0.4,0.1])
+    expect(Bioinform::ConversionAlgorithms::PWM2PCMConverter.new(background: bckgr).background).to eq bckgr
+  }
+  
+  context 'from PWM converted by PCM2PWMConverter' do
+    let(:specified_pseudocount) { 5 }
+    let(:pcm) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4]]) }
+
+    
+    specify do
+      pwm = Bioinform::ConversionAlgorithms::PCM2PWMConverter.new(pseudocount: specified_pseudocount).convert(pcm)
+      expect(Bioinform::ConversionAlgorithms::PWM2PCMConverter.new(count: 10, pseudocount: specified_pseudocount).convert(pwm)).to be_within_range_from_matrix(pcm, 1e-10)
+    end
+    specify do
+      pwm = Bioinform::ConversionAlgorithms::PCM2PWMConverter.new.convert(pcm)
+      expect(Bioinform::ConversionAlgorithms::PWM2PCMConverter.new(count: 10).convert(pwm)).to be_within_range_from_matrix(pcm, 1e-10)
+    end
+  end
+
+  specify do
+    pwm = Bioinform::MotifModel::PWM.new([[1,2,3,4],[2,2,2,4]])      
+    pcm = Bioinform::ConversionAlgorithms::PWM2PCMConverter.new(count: 137).convert(pwm)
+    expect(pcm.count).to be_within(1e-10).of(137)
+  end
+
+  context 'with default converter' do
+    let(:converter) { Bioinform::ConversionAlgorithms::PWM2PCMConverter.new }
+
+    let(:pwm) { Bioinform::MotifModel::PWM.new([[1,2,3,4],[2,2,2,4]]) }
+    let(:pcm) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4]]) }
+    let(:ppm) { Bioinform::MotifModel::PPM.new([[0.1,0.2,0.3,0.4],[0.2,0.2,0.2,0.4]]) }
+
+    let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
+    let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
+
+
+    specify { expect(converter.count).to eq 100 }
+    specify { expect(converter.pseudocount).to eq :default }
+    specify { expect(converter.background).to eq Bioinform::Background::Uniform }
+
+    specify { expect(converter.convert(pwm)).to be_kind_of Bioinform::MotifModel::PCM }
+
+    specify { expect(converter.convert(named_pwm)).to be_kind_of Bioinform::MotifModel::NamedModel }
+    specify { expect(converter.convert(named_pwm).model).to be_kind_of Bioinform::MotifModel::PCM }
+    specify { expect(converter.convert(named_pwm).name).to eq 'motif name' }
+
+    specify { expect{ converter.convert(pcm) }.to raise_error Bioinform::Error }
+    specify { expect{ converter.convert(ppm) }.to raise_error Bioinform::Error }
+    specify { expect{ converter.convert(named_pcm) }.to raise_error Bioinform::Error }
+  end
+end

data/spec/data_models/named_model_spec.rb

@@ -0,0 +1,41 @@
+require 'bioinform/data_models/pwm'
+require 'bioinform/data_models/named_model'
+
+describe Bioinform::MotifModel::NamedModel do
+  context 'with PWM-model' do
+    let(:pwm) { Bioinform::MotifModel::PWM.new([[1,2,3,4],[10,20,30,40]]) }
+    let(:name) { 'pwm name' }
+    let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, name) }
+    specify { expect(named_pwm.model).to eq pwm }
+    specify { expect(named_pwm.name).to eq name }
+
+    context 'being sent a method returning a result of model type (class is Bioinform::MotifModel::*)' do
+      subject { named_pwm.reversed }
+      specify 'should return a named model' do
+        expect(subject).to be_kind_of Bioinform::MotifModel::NamedModel
+      end
+      specify 'resulting named model should wrap actual result' do
+        expect(subject.model).to eq pwm.reversed
+      end
+      specify 'resulting named model should have the same name as callee' do
+        expect(subject.name).to eq name
+      end
+    end
+
+    context 'being sent a method returning a result of common, non-model type (class is not Bioinform::MotifModel::*)' do
+      specify 'should return original result' do
+        expect(named_pwm.length).to eq pwm.length
+      end
+    end
+
+    describe '#==' do
+      let(:another_pwm) { Bioinform::MotifModel::PWM.new([[4,3,2,1],[-100,-500,-500,-100]]) }
+      specify { expect(named_pwm).to eq Bioinform::MotifModel::NamedModel.new(pwm, name) }
+      specify { expect(named_pwm).not_to eq Bioinform::MotifModel::NamedModel.new(pwm, 'Another name') }
+      specify { expect(named_pwm).not_to eq Bioinform::MotifModel::NamedModel.new(another_pwm, name) }
+      specify { expect(named_pwm).not_to eq Bioinform::MotifModel::NamedModel.new(another_pwm, 'Another name') }
+    end
+
+    specify { expect(named_pwm.to_s).to eq ">pwm name\n" + "1\t2\t3\t4\n" + "10\t20\t30\t40" }
+  end
+end

data/spec/data_models/pcm_spec.rb

@@ -1,56 +1,125 @@
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/data_models/pcm'
-
-module Bioinform
-  describe PCM do
-    describe '#count' do
-      it 'should be equal to sum of elements at position' do
-        Fabricate(:pcm).count.should == 7
-        Fabricate(:pcm_with_floats).count.should == 7.5
-      end
-    end
+require 'bioinform/data_models/pcm'
 
-    describe '#to_pwm' do
-      subject{ Fabricate(:pcm) }
-      it 'should return PWM' do
-        Fabricate(:pcm).to_pwm.should be_kind_of(PWM)
-      end
-      it 'should make transformation: el --> log( (el + p_i*pseudocount) / (p_i*(count + pseudocount)) )' do
-        subject.to_pwm(1).matrix.map{|line|line.map{|el| el.round(3)}}.should == Fabricate(:rounded_upto_3_digits_pwm_by_pcm_with_pseudocount_1).matrix
-        subject.to_pwm(10).matrix.map{|line|line.map{|el| el.round(3)}}.should == Fabricate(:rounded_upto_3_digits_pwm_by_pcm_with_pseudocount_10).matrix
-      end
-      it 'should use default pseudocount equal to log(count)' do
-        Fabricate(:pcm).to_pwm.should == Fabricate(:pcm).to_pwm(Math.log(7))
-      end
-      it 'should preserve name' do
-        Fabricate(:pcm, name: nil).to_pwm.name.should be_nil
-        Fabricate(:pcm, name: 'Stub name').to_pwm.name.should == 'Stub name'
-      end
+describe Bioinform::MotifModel::PCM do
+
+  describe '.new' do
+    specify 'fails on matrix having negative elements' do
+      expect { Bioinform::MotifModel::PCM.new([[1,2,1,3],[3,3,0,1], [-2, 3, 3, 3]]) }.to raise_error (Bioinform::Error)
     end
 
-    describe '#to_ppm' do
-      let(:pcm_motif) { Fabricate(:pcm) }
-      context 'returned object' do
-        subject{ pcm_motif.to_ppm }
-        it { should be_kind_of(PPM)}
-        it 'should have matrix transformed with el --> el / count' do
-          subject.matrix.should == Fabricate(:ppm_pcm_divided_by_count).matrix
+    context 'with valid matrix' do
+      context 'with equal counts in different positions' do
+        let(:matrix) { [[1,2,1,3],[3,3,0,1], [1, 0, 3, 3]] }
+        specify do
+          expect { Bioinform::MotifModel::PCM.new(matrix) }.not_to raise_error
         end
-        context 'when source PCM name is absent' do
-          let(:pcm_motif) { Fabricate(:pcm, name: nil) }
-          it 'should have no name' do
-            subject.name.should be_nil
-          end
+        specify do
+          expect( Bioinform::MotifModel::PCM.new(matrix).matrix ).to eq matrix
         end
-        context 'when source PCM has name' do
-          let(:pcm_motif) { Fabricate(:pcm, name: 'Stub-name') }
-          it 'should has the same name' do
-            subject.name.should == 'Stub-name'
-          end
+      end
+
+      context 'with different counts in different positions' do
+        let(:matrix) { [[1,2,1,3],[30,10,100,11000], [1, 0, 3, 3]] }
+        specify do
+          expect { Bioinform::MotifModel::PCM.new(matrix) }.not_to raise_error
+        end
+        specify do
+          expect( Bioinform::MotifModel::PCM.new(matrix).matrix ).to eq matrix
         end
       end
     end
+  end
 
+  describe '.from_string' do
+    specify {
+      expect( Bioinform::MotifModel::PCM.from_string("1 2 3 4\n4 2 2 2").model.class ).to eq Bioinform::MotifModel::PCM
+    }
+  end
+
+  context 'valid PCM' do
+    let(:pcm) { Bioinform::MotifModel::PCM.new(matrix) }
+    context 'with equal counts in different positions' do
+      let(:matrix) { [[1,2,1,3],[3,3,0,1], [1, 0, 3, 3]] }
+      specify{ expect(pcm.count).to eq 7 }
+    end
+
+    context 'with different counts in different positions' do
+      let(:matrix) { [[1,2,1,3],[30,10,100,11000], [1, 0, 3, 3]] }
+        specify{ expect{ pcm.count }.to raise_error Bioinform::Error }
+    end
+  end
+
+  context 'valid PCM' do
+    let(:pcm) { Bioinform::MotifModel::PCM.new(matrix) }
+    let(:matrix) { [[1,2,1,3],[3,3,0,1], [1, 0, 3, 3]] }
+
+    specify { expect(pcm).to eq Bioinform::MotifModel::PCM.new(matrix) }
+    specify { expect(pcm).not_to eq matrix }
+    specify { expect(pcm).not_to eq Bioinform::MotifModel::PM.new(matrix) }
+    specify { expect(pcm).not_to eq Bioinform::MotifModel::PWM.new(matrix) }
+    # specify { expect(pcm).not_to eq Bioinform::MotifModel::PPM.new(matrix) }
+    specify { expect(matrix).not_to eq pcm }
+    specify { expect(Bioinform::MotifModel::PM.new(matrix)).not_to eq pcm }
+    specify { expect(Bioinform::MotifModel::PWM.new(matrix)).not_to eq pcm }
+    # specify { expect(Bioinform::MotifModel::PPM.new(matrix)).not_to eq pcm }
+
+    specify { expect(pcm.named('motif name')).to be_kind_of Bioinform::MotifModel::NamedModel }
+    specify { expect(pcm.named('motif name').model).to eq pcm }
+    specify { expect(pcm.named('motif name').name).to eq 'motif name' }
+
+    describe '#reversed, #complemented, #reverse_complemented' do
+      specify { expect(pcm.reversed).to be_kind_of Bioinform::MotifModel::PCM }
+      specify { expect(pcm.complemented).to be_kind_of Bioinform::MotifModel::PCM }
+      specify { expect(pcm.reverse_complemented).to be_kind_of  Bioinform::MotifModel::PCM }
+      specify { expect(pcm.revcomp).to be_kind_of             Bioinform::MotifModel::PCM }
+    end
+  end
+
+  describe '.acts_as_pcm?' do
+    let(:matrix) { [[0.1,0.2,0.3,0.4],[0.3,0.3,0.3,0.1], [0.3,0,0.3,0.4]] }
+    let(:pcm) { Bioinform::MotifModel::PCM.new(matrix) }
+    let(:pwm) { Bioinform::MotifModel::PWM.new(matrix) }
+    let(:ppm) { Bioinform::MotifModel::PPM.new(matrix) }
+    let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
+    let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
+    let(:named_ppm) { Bioinform::MotifModel::NamedModel.new(ppm, 'motif name') }
+    specify{ expect(Bioinform::MotifModel.acts_as_pcm?(pcm)).to be_truthy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pcm?(named_pcm)).to be_truthy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pcm?(pwm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pcm?(named_pwm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pcm?(ppm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pcm?(named_ppm)).to be_falsy }
+  end
+
+  describe '.acts_as_pwm?' do
+    let(:matrix) { [[0.1,0.2,0.3,0.4],[0.3,0.3,0.3,0.1], [0.3,0,0.3,0.4]] }
+    let(:pcm) { Bioinform::MotifModel::PCM.new(matrix) }
+    let(:pwm) { Bioinform::MotifModel::PWM.new(matrix) }
+    let(:ppm) { Bioinform::MotifModel::PPM.new(matrix) }
+    let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
+    let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
+    let(:named_ppm) { Bioinform::MotifModel::NamedModel.new(ppm, 'motif name') }
+    specify{ expect(Bioinform::MotifModel.acts_as_pwm?(pcm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pwm?(named_pcm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pwm?(pwm)).to be_truthy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pwm?(named_pwm)).to be_truthy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pwm?(ppm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_pwm?(named_ppm)).to be_falsy }
+  end
 
+  describe '.acts_as_ppm?' do
+    let(:matrix) { [[0.1,0.2,0.3,0.4],[0.3,0.3,0.3,0.1], [0.3,0,0.3,0.4]] }
+    let(:pcm) { Bioinform::MotifModel::PCM.new(matrix) }
+    let(:pwm) { Bioinform::MotifModel::PWM.new(matrix) }
+    let(:ppm) { Bioinform::MotifModel::PPM.new(matrix) }
+    let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
+    let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
+    let(:named_ppm) { Bioinform::MotifModel::NamedModel.new(ppm, 'motif name') }
+    specify{ expect(Bioinform::MotifModel.acts_as_ppm?(pcm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_ppm?(named_pcm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_ppm?(pwm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_ppm?(named_pwm)).to be_falsy }
+    specify{ expect(Bioinform::MotifModel.acts_as_ppm?(ppm)).to be_truthy }
+    specify{ expect(Bioinform::MotifModel.acts_as_ppm?(named_ppm)).to be_truthy }
   end
-end
+end