ruby_speech 2.1.2 → 2.2.0

data/lib/ruby_speech/ssml/say_as.rb

@@ -1,3 +1,5 @@
+require 'ruby_speech/ssml/element'
+
 module RubySpeech
   module SSML
     ##

data/lib/ruby_speech/ssml/speak.rb

@@ -1,3 +1,6 @@
+require 'ruby_speech/ssml/element'
+require 'ruby_speech/xml/language'
+
 module RubySpeech
   module SSML
     ##
@@ -6,11 +9,26 @@ module RubySpeech
     # http://www.w3.org/TR/speech-synthesis/#S3.1.1
     #
     class Speak < Element
+
+      %w{
+        audio
+        break
+        desc
+        emphasis
+        mark
+        phoneme
+        prosody
+        s
+        say_as
+        sub
+        voice
+      }.each { |f| require "ruby_speech/ssml/#{f}" }
+
       include XML::Language
 
       register :speak
 
-      self.defaults = { :version => '1.0', :language => "en-US" }
+      self.defaults = { :version => '1.0', :language => "en-US", namespace: SSML_NAMESPACE }
 
       VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, S, SayAs, Sub, Voice].freeze
 

data/lib/ruby_speech/ssml/sub.rb

@@ -1,3 +1,5 @@
+require 'ruby_speech/ssml/element'
+
 module RubySpeech
   module SSML
     ##

data/lib/ruby_speech/ssml/voice.rb

@@ -1,3 +1,6 @@
+require 'ruby_speech/ssml/element'
+require 'ruby_speech/xml/language'
+
 module RubySpeech
   module SSML
     ##
@@ -6,6 +9,22 @@ module RubySpeech
     # http://www.w3.org/TR/speech-synthesis/#S3.2.1
     #
     class Voice < Element
+
+      %w{
+        audio
+        break
+        desc
+        emphasis
+        mark
+        p
+        phoneme
+        prosody
+        s
+        say_as
+        speak
+        sub
+      }.each { |f| require "ruby_speech/ssml/#{f}" }
+
       include XML::Language
 
       register :voice

data/lib/ruby_speech/version.rb

@@ -1,3 +1,3 @@
 module RubySpeech
-  VERSION = "2.1.2"
+  VERSION = "2.2.0"
 end

data/ruby_speech.gemspec

@@ -25,9 +25,8 @@ Gem::Specification.new do |s|
     s.extensions = ['ext/ruby_speech/extconf.rb']
   end
 
-  s.add_runtime_dependency %q<niceogiri>, ["~> 1.1", ">= 1.1.2"]
-  s.add_runtime_dependency %q<nokogiri>, ["~> 1.5", ">= 1.5.6"]
-  s.add_runtime_dependency %q<activesupport>, [">= 3.0.7"]
+  s.add_runtime_dependency %q<nokogiri>, ["~> 1.6"]
+  s.add_runtime_dependency %q<activesupport>, [">= 3.0.7", "< 5.0.0"]
 
   s.add_development_dependency %q<bundler>, [">= 1.0.0"]
   s.add_development_dependency %q<rspec>, [">= 2.7"]

data/spec/ruby_speech/grxml/grammar_spec.rb

@@ -3,13 +3,17 @@ require 'spec_helper'
 module RubySpeech
   module GRXML
     describe Grammar do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       it { should be_a_valid_grxml_document }
 
       its(:name)      { should == 'grammar' }
       its(:language)  { should == 'en-US' }
 
       describe "setting options in initializers" do
-        subject { Grammar.new :language => 'jp', :base_uri => 'blah', :root => "main_rule", :tag_format => "semantics/1.0" }
+        subject { Grammar.new doc, :language => 'jp', :base_uri => 'blah', :root => "main_rule", :tag_format => "semantics/1.0" }
 
         its(:language)    { should == 'jp' }
         its(:base_uri)    { should == 'blah' }
@@ -18,14 +22,14 @@ module RubySpeech
       end
 
       describe "setting dtmf mode" do
-        subject       { Grammar.new :mode => 'dtmf' }
+        subject       { Grammar.new doc, :mode => 'dtmf' }
         its(:mode)    { should == :dtmf }
         its(:dtmf?)   { should be true }
         its(:voice?)  { should be false }
       end
 
       describe "setting voice mode" do
-        subject       { Grammar.new :mode => 'voice' }
+        subject       { Grammar.new doc, :mode => 'voice' }
         its(:mode)    { should == :voice }
         its(:voice?)  { should be true }
         its(:dtmf?)   { should be false }
@@ -66,33 +70,33 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language and base uri are the same" do
-          Grammar.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there").should == Grammar.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there")
+          Grammar.new(doc, :language => 'en-GB', :base_uri => 'blah', :content => "Hello there").should == Grammar.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
-            Grammar.new(:content => "Hello").should_not == Grammar.new(:content => "Hello there")
+            Grammar.new(doc, :content => "Hello").should_not == Grammar.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Grammar.new(:language => 'en-US').should_not == Grammar.new(:language => 'en-GB')
+            Grammar.new(doc, :language => 'en-US').should_not == Grammar.new(doc, :language => 'en-GB')
           end
         end
 
         describe "when the base URI is different" do
           it "should not be equal" do
-            Grammar.new(:base_uri => 'foo').should_not == Grammar.new(:base_uri => 'bar')
+            Grammar.new(doc, :base_uri => 'foo').should_not == Grammar.new(doc, :base_uri => 'bar')
           end
         end
 
         describe "when the children are different" do
           it "should not be equal" do
-            g1 = Grammar.new
-            g1 << Rule.new(:id => 'main1')
-            g2 = Grammar.new
-            g2 << Rule.new(:id => 'main2')
+            g1 = Grammar.new doc
+            g1 << Rule.new(doc, :id => 'main1')
+            g2 = Grammar.new doc
+            g2 << Rule.new(doc, :id => 'main2')
 
             g1.should_not == g2
           end
@@ -100,20 +104,20 @@ module RubySpeech
       end
 
       it "should allow creating child GRXML elements" do
-        g = Grammar.new
-        g.Rule :id => :main, :scope => 'public'
-        expected_g = Grammar.new
-        expected_g << Rule.new(:id => :main, :scope => 'public')
+        g = Grammar.new doc
+        g.rule :id => :main, :scope => 'public'
+        expected_g = Grammar.new doc
+        expected_g << Rule.new(doc, :id => :main, :scope => 'public')
         g.should == expected_g
       end
 
       describe "<<" do
         it "should accept Rule" do
-          lambda { subject << Rule.new }.should_not raise_error
+          lambda { subject << Rule.new(doc) }.should_not raise_error
         end
 
         it "should accept Tag" do
-          lambda { subject << Tag.new }.should_not raise_error
+          lambda { subject << Tag.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
@@ -135,26 +139,27 @@ module RubySpeech
 
       describe "concat" do
         it "should allow concatenation" do
-          grammar1 = Grammar.new
-          grammar1 << Rule.new(:id => 'frank', :scope => 'public', :content => "Hi Frank")
-          grammar2 = Grammar.new
-          grammar2 << Rule.new(:id => 'millie', :scope => 'public', :content => "Hi Millie")
+          grammar1 = Grammar.new doc
+          grammar1 << Rule.new(doc, :id => 'frank', :scope => 'public', :content => "Hi Frank")
+          grammar2 = Grammar.new doc
+          grammar2 << Rule.new(doc, :id => 'millie', :scope => 'public', :content => "Hi Millie")
 
-          expected_concat = Grammar.new
-          expected_concat << Rule.new(:id => 'frank', :scope => 'public', :content => "Hi Frank")
-          expected_concat << Rule.new(:id => 'millie', :scope => 'public', :content => "Hi Millie")
+          expected_concat = Grammar.new doc
+          expected_concat << Rule.new(doc, :id => 'frank', :scope => 'public', :content => "Hi Frank")
+          expected_concat << Rule.new(doc, :id => 'millie', :scope => 'public', :content => "Hi Millie")
 
           concat = grammar1 + grammar2
           concat.should == expected_concat
+          concat.document.root.should == concat
           concat.to_s.should_not include('default')
         end
       end
 
       it "should allow finding its root rule" do
-        grammar = GRXML::Grammar.new :root => 'foo'
-        bar = GRXML::Rule.new :id => 'bar'
+        grammar = GRXML::Grammar.new doc, :root => 'foo'
+        bar = GRXML::Rule.new doc, :id => 'bar'
         grammar << bar
-        foo = GRXML::Rule.new :id => 'foo'
+        foo = GRXML::Rule.new doc, :id => 'foo'
         grammar << foo
 
         grammar.root_rule.should == foo
@@ -229,7 +234,7 @@ module RubySpeech
 
         let(:tokenized_version) do
           expected_tokens = Array(tokens).map do |s|
-            Token.new.tap { |t| t << s }
+            Token.new(doc).tap { |t| t << s }
           end
           single_rule_grammar expected_tokens
         end
@@ -291,7 +296,7 @@ module RubySpeech
         end
 
         context "with a single XML token" do
-          let(:content) { [Token.new.tap { |t| t << 'San Francisco' }] }
+          let(:content) { [Token.new(doc).tap { |t| t << 'San Francisco' }] }
           let(:tokens)  { ['San Francisco'] }
 
           it "should tokenize correctly" do
@@ -303,7 +308,7 @@ module RubySpeech
           let(:content) do
             [
               'Welcome to "San Francisco"',
-              Token.new.tap { |t| t << 'Have Fun!' }
+              Token.new(doc).tap { |t| t << 'Have Fun!' }
             ]
           end
 

data/spec/ruby_speech/grxml/item_spec.rb

@@ -3,7 +3,9 @@ require 'spec_helper'
 module RubySpeech
   module GRXML
     describe Item do
-      subject { Item.new :weight => 1.1, :repeat => '1' }
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { Item.new doc, :weight => 1.1, :repeat => '1' }
 
       its(:name) { should == 'item' }
 
@@ -168,23 +170,23 @@ module RubySpeech
         end
 
         it "should accept OneOf" do
-          lambda { subject << OneOf.new }.should_not raise_error
+          lambda { subject << OneOf.new(doc) }.should_not raise_error
         end
 
         it "should accept Item" do
-          lambda { subject << Item.new }.should_not raise_error
+          lambda { subject << Item.new(doc) }.should_not raise_error
         end
 
         it "should accept Ruleref" do
-          lambda { subject << Ruleref.new }.should_not raise_error
+          lambda { subject << Ruleref.new(doc) }.should_not raise_error
         end
 
         it "should accept Tag" do
-          lambda { subject << Tag.new }.should_not raise_error
+          lambda { subject << Tag.new(doc) }.should_not raise_error
         end
 
         it "should accept Token" do
-          lambda { subject << Token.new }.should_not raise_error
+          lambda { subject << Token.new(doc) }.should_not raise_error
         end
       end
     end # Item

data/spec/ruby_speech/grxml/one_of_spec.rb

@@ -3,6 +3,10 @@ require 'spec_helper'
 module RubySpeech
   module GRXML
     describe OneOf do
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { described_class.new doc }
+
       its(:name) { should == 'one-of' }
 
       it 'registers itself' do
@@ -25,7 +29,7 @@ module RubySpeech
 
       describe "<<" do
         it "should accept Item" do
-          lambda { subject << Item.new }.should_not raise_error
+          lambda { subject << Item.new(doc) }.should_not raise_error
         end
 
         it "should raise InvalidChildError with non-acceptable objects" do
@@ -35,12 +39,12 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the language (when specified) is the same" do
-          OneOf.new(:language => "jp").should == OneOf.new(:language => "jp")
+          OneOf.new(doc, :language => "jp").should == OneOf.new(doc, :language => "jp")
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            OneOf.new(:language => "jp").should_not == OneOf.new(:content => "fr-CA")
+            OneOf.new(doc, :language => "jp").should_not == OneOf.new(doc, :content => "fr-CA")
           end
         end
       end

data/spec/ruby_speech/grxml/rule_spec.rb

@@ -3,7 +3,9 @@ require 'spec_helper'
 module RubySpeech
   module GRXML
     describe Rule do
-      subject { Rule.new :id => 'one', :scope => 'public' }
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { Rule.new doc, :id => 'one', :scope => 'public' }
 
       its(:name) { should == 'rule' }
 
@@ -63,30 +65,30 @@ module RubySpeech
 
       describe "comparing objects" do
         it "should be equal if the content, language, id, and scope are the same" do
-          Rule.new(:language => 'jp', :id => :main, :scope => :public, :content => "hello").should == Rule.new(:language => 'jp', :id => :main, :scope => :public, :content => "hello")
+          Rule.new(doc, :language => 'jp', :id => :main, :scope => :public, :content => "hello").should == Rule.new(doc, :language => 'jp', :id => :main, :scope => :public, :content => "hello")
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Rule.new(:content => "Hello").should_not == Rule.new(:content => "Hello there")
+            Rule.new(doc, :content => "Hello").should_not == Rule.new(doc, :content => "Hello there")
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Rule.new(:language => "jp").should_not == Rule.new(:language => "esperanto")
+            Rule.new(doc, :language => "jp").should_not == Rule.new(doc, :language => "esperanto")
           end
         end
 
         describe "when the id is different" do
           it "should not be equal" do
-            Rule.new(:id => :main).should_not == Rule.new(:id => :dtmf)
+            Rule.new(doc, :id => :main).should_not == Rule.new(doc, :id => :dtmf)
           end
         end
 
         describe "when the scope is different" do
           it "should not be equal" do
-            Rule.new(:scope => :public).should_not == Rule.new(:scope => :private)
+            Rule.new(doc, :scope => :public).should_not == Rule.new(doc, :scope => :private)
           end
         end
       end
@@ -97,28 +99,28 @@ module RubySpeech
         end
 
         it "should accept OneOf" do
-          lambda { subject << OneOf.new }.should_not raise_error
+          lambda { subject << OneOf.new(doc) }.should_not raise_error
         end
 
         it "should accept Item" do
-          lambda { subject << Item.new }.should_not raise_error
+          lambda { subject << Item.new(doc) }.should_not raise_error
         end
 
         it "should accept Ruleref" do
-          lambda { subject << Ruleref.new }.should_not raise_error
+          lambda { subject << Ruleref.new(doc) }.should_not raise_error
         end
 
         it "should accept Tag" do
-          lambda { subject << Tag.new }.should_not raise_error
+          lambda { subject << Tag.new(doc) }.should_not raise_error
         end
 
         it "should accept Token" do
-          lambda { subject << Token.new }.should_not raise_error
+          lambda { subject << Token.new(doc) }.should_not raise_error
         end
       end
 
       it "should raise ArgumentError with any other scope" do
-        lambda { Rule.new :id => 'one', :scope => 'invalid_scope' }.should raise_error(ArgumentError, "A Rule's scope can only be 'public' or 'private'")
+        lambda { Rule.new doc, :id => 'one', :scope => 'invalid_scope' }.should raise_error(ArgumentError, "A Rule's scope can only be 'public' or 'private'")
       end
     end # Rule
   end # GRXML

data/spec/ruby_speech/grxml/ruleref_spec.rb

@@ -3,7 +3,9 @@ require 'spec_helper'
 module RubySpeech
   module GRXML
     describe Ruleref do
-      subject { Ruleref.new :uri => '#testrule' }
+      let(:doc) { Nokogiri::XML::Document.new }
+
+      subject { Ruleref.new doc, :uri => '#testrule' }
 
       its(:name)  { should == 'ruleref' }
       its(:uri)   { should == '#testrule' }
@@ -23,7 +25,7 @@ module RubySpeech
       end
 
       describe "#special" do
-        subject { Ruleref.new }
+        subject { Ruleref.new doc }
 
         context "with reserved values" do
           it "with a valid value" do
@@ -47,7 +49,7 @@ module RubySpeech
 
       describe "only uri or special can be specified" do
         it "should raise an error" do
-          lambda { subject << Ruleref.new(:uri => '#test', :special => :NULL) }.should raise_error(ArgumentError, "A Ruleref can only take uri or special")
+          lambda { subject << Ruleref.new(doc, :uri => '#test', :special => :NULL) }.should raise_error(ArgumentError, "A Ruleref can only take uri or special")
         end
       end
     end # Ruleref