bioinform 0.1.12 → 0.1.13

data/spec/parsers/string_parser_spec.rb

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

data/spec/parsers/trivial_parser_spec.rb

@@ -1,64 +1,64 @@
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/parsers/parser'
-require_relative '../../lib/bioinform/data_models/collection'
-
-module Bioinform
-  describe TrivialParser do
-    context '.new' do
-      it 'should take the only input argument' do
-        TrivialParser.instance_method(:initialize).arity.should == 1
-      end
-    end
-
-    context '#parse!' do
-      it 'should return OpenStruct based on input of that was passed to initialize when input is a Hash' do
-        TrivialParser.new(matrix: 'stub matrix', name: 'stub name').parse!.should == OpenStruct.new(matrix: 'stub matrix', name: 'stub name')
-      end
-
-      it 'should return OpenStruct based on input of that was passed to initialize when input is a OpenStruct' do
-        TrivialParser.new(OpenStruct.new(matrix: 'stub matrix', name: 'stub name')).parse!.should == OpenStruct.new(matrix: 'stub matrix', name: 'stub name')
-      end
-    end
-
-    context '.split_on_motifs' do
-      it 'should be able to get a single PM' do
-        TrivialParser.split_on_motifs({matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name'}, PM).should == [ PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name:'Name') ]
-      end
-    end
-
-    it 'can be used to create PM with {matrix: ..., name: ...} form' do
-      pm = PM.new({matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name'}, TrivialParser)
-      pm.matrix.should == [[1,2,3,4],[5,6,7,8]]
-      pm.name.should == 'Name'
-    end
-
-    it 'can be used to create PM from PM (make copy)' do
-      pm = Fabricate(:pm)
-      pm_copy = PM.new(pm, TrivialParser)
-      pm_copy.should == pm
-    end
-  end
-
-  describe TrivialCollectionParser do
-    let(:collection){ Fabricate(:three_elements_collection) }
-    let(:pm_1){ Fabricate(:pm_1) }
-    let(:pm_2){ Fabricate(:pm_2) }
-    let(:pm_3){ Fabricate(:pm_3) }
-
-    describe '#parse!' do
-      it 'can be used to obtain PMs from Collection' do
-        @parser = TrivialCollectionParser.new(collection)
-        @parser.parse!.should == pm_1
-        @parser.parse!.should == pm_2
-        @parser.parse!.should == pm_3
-        expect{ @parser.parse! }.to raise_error
-      end
-    end
-
-    describe '.split_on_motifs' do
-      it 'should be able to split collection into PMs' do
-        TrivialCollectionParser.split_on_motifs(collection).should == [pm_1, pm_2, pm_3]
-      end
-    end
-  end
+require_relative '../spec_helper'
+require_relative '../../lib/bioinform/parsers/parser'
+require_relative '../../lib/bioinform/data_models/collection'
+
+module Bioinform
+  describe TrivialParser do
+    context '.new' do
+      it 'should take the only input argument' do
+        TrivialParser.instance_method(:initialize).arity.should == 1
+      end
+    end
+
+    context '#parse!' do
+      it 'should return OpenStruct based on input of that was passed to initialize when input is a Hash' do
+        TrivialParser.new(matrix: 'stub matrix', name: 'stub name').parse!.should == OpenStruct.new(matrix: 'stub matrix', name: 'stub name')
+      end
+
+      it 'should return OpenStruct based on input of that was passed to initialize when input is a OpenStruct' do
+        TrivialParser.new(OpenStruct.new(matrix: 'stub matrix', name: 'stub name')).parse!.should == OpenStruct.new(matrix: 'stub matrix', name: 'stub name')
+      end
+    end
+
+    context '.split_on_motifs' do
+      it 'should be able to get a single PM' do
+        TrivialParser.split_on_motifs({matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name'}, PM).should == [ PM.new(matrix: [[1,2,3,4],[5,6,7,8]], name:'Name') ]
+      end
+    end
+
+    it 'can be used to create PM with {matrix: ..., name: ...} form' do
+      pm = PM.new({matrix: [[1,2,3,4],[5,6,7,8]], name: 'Name'}, TrivialParser)
+      pm.matrix.should == [[1,2,3,4],[5,6,7,8]]
+      pm.name.should == 'Name'
+    end
+
+    it 'can be used to create PM from PM (make copy)' do
+      pm = Fabricate(:pm)
+      pm_copy = PM.new(pm, TrivialParser)
+      pm_copy.should == pm
+    end
+  end
+
+  describe TrivialCollectionParser do
+    let(:collection){ Fabricate(:three_elements_collection) }
+    let(:pm_1){ Fabricate(:pm_1) }
+    let(:pm_2){ Fabricate(:pm_2) }
+    let(:pm_3){ Fabricate(:pm_3) }
+
+    describe '#parse!' do
+      it 'can be used to obtain PMs from Collection' do
+        @parser = TrivialCollectionParser.new(collection)
+        @parser.parse!.should == pm_1
+        @parser.parse!.should == pm_2
+        @parser.parse!.should == pm_3
+        expect{ @parser.parse! }.to raise_error
+      end
+    end
+
+    describe '.split_on_motifs' do
+      it 'should be able to split collection into PMs' do
+        TrivialCollectionParser.split_on_motifs(collection).should == [pm_1, pm_2, pm_3]
+      end
+    end
+  end
 end

data/spec/parsers/yaml_parser_spec.rb

@@ -1,50 +1,50 @@
-require 'yaml'
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/parsers/yaml_parser'
-require_relative '../../lib/bioinform/data_models/collection'
-
-module Bioinform
-  describe YAMLParser do
-    context '#parse!' do
-      it 'should return PM that was encoded in YAML format' do
-        pm = Fabricate(:pm)
-        parser = YAMLParser.new(pm.to_yaml)
-        parser.parse!.should == pm
-      end
-    end
-    it 'can be used to create PM from yaml-string' do
-      pm = Fabricate(:pm)
-      pm_copy = PM.new(pm.to_yaml, YAMLParser)
-      pm_copy.should == pm
-    end
-
-    context '::split_on_motifs' do
-      it 'should be able to get a single PM' do
-        pm = Fabricate(:pm)
-        YAMLParser.split_on_motifs(pm.to_yaml, PM).should == [ pm ]
-      end
-    end
-  end
-
-  describe YAMLCollectionParser do
-    let(:yamled_collection){ Fabricate(:three_elements_collection).to_yaml }
-    let(:pm_1){ Fabricate(:pm_1) }
-    let(:pm_2){ Fabricate(:pm_2) }
-    let(:pm_3){ Fabricate(:pm_3) }
-
-    context '::split_on_motifs' do
-      it 'should be able to split yamled collection into PMs' do
-        YAMLCollectionParser.split_on_motifs(yamled_collection).should == [pm_1, pm_2, pm_3]
-      end
-    end
-    context '#parse!' do
-      it 'should return PMs which were in encoded YAML format' do
-        @parser = YAMLCollectionParser.new(yamled_collection)
-        @parser.parse!.should == pm_1
-        @parser.parse!.should == pm_2
-        @parser.parse!.should == pm_3
-        expect{ @parser.parse! }.to raise_error
-      end
-    end
-  end
-end
+require 'yaml'
+require_relative '../spec_helper'
+require_relative '../../lib/bioinform/parsers/yaml_parser'
+require_relative '../../lib/bioinform/data_models/collection'
+
+module Bioinform
+  describe YAMLParser do
+    context '#parse!' do
+      it 'should return PM that was encoded in YAML format' do
+        pm = Fabricate(:pm)
+        parser = YAMLParser.new(pm.to_yaml)
+        parser.parse!.should == pm
+      end
+    end
+    it 'can be used to create PM from yaml-string' do
+      pm = Fabricate(:pm)
+      pm_copy = PM.new(pm.to_yaml, YAMLParser)
+      pm_copy.should == pm
+    end
+
+    context '::split_on_motifs' do
+      it 'should be able to get a single PM' do
+        pm = Fabricate(:pm)
+        YAMLParser.split_on_motifs(pm.to_yaml, PM).should == [ pm ]
+      end
+    end
+  end
+
+  describe YAMLCollectionParser do
+    let(:yamled_collection){ Fabricate(:three_elements_collection).to_yaml }
+    let(:pm_1){ Fabricate(:pm_1) }
+    let(:pm_2){ Fabricate(:pm_2) }
+    let(:pm_3){ Fabricate(:pm_3) }
+
+    context '::split_on_motifs' do
+      it 'should be able to split yamled collection into PMs' do
+        YAMLCollectionParser.split_on_motifs(yamled_collection).should == [pm_1, pm_2, pm_3]
+      end
+    end
+    context '#parse!' do
+      it 'should return PMs which were in encoded YAML format' do
+        @parser = YAMLCollectionParser.new(yamled_collection)
+        @parser.parse!.should == pm_1
+        @parser.parse!.should == pm_2
+        @parser.parse!.should == pm_3
+        expect{ @parser.parse! }.to raise_error
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,13 +1,13 @@
-$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-$LOAD_PATH.unshift File.dirname(__FILE__)
-
-require 'rspec'
-require 'rspec-given'
-
-require 'fileutils'
-require 'stringio'
-require 'fabrication'
-
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+$LOAD_PATH.unshift File.dirname(__FILE__)
+
+require 'rspec'
+require 'rspec-given'
+
+require 'fileutils'
+require 'stringio'
+require 'fabrication'
+
 require 'fakefs/spec_helpers'
 require 'spec_helper_source'
 Fabrication.clear_definitions

data/spec/spec_helper_source.rb

@@ -1,59 +1,59 @@
-# from minitest (TODO: make use of minitest, not override it)
-def capture_io(&block)
-  orig_stdout, orig_stderr = $stdout, $stderr
-  captured_stdout, captured_stderr = StringIO.new, StringIO.new
-  $stdout, $stderr = captured_stdout, captured_stderr
-  yield
-  return {stdout: captured_stdout.string, stderr: captured_stderr.string}
-ensure
-  $stdout = orig_stdout
-  $stderr = orig_stderr
-end
-
-# Method stubs $stdin not STDIN !
-def provide_stdin(input, tty = false, &block)
-  orig_stdin = $stdin
-  $stdin = StringIO.new(input)
-  $stdin.send(:define_singleton_method, :tty?){ tty }  # Simulate that stdin is tty by default
-  yield
-ensure
-  $stdin = orig_stdin
-end
-
-def capture_output(&block)
-  capture_io(&block)[:stdout]
-end
-def capture_stderr(&block)
-  capture_io(&block)[:stderr]
-end
-
-def parser_specs(parser_klass, good_cases, bad_cases)
-  context '#parse!' do
-    good_cases.each do |case_description, input_and_result|
-      it "should be able to parse #{case_description}" do
-        result = parser_klass.new(input_and_result[:input]).parse
-        Bioinform::PM.new(result).should == input_and_result[:result]
-      end
-    end
-
-    bad_cases.each do |case_description, input|
-      it "should raise an exception on parsing #{case_description}" do
-        expect{ parser_klass.new(input[:input]).parse! }.to raise_error
-      end
-    end
-  end
-end
-
-##############################
-
-def make_file(filename, content)
-  File.open(filename, 'w'){|f| f.puts content }
-end
-
-def motif_filename(motif, model_type)
-  "#{motif.name}.#{model_type}"
-end
-
-def make_model_file(motif, model_type)
-  make_file(motif_filename(motif, model_type), motif.send(model_type))
-end
+# from minitest (TODO: make use of minitest, not override it)
+def capture_io(&block)
+  orig_stdout, orig_stderr = $stdout, $stderr
+  captured_stdout, captured_stderr = StringIO.new, StringIO.new
+  $stdout, $stderr = captured_stdout, captured_stderr
+  yield
+  return {stdout: captured_stdout.string, stderr: captured_stderr.string}
+ensure
+  $stdout = orig_stdout
+  $stderr = orig_stderr
+end
+
+# Method stubs $stdin not STDIN !
+def provide_stdin(input, tty = false, &block)
+  orig_stdin = $stdin
+  $stdin = StringIO.new(input)
+  $stdin.send(:define_singleton_method, :tty?){ tty }  # Simulate that stdin is tty by default
+  yield
+ensure
+  $stdin = orig_stdin
+end
+
+def capture_output(&block)
+  capture_io(&block)[:stdout]
+end
+def capture_stderr(&block)
+  capture_io(&block)[:stderr]
+end
+
+def parser_specs(parser_klass, good_cases, bad_cases)
+  context '#parse!' do
+    good_cases.each do |case_description, input_and_result|
+      it "should be able to parse #{case_description}" do
+        result = parser_klass.new(input_and_result[:input]).parse
+        Bioinform::PM.new(result).should == input_and_result[:result]
+      end
+    end
+
+    bad_cases.each do |case_description, input|
+      it "should raise an exception on parsing #{case_description}" do
+        expect{ parser_klass.new(input[:input]).parse! }.to raise_error
+      end
+    end
+  end
+end
+
+##############################
+
+def make_file(filename, content)
+  File.open(filename, 'w'){|f| f.puts content }
+end
+
+def motif_filename(motif, model_type)
+  "#{motif.name}.#{model_type}"
+end
+
+def make_model_file(motif, model_type)
+  make_file(motif_filename(motif, model_type), motif.send(model_type))
+end

data/spec/support/advanced_scan_spec.rb

@@ -1,32 +1,32 @@
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/support/advanced_scan'
-
-describe StringScanner do
-  context '#advanced_scan' do
-    before do
-      @scanner = StringScanner.new('abcde  fghIJKLmnop')
-    end
-    it 'should return nil if text doesn\'t match. Pointer should not move' do
-      @scanner.advanced_scan(/\s\s\s/).should be_nil
-      @scanner.pos.should == 0
-    end
-    it 'should return MatchData if string Matches. Pointer should move' do
-      @scanner.advanced_scan(/\w\w\w/).should be_kind_of MatchData
-      @scanner.pos.should == 3
-    end
-    it 'should return have the same groups as regexp has' do
-      result = @scanner.advanced_scan(/(\w+)(\s+)([a-z]+)([A-Z]+)/)
-      result[0].should == 'abcde  fghIJKL'
-      result[1].should == 'abcde'
-      result[2].should == '  '
-      result[3].should == 'fgh'
-      result[4].should == 'IJKL'
-    end
-    it 'should return have the same named groups as regexp has' do
-      result = @scanner.advanced_scan(/(\w+)(\s+)(?<word_downcase>[a-z]+)(?<word_upcase>[A-Z]+)/)
-      result[0].should == 'abcde  fghIJKL'
-      result[:word_downcase].should == 'fgh'
-      result[:word_upcase].should == 'IJKL'
-    end
-  end
+require_relative '../spec_helper'
+require_relative '../../lib/bioinform/support/advanced_scan'
+
+describe StringScanner do
+  context '#advanced_scan' do
+    before do
+      @scanner = StringScanner.new('abcde  fghIJKLmnop')
+    end
+    it 'should return nil if text doesn\'t match. Pointer should not move' do
+      @scanner.advanced_scan(/\s\s\s/).should be_nil
+      @scanner.pos.should == 0
+    end
+    it 'should return MatchData if string Matches. Pointer should move' do
+      @scanner.advanced_scan(/\w\w\w/).should be_kind_of MatchData
+      @scanner.pos.should == 3
+    end
+    it 'should return have the same groups as regexp has' do
+      result = @scanner.advanced_scan(/(\w+)(\s+)([a-z]+)([A-Z]+)/)
+      result[0].should == 'abcde  fghIJKL'
+      result[1].should == 'abcde'
+      result[2].should == '  '
+      result[3].should == 'fgh'
+      result[4].should == 'IJKL'
+    end
+    it 'should return have the same named groups as regexp has' do
+      result = @scanner.advanced_scan(/(\w+)(\s+)(?<word_downcase>[a-z]+)(?<word_upcase>[A-Z]+)/)
+      result[0].should == 'abcde  fghIJKL'
+      result[:word_downcase].should == 'fgh'
+      result[:word_upcase].should == 'IJKL'
+    end
+  end
 end

data/spec/support/array_product_spec.rb

@@ -1,15 +1,15 @@
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/support/array_product'
-
-describe Array do
-  context '::product' do
-    it 'should take any number of arrays and product them as if #product was made to first and others' do
-      Array.product([1,2,3]).should == [1,2,3].product()
-      Array.product([1,2,3],[4,5,6]).should == [1,2,3].product([4,5,6])
-      Array.product([1,2,3],[4,5,6],[7,8,9]).should == [1,2,3].product([4,5,6],[7,8,9])
-    end
-    it 'should return empty array if no arrays\'re given' do
-      Array.product().should == []
-    end
-  end
+require_relative '../spec_helper'
+require_relative '../../lib/bioinform/support/array_product'
+
+describe Array do
+  context '::product' do
+    it 'should take any number of arrays and product them as if #product was made to first and others' do
+      Array.product([1,2,3]).should == [1,2,3].product()
+      Array.product([1,2,3],[4,5,6]).should == [1,2,3].product([4,5,6])
+      Array.product([1,2,3],[4,5,6],[7,8,9]).should == [1,2,3].product([4,5,6],[7,8,9])
+    end
+    it 'should return empty array if no arrays\'re given' do
+      Array.product().should == []
+    end
+  end
 end