ruby_speech 1.1.0 → 2.0.1

data/lib/ruby_speech/grxml.rb

@@ -14,6 +14,7 @@ module RubySpeech
     end
 
     autoload :Match
+    autoload :Matcher
     autoload :NoMatch
     autoload :PotentialMatch
 

data/lib/ruby_speech/grxml/element.rb

@@ -24,23 +24,6 @@ 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

@@ -149,99 +149,6 @@ module RubySpeech
         end
       end
 
-      ##
-      # Checks the grammar for a match against an input string
-      #
-      # @param [String] other the input string to check for a match with the grammar
-      #
-      # @return [NoMatch, Match] depending on the result of a match attempt. If a match can be found, it will be returned with appropriate mode/confidence/utterance and interpretation attributes
-      #
-      # @example A grammar that takes a 4 digit pin terminated by hash, or the *9 escape sequence
-      #     ```ruby
-      #       grammar = 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
-      #
-      #       >> subject.match '*9'
-      #       => #<RubySpeech::GRXML::Match:0x00000100ae5d98
-      #             @mode = :dtmf,
-      #             @confidence = 1,
-      #             @utterance = "*9",
-      #             @interpretation = "*9"
-      #           >
-      #       >> subject.match '1234#'
-      #       => #<RubySpeech::GRXML::Match:0x00000100b7e020
-      #             @mode = :dtmf,
-      #             @confidence = 1,
-      #             @utterance = "1234#",
-      #             @interpretation = "1234#"
-      #           >
-      #       >> subject.match '111'
-      #       => #<RubySpeech::GRXML::PotentialMatch:0x00000101371660>
-      #
-      #       >> subject.match '11111'
-      #       => #<RubySpeech::GRXML::NoMatch:0x00000101371936>
-      #
-      #     ```
-      #
-      def match(other)
-        other = other.dup
-        regex = to_regexp
-        return check_for_potential_match(other) if regex == //
-        match = regex.match other
-        return check_for_potential_match(other) unless match
-
-        Match.new :mode           => mode,
-                  :confidence     => dtmf? ? 1 : 0,
-                  :utterance      => other,
-                  :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
-      #
-      # @return [Regexp] a regular expression which is equivalent to the grammar
-      #
-      def to_regexp
-        /^#{regexp_content.join}$/
-      end
-
-      def regexp_content
-        root_rule.children.map &:regexp_content
-      end
-
       def dtmf?
         mode == :dtmf
       end
@@ -270,16 +177,6 @@ module RubySpeech
         !root || root_rule
       end
 
-      def interpret_utterance(utterance)
-        conversion = Hash.new { |hash, key| hash[key] = key }
-        conversion['*'] = 'star'
-        conversion['#'] = 'pound'
-
-        utterance.chars.inject [] do |array, digit|
-          array << "dtmf-#{conversion[digit]}"
-        end.join ' '
-      end
-
       def split_tokens(element)
         element.to_s.split(/(\".*\")/).reject(&:empty?).map do |string|
           match = string.match /^\"(.*)\"$/

data/lib/ruby_speech/grxml/item.rb

@@ -139,27 +139,6 @@ module RubySpeech
           super
         end
       end
-
-      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
-          children.size
-        end
-      end
     end # Item
   end # GRXML
 end # RubySpeech

data/lib/ruby_speech/grxml/matcher.rb

@@ -0,0 +1,129 @@
+require 'ruby_speech/ruby_speech'
+
+if RUBY_PLATFORM =~ /java/
+  require 'jruby'
+  com.benlangfeld.ruby_speech.RubySpeechService.new.basicLoad(JRuby.runtime)
+end
+
+module RubySpeech
+  module GRXML
+    class Matcher
+
+      BLANK_REGEX = //.freeze
+
+      attr_reader :grammar, :regex
+
+      def initialize(grammar)
+        @grammar = grammar
+        prepare_grammar
+        @regex = /^#{regexp_content.join}$/
+      end
+
+      ##
+      # Checks the grammar for a match against an input string
+      #
+      # @param [String] other the input string to check for a match with the grammar
+      #
+      # @return [NoMatch, Match] depending on the result of a match attempt. If a match can be found, it will be returned with appropriate mode/confidence/utterance and interpretation attributes
+      #
+      # @example A grammar that takes a 4 digit pin terminated by hash, or the *9 escape sequence
+      #     ```ruby
+      #       grammar = 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
+      #
+      #       matcher = RubySpeech::GRXML::Matcher.new grammar
+      #
+      #       >> matcher.match '*9'
+      #       => #<RubySpeech::GRXML::Match:0x00000100ae5d98
+      #             @mode = :dtmf,
+      #             @confidence = 1,
+      #             @utterance = "*9",
+      #             @interpretation = "*9"
+      #           >
+      #       >> matcher.match '1234#'
+      #       => #<RubySpeech::GRXML::Match:0x00000100b7e020
+      #             @mode = :dtmf,
+      #             @confidence = 1,
+      #             @utterance = "1234#",
+      #             @interpretation = "1234#"
+      #           >
+      #       >> matcher.match '5678#'
+      #       => #<RubySpeech::GRXML::Match:0x00000101218688
+      #             @mode = :dtmf,
+      #             @confidence = 1,
+      #             @utterance = "5678#",
+      #             @interpretation = "5678#"
+      #           >
+      #       >> matcher.match '1111#'
+      #       => #<RubySpeech::GRXML::Match:0x000001012f69d8
+      #             @mode = :dtmf,
+      #             @confidence = 1,
+      #             @utterance = "1111#",
+      #             @interpretation = "1111#"
+      #           >
+      #       >> matcher.match '111'
+      #       => #<RubySpeech::GRXML::NoMatch:0x00000101371660>
+      #       ```
+      #
+      def match(buffer)
+        buffer = buffer.dup
+
+        return check_potential_match(buffer) if regex == BLANK_REGEX
+
+        check_full_match(buffer) || check_potential_match(buffer) || NoMatch.new
+      end
+
+      private
+
+      def prepare_grammar
+        grammar.inline!
+        grammar.tokenize!
+        grammar.normalize_whitespace
+      end
+
+      def check_full_match(buffer)
+        match = regex.match buffer
+
+        return unless match
+
+        Match.new :mode           => grammar.mode,
+                  :confidence     => grammar.dtmf? ? 1 : 0,
+                  :utterance      => buffer,
+                  :interpretation => interpret_utterance(buffer)
+      end
+
+      def regexp_content
+        grammar.root_rule.children.map &:regexp_content
+      end
+
+      def interpret_utterance(utterance)
+        conversion = Hash.new { |hash, key| hash[key] = key }
+        conversion['*'] = 'star'
+        conversion['#'] = 'pound'
+
+        utterance.chars.inject [] do |array, digit|
+          array << "dtmf-#{conversion[digit]}"
+        end.join ' '
+      end
+    end
+  end
+end

data/lib/ruby_speech/grxml/one_of.rb

@@ -26,10 +26,6 @@ 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/token.rb

@@ -26,10 +26,6 @@ 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/nlsml.rb

@@ -2,8 +2,7 @@ module RubySpeech
   module NLSML
     extend ActiveSupport::Autoload
 
-    NLSML_NAMESPACE   = 'http://www.w3c.org/2000/11/nlsml'
-    XFORMS_NAMESPACE  = 'http://www.w3.org/2000/xforms'
+    NLSML_NAMESPACE = 'http://www.ietf.org/xml/ns/mrcpv2'
 
     eager_autoload do
       autoload :Builder

data/lib/ruby_speech/nlsml/builder.rb

@@ -4,7 +4,7 @@ module RubySpeech
       attr_reader :document
 
       def initialize(options = {}, &block)
-        options = {'xmlns' => NLSML_NAMESPACE, 'xmlns:xf' => XFORMS_NAMESPACE}.merge(options)
+        options = {'xmlns' => NLSML_NAMESPACE}.merge(options)
         @document = Nokogiri::XML::Builder.new do |builder|
           builder.result options do |r|
             apply_block r, &block
@@ -14,19 +14,11 @@ module RubySpeech
 
       def interpretation(*args, &block)
         if args.last.respond_to?(:has_key?) && args.last.has_key?(:confidence)
-          args.last[:confidence] = (args.last[:confidence] * 100).to_i
+          args.last[:confidence] = args.last[:confidence].to_f
         end
         @result.send :interpretation, *args, &block
       end
 
-      def model(*args, &block)
-        xf_namespaced_element :model, *args, &block
-      end
-
-      def instance(*args, &block)
-        xf_namespaced_element :instance, *args, &block
-      end
-
       def method_missing(method_name, *args, &block)
         @result.send method_name, *args, &block
       end
@@ -37,11 +29,6 @@ module RubySpeech
         @result = result
         instance_eval &block
       end
-
-      def xf_namespaced_element(element_name, *args, &block)
-        namespace = @result.send :[], 'xf'
-        namespace.send element_name, &block
-      end
     end
   end
 end

data/lib/ruby_speech/nlsml/document.rb

@@ -4,8 +4,11 @@ module RubySpeech
   module NLSML
     class Document < SimpleDelegator
       def initialize(xml)
+        unless xml.root.namespace
+          xml.root.default_namespace = NLSML_NAMESPACE
+          xml = Nokogiri::XML.parse xml.to_xml, nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS
+        end
         super
-        @xml = xml
       end
 
       def grammar
@@ -41,19 +44,19 @@ module RubySpeech
       end
 
       def nomatch_elements
-        result.xpath 'ns:interpretation/ns:input/ns:nomatch|interpretation/input/nomatch', 'ns' => NLSML_NAMESPACE
+        result.xpath 'ns:interpretation/ns:input/ns:nomatch', 'ns' => NLSML_NAMESPACE
       end
 
       def noinput_elements
-        result.xpath 'ns:interpretation/ns:input/ns:noinput|interpretation/input/noinput', 'ns' => NLSML_NAMESPACE
+        result.xpath 'ns:interpretation/ns:input/ns:noinput', 'ns' => NLSML_NAMESPACE
       end
 
       def input_elements
-        result.xpath 'ns:interpretation/ns:input|interpretation/input', 'ns' => NLSML_NAMESPACE
+        result.xpath 'ns:interpretation/ns:input', 'ns' => NLSML_NAMESPACE
       end
 
       def input_hash_for_interpretation(interpretation)
-        input_element = interpretation.at_xpath '(ns:input|input)', 'ns' => NLSML_NAMESPACE
+        input_element = interpretation.at_xpath 'ns:input', 'ns' => NLSML_NAMESPACE
         { content: input_element.content }.tap do |h|
           h[:mode] = input_element['mode'].to_sym if input_element['mode']
         end
@@ -73,10 +76,11 @@ module RubySpeech
       end
 
       def instance_elements(interpretation)
-        interpretation.xpath '(xf:instance|ns:instance|instance)', 'xf' => XFORMS_NAMESPACE, 'ns' => NLSML_NAMESPACE
+        interpretation.xpath 'ns:instance', 'ns' => NLSML_NAMESPACE
       end
 
       def element_children_key_value(element)
+        return element.children.first.content if element.children.first.is_a?(Nokogiri::XML::Text)
         element.children.inject({}) do |acc, child|
           acc[child.node_name.to_sym] = case child.children.count
           when 0
@@ -96,7 +100,7 @@ module RubySpeech
 
       def interpretation_hash_for_interpretation(interpretation)
         {
-          confidence: interpretation['confidence'].to_f/100,
+          confidence: interpretation['confidence'].to_f,
           input: input_hash_for_interpretation(interpretation),
           instance: instance_hash_for_interpretation(interpretation),
           instances: instances_collection_for_interpretation(interpretation)
@@ -108,8 +112,8 @@ module RubySpeech
       end
 
       def interpretation_nodes
-        nodes = result.xpath '(ns:interpretation|interpretation)', 'ns' => NLSML_NAMESPACE
-        nodes.sort_by { |int| -int[:confidence].to_i }
+        nodes = result.xpath 'ns:interpretation', 'ns' => NLSML_NAMESPACE
+        nodes.sort_by { |int| -int[:confidence].to_f }
       end
     end
   end