ruby_speech 2.1.0-java

data/assets/xml.xsd

@@ -0,0 +1,287 @@
+<?xml version='1.0'?>
+<?xml-stylesheet href="../2008/09/xsd.xsl" type="text/xsl"?>
+<xs:schema targetNamespace="http://www.w3.org/XML/1998/namespace" 
+  xmlns:xs="http://www.w3.org/2001/XMLSchema" 
+  xmlns   ="http://www.w3.org/1999/xhtml"
+  xml:lang="en">
+
+ <xs:annotation>
+  <xs:documentation>
+   <div>
+    <h1>About the XML namespace</h1>
+
+    <div class="bodytext">
+     <p>
+      This schema document describes the XML namespace, in a form
+      suitable for import by other schema documents.
+     </p>
+     <p>
+      See <a href="http://www.w3.org/XML/1998/namespace.html">
+      http://www.w3.org/XML/1998/namespace.html</a> and
+      <a href="http://www.w3.org/TR/REC-xml">
+      http://www.w3.org/TR/REC-xml</a> for information 
+      about this namespace.
+     </p>
+     <p>
+      Note that local names in this namespace are intended to be
+      defined only by the World Wide Web Consortium or its subgroups.
+      The names currently defined in this namespace are listed below.
+      They should not be used with conflicting semantics by any Working
+      Group, specification, or document instance.
+     </p>
+     <p>   
+      See further below in this document for more information about <a
+      href="#usage">how to refer to this schema document from your own
+      XSD schema documents</a> and about <a href="#nsversioning">the
+      namespace-versioning policy governing this schema document</a>.
+     </p>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:attribute name="lang">
+  <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>lang (as an attribute name)</h3>
+      <p>
+       denotes an attribute whose value
+       is a language code for the natural language of the content of
+       any element; its value is inherited.  This name is reserved
+       by virtue of its definition in the XML specification.</p>
+     
+    </div>
+    <div>
+     <h4>Notes</h4>
+     <p>
+      Attempting to install the relevant ISO 2- and 3-letter
+      codes as the enumerated possible values is probably never
+      going to be a realistic possibility.  
+     </p>
+     <p>
+      See BCP 47 at <a href="http://www.rfc-editor.org/rfc/bcp/bcp47.txt">
+       http://www.rfc-editor.org/rfc/bcp/bcp47.txt</a>
+      and the IANA language subtag registry at
+      <a href="http://www.iana.org/assignments/language-subtag-registry">
+       http://www.iana.org/assignments/language-subtag-registry</a>
+      for further information.
+     </p>
+     <p>
+      The union allows for the 'un-declaration' of xml:lang with
+      the empty string.
+     </p>
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+  <xs:simpleType>
+   <xs:union memberTypes="xs:language">
+    <xs:simpleType>    
+     <xs:restriction base="xs:string">
+      <xs:enumeration value=""/>
+     </xs:restriction>
+    </xs:simpleType>
+   </xs:union>
+  </xs:simpleType>
+ </xs:attribute>
+
+ <xs:attribute name="space">
+  <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>space (as an attribute name)</h3>
+      <p>
+       denotes an attribute whose
+       value is a keyword indicating what whitespace processing
+       discipline is intended for the content of the element; its
+       value is inherited.  This name is reserved by virtue of its
+       definition in the XML specification.</p>
+     
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+  <xs:simpleType>
+   <xs:restriction base="xs:NCName">
+    <xs:enumeration value="default"/>
+    <xs:enumeration value="preserve"/>
+   </xs:restriction>
+  </xs:simpleType>
+ </xs:attribute>
+ 
+ <xs:attribute name="base" type="xs:anyURI"> <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>base (as an attribute name)</h3>
+      <p>
+       denotes an attribute whose value
+       provides a URI to be used as the base for interpreting any
+       relative URIs in the scope of the element on which it
+       appears; its value is inherited.  This name is reserved
+       by virtue of its definition in the XML Base specification.</p>
+     
+     <p>
+      See <a
+      href="http://www.w3.org/TR/xmlbase/">http://www.w3.org/TR/xmlbase/</a>
+      for information about this attribute.
+     </p>
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+ </xs:attribute>
+ 
+ <xs:attribute name="id" type="xs:ID">
+  <xs:annotation>
+   <xs:documentation>
+    <div>
+     
+      <h3>id (as an attribute name)</h3> 
+      <p>
+       denotes an attribute whose value
+       should be interpreted as if declared to be of type ID.
+       This name is reserved by virtue of its definition in the
+       xml:id specification.</p>
+     
+     <p>
+      See <a
+      href="http://www.w3.org/TR/xml-id/">http://www.w3.org/TR/xml-id/</a>
+      for information about this attribute.
+     </p>
+    </div>
+   </xs:documentation>
+  </xs:annotation>
+ </xs:attribute>
+
+ <xs:attributeGroup name="specialAttrs">
+  <xs:attribute ref="xml:base"/>
+  <xs:attribute ref="xml:lang"/>
+  <xs:attribute ref="xml:space"/>
+  <xs:attribute ref="xml:id"/>
+ </xs:attributeGroup>
+
+ <xs:annotation>
+  <xs:documentation>
+   <div>
+   
+    <h3>Father (in any context at all)</h3> 
+
+    <div class="bodytext">
+     <p>
+      denotes Jon Bosak, the chair of 
+      the original XML Working Group.  This name is reserved by 
+      the following decision of the W3C XML Plenary and 
+      XML Coordination groups:
+     </p>
+     <blockquote>
+       <p>
+	In appreciation for his vision, leadership and
+	dedication the W3C XML Plenary on this 10th day of
+	February, 2000, reserves for Jon Bosak in perpetuity
+	the XML name "xml:Father".
+       </p>
+     </blockquote>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+  <xs:documentation>
+   <div xml:id="usage" id="usage">
+    <h2><a name="usage">About this schema document</a></h2>
+
+    <div class="bodytext">
+     <p>
+      This schema defines attributes and an attribute group suitable
+      for use by schemas wishing to allow <code>xml:base</code>,
+      <code>xml:lang</code>, <code>xml:space</code> or
+      <code>xml:id</code> attributes on elements they define.
+     </p>
+     <p>
+      To enable this, such a schema must import this schema for
+      the XML namespace, e.g. as follows:
+     </p>
+     <pre>
+          &lt;schema . . .>
+           . . .
+           &lt;import namespace="http://www.w3.org/XML/1998/namespace"
+                      schemaLocation="http://www.w3.org/2001/xml.xsd"/>
+     </pre>
+     <p>
+      or
+     </p>
+     <pre>
+           &lt;import namespace="http://www.w3.org/XML/1998/namespace"
+                      schemaLocation="http://www.w3.org/2009/01/xml.xsd"/>
+     </pre>
+     <p>
+      Subsequently, qualified reference to any of the attributes or the
+      group defined below will have the desired effect, e.g.
+     </p>
+     <pre>
+          &lt;type . . .>
+           . . .
+           &lt;attributeGroup ref="xml:specialAttrs"/>
+     </pre>
+     <p>
+      will define a type which will schema-validate an instance element
+      with any of those attributes.
+     </p>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+ <xs:annotation>
+  <xs:documentation>
+   <div id="nsversioning" xml:id="nsversioning">
+    <h2><a name="nsversioning">Versioning policy for this schema document</a></h2>
+    <div class="bodytext">
+     <p>
+      In keeping with the XML Schema WG's standard versioning
+      policy, this schema document will persist at
+      <a href="http://www.w3.org/2009/01/xml.xsd">
+       http://www.w3.org/2009/01/xml.xsd</a>.
+     </p>
+     <p>
+      At the date of issue it can also be found at
+      <a href="http://www.w3.org/2001/xml.xsd">
+       http://www.w3.org/2001/xml.xsd</a>.
+     </p>
+     <p>
+      The schema document at that URI may however change in the future,
+      in order to remain compatible with the latest version of XML
+      Schema itself, or with the XML namespace itself.  In other words,
+      if the XML Schema or XML namespaces change, the version of this
+      document at <a href="http://www.w3.org/2001/xml.xsd">
+       http://www.w3.org/2001/xml.xsd 
+      </a> 
+      will change accordingly; the version at 
+      <a href="http://www.w3.org/2009/01/xml.xsd">
+       http://www.w3.org/2009/01/xml.xsd 
+      </a> 
+      will not change.
+     </p>
+     <p>
+      Previous dated (and unchanging) versions of this schema 
+      document are at:
+     </p>
+     <ul>
+      <li><a href="http://www.w3.org/2009/01/xml.xsd">
+	http://www.w3.org/2009/01/xml.xsd</a></li>
+      <li><a href="http://www.w3.org/2007/08/xml.xsd">
+	http://www.w3.org/2007/08/xml.xsd</a></li>
+      <li><a href="http://www.w3.org/2004/10/xml.xsd">
+	http://www.w3.org/2004/10/xml.xsd</a></li>
+      <li><a href="http://www.w3.org/2001/03/xml.xsd">
+	http://www.w3.org/2001/03/xml.xsd</a></li>
+     </ul>
+    </div>
+   </div>
+  </xs:documentation>
+ </xs:annotation>
+
+</xs:schema>
+

data/ext/ruby_speech/RubySpeechGRXMLMatcher.java

@@ -0,0 +1,64 @@
+package com.benlangfeld.ruby_speech;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.Visibility;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.javasupport.util.RuntimeHelpers;
+
+import java.util.regex.*;
+
+@JRubyClass(name="RubySpeech::GRXML::Matcher")
+public class RubySpeechGRXMLMatcher extends RubyObject {
+
+  Pattern p;
+
+  public RubySpeechGRXMLMatcher(final Ruby runtime, RubyClass rubyClass) {
+    super(runtime, rubyClass);
+  }
+
+  @JRubyMethod(visibility=Visibility.PRIVATE)
+  public IRubyObject compile_regex(ThreadContext context, IRubyObject regex) {
+    Ruby runtime = context.getRuntime();
+    p = Pattern.compile(regex.toString());
+    return runtime.getNil();
+  }
+
+  @JRubyMethod(visibility=Visibility.PUBLIC)
+  public IRubyObject find_match(ThreadContext context, IRubyObject buffer)
+  {
+    Ruby runtime = context.getRuntime();
+    String string_buffer = buffer.toString();
+    Matcher m = p.matcher(string_buffer);
+
+    if (m.matches()) {
+      if (is_max_match(string_buffer)) {
+        return RuntimeHelpers.invoke(context, this, "match_for_buffer", buffer, runtime.getTrue());
+      }
+      return callMethod(context, "match_for_buffer", buffer);
+    } else if (m.hitEnd()) {
+      RubyModule potential_match = runtime.getClassFromPath("RubySpeech::GRXML::PotentialMatch");
+      return potential_match.callMethod(context, "new");
+    }
+    RubyModule nomatch = runtime.getClassFromPath("RubySpeech::GRXML::NoMatch");
+    return nomatch.callMethod(context, "new");
+  }
+
+  public Boolean is_max_match(String buffer)
+  {
+    String search_set = "0123456789#*ABCD";
+    for (int i = 0; i < 16; i++) {
+      String new_buffer = buffer + search_set.charAt(i);
+      Matcher m = p.matcher(new_buffer);
+      if (m.matches()) return false;
+    }
+    return true;
+  }
+
+}

data/ext/ruby_speech/RubySpeechService.java

@@ -0,0 +1,23 @@
+package com.benlangfeld.ruby_speech;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class RubySpeechService implements BasicLibraryService {
+  public boolean basicLoad(Ruby ruby) {
+    RubyModule ruby_speech = ruby.defineModule("RubySpeech");
+    RubyModule grxml = ruby_speech.defineModuleUnder("GRXML");
+    RubyClass matcher = grxml.defineClassUnder("Matcher", ruby.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+        return new RubySpeechGRXMLMatcher(runtime, rubyClass);
+      }
+    });
+    matcher.defineAnnotatedMethods(RubySpeechGRXMLMatcher.class);
+    return true;
+  }
+}

data/ext/ruby_speech/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+$LIBS << " -lpcre"
+
+abort "-----\n#{lib} is missing.\n-----" unless find_header('pcre.h')
+
+create_makefile 'ruby_speech/ruby_speech'

data/ext/ruby_speech/ruby_speech.c

@@ -0,0 +1,97 @@
+#include "ruby.h"
+#include "pcre.h"
+#include <stdio.h>
+
+static VALUE method_compile_regex(VALUE self, VALUE regex_string)
+{
+  int erroffset       = 0;
+  const char *errptr  = "";
+  int options         = 0;
+  const char *regex   = StringValueCStr(regex_string);
+
+  pcre *compiled_regex = pcre_compile(regex, options, &errptr, &erroffset, NULL);
+  VALUE compiled_regex_wrapper = Data_Wrap_Struct(rb_cObject, 0, pcre_free, compiled_regex);
+  rb_iv_set(self, "@regex", compiled_regex_wrapper);
+
+  return Qnil;
+}
+
+#define MAX_INPUT_SIZE 128
+#define OVECTOR_SIZE 30
+#define WORKSPACE_SIZE 1024
+
+/**
+ * Check if no more digits can be added to input and match
+ * @param compiled_regex the regex used in the initial match
+ * @param input the input to check
+ * @return true if end of match (no more input can be added)
+ */
+static int is_match_end(pcre *compiled_regex, const char *input)
+{
+  int ovector[OVECTOR_SIZE];
+  int input_size = (int)strlen(input);
+  char search_input[MAX_INPUT_SIZE + 2];
+  const char *search_set = "0123456789#*ABCD";
+  const char *search = strchr(search_set, input[input_size - 1]); /* start with last digit in input */
+
+  /* For each digit in search_set, check if input + search_set digit is a potential match.
+     If so, then this is not a match end.
+   */
+  sprintf(search_input, "%sZ", input);
+  int i;
+  for (i = 0; i < 16; i++) {
+    int result;
+    if (!*search) {
+      search = search_set;
+    }
+    search_input[input_size] = *search++;
+    result = pcre_exec(compiled_regex, NULL, search_input, input_size + 1, 0, 0,
+      ovector, sizeof(ovector) / sizeof(ovector[0]));
+    if (result > 0) return 0;
+  }
+  return 1;
+}
+
+static VALUE method_find_match(VALUE self, VALUE buffer)
+{
+  VALUE RubySpeech  = rb_const_get(rb_cObject, rb_intern("RubySpeech"));
+  VALUE GRXML       = rb_const_get(RubySpeech, rb_intern("GRXML"));
+  VALUE NoMatch     = rb_const_get(GRXML, rb_intern("NoMatch"));
+  pcre *compiled_regex;
+  int result = 0;
+  int ovector[OVECTOR_SIZE];
+  int workspace[WORKSPACE_SIZE];
+  char *input = StringValueCStr(buffer);
+
+  Data_Get_Struct(rb_iv_get(self, "@regex"), pcre, compiled_regex);
+
+  if (!compiled_regex) {
+    return rb_class_new_instance(0, NULL, NoMatch);
+  }
+
+  result = pcre_dfa_exec(compiled_regex, NULL, input, (int)strlen(input), 0, PCRE_PARTIAL,
+    ovector, sizeof(ovector) / sizeof(ovector[0]),
+    workspace, sizeof(workspace) / sizeof(workspace[0]));
+
+  if (result > 0) {
+    if (is_match_end(compiled_regex, input)) {
+      return rb_funcall(self, rb_intern("match_for_buffer"), 2, buffer, Qtrue);
+    }
+    return rb_funcall(self, rb_intern("match_for_buffer"), 1, buffer);
+  }
+  if (result == PCRE_ERROR_PARTIAL) {
+    VALUE PotentialMatch = rb_const_get(GRXML, rb_intern("PotentialMatch"));
+    return rb_class_new_instance(0, NULL, PotentialMatch);
+  }
+  return rb_class_new_instance(0, NULL, NoMatch);
+}
+
+void Init_ruby_speech()
+{
+  VALUE RubySpeech  = rb_define_module("RubySpeech");
+  VALUE GRXML       = rb_define_module_under(RubySpeech, "GRXML");
+  VALUE Matcher     = rb_define_class_under(GRXML, "Matcher", rb_cObject);
+
+  rb_define_method(Matcher, "find_match", method_find_match, 1);
+  rb_define_method(Matcher, "compile_regex", method_compile_regex, 1);
+}

data/lib/ruby_speech/generic_element.rb

@@ -0,0 +1,169 @@
+require 'active_support/core_ext/class/attribute'
+
+module RubySpeech
+  module GenericElement
+
+    def self.included(klass)
+      klass.class_attribute :registered_ns, :registered_name, :defaults
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      @@registrations = {}
+
+      # Register a new stanza class to a name and/or namespace
+      #
+      # This registers a namespace that is used when looking
+      # up the class name of the object to instantiate when a new
+      # stanza is received
+      #
+      # @param [#to_s] name the name of the node
+      #
+      def register(name)
+        self.registered_name = name.to_s
+        self.registered_ns = namespace
+        @@registrations[[self.registered_name, self.registered_ns]] = self
+      end
+
+      # Find the class to use given the name and namespace of a stanza
+      #
+      # @param [#to_s] name the name to lookup
+      #
+      # @return [Class, nil] the class appropriate for the name
+      def class_from_registration(name)
+        @@registrations[[name.to_s, namespace]]
+      end
+
+      # Import an XML::Node to the appropriate class
+      #
+      # Looks up the class the node should be then creates it based on the
+      # elements of the XML::Node
+      # @param [XML::Node] node the node to import
+      # @return the appropriate object based on the node name and namespace
+      def import(node)
+        node = Nokogiri::XML.parse(node, nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS).root unless node.is_a?(Nokogiri::XML::Node)
+        return node.content if node.is_a?(Nokogiri::XML::Text)
+        klass = class_from_registration node.node_name
+        if klass && klass != self
+          klass.import node
+        else
+          new.inherit node
+        end
+      end
+
+      def new(atts = {}, &block)
+        super(self.registered_name, nil, self.namespace) do |new_node|
+          (self.defaults || {}).merge(atts).each_pair { |k, v| new_node.send :"#{k}=", v }
+          block_return = new_node.eval_dsl_block &block
+          new_node.string block_return if block_return.is_a?(String) && block_return.present?
+        end
+      end
+    end
+
+    attr_writer :parent
+
+    def parent
+      @parent || super
+    end
+
+    def inherit(node)
+      self.parent = node.parent
+      super
+    end
+
+    def version
+      read_attr :version
+    end
+
+    def version=(other)
+      self[:version] = other
+    end
+
+    ##
+    # @return [String] the base URI to which relative URLs are resolved
+    #
+    def base_uri
+      read_attr 'xml:base'
+    end
+
+    ##
+    # @param [String] uri the base URI to which relative URLs are resolved
+    #
+    def base_uri=(uri)
+      self['xml:base'] = uri
+    end
+
+    def +(other)
+      self.class.new(:base_uri => base_uri).tap do |new_element|
+        (self.children + other.children).each do |child|
+          new_element << child
+        end
+      end
+    end
+
+    def eval_dsl_block(&block)
+      return unless block_given?
+      @block_binding = eval "self", block.binding
+      instance_eval &block
+    end
+
+    def children(type = nil, attributes = nil)
+      if type
+        expression = namespace_href ? 'ns:' : ''
+        expression << type.to_s
+
+        expression << '[' << attributes.inject([]) do |h, (key, value)|
+          h << "@#{namespace_href && Nokogiri.jruby? ? 'ns:' : ''}#{key}='#{value}'"
+        end.join(',') << ']' if attributes
+
+        xpath expression, :ns => namespace_href
+      else
+        super()
+      end.map { |c| self.class.import c }
+    end
+
+    def embed(other)
+      case other
+      when String
+        string other
+      when self.class.root_element
+        other.children.each do |child|
+          self << child
+        end
+      when self.class.module::Element
+        self << other
+      else
+        raise ArgumentError, "Can only embed a String or a #{self.class.module} element, not a #{other}"
+      end
+    end
+
+    def string(other)
+      self << Nokogiri::XML::Text.new(other, document)
+    end
+
+    def method_missing(method_name, *args, &block)
+      const_name = method_name.to_s.sub('ssml', '').titleize.gsub(' ', '')
+      if self.class.module.const_defined?(const_name)
+        const = self.class.module.const_get const_name
+        embed const.new(*args, &block)
+      elsif @block_binding && @block_binding.respond_to?(method_name)
+        @block_binding.send method_name, *args, &block
+      else
+        super
+      end
+    end
+
+    def clone
+      GRXML.import to_xml
+    end
+
+    def traverse(&block)
+      nokogiri_children.each { |j| j.traverse &block }
+      block.call self
+    end
+
+    def eql?(o, *args)
+      super o, :content, :children, *args
+    end
+  end # Element
+end # RubySpeech

data/lib/ruby_speech/grxml/element.rb

@@ -0,0 +1,29 @@
+require 'active_support/core_ext/class/attribute'
+
+module RubySpeech
+  module GRXML
+    class Element < Niceogiri::XML::Node
+      def self.namespace
+        GRXML_NAMESPACE
+      end
+
+      def self.root_element
+        Grammar
+      end
+
+      def self.module
+        GRXML
+      end
+
+      alias_method :nokogiri_children, :children
+
+      alias :to_doc :document
+
+      include GenericElement
+
+      def regexp_content # :nodoc:
+        "(#{children.map(&:regexp_content).join})"
+      end
+    end # Element
+  end # GRXML
+end # RubySpeech