ruby_speech 2.1.2 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: caf6dc66fd5b216e0825c25c2df9c16324e955e1
-  data.tar.gz: ecd61a61b6a362521b6915d7eac46b47556f55c0
+  metadata.gz: ec0d77b52aa0d3a5f6984d3a966592337bf744b8
+  data.tar.gz: dd2535eab8d121f262017bd29cb881021652b1ea
 SHA512:
-  metadata.gz: 1a08ac02e15a99aaf0f4ec753cb22fbf63304d4d42df34215dffe15255d344cf2d06bc23ab448f2152069e1c074d3d47b9a4978a4e04a1a746124a5658ce8a1e
-  data.tar.gz: 4a96f1f2fb4a56a08f6328bd6caa89ec4b47ee8638ee1c0d2e7bd3e2a867274b1d19d43039b423144e7e195140380e474c1533109e5ca0d165fc919e3b63fc69
+  metadata.gz: 23a82e611e67b400e6fd06560e5ae7bcec8a68df565ac6c82378dcb2d86378ac75696b5f6399f39d275c8c98ec9cc0126209b60f1b78bf262bc2b97b65f7f453
+  data.tar.gz: 9816cb0183ec5138a976417b27beae562590eba32d205076294855a8160f763828bfc84a548fa603e5758970cc73affe65838e84dc541c4abf3054b5bd71ee2c

data/.travis.yml

@@ -1,7 +1,6 @@
 language: ruby
 
 rvm:
-  - 1.9.2
   - 1.9.3
   - 2.0.0
   - jruby-19mode
@@ -9,7 +8,7 @@ rvm:
   - ruby-head
 matrix:
   allow_failures:
-    # - rvm: jruby-19mode
+    - rvm: ruby-head
 before_install:
   - sudo apt-get install libpcre3 libpcre3-dev
 

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # [develop](https://github.com/benlangfeld/ruby_speech)
 
+# [2.2.0](https://github.com/benlangfeld/ruby_speech/compare/v2.1.2...v2.2.0) - [2013-06-26](https://rubygems.org/gems/ruby_speech/versions/2.2.0)
+  * Bugfix: Constant autoload in rbx C extensions doesn't work properly
+  * Bugfix: No longer subclass or copy nodes, use delegation instead
+  * Bugfix: Java 1.6 compatability
+  * CS: Remove niceogiri dependency
+  * CS: Remove autoloading
+  * CS: Depend on activesupport less
+
 # [2.1.2](https://github.com/benlangfeld/ruby_speech/compare/v2.1.1...v2.1.2) - [2013-06-05](https://rubygems.org/gems/ruby_speech/versions/2.1.2)
   * Bugfix: Allow wrapping a pre-parsed XML node nested arbitrary deeply as an NLSML document
 

data/README.md

@@ -1,9 +1,32 @@
 # RubySpeech
 RubySpeech is a library for constructing and parsing Text to Speech (TTS) and Automatic Speech Recognition (ASR) documents such as [SSML](http://www.w3.org/TR/speech-synthesis), [GRXML](http://www.w3.org/TR/speech-grammar/) and [NLSML](http://www.w3.org/TR/nl-spec/). Such documents can be constructed to be processed by TTS and ASR engines, parsed as the result from such, or used in the implementation of such engines.
 
+## Dependencies
+
+### pcre (except on JRuby)
+
+#### On OSX with Homebrew
+```
+brew install pcre
+```
+
+#### On Ubuntu/Debian
+```
+sudo apt-get install libpcre3 libpcre3-dev
+```
+
+#### On CentOS
+```
+sudo yum install pcre-devel
+```
+
 ## Installation
     gem install ruby_speech
 
+## Ruby Version Compatability
+  * CRuby 1.9.3+ (1.9.2 is unofficially supported, but not regularly tested)
+  * JRuby 1.7+
+
 ## Library
 
 ### SSML

data/ext/ruby_speech/extconf.rb

@@ -2,6 +2,8 @@ require 'mkmf'
 
 $LIBS << " -lpcre"
 
-abort "-----\n#{lib} is missing.\n-----" unless find_header('pcre.h')
+unless find_header('pcre.h')
+  abort "-----\nPCRE is missing. You must install it as per the README @ https://github.com/benlangfeld/ruby_speech\n-----"
+end
 
 create_makefile 'ruby_speech/ruby_speech'

data/ext/ruby_speech/ruby_speech.c

@@ -33,12 +33,15 @@ static int is_match_end(pcre *compiled_regex, const char *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 */
+  int i;
 
   /* 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.
    */
+  if (strlen(input) > MAX_INPUT_SIZE) {
+    return 0;
+  }
   sprintf(search_input, "%sZ", input);
-  int i;
   for (i = 0; i < 16; i++) {
     int result;
     if (!*search) {

data/lib/ruby_speech.rb

@@ -1,24 +1,13 @@
 %w{
-  active_support/dependencies/autoload
-  active_support/core_ext/object/blank
-  active_support/core_ext/numeric/time
-  active_support/core_ext/enumerable
-  niceogiri
+  nokogiri
+
+  ruby_speech/version
+  ruby_speech/ssml
+  ruby_speech/grxml
+  ruby_speech/nlsml
 }.each { |f| require f }
 
 module RubySpeech
-  extend ActiveSupport::Autoload
-
-  autoload :Version
-
-  eager_autoload do
-    autoload :GenericElement
-    autoload :SSML
-    autoload :GRXML
-    autoload :NLSML
-    autoload :XML
-  end
-
   def self.parse(string)
     document = Nokogiri::XML.parse string, nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS
     namespace = document.root.namespace
@@ -32,5 +21,3 @@ module RubySpeech
     end
   end
 end
-
-ActiveSupport::Autoload.eager_autoload!

data/lib/ruby_speech/generic_element.rb

@@ -41,34 +41,42 @@ module RubySpeech
       # @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)
+        node = Nokogiri::XML.parse(node, nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS).root unless node.is_a?(Nokogiri::XML::Node) || node.is_a?(GenericElement)
         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
+          new(node.document).inherit node
         end
       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
+    def initialize(doc, atts = nil, &block)
+      @doc = doc
+      build atts, &block if atts || block_given?
     end
 
     attr_writer :parent
 
+    def node
+      @node || create_node
+    end
+
     def parent
       @parent || super
     end
 
     def inherit(node)
       self.parent = node.parent
-      super
+      @node = node
+      self
+    end
+
+    def build(atts, &block)
+      mass_assign atts
+      block_return = eval_dsl_block &block
+      string block_return if block_return.is_a?(String) && !block_return.length.zero?
     end
 
     def version
@@ -94,9 +102,16 @@ module RubySpeech
     end
 
     def +(other)
-      self.class.new(:base_uri => base_uri).tap do |new_element|
-        (self.children + other.children).each do |child|
-          new_element << child
+      new_doc = Nokogiri::XML::Document.new
+      self.class.new(new_doc).tap do |new_element|
+        new_doc.root = new_element.node
+        if Nokogiri.jruby?
+          new_element.add_child self.nokogiri_children
+          new_element.add_child other.nokogiri_children
+        else
+          # TODO: This is yucky because it requires serialization
+          new_element.add_child self.nokogiri_children.to_xml
+          new_element.add_child other.nokogiri_children.to_xml
         end
       end
     end
@@ -113,15 +128,30 @@ module RubySpeech
         expression << type.to_s
 
         expression << '[' << attributes.inject([]) do |h, (key, value)|
-          h << "@#{namespace_href && Nokogiri.jruby? ? 'ns:' : ''}#{key}='#{value}'"
+          h << "@#{key}='#{value}'"
         end.join(',') << ']' if attributes
 
-        xpath expression, :ns => namespace_href
+        xpath expression, :ns => self.class.namespace
       else
         super()
       end.map { |c| self.class.import c }
     end
 
+    def nokogiri_children
+      node.children
+    end
+
+    def <<(other)
+      case other
+      when GenericElement
+        super other.node
+      when String
+        string other
+      else
+        super other
+      end
+    end
+
     def embed(other)
       case other
       when String
@@ -141,18 +171,6 @@ module RubySpeech
       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
@@ -162,8 +180,102 @@ module RubySpeech
       block.call self
     end
 
-    def eql?(o, *args)
-      super o, :content, :children, *args
+    # Helper method to read an attribute
+    #
+    # @param [#to_sym] attr_name the name of the attribute
+    # @param [String, Symbol, nil] to_call the name of the method to call on
+    # the returned value
+    # @return nil or the value
+    def read_attr(attr_name, to_call = nil)
+      val = self[attr_name]
+      val && to_call ? val.__send__(to_call) : val
+    end
+
+    # Helper method to write a value to an attribute
+    #
+    # @param [#to_sym] attr_name the name of the attribute
+    # @param [#to_s] value the value to set the attribute to
+    def write_attr(attr_name, value, to_call = nil)
+      self[attr_name] = value && to_call ? value.__send__(to_call) : value
+    end
+
+    # Attach a namespace to the node
+    #
+    # @overload namespace=(ns)
+    #   Attach an already created XML::Namespace
+    #   @param [XML::Namespace] ns the namespace object
+    # @overload namespace=(ns)
+    #   Create a new namespace and attach it
+    #   @param [String] ns the namespace uri
+    def namespace=(namespaces)
+      case namespaces
+      when Nokogiri::XML::Namespace
+        super namespaces
+      when String
+        ns = self.add_namespace nil, namespaces
+        super ns
+      end
+    end
+
+    # Helper method to get the node's namespace
+    #
+    # @return [XML::Namespace, nil] The node's namespace object if it exists
+    def namespace_href
+      namespace.href if namespace
+    end
+
+    # The node as XML
+    #
+    # @return [String] XML representation of the node
+    def inspect
+      self.to_xml
+    end
+
+    def to_s
+      to_xml
+    end
+
+    # Check that a set of fields are equal between nodes
+    #
+    # @param [Node] other the other node to compare against
+    # @param [*#to_s] fields the set of fields to compare
+    # @return [Fixnum<-1,0,1>]
+    def eql?(o, *fields)
+      o.is_a?(self.class) && ([:content, :children] + fields).all? { |f| self.__send__(f) == o.__send__(f) }
+    end
+
+    # @private
+    def ==(o)
+      eql?(o)
+    end
+
+    def create_node
+      @node = Nokogiri::XML::Node.new self.class.registered_name, @doc
+      mass_assign self.class.defaults
+      @node
+    end
+
+    def mass_assign(attrs)
+      attrs.each_pair { |k, v| send :"#{k}=", v } if attrs
+    end
+
+    def method_missing(method_name, *args, &block)
+      if node.respond_to?(method_name)
+        return node.send method_name, *args, &block
+      end
+
+      const_name = method_name.to_s.sub('ssml_', '').gsub('_', '-')
+      if const = self.class.class_from_registration(const_name)
+        embed const.new(self.document, *args, &block)
+      elsif @block_binding && @block_binding.respond_to?(method_name)
+        @block_binding.send method_name, *args, &block
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      node.respond_to?(method_name, include_private) || super
     end
   end # Element
 end # RubySpeech

data/lib/ruby_speech/grxml.rb

@@ -1,30 +1,26 @@
+require 'ruby_speech/grxml/matcher'
+require 'ruby_speech/grxml/element'
+
 module RubySpeech
   module GRXML
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Element
-      autoload :Grammar
-      autoload :Rule
-      autoload :Item
-      autoload :OneOf
-      autoload :Ruleref
-      autoload :Tag
-      autoload :Token
-    end
-
-    autoload :Match
-    autoload :Matcher
-    autoload :MaxMatch
-    autoload :NoMatch
-    autoload :PotentialMatch
-
     InvalidChildError = Class.new StandardError
 
     GRXML_NAMESPACE = 'http://www.w3.org/2001/06/grammar'
 
+    %w{
+      grammar
+      rule
+      item
+      one_of
+      ruleref
+      tag
+      token
+    }.each { |f| require "ruby_speech/grxml/#{f}" }
+
     def self.draw(attributes = {}, &block)
-      Grammar.new(attributes).tap do |grammar|
+      document = Nokogiri::XML::Document.new
+      Grammar.new(document, attributes).tap do |grammar|
+        document.root = grammar.node
         block_return = grammar.eval_dsl_block &block
         grammar << block_return if block_return.is_a?(String)
       end.assert_has_matching_root_rule
@@ -35,5 +31,3 @@ module RubySpeech
     end
   end # GRXML
 end # RubySpeech
-
-ActiveSupport::Autoload.eager_autoload!

data/lib/ruby_speech/grxml/element.rb

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