bioinform 0.1.8 → 0.1.9

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

@@ -0,0 +1,18 @@
+require_relative '../../../spec_helper'
+require_relative 'yield_help_string'
+
+shared_examples 'motif list is empty' do
+  context  'motif list is empty' do
+    Given(:motif_list) { [] }
+    
+    context 'with options' do
+      Given(:options) { '--formatter default  --silent' }
+      include_examples 'yield help string'
+    end
+    
+    context 'without options' do
+      Given(:options){ '' }
+      include_examples 'yield help string'
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require_relative '../../../spec_helper'
+
+shared_examples 'several motifs specified' do
+  context 'several motifs specified' do
+    Given {
+      make_model_file(sp1_f1, 'pcm')
+      make_model_file(klf4_f2, 'pcm')
+    }
+    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") }
+  end
+end

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

@@ -0,0 +1,50 @@
+require_relative '../../../spec_helper'
+
+shared_examples 'single motif specified' do
+  context 'single motif specified' do
+    Given {
+      make_model_file(sp1_f1, model_from)
+    }
+    Given(:motif_list) { [sp1_f1] }
+
+    context 'when input is a pcm' do
+      Given(:model_from) { 'pcm' }
+
+      context 'pwm conversion invoked' do
+        Given(:model_to) { 'pwm' }
+        Then { resulting_stdout.should == sp1_f1.pwm }
+      end
+
+      context 'ppm conversion invoked' do
+        Given(:model_to) { 'ppm' }
+        Then { resulting_stdout.should == sp1_f1.ppm }
+      end
+    end
+    
+    context 'when input is a pwm' do
+      Given(:model_from) { 'pwm' }
+
+      context 'pcm conversion invoked' do
+        Given(:model_to) { 'pcm' }
+        include_examples 'yields motif conversion error'
+      end
+
+      context 'ppm conversion invoked' do
+        Given(:model_to) { 'ppm' }
+        include_examples 'yields motif conversion error'
+      end
+    end
+
+    context 'if there exist other files in current folder' do
+      Given {
+        make_model_file(sp1_f1, model_from)
+        make_model_file(klf4_f2, model_from)
+      }
+      Given(:model_from) { 'pcm' }
+      Given(:model_to) { 'pwm' }
+      Then { resulting_stdout.should == sp1_f1.pwm }
+      Then { resulting_stdout.should_not match(klf4_f2.pwm) }
+    end
+    
+  end
+end

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

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

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

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

data/spec/data_models/collection_spec.rb

@@ -5,9 +5,9 @@ module Bioinform
   describe Collection do
     before :each do
       @collection = Collection.new(name: 'Main collection')
-      @pm_1 = PM.new(matrix:[[1,1,1,1]],name:'Stub datamodel')
-      @pm_2 = PM.new(matrix:[[1,2,3,4],[4,3,2,1]],name:'Second stub')
-      @pm_3 = PM.new(matrix:[[11,12,13,14],[41,31,21,11]],name:'Third stub')
+      @pm_1 = Fabricate(:pm_1)
+      @pm_2 = Fabricate(:pm_2)
+      @pm_3 = Fabricate(:pm_3)
     end
     describe '#size' do
       it 'should return size of collection' do
@@ -20,51 +20,52 @@ module Bioinform
         @collection << @pm_1
         @collection << @pm_2
         @collection << @pm_3
-        @collection.collection.map(&:first).should include(@pm_1, @pm_2, @pm_3)
+        @collection.should include(Motif.new(pm: @pm_1), Motif.new(pm: @pm_2), Motif.new(pm: @pm_3))
       end
       it 'should be chainable' do
         @collection << @pm_1 << @pm_2 << @pm_3
-        @collection.collection.map(&:first).should include(@pm_1, @pm_2, @pm_3)
-      end
-      it 'should mark motif with name' do
-        @collection << @pm_1 << @pm_2
-        @pm_1.should be_tagged('Main collection')
-        @pm_2.should be_tagged('Main collection')
-      end
-      it 'should mark motif with self' do
-        @collection << @pm_1 << @pm_2
-        @pm_1.should be_tagged(@collection)
-        @pm_2.should be_tagged(@collection)
+        @collection.should include(Motif.new(pm: @pm_1), Motif.new(pm: @pm_2), Motif.new(pm: @pm_3))
       end
+#      it 'should mark motif with name' do
+#        @collection << @pm_1 << @pm_2
+#        @pm_1.should be_tagged('Main collection')
+#        @pm_2.should be_tagged('Main collection')
+#      end
+#      it 'should mark motif with self' do
+#        @collection << @pm_1 << @pm_2
+#        @pm_1.should be_tagged(@collection)
+#        @pm_2.should be_tagged(@collection)
+#      end
     end
 
-    describe '#each_pm' do
+    describe '#each' do
       before :each do
         @collection << @pm_1 << @pm_2 << @pm_3
       end
       context 'with block given' do
-        it 'should yield elements of collecton' do
-          expect{|b| @collection.each_pm(&b)}.to yield_successive_args(@pm_1, @pm_2, @pm_3)
+        it 'should yield Motifs' do
+          expect{|b| @collection.each(&b)}.to yield_successive_args(Motif,Motif,Motif)
         end
       end
       context 'with block given' do
         it 'return an Enumerator' do
-          @collection.each_pm.should be_kind_of(Enumerator)
+          @collection.each.should be_kind_of(Enumerator)
         end
       end
     end
-    describe '#each_pcm' do
+
+    describe '#each(:pcm)' do
       before :each do
-        @collection << @pm_1 << @pm_2 << @pm_3
+        @collection << @pm_1.as_pcm << @pm_2 << @pm_3.as_pcm
       end
       context 'with block given' do
         it 'should yield elements of collecton converted to pcm' do
-          expect{|b| @collection.each_pcm(&b)}.to yield_successive_args(PCM, PCM, PCM)
+          expect{|b| @collection.each(:pcm, &b)}.to yield_successive_args(PCM, nil, PCM)
         end
       end
       context 'with block given' do
         it 'return an Enumerator' do
-          @collection.each_pcm.should be_kind_of(Enumerator)
+          @collection.each(:pcm).should be_kind_of(Enumerator)
         end
       end
     end
@@ -72,8 +73,8 @@ module Bioinform
     describe '#+' do
       before :each do
         @collection << @pm_1 << @pm_2 << @pm_3
-        @pm_sec_1 = PM.new(matrix: [[1,0,1,0],[0,0,0,0],[1,2,3,4]], name: 'Secondary collection matrix 1')
-        @pm_sec_2 = PM.new(matrix: [[1,2,1,2],[0,3,6,9],[1,2,3,4]], name: 'Secondary collection matrix 2')
+        @pm_sec_1 = Fabricate(:pm_4)
+        @pm_sec_2 = Fabricate(:pm_5)
         @secondary_collection = Collection.new(name: 'Secondary collection')
         @secondary_collection << @pm_sec_1 << @pm_sec_2
         @summary_collection = @collection + @secondary_collection
@@ -81,16 +82,17 @@ module Bioinform
       it 'should create a collection consisting of all elements of both collections' do
         @summary_collection.should be_kind_of(Collection)
         @summary_collection.size.should == (@collection.size + @secondary_collection.size)
-        @summary_collection.collection.map(&:first).should include(@pm_1, @pm_2, @pm_3, @pm_sec_1, @pm_sec_2)
-      end
-      it 'should leave marks on motifs' do
-        @pm_1.should be_tagged('Main collection')
-        @pm_sec_1.should be_tagged('Secondary collection')
-      end
-      it 'should not mix marks of motifs in different collections' do
-        @pm_1.should_not be_tagged('Secondary collection')
-        @pm_sec_1.should_not be_tagged('Main collection')
+        @summary_collection.should include(Motif.new(pm: @pm_1), Motif.new(pm: @pm_2), Motif.new(pm: @pm_3), 
+                                          Motif.new(pm: @pm_sec_1), Motif.new(pm: @pm_sec_2))
       end
+      # it 'should leave marks on motifs' do
+        # @pm_1.should be_tagged('Main collection')
+        # @pm_sec_1.should be_tagged('Secondary collection')
+      # end
+      # it 'should not mix marks of motifs in different collections' do
+        # @pm_1.should_not be_tagged('Secondary collection')
+        # @pm_sec_1.should_not be_tagged('Main collection')
+      # end
     end
   end
 end

data/spec/data_models/motif_spec.rb

@@ -0,0 +1,224 @@
+require_relative '../../lib/bioinform/data_models/motif'
+
+shared_examples 'when pm is PM' do
+  context 'when pm-value is a PCM' do
+    let(:pm) { Fabricate(:pcm) }
+    it 'sets pcm-attribute to specified PM' do
+      subject.pcm.should == Fabricate(:pcm)
+    end
+  end
+  context 'when pm-value is a PWM' do
+    let(:pm) { Fabricate(:pwm) }
+    it 'sets pwm-attribute to specified PM' do
+      subject.pwm.should == Fabricate(:pwm)
+    end
+  end
+  context 'when pm-value is a PPM' do
+    let(:pm) { Fabricate(:ppm) }
+    it 'sets ppm-attribute to specified PM' do
+      subject.ppm.should == Fabricate(:ppm)
+    end
+  end
+  context 'when pm-value is a PM' do
+    let(:pm) { Fabricate(:pm) }
+    it 'sets only parameter pm attribute to specified PM' do
+      subject.parameters.pm.should == Fabricate(:pm)
+      subject.pcm.should be_nil
+      subject.pwm.should be_nil
+      subject.ppm.should be_nil
+    end
+  end
+end
+
+
+module Bioinform
+  describe Motif do
+    describe '.new' do
+      it 'accepts empty argument list' do
+        expect{ described_class.new }.to_not raise_error
+      end
+
+      context 'when argument is a Hash' do
+        subject{ described_class.new(hash) }
+        context 'which contains usual symbolic parameters' do
+          let(:hash){ {:a => 123, :key => 'value', :threshold => {0.1 => 15} } }
+          it 'sets its content as parameters' do
+            subject.parameters.a.should == 123
+            subject.parameters.key.should == 'value'
+            subject.parameters.threshold.should == {0.1 => 15}
+          end
+        end
+        context 'which contains any combination of :pwm, :pcm and :ppm keys' do
+          let(:hash) { {pcm: 'my_pcm', ppm: 'my_ppm'} }
+          it 'sets corresponding attributes to specified values' do
+            subject.pcm.should == 'my_pcm'
+            subject.ppm.should == 'my_ppm'
+          end
+        end
+      end
+
+      context 'when argument is a Hash with pm-key' do
+        subject{ described_class.new(pm: pm) }
+
+        include_examples 'when pm is PM'
+
+        context 'when pm-value is a usual object' do
+          let(:pm) { 'stub pm' }
+          it 'sets only parameter pm attribute to specified value' do
+            subject.parameters.pm.should == 'stub pm'
+            subject.pcm.should be_nil
+            subject.pwm.should be_nil
+            subject.ppm.should be_nil
+          end
+        end
+      end
+      context 'when argument is neither PM nor Hash' do
+        it 'raises ArgumentError' do
+          expect{ described_class.new('stub pm') }.to raise_error(ArgumentError)
+        end
+      end
+    end
+
+    ########################################################
+    describe '#pcm' do
+      subject {  motif.pcm }
+      context 'when pcm is set' do
+        context 'when pwm and ppm aren\'t setted' do
+          let(:motif) { Fabricate(:motif_pcm) }
+          it 'returns setted pcm' do
+            subject.should == Fabricate(:pcm)
+          end
+        end
+        context 'when ppm also setted' do
+          let(:motif) { Fabricate(:motif_pcm_and_ppm) }
+          it 'returns setted pcm' do
+            subject.should == Fabricate(:pcm)
+          end
+        end
+        context 'when pwm also setted' do
+          let(:motif) { Fabricate(:motif_pcm_and_pwm) }
+          it 'returns setted pcm' do
+            subject.should == Fabricate(:pcm)
+          end
+        end
+      end
+
+      context 'when pcm isn\'t set' do
+        context 'when nothing set' do
+          let(:motif) { Fabricate(:motif) }
+          it 'returns nil' do
+            subject.should be_nil
+          end
+        end
+        context 'when pwm setted' do
+          let(:motif) { Fabricate(:motif_pwm) }
+          it 'returns nil' do
+            subject.should be_nil
+          end
+        end
+        context 'when ppm setted' do
+          let(:motif) { Fabricate(:motif_ppm) }
+          it 'returns nil' do
+            subject.should be_nil
+          end
+        end
+      end
+    end
+    ############################################
+    describe '#pwm' do
+      subject {  motif.pwm }
+      context 'when pwm is set' do
+        context 'when pcm and ppm aren\'t setted' do
+          let(:motif) { Fabricate(:motif_pwm) }
+          it 'returns setted pwm' do
+            subject.should == Fabricate(:pwm)
+          end
+        end
+        context 'when ppm also setted' do
+          let(:motif) { Fabricate(:motif_pwm_and_ppm) }
+          it 'returns setted pwm' do
+            subject.should == Fabricate(:pwm)
+          end
+        end
+        context 'when pcm also setted' do
+          let(:motif) { Fabricate(:motif_pcm_and_pwm) }
+          it 'returns setted pwm' do
+            subject.should == Fabricate(:pwm)
+          end
+        end
+      end
+
+      context 'when pwm isn\'t set' do
+        context 'when nothing set' do
+          let(:motif) { Fabricate(:motif) }
+          it 'returns nil' do
+            subject.should be_nil
+          end
+        end
+        context 'when pcm setted' do
+          let(:motif) { Fabricate(:motif_pcm) }
+          it 'returns pcm converted to pwm' do
+            subject.should == Fabricate(:pwm_by_pcm)
+          end
+        end
+        context 'when ppm setted' do
+          let(:motif) { Fabricate(:motif_ppm) }
+          it 'returns nil' do
+            subject.should be_nil
+          end
+        end
+      end
+    end
+
+    ############################################
+    describe '#ppm' do
+      subject {  motif.ppm }
+      context 'when ppm is set' do
+        context 'when pcm and pwm aren\'t setted' do
+          let(:motif) { Fabricate(:motif_ppm) }
+          it 'returns setted ppm' do
+            subject.should == Fabricate(:ppm)
+          end
+        end
+        context 'when pcm also setted' do
+          let(:motif) { Fabricate(:motif_pcm_and_ppm) }
+          it 'returns setted ppm' do
+            subject.should == Fabricate(:ppm)
+          end
+        end
+        context 'when pwm also setted' do
+          let(:motif) { Fabricate(:motif_pwm_and_ppm) }
+          it 'returns setted ppm' do
+            subject.should == Fabricate(:ppm)
+          end
+        end
+      end
+
+      context 'when ppm isn\'t set' do
+        context 'when nothing set' do
+          let(:motif) { Fabricate(:motif) }
+          it 'returns nil' do
+            subject.should be_nil
+          end
+        end
+        context 'when pcm setted' do
+          let(:motif) { Fabricate(:motif_pcm) }
+          it 'returns pcm converted to ppm' do
+            subject.should == Fabricate(:ppm_by_pcm)
+          end
+        end
+        context 'when pwm setted' do
+          let(:motif) { Fabricate(:motif_pwm) }
+          it 'returns nil' do
+            subject.should be_nil
+          end
+        end
+      end
+    end
+
+
+
+
+
+  end
+end

data/spec/data_models/pcm_spec.rb

@@ -5,38 +5,49 @@ module Bioinform
   describe PCM do
     describe '#count' do
       it 'should be equal to sum of elements at position' do
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).count.should == 7
-        PCM.new([[1, 2.3, 3.2, 1],[4.4, 0.1, 1, 2]]).count.should == 7.5
+        Fabricate(:pcm).count.should == 7
+        Fabricate(:pcm_with_floats).count.should == 7.5
       end
     end
 
     describe '#to_pwm' do
+      subject{ Fabricate(:pcm) }
       it 'should return PWM' do
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm.should be_kind_of(PWM)
+        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
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm(1).matrix.map{|line|line.map{|el| el.round(3)}}.should  == [[-0.47, 0.118, 0.486, -0.47],[0.754, -2.079, -0.47, 0.118]]
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm(10).matrix.map{|line|line.map{|el| el.round(3)}}.should == [[-0.194, 0.057, 0.258, -0.194],[0.425, -0.531, -0.194, 0.057]]
+        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
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm.should == PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_pwm(Math.log(7))
+        Fabricate(:pcm).to_pwm.should == Fabricate(:pcm).to_pwm(Math.log(7))
       end
       it 'should preserve name' do
-        PCM.new(matrix: [[1, 2, 3, 1],[4, 0, 1, 2]], name: nil).to_pwm.name.should be_nil
-        PCM.new(matrix: [[1, 2, 3, 1],[4, 0, 1, 2]], name: 'Stub name').to_pwm.name.should == 'Stub name'
+        Fabricate(:pcm, name: nil).to_pwm.name.should be_nil
+        Fabricate(:pcm, name: 'Stub name').to_pwm.name.should == 'Stub name'
       end
     end
 
     describe '#to_ppm' do
-      it 'should return PPM' do
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_ppm.should be_kind_of(PPM)
-      end
-      it 'should make transformation el --> el / count' do
-        PCM.new([[1, 2, 3, 1],[4, 0, 1, 2]]).to_ppm.should == PPM.new([[1.0/7, 2.0/7, 3.0/7, 1.0/7],[4.0/7, 0.0/7, 1.0/7, 2.0/7]])
-      end
-      it 'should preserve name' do
-        PCM.new(matrix: [[1, 2, 3, 1],[4, 0, 1, 2]], name: nil).to_ppm.name.should be_nil
-        PCM.new(matrix: [[1, 2, 3, 1],[4, 0, 1, 2]], name: 'Stub name').to_ppm.name.should == 'Stub name'
+      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
+        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
+        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
       end
     end