ruby_speech 2.1.2 → 2.2.0

data/spec/ruby_speech/grxml/tag_spec.rb

@@ -3,6 +3,10 @@ require 'spec_helper'
 module RubySpeech
   module GRXML
     describe Tag do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'tag' }
 
       it 'registers itself' do
@@ -21,12 +25,12 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content is the same" do
-          Tag.new(:content => "hello").should == Tag.new(:content => "hello")
+          Tag.new(doc, :content => "hello").should == Tag.new(doc, :content => "hello")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Tag.new(:content => "Hello").should_not == Tag.new(:content => "Hello there")
+            Tag.new(doc, :content => "Hello").should_not == Tag.new(doc, :content => "Hello there")
           end
         end
       end

data/spec/ruby_speech/grxml/token_spec.rb

@@ -3,6 +3,10 @@ require 'spec_helper'
 module RubySpeech
   module GRXML
     describe Token do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'token' }
 
       it 'registers itself' do
@@ -37,12 +41,12 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content is the same" do
-          Token.new(:content => "hello").should == Token.new(:content => "hello")
+          Token.new(doc, :content => "hello").should == Token.new(doc, :content => "hello")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Token.new(:content => "Hello").should_not == Token.new(:content => "Hello there")
+            Token.new(doc, :content => "Hello").should_not == Token.new(doc, :content => "Hello there")
           end
         end
       end

data/spec/ruby_speech/grxml_spec.rb

@@ -3,8 +3,11 @@ require 'spec_helper'
 module RubySpeech
   describe GRXML do
     describe "#draw" do
+      let(:doc) { Nokogiri::XML::Document.new }
+
       it "should create a GRXML document" do
-        GRXML.draw.should == GRXML::Grammar.new
+        GRXML.draw.should == GRXML::Grammar.new(doc)
+        GRXML.draw.document.xpath('ns:grammar', ns: 'http://www.w3.org/2001/06/grammar').size.should == 1
       end
 
       context "with a root rule name specified but not found" do
@@ -15,25 +18,25 @@ module RubySpeech
                 '6'
               end
             end
-          end.should raise_error(InvalidChildError, "A GRXML document must have a rule matching the root rule name")
+          end.should raise_error(GRXML::InvalidChildError, "A GRXML document must have a rule matching the root rule name")
         end
       end
 
       # TODO: Maybe GRXML#draw should create a Rule to pass the string
       describe "when the return value of the block is a string" do
         it "should be inserted into the document" do
-          lambda { GRXML.draw { "Hello Fred" }}.should raise_error(InvalidChildError, "A Grammar can only accept Rule and Tag as children")
+          lambda { GRXML.draw { "Hello Fred" }}.should raise_error(GRXML::InvalidChildError, "A Grammar can only accept Rule and Tag as children")
         end
       end
 
       it "should allow other GRXML elements to be inserted in the document" do
-        doc = GRXML.draw(:mode => :voice, :root => 'main') { rule :id => :main, :content => "Hello Fred" }
+        drawn_doc = GRXML.draw(:mode => :voice, :root => 'main') { rule :id => :main, :content => "Hello Fred" }
 
-        expected_doc = GRXML::Grammar.new(:mode => :voice, :root => 'main')
-        rule = GRXML::Rule.new(:id => "main")
+        expected_doc = GRXML::Grammar.new(doc, :mode => :voice, :root => 'main')
+        rule = GRXML::Rule.new(doc, :id => "main")
         rule << "Hello Fred"
         expected_doc << rule
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
 
       it "should allow accessing methods defined outside the block" do
@@ -41,14 +44,14 @@ module RubySpeech
           'bar'
         end
 
-        doc = GRXML.draw do
+        drawn_doc = GRXML.draw do
           rule :id => foo
         end
 
-        expected_doc = GRXML::Grammar.new
-        rule = GRXML::Rule.new(:id => foo)
+        expected_doc = GRXML::Grammar.new doc
+        rule = GRXML::Rule.new(doc, :id => foo)
         expected_doc << rule
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
 
       it "should raise error if given an empty rule" do
@@ -57,18 +60,18 @@ module RubySpeech
       end
 
       it "should allow nested block return values" do
-        doc = RubySpeech::GRXML.draw do
+        drawn_doc = RubySpeech::GRXML.draw do
           rule :scope => 'public', :id => :main do
             "Hello Fred"
           end
         end
-        expected_doc = GRXML::Grammar.new
-        expected_doc << GRXML::Rule.new(:scope => :public, :id => :main, :content => "Hello Fred")
-        doc.should == expected_doc
+        expected_doc = GRXML::Grammar.new doc
+        expected_doc << GRXML::Rule.new(doc, :scope => :public, :id => :main, :content => "Hello Fred")
+        drawn_doc.should == expected_doc
       end
 
       it "should allow nested GRXML elements" do
-        doc = RubySpeech::GRXML.draw do
+        drawn_doc = RubySpeech::GRXML.draw do
           rule :id => :main, :scope => 'public' do
             string "Hello Fred. I like ninjas and pirates"
             one_of do
@@ -77,14 +80,14 @@ module RubySpeech
             end
           end
         end
-        rule = GRXML::Rule.new(:id => :main, :scope => 'public', :content => "Hello Fred. I like ninjas and pirates")
-        oneof = GRXML::OneOf.new
-        oneof << GRXML::Item.new(:content => "ninja")
-        oneof << GRXML::Item.new(:content => "pirate")
+        rule = GRXML::Rule.new(doc, :id => :main, :scope => 'public', :content => "Hello Fred. I like ninjas and pirates")
+        oneof = GRXML::OneOf.new doc
+        oneof << GRXML::Item.new(doc, :content => "ninja")
+        oneof << GRXML::Item.new(doc, :content => "pirate")
         rule << oneof
-        expected_doc = GRXML::Grammar.new
+        expected_doc = GRXML::Grammar.new doc
         expected_doc << rule
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
 
       # TODO: maybe turn a rule embedded in anthoer rule into a ruleref??
@@ -143,13 +146,13 @@ module RubySpeech
             end
 
             it "should raise an exception" do
-              lambda { voice_doc }.should raise_error(InvalidChildError, "Embedded grammars must have the same mode")
+              lambda { voice_doc }.should raise_error(GRXML::InvalidChildError, "Embedded grammars must have the same mode")
             end
           end
         end
 
         it "GRXML elements" do
-          element = GRXML::Item.new :content => "HELLO?"
+          element = GRXML::Item.new doc, :content => "HELLO?"
 
           doc = RubySpeech::GRXML.draw do
             rule :id => :main, :scope => 'public' do
@@ -188,23 +191,23 @@ module RubySpeech
       end
 
       it "should properly escape string input" do
-        doc = RubySpeech::GRXML.draw do
+        drawn_doc = RubySpeech::GRXML.draw do
           rule { string "I <3 nachos." }
           rule { "I <3 nachos." }
           rule { 'I <3 nachos.' }
         end
-        expected_doc = GRXML::Grammar.new
+        expected_doc = GRXML::Grammar.new doc
         3.times do
-          expected_doc << GRXML::Rule.new(:native_content => "I <3 nachos.")
+          expected_doc << GRXML::Rule.new(doc, :native_content => "I <3 nachos.")
         end
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
 
       # TODO: verfify rule is in document if named in a ruleref
       # TODO: ruleref must have named rule id
 
       it "should allow all permutations of possible nested GRXML elements" do
-        doc = RubySpeech::GRXML.draw do
+        drawn_doc = RubySpeech::GRXML.draw do
           rule :id => "hello" do
             string "HELLO?"
             item :weight => 2.5
@@ -229,43 +232,44 @@ module RubySpeech
             one_of { item { "single item" } }
           end
         end
-        expected_doc = GRXML::Grammar.new
-        rule = GRXML::Rule.new(:id => "hello", :content => "HELLO?")
-        rule << GRXML::Item.new(:weight => 2.5)
-        oneof = GRXML::OneOf.new
-        1.upto(2) { |d| oneof << GRXML::Item.new(:content => d.to_s) }
+        expected_doc = GRXML::Grammar.new doc
+        rule = GRXML::Rule.new(doc, :id => "hello", :content => "HELLO?")
+        rule << GRXML::Item.new(doc, :weight => 2.5)
+        oneof = GRXML::OneOf.new doc
+        1.upto(2) { |d| oneof << GRXML::Item.new(doc, :content => d.to_s) }
         rule << oneof
-        rule << GRXML::Ruleref.new(:uri => '#test')
-        rule << GRXML::Item.new(:content => "last")
+        rule << GRXML::Ruleref.new(doc, :uri => '#test')
+        rule << GRXML::Item.new(doc, :content => "last")
         expected_doc << rule
 
-        rule = GRXML::Rule.new(:id => "test", :content => "TESTING")
+        rule = GRXML::Rule.new(doc, :id => "test", :content => "TESTING")
         expected_doc << rule
 
-        rule = GRXML::Rule.new(:id => "hello2")
-        rule << GRXML::Item.new(:weight => 5.5, :content => "hello")
+        rule = GRXML::Rule.new(doc, :id => "hello2")
+        rule << GRXML::Item.new(doc, :weight => 5.5, :content => "hello")
         rule << "H...E...L...L...O?"
-        rule << GRXML::Token.new(:content => "test token")
-        rule << GRXML::Tag.new
-        rule << GRXML::Item.new
-        oneof = GRXML::OneOf.new
-        oneof << GRXML::Item.new(:content => "single item")
+        rule << GRXML::Token.new(doc, :content => "test token")
+        rule << GRXML::Tag.new(doc)
+        rule << GRXML::Item.new(doc)
+        oneof = GRXML::OneOf.new doc
+        oneof << GRXML::Item.new(doc, :content => "single item")
         rule << oneof
         expected_doc << rule
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
 
       describe "importing nested tags" do
-        let(:item) { GRXML::Item.new(:weight => 1.5, :content => "Are you a pirate or ninja?") }
+        let(:doc) { Nokogiri::XML::Document.new }
+        let(:item) { GRXML::Item.new(doc, :weight => 1.5, :content => "Are you a pirate or ninja?") }
         let(:string) { "Hello Fred. I like pirates and ninjas " }
         let :rule do
-          GRXML::Rule.new(:id => :main, :scope => 'public', :content => string).tap do |rule|
+          GRXML::Rule.new(doc, :id => :main, :scope => 'public', :content => string).tap do |rule|
             rule << item
           end
         end
 
         let :document do
-          GRXML::Grammar.new.tap { |doc| doc << rule }.to_s
+          GRXML::Grammar.new(doc).tap { |doc| doc << rule }.to_s
         end
 
         let(:import) { GRXML.import document }
@@ -287,14 +291,14 @@ module RubySpeech
       end
 
       it "should allow finding direct children of a particular type, matching certain attributes" do
-        item = GRXML::Item.new
-        item1 = GRXML::Item.new :weight => 0.5
-        item11 = GRXML::Item.new :weight => 0.5
+        item = GRXML::Item.new doc
+        item1 = GRXML::Item.new doc, :weight => 0.5
+        item11 = GRXML::Item.new doc, :weight => 0.5
         item1 << item11
         item << item1
-        item2 = GRXML::Item.new :weight => 0.7
+        item2 = GRXML::Item.new doc, :weight => 0.7
         item << item2
-        tag = GRXML::Tag.new
+        tag = GRXML::Tag.new doc
         item << tag
 
         item.children(:item, :weight => 0.5).should == [item1]
@@ -318,22 +322,6 @@ module RubySpeech
         text = item.nokogiri_children.first
         text.parent.should == item
       end
-    end # draw
-
-    describe "manually created documents" do
-      it "should be able to traverse up the tree" do
-        grammar = GRXML::Grammar.new
-        rule    = GRXML::Rule.new :id => 'one'
-        item    = GRXML::Item.new
-        text    = Nokogiri::XML::Text.new 'foobar', grammar.document
-        item    << text
-        rule    << item
-        grammar << rule
-
-        text.parent.should == item
-        item.parent.should == rule
-        rule.parent.should == grammar
-      end
     end
   end # GRXML
 end # RubySpeech

data/spec/ruby_speech/ssml/audio_spec.rb

@@ -3,10 +3,14 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Audio do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'audio' }
 
       describe "setting options in initializers" do
-        subject { Audio.new :src => 'http://whatever.you-say-boss.com', :content => 'Hello' }
+        subject { Audio.new doc, :src => 'http://whatever.you-say-boss.com', :content => 'Hello' }
 
         its(:src)     { should == 'http://whatever.you-say-boss.com' }
         its(:content) { should == 'Hello' }
@@ -47,51 +51,51 @@ 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 Desc" do
-          lambda { subject << Desc.new }.should_not raise_error
+          lambda { subject << Desc.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
@@ -101,18 +105,18 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, and src are the same" do
-          Audio.new(:src => "one", :content => "Hello there").should == Audio.new(:src => "one", :content => "Hello there")
+          Audio.new(doc, :src => "one", :content => "Hello there").should == Audio.new(doc, :src => "one", :content => "Hello there")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Audio.new(:content => "Hello").should_not == Audio.new(:content => "Hello there")
+            Audio.new(doc, :content => "Hello").should_not == Audio.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the src is different" do
           it "should not be equal" do
-            Audio.new(:src => 'one').should_not == Audio.new(:src => 'two')
+            Audio.new(doc, :src => 'one').should_not == Audio.new(doc, :src => 'two')
           end
         end
       end

data/spec/ruby_speech/ssml/break_spec.rb

@@ -3,13 +3,17 @@ require 'spec_helper'
 module RubySpeech
   module SSML
     describe Break do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'break' }
 
       describe "setting options in initializers" do
-        subject { Break.new :strength => :strong, :time => 3.seconds }
+        subject { Break.new doc, :strength => :strong, :time => 3 }
 
         its(:strength)  { should == :strong }
-        its(:time)      { should == 3.seconds }
+        its(:time)      { should == 3 }
       end
 
       it 'registers itself' do
@@ -24,7 +28,7 @@ module RubySpeech
         it { should be_instance_of Break }
 
         its(:strength)  { should == :strong }
-        its(:time)      { should == 3.seconds }
+        its(:time)      { should == 3 }
       end
 
       describe "#strength" do
@@ -48,14 +52,14 @@ module RubySpeech
 
       describe "#time" do
         context "with a valid value" do
-          before { subject.time = 3.seconds }
+          before { subject.time = 3 }
 
-          its(:time) { should == 3.seconds }
+          its(:time) { should == 3 }
         end
 
         context "with a negative value" do
           it do
-            lambda { subject.time = -3.seconds }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
+            lambda { subject.time = -3 }.should raise_error(ArgumentError, "You must specify a valid time (positive float value in seconds)")
           end
         end
 
@@ -74,24 +78,24 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, strength and base uri are the same" do
-          Break.new(:strength => :strong, :time => 1.second, :content => "Hello there").should == Break.new(:strength => :strong, :time => 1.second, :content => "Hello there")
+          Break.new(doc, :strength => :strong, :time => 1, :content => "Hello there").should == 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(:content => "Hello").should_not == Break.new(:content => "Hello there")
+            Break.new(doc, :content => "Hello").should_not == Break.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the strength is different" do
           it "should not be equal" do
-            Break.new(:strength => :strong).should_not == Break.new(:strength => :weak)
+            Break.new(doc, :strength => :strong).should_not == Break.new(doc, :strength => :weak)
           end
         end
 
         describe "when the time is different" do
           it "should not be equal" do
-            Break.new(:time => 1.second).should_not == Break.new(:time => 2.seconds)
+            Break.new(doc, :time => 1).should_not == Break.new(doc, :time => 2)
           end
         end
       end