ruby_speech 0.4.0 → 0.5.0

data/lib/ruby_speech/grxml/item.rb

@@ -31,17 +31,6 @@ module RubySpeech
 
       VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, OneOf, Item, String, Ruleref, Tag, Token].freeze
 
-      ##
-      # Create a new GRXML item element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Item] an element for use in an GRXML document
-      #
-      def self.new(atts = {}, &block)
-        super 'item', atts, &block
-      end
-
       ##
       #
       # The optional weight attribute
@@ -83,6 +72,7 @@ module RubySpeech
       # @param [String] r
       #
       def repeat=(r)
+        r = "#{r.min}-#{r.max}" if r.is_a?(Range)
         r = r.to_s
         error = ArgumentError.new "A Item's repeat must be 0 or a positive integer"
 
@@ -130,6 +120,17 @@ module RubySpeech
       def eql?(o)
         super o, :weight, :repeat
       end
+
+      def regexp_content # :nodoc:
+        return super unless repeat
+
+        if repeat.include?('-')
+          min, max = repeat.split '-'
+          "#{super}{#{min},#{max}}"
+        else
+          "#{super}{#{repeat}}"
+        end
+      end
     end # Item
   end # GRXML
 end # RubySpeech

data/lib/ruby_speech/grxml/match.rb

@@ -0,0 +1,16 @@
+module RubySpeech
+  module GRXML
+    class Match
+      attr_accessor :mode, :confidence, :utterance, :interpretation
+
+      def initialize(options = {})
+        options.each_pair { |k, v| self.send :"#{k}=", v }
+      end
+
+      def eql?(o)
+        o.is_a?(self.class) && [:mode, :confidence, :utterance, :interpretation].all? { |f| self.__send__(f) == o.__send__(f) }
+      end
+      alias :== :eql?
+    end
+  end
+end

data/lib/ruby_speech/grxml/no_match.rb

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

data/lib/ruby_speech/grxml/one_of.rb

@@ -18,21 +18,14 @@ module RubySpeech
 
       VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, Item].freeze
 
-      ##
-      # Create a new GRXML one-of element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [OneOf] an element for use in an GRXML document
-      #
-      def self.new(atts = {}, &block)
-        super 'one-of', atts, &block
-      end
-
       def <<(arg)
         raise InvalidChildError, "A OneOf can only accept Item as children" unless VALID_CHILD_TYPES.include? arg.class
         super
       end
+
+      def regexp_content # :nodoc:
+        "(#{children.map(&:regexp_content).join '|'})"
+      end
     end # OneOf
   end # GRXML
 end # RubySpeech

data/lib/ruby_speech/grxml/rule.rb

@@ -21,17 +21,6 @@ module RubySpeech
 
       VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, OneOf, Item, Ruleref, Tag, Token].freeze
 
-      ##
-      # Create a new GRXML rule element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Rule] an element for use in an GRXML document
-      #
-      def self.new(atts = {}, &block)
-        super 'rule', atts, &block
-      end
-
       ##
       #
       # The id attribute is the unique name to identify the rule

data/lib/ruby_speech/grxml/ruleref.rb

@@ -18,17 +18,6 @@ module RubySpeech
 
       register :ruleref
 
-      ##
-      # Create a new GRXML ruleref element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Ruleref] an element for use in an GRXML document
-      #
-      def self.new(atts = {}, &block)
-        super 'ruleref', atts, &block
-      end
-
       ##
       # XML URI: in the XML Form of this specification any URI is provided as an attribute to an element; for example the ruleref and lexicon elements.
       #

data/lib/ruby_speech/grxml/tag.rb

@@ -16,17 +16,6 @@ module RubySpeech
 
       VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String].freeze
 
-      ##
-      # Create a new GRXML tag element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Tag] an element for use in an GRXML document
-      #
-      def self.new(atts = {}, &block)
-        super 'tag', atts, &block
-      end
-
       def <<(arg)
         raise InvalidChildError, "A Tag can only accept Strings as children" unless VALID_CHILD_TYPES.include? arg.class
         super

data/lib/ruby_speech/grxml/token.rb

@@ -14,21 +14,18 @@ module RubySpeech
 
       VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String].freeze
 
-      ##
-      # Create a new GRXML token element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Token] an element for use in an GRXML document
-      #
-      def self.new(atts = {}, &block)
-        super 'token', atts, &block
-      end
-
       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/ssml.rb

@@ -5,11 +5,17 @@ module RubySpeech
     eager_autoload do
       autoload :Audio
       autoload :Break
+      autoload :Desc
       autoload :Element
       autoload :Emphasis
+      autoload :Mark
+      autoload :P
+      autoload :Phoneme
       autoload :Prosody
+      autoload :S
       autoload :SayAs
       autoload :Speak
+      autoload :Sub
       autoload :Voice
     end
 

data/lib/ruby_speech/ssml/audio.rb

@@ -16,18 +16,7 @@ module RubySpeech
 
       register :audio
 
-      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text,String, Audio, Break, Emphasis, Prosody, SayAs, Voice].freeze
-
-      ##
-      # Create a new SSML audio element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Break] an element for use in an SSML document
-      #
-      def self.new(atts = {}, &block)
-        super 'audio', atts, &block
-      end
+      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

data/lib/ruby_speech/ssml/break.rb

@@ -11,17 +11,6 @@ module RubySpeech
 
       VALID_STRENGTHS = [:none, :'x-weak', :weak, :medium, :strong, :'x-strong'].freeze
 
-      ##
-      # Create a new SSML break element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Break] an element for use in an SSML document
-      #
-      def self.new(atts = {}, &block)
-        super 'break', atts, &block
-      end
-
       ##
       # 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.
       #

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/emphasis.rb

@@ -10,18 +10,7 @@ module RubySpeech
       register :emphasis
 
       VALID_LEVELS = [:strong, :moderate, :none, :reduced].freeze
-      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Prosody, SayAs, Voice].freeze
-
-      ##
-      # Create a new SSML emphasis element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Emphasis] an element for use in an SSML document
-      #
-      def self.new(atts = {}, &block)
-        super 'emphasis', atts, &block
-      end
+      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.

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)
+        write_attr :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)
+        write_attr :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)
+        write_attr :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

data/lib/ruby_speech/ssml/prosody.rb

@@ -18,18 +18,7 @@ module RubySpeech
       VALID_PITCHES     = [:'x-low', :low, :medium, :high, :'x-high', :default].freeze
       VALID_VOLUMES     = [:silent, :'x-soft', :soft, :medium, :loud, :'x-loud', :default].freeze
       VALID_RATES       = [:'x-slow', :slow, :medium, :fast, :'x-fast', :default].freeze
-      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Prosody, SayAs, Voice].freeze
-
-      ##
-      # Create a new SSML prosody element
-      #
-      # @param [Hash] atts Key-value pairs of options mapping to setter methods
-      #
-      # @return [Prosody] an element for use in an SSML document
-      #
-      def self.new(atts = {}, &block)
-        super 'prosody', atts, &block
-      end
+      VALID_CHILD_TYPES = [Nokogiri::XML::Element, Nokogiri::XML::Text, String, Audio, Break, Emphasis, Mark, P, Phoneme, Prosody, S, SayAs, Sub, Voice].freeze
 
       ##
       # The baseline pitch for the contained text. Although the exact meaning of "baseline pitch" will vary across synthesis processors, increasing/decreasing this value will typically increase/decrease the approximate pitch of the output. Legal values are: a number followed by "Hz", a relative change or "x-low", "low", "medium", "high", "x-high", or "default". Labels "x-low" through "x-high" represent a sequence of monotonically non-decreasing pitch levels.