bioinform 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a5079febe803b62c10bfb75d36d855acdddd2e4
-  data.tar.gz: d532f731276f1fe95296cab260c2a41dbba8cb8e
+  metadata.gz: 64c5e6fe652d85bd538d08020e5d06779e676fa7
+  data.tar.gz: 954a02afb784d086d006e59e97f57400a10f7858
 SHA512:
-  metadata.gz: 07043ec6338e5e41a92aaca9817a82ed259b7d60f559cc27fe0936a5d8516e46b8379be53c3cd60f276a7bada3e745093861348b719dea1622ac1801f780c039
-  data.tar.gz: 80995232881a7a69feb01a9ba04097ab277ea77bf7a8b9ad3abdc3c3dfb272f82103a8e0f0a1adb1cec7d42957b5e92514483c557ee2f73692fac6e557d903fe
+  metadata.gz: f3e549ad3b7b20a45ba37dc90c25660af7f1a455cf358aced90991570b76070da5688872141a32e54590a6cd0e65622fe2010b9b27b34466886b15f5a6b7856e
+  data.tar.gz: 81e3dba3f91e3f4acc6838efe5e197da2712f070a4962e3d29bd0df81a0834eb513542ecfcbaca62802cd32fdaa90e883c356d1a008abde9715e5183e52501ee

data/.gitignore

@@ -4,7 +4,6 @@
 .bundle
 .config
 .yardoc
-Gemfile.lock
 InstalledFiles
 _yardoc
 coverage
@@ -15,4 +14,4 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
-tmp
+tmp

data/Gemfile

@@ -3,6 +3,7 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in bioinform.gemspec
 gemspec
 
+gem 'rake', '~>10.4'
 
 group :development do
 #  gem 'win32console'

data/Gemfile.lock

@@ -0,0 +1,84 @@
+PATH
+  remote: .
+  specs:
+    bioinform (0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    fakefs (0.4.3)
+    ffi (1.9.10)
+    formatador (0.2.5)
+    given_core (3.7.1)
+      sorcerer (>= 0.3.7)
+    guard (2.13.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, <= 4.0)
+      lumberjack (~> 1.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.6.4)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    listen (3.0.5)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    lumberjack (1.0.9)
+    method_source (0.8.2)
+    nenv (0.2.0)
+    notiffany (0.0.8)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.4.2)
+    rb-fsevent (0.9.6)
+    rb-inotify (0.9.5)
+      ffi (>= 0.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.1)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-given (3.7.1)
+      given_core (= 3.7.1)
+      rspec (>= 2.14.0)
+    rspec-mocks (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    shellany (0.0.1)
+    slop (3.6.0)
+    sorcerer (1.0.2)
+    spork (0.9.2)
+    thor (0.19.1)
+    wdm (0.1.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bioinform!
+  fakefs (~> 0.4.2)
+  guard-rspec (>= 2.1.0)
+  rake (~> 10.4)
+  rspec (~> 3.0)
+  rspec-given (>= 2.0.0)
+  spork (>= 0.9.2)
+  wdm
+
+BUNDLED WITH
+   1.11.2

data/TODO.txt

@@ -32,4 +32,8 @@ Decide:
 Specs
 -- PWM#probabilities, #score_variance, #gauss_estimation
 
-background#to_s and WordwiseBackground#to_s
+background#to_s and WordwiseBackground#to_s
+
+SNP should be indexed both by sequence start and relative to snp position
+
+Интеграция PCM/PWM с iRuby: вывод лого в форме svg/png, печать матриц в tex-формате

data/lib/bioinform/background.rb

@@ -50,6 +50,8 @@ module Bioinform
     include Bioinform::Background
     def initialize(frequencies)
       @frequencies = frequencies
+      raise Error, 'Frequencies should have 4 components' unless frequencies.length == 4
+      raise Error, 'Frequencies should be in [0;1]' unless frequencies.all?{|el| (0..1).include?(el) }
       raise Error, 'Sum of Background frequencies should be equal to 1' unless (frequencies.inject(0.0, &:+) - 1.0).abs < 1e-4
     end
 

data/lib/bioinform/cli/convert_motif.rb

@@ -27,14 +27,13 @@ module Bioinform
         output_motifs = []
         motifs = motif_files.map do |filename|
           input = File.read(filename)
-          motif_info = MotifParser.new.parse(input)
           case options[:model_from]
           when 'pwm'
-            MotifModel::PWM.new(motif_info[:matrix]).named(motif_info[:name])
+            MotifModel::PWM.from_string(input)
           when 'pcm'
-            MotifModel::PCM.new(motif_info[:matrix]).named(motif_info[:name])
+            MotifModel::PCM.from_string(input)
           when 'ppm'
-            MotifModel::PPM.new(motif_info[:matrix]).named(motif_info[:name])
+            MotifModel::PPM.from_string(input)
           else
             raise "Unknown value of model-from parameter: `#{options[:model_from]}`"
           end

data/lib/bioinform/conversion_algorithms/pcm2pwm_converter.rb

@@ -12,16 +12,17 @@ module Bioinform
         @pseudocount = options.fetch(:pseudocount, :log)
       end
 
-      def calculate_pseudocount(pcm)
+      def calculate_pseudocount(pos)
         case @pseudocount
         when Numeric
           @pseudocount
         when :log
-          Math.log(pcm.count)
+          count = pos.inject(0.0, &:+)
+          Math.log([count, 2].max)
         when :sqrt
-          Math.sqrt(pcm.count)
+          Math.sqrt(pcm.inject(0.0, &:+))
         when Proc
-          @pseudocount.call(pcm)
+          @pseudocount.call(pos)
         else
           raise Error, 'Unknown pseudocount type use numeric or :log or :sqrt or Proc with taking pcm parameter'
         end
@@ -29,8 +30,8 @@ module Bioinform
 
       def convert(pcm)
         raise Error, "#{self.class}#convert accepts only models acting as PCM"  unless MotifModel.acts_as_pcm?(pcm)
-        actual_pseudocount = calculate_pseudocount(pcm)
         matrix = pcm.each_position.map do |pos|
+          actual_pseudocount = calculate_pseudocount(pos)
           count = pos.inject(0.0, &:+)
           pos.each_index.map do |index|
             Math.log((pos[index] + @background.frequencies[index] * actual_pseudocount).to_f / (@background.frequencies[index]*(count + actual_pseudocount)) )

data/lib/bioinform/data_models/pcm.rb

@@ -7,20 +7,34 @@ module Bioinform
     end
 
     class PCM < PM
-      def validation_errors
-        errors = super
-        errors << "elements of PCM should be non-negative"  unless matrix.all?{|pos| pos.all?{|el| el >= 0 } }
-        errors
+      def self.count_validator(eps: 1.0e-4)
+        Validator.new{|matrix, alphabet|
+          errors = []
+          unless matrix.all?{|pos| pos.all?{|el| el >= 0 } }
+            errors << "Elements of PCM should be non-negative."
+          end
+
+          warnings = []
+          if eps
+            counts = matrix.map{|pos| pos.inject(0.0, &:+) }
+            unless (counts.max - counts.min) <= eps * counts.min
+              warnings << "PCM counts are different (discrepancy is greater than eps * MinCount; eps=#{eps}; MinCountn=#{counts.min})."
+            end
+          end
+
+          ValidationResult.new(errors: errors, warnings: warnings)
+        }
       end
 
-      def count
-        counts = each_position.map{|pos| pos.inject(0.0, &:+)}
-        count = counts.first
-        diffs = counts.map{|pos_count| (pos_count - count).abs }
-        counts_are_same = (diffs.max < count * 1e-3)
-        raise Error, 'Different columns have different count'  unless counts_are_same
-        count
+      VALIDATOR = PM::VALIDATOR * PCM.count_validator(eps: 1.0e-4).make_strict
+      DIFFERENT_COUNTS_VALIDATOR = PM::VALIDATOR * PCM.count_validator(eps: nil).make_strict
+
+      def initialize(matrix, alphabet: NucleotideAlphabet, validator: PCM::VALIDATOR)
+        super
+        # validator already checked count discrepancy. We store median count.
+        @count = matrix.map{|pos| pos.inject(0.0, &:+) }.sort[matrix.length / 2]
       end
+      attr_reader :count
     end
   end
 end

data/lib/bioinform/data_models/pm.rb

@@ -1,4 +1,5 @@
 require_relative '../formatters/motif_formatter'
+require_relative '../validator'
 require_relative '../errors'
 require_relative '../alphabet'
 require_relative 'named_model'
@@ -6,47 +7,39 @@ require_relative 'named_model'
 module Bioinform
   module MotifModel
     class PM
+      DEFAULT_PARSER = MatrixParser.new
+      TRIVIAL_VALIDATOR = Validator.new{|matrix, alphabet| ValidationResult.all_ok }
+      VALIDATOR = Validator.new{|matrix, alphabet|
+        errors = []
+        errors << "Matrix should be an Array."  unless matrix.is_a? Array
+        errors << "Matrix shouldn't be empty."  unless matrix.size > 0
+        errors << "Each matrix position should be an Array."  unless matrix.all?{|pos| pos.is_a?(Array) }
+        errors << "Each matrix position should be of size compatible with alphabet (=#{alphabet.size})."  unless matrix.all?{|pos| pos.size == alphabet.size }
+        errors << "Each matrix element should be Numeric."  unless matrix.all?{|pos| pos.all?{|el| el.is_a?(Numeric) } }
+        ValidationResult.new(errors: errors)
+      }
+
       attr_reader :matrix, :alphabet
-      def initialize(matrix, options = {})
+      def initialize(matrix, alphabet: NucleotideAlphabet, validator: PM::VALIDATOR)
+        validation_results = validator.validate_params(matrix, alphabet)
+        unless validation_results.valid?
+          raise ValidationError.new('Invalid matrix.', validation_errors: validation_results)
+        end
         @matrix = matrix
-        @alphabet = options.fetch(:alphabet, NucleotideAlphabet)
-        raise ValidationError.new('invalid matrix', validation_errors: validation_errors)  unless valid?
+        @alphabet = alphabet
       end
 
-      def self.from_string(input, options = {})
-        parser = options.fetch(:parser, MatrixParser.new)
-        alphabet = options.fetch(:alphabet, NucleotideAlphabet)
+      def self.from_string(input, alphabet: NucleotideAlphabet, parser: DEFAULT_PARSER)
         info = parser.parse!(input)
         self.new(info[:matrix], alphabet: alphabet).named( info[:name] )
       end
 
-      def self.from_file(filename, options = {})
-        parser = options.fetch(:parser, MatrixParser.new)
-        alphabet = options.fetch(:alphabet, NucleotideAlphabet)
+      def self.from_file(filename, alphabet: NucleotideAlphabet, parser: DEFAULT_PARSER)
         info = parser.parse!(File.read(filename))
         name = (info[:name] && !info[:name].strip.empty?) ? info[:name] : File.basename(filename, File.extname(filename))
         self.new(info[:matrix], alphabet: alphabet).named( name )
       end
 
-      def validation_errors
-        errors = []
-        errors << "matrix should be an Array"  unless matrix.is_a? Array
-        errors << "matrix shouldn't be empty"  unless matrix.size > 0
-        errors << "each matrix position should be an Array"  unless matrix.all?{|pos| pos.is_a?(Array) }
-        errors << "each matrix position should be of size compatible with alphabet (=#{alphabet.size})"  unless matrix.all?{|pos| pos.size == alphabet.size }
-        errors << "each matrix element should be Numeric"  unless matrix.all?{|pos| pos.all?{|el| el.is_a?(Numeric) } }
-        errors
-      end
-      private :validation_errors
-
-      def valid?
-       validation_errors.empty?
-      rescue
-        false
-      end
-
-      private :valid?
-
       def length
         matrix.size
       end
@@ -68,15 +61,15 @@ module Bioinform
       end
 
       def reversed
-        self.class.new(matrix.reverse, alphabet: alphabet)
+        self.class.new(matrix.reverse, alphabet: alphabet, validator: TRIVIAL_VALIDATOR)
       end
 
       def complemented
-        self.class.new(complement_matrix, alphabet: alphabet)
+        self.class.new(complement_matrix, alphabet: alphabet, validator: TRIVIAL_VALIDATOR)
       end
 
       def reverse_complemented
-        self.class.new(complement_matrix.reverse, alphabet: alphabet)
+        self.class.new(complement_matrix.reverse, alphabet: alphabet, validator: TRIVIAL_VALIDATOR)
       end
 
       alias_method :revcomp, :reverse_complemented
@@ -88,6 +81,16 @@ module Bioinform
       end
       private :complement_matrix
 
+      def rounded(precision: 0)
+        return self  if !precision
+        rounded_matrix = matrix.map{|pos|
+          pos.map{|el|
+            el.round(precision)
+          }
+        }
+        self.class.new(rounded_matrix, alphabet: alphabet, validator: TRIVIAL_VALIDATOR)
+      end
+
       # def consensus
       #   ConsensusFormatter.by_maximal_elements.format_string(self)
       # end

data/lib/bioinform/data_models/ppm.rb

@@ -7,11 +7,28 @@ module Bioinform
     end
 
     class PPM < PM
-      def validation_errors
-        errors = super
-        errors << "elements of PPM should be non-negative"  unless matrix.all?{|pos| pos.all?{|el| el >= 0 } }
-        errors << "each PPM position should be equal to 1.0 being summed"  unless matrix.all?{|pos| (pos.inject(0.0, &:+) - 1.0).abs < 1e-3 }
-        errors
+      def self.probability_validator(eps: 1.0e-4)
+        Validator.new{|matrix, alphabet|
+          errors = []
+          unless matrix.all?{|pos| pos.all?{|el| el >= 0 } }
+            errors << "Elements of PPM should be non-negative."
+          end
+
+          warnings = []
+          probability_sums = matrix.map{|pos| pos.inject(0.0, &:+) }
+          max_discrepancy = probability_sums.map{|sum| (sum - 1.0).abs }.max
+          unless max_discrepancy <= eps
+            warnings << "PPM should sum up to 1, with discrepancy not greater than #{eps}."
+          end
+
+          ValidationResult.new(errors: errors, warnings: warnings)
+        }
+      end
+
+      VALIDATOR = PM::VALIDATOR * PPM.probability_validator(eps: 1.0e-4).make_strict
+
+      def initialize(matrix, alphabet: NucleotideAlphabet, validator: PPM::VALIDATOR)
+        super  # default validator redefined
       end
     end
   end

data/lib/bioinform/data_models/pwm.rb

@@ -7,6 +7,11 @@ module Bioinform
     end
 
     class PWM < PM
+      VALIDATOR = PM::VALIDATOR
+      def initialize(matrix, alphabet: NucleotideAlphabet, validator: PWM::VALIDATOR)
+        super  # default validator redefined
+      end
+
       def score(word)
         raise Error, 'Word length should be the same as PWM length'  unless word.length == length
         length.times.map do |pos|
@@ -14,10 +19,13 @@ module Bioinform
         end.inject(0.0, &:+)
       end
 
-      def discreted(rate, options = {})
-        rounding_method = options.fetch(:rounding_method, :ceil)
-        discreted_matrix = matrix.map{|position| position.map{|element| (element * rate).send(rounding_method) } }
-        self.class.new(discreted_matrix, alphabet: alphabet)
+      def discreted(rate, rounding_method: :ceil)
+        discreted_matrix = matrix.map{|position|
+          position.map{|element|
+            (element * rate).send(rounding_method)
+          }
+        }
+        self.class.new(discreted_matrix, alphabet: alphabet, validator: TRIVIAL_VALIDATOR)
       end
 
       def zero_column

data/lib/bioinform/errors.rb

@@ -11,7 +11,14 @@ module Bioinform
     end
 
     def to_s
-      "#{super} (#{@validation_errors.join('; ')})"
+      case @validation_errors
+      when Array
+        "#{super} (#{@validation_errors.join('; ')})"
+      when ValidationResult
+        "#{super}\n#{@validation_errors}"
+      else
+        "#{super} (#{@validation_errors})"
+      end
     end
   end
 end

data/lib/bioinform/validator.rb

@@ -0,0 +1,86 @@
+module Bioinform
+  class ValidationResult
+    attr_reader :errors, :warnings
+    def initialize(errors: [], warnings: [])
+      @errors = errors.freeze
+      @warnings = warnings.freeze
+    end
+
+    def self.all_ok
+      self.new(errors: [], warnings: [])
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def to_s
+      msg = ""
+
+      if errors && !errors.empty?
+        msg += "Errors:\n" + errors.join("\n") + "\n"
+      end
+
+      if warnings && !warnings.empty?
+        msg += "Warnings:\n" + warnings.join("\n")
+      end
+
+      msg.empty? ? "{No errors, no warnings}" : "{#{msg}}"
+    end
+
+    def with_errors(additional_errors)
+      ValidationResult.new(errors: errors + additional_errors, warnings: warnings)
+    end
+
+    def with_warnings(additional_warnings)
+      ValidationResult.new(errors: errors, warnings: warnings + additional_warnings)
+    end
+
+    # errors from both operands
+    def +(other)
+      ValidationResult.new(errors: errors + other.errors, warnings: warnings + other.warnings)
+    end
+
+    def hash
+      [@errors, @warnings].hash
+    end
+    def eql?(other)
+      (other.class == self.class) && (errors == other.errors) && (warnings == other.warnings)
+    end
+    def ==(other)
+      other.is_a?(ValidationResult) && (errors == other.errors) && (warnings == other.warnings)
+    end
+  end
+
+  class Validator
+    def initialize(&block)
+      if block_given?
+        @validation_block = block
+      else
+        @validation_block = ->(*args, &b){ ValidationResult.new }
+      end
+    end
+
+    def validate_params(*args, &block)
+      @validation_block.call(*args, &block)
+    rescue => e
+      msg = "Unexpected error occured during validation: #{e.message}. Backtrace:\n" + e.backtrace.join("\n")
+      ValidationResult.new(errors: [msg])
+    end
+
+    # Validate both
+    def *(other)
+      Validator.new{|*args, &b|
+        validate_params(*args, &b) + other.validate_params(*args, &b)
+      }
+    end
+
+    # treat warnings as errors
+    def make_strict
+      Validator.new{|*args, &block|
+        result = self.validate_params(*args, &block)
+        ValidationResult.new(errors: result.errors + result.warnings)
+      }
+    end
+  end
+end

data/lib/bioinform/version.rb

@@ -1,3 +1,3 @@
 module Bioinform
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/spec/alphabet_spec.rb

@@ -2,9 +2,9 @@ require 'bioinform/alphabet'
 
 describe Bioinform::ComplementableAlphabet do
   specify "should raise if complement's complement is not original letter" do
-    expect{ Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:X,:Y,:B,:A]) }.to raise_error Bioinform::Error
-    expect{ Bioinform::ComplementableAlphabet.new([:A,:B,:B,:C], [:C,:B,:B,:A]) }.to raise_error Bioinform::Error
-    expect{ Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:X,:Y,:B,:A,:C]) }.to raise_error Bioinform::Error
+    expect{ Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:X,:Y,:B,:A]) }.to raise_error(Bioinform::Error)
+    expect{ Bioinform::ComplementableAlphabet.new([:A,:B,:B,:C], [:C,:B,:B,:A]) }.to raise_error(Bioinform::Error)
+    expect{ Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:X,:Y,:B,:A,:C]) }.to raise_error(Bioinform::Error)
   end
 
   context 'usage with alphabet non-symbolized, non-upcased' do
@@ -48,10 +48,10 @@ describe Bioinform::NucleotideAlphabet do
   specify { expect( Bioinform::NucleotideAlphabet.size ).to eq 4 }
   specify { expect( Bioinform::NucleotideAlphabet.complement_letter(:A) ).to eq :T }
   specify { expect( Bioinform::NucleotideAlphabet.complement_letter(:C) ).to eq :G }
-  specify { expect{ Bioinform::NucleotideAlphabet.complement_letter(:N) }.to raise_error Bioinform::Error }
+  specify { expect{ Bioinform::NucleotideAlphabet.complement_letter(:N) }.to raise_error(Bioinform::Error) }
 
   specify { expect(Bioinform::NucleotideAlphabet.complement_index(0)).to eq 3 }
-  specify { expect{Bioinform::NucleotideAlphabet.complement_index(4)}.to raise_error Bioinform::Error}
+  specify { expect{Bioinform::NucleotideAlphabet.complement_index(4)}.to raise_error(Bioinform::Error)}
 end
 
 describe Bioinform::NucleotideAlphabetWithN do

data/spec/background_spec.rb

@@ -1,8 +1,8 @@
 require 'bioinform/background'
 
 describe Bioinform::Frequencies do
-  specify { expect{Bioinform::Frequencies.new([1,1,1,1]) }.to raise_error Bioinform::Error }
-  specify { expect{Bioinform::Frequencies.new([0.3,0.3,0.3,0.3]) }.to raise_error Bioinform::Error }
+  specify { expect{Bioinform::Frequencies.new([1,1,1,1]) }.to raise_error(Bioinform::Error) }
+  specify { expect{Bioinform::Frequencies.new([0.3,0.3,0.3,0.3]) }.to raise_error(Bioinform::Error) }
   specify { expect{Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }.not_to raise_error }
   specify { expect{Bioinform::Frequencies.new([0.2,0.3,0.3,0.2]) }.not_to raise_error }
 
@@ -52,6 +52,6 @@ describe Bioinform::Background do
   specify { expect(Bioinform::Background.from_string('uniform')).to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
   specify { expect(Bioinform::Background.from_string('UNIFORM')).to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
   specify { expect(Bioinform::Background.from_string('wordwise')).to eq Bioinform::WordwiseBackground.new }
-  specify { expect{Bioinform::Background.from_string('0.25,0.25,0.25')}.to raise_error Bioinform::Error }
-  specify { expect{Bioinform::Background.from_string('unifromm')}.to raise_error Bioinform::Error }
+  specify { expect{Bioinform::Background.from_string('0.25,0.25,0.25')}.to raise_error(Bioinform::Error) }
+  specify { expect{Bioinform::Background.from_string('unifromm')}.to raise_error(Bioinform::Error) }
 end

data/spec/cli/cli_spec.rb

@@ -1,6 +1,25 @@
 require_relative '../spec_helper'
 require 'bioinform/cli'
 
+def compare_positions(pos_1, pos_2, eps: 1e-6)
+  pos_1.zip(pos_2).all?{|el_1, el_2|
+    (el_1 - el_2).abs <= eps
+  }
+end
+
+def compare_matrices(matrix_1, matrix_2, eps: 1e-6)
+  matrix_1.length == matrix_2.length && \
+  matrix_1.zip(matrix_2).all?{|pos_1, pos_2|
+    compare_positions(pos_1, pos_2, eps: eps)
+  }
+end
+
+def compare_models_in_files(file_1, file_2, klass: Bioinform::MotifModel::PM, eps: 1e-6)
+  pm_1 = klass.from_file(file_1)
+  pm_2 = klass.from_file(file_2)
+  pm_1.name == pm_2.name && compare_matrices(pm_1.matrix, pm_2.matrix)
+end
+
 describe Bioinform::CLI do
   describe '.change_folder_and_extension' do
     it 'should change extension and folder' do

data/spec/cli/pcm2pwm_spec.rb

@@ -24,56 +24,56 @@ describe Bioinform::CLI::PCM2PWM do
   it 'should transform single PCM to PWM' do
     run_pcm2pwm('KLF4_f2.pcm')
     expect(File.exist?('KLF4_f2.pwm')).to be_truthy
-    expect(File.read('KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('KLF4_f2.pwm', 'KLF4_f2.pwm.result')).to be_truthy
   end
 
   it 'should transform multiple PCMs to PWMs' do
     run_pcm2pwm('KLF4_f2.pcm SP1_f1.pcm')
 
     expect(File.exist?('KLF4_f2.pwm')).to be_truthy
-    expect(File.read('KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('KLF4_f2.pwm', 'KLF4_f2.pwm.result')).to be_truthy
 
     expect(File.exist?('SP1_f1.pwm')).to be_truthy
-    expect(File.read('SP1_f1.pwm')).to eq File.read('SP1_f1.pwm.result')
+    expect(compare_models_in_files('SP1_f1.pwm', 'SP1_f1.pwm.result')).to be_truthy
   end
 
   it 'should transform extension to specified with --extension option' do
     run_pcm2pwm('KLF4_f2.pcm --extension=pat')
     expect(File.exist?('KLF4_f2.pat')).to be_truthy
-    expect(File.read('KLF4_f2.pat')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('KLF4_f2.pat', 'KLF4_f2.pwm.result')).to be_truthy
   end
 
   it 'should save PWMs into folder specified with --folder option when folder exists' do
     Dir.mkdir('pwm_folder')  unless Dir.exist?('pwm_folder')
     run_pcm2pwm('KLF4_f2.pcm --folder=pwm_folder')
     expect(File.exist?('pwm_folder/KLF4_f2.pwm')).to be_truthy
-    expect(File.read('pwm_folder/KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('pwm_folder/KLF4_f2.pwm', 'KLF4_f2.pwm.result')).to be_truthy
   end
   it 'should save PWMs into folder specified with --folder option' do
     FileUtils.rm_rf('pwm_folder')  if Dir.exist?('pwm_folder')
     run_pcm2pwm('KLF4_f2.pcm --folder=pwm_folder')
     expect(File.exist?('pwm_folder/KLF4_f2.pwm')).to be_truthy
-    expect(File.read('pwm_folder/KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('pwm_folder/KLF4_f2.pwm', 'KLF4_f2.pwm.result')).to be_truthy
   end
 
   it 'should process PCMs with names obtained from STDIN' do
     provide_stdin('KLF4_f2.pcm SP1_f1.pcm') { run_pcm2pwm('') }
     expect(File.exist?('KLF4_f2.pwm')).to be_truthy
-    expect(File.read('KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('KLF4_f2.pwm', 'KLF4_f2.pwm.result')).to be_truthy
 
     expect(File.exist?('SP1_f1.pwm')).to be_truthy
-    expect(File.read('SP1_f1.pwm')).to eq File.read('SP1_f1.pwm.result')
+    expect(compare_models_in_files('SP1_f1.pwm', 'SP1_f1.pwm.result')).to be_truthy
   end
 
   it 'should process PCMs with names obtained from STDIN when there are some options' do
     provide_stdin('KLF4_f2.pcm') { run_pcm2pwm('-e pat') }
     expect(File.exist?('KLF4_f2.pat')).to be_truthy
-    expect(File.read('KLF4_f2.pat')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('KLF4_f2.pat', 'KLF4_f2.pwm.result')).to be_truthy
   end
 
   it 'should process PCMs having filename with spaces' do
     run_pcm2pwm('"KLF4 f2 spaced name.pcm"')
     expect(File.exist?('KLF4 f2 spaced name.pwm')).to be_truthy
-    expect(File.read('KLF4 f2 spaced name.pwm')).to eq File.read('KLF4_f2.pwm.result')
+    expect(compare_models_in_files('KLF4 f2 spaced name.pwm', 'KLF4_f2.pwm.result')).to be_truthy
   end
 end

data/spec/converters/pcm2ppm_converter_spec.rb

@@ -4,7 +4,7 @@ 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(:pcm_different_counts) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4],[3,3,3,4]], validator: Bioinform::MotifModel::PCM::DIFFERENT_COUNTS_VALIDATOR) }
 
   let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
   let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
@@ -26,7 +26,7 @@ describe Bioinform::ConversionAlgorithms::PCM2PPMConverter do
   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 }
+  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

@@ -4,7 +4,7 @@ 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(:pcm_different_counts) { Bioinform::MotifModel::PCM.new([[1,2,3,4],[2,2,2,4],[3,3,3,4]], validator: Bioinform::MotifModel::PCM::DIFFERENT_COUNTS_VALIDATOR) }
 
   let(:named_pcm) { Bioinform::MotifModel::NamedModel.new(pcm, 'motif name') }
   let(:named_pwm) { Bioinform::MotifModel::NamedModel.new(pwm, 'motif name') }
@@ -16,7 +16,7 @@ describe Bioinform::ConversionAlgorithms::PCM2PWMConverter do
     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 { expect(converter.calculate_pseudocount(pcm.matrix[0])).to eq Math.log(10) }
 
     specify do
       cnt = 10
@@ -27,14 +27,24 @@ describe Bioinform::ConversionAlgorithms::PCM2PWMConverter do
             [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(pcm_different_counts) }.not_to raise_error }
+    specify {
+      counts = [10, 10, 13]
+      pseudocounts = counts.map{|el| Math.log(el) }
+      denominators = counts.zip(pseudocounts).map{|count, pseudocount|  0.25 * (count + pseudocount)  }
+      expect(converter.convert(pcm_different_counts).matrix).to eq [
+        [1,2,3,4].map{|el| Math.log((el + pseudocounts[0]*0.25) / denominators[0]) },
+        [2,2,2,4].map{|el| Math.log((el + pseudocounts[1]*0.25) / denominators[1]) },
+        [3,3,3,4].map{|el| Math.log((el + pseudocounts[2]*0.25) / denominators[2]) },
+      ]
+    }
 
     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 }
+    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

data/spec/converters/pwm2iupac_pwm_converter_spec.rb

@@ -8,7 +8,7 @@ describe Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter do
     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
+      expect { converter.convert(pcm) }.to raise_error(Bioinform::Error)
     end
   end
 
@@ -28,12 +28,12 @@ describe Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter 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
+      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
+      expect { converter.convert(pwm_w_custom_alphabet) }.to raise_error(Bioinform::Error)
     end
 
   end
@@ -54,12 +54,12 @@ describe Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter 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
+      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
+      expect { converter.convert(pwm_w_custom_alphabet) }.to raise_error(Bioinform::Error)
     end
   end
 end

data/spec/converters/pwm2pcm_converter_spec.rb

@@ -50,8 +50,8 @@ describe Bioinform::ConversionAlgorithms::PWM2PCMConverter do
     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 }
+    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/pcm_spec.rb

@@ -4,7 +4,7 @@ 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)
+      expect { Bioinform::MotifModel::PCM.new([[1,2,1,3],[3,3,0,1], [-2, 3, 3, 3]]) }.to raise_error(Bioinform::Error)
     end
 
     context 'with valid matrix' do
@@ -21,10 +21,13 @@ describe Bioinform::MotifModel::PCM do
       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
+          expect { Bioinform::MotifModel::PCM.new(matrix) }.to raise_error(Bioinform::Error)
         end
         specify do
-          expect( Bioinform::MotifModel::PCM.new(matrix).matrix ).to eq matrix
+          expect { Bioinform::MotifModel::PCM.new(matrix, validator: Bioinform::MotifModel::PCM::DIFFERENT_COUNTS_VALIDATOR) }.not_to raise_error
+        end
+        specify do
+          expect( Bioinform::MotifModel::PCM.new(matrix, validator: Bioinform::MotifModel::PCM::DIFFERENT_COUNTS_VALIDATOR).matrix ).to eq matrix
         end
       end
     end
@@ -45,7 +48,7 @@ describe Bioinform::MotifModel::PCM do
 
     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 }
+        specify{ expect{ pcm.count }.to raise_error(Bioinform::Error) }
     end
   end
 

data/spec/data_models/pm_spec.rb

@@ -4,19 +4,19 @@ describe Bioinform::MotifModel::PM do
 
   describe '.new' do
     specify 'with matrix having more than 4 elements in a position' do
-      expect { Bioinform::MotifModel::PM.new([[1,2,3,1.567],[10,11,12,15,10],[-1.1, 0.6, 0.4, 0.321]]) }.to raise_error (Bioinform::Error)
+      expect { Bioinform::MotifModel::PM.new([[1,2,3,1.567],[10,11,12,15,10],[-1.1, 0.6, 0.4, 0.321]]) }.to raise_error(Bioinform::Error)
     end
 
     specify 'with matrix having less than 4 elements in a position' do
-      expect { Bioinform::MotifModel::PM.new([[1,2,3,1.567],[10,11,12,15],[-1.1, 0.6]]) }.to raise_error (Bioinform::Error)
+      expect { Bioinform::MotifModel::PM.new([[1,2,3,1.567],[10,11,12,15],[-1.1, 0.6]]) }.to raise_error(Bioinform::Error)
     end
 
     specify 'with matrix having positions in rows, nucleotides in columns' do
-      expect { Bioinform::MotifModel::PM.new([[1,2,3],[10,-11,12],[-1.1, 0.6, 0.4],[5,6,7]]) }.to raise_error (Bioinform::Error)
+      expect { Bioinform::MotifModel::PM.new([[1,2,3],[10,-11,12],[-1.1, 0.6, 0.4],[5,6,7]]) }.to raise_error(Bioinform::Error)
     end
 
     specify 'with empty matrix' do
-      expect { Bioinform::MotifModel::PM.new([]) }.to raise_error (Bioinform::Error)
+      expect { Bioinform::MotifModel::PM.new([]) }.to raise_error(Bioinform::Error)
     end
 
     context 'with valid matrix' do
@@ -105,7 +105,7 @@ describe Bioinform::MotifModel::PM do
     let(:matrix_15) { [[1,2,3,1.567,  12,-11,12,0,-1.1,0.6,  0.4,0.321,0.11,-1.23, 2.0],
                        [0,0,0,0,       0,0,0,0,0,0, 0,0,0,0, 0]] }
     specify do
-      expect{ Bioinform::MotifModel::PM.new(matrix_4, alphabet: Bioinform::IUPACAlphabet) }.to raise_error Bioinform::Error
+      expect{ Bioinform::MotifModel::PM.new(matrix_4, alphabet: Bioinform::IUPACAlphabet) }.to raise_error(Bioinform::Error)
     end
     specify do
       expect{ Bioinform::MotifModel::PM.new(matrix_15, alphabet: Bioinform::IUPACAlphabet) }.not_to raise_error

data/spec/data_models/ppm_spec.rb

@@ -4,12 +4,12 @@ describe Bioinform::MotifModel::PPM do
 
   describe '.new' do
     specify 'fails on matrix having negative elements' do
-      expect { Bioinform::MotifModel::PPM.new([[0.4, 0.1, 0.1, 0.4],[0.6, -0.1, -0.1, 0.6],[0.25, 0.25, 0.25, 0.25]]) }.to raise_error (Bioinform::Error)
+      expect { Bioinform::MotifModel::PPM.new([[0.4, 0.1, 0.1, 0.4],[0.6, -0.1, -0.1, 0.6],[0.25, 0.25, 0.25, 0.25]]) }.to raise_error(Bioinform::Error)
     end
     specify 'fails on matrix having sum of position elements different from 1' do
-      expect { Bioinform::MotifModel::PPM.new([[0.4, 0.1, 0.1, 0.4],[0.6, 0.1, 0.1, 0.6],[0.25, 0.25, 0.25, 0.25]]) }.to raise_error (Bioinform::Error)
-      expect { Bioinform::MotifModel::PPM.new([[0.4, 0.1, 0.1, 0.4],[0.3, 0.1, 0.1, 0.3],[0.25, 0.25, 0.25, 0.25]]) }.to raise_error (Bioinform::Error)
-      expect { Bioinform::MotifModel::PPM.new([[0.3, 0.1, 0.1, 0.3],[0.3, 0.1, 0.1, 0.3],[0.2, 0.2, 0.2, 0.2]]) }.to raise_error (Bioinform::Error)
+      expect { Bioinform::MotifModel::PPM.new([[0.4, 0.1, 0.1, 0.4],[0.6, 0.1, 0.1, 0.6],[0.25, 0.25, 0.25, 0.25]]) }.to raise_error(Bioinform::Error)
+      expect { Bioinform::MotifModel::PPM.new([[0.4, 0.1, 0.1, 0.4],[0.3, 0.1, 0.1, 0.3],[0.25, 0.25, 0.25, 0.25]]) }.to raise_error(Bioinform::Error)
+      expect { Bioinform::MotifModel::PPM.new([[0.3, 0.1, 0.1, 0.3],[0.3, 0.1, 0.1, 0.3],[0.2, 0.2, 0.2, 0.2]]) }.to raise_error(Bioinform::Error)
     end
 
     context 'with valid matrix' do

data/spec/data_models/pwm_spec.rb

@@ -57,12 +57,12 @@ describe Bioinform::MotifModel::PWM do
     end
 
     describe '#left_augmented' do
-      specify { expect{pwm.left_augmented(-1)}.to raise_error Bioinform::Error }
+      specify { expect{pwm.left_augmented(-1)}.to raise_error(Bioinform::Error) }
       specify { expect(pwm.left_augmented(0)).to eq pwm }
       specify { expect(pwm.left_augmented(2)).to eq Bioinform::MotifModel::PWM.new( [[0,0,0,0],[0,0,0,0],[1,2,3,1.567],[12,-11,12,0],[-1.1, 0.6, 0.4, 0.321]]) }
     end
     describe '#right_augmented' do
-      specify { expect{pwm.right_augmented(-1)}.to raise_error Bioinform::Error }
+      specify { expect{pwm.right_augmented(-1)}.to raise_error(Bioinform::Error) }
       specify { expect(pwm.right_augmented(0)).to eq pwm }
       specify { expect(pwm.right_augmented(2)).to eq Bioinform::MotifModel::PWM.new( [[1,2,3,1.567],[12,-11,12,0],[-1.1, 0.6, 0.4, 0.321],[0,0,0,0],[0,0,0,0]]) }
     end
@@ -93,7 +93,8 @@ describe Bioinform::MotifModel::PWM do
                                                     [-1, 1, 1, 1,  12,22,32,42,52,62, 702,802,902,1002, 10002 ]] }
     specify { expect(pwm.discreted(1).alphabet).to eq Bioinform::IUPACAlphabet}
 
-    specify { expect{ pwm.to_IUPAC_PWM }.to raise_error }
+    let(:iupac_converter) { Bioinform::ConversionAlgorithms::PWM2IupacPWMConverter.new }
+    specify { expect{ iupac_converter.convert(pwm) }.to raise_error(Bioinform::Error) }
   end
 
   describe '.from_string' do

data/spec/formatters/consensus_formatter_spec.rb

@@ -4,7 +4,7 @@ require 'bioinform/formatters/consensus_formatter'
 describe Bioinform::ConsensusFormatter do
   let(:pm) { Bioinform::MotifModel::PM.new([[10,30,10,28], [30,16,16,16], [12,30,10,26], [26,27,27,1]]) }
 
-  specify('.new without a block raises error') { expect{ Bioinform::ConsensusFormatter.new }.to raise_error Bioinform::Error }
+  specify('.new without a block raises error') { expect{ Bioinform::ConsensusFormatter.new }.to raise_error(Bioinform::Error) }
 
   context 'custom formatter' do
     let(:formatter){ Bioinform::ConsensusFormatter.new{|pos, el, ind| (pos.max - el) < pos.max * 0.1 } }

data/spec/formatters/raw_formatter_spec.rb

@@ -24,7 +24,7 @@ describe Bioinform::MotifFormatter do
   end
   context 'with with_name equal to true' do
     let(:formatter) { Bioinform::MotifFormatter.new(with_name: true) }
-    specify { expect{ formatter.format(motif) }.to raise_error Bioinform::Error }
+    specify { expect{ formatter.format(motif) }.to raise_error(Bioinform::Error) }
     specify { expect( formatter.format(motif.named('')) ).to eq ">\n" +
                                                               default_matrix_string }
     specify { expect( formatter.format(motif.named('Stub name')) ).to eq ">Stub name\n" +
@@ -38,7 +38,7 @@ describe Bioinform::MotifFormatter do
                                                                       default_matrix_string }
   end
   context 'with with_name value different from true/false/:auto' do
-    specify{ expect { Bioinform::MotifFormatter.new(with_name: :somewhat) }.to raise_error Bioinform::Error }
+    specify{ expect { Bioinform::MotifFormatter.new(with_name: :somewhat) }.to raise_error(Bioinform::Error) }
   end
 
   context 'with nucleotides_in :columns' do

data/spec/parsers/matrix_parser_spec.rb

@@ -1,7 +1,7 @@
 require 'bioinform/parsers/matrix_parser'
 
 describe Bioinform::MatrixParser do
-  specify { expect{ Bioinform::MatrixParser.new(nucleotides_in: :somewhat) }.to raise_error Bioinform::Error }
+  specify { expect{ Bioinform::MatrixParser.new(nucleotides_in: :somewhat) }.to raise_error(Bioinform::Error) }
 
   context 'with default options' do
     subject(:parser) { Bioinform::MatrixParser.new }
@@ -40,9 +40,9 @@ describe Bioinform::MatrixParser do
     let(:input_not_allowed_2) {"A\tC\tG\tT\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
     let(:input_not_allowed_3) {"##01\t1\t2\t3\t4\n" + "##02\t11\t12\t13\t14" }
     specify { expect( parser.parse!(input_allowed) ).to eq( {name: nil, matrix: [[1,2,3,4],[11,12,13,14]]} ) }
-    specify { expect{ parser.parse!(input_not_allowed) }.to raise_error Bioinform::Error }
-    specify { expect{ parser.parse!(input_not_allowed_2) }.to raise_error Bioinform::Error }
-    specify { expect{ parser.parse!(input_not_allowed_3) }.to raise_error Bioinform::Error }
+    specify { expect{ parser.parse!(input_not_allowed) }.to raise_error(Bioinform::Error) }
+    specify { expect{ parser.parse!(input_not_allowed_2) }.to raise_error(Bioinform::Error) }
+    specify { expect{ parser.parse!(input_not_allowed_3) }.to raise_error(Bioinform::Error) }
   end
   context 'with has_name equal to :auto parser can either have name or not' do
     subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_name: :auto) }
@@ -51,7 +51,7 @@ describe Bioinform::MatrixParser do
     let(:input_with_bad_name) {"-Name\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
     specify { expect( parser.parse!(input_without_name) ).to eq( {name: nil, matrix: [[1,2,3,4],[11,12,13,14]]} ) }
     specify { expect( parser.parse!(input_with_name) ).to eq( {name: 'PM Name', matrix: [[1,2,3,4],[11,12,13,14]]} ) }
-    specify { expect{ parser.parse!(input_with_bad_name) }.to raise_error Bioinform::Error }
+    specify { expect{ parser.parse!(input_with_bad_name) }.to raise_error(Bioinform::Error) }
   end
   context 'parser having name and header row' do
     subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_name: true, has_header_row: true) }
@@ -62,7 +62,7 @@ describe Bioinform::MatrixParser do
     subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_name: false, has_header_row: true) }
     let(:input) {"A\tC\tG\tT\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
     specify { expect( parser.parse!(input) ).to eq( {name: nil, matrix: [[1,2,3,4],[11,12,13,14]]} ) }
-    specify { expect{ parser.parse!("Motif name\n" + input) }.to raise_error Bioinform::Error }
+    specify { expect{ parser.parse!("Motif name\n" + input) }.to raise_error(Bioinform::Error) }
   end
   context 'parser having header column' do
     subject(:parser) { Bioinform::MatrixParser.new(nucleotides_in: :columns, has_header_column: true) }
@@ -101,7 +101,7 @@ describe Bioinform::MatrixParser do
     let(:input_allowed) {"NA>Motif name\tother info\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
     let(:input_not_allowed) {"Motif name\tother info\n" + "1\t2\t3\t4\n" + "11\t12\t13\t14" }
     specify { expect( parser.parse!(input_allowed) ).to eq( {name: "Motif name\tother info", matrix: [[1,2,3,4],[11,12,13,14]]} ) }
-    specify { expect{ parser.parse!(input_not_allowed) }.to raise_error Bioinform::Error }
+    specify { expect{ parser.parse!(input_not_allowed) }.to raise_error(Bioinform::Error) }
   end
 
   context 'parser reducing number of nucleotides' do
@@ -127,7 +127,7 @@ describe Bioinform::MatrixParser do
   context 'parser which hasn\'t enough number of nucleotides' do
     subject(:parser) { Bioinform::MatrixParser.new(has_name: true, fix_nucleotides_number: 4) }
     let(:input) {">PM name\n" + "1\t2\t3\n" + "11\t12\t13" }
-    specify { expect{ parser.parse!(input) }.to raise_error Bioinform::Error }
+    specify { expect{ parser.parse!(input) }.to raise_error(Bioinform::Error) }
   end
 
   context 'parser with auto transposition' do

data/spec/spec_helper_source.rb

@@ -37,7 +37,7 @@ def parser_specs(parser, good_cases, bad_cases)
 
     bad_cases.each do |case_description, input|
       it "should raise an exception on parsing #{case_description}" do
-        expect{ parser.parse!(input[:input]) }.to raise_error
+        expect{ parser.parse!(input[:input]) }.to raise_error(Bioinform::Error)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bioinform
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Ilya Vorontsov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-03 00:00:00.000000000 Z
+date: 2016-04-19 00:00:00.000000000 Z
 dependencies: []
 description: A bunch of useful classes for bioinformatics
 email:
@@ -22,6 +22,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
+- Gemfile.lock
 - Guardfile
 - LICENSE
 - README.md
@@ -62,6 +63,7 @@ files:
 - lib/bioinform/parsers/motif_splitter.rb
 - lib/bioinform/support.rb
 - lib/bioinform/support/strip_doc.rb
+- lib/bioinform/validator.rb
 - lib/bioinform/version.rb
 - spec/alphabet_spec.rb
 - spec/background_spec.rb
@@ -120,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Classes for work with different input formats of positional matrices and