ruby_speech 2.3.1-java → 3.0.1-java

data/spec/ruby_speech/ssml/speak_spec.rb

@@ -7,7 +7,7 @@ module RubySpeech
 
       subject { described_class.new doc }
 
-      it { should be_a_valid_ssml_document }
+      it { is_expected.to be_a_valid_ssml_document }
 
       its(:name) { should == 'speak' }
       its(:language) { should == 'en-US' }
@@ -20,7 +20,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:speak).should == Speak
+        expect(Element.class_from_registration(:speak)).to eq(Speak)
       end
 
       describe "from a document" do
@@ -28,7 +28,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Speak }
+        it { is_expected.to be_instance_of Speak }
 
         its(:language) { should == 'jp' }
         its(:base_uri) { should == 'blah' }
@@ -48,24 +48,24 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language and base uri are the same" do
-          Speak.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there").should == Speak.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there")
+          expect(Speak.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there")).to eq(Speak.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Speak.new(doc, :content => "Hello").should_not == Speak.new(doc, :content => "Hello there")
+            expect(Speak.new(doc, :content => "Hello")).not_to eq(Speak.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Speak.new(doc, :language => 'en-US').should_not == Speak.new(doc, :language => 'en-GB')
+            expect(Speak.new(doc, :language => 'en-US')).not_to eq(Speak.new(doc, :language => 'en-GB'))
           end
         end
 
         describe "when the base URI is different" do
           it "should not be equal" do
-            Speak.new(doc, :base_uri => 'foo').should_not == Speak.new(doc, :base_uri => 'bar')
+            expect(Speak.new(doc, :base_uri => 'foo')).not_to eq(Speak.new(doc, :base_uri => 'bar'))
           end
         end
 
@@ -76,7 +76,7 @@ module RubySpeech
             s2 = Speak.new doc
             s2 << SayAs.new(doc, :interpret_as => 'time')
 
-            s1.should_not == s2
+            expect(s1).not_to eq(s2)
           end
         end
       end
@@ -86,66 +86,66 @@ module RubySpeech
         s.voice :gender => :male, :content => 'Hello'
         expected_s = Speak.new doc
         expected_s << Voice.new(doc, :gender => :male, :content => 'Hello')
-        s.should == expected_s
+        expect(s).to eq(expected_s)
       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 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, "A Speak can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "A Speak can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
         end
       end
 
       describe "#to_doc" do
         it "should create an XML document from the grammar" do
-          subject.to_doc.should == subject.document
+          expect(subject.to_doc).to eq(subject.document)
         end
       end
 
@@ -176,11 +176,11 @@ module RubySpeech
         end
 
         concat = (speak1 + speak2)
-        speak1.to_s.should == speak1_string
-        speak2.to_s.should == speak2_string
-        concat.should == expected_concat
-        concat.document.root.should == concat
-        concat.to_s.should_not include('default')
+        expect(speak1.to_s).to eq(speak1_string)
+        expect(speak2.to_s).to eq(speak2_string)
+        expect(concat).to eq(expected_concat)
+        expect(concat.document.root).to eq(concat)
+        expect(concat.to_s).not_to include('default')
       end
 
       context "when concatenating" do
@@ -199,7 +199,7 @@ module RubySpeech
             end
 
             concat = (speak1 + speak2)
-            concat.should == expected_concat
+            expect(concat).to eq(expected_concat)
           end
         end
       end

data/spec/ruby_speech/ssml/sub_spec.rb

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

data/spec/ruby_speech/ssml/voice_spec.rb

@@ -21,7 +21,7 @@ module RubySpeech
       end
 
       it 'registers itself' do
-        Element.class_from_registration(:voice).should == Voice
+        expect(Element.class_from_registration(:voice)).to eq(Voice)
       end
 
       describe "from a document" do
@@ -29,7 +29,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Voice }
+        it { is_expected.to be_instance_of Voice }
 
         its(:language)  { should == 'jp' }
         its(:gender)    { should == :male }
@@ -50,13 +50,13 @@ module RubySpeech
         its(:gender) { should == :male }
 
         it "with a valid gender" do
-          lambda { subject.gender = :male }.should_not raise_error
-          lambda { subject.gender = :female }.should_not raise_error
-          lambda { subject.gender = :neutral }.should_not raise_error
+          expect { subject.gender = :male }.not_to raise_error
+          expect { subject.gender = :female }.not_to raise_error
+          expect { subject.gender = :neutral }.not_to raise_error
         end
 
         it "with an invalid gender" do
-          lambda { subject.gender = :something }.should raise_error(ArgumentError, "You must specify a valid gender (:male, :female, :neutral)")
+          expect { subject.gender = :something }.to raise_error(ArgumentError, "You must specify a valid gender (:male, :female, :neutral)")
         end
       end
 
@@ -66,15 +66,15 @@ module RubySpeech
         its(:age) { should == 12 }
 
         it "with an integer of 0" do
-          lambda { subject.age = 0 }.should_not raise_error
+          expect { subject.age = 0 }.not_to raise_error
         end
 
         it "with an integer less than 0" do
-          lambda { subject.age = -1 }.should raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
+          expect { subject.age = -1 }.to raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
         end
 
         it "with something other than an integer" do
-          lambda { subject.age = "bah" }.should raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
+          expect { subject.age = "bah" }.to raise_error(ArgumentError, "You must specify a valid age (non-negative integer)")
         end
       end
 
@@ -84,11 +84,11 @@ module RubySpeech
         its(:variant) { should == 12 }
 
         it "with an integer less than 1" do
-          lambda { subject.variant = 0 }.should raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
+          expect { subject.variant = 0 }.to raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
         end
 
         it "with something other than an integer" do
-          lambda { subject.variant = "bah" }.should raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
+          expect { subject.variant = "bah" }.to raise_error(ArgumentError, "You must specify a valid variant (positive integer)")
         end
       end
 
@@ -106,97 +106,97 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language, gender, age, variant, name are the same" do
-          Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello").should == Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello")
+          expect(Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello")).to eq(Voice.new(doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Voice.new(doc, :content => "Hello").should_not == Voice.new(doc, :content => "Hello there")
+            expect(Voice.new(doc, :content => "Hello")).not_to eq(Voice.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Voice.new(doc, :language => "Hello").should_not == Voice.new(doc, :language => "Hello there")
+            expect(Voice.new(doc, :language => "Hello")).not_to eq(Voice.new(doc, :language => "Hello there"))
           end
         end
 
         describe "when the gender is different" do
           it "should not be equal" do
-            Voice.new(doc, :gender => :male).should_not == Voice.new(doc, :gender => :female)
+            expect(Voice.new(doc, :gender => :male)).not_to eq(Voice.new(doc, :gender => :female))
           end
         end
 
         describe "when the age is different" do
           it "should not be equal" do
-            Voice.new(doc, :age => 20).should_not == Voice.new(doc, :age => 30)
+            expect(Voice.new(doc, :age => 20)).not_to eq(Voice.new(doc, :age => 30))
           end
         end
 
         describe "when the variant is different" do
           it "should not be equal" do
-            Voice.new(doc, :variant => 1).should_not == Voice.new(doc, :variant => 2)
+            expect(Voice.new(doc, :variant => 1)).not_to eq(Voice.new(doc, :variant => 2))
           end
         end
 
         describe "when the name is different" do
           it "should not be equal" do
-            Voice.new(doc, :name => "Hello").should_not == Voice.new(doc, :name => "Hello there")
+            expect(Voice.new(doc, :name => "Hello")).not_to eq(Voice.new(doc, :name => "Hello there"))
           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 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, "A Voice can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
+          expect { subject << 1 }.to raise_error(InvalidChildError, "A Voice can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children")
         end
       end
     end # Voice

data/spec/ruby_speech/ssml_spec.rb

@@ -7,40 +7,40 @@ module RubySpeech
 
       it "should create an SSML document" do
         expected_doc = SSML::Speak.new doc
-        SSML.draw.should == expected_doc
-        SSML.draw.document.xpath('ns:speak', ns: 'http://www.w3.org/2001/10/synthesis').size.should == 1
+        expect(SSML.draw).to eq(expected_doc)
+        expect(SSML.draw.document.xpath('ns:speak', ns: 'http://www.w3.org/2001/10/synthesis').size).to eq(1)
       end
 
       it "can draw with a language" do
         expected_doc = SSML::Speak.new doc, language: 'pt-BR'
-        SSML.draw(language: 'pt-BR').should == expected_doc
+        expect(SSML.draw(language: 'pt-BR')).to eq(expected_doc)
       end
 
       describe "when the return value of the block is a string" do
         it "should be inserted into the document" do
           expected_doc = SSML::Speak.new(doc, :content => "Hi, I'm Fred")
-          SSML.draw { "Hi, I'm Fred" }.should == expected_doc
+          expect(SSML.draw { "Hi, I'm Fred" }).to eq(expected_doc)
         end
       end
 
       describe "when the return value of the block is not a string" do
         it "should not be inserted into the document" do
           expected_doc = SSML::Speak.new doc
-          SSML.draw { :foo }.should == expected_doc
+          expect(SSML.draw { :foo }).to eq(expected_doc)
         end
       end
 
       describe "when inserting a string" do
         it "should work" do
           expected_doc = SSML::Speak.new(doc, :content => "Hi, I'm Fred")
-          SSML.draw { string "Hi, I'm Fred" }.should == expected_doc
+          expect(SSML.draw { string "Hi, I'm Fred" }).to eq(expected_doc)
         end
       end
 
       it "should allow other SSML elements to be inserted in the document" do
         expected_doc = SSML::Speak.new doc
         expected_doc << SSML::Voice.new(doc, :gender => :male, :name => 'fred')
-        SSML.draw { voice :gender => :male, :name => 'fred' }.should == expected_doc
+        expect(SSML.draw { voice :gender => :male, :name => 'fred' }).to eq(expected_doc)
       end
 
       it "should allow nested block return values" do
@@ -52,7 +52,7 @@ module RubySpeech
             "Hi, I'm Fred."
           end
         end
-        doc.should == expected_doc
+        expect(doc).to eq(expected_doc)
       end
 
       it "should allow nested SSML elements" do
@@ -69,7 +69,7 @@ module RubySpeech
         voice << SSML::SayAs.new(doc, :interpret_as => 'date', :format => 'dmy', :content => "01/02/1960")
         expected_doc = SSML::Speak.new doc
         expected_doc << voice
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       it "should allow accessing methods defined outside the block" do
@@ -78,7 +78,31 @@ module RubySpeech
         end
 
         expected_doc = SSML::Speak.new doc, :content => foo
-        SSML.draw { string foo }.should == expected_doc
+        expect(SSML.draw { string foo }).to eq(expected_doc)
+      end
+
+      describe 'cloning' do
+        context 'SSML documents' do
+          let :original do
+            RubySpeech::SSML.draw do
+              string "Hi, I'm Fred."
+            end
+          end
+
+          subject { original.clone }
+
+          it 'should match the contents of the original document' do
+            expect(subject.to_s).to eq(original.to_s)
+          end
+
+          it 'should match the class of the original document' do
+            expect(subject.class).to eq(original.class)
+          end
+
+          it 'should be equal to the original document' do
+            expect(subject).to eq(original)
+          end
+        end
       end
 
       describe "embedding" do
@@ -105,7 +129,7 @@ module RubySpeech
             end
           end
 
-          doc2.should == expected_doc
+          expect(doc2).to eq(expected_doc)
         end
 
         it "SSML elements" do
@@ -125,7 +149,7 @@ module RubySpeech
             end
           end
 
-          doc.should == expected_doc
+          expect(doc).to eq(expected_doc)
         end
 
         it "strings" do
@@ -143,7 +167,7 @@ module RubySpeech
             end
           end
 
-          doc.should == expected_doc
+          expect(doc).to eq(expected_doc)
         end
       end
 
@@ -156,7 +180,7 @@ module RubySpeech
         2.times do
           expected_doc << SSML::Voice.new(doc, :native_content => "I <3 nachos.")
         end
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       it "should allow all permutations of possible nested SSML elements" do
@@ -246,7 +270,7 @@ module RubySpeech
         voice << SSML::Prosody.new(doc, :rate => :fast, :content => "And yet so spritely!")
         voice << SSML::Voice.new(doc, :age => 12, :content => "And I'm young Fred")
         expected_doc << voice
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
     end
 
@@ -269,10 +293,10 @@ module RubySpeech
       subject { import }
 
       it "should work" do
-        lambda { subject }.should_not raise_error
+        expect { subject }.not_to raise_error
       end
 
-      it { should be_a SSML::Speak }
+      it { is_expected.to be_a SSML::Speak }
 
       its(:children) { should == [voice] }
 

data/spec/ruby_speech_spec.rb

@@ -30,7 +30,7 @@ describe RubySpeech do
         '''
       end
 
-      it { should be_a RubySpeech::SSML::Element }
+      it { is_expected.to be_a RubySpeech::SSML::Element }
     end
 
     context "with a GRXML document" do
@@ -91,7 +91,7 @@ describe RubySpeech do
         '''
       end
 
-      it { should be_a RubySpeech::GRXML::Element }
+      it { is_expected.to be_a RubySpeech::GRXML::Element }
     end
 
     context "with an NLSML document" do
@@ -118,7 +118,7 @@ describe RubySpeech do
         '''
       end
 
-      it { should be_a RubySpeech::NLSML::Document }
+      it { is_expected.to be_a RubySpeech::NLSML::Document }
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,14 @@
-require 'ruby_speech'
+# encoding: utf-8
+# frozen_string_literal: true
 
-require 'coveralls'
+require "coveralls"
 Coveralls.wear!
 
+%w{
+  rspec/its
+  ruby_speech
+}.each { |f| require f }
+
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 
 schema_file_path = File.expand_path File.join(__FILE__, '../../assets/synthesis.xsd')
@@ -18,5 +24,4 @@ puts "Finished loading schema."
 RSpec.configure do |config|
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
-  config.treat_symbols_as_metadata_keys_with_true_values = true
 end

data/spec/support/dtmf_helper.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+#
+# Convert a simple DTMF string from "1 star 2" to "dtmf-1 dtmf-star dtmf-2".
+#
+# @param [Array] sequence A set of DTMF keys, such as `%w(1 star 2)`.
+#
+# @return [String] A string with "dtmf-" prefixed for each DTMF element.
+#                  Example: "dtmf-1 dtmf-star dtmf-2".
+#
+def dtmf_seq(sequence)
+  sequence.map { |d| "dtmf-#{d}" }.join ' '
+end