ruby_speech 2.4.0 → 3.0.0

data/spec/ruby_speech/nlsml_spec.rb

@@ -52,7 +52,7 @@ describe RubySpeech::NLSML do
         end
       end
 
-      document.to_xml.should == expected_document
+      expect(document.to_xml).to eq(expected_document)
     end
 
     it "should return a structured/parsed document" do
@@ -68,7 +68,7 @@ describe RubySpeech::NLSML do
         end
       end
 
-      document.should be_match
+      expect(document).to be_match
     end
 
     context "with a string instance" do
@@ -92,7 +92,7 @@ describe RubySpeech::NLSML do
           end
         end
 
-        document.to_xml.should == expected_document
+        expect(document.to_xml).to eq(expected_document)
       end
     end
   end
@@ -106,7 +106,7 @@ describe RubySpeech::NLSML do
 
     its(:grammar) { should == 'http://flight' }
 
-    it { should be_match }
+    it { is_expected.to be_match }
 
     let(:expected_best_interpretation) do
       {
@@ -133,11 +133,11 @@ describe RubySpeech::NLSML do
     its(:best_interpretation) { should == expected_best_interpretation }
 
     it "should be equal if the XML is the same" do
-      subject.should be == RubySpeech.parse(example_document)
+      expect(subject).to eq(RubySpeech.parse(example_document))
     end
 
     it "should not be equal if the XML is different" do
-      subject.should_not be == RubySpeech.parse(empty_result)
+      expect(subject).not_to eq(RubySpeech.parse(empty_result))
     end
 
     context "when the XML is already parsed and is not the root of a document" do
@@ -280,7 +280,7 @@ describe RubySpeech::NLSML do
         RubySpeech.parse empty_result
       end
 
-      it { should_not be_match }
+      it { is_expected.not_to be_match }
     end
 
     context "with interpretations out of confidence order" do
@@ -389,7 +389,7 @@ describe RubySpeech::NLSML do
         '''
       end
 
-      it { should_not be_match }
+      it { is_expected.not_to be_match }
     end
 
     context "with multiple interpretations where one is a nomatch input" do
@@ -413,7 +413,7 @@ describe RubySpeech::NLSML do
         '''
       end
 
-      it { should be_match }
+      it { is_expected.to be_match }
     end
 
     context "with a single interpretation with a noinput" do
@@ -429,8 +429,8 @@ describe RubySpeech::NLSML do
         '''
       end
 
-      it { should_not be_match }
-      it { should be_noinput }
+      it { is_expected.not_to be_match }
+      it { is_expected.to be_noinput }
     end
   end
 end

data/spec/ruby_speech/ssml/audio_spec.rb

@@ -17,7 +17,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:audio).should == Audio
+        expect(Element.class_from_registration(:audio)).to eq(Audio)
       end
 
       describe "from a document" do
@@ -25,7 +25,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Audio }
+        it { is_expected.to be_instance_of Audio }
 
         its(:src)     { should == 'http://whatever.you-say-boss.com' }
         its(:content) { should == 'Hello' }
@@ -47,76 +47,76 @@ module RubySpeech
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new(doc) }.should_not raise_error
+          expect { subject << Audio.new(doc) }.not_to raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new(doc) }.should_not raise_error
+          expect { subject << Break.new(doc) }.not_to raise_error
         end
 
         it "should accept Desc" do
-          lambda { subject << Desc.new(doc) }.should_not raise_error
+          expect { subject << Desc.new(doc) }.not_to raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new(doc) }.should_not raise_error
+          expect { subject << Emphasis.new(doc) }.not_to raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new(doc) }.should_not raise_error
+          expect { subject << Mark.new(doc) }.not_to raise_error
         end
 
         it "should accept P" do
-          lambda { subject << P.new(doc) }.should_not raise_error
+          expect { subject << P.new(doc) }.not_to raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new(doc) }.should_not raise_error
+          expect { subject << Phoneme.new(doc) }.not_to raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new(doc) }.should_not raise_error
+          expect { subject << Prosody.new(doc) }.not_to raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
+          expect { subject << SayAs.new(doc, :interpret_as => :foo) }.not_to raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new(doc) }.should_not raise_error
+          expect { subject << Sub.new(doc) }.not_to raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new(doc) }.should_not raise_error
+          expect { subject << S.new(doc) }.not_to raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new(doc) }.should_not raise_error
+          expect { subject << Voice.new(doc) }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << 1 }.should raise_error(InvalidChildError, "An Audio can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "An Audio can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the content, and src are the same" do
-          Audio.new(doc, :src => "one", :content => "Hello there").should == Audio.new(doc, :src => "one", :content => "Hello there")
+          expect(Audio.new(doc, :src => "one", :content => "Hello there")).to eq(Audio.new(doc, :src => "one", :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Audio.new(doc, :content => "Hello").should_not == Audio.new(doc, :content => "Hello there")
+            expect(Audio.new(doc, :content => "Hello")).not_to eq(Audio.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the src is different" do
           it "should not be equal" do
-            Audio.new(doc, :src => 'one').should_not == Audio.new(doc, :src => 'two')
+            expect(Audio.new(doc, :src => 'one')).not_to eq(Audio.new(doc, :src => 'two'))
           end
         end
       end

data/spec/ruby_speech/ssml/break_spec.rb

@@ -17,7 +17,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:break).should == Break
+        expect(Element.class_from_registration(:break)).to eq(Break)
       end
 
       describe "from a document" do
@@ -26,7 +26,7 @@ module RubySpeech
         context 'with time of 3' do
           let(:document) { '<break strength="strong" time="3"/>' }
 
-          it { should be_instance_of Break }
+          it { is_expected.to be_instance_of Break }
 
           its(:strength)  { should == :strong }
           its(:time)      { should eql 3.0 }
@@ -51,16 +51,16 @@ module RubySpeech
         its(:strength) { should == :strong }
 
         it "with a valid level" do
-          lambda { subject.strength = :none }.should_not raise_error
-          lambda { subject.strength = :'x-weak' }.should_not raise_error
-          lambda { subject.strength = :weak }.should_not raise_error
-          lambda { subject.strength = :medium }.should_not raise_error
-          lambda { subject.strength = :strong }.should_not raise_error
-          lambda { subject.strength = :'x-strong' }.should_not raise_error
+          expect { subject.strength = :none }.not_to raise_error
+          expect { subject.strength = :'x-weak' }.not_to raise_error
+          expect { subject.strength = :weak }.not_to raise_error
+          expect { subject.strength = :medium }.not_to raise_error
+          expect { subject.strength = :strong }.not_to raise_error
+          expect { subject.strength = :'x-strong' }.not_to raise_error
         end
 
         it "with an invalid strength" do
-          lambda { subject.strength = :something }.should raise_error(ArgumentError, "You must specify a valid strength (:none, :\"x-weak\", :weak, :medium, :strong, :\"x-strong\")")
+          expect { subject.strength = :something }.to raise_error(ArgumentError, "You must specify a valid strength (:none, :\"x-weak\", :weak, :medium, :strong, :\"x-strong\")")
         end
       end
 
@@ -79,43 +79,43 @@ module RubySpeech
 
         context "with a negative value" do
           it do
-            lambda { subject.time = -3 }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
+            expect { subject.time = -3 }.to raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
           end
         end
 
         context "with an invalid value" do
           it do
-            lambda { subject.time = 'blah' }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
+            expect { subject.time = 'blah' }.to raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
           end
         end
       end
 
       describe "<<" do
         it "should always raise InvalidChildError" do
-          lambda { subject << 'anything' }.should raise_error(InvalidChildError, "A Break cannot contain children")
+          expect { subject << 'anything' }.to raise_error(InvalidChildError, "A Break cannot contain children")
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the content, strength and base uri are the same" do
-          Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there").should == Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there")
+          expect(Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there")).to eq(Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Break.new(doc, :content => "Hello").should_not == Break.new(doc, :content => "Hello there")
+            expect(Break.new(doc, :content => "Hello")).not_to eq(Break.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the strength is different" do
           it "should not be equal" do
-            Break.new(doc, :strength => :strong).should_not == Break.new(doc, :strength => :weak)
+            expect(Break.new(doc, :strength => :strong)).not_to eq(Break.new(doc, :strength => :weak))
           end
         end
 
         describe "when the time is different" do
           it "should not be equal" do
-            Break.new(doc, :time => 1).should_not == Break.new(doc, :time => 2)
+            expect(Break.new(doc, :time => 1)).not_to eq(Break.new(doc, :time => 2))
           end
         end
       end

data/spec/ruby_speech/ssml/desc_spec.rb

@@ -16,7 +16,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:desc).should == Desc
+        expect(Element.class_from_registration(:desc)).to eq(Desc)
       end
 
       describe "from a document" do
@@ -24,36 +24,36 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Desc }
+        it { is_expected.to be_instance_of Desc }
 
         its(:language) { should == 'en' }
       end
 
       describe "comparing objects" do
         it "should be equal if the content and language are the same" do
-          Desc.new(doc, :language => 'jp', :content => "Hello there").should == Desc.new(doc, :language => 'jp', :content => "Hello there")
+          expect(Desc.new(doc, :language => 'jp', :content => "Hello there")).to eq(Desc.new(doc, :language => 'jp', :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Desc.new(doc, :content => "Hello").should_not == Desc.new(doc, :content => "Hello there")
+            expect(Desc.new(doc, :content => "Hello")).not_to eq(Desc.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Desc.new(doc, :language => 'jp').should_not == Desc.new(doc, :language => 'en')
+            expect(Desc.new(doc, :language => 'jp')).not_to eq(Desc.new(doc, :language => 'en'))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << Voice.new(doc) }.should raise_error(InvalidChildError, "A Desc can only accept Strings as children")
+          expect { subject << Voice.new(doc) }.to raise_error(InvalidChildError, "A Desc can only accept Strings as children")
         end
       end
     end # Desc

data/spec/ruby_speech/ssml/emphasis_spec.rb

@@ -16,7 +16,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:emphasis).should == Emphasis
+        expect(Element.class_from_registration(:emphasis)).to eq(Emphasis)
       end
 
       describe "from a document" do
@@ -24,7 +24,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Emphasis }
+        it { is_expected.to be_instance_of Emphasis }
 
         its(:level) { should == :strong }
       end
@@ -35,78 +35,78 @@ module RubySpeech
         its(:level) { should == :strong }
 
         it "with a valid level" do
-          lambda { subject.level = :strong }.should_not raise_error
-          lambda { subject.level = :moderate }.should_not raise_error
-          lambda { subject.level = :none }.should_not raise_error
-          lambda { subject.level = :reduced }.should_not raise_error
+          expect { subject.level = :strong }.not_to raise_error
+          expect { subject.level = :moderate }.not_to raise_error
+          expect { subject.level = :none }.not_to raise_error
+          expect { subject.level = :reduced }.not_to raise_error
         end
 
         it "with an invalid level" do
-          lambda { subject.level = :something }.should raise_error(ArgumentError, "You must specify a valid level (:strong, :moderate, :none, :reduced)")
+          expect { subject.level = :something }.to raise_error(ArgumentError, "You must specify a valid level (:strong, :moderate, :none, :reduced)")
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the content and level are the same" do
-          Emphasis.new(doc, :level => :strong, :content => "Hello there").should == Emphasis.new(doc, :level => :strong, :content => "Hello there")
+          expect(Emphasis.new(doc, :level => :strong, :content => "Hello there")).to eq(Emphasis.new(doc, :level => :strong, :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Emphasis.new(doc, :content => "Hello").should_not == Emphasis.new(doc, :content => "Hello there")
+            expect(Emphasis.new(doc, :content => "Hello")).not_to eq(Emphasis.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the level is different" do
           it "should not be equal" do
-            Emphasis.new(doc, :level => :strong).should_not == Emphasis.new(doc, :level => :reduced)
+            expect(Emphasis.new(doc, :level => :strong)).not_to eq(Emphasis.new(doc, :level => :reduced))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new(doc) }.should_not raise_error
+          expect { subject << Audio.new(doc) }.not_to raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new(doc) }.should_not raise_error
+          expect { subject << Break.new(doc) }.not_to raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new(doc) }.should_not raise_error
+          expect { subject << Emphasis.new(doc) }.not_to raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new(doc) }.should_not raise_error
+          expect { subject << Mark.new(doc) }.not_to raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new(doc) }.should_not raise_error
+          expect { subject << Phoneme.new(doc) }.not_to raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new(doc) }.should_not raise_error
+          expect { subject << Prosody.new(doc) }.not_to raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
+          expect { subject << SayAs.new(doc, :interpret_as => :foo) }.not_to raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new(doc) }.should_not raise_error
+          expect { subject << Sub.new(doc) }.not_to raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new(doc) }.should_not raise_error
+          expect { subject << Voice.new(doc) }.not_to raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << 1 }.should raise_error(InvalidChildError, "An Emphasis can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "An Emphasis can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice as children")
         end
       end
     end # Emphasis