ruby_speech 2.1.2-java → 2.2.0-java

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

data/spec/ruby_speech/ssml_spec.rb

@@ -3,57 +3,60 @@ require 'spec_helper'
 module RubySpeech
   describe SSML do
     describe "#draw" do
+      let(:doc) { Nokogiri::XML::Document.new }
+
       it "should create an SSML document" do
-        expected_doc = SSML::Speak.new
+        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
       end
 
       it "can draw with a language" do
-        expected_doc = SSML::Speak.new language: 'pt-BR'
+        expected_doc = SSML::Speak.new doc, language: 'pt-BR'
         SSML.draw(language: 'pt-BR').should == 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(:content => "Hi, I'm Fred")
+          expected_doc = SSML::Speak.new(doc, :content => "Hi, I'm Fred")
           SSML.draw { "Hi, I'm Fred" }.should == 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
+          expected_doc = SSML::Speak.new doc
           SSML.draw { :foo }.should == expected_doc
         end
       end
 
       describe "when inserting a string" do
         it "should work" do
-          expected_doc = SSML::Speak.new(:content => "Hi, I'm Fred")
+          expected_doc = SSML::Speak.new(doc, :content => "Hi, I'm Fred")
           SSML.draw { string "Hi, I'm Fred" }.should == expected_doc
         end
       end
 
       it "should allow other SSML elements to be inserted in the document" do
-        doc = SSML.draw { voice :gender => :male, :name => 'fred' }
-        expected_doc = SSML::Speak.new
-        expected_doc << SSML::Voice.new(:gender => :male, :name => 'fred')
-        doc.should == expected_doc
+        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
       end
 
       it "should allow nested block return values" do
+        expected_doc = SSML::Speak.new doc
+        expected_doc << SSML::Voice.new(doc, :gender => :male, :name => 'fred', :content => "Hi, I'm Fred.")
+
         doc = RubySpeech::SSML.draw do
           voice :gender => :male, :name => 'fred' do
             "Hi, I'm Fred."
           end
         end
-        expected_doc = SSML::Speak.new
-        expected_doc << SSML::Voice.new(:gender => :male, :name => 'fred', :content => "Hi, I'm Fred.")
         doc.should == expected_doc
       end
 
       it "should allow nested SSML elements" do
-        doc = RubySpeech::SSML.draw do
+        drawn_doc = RubySpeech::SSML.draw do
           voice :gender => :male, :name => 'fred' do
             string "Hi, I'm Fred. The time is currently "
             say_as :interpret_as => 'date', :format => 'dmy' do
@@ -61,11 +64,12 @@ module RubySpeech
             end
           end
         end
-        voice = SSML::Voice.new(:gender => :male, :name => 'fred', :content => "Hi, I'm Fred. The time is currently ")
-        voice << SSML::SayAs.new(:interpret_as => 'date', :format => 'dmy', :content => "01/02/1960")
-        expected_doc = SSML::Speak.new
+
+        voice = SSML::Voice.new(doc, :gender => :male, :name => 'fred', :content => "Hi, I'm Fred. The time is currently ")
+        voice << SSML::SayAs.new(doc, :interpret_as => 'date', :format => 'dmy', :content => "01/02/1960")
+        expected_doc = SSML::Speak.new doc
         expected_doc << voice
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
 
       it "should allow accessing methods defined outside the block" do
@@ -73,12 +77,8 @@ module RubySpeech
           'bar'
         end
 
-        doc = SSML.draw do
-          string foo
-        end
-
-        expected_doc = SSML::Speak.new :content => foo
-        doc.should == expected_doc
+        expected_doc = SSML::Speak.new doc, :content => foo
+        SSML.draw { string foo }.should == expected_doc
       end
 
       describe "embedding" do
@@ -109,7 +109,7 @@ module RubySpeech
         end
 
         it "SSML elements" do
-          element = SSML::Emphasis.new(:content => "HELLO?")
+          element = SSML::Emphasis.new(doc, :content => "HELLO?")
 
           doc = RubySpeech::SSML.draw do
             voice :gender => :male, :name => 'fred' do
@@ -148,19 +148,19 @@ module RubySpeech
       end
 
       it "should properly escape string input" do
-        doc = RubySpeech::SSML.draw do
+        drawn_doc = RubySpeech::SSML.draw do
           voice { string "I <3 nachos." }
           voice { "I <3 nachos." }
         end
-        expected_doc = SSML::Speak.new
+        expected_doc = SSML::Speak.new doc
         2.times do
-          expected_doc << SSML::Voice.new(:native_content => "I <3 nachos.")
+          expected_doc << SSML::Voice.new(doc, :native_content => "I <3 nachos.")
         end
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
 
       it "should allow all permutations of possible nested SSML elements" do
-        doc = RubySpeech::SSML.draw do
+        drawn_doc = RubySpeech::SSML.draw do
           string "Hello world."
           ssml_break
           audio :src => "hello" do
@@ -211,56 +211,57 @@ module RubySpeech
             end
           end
         end
-        expected_doc = SSML::Speak.new(:content => "Hello world.")
-        expected_doc << SSML::Break.new
-        audio = SSML::Audio.new(:src => "hello", :content => "HELLO?")
-        audio << SSML::Break.new
-        audio << SSML::Audio.new(:src => "hello")
-        audio << SSML::Emphasis.new
-        audio << SSML::Prosody.new
-        audio << SSML::SayAs.new(:interpret_as => 'date')
-        audio << SSML::Voice.new
+        expected_doc = SSML::Speak.new(doc, :content => "Hello world.")
+        expected_doc << SSML::Break.new(doc)
+        audio = SSML::Audio.new(doc, :src => "hello", :content => "HELLO?")
+        audio << SSML::Break.new(doc)
+        audio << SSML::Audio.new(doc, :src => "hello")
+        audio << SSML::Emphasis.new(doc)
+        audio << SSML::Prosody.new(doc)
+        audio << SSML::SayAs.new(doc, :interpret_as => 'date')
+        audio << SSML::Voice.new(doc)
         expected_doc << audio
-        emphasis = SSML::Emphasis.new(:content => "HELLO?")
-        emphasis << SSML::Break.new
-        emphasis << SSML::Audio.new(:src => "hello")
-        emphasis << SSML::Emphasis.new
-        emphasis << SSML::Prosody.new
-        emphasis << SSML::SayAs.new(:interpret_as => 'date')
-        emphasis << SSML::Voice.new
+        emphasis = SSML::Emphasis.new(doc, :content => "HELLO?")
+        emphasis << SSML::Break.new(doc)
+        emphasis << SSML::Audio.new(doc, :src => "hello")
+        emphasis << SSML::Emphasis.new(doc)
+        emphasis << SSML::Prosody.new(doc)
+        emphasis << SSML::SayAs.new(doc, :interpret_as => 'date')
+        emphasis << SSML::Voice.new(doc)
         expected_doc << emphasis
-        prosody = SSML::Prosody.new(:rate => :slow, :content => "H...E...L...L...O?")
-        prosody << SSML::Break.new
-        prosody << SSML::Audio.new(:src => "hello")
-        prosody << SSML::Emphasis.new
-        prosody << SSML::Prosody.new
-        prosody << SSML::SayAs.new(:interpret_as => 'date')
-        prosody << SSML::Voice.new
+        prosody = SSML::Prosody.new(doc, :rate => :slow, :content => "H...E...L...L...O?")
+        prosody << SSML::Break.new(doc)
+        prosody << SSML::Audio.new(doc, :src => "hello")
+        prosody << SSML::Emphasis.new(doc)
+        prosody << SSML::Prosody.new(doc)
+        prosody << SSML::SayAs.new(doc, :interpret_as => 'date')
+        prosody << SSML::Voice.new(doc)
         expected_doc << prosody
-        expected_doc << SSML::SayAs.new(:interpret_as => 'date', :format => 'dmy', :content => "01/02/1960")
-        voice = SSML::Voice.new(:gender => :male, :name => 'fred', :content => "Hi, I'm Fred. The time is currently ")
-        voice << SSML::SayAs.new(:interpret_as => 'date', :format => 'dmy', :content => "01/02/1960")
-        voice << SSML::Break.new
-        voice << SSML::Audio.new(:src => "hello")
-        voice << SSML::Emphasis.new(:content => "I'm so old")
-        voice << SSML::Prosody.new(:rate => :fast, :content => "And yet so spritely!")
-        voice << SSML::Voice.new(:age => 12, :content => "And I'm young Fred")
+        expected_doc << SSML::SayAs.new(doc, :interpret_as => 'date', :format => 'dmy', :content => "01/02/1960")
+        voice = SSML::Voice.new(doc, :gender => :male, :name => 'fred', :content => "Hi, I'm Fred. The time is currently ")
+        voice << SSML::SayAs.new(doc, :interpret_as => 'date', :format => 'dmy', :content => "01/02/1960")
+        voice << SSML::Break.new(doc)
+        voice << SSML::Audio.new(doc, :src => "hello")
+        voice << SSML::Emphasis.new(doc, :content => "I'm so old")
+        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
-        doc.should == expected_doc
+        drawn_doc.should == expected_doc
       end
     end
 
     describe "importing nested tags" do
-      let(:say_as) { SSML::SayAs.new :interpret_as => 'date', :format => 'dmy', :content => "01/02/1960" }
+      let(:doc) { Nokogiri::XML::Document.new }
+      let(:say_as) { SSML::SayAs.new doc, :interpret_as => 'date', :format => 'dmy', :content => "01/02/1960" }
       let(:string) { "Hi, I'm Fred. The time is currently " }
       let :voice do
-        SSML::Voice.new(:gender => :male, :name => 'fred', :content => string).tap do |voice|
+        SSML::Voice.new(doc, :gender => :male, :name => 'fred', :content => string).tap do |voice|
           voice << say_as
         end
       end
 
       let :document do
-        SSML::Speak.new.tap { |doc| doc << voice }.to_s
+        SSML::Speak.new(doc).tap { |doc| doc << voice }.to_s
       end
 
       let(:import) { SSML.import document }

data/spec/spec_helper.rb

@@ -1,8 +1,5 @@
 require 'ruby_speech'
 
-include RubySpeech::GRXML
-include RubySpeech::XML::Language
-
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 
 schema_file_path = File.expand_path File.join(__FILE__, '../../assets/synthesis.xsd')

metadata

@@ -1,57 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ruby_speech
 version: !ruby/object:Gem::Version
+  version: 2.2.0
   prerelease:
-  version: 2.1.2
 platform: java
 authors:
 - Ben Langfeld
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-06-12 00:00:00.000000000 Z
+date: 2013-06-26 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: niceogiri
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.1.2
-    none: false
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.1.2
-    none: false
-  prerelease: false
-  type: :runtime
 - !ruby/object:Gem::Dependency
   name: nokogiri
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.5'
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.5.6
+        version: '1.6'
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.5'
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.5.6
+        version: '1.6'
     none: false
   prerelease: false
   type: :runtime
@@ -62,12 +34,18 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.7
+    - - <
+      - !ruby/object:Gem::Version
+        version: 5.0.0
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.7
+    - - <
+      - !ruby/object:Gem::Version
+        version: 5.0.0
     none: false
   prerelease: false
   type: :runtime
@@ -291,7 +269,6 @@ files:
 - lib/ruby_speech/ssml/sub.rb
 - lib/ruby_speech/ssml/voice.rb
 - lib/ruby_speech/version.rb
-- lib/ruby_speech/xml.rb
 - lib/ruby_speech/xml/language.rb
 - ruby_speech.gemspec
 - spec/ruby_speech/grxml/grammar_spec.rb
@@ -339,8 +316,8 @@ required_ruby_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       segments:
       - 0
-      hash: 2
       version: '0'
+      hash: 2
   none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
@@ -348,8 +325,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       segments:
       - 0
-      hash: 2
       version: '0'
+      hash: 2
   none: false
 requirements: []
 rubyforge_project: ruby_speech

data/lib/ruby_speech/xml.rb

@@ -1,11 +0,0 @@
-module RubySpeech
-  module XML
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Language
-    end
-  end # XML
-end # RubySpeech
-
-ActiveSupport::Autoload.eager_autoload!