bioinform 0.1.17 → 0.2.0

data/lib/bioinform/support/strip_doc.rb

@@ -6,4 +6,4 @@ class String
   def strip_doc
     gsub(/^#{self[/\A +/]}/,'')
   end
-end
+end

data/lib/bioinform/version.rb

@@ -1,3 +1,3 @@
 module Bioinform
-  VERSION = "0.1.17"
+  VERSION = "0.2.0"
 end

data/spec/alphabet_spec.rb

@@ -0,0 +1,79 @@
+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
+  end
+
+  context 'usage with alphabet non-symbolized, non-upcased' do
+    let(:alphabet) { Bioinform::ComplementableAlphabet.new([:a,:B,'x','Y'], ['X',:y,:A,'B']) }
+
+    specify{ expect(alphabet.alphabet).to eq [:A,:B,:X,:Y]  }
+    specify{ expect(alphabet.complement_letter(:A)).to eq :X  }
+    specify{ expect(alphabet.complement_letter(:x)).to eq :a  }
+    specify{ expect(alphabet.complement_letter('B')).to eq 'Y'  }
+    specify{ expect(alphabet.complement_letter('b')).to eq 'y'  }
+
+    specify{ expect(alphabet.index_by_letter(:B)).to eq 1  }
+    specify{ expect(alphabet.index_by_letter(:b)).to eq 1  }
+    specify{ expect(alphabet.index_by_letter('B')).to eq 1  }
+    specify{ expect(alphabet.index_by_letter('b')).to eq 1  }
+  end
+
+  context 'with correct alphabet' do
+    specify{ expect{ Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:X,:Y,:A,:B]) }.not_to raise_error }
+    let(:alphabet) { Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:X,:Y,:A,:B]) }
+
+    specify{ expect(alphabet).to eq Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:X,:Y,:A,:B]) }
+    specify{ expect(alphabet).not_to eq Bioinform::ComplementableAlphabet.new([:A,:C,:X,:Y], [:X,:Y,:A,:C]) }
+    specify{ expect(alphabet).not_to eq Bioinform::ComplementableAlphabet.new([:A,:B,:X,:Y], [:Y,:X,:B,:A]) }
+    specify{ expect(alphabet).not_to eq Bioinform::ComplementableAlphabet.new([:B,:A,:Y,:X], [:X,:Y,:A,:B]) }
+
+    specify{ expect(alphabet.alphabet).to eq [:A,:B,:X,:Y]  }
+    specify{ expect(alphabet.complement_alphabet).to eq [:X,:Y,:A,:B]  }
+    specify{ expect(alphabet.letter_by_index(2)).to eq :X  }
+
+    specify{ expect(alphabet.complement_index(1)).to eq 3  } # :B --> :Y
+
+    specify{ expect{|b| alphabet.each_letter(&b) }.to yield_successive_args(:A,:B,:X,:Y) }
+    specify{ expect{|b| alphabet.each_letter.each(&b) }.to yield_successive_args(:A,:B,:X,:Y) }
+    specify{ expect{|b| alphabet.each_letter_index(&b) }.to yield_successive_args(0,1,2,3) }
+    specify{ expect{|b| alphabet.each_letter_index.each(&b) }.to yield_successive_args(0,1,2,3) }
+  end
+end
+
+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_index(0)).to eq 3 }
+  specify { expect{Bioinform::NucleotideAlphabet.complement_index(4)}.to raise_error Bioinform::Error}
+end
+
+describe Bioinform::NucleotideAlphabetWithN do
+  specify { expect( Bioinform::NucleotideAlphabetWithN.size ).to eq 5 }
+  specify { expect( Bioinform::NucleotideAlphabetWithN.complement_letter(:A) ).to eq :T }
+  specify { expect( Bioinform::NucleotideAlphabetWithN.complement_letter(:C) ).to eq :G }
+  specify { expect( Bioinform::NucleotideAlphabetWithN.complement_letter(:N) ).to eq :N }
+
+  specify { expect( Bioinform::NucleotideAlphabetWithN.complement_index(0) ).to eq 3 }
+  specify { expect( Bioinform::NucleotideAlphabetWithN.complement_index(4) ).to eq 4 }
+end
+
+describe Bioinform::IUPACAlphabet do
+  specify { expect( Bioinform::IUPACAlphabet.size ).to eq 15 }
+  specify { expect( Bioinform::IUPACAlphabet.complement_letter(:A) ).to eq :T }
+  specify { expect( Bioinform::IUPACAlphabet.complement_letter(:N) ).to eq :N }
+  specify { expect( Bioinform::IUPACAlphabet.complement_letter(:R) ).to eq :Y } # R = AG; Y = CT
+  specify { expect( Bioinform::IUPACAlphabet.complement_letter(:Y) ).to eq :R }
+  specify { expect( Bioinform::IUPACAlphabet.complement_letter(:W) ).to eq :W } # W = AT
+  specify { expect( Bioinform::IUPACAlphabet.complement_letter(:V) ).to eq :B } # V = ACG; B = CGT
+
+  specify { expect(Bioinform::IUPACAlphabet.complement_index(0)).to eq 3 }
+  specify { expect(Bioinform::IUPACAlphabet.complement_index(14)).to eq 14 } # N --> 4
+  specify { expect(Bioinform::IUPACAlphabet.complement_index(5)).to eq 8 } # R --> 5; Y --> 8
+end

data/spec/background_spec.rb

@@ -0,0 +1,57 @@
+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([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 }
+
+  let(:frequencies) { Bioinform::Frequencies.new([0.2,0.3,0.3,0.2]) }
+  specify { expect(frequencies.frequencies).to eq [0.2,0.3,0.3,0.2] }
+  specify { expect(frequencies.counts).to eq [0.2,0.3,0.3,0.2] }
+  specify { expect(frequencies.volume).to eq 1 }
+  specify { expect(frequencies).not_to be_wordwise }
+  specify { expect(frequencies).to eq Bioinform::Frequencies.new([0.2,0.3,0.3,0.2]) }
+  specify { expect(frequencies).not_to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
+
+  specify { expect(Bioinform::Frequencies.new([0.2,0.3,0.3,0.2])).not_to eq Bioinform::WordwiseBackground.new }
+  specify { expect(Bioinform::Frequencies.new([0.25,0.25,0.25,0.25])).not_to eq Bioinform::WordwiseBackground.new }
+
+  specify { expect(frequencies.mean([1,2,3,-4])).to eq(0.2*1 + 0.3*2 + 0.3*3 + 0.2*(-4)) }
+  specify { expect(frequencies.mean_square([1,2,3,-4])).to eq(0.2*1*1 + 0.3*2*2 + 0.3*3*3 + 0.2*(-4)*(-4)) }
+
+end
+
+describe Bioinform::WordwiseBackground do
+  specify { expect{Bioinform::WordwiseBackground.new }.not_to raise_error }
+  let(:frequencies) { Bioinform::WordwiseBackground.new }
+  specify { expect(frequencies.frequencies).to eq [0.25,0.25,0.25,0.25] }
+  specify { expect(frequencies.counts).to eq [1,1,1,1] }
+  specify { expect(frequencies.volume).to eq 4 }
+  specify { expect(frequencies).to be_wordwise }
+  specify { expect(frequencies).to eq Bioinform::WordwiseBackground.new }
+  specify { expect(frequencies).not_to eq Bioinform::Frequencies.new([0.2,0.3,0.3,0.2]) }
+  specify { expect(frequencies).not_to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
+
+  specify { expect(frequencies.mean([1,2,3,-4])).to eq(0.25*1 + 0.25*2 + 0.25*3 + 0.25*(-4)) }
+  specify { expect(frequencies.mean_square([1,2,3,-4])).to eq(0.25*1*1 + 0.25*2*2 + 0.25*3*3 + 0.25*(-4)*(-4)) }
+end
+
+describe Bioinform::Background do
+  specify { expect(Bioinform::Background.wordwise).to eq Bioinform::WordwiseBackground.new }
+  specify { expect(Bioinform::Background::Wordwise).to eq Bioinform::WordwiseBackground.new }
+  specify { expect(Bioinform::Background.uniform).to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
+  specify { expect(Bioinform::Background::Uniform).to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
+
+  specify { expect(Bioinform::Background.from_gc_content(0.5)).to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
+  specify { expect(Bioinform::Background.from_gc_content(0.6)).to eq Bioinform::Frequencies.new([0.2,0.3,0.3,0.2]) }
+
+  specify { expect(Bioinform::Background.from_string('0.2,0.3,0.3,0.2')).to eq Bioinform::Frequencies.new([0.2,0.3,0.3,0.2]) }
+  specify { expect(Bioinform::Background.from_string('0.25,0.25,0.25,0.25')).to eq Bioinform::Frequencies.new([0.25,0.25,0.25,0.25]) }
+  specify { expect(Bioinform::Background.from_string('1,1,1,1')).to eq Bioinform::WordwiseBackground.new }
+  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 }
+end

data/spec/cli/cli_spec.rb

@@ -1,14 +1,14 @@
 require_relative '../spec_helper'
-require_relative '../../lib/bioinform/cli'
+require 'bioinform/cli'
 
 describe Bioinform::CLI do
   describe '.change_folder_and_extension' do
     it 'should change extension and folder' do
       extend Bioinform::CLI::Helpers
-      change_folder_and_extension('test.pcm', 'pwm', '.').should == './test.pwm'
-      change_folder_and_extension('test.pcm', 'pat', 'pwm_folder').should == 'pwm_folder/test.pat'
-      change_folder_and_extension('pcm/test.pcm', 'pat', 'pwm_folder').should == 'pwm_folder/test.pat'
-      change_folder_and_extension('test.pcm', 'pat', '../pwm_folder').should == '../pwm_folder/test.pat'
+      expect( change_folder_and_extension('test.pcm', 'pwm', '.') ).to eq './test.pwm'
+      expect( change_folder_and_extension('test.pcm', 'pat', 'pwm_folder') ).to eq 'pwm_folder/test.pat'
+      expect( change_folder_and_extension('pcm/test.pcm', 'pat', 'pwm_folder') ).to eq 'pwm_folder/test.pat'
+      expect( change_folder_and_extension('test.pcm', 'pat', '../pwm_folder') ).to eq '../pwm_folder/test.pat'
     end
   end
-end
+end

data/spec/cli/convert_motif_spec.rb

@@ -1,107 +1,107 @@
-require 'shellwords'
-require_relative '../spec_helper'
-require_relative '../../lib/bioinform/cli/convert_motif'
-require_relative 'shared_examples/convert_motif/single_motif_specified'
-require_relative 'shared_examples/convert_motif/several_motifs_specified'
-require_relative 'shared_examples/convert_motif/motif_list_empty'
-require_relative 'shared_examples/convert_motif/yield_motif_conversion_error'
+# require 'shellwords'
+# require_relative '../spec_helper'
+# require 'bioinform/cli/convert_motif'
+# require_relative 'shared_examples/convert_motif/single_motif_specified'
+# require_relative 'shared_examples/convert_motif/several_motifs_specified'
+# require_relative 'shared_examples/convert_motif/motif_list_empty'
+# require_relative 'shared_examples/convert_motif/yield_motif_conversion_error'
 
-def make_option_list(options = {})
-  result = []
-  result << '--from' << options[:model_from]  if options[:model_from]
-  result << '--to' << options[:model_to]  if options[:model_to]
-  result << '--parser' << options[:parser]  if options[:parser]
-  result << '--formatter' << options[:formatter]  if options[:formatter]
-  result << (options[:silent] ? '--silent' : '--no-silent')  if options.has_key?(:silent)
-  result << (options[:force] ? '--force' : '--no-force')  if options.has_key?(:force)
-  result << '--save' << options[:filename_format]  if options[:filename_format]
-  result << '--algorithm' << options[:algorithm]  if options[:algorithm]
-  result
-end
+# def make_option_list(options = {})
+#   result = []
+#   result << '--from' << options[:model_from]  if options[:model_from]
+#   result << '--to' << options[:model_to]  if options[:model_to]
+#   result << '--parser' << options[:parser]  if options[:parser]
+#   result << '--formatter' << options[:formatter]  if options[:formatter]
+#   result << (options[:silent] ? '--silent' : '--no-silent')  if options.has_key?(:silent)
+#   result << (options[:force] ? '--force' : '--no-force')  if options.has_key?(:force)
+#   result << '--save' << options[:filename_format]  if options[:filename_format]
+#   result << '--algorithm' << options[:algorithm]  if options[:algorithm]
+#   result
+# end
 
 
-shared_context 'most common options' do
-  Given(:parser) { 'plain' }
-  Given(:formatter) { 'plain' }
-  Given(:silent) { true }
-  Given(:force) { false }
-  Given(:filename_format) { nil }
-  Given(:algorithm) { nil }
-end
+# shared_context 'most common options' do
+#   Given(:parser) { 'plain' }
+#   Given(:formatter) { 'plain' }
+#   Given(:silent) { true }
+#   Given(:force) { false }
+#   Given(:filename_format) { nil }
+#   Given(:algorithm) { nil }
+# end
 
-shared_context 'completely specified option list' do
-  Given(:options) {
-    make_option_list( model_from: model_from,  model_to: model_to,
-                      parser: parser,  formatter: formatter,
-                      silent: silent,  force: force,
-                      filename_format: filename_format,
-                      algorithm: algorithm ).shelljoin 
-  }
-end
+# shared_context 'completely specified option list' do
+#   Given(:options) {
+#     make_option_list( model_from: model_from,  model_to: model_to,
+#                       parser: parser,  formatter: formatter,
+#                       silent: silent,  force: force,
+#                       filename_format: filename_format,
+#                       algorithm: algorithm ).shelljoin 
+#   }
+# end
 
-shared_context 'input filenames are motif_name.motif_type' do
-  Given(:input_filenames) { motif_list.map{|motif| motif_filename(motif, model_from) }.shelljoin }
-end
+# shared_context 'input filenames are motif_name.motif_type' do
+#   Given(:input_filenames) { motif_list.map{|motif| motif_filename(motif, model_from) }.shelljoin }
+# end
 
-##################################
+# ##################################
 
-describe Bioinform::CLI::ConvertMotif do
-  include FakeFS::SpecHelpers
-  Given(:resulting_stdout) { resulting_io[:stdout] }
-  Given(:resulting_stderr) { resulting_io[:stderr] }
+# describe Bioinform::CLI::ConvertMotif do
+#   include FakeFS::SpecHelpers
+#   Given(:resulting_stdout) { resulting_io[:stdout] }
+#   Given(:resulting_stderr) { resulting_io[:stderr] }
   
-  Given(:command) { options.shellsplit + arguments.shellsplit }
+#   Given(:command) { options.shellsplit + arguments.shellsplit }
   
-  Given(:sp1_f1){ Fabricate(:SP1_f1_plain_text) }
-  Given(:klf4_f2){ Fabricate(:KLF4_f2_plain_text) }
+#   Given(:sp1_f1){ Fabricate(:SP1_f1_plain_text) }
+#   Given(:klf4_f2){ Fabricate(:KLF4_f2_plain_text) }
   
-########################################################
+# ########################################################
   
-  context 'when program not piped' do
-    Given(:arguments) { input_filenames }
-    Given(:resulting_io) {
-      capture_io{
-          Bioinform::CLI::ConvertMotif.main(command)
-      }
-    }
-    include_context 'input filenames are motif_name.motif_type'
+#   context 'when program not piped' do
+#     Given(:arguments) { input_filenames }
+#     Given(:resulting_io) {
+#       capture_io{
+#           Bioinform::CLI::ConvertMotif.main(command)
+#       }
+#     }
+#     include_context 'input filenames are motif_name.motif_type'
     
-    context 'with most options specified' do
-      include_context 'completely specified option list'
-      include_context 'most common options'      
+#     context 'with most options specified' do
+#       include_context 'completely specified option list'
+#       include_context 'most common options'      
 
-      include_examples 'single motif specified'
-      include_examples 'several motifs specified'
-    end
+#       include_examples 'single motif specified'
+#       include_examples 'several motifs specified'
+#     end
     
-    include_examples 'motif list is empty'
-  end
+#     include_examples 'motif list is empty'
+#   end
   
-########################################################
+# ########################################################
 
-  context 'when program is piped' do
-#    include_context 'completely specified option list'
-#    include_context 'most common options'
-    include_context 'input filenames are motif_name.motif_type'
+#   context 'when program is piped' do
+# #    include_context 'completely specified option list'
+# #    include_context 'most common options'
+#     include_context 'input filenames are motif_name.motif_type'
 
-    Given(:tty){ false }
-    Given(:stdin_data) { input_filenames }
-    Given(:arguments) { '' }
-    Given(:resulting_io) {
-      capture_io{
-        provide_stdin(stdin_data, tty) {
-          Bioinform::CLI::ConvertMotif.main(command)
-        }
-      }
-    }
+#     Given(:tty){ false }
+#     Given(:stdin_data) { input_filenames }
+#     Given(:arguments) { '' }
+#     Given(:resulting_io) {
+#       capture_io{
+#         provide_stdin(stdin_data, tty) {
+#           Bioinform::CLI::ConvertMotif.main(command)
+#         }
+#       }
+#     }
 
-    include_examples 'motif list is empty'
-    context 'with most options specified' do
-      include_context 'completely specified option list'
-      include_context 'most common options'      
+#     include_examples 'motif list is empty'
+#     context 'with most options specified' do
+#       include_context 'completely specified option list'
+#       include_context 'most common options'      
 
-      include_examples 'single motif specified'
-      include_examples 'several motifs specified'
-    end
-  end
-end
+#       include_examples 'single motif specified'
+#       include_examples 'several motifs specified'
+#     end
+#   end
+# end

data/spec/cli/data/pcm2pwm/KLF4_f2.pwm.result

@@ -1,11 +1,11 @@
-KLF4_f2
+>KLF4_f2
 0.30861857265872605	-2.254321000121579	0.13505703522674192	0.3285194224375633
--1.227018967707036	-4.814127713368663	1.3059890687390967	-4.908681463544344
--2.443469374521196	-4.648238485031404	1.3588686548279805	-4.441801801188402
--2.7177827948276123	-3.8073538975356565	1.356272809724262	-3.504104725510225
--0.5563232977367343	0.5340697765121405	-3.61417723090579	0.5270259776377405
+-1.2270189677070362	-4.814127713368663	1.3059890687390965	-4.908681463544344
+-2.4434693745211966	-4.648238485031404	1.3588686548279802	-4.441801801188402
+-2.7177827948276128	-3.807353897535657	1.3562728097242616	-3.504104725510225
+-0.5563232977367345	0.5340697765121402	-3.61417723090579	0.5270259776377402
 -1.8687622060887386	-4.381483976582316	1.337932245336098	-3.815629658877517
--2.045671123823928	-2.384975142213679	0.7198551207724355	0.5449254135616948
--1.373157530374372	-3.0063112097748217	1.285188335493552	-2.5026044231773543
--2.1030513122772208	-1.8941348100402244	1.249265758393991	-1.4284210948906104
--1.3277128628152939	0.8982415633049462	-0.8080773665408135	-0.18161647647456935
+-2.0456711238239285	-2.3849751422136793	0.7198551207724353	0.5449254135616943
+-1.3731575303743726	-3.006311209774822	1.2851883354935514	-2.5026044231773548
+-2.103051312277221	-1.8941348100402247	1.249265758393991	-1.4284210948906106
+-1.327712862815294	0.898241563304946	-0.8080773665408136	-0.1816164764745695

data/spec/cli/data/pcm2pwm/SP1_f1.pwm.result

@@ -1,12 +1,12 @@
-SP1_f1
+>SP1_f1
 -0.24435707885585292	-0.674823404693731	0.8657012535789866	-1.1060188862599287
--1.0631255752097797	-2.111925969423868	1.0960627561110403	-0.6138563775211977
--0.3872276234760535	-2.9739851913218045	1.1807800242010378	-4.338927525031566
--4.563896055436894	-2.9161633002532277	1.3684371349982638	-5.077972423609655
--2.2369752892820083	-3.7196436313301846	1.3510439136452734	-4.889930670508233
--0.07473964149330865	0.944919654762011	-2.6246857648086044	-0.8510983487822436
--1.9643526491643322	-2.978402770880115	1.3113096718240573	-2.324334259499025
--4.0155484139655835	-3.1384268078096667	1.3387488589788057	-2.084673903537648
--0.44509385828355363	-2.2510053061629702	1.1265431574368685	-1.7780413702431372
--1.1896356092245048	-1.2251832285630027	1.1636760063747527	-1.6080243648157353
--0.5166047365590571	0.7641033353626657	-0.2862677570028208	-0.68254820978656
+-1.063125575209786	-2.111925969423874	1.096062756111034	-0.6138563775212038
+-0.38722762347606526	-2.9739851913218165	1.180780024201026	-4.338927525031577
+-4.563896055436912	-2.916163300253245	1.3684371349982463	-5.077972423609672
+-2.2369752892820247	-3.7196436313302015	1.3510439136452568	-4.8899306705082495
+-0.07473964149331284	0.9449196547620068	-2.6246857648086084	-0.8510983487822477
+-1.9643526491643477	-2.9784027708801304	1.3113096718240418	-2.3243342594990404
+-4.015548413965599	-3.138426807809682	1.3387488589787901	-2.0846739035376634
+-0.44509385828356285	-2.2510053061629796	1.1265431574368594	-1.7780413702431463
+-1.1896356092245128	-1.2251832285630104	1.1636760063747449	-1.608024364815743
+-0.5166047365590577	0.7641033353626651	-0.28626775700282125	-0.6825482097865606

data/spec/cli/pcm2pwm_spec.rb

@@ -1,6 +1,6 @@
 require 'shellwords'
 require_relative '../spec_helper'
-require_relative '../../lib/bioinform/cli/pcm2pwm'
+require 'bioinform/cli/pcm2pwm'
 
 
 def run_pcm2pwm(cmd)
@@ -23,58 +23,57 @@ describe Bioinform::CLI::PCM2PWM do
 
   it 'should transform single PCM to PWM' do
     run_pcm2pwm('KLF4_f2.pcm')
-    File.exist?('KLF4_f2.pwm').should be_true
-    File.read('KLF4_f2.pwm').should == File.read('KLF4_f2.pwm.result')
+    expect(File.exist?('KLF4_f2.pwm')).to be_truthy
+    expect(File.read('KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
   end
 
   it 'should transform multiple PCMs to PWMs' do
     run_pcm2pwm('KLF4_f2.pcm SP1_f1.pcm')
 
-    File.exist?('KLF4_f2.pwm').should be_true
-    File.read('KLF4_f2.pwm').should == File.read('KLF4_f2.pwm.result')
+    expect(File.exist?('KLF4_f2.pwm')).to be_truthy
+    expect(File.read('KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
 
-    File.exist?('SP1_f1.pwm').should be_true
-    File.read('SP1_f1.pwm').should == File.read('SP1_f1.pwm.result')
+    expect(File.exist?('SP1_f1.pwm')).to be_truthy
+    expect(File.read('SP1_f1.pwm')).to eq File.read('SP1_f1.pwm.result')
   end
 
   it 'should transform extension to specified with --extension option' do
     run_pcm2pwm('KLF4_f2.pcm --extension=pat')
-    File.exist?('KLF4_f2.pat').should be_true
-    File.read('KLF4_f2.pat').should == File.read('KLF4_f2.pwm.result')
+    expect(File.exist?('KLF4_f2.pat')).to be_truthy
+    expect(File.read('KLF4_f2.pat')).to eq File.read('KLF4_f2.pwm.result')
   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')
-    File.exist?('pwm_folder/KLF4_f2.pwm').should be_true
-    File.read('pwm_folder/KLF4_f2.pwm').should == File.read('KLF4_f2.pwm.result')
+    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')
   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')
-    File.exist?('pwm_folder/KLF4_f2.pwm').should be_true
-    File.read('pwm_folder/KLF4_f2.pwm').should == File.read('KLF4_f2.pwm.result')
+    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')
   end
 
   it 'should process PCMs with names obtained from STDIN' do
     provide_stdin('KLF4_f2.pcm SP1_f1.pcm') { run_pcm2pwm('') }
-    File.exist?('KLF4_f2.pwm').should be_true
-    File.read('KLF4_f2.pwm').should == File.read('KLF4_f2.pwm.result')
+    expect(File.exist?('KLF4_f2.pwm')).to be_truthy
+    expect(File.read('KLF4_f2.pwm')).to eq File.read('KLF4_f2.pwm.result')
 
-    File.exist?('SP1_f1.pwm').should be_true
-    File.read('SP1_f1.pwm').should == File.read('SP1_f1.pwm.result')
+    expect(File.exist?('SP1_f1.pwm')).to be_truthy
+    expect(File.read('SP1_f1.pwm')).to eq File.read('SP1_f1.pwm.result')
   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') }
-    File.exist?('KLF4_f2.pat').should be_true
-    File.read('KLF4_f2.pat').should == File.read('KLF4_f2.pwm.result')
+    expect(File.exist?('KLF4_f2.pat')).to be_truthy
+    expect(File.read('KLF4_f2.pat')).to eq File.read('KLF4_f2.pwm.result')
   end
 
   it 'should process PCMs having filename with spaces' do
     run_pcm2pwm('"KLF4 f2 spaced name.pcm"')
-    File.exist?('KLF4 f2 spaced name.pwm').should be_true
-    File.read('KLF4 f2 spaced name.pwm').should == File.read('KLF4_f2.pwm.result')
+    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')
   end
-
-end
+end