ruby_speech 2.1.0-java

data/lib/ruby_speech/grxml/tag.rb

@@ -0,0 +1,29 @@
+module RubySpeech
+  module GRXML
+    ##
+    #
+    # The tag element is one of the valid expansion elements for the SGR rule element
+    #
+    #   http://www.w3.org/TR/speech-grammar/#S2.6
+    #
+    #
+    # TODO: Make sure this is complete...
+    #
+    #
+    class Tag < Element
+
+      register :tag
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String].freeze
+
+      def <<(arg)
+        raise InvalidChildError, "A Tag can only accept Strings as children" unless VALID_CHILD_TYPES.include? arg.class
+        super
+      end
+
+      def regexp_content # :nodoc:
+        "?<#{content}>"
+      end
+    end # Tag
+  end # GRXML
+end # RubySpeech

data/lib/ruby_speech/grxml/token.rb

@@ -0,0 +1,31 @@
+module RubySpeech
+  module GRXML
+    ##
+    #
+    # A token (a.k.a. a terminal symbol) is the part of a grammar that defines words or other entities that may be spoken. Any legal token is a legal expansion.
+    #
+    #   http://www.w3.org/TR/speech-grammar/#S2.1
+    #
+    #  The token element may include an optional xml:lang attribute to indicate the language of the contained token.
+    #
+    class Token < Element
+
+      register :token
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String].freeze
+
+      def <<(arg)
+        raise InvalidChildError, "A Token can only accept Strings as children" unless VALID_CHILD_TYPES.include? arg.class
+        super
+      end
+
+      def normalize_whitespace
+        self.content = content.strip.squeeze ' '
+      end
+
+      def regexp_content # :nodoc:
+        Regexp.escape content
+      end
+    end # Token
+  end # GRXML
+end # RubySpeech

data/lib/ruby_speech/grxml.rb

@@ -0,0 +1,39 @@
+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'
+
+    def self.draw(attributes = {}, &block)
+      Grammar.new(attributes).tap do |grammar|
+        block_return = grammar.eval_dsl_block &block
+        grammar << block_return if block_return.is_a?(String)
+      end.assert_has_matching_root_rule
+    end
+
+    def self.import(other)
+      Element.import other
+    end
+  end # GRXML
+end # RubySpeech
+
+ActiveSupport::Autoload.eager_autoload!

data/lib/ruby_speech/nlsml/builder.rb

@@ -0,0 +1,34 @@
+module RubySpeech
+  module NLSML
+    class Builder
+      attr_reader :document
+
+      def initialize(options = {}, &block)
+        options = {'xmlns' => NLSML_NAMESPACE}.merge(options)
+        @document = Nokogiri::XML::Builder.new do |builder|
+          builder.result options do |r|
+            apply_block r, &block
+          end
+        end.doc
+      end
+
+      def interpretation(*args, &block)
+        if args.last.respond_to?(:has_key?) && args.last.has_key?(:confidence)
+          args.last[:confidence] = args.last[:confidence].to_f
+        end
+        @result.send :interpretation, *args, &block
+      end
+
+      def method_missing(method_name, *args, &block)
+        @result.send method_name, *args, &block
+      end
+
+      private
+
+      def apply_block(result, &block)
+        @result = result
+        instance_eval &block
+      end
+    end
+  end
+end

data/lib/ruby_speech/nlsml/document.rb

@@ -0,0 +1,120 @@
+require 'delegate'
+
+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
+      end
+
+      def grammar
+        result['grammar']
+      end
+
+      def interpretations
+        interpretation_nodes.map do |interpretation|
+          interpretation_hash_for_interpretation interpretation
+        end
+      end
+
+      def best_interpretation
+        interpretation_hash_for_interpretation interpretation_nodes.first
+      end
+
+      def match?
+        interpretation_nodes.count > 0 && !nomatch? && !noinput?
+      end
+
+      def ==(other)
+        to_xml == other.to_xml
+      end
+
+      def noinput?
+        noinput_elements.any?
+      end
+
+      private
+
+      def nomatch?
+        nomatch_elements.count >= input_elements.count
+      end
+
+      def nomatch_elements
+        result.xpath 'ns:interpretation/ns:input/ns:nomatch', 'ns' => NLSML_NAMESPACE
+      end
+
+      def noinput_elements
+        result.xpath 'ns:interpretation/ns:input/ns:noinput', 'ns' => NLSML_NAMESPACE
+      end
+
+      def input_elements
+        result.xpath 'ns:interpretation/ns:input', 'ns' => NLSML_NAMESPACE
+      end
+
+      def input_hash_for_interpretation(interpretation)
+        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
+      end
+
+      def instance_hash_for_interpretation(interpretation)
+        instances = instance_elements interpretation
+        return unless instances.any?
+        element_children_key_value instances.first
+      end
+
+      def instances_collection_for_interpretation(interpretation)
+        instances = instance_elements interpretation
+        instances.map do |instance|
+          element_children_key_value instance
+        end
+      end
+
+      def instance_elements(interpretation)
+        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
+            child.content
+          when 1
+            if child.children.first.is_a?(Nokogiri::XML::Text)
+              child.children.first.content
+            else
+              element_children_key_value child
+            end
+          else
+            element_children_key_value child
+          end
+          acc
+        end
+      end
+
+      def interpretation_hash_for_interpretation(interpretation)
+        {
+          confidence: interpretation['confidence'].to_f,
+          input: input_hash_for_interpretation(interpretation),
+          instance: instance_hash_for_interpretation(interpretation),
+          instances: instances_collection_for_interpretation(interpretation)
+        }
+      end
+
+      def result
+        root
+      end
+
+      def interpretation_nodes
+        nodes = result.xpath 'ns:interpretation', 'ns' => NLSML_NAMESPACE
+        nodes.sort_by { |int| -int[:confidence].to_f }
+      end
+    end
+  end
+end

data/lib/ruby_speech/nlsml.rb

@@ -0,0 +1,18 @@
+module RubySpeech
+  module NLSML
+    extend ActiveSupport::Autoload
+
+    NLSML_NAMESPACE = 'http://www.ietf.org/xml/ns/mrcpv2'
+
+    eager_autoload do
+      autoload :Builder
+      autoload :Document
+    end
+
+    def self.draw(options = {}, &block)
+      Builder.new(options, &block).document
+    end
+  end
+end
+
+ActiveSupport::Autoload.eager_autoload!

data/lib/ruby_speech/ssml/audio.rb

@@ -0,0 +1,47 @@
+module RubySpeech
+  module SSML
+    ##
+    # The audio element supports the insertion of recorded audio files (see Appendix A for required formats) and the insertion of other audio formats in conjunction with synthesized speech output. The audio element may be empty. If the audio element is not empty then the contents should be the marked-up text to be spoken if the audio document is not available. The alternate content may include text, speech markup, desc elements, or other audio elements. The alternate content may also be used when rendering the document to non-audible output and for accessibility (see the desc element). The required attribute is src, which is the URI of a document with an appropriate MIME type.
+    #
+    # An audio element is successfully rendered:
+    #   * If the referenced audio source is played, or
+    #   * If the synthesis processor is unable to execute #1 but the alternative content is successfully rendered, or
+    #   * If the processor can detect that text-only output is required and the alternative content is successfully rendered.
+    #
+    # Deciding which conditions result in the alternative content being rendered is processor-dependent. If the audio element is not successfully rendered, a synthesis processor should continue processing and should notify the hosting environment. The processor may determine after beginning playback of an audio source that the audio cannot be played in its entirety. For example, encoding problems, network disruptions, etc. may occur. The processor may designate this either as successful or unsuccessful rendering, but it must document this behavior.
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.3.1
+    #
+    class Audio < Element
+
+      register :audio
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Desc, Emphasis, Mark, P, Phoneme, Prosody, S, SayAs, Sub, Voice].freeze
+
+      ##
+      # The URI of a document with an appropriate MIME type
+      #
+      # @return [String]
+      #
+      def src
+        read_attr :src
+      end
+
+      ##
+      # @param [String] the source. Must be a valid URI
+      #
+      def src=(s)
+        self[:src] = s
+      end
+
+      def <<(arg)
+        raise InvalidChildError, "An Audio 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 eql?(o)
+        super o, :src
+      end
+    end # Audio
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/break.rb

@@ -0,0 +1,62 @@
+module RubySpeech
+  module SSML
+    ##
+    # The break element is an empty element that controls the pausing or other prosodic boundaries between words. The use of the break element between any pair of words is optional. If the element is not present between words, the synthesis processor is expected to automatically determine a break based on the linguistic context. In practice, the break element is most often used to override the typical automatic behavior of a synthesis processor.
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.2.3
+    #
+    class Break < Element
+
+      register :break
+
+      VALID_STRENGTHS = [:none, :'x-weak', :weak, :medium, :strong, :'x-strong'].freeze
+
+      ##
+      # This attribute is used to indicate the strength of the prosodic break in the speech output. The value "none" indicates that no prosodic break boundary should be outputted, which can be used to prevent a prosodic break which the processor would otherwise produce. The other values indicate monotonically non-decreasing (conceptually increasing) break strength between words. The stronger boundaries are typically accompanied by pauses. "x-weak" and "x-strong" are mnemonics for "extra weak" and "extra strong", respectively.
+      #
+      # @return [Symbol]
+      #
+      def strength
+        read_attr :strength, :to_sym
+      end
+
+      ##
+      # @param [Symbol] the strength. Must be one of VALID_STRENGTHS
+      #
+      # @raises ArgumentError if s is not one of VALID_STRENGTHS
+      #
+      def strength=(s)
+        raise ArgumentError, "You must specify a valid strength (#{VALID_STRENGTHS.map(&:inspect).join ', '})" unless VALID_STRENGTHS.include? s
+        self[:strength] = s
+      end
+
+      ##
+      # Indicates the duration of a pause to be inserted in the output in seconds or milliseconds. It follows the time value format from the Cascading Style Sheets Level 2 Recommendation [CSS2], e.g. "250ms", "3s".
+      #
+      # @return [Float]
+      #
+      def time
+        read_attr :time, :to_f
+      end
+
+      ##
+      # @param [Numeric] t the time as a positive value in seconds
+      #
+      # @raises ArgumentError if t is nota positive numeric value
+      #
+      def time=(t)
+        raise ArgumentError, "You must specify a valid time (positive float value in seconds)" unless t.is_a?(Numeric) && t >= 0
+        self[:time] = "#{t}s"
+      end
+
+      def <<(*args)
+        raise InvalidChildError, "A Break cannot contain children"
+        super
+      end
+
+      def eql?(o)
+        super o, :strength, :time
+      end
+    end # Break
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/desc.rb

@@ -0,0 +1,24 @@
+module RubySpeech
+  module SSML
+    ##
+    # The emphasis element requests that the contained text be spoken with emphasis (also referred to as prominence or stress). The synthesis processor determines how to render emphasis since the nature of emphasis differs between languages, dialects or even voices.
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.2.2
+    #
+    class Desc < Element
+
+      register :desc
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Text, String].freeze
+
+      def <<(arg)
+        raise InvalidChildError, "A Desc can only accept Strings as children" unless VALID_CHILD_TYPES.include? arg.class
+        super
+      end
+
+      def eql?(o)
+        super o, :language
+      end
+    end # Desc
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/element.rb

@@ -0,0 +1,23 @@
+require 'active_support/core_ext/class/attribute'
+
+module RubySpeech
+  module SSML
+    class Element < Niceogiri::XML::Node
+      def self.namespace
+        SSML_NAMESPACE
+      end
+
+      def self.root_element
+        Speak
+      end
+
+      def self.module
+        SSML
+      end
+
+      include GenericElement
+
+      alias :to_doc :document
+    end # Element
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/emphasis.rb

@@ -0,0 +1,44 @@
+module RubySpeech
+  module SSML
+    ##
+    # The emphasis element requests that the contained text be spoken with emphasis (also referred to as prominence or stress). The synthesis processor determines how to render emphasis since the nature of emphasis differs between languages, dialects or even voices.
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.2.2
+    #
+    class Emphasis < Element
+
+      register :emphasis
+
+      VALID_LEVELS = [:strong, :moderate, :none, :reduced].freeze
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, Voice].freeze
+
+      ##
+      # Indicates the strength of emphasis to be applied. Defined values are "strong", "moderate", "none" and "reduced". The default level is "moderate". The meaning of "strong" and "moderate" emphasis is interpreted according to the language being spoken (languages indicate emphasis using a possible combination of pitch change, timing changes, loudness and other acoustic differences). The "reduced" level is effectively the opposite of emphasizing a word. For example, when the phrase "going to" is reduced it may be spoken as "gonna". The "none" level is used to prevent the synthesis processor from emphasizing words that it might typically emphasize. The values "none", "moderate", and "strong" are monotonically non-decreasing in strength.
+      #
+      # @return [Symbol]
+      #
+      def level
+        read_attr :level, :to_sym
+      end
+
+      ##
+      # @param [Symbol] l the level. Must be one of VALID_LEVELS
+      #
+      # @raises ArgumentError if l is not one of VALID_LEVELS
+      #
+      def level=(l)
+        raise ArgumentError, "You must specify a valid level (#{VALID_LEVELS.map(&:inspect).join ', '})" unless VALID_LEVELS.include? l
+        self[:level] = l
+      end
+
+      def <<(arg)
+        raise InvalidChildError, "An Emphasis 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, :level
+      end
+    end # Emphasis
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/mark.rb

@@ -0,0 +1,43 @@
+module RubySpeech
+  module SSML
+    ##
+    # A mark element is an empty element that places a marker into the text/tag sequence. It has one required attribute, name, which is of type xsd:token [SCHEMA2 §3.3.2]. The mark element can be used to reference a specific location in the text/tag sequence, and can additionally be used to insert a marker into an output stream for asynchronous notification. When processing a mark element, a synthesis processor must do one or both of the following:
+    #
+    # * inform the hosting environment with the value of the name attribute and with information allowing the platform to retrieve the corresponding position in the rendered output.
+    # * when audio output of the SSML document reaches the mark, issue an event that includes the required name attribute of the element. The hosting environment defines the destination of the event.
+    #
+    # The mark element does not affect the speech output process.
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.3.2
+    #
+    class Mark < Element
+
+      register :mark
+
+      ##
+      # This attribute is a token by which to reference the mark
+      #
+      # @return [String]
+      #
+      def name
+        read_attr :name
+      end
+
+      ##
+      # @param [String] the name token
+      #
+      def name=(other)
+        self[:name] = other
+      end
+
+      def <<(*args)
+        raise InvalidChildError, "A Mark cannot contain children"
+        super
+      end
+
+      def eql?(o)
+        super o, :name
+      end
+    end # Mark
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/p.rb

@@ -0,0 +1,25 @@
+module RubySpeech
+  module SSML
+    ##
+    # A p element represents a paragraph.
+    # The use of p elements is optional. Where text occurs without an enclosing p 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 P < Element
+
+      register :p
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, S, SayAs, Sub, Voice].freeze
+
+      def <<(arg)
+        raise InvalidChildError, "A P can only accept String, Audio, Break, Emphasis, Mark, Phoneme, Prosody, SayAs, Sub, S, Voice as children" unless VALID_CHILD_TYPES.include? arg.class
+        super
+      end
+
+      def eql?(o)
+        super o, :language
+      end
+    end # P
+  end # SSML
+end # RubySpeech

data/lib/ruby_speech/ssml/phoneme.rb

@@ -0,0 +1,72 @@
+module RubySpeech
+  module SSML
+    ##
+    # The phoneme element provides a phonemic/phonetic pronunciation for the contained text. The phoneme element may be empty. However, it is recommended that the element contain human-readable text that can be used for non-spoken rendering of the document. For example, the content may be displayed visually for users with hearing impairments.
+    #
+    # The ph attribute is a required attribute that specifies the phoneme/phone string.
+    #
+    # This element is designed strictly for phonemic and phonetic notations and is intended to be used to provide pronunciations for words or very short phrases. The phonemic/phonetic string does not undergo text normalization and is not treated as a token for lookup in the lexicon (see Section 3.1.4), while values in say-as and sub may undergo both. Briefly, phonemic strings consist of phonemes, language-dependent speech units that characterize linguistically significant differences in the language; loosely, phonemes represent all the sounds needed to distinguish one word from another in a given language. On the other hand, phonetic strings consist of phones, speech units that characterize the manner (puff of air, click, vocalized, etc.) and place (front, middle, back, etc.) of articulation within the human vocal tract and are thus independent of language; phones represent realized distinctions in human speech production.
+    #
+    # The alphabet attribute is an optional attribute that specifies the phonemic/phonetic alphabet. An alphabet in this context refers to a collection of symbols to represent the sounds of one or more human languages. The only valid values for this attribute are "ipa" (see the next paragraph) and vendor-defined strings of the form "x-organization" or "x-organization-alphabet". For example, the Japan Electronics and Information Technology Industries Association [JEITA] might wish to encourage the use of an alphabet such as "x-JEITA" or "x-JEITA-2000" for their phoneme alphabet [JEIDAALPHABET].
+    #
+    # Synthesis processors should support a value for alphabet of "ipa", corresponding to Unicode representations of the phonetic characters developed by the International Phonetic Association [IPA]. In addition to an exhaustive set of vowel and consonant symbols, this character set supports a syllable delimiter, numerous diacritics, stress symbols, lexical tone symbols, intonational markers and more. For this alphabet, legal ph values are strings of the values specified in Appendix 2 of [IPAHNDBK]. Informative tables of the IPA-to-Unicode mappings can be found at [IPAUNICODE1] and [IPAUNICODE2]. Note that not all of the IPA characters are available in Unicode. For processors supporting this alphabet,
+    #
+    # * The processor must syntactically accept all legal ph values.
+    # * The processor should produce output when given Unicode IPA codes that can reasonably be considered to belong to the current language.
+    # * The production of output when given other codes is entirely at processor discretion.
+    #
+    # It is an error if a value for alphabet is specified that is not known or cannot be applied by a synthesis processor. The default behavior when the alphabet attribute is left unspecified is processor-specific.
+    #
+    # The phoneme element itself can only contain text (no elements).
+    #
+    # http://www.w3.org/TR/speech-synthesis/#S3.1.9
+    #
+    class Phoneme < Element
+
+      register :phoneme
+
+      VALID_CHILD_TYPES = [Nokogiri::XML::Text, String].freeze
+
+      ##
+      # Specifies the phonemic/phonetic alphabet
+      #
+      # @return [String]
+      #
+      def alphabet
+        read_attr :alphabet
+      end
+
+      ##
+      # @param [String] other the phonemic/phonetic alphabet
+      #
+      def alphabet=(other)
+        self[:alphabet] = other
+      end
+
+      ##
+      # Specifies the phoneme/phone string.
+      #
+      # @return [String]
+      #
+      def ph
+        read_attr :ph
+      end
+
+      ##
+      # @param [String] other the phoneme/phone string.
+      #
+      def ph=(other)
+        self[:ph] = other
+      end
+
+      def <<(arg)
+        raise InvalidChildError, "A Phoneme can only accept Strings as children" unless VALID_CHILD_TYPES.include? arg.class
+        super
+      end
+
+      def eql?(o)
+        super o, :alphabet, :ph
+      end
+    end # Phoneme
+  end # SSML
+end # RubySpeech