ruby_speech 2.1.2 → 2.2.0

data/spec/ruby_speech/ssml/desc_spec.rb

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

data/spec/ruby_speech/ssml/emphasis_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Emphasis do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'emphasis' }
 
       describe "setting options in initializers" do
-        subject { Emphasis.new :level => :strong }
+        subject { Emphasis.new doc, :level => :strong }
 
         its(:level) { should == :strong }
       end
@@ -44,18 +48,18 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content and level are the same" do
-          Emphasis.new(:level => :strong, :content => "Hello there").should == Emphasis.new(:level => :strong, :content => "Hello there")
+          Emphasis.new(doc, :level => :strong, :content => "Hello there").should == Emphasis.new(doc, :level => :strong, :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Emphasis.new(:content => "Hello").should_not == Emphasis.new(:content => "Hello there")
+            Emphasis.new(doc, :content => "Hello").should_not == Emphasis.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the level is different" do
           it "should not be equal" do
-            Emphasis.new(:level => :strong).should_not == Emphasis.new(:level => :reduced)
+            Emphasis.new(doc, :level => :strong).should_not == Emphasis.new(doc, :level => :reduced)
           end
         end
       end
@@ -66,39 +70,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/mark_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Mark do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:node_name) { should == 'mark' }
 
       describe "setting options in initializers" do
-        subject { Mark.new :name => 'foo' }
+        subject { Mark.new doc, :name => 'foo' }
 
         its(:name)  { should == 'foo' }
       end
@@ -39,12 +43,12 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the name is the same" do
-          Mark.new(:name => "foo").should == Mark.new(:name => "foo")
+          Mark.new(doc, :name => "foo").should == Mark.new(doc, :name => "foo")
         end
 
         describe "when the name is different" do
           it "should not be equal" do
-            Mark.new(:name => "foo").should_not == Mark.new(:name => "bar")
+            Mark.new(doc, :name => "foo").should_not == Mark.new(doc, :name => "bar")
           end
         end
       end

data/spec/ruby_speech/ssml/p_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe P do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'p' }
 
       describe "setting options in initializers" do
-        subject { P.new :language => 'jp' }
+        subject { P.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
-          P.new(:language => 'jp', :content => "Hello there").should == P.new(:language => 'jp', :content => "Hello there")
+          P.new(doc, :language => 'jp', :content => "Hello there").should == P.new(doc, :language => 'jp', :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            P.new(:content => "Hello").should_not == P.new(:content => "Hello there")
+            P.new(doc, :content => "Hello").should_not == P.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            P.new(:language => 'jp').should_not == P.new(:language => 'en')
+            P.new(doc, :language => 'jp').should_not == P.new(doc, :language => 'en')
           end
         end
       end
@@ -48,43 +52,43 @@ 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 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

data/spec/ruby_speech/ssml/phoneme_spec.rb

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

data/spec/ruby_speech/ssml/prosody_spec.rb

@@ -3,16 +3,20 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Prosody do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'prosody' }
 
       describe "setting options in initializers" do
-        subject { Prosody.new :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10.seconds, :volume => :loud }
+        subject { Prosody.new doc, :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10, :volume => :loud }
 
         its(:pitch)     { should == :medium }
         its(:contour)   { should == 'something' }
         its(:range)     { should == '20Hz' }
         its(:rate)      { should == 2 }
-        its(:duration)  { should == 10.seconds }
+        its(:duration)  { should == 10 }
         its(:volume)    { should == :loud }
       end
 
@@ -31,7 +35,7 @@ module RubySpeech
         its(:contour)   { should == 'something' }
         its(:range)     { should == '20Hz' }
         its(:rate)      { should == 2 }
-        its(:duration)  { should == 10.seconds }
+        its(:duration)  { should == 10 }
         its(:volume)    { should == :loud }
       end
 
@@ -150,14 +154,14 @@ module RubySpeech
 
       describe "#duration" do
         context "with a valid value" do
-          before { subject.duration = 3.seconds }
+          before { subject.duration = 3 }
 
-          its(:duration) { should == 3.seconds }
+          its(:duration) { should == 3 }
         end
 
         context "with a negative value" do
           it do
-            lambda { subject.duration = -3.seconds }.should raise_error(ArgumentError, "You must specify a valid duration (positive float value in seconds)")
+            lambda { subject.duration = -3 }.should raise_error(ArgumentError, "You must specify a valid duration (positive float value in seconds)")
           end
         end
 
@@ -205,48 +209,48 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, strength and base uri are the same" do
-          Prosody.new(:pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10.seconds, :volume => :loud, :content => "Hello there").should == Prosody.new(:pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10.seconds, :volume => :loud, :content => "Hello there")
+          Prosody.new(doc, :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10, :volume => :loud, :content => "Hello there").should == Prosody.new(doc, :pitch => :medium, :contour => "something", :range => '20Hz', :rate => 2, :duration => 10, :volume => :loud, :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Prosody.new(:content => "Hello").should_not == Prosody.new(:content => "Hello there")
+            Prosody.new(doc, :content => "Hello").should_not == Prosody.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the pitch is different" do
           it "should not be equal" do
-            Prosody.new(:pitch => :medium).should_not == Prosody.new(:pitch => :high)
+            Prosody.new(doc, :pitch => :medium).should_not == Prosody.new(doc, :pitch => :high)
           end
         end
 
         describe "when the contour is different" do
           it "should not be equal" do
-            Prosody.new(:contour => 'foo').should_not == Prosody.new(:contour => 'bar')
+            Prosody.new(doc, :contour => 'foo').should_not == Prosody.new(doc, :contour => 'bar')
           end
         end
 
         describe "when the range is different" do
           it "should not be equal" do
-            Prosody.new(:range => '20Hz').should_not == Prosody.new(:range => '30Hz')
+            Prosody.new(doc, :range => '20Hz').should_not == Prosody.new(doc, :range => '30Hz')
           end
         end
 
         describe "when the rate is different" do
           it "should not be equal" do
-            Prosody.new(:rate => 2).should_not == Prosody.new(:rate => 3)
+            Prosody.new(doc, :rate => 2).should_not == Prosody.new(doc, :rate => 3)
           end
         end
 
         describe "when the duration is different" do
           it "should not be equal" do
-            Prosody.new(:duration => 10.seconds).should_not == Prosody.new(:duration => 20.seconds)
+            Prosody.new(doc, :duration => 10).should_not == Prosody.new(doc, :duration => 20)
           end
         end
 
         describe "when the volume is different" do
           it "should not be equal" do
-            Prosody.new(:volume => :loud).should_not == Prosody.new(:volume => :soft)
+            Prosody.new(doc, :volume => :loud).should_not == Prosody.new(doc, :volume => :soft)
           end
         end
       end
@@ -257,47 +261,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 S" do
-          lambda { subject << S.new }.should_not raise_error
+          lambda { subject << S.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