ruby_speech 0.5.0 → 0.5.1

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # develop
 
+# 0.5.1 - 2012-01-09
+  * Feature: Chaining child injection using #<< now works
+  * Feature: Reading the repeat value for a GRXML Item now returns an Integer or a Range, rather than the plain string
+  * Feature: Most simple GRXML grammars now return PotentialMatch when the provided input is valid but incomplete. This does not work for complex grammars including repeats and deep nesting. Fixes for these coming soon.
+
 # 0.5.0 - 2012-01-03
   * Feature: Add a whole bunch more SSML elements:
   ** p & s

data/lib/ruby_speech.rb

@@ -2,6 +2,7 @@
   active_support/dependencies/autoload
   active_support/core_ext/object/blank
   active_support/core_ext/numeric/time
+  active_support/core_ext/enumerable
   niceogiri
 }.each { |f| require f }
 

data/lib/ruby_speech/generic_element.rb

@@ -164,6 +164,7 @@ module RubySpeech
     def <<(other)
       other = encode_special_chars other if other.is_a? String
       super other
+      self
     end
 
     def method_missing(method_name, *args, &block)

data/lib/ruby_speech/grxml.rb

@@ -15,6 +15,7 @@ module RubySpeech
 
     autoload :Match
     autoload :NoMatch
+    autoload :PotentialMatch
 
     InvalidChildError = Class.new StandardError
 

data/lib/ruby_speech/grxml/element.rb

@@ -22,6 +22,23 @@ module RubySpeech
       def regexp_content # :nodoc:
         children.map(&:regexp_content).join
       end
+
+      def potential_match?(other)
+        false
+      end
+
+      def max_input_length
+        0
+      end
+
+      def longest_potential_match(input)
+        input.dup.tap do |longest_input|
+          begin
+            return longest_input if potential_match? longest_input
+            longest_input.chop!
+          end until longest_input.length.zero?
+        end
+      end
     end # Element
   end # GRXML
 end # RubySpeech

data/lib/ruby_speech/grxml/grammar.rb

@@ -195,15 +195,19 @@ module RubySpeech
       #             @interpretation = "1234#"
       #           >
       #       >> subject.match '111'
-      #       => #<RubySpeech::GRXML::NoMatch:0x00000101371660>
+      #       => #<RubySpeech::GRXML::PotentialMatch:0x00000101371660>
+      #
+      #       >> subject.match '11111'
+      #       => #<RubySpeech::GRXML::NoMatch:0x00000101371936>
       #
       #     ```
       #
       def match(other)
+        other = other.dup
         regex = to_regexp
-        return NoMatch.new if regex == //
+        return check_for_potential_match(other) if regex == //
         match = regex.match other
-        return NoMatch.new unless match
+        return check_for_potential_match(other) unless match
 
         Match.new :mode           => mode,
                   :confidence     => dtmf? ? 1 : 0,
@@ -211,6 +215,20 @@ module RubySpeech
                   :interpretation => interpret_utterance(other)
       end
 
+      def check_for_potential_match(other)
+        potential_match?(other) ? PotentialMatch.new : NoMatch.new
+      end
+
+      def potential_match?(other)
+        root_rule.children.each do |token|
+          return true if other.length.zero?
+          longest_potential_match = token.longest_potential_match other
+          return false if longest_potential_match.length.zero?
+          other.gsub! /^#{Regexp.escape longest_potential_match}/, ''
+        end
+        other.length.zero?
+      end
+
       ##
       # Converts the grammar into a regular expression for matching
       #

data/lib/ruby_speech/grxml/item.rb

@@ -26,6 +26,7 @@ module RubySpeech
     # xml:lang declares declaration declares the language of the grammar section for the item element just as xml:lang in the <grammar> element declares for the entire document
     #
     class Item < Element
+      Inf = 1.0 / 0.0
 
       register :item
 
@@ -61,7 +62,14 @@ module RubySpeech
       # @return [String]
       #
       def repeat
-        read_attr :repeat
+        repeat = read_attr :repeat
+        return nil unless repeat
+        if repeat.include?('-')
+          min, max = repeat.split('-').map &:to_i
+          (min || 0)..(max || Inf)
+        else
+          repeat.to_i
+        end
       end
 
       ##
@@ -72,7 +80,7 @@ module RubySpeech
       # @param [String] r
       #
       def repeat=(r)
-        r = "#{r.min}-#{r.max}" if r.is_a?(Range)
+        r = "#{r.min}-#{r.max unless r.max == Inf}" if r.is_a?(Range)
         r = r.to_s
         error = ArgumentError.new "A Item's repeat must be 0 or a positive integer"
 
@@ -122,13 +130,34 @@ module RubySpeech
       end
 
       def regexp_content # :nodoc:
-        return super unless repeat
+        case repeat
+        when Range
+          "#{super}{#{repeat.min},#{repeat.max unless repeat.max == Inf}}"
+        when Integer
+          "#{super}{#{repeat}}"
+        else
+          super
+        end
+      end
 
-        if repeat.include?('-')
-          min, max = repeat.split '-'
-          "#{super}{#{min},#{max}}"
+      def potential_match?(other)
+        tokens = children
+        return false if other.length > max_input_length
+        other.chars.each_with_index do |digit, index|
+          index -= tokens.size until index < tokens.size if repeat
+          return false unless tokens[index].potential_match?(digit)
+        end
+        true
+      end
+
+      def max_input_length # :nodoc:
+        case repeat
+        when Range
+          children.size * repeat.max
+        when Integer
+          children.size * repeat
         else
-          "#{super}{#{repeat}}"
+          children.size
         end
       end
     end # Item

data/lib/ruby_speech/grxml/one_of.rb

@@ -26,6 +26,10 @@ module RubySpeech
       def regexp_content # :nodoc:
         "(#{children.map(&:regexp_content).join '|'})"
       end
+
+      def potential_match?(input)
+        children.any? { |c| c.potential_match? input }
+      end
     end # OneOf
   end # GRXML
 end # RubySpeech

data/lib/ruby_speech/grxml/potential_match.rb

@@ -0,0 +1,10 @@
+module RubySpeech
+  module GRXML
+    class PotentialMatch
+      def eql?(o)
+        o.is_a? self.class
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/ruby_speech/grxml/token.rb

@@ -26,6 +26,10 @@ module RubySpeech
       def regexp_content # :nodoc:
         Regexp.escape content
       end
+
+      def potential_match?(other)
+        other == content
+      end
     end # Token
   end # GRXML
 end # RubySpeech

data/lib/ruby_speech/version.rb

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

data/spec/ruby_speech/grxml/grammar_spec.rb

@@ -360,11 +360,13 @@ module RubySpeech
           end
 
           it "should match '6'" do
+            input = '6'
             expected_match = GRXML::Match.new :mode           => :dtmf,
                                               :confidence     => 1,
                                               :utterance      => '6',
                                               :interpretation => 'dtmf-6'
-            subject.match('6').should == expected_match
+            subject.match(input).should == expected_match
+            input.should == '6'
           end
 
           %w{1 2 3 4 5 7 8 9 10 66 26 61}.each do |input|
@@ -391,7 +393,13 @@ module RubySpeech
             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 potentially match '5'" do
+            input = '5'
+            subject.match(input).should == GRXML::PotentialMatch.new
+            input.should == '5'
+          end
+
+          %w{* *7 #6 6* 1 2 3 4 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
@@ -415,7 +423,11 @@ module RubySpeech
             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 potentially match '*'" do
+            subject.match('*').should == GRXML::PotentialMatch.new
+          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
@@ -439,6 +451,10 @@ module RubySpeech
             subject.match('#6').should == expected_match
           end
 
+          it "should potentially match '#'" do
+            subject.match('#').should == GRXML::PotentialMatch.new
+          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
@@ -468,7 +484,142 @@ module RubySpeech
             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 potentially match '*'" do
+            subject.match('*').should == GRXML::PotentialMatch.new
+          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 a single digit alternative" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                one_of do
+                  item { '6' }
+                  item { '7' }
+                end
+              end
+            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
+
+          it "should match '7'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '7',
+                                              :interpretation => 'dtmf-7'
+            subject.match('7').should == expected_match
+          end
+
+          %w{* # 1 2 3 4 5 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 double digit alternative" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                one_of do
+                  item do
+                    token { '6' }
+                    token { '5' }
+                  end
+                  item do
+                    token { '7' }
+                    token { '2' }
+                  end
+                end
+              end
+            end
+          end
+
+          it "should match '65'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '65',
+                                              :interpretation => 'dtmf-6 dtmf-5'
+            subject.match('65').should == expected_match
+          end
+
+          it "should match '72'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '72',
+                                              :interpretation => 'dtmf-7 dtmf-2'
+            subject.match('72').should == expected_match
+          end
+
+          %w{6 7}.each do |input|
+            it "should potentially match '#{input}'" do
+              subject.match(input).should == GRXML::PotentialMatch.new
+            end
+          end
+
+          %w{* # 1 2 3 4 5 8 9 10 66 26 61 75}.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 triple digit alternative" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                one_of do
+                  item do
+                    token { '6' }
+                    token { '5' }
+                    token { '2' }
+                  end
+                  item do
+                    token { '7' }
+                    token { '2' }
+                    token { '8' }
+                  end
+                end
+              end
+            end
+          end
+
+          it "should match '652'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '652',
+                                              :interpretation => 'dtmf-6 dtmf-5 dtmf-2'
+            subject.match('652').should == expected_match
+          end
+
+          it "should match '728'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '728',
+                                              :interpretation => 'dtmf-7 dtmf-2 dtmf-8'
+            subject.match('728').should == expected_match
+          end
+
+          %w{6 65 7 72}.each do |input|
+            it "should potentially match '#{input}'" do
+              subject.match(input).should == GRXML::PotentialMatch.new
+            end
+          end
+
+          %w{* # 1 2 3 4 5 8 9 10 66 26 61 75 729 654}.each do |input|
             it "should not match '#{input}'" do
               subject.match(input).should == GRXML::NoMatch.new
             end
@@ -504,7 +655,55 @@ module RubySpeech
             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 potentially match '*'" do
+            subject.match('*').should == GRXML::PotentialMatch.new
+          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 two specific digits with the first being an alternative" do
+          subject do
+            GRXML.draw :mode => :dtmf, :root => 'digits' do
+              rule :id => 'digits' do
+                one_of do
+                  item { '6' }
+                  item { '7' }
+                end
+                string '*'
+              end
+            end
+          end
+
+          it "should match '6*'" do
+            expected_match = GRXML::Match.new :mode           => :dtmf,
+                                              :confidence     => 1,
+                                              :utterance      => '6*',
+                                              :interpretation => 'dtmf-6 dtmf-star'
+            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-7 dtmf-star'
+            subject.match('7*').should == expected_match
+          end
+
+          it "should potentially match '6'" do
+            subject.match('6').should == GRXML::PotentialMatch.new
+          end
+
+          it "should potentially match '7'" do
+            subject.match('7').should == GRXML::PotentialMatch.new
+          end
+
+          %w{8* 6# *6 *7 1 2 3 4 5 8 9 10 66 26 61}.each do |input|
             it "should not match '#{input}'" do
               subject.match(input).should == GRXML::NoMatch.new
             end
@@ -531,7 +730,13 @@ module RubySpeech
             subject.match('166').should == expected_match
           end
 
-          %w{1 16 1666 16666 17}.each do |input|
+          %w{1 16}.each do |input|
+            it "should potentially match '#{input}'" do
+              subject.match(input).should == GRXML::PotentialMatch.new
+            end
+          end
+
+          %w{1666 16666 17}.each do |input|
             it "should not match '#{input}'" do
               subject.match(input).should == GRXML::NoMatch.new
             end
@@ -598,7 +803,13 @@ module RubySpeech
             end
           end
 
-          %w{1 16 17}.each do |input|
+          %w{1 16}.each do |input|
+            it "should potentially match '#{input}'" do
+              subject.match(input).should == GRXML::PotentialMatch.new
+            end
+          end
+
+          %w{7 17}.each do |input|
             it "should not match '#{input}'" do
               subject.match(input).should == GRXML::NoMatch.new
             end
@@ -645,7 +856,14 @@ module RubySpeech
             end
           end
 
-          %w{111}.each do |input|
+          %w{* 1 12 123 1234}.each do |input|
+            it "should potentially match '#{input}'" do
+              pending
+              subject.match(input).should == GRXML::PotentialMatch.new
+            end
+          end
+
+          %w{11111 #1111 *7}.each do |input|
             it "should not match '#{input}'" do
               subject.match(input).should == GRXML::NoMatch.new
             end