ruby_speech 2.1.2 → 2.2.0

data/spec/ruby_speech/ssml/s_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe S do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 's' }
 
       describe "setting options in initializers" do
-        subject { S.new :language => 'jp' }
+        subject { S.new doc, :language => 'jp' }
 
         its(:language) { should == 'jp' }
       end
@@ -26,18 +30,18 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content and language are the same" do
-          S.new(:language => 'jp', :content => "Hello there").should == S.new(:language => 'jp', :content => "Hello there")
+          S.new(doc, :language => 'jp', :content => "Hello there").should == S.new(doc, :language => 'jp', :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            S.new(:content => "Hello").should_not == S.new(:content => "Hello there")
+            S.new(doc, :content => "Hello").should_not == S.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            S.new(:language => 'jp').should_not == S.new(:language => 'en')
+            S.new(doc, :language => 'jp').should_not == S.new(doc, :language => 'en')
           end
         end
       end
@@ -48,39 +52,39 @@ module RubySpeech
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new }.should_not raise_error
+          lambda { subject << Audio.new(doc) }.should_not raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new }.should_not raise_error
+          lambda { subject << Break.new(doc) }.should_not raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new }.should_not raise_error
+          lambda { subject << Emphasis.new(doc) }.should_not raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new }.should_not raise_error
+          lambda { subject << Mark.new(doc) }.should_not raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new }.should_not raise_error
+          lambda { subject << Phoneme.new(doc) }.should_not raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new }.should_not raise_error
+          lambda { subject << Prosody.new(doc) }.should_not raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new }.should_not raise_error
+          lambda { subject << Sub.new(doc) }.should_not raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new }.should_not raise_error
+          lambda { subject << Voice.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do

data/spec/ruby_speech/ssml/say_as_spec.rb

@@ -3,7 +3,11 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe SayAs do
-      subject { SayAs.new :interpret_as => 'one', :format => 'two', :detail => 'three' }
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
+      subject { SayAs.new doc, :interpret_as => 'one', :format => 'two', :detail => 'three' }
 
       its(:name) { should == 'say-as' }
 
@@ -29,30 +33,30 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, interpret_as, format, age, variant, name are the same" do
-          SayAs.new(:interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello").should == SayAs.new(:interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello")
+          SayAs.new(doc, :interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello").should == SayAs.new(doc, :interpret_as => 'jp', :format => 'foo', :detail => 'bar', :content => "hello")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => 'jp', :content => "Hello").should_not == SayAs.new(:interpret_as => 'jp', :content => "Hello there")
+            SayAs.new(doc, :interpret_as => 'jp', :content => "Hello").should_not == SayAs.new(doc, :interpret_as => 'jp', :content => "Hello there")
           end
         end
 
         describe "when the interpret_as is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => "Hello").should_not == SayAs.new(:interpret_as => "Hello there")
+            SayAs.new(doc, :interpret_as => "Hello").should_not == SayAs.new(doc, :interpret_as => "Hello there")
           end
         end
 
         describe "when the format is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => 'jp', :format => 'foo').should_not == SayAs.new(:interpret_as => 'jp', :format => 'bar')
+            SayAs.new(doc, :interpret_as => 'jp', :format => 'foo').should_not == SayAs.new(doc, :interpret_as => 'jp', :format => 'bar')
           end
         end
 
         describe "when the detail is different" do
           it "should not be equal" do
-            SayAs.new(:interpret_as => 'jp', :detail => 'foo').should_not == SayAs.new(:interpret_as => 'jp', :detail => 'bar')
+            SayAs.new(doc, :interpret_as => 'jp', :detail => 'foo').should_not == SayAs.new(doc, :interpret_as => 'jp', :detail => 'bar')
           end
         end
       end
@@ -63,7 +67,7 @@ module RubySpeech
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << Voice.new }.should raise_error(InvalidChildError, "A SayAs can only accept Strings as children")
+          lambda { subject << Voice.new(doc) }.should raise_error(InvalidChildError, "A SayAs can only accept Strings as children")
         end
       end
     end # SayAs

data/spec/ruby_speech/ssml/speak_spec.rb

@@ -3,13 +3,17 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Speak do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       it { should be_a_valid_ssml_document }
 
       its(:name) { should == 'speak' }
       its(:language) { should == 'en-US' }
 
       describe "setting options in initializers" do
-        subject { Speak.new :language => 'jp', :base_uri => 'blah' }
+        subject { Speak.new doc, :language => 'jp', :base_uri => 'blah' }
 
         its(:language) { should == 'jp' }
         its(:base_uri) { should == 'blah' }
@@ -44,33 +48,33 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language and base uri are the same" do
-          Speak.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there").should == Speak.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there")
+          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")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Speak.new(:content => "Hello").should_not == Speak.new(:content => "Hello there")
+            Speak.new(doc, :content => "Hello").should_not == Speak.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Speak.new(:language => 'en-US').should_not == Speak.new(:language => 'en-GB')
+            Speak.new(doc, :language => 'en-US').should_not == Speak.new(doc, :language => 'en-GB')
           end
         end
 
         describe "when the base URI is different" do
           it "should not be equal" do
-            Speak.new(:base_uri => 'foo').should_not == Speak.new(:base_uri => 'bar')
+            Speak.new(doc, :base_uri => 'foo').should_not == Speak.new(doc, :base_uri => 'bar')
           end
         end
 
         describe "when the children are different" do
           it "should not be equal" do
-            s1 = Speak.new
-            s1 << SayAs.new(:interpret_as => 'date')
-            s2 = Speak.new
-            s2 << SayAs.new(:interpret_as => 'time')
+            s1 = Speak.new doc
+            s1 << SayAs.new(doc, :interpret_as => 'date')
+            s2 = Speak.new doc
+            s2 << SayAs.new(doc, :interpret_as => 'time')
 
             s1.should_not == s2
           end
@@ -78,10 +82,10 @@ module RubySpeech
       end
 
       it "should allow creating child SSML elements" do
-        s = Speak.new
+        s = Speak.new doc
         s.voice :gender => :male, :content => 'Hello'
-        expected_s = Speak.new
-        expected_s << Voice.new(:gender => :male, :content => 'Hello')
+        expected_s = Speak.new doc
+        expected_s << Voice.new(doc, :gender => :male, :content => 'Hello')
         s.should == expected_s
       end
 
@@ -91,47 +95,47 @@ module RubySpeech
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new }.should_not raise_error
+          lambda { subject << Audio.new(doc) }.should_not raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new }.should_not raise_error
+          lambda { subject << Break.new(doc) }.should_not raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new }.should_not raise_error
+          lambda { subject << Emphasis.new(doc) }.should_not raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new }.should_not raise_error
+          lambda { subject << Mark.new(doc) }.should_not raise_error
         end
 
         it "should accept P" do
-          lambda { subject << P.new }.should_not raise_error
+          lambda { subject << P.new(doc) }.should_not raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new }.should_not raise_error
+          lambda { subject << Phoneme.new(doc) }.should_not raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new }.should_not raise_error
+          lambda { subject << Prosody.new(doc) }.should_not raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new }.should_not raise_error
+          lambda { subject << Sub.new(doc) }.should_not raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new }.should_not raise_error
+          lambda { subject << S.new(doc) }.should_not raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new }.should_not raise_error
+          lambda { subject << Voice.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
@@ -146,19 +150,31 @@ module RubySpeech
       end
 
       it "should allow concatenation" do
-        speak1 = Speak.new
-        speak1 << Voice.new(:name => 'frank', :content => "Hi, I'm Frank")
-        speak2 = Speak.new
-        speak2 << "Hello there"
-        speak2 << Voice.new(:name => 'millie', :content => "Hi, I'm Millie")
+        speak1 = SSML.draw do
+          voice :name => 'frank' do
+            "Hi, I'm Frank"
+          end
+        end
+        speak2 = SSML.draw do
+          string "Hello there"
+          voice :name => 'millie' do
+            "Hi, I'm Millie"
+          end
+        end
 
-        expected_concat = Speak.new
-        expected_concat << Voice.new(:name => 'frank', :content => "Hi, I'm Frank")
-        expected_concat << "Hello there"
-        expected_concat << Voice.new(:name => 'millie', :content => "Hi, I'm Millie")
+        expected_concat = SSML.draw do
+          voice :name => 'frank' do
+            "Hi, I'm Frank"
+          end
+          string "Hello there"
+          voice :name => 'millie' do
+            "Hi, I'm Millie"
+          end
+        end
 
         concat = (speak1 + speak2)
         concat.should == expected_concat
+        concat.document.root.should == concat
         concat.to_s.should_not include('default')
       end
     end # Speak

data/spec/ruby_speech/ssml/sub_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Sub do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'sub' }
 
       describe "setting options in initializers" do
-        subject { Sub.new :alias => 'foo' }
+        subject { Sub.new doc, :alias => 'foo' }
 
         its(:alias) { should == 'foo' }
       end
@@ -27,18 +31,18 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content and alias are the same" do
-          Sub.new(:alias => 'jp', :content => "Hello there").should == Sub.new(:alias => 'jp', :content => "Hello there")
+          Sub.new(doc, :alias => 'jp', :content => "Hello there").should == Sub.new(doc, :alias => 'jp', :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Sub.new(:content => "Hello").should_not == Sub.new(:content => "Hello there")
+            Sub.new(doc, :content => "Hello").should_not == Sub.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the alias is different" do
           it "should not be equal" do
-            Sub.new(:alias => 'jp').should_not == Sub.new(:alias => 'en')
+            Sub.new(doc, :alias => 'jp').should_not == Sub.new(doc, :alias => 'en')
           end
         end
       end
@@ -49,7 +53,7 @@ module RubySpeech
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
-          lambda { subject << Voice.new }.should raise_error(InvalidChildError, "A Sub can only accept Strings as children")
+          lambda { subject << Voice.new(doc) }.should raise_error(InvalidChildError, "A Sub can only accept Strings as children")
         end
       end
     end # Desc

data/spec/ruby_speech/ssml/voice_spec.rb

@@ -3,11 +3,15 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Voice do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:node_name) { should == 'voice' }
       its(:name) { should be_nil }
 
       describe "setting options in initializers" do
-        subject { Voice.new :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul" }
+        subject { Voice.new doc, :language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul" }
 
         its(:language)  { should == 'jp' }
         its(:gender)    { should == :male }
@@ -102,42 +106,42 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language, gender, age, variant, name are the same" do
-          Voice.new(:language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello").should == Voice.new(:language => 'jp', :gender => :male, :age => 25, :variant => 2, :name => "paul", :content => "hello")
+          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")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Voice.new(:content => "Hello").should_not == Voice.new(:content => "Hello there")
+            Voice.new(doc, :content => "Hello").should_not == Voice.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Voice.new(:language => "Hello").should_not == Voice.new(:language => "Hello there")
+            Voice.new(doc, :language => "Hello").should_not == Voice.new(doc, :language => "Hello there")
           end
         end
 
         describe "when the gender is different" do
           it "should not be equal" do
-            Voice.new(:gender => :male).should_not == Voice.new(:gender => :female)
+            Voice.new(doc, :gender => :male).should_not == Voice.new(doc, :gender => :female)
           end
         end
 
         describe "when the age is different" do
           it "should not be equal" do
-            Voice.new(:age => 20).should_not == Voice.new(:age => 30)
+            Voice.new(doc, :age => 20).should_not == Voice.new(doc, :age => 30)
           end
         end
 
         describe "when the variant is different" do
           it "should not be equal" do
-            Voice.new(:variant => 1).should_not == Voice.new(:variant => 2)
+            Voice.new(doc, :variant => 1).should_not == Voice.new(doc, :variant => 2)
           end
         end
 
         describe "when the name is different" do
           it "should not be equal" do
-            Voice.new(:name => "Hello").should_not == Voice.new(:name => "Hello there")
+            Voice.new(doc, :name => "Hello").should_not == Voice.new(doc, :name => "Hello there")
           end
         end
       end
@@ -148,47 +152,47 @@ module RubySpeech
         end
 
         it "should accept Audio" do
-          lambda { subject << Audio.new }.should_not raise_error
+          lambda { subject << Audio.new(doc) }.should_not raise_error
         end
 
         it "should accept Break" do
-          lambda { subject << Break.new }.should_not raise_error
+          lambda { subject << Break.new(doc) }.should_not raise_error
         end
 
         it "should accept Emphasis" do
-          lambda { subject << Emphasis.new }.should_not raise_error
+          lambda { subject << Emphasis.new(doc) }.should_not raise_error
         end
 
         it "should accept Mark" do
-          lambda { subject << Mark.new }.should_not raise_error
+          lambda { subject << Mark.new(doc) }.should_not raise_error
         end
 
         it "should accept P" do
-          lambda { subject << P.new }.should_not raise_error
+          lambda { subject << P.new(doc) }.should_not raise_error
         end
 
         it "should accept Phoneme" do
-          lambda { subject << Phoneme.new }.should_not raise_error
+          lambda { subject << Phoneme.new(doc) }.should_not raise_error
         end
 
         it "should accept Prosody" do
-          lambda { subject << Prosody.new }.should_not raise_error
+          lambda { subject << Prosody.new(doc) }.should_not raise_error
         end
 
         it "should accept SayAs" do
-          lambda { subject << SayAs.new(:interpret_as => :foo) }.should_not raise_error
+          lambda { subject << SayAs.new(doc, :interpret_as => :foo) }.should_not raise_error
         end
 
         it "should accept Sub" do
-          lambda { subject << Sub.new }.should_not raise_error
+          lambda { subject << Sub.new(doc) }.should_not raise_error
         end
 
         it "should accept S" do
-          lambda { subject << S.new }.should_not raise_error
+          lambda { subject << S.new(doc) }.should_not raise_error
         end
 
         it "should accept Voice" do
-          lambda { subject << Voice.new }.should_not raise_error
+          lambda { subject << Voice.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do