ruby_speech 0.4.0 → 0.5.0

data/lib/ruby_speech/ssml/s.rb

@@ -0,0 +1,25 @@
+module RubySpeech
+  module SSML
+    ##
+    # As s element represents a sentence.
+    # The use of s elements is optional. Where text occurs without an enclosing s element the synthesis processor should attempt to determine the structure using language-specific knowledge of the format of plain text.
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.1.7
+    #
+    class S < Element
+
+      register :s
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice].freeze
+
+      def <<(arg)
+        raise InvalidChildError, "An S can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice as children" unless VALID_CHILD_TYPES.include? arg.class
+        super
+      end
+
+      def eql?(o)
+        super o, :language
+      end
+    end # S
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/say_as.rb

@@ -26,17 +26,6 @@ module RubySpeech
 
       VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String].freeze
 
-      ##
-      # Create a new SSML say-as element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Prosody] an element for use in an SSML document
-      #
-      def self.new(atts = {}, &block)
-        super 'say-as', atts, &block
-      end
-
       ##
       #
       # The interpret-as attribute indicates the content type of the contained text construct. Specifying the content type helps the synthesis processor to distinguish and interpret text constructs that may be rendered in different ways depending on what type of information is intended.

data/lib/ruby_speech/ssml/speak.rb

@@ -10,57 +10,15 @@ module RubySpeech
 
       register :speak
 
-      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Prosody, SayAs, Voice].freeze
+      self.defaults = { :version => '1.0', :language => "en-US" }
 
-      ##
-      # Create a new SSML speak root element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Speak] an element for use in an SSML document
-      #
-      def self.new(atts = {}, &block)
-        new_node = super('speak', atts)
-        new_node[:version] = '1.0'
-        new_node.namespace = SSML_NAMESPACE
-        new_node.language ||= "en-US"
-        new_node.eval_dsl_block &block
-        new_node
-      end
-
-      ##
-      # @return [String] the base URI to which relative URLs are resolved
-      #
-      def base_uri
-        read_attr :base
-      end
-
-      ##
-      # @param [String] uri the base URI to which relative URLs are resolved
-      #
-      def base_uri=(uri)
-        write_attr 'xml:base', uri
-      end
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, S, SayAs, Sub, Voice].freeze
 
       def <<(arg)
         raise InvalidChildError, "A Speak can only accept String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, SayAs, Sub, S, Voice as children" unless VALID_CHILD_TYPES.include? arg.class
         super
       end
 
-      def to_doc
-        Nokogiri::XML::Document.new.tap do |doc|
-          doc << self
-        end
-      end
-
-      def +(other)
-        self.class.new(:base_uri => base_uri).tap do |new_speak|
-          (self.children + other.children).each do |child|
-            new_speak << child
-          end
-        end
-      end
-
       def eql?(o)
         super o, :language, :base_uri
       end

data/lib/ruby_speech/ssml/sub.rb

@@ -0,0 +1,42 @@
+module RubySpeech
+  module SSML
+    ##
+    # The sub element is employed to indicate that the text in the alias attribute value replaces the contained text for pronunciation. This allows a document to contain both a spoken and written form. The required alias attribute specifies the string to be spoken instead of the enclosed string. The processor should apply text normalization to the alias value.
+    #
+    # The sub element can only contain text (no elements).
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.1.10
+    #
+    class Sub < Element
+
+      register :sub
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Text, String].freeze
+
+      ##
+      # Indicates the string to be spoken instead of the enclosed string
+      #
+      # @return [String]
+      #
+      def alias
+        read_attr :alias
+      end
+
+      ##
+      # @param [String] other the string to be spoken instead of the enclosed string
+      #
+      def alias=(other)
+        write_attr :alias, other
+      end
+
+      def <<(arg)
+        raise InvalidChildError, "A Sub can only accept Strings as children" unless VALID_CHILD_TYPES.include? arg.class
+        super
+      end
+
+      def eql?(o)
+        super o, :alias
+      end
+    end # Sub
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/voice.rb

@@ -11,18 +11,7 @@ module RubySpeech
       register :voice
 
       VALID_GENDERS = [:male, :female, :neutral].freeze
-      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio,Break, Emphasis, Prosody, SayAs, Voice].freeze
-
-      ##
-      # Create a new SSML voice element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Voice] an element for use in an SSML document
-      #
-      def self.new(atts = {}, &block)
-        super 'voice', atts, &block
-      end
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, S, SayAs, Sub, Voice].freeze
 
       ##
       # Indicates the preferred gender of the voice to speak the contained text. Enumerated values are: "male", "female", "neutral".

data/lib/ruby_speech/version.rb

@@ -1,3 +1,3 @@
 module RubySpeech
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/spec/ruby_speech/grxml/grammar_spec.rb

@@ -18,13 +18,17 @@ module RubySpeech
       end
 
       describe "setting dtmf mode" do
-        subject     { Grammar.new :mode => 'dtmf' }
-        its(:mode)  { should == 'dtmf' }
+        subject       { Grammar.new :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' }
-        its(:mode)  { should == 'voice' }
+        subject       { Grammar.new :mode => 'voice' }
+        its(:mode)    { should == :voice }
+        its(:voice?)  { should be true }
+        its(:dtmf?)   { should be false }
       end
 
       it 'registers itself' do
@@ -38,13 +42,13 @@ module RubySpeech
                                                      http://www.w3.org/TR/speech-grammar/grammar.xsd"
                                  xmlns="http://www.w3.org/2001/06/grammar" />' }
 
-        subject { Element.import parse_xml(document).root }
+        subject { Element.import document }
 
         it { should be_instance_of Grammar }
 
-        its(:language)  { pending; should == 'jp' }
+        its(:language)  { should == 'jp' }
         its(:base_uri)  { should == 'blah' }
-        its(:mode)      { should == 'dtmf' }
+        its(:mode)      { should == :dtmf }
         its(:root)      { should == 'main_rule' }
       end
 
@@ -162,52 +166,491 @@ module RubySpeech
         grammar.root_rule.should == foo
       end
 
-      it "should allow inlining rule references" do
-        grammar = GRXML.draw :root => 'pin', :mode => :dtmf do
-          rule :id => 'digits' do
-            one_of do
-              0.upto(9) { |d| item { d.to_s } }
+      describe "inlining rule references" do
+        let :grammar do
+          GRXML.draw :root => 'pin', :mode => :dtmf do
+            rule :id => 'digits' do
+              one_of do
+                0.upto(9) { |d| item { d.to_s } }
+              end
+            end
+
+            rule :id => 'pin', :scope => 'public' do
+              one_of do
+                item do
+                  item :repeat => '4' do
+                    ruleref :uri => '#digits'
+                  end
+                  "#"
+                end
+                item do
+                  "* 9"
+                end
+              end
             end
           end
+        end
 
-          rule :id => 'pin', :scope => 'public' do
-            one_of do
-              item do
-                item :repeat => '4' do
-                  ruleref :uri => '#digits'
+        let :inline_grammar do
+          GRXML.draw :root => 'pin', :mode => :dtmf do
+            rule :id => 'pin', :scope => 'public' do
+              one_of do
+                item do
+                  item :repeat => '4' do
+                    one_of do
+                      0.upto(9) { |d| item { d.to_s } }
+                    end
+                  end
+                  "#"
                 end
-                "#"
+                item do
+                  "* 9"
+                end
+              end
+            end
+          end
+        end
+
+        it "should be possible in a non-destructive manner" do
+          grammar.inline.should == inline_grammar
+          grammar.should_not == inline_grammar
+        end
+
+        it "should be possible in a destructive manner" do
+          grammar.inline!.should == inline_grammar
+          grammar.should == inline_grammar
+        end
+      end
+
+      describe "#tokenize!" do
+        def single_rule_grammar(content = [])
+          GRXML.draw :root => 'm', :mode => :speech do
+            rule :id => 'm' do
+              Array(content).each { |e| embed e }
+            end
+          end
+        end
+
+        subject { single_rule_grammar content }
+
+        let(:tokenized_version) do
+          expected_tokens = Array(tokens).map do |s|
+            Token.new.tap { |t| t << s }
+          end
+          single_rule_grammar expected_tokens
+        end
+
+        before { subject.tokenize! }
+
+        context "with a single unquoted token" do
+          let(:content) { 'hello' }
+          let(:tokens)  { 'hello' }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+
+        context "with a single unquoted token (non-alphabetic)" do
+          let(:content) { '2' }
+          let(:tokens)  { ['2'] }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+
+        context "with a single quoted token (including whitespace)" do
+          let(:content) { '"San Francisco"' }
+          let(:tokens)  { ['San Francisco'] }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+
+        context "with a single quoted token (no whitespace)" do
+          let(:content) { '"hello"' }
+          let(:tokens)  { ['hello'] }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+
+        context "with two tokens delimited by white space" do
+          let(:content) { 'bon voyage' }
+          let(:tokens)  { ['bon', 'voyage'] }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+
+        context "with four tokens delimited by white space" do
+          let(:content) { 'this is a test' }
+          let(:tokens)  { ['this', 'is', 'a', 'test'] }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+
+        context "with a single XML token" do
+          let(:content) { [Token.new.tap { |t| t << 'San Francisco' }] }
+          let(:tokens)  { ['San Francisco'] }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+
+        context "with a mixture of token types" do
+          let(:content) do
+            [
+              'Welcome to "San Francisco"',
+              Token.new.tap { |t| t << 'Have Fun!' }
+            ]
+          end
+
+          let(:tokens) { ['Welcome', 'to', 'San Francisco', 'Have Fun!'] }
+
+          it "should tokenize correctly" do
+            should == tokenized_version
+          end
+        end
+      end
+
+      describe "#normalize_whitespace" do
+        it "should normalize whitespace in all of the tokens contained within it" do
+          grammar = GRXML.draw do
+            rule do
+              token { ' Welcome to ' }
+              token { ' San  Francisco ' }
+            end
+          end
+
+          normalized_grammar = GRXML.draw do
+            rule do
+              token { 'Welcome to' }
+              token { 'San Francisco' }
+            end
+          end
+
+          grammar.should_not == normalized_grammar
+          grammar.normalize_whitespace
+          grammar.should == normalized_grammar
+        end
+      end
+
+      describe "matching against an input string" do
+        before do
+          subject.inline!
+          subject.tokenize!
+          subject.normalize_whitespace
+        end
+
+        context "with a grammar that takes a single specific digit" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digit' do
+              rule :id => 'digit' do
+                '6'
               end
-              item do
-                "* 9"
+            end
+          end
+
+          it "should match '6'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '6',
+                                              :interpretation => 'dtmf-6'
+            subject.match('6').should == expected_match
+          end
+
+          %w{1 2 3 4 5 7 8 9 10 66 26 61}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
+
+        context "with a grammar that takes two specific digits" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                '5 6'
               end
             end
           end
+
+          it "should match '56'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '56',
+                                              :interpretation => 'dtmf-5 dtmf-6'
+            subject.match('56').should == expected_match
+          end
+
+          %w{* *7 #6 6* 1 2 3 4 5 6 7 8 9 10 65 57 46 26 61}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
         end
 
-        expected_grammar = GRXML.draw :root => 'pin', :mode => :dtmf do
-          rule :id => 'pin', :scope => 'public' do
-            one_of do
-              item do
-                item :repeat => '4' do
-                  one_of do
-                    0.upto(9) { |d| item { d.to_s } }
-                  end
+        context "with a grammar that takes star and a digit" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                '* 6'
+              end
+            end
+          end
+
+          it "should match '*6'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '*6',
+                                              :interpretation => 'dtmf-star dtmf-6'
+            subject.match('*6').should == expected_match
+          end
+
+          %w{* *7 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
+
+        context "with a grammar that takes hash and a digit" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                '# 6'
+              end
+            end
+          end
+
+          it "should match '#6'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '#6',
+                                              :interpretation => 'dtmf-pound dtmf-6'
+            subject.match('#6').should == expected_match
+          end
+
+          %w{* *6 #7 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
+
+        context "with a grammar that takes two specific digits, via a ruleref, and whitespace normalization" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                ruleref :uri => '#star'
+                '" 6 "'
+              end
+
+              rule :id => 'star' do
+                '" * "'
+              end
+            end
+          end
+
+          it "should match '*6'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '*6',
+                                              :interpretation => 'dtmf-star dtmf-6'
+            subject.match('*6').should == expected_match
+          end
+
+          %w{* *7 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
+
+        context "with a grammar that takes two specific digits with the second being an alternative" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                string '*'
+                one_of do
+                  item { '6' }
+                  item { '7' }
                 end
-                "#"
               end
-              item do
-                "* 9"
+            end
+          end
+
+          it "should match '*6'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '*6',
+                                              :interpretation => 'dtmf-star dtmf-6'
+            subject.match('*6').should == expected_match
+          end
+
+          it "should match '*7'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '*7',
+                                              :interpretation => 'dtmf-star dtmf-7'
+            subject.match('*7').should == expected_match
+          end
+
+          %w{* *8 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
+
+        context "with a grammar that takes a specific digit, followed by a specific digit repeated an exact number of times" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                string '1'
+                item :repeat => 2 do
+                  '6'
+                end
               end
             end
           end
+
+          it "should match '166'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '166',
+                                              :interpretation => 'dtmf-1 dtmf-6 dtmf-6'
+            subject.match('166').should == expected_match
+          end
+
+          %w{1 16 1666 16666 17}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
         end
 
-        grammar.inline.should == expected_grammar
-      end
+        context "with a grammar that takes a specific digit, followed by a specific digit repeated within a range" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                string '1'
+                item :repeat => 0..3 do
+                  '6'
+                end
+              end
+            end
+          end
+
+          {
+            '1' => 'dtmf-1',
+            '16' => 'dtmf-1 dtmf-6',
+            '166' => 'dtmf-1 dtmf-6 dtmf-6',
+            '1666' => 'dtmf-1 dtmf-6 dtmf-6 dtmf-6'
+          }.each_pair do |input, interpretation|
+            it "should match '#{input}'" do
+              expected_match = GRXML::Match.new :mode           => :dtmf,
+                                                :confidence     => 1,
+                                                :utterance      => input,
+                                                :interpretation => interpretation
+              subject.match(input).should == expected_match
+            end
+          end
+
+          %w{6 16666 17}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
+
+        context "with a grammar that takes a specific digit, followed by a specific digit repeated a minimum number of times" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                string '1'
+                item :repeat => '2-' do
+                  '6'
+                end
+              end
+            end
+          end
+
+          {
+            '166' => 'dtmf-1 dtmf-6 dtmf-6',
+            '1666' => 'dtmf-1 dtmf-6 dtmf-6 dtmf-6',
+            '16666' => 'dtmf-1 dtmf-6 dtmf-6 dtmf-6 dtmf-6'
+          }.each_pair do |input, interpretation|
+            it "should match '#{input}'" do
+              expected_match = GRXML::Match.new :mode           => :dtmf,
+                                                :confidence     => 1,
+                                                :utterance      => input,
+                                                :interpretation => interpretation
+              subject.match(input).should == expected_match
+            end
+          end
+
+          %w{1 16 17}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
+
+        context "with a grammar that takes a 4 digit pin terminated by hash, or the *9 escape sequence" do
+          subject do
+            RubySpeech::GRXML.draw :mode => :dtmf, :root => 'pin' do
+              rule :id => 'digit' do
+                one_of do
+                  ('0'..'9').map { |d| item { d } }
+                end
+              end
+
+              rule :id => 'pin', :scope => 'public' do
+                one_of do
+                  item do
+                    item :repeat => '4' do
+                      ruleref :uri => '#digit'
+                    end
+                    "#"
+                  end
+                  item do
+                    "\* 9"
+                  end
+                end
+              end
+            end
+          end
 
-      describe "#tokens" do
-        context "with unquoted tokens"
+          {
+            '*9' => 'dtmf-star dtmf-9',
+            '1234#' => 'dtmf-1 dtmf-2 dtmf-3 dtmf-4 dtmf-pound',
+            '5678#' => 'dtmf-5 dtmf-6 dtmf-7 dtmf-8 dtmf-pound',
+            '1111#' => 'dtmf-1 dtmf-1 dtmf-1 dtmf-1 dtmf-pound'
+          }.each_pair do |input, interpretation|
+            it "should match '#{input}'" do
+              expected_match = GRXML::Match.new :mode           => :dtmf,
+                                                :confidence     => 1,
+                                                :utterance      => input,
+                                                :interpretation => interpretation
+              subject.match(input).should == expected_match
+            end
+          end
+
+          %w{111}.each do |input|
+            it "should not match '#{input}'" do
+              subject.match(input).should == GRXML::NoMatch.new
+            end
+          end
+        end
       end
     end # Grammar
   end # GRXML