ruby_speech 1.1.0 → 2.0.1

data/lib/ruby_speech/version.rb

@@ -1,3 +1,3 @@
 module RubySpeech
-  VERSION = "1.1.0"
+  VERSION = "2.0.1"
 end

data/ruby_speech.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |s|
   s.authors     = ["Ben Langfeld"]
   s.email       = ["ben@langfeld.me"]
   s.homepage    = "https://github.com/benlangfeld/ruby_speech"
-  s.summary     = %q{A ruby library for TTS & ASR document preparation}
+  s.summary     = %q{A Ruby library for TTS & ASR document preparation}
   s.description = %q{Prepare SSML and GRXML documents with ease}
 
   s.rubyforge_project = "ruby_speech"
@@ -18,6 +18,13 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
+  if RUBY_PLATFORM =~ /java/
+    s.platform = "java"
+    s.files << "lib/ruby_speech/ruby_speech.jar"
+  else
+    s.extensions = ['ext/ruby_speech/extconf.rb']
+  end
+
   s.add_runtime_dependency %q<niceogiri>, ["~> 1.1", ">= 1.1.1"]
   s.add_runtime_dependency %q<nokogiri>, ["~> 1.5", ">= 1.5.6"]
   s.add_runtime_dependency %q<activesupport>, [">= 3.0.7"]
@@ -27,9 +34,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency %q<ci_reporter>, [">= 1.6.3"]
   s.add_development_dependency %q<yard>, [">= 0.7.0"]
   s.add_development_dependency %q<rake>, [">= 0"]
-  s.add_development_dependency %q<mocha>, [">= 0"]
-  s.add_development_dependency %q<i18n>, [">= 0"]
   s.add_development_dependency %q<guard>, [">= 0.9.0"]
   s.add_development_dependency %q<guard-rspec>, [">= 0"]
   s.add_development_dependency %q<ruby_gntp>, [">= 0"]
+  s.add_development_dependency %q<guard-rake>, [">= 0"]
+  s.add_development_dependency %q<rake-compiler>, [">= 0"]
 end

data/spec/ruby_speech/grxml/grammar_spec.rb

@@ -336,534 +336,6 @@ module RubySpeech
           grammar.should == normalized_grammar
         end
       end
-
-      describe "matching against an input string" do
-        before do
-          subject.inline!
-          subject.tokenize!
-          subject.normalize_whitespace
-        end
-
-        context "with a grammar that takes a single specific digit" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digit' do
-              rule :id => 'digit' do
-                '6'
-              end
-            end
-          end
-
-          it "should match '6'" do
-            input = '6'
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '6',
-                                              :interpretation => 'dtmf-6'
-            subject.match(input).should == expected_match
-            input.should == '6'
-          end
-
-          %w{1 2 3 4 5 7 8 9 10 66 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes two specific digits" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                '5 6'
-              end
-            end
-          end
-
-          it "should match '56'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '56',
-                                              :interpretation => 'dtmf-5 dtmf-6'
-            subject.match('56').should == expected_match
-          end
-
-          it "should potentially match '5'" do
-            input = '5'
-            subject.match(input).should == GRXML::PotentialMatch.new
-            input.should == '5'
-          end
-
-          %w{* *7 #6 6* 1 2 3 4 6 7 8 9 10 65 57 46 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes star and a digit" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                '* 6'
-              end
-            end
-          end
-
-          it "should match '*6'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '*6',
-                                              :interpretation => 'dtmf-star dtmf-6'
-            subject.match('*6').should == expected_match
-          end
-
-          it "should potentially match '*'" do
-            subject.match('*').should == GRXML::PotentialMatch.new
-          end
-
-          %w{*7 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes hash and a digit" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                '# 6'
-              end
-            end
-          end
-
-          it "should match '#6'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '#6',
-                                              :interpretation => 'dtmf-pound dtmf-6'
-            subject.match('#6').should == expected_match
-          end
-
-          it "should potentially match '#'" do
-            subject.match('#').should == GRXML::PotentialMatch.new
-          end
-
-          %w{* *6 #7 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes two specific digits, via a ruleref, and whitespace normalization" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                ruleref :uri => '#star'
-                '" 6 "'
-              end
-
-              rule :id => 'star' do
-                '" * "'
-              end
-            end
-          end
-
-          it "should match '*6'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '*6',
-                                              :interpretation => 'dtmf-star dtmf-6'
-            subject.match('*6').should == expected_match
-          end
-
-          it "should potentially match '*'" do
-            subject.match('*').should == GRXML::PotentialMatch.new
-          end
-
-          %w{*7 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes a single digit alternative" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                one_of do
-                  item { '6' }
-                  item { '7' }
-                end
-              end
-            end
-          end
-
-          it "should match '6'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '6',
-                                              :interpretation => 'dtmf-6'
-            subject.match('6').should == expected_match
-          end
-
-          it "should match '7'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '7',
-                                              :interpretation => 'dtmf-7'
-            subject.match('7').should == expected_match
-          end
-
-          %w{* # 1 2 3 4 5 8 9 10 66 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes a double digit alternative" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                one_of do
-                  item do
-                    token { '6' }
-                    token { '5' }
-                  end
-                  item do
-                    token { '7' }
-                    token { '2' }
-                  end
-                end
-              end
-            end
-          end
-
-          it "should match '65'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '65',
-                                              :interpretation => 'dtmf-6 dtmf-5'
-            subject.match('65').should == expected_match
-          end
-
-          it "should match '72'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '72',
-                                              :interpretation => 'dtmf-7 dtmf-2'
-            subject.match('72').should == expected_match
-          end
-
-          %w{6 7}.each do |input|
-            it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
-            end
-          end
-
-          %w{* # 1 2 3 4 5 8 9 10 66 26 61 75}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes a triple digit alternative" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                one_of do
-                  item do
-                    token { '6' }
-                    token { '5' }
-                    token { '2' }
-                  end
-                  item do
-                    token { '7' }
-                    token { '2' }
-                    token { '8' }
-                  end
-                end
-              end
-            end
-          end
-
-          it "should match '652'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '652',
-                                              :interpretation => 'dtmf-6 dtmf-5 dtmf-2'
-            subject.match('652').should == expected_match
-          end
-
-          it "should match '728'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '728',
-                                              :interpretation => 'dtmf-7 dtmf-2 dtmf-8'
-            subject.match('728').should == expected_match
-          end
-
-          %w{6 65 7 72}.each do |input|
-            it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
-            end
-          end
-
-          %w{* # 1 2 3 4 5 8 9 10 66 26 61 75 729 654}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes two specific digits with the second being an alternative" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                string '*'
-                one_of do
-                  item { '6' }
-                  item { '7' }
-                end
-              end
-            end
-          end
-
-          it "should match '*6'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '*6',
-                                              :interpretation => 'dtmf-star dtmf-6'
-            subject.match('*6').should == expected_match
-          end
-
-          it "should match '*7'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '*7',
-                                              :interpretation => 'dtmf-star dtmf-7'
-            subject.match('*7').should == expected_match
-          end
-
-          it "should potentially match '*'" do
-            subject.match('*').should == GRXML::PotentialMatch.new
-          end
-
-          %w{*8 #6 6* 1 2 3 4 5 6 7 8 9 10 66 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes two specific digits with the first being an alternative" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                one_of do
-                  item { '6' }
-                  item { '7' }
-                end
-                string '*'
-              end
-            end
-          end
-
-          it "should match '6*'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '6*',
-                                              :interpretation => 'dtmf-6 dtmf-star'
-            subject.match('6*').should == expected_match
-          end
-
-          it "should match '7*'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '7*',
-                                              :interpretation => 'dtmf-7 dtmf-star'
-            subject.match('7*').should == expected_match
-          end
-
-          it "should potentially match '6'" do
-            subject.match('6').should == GRXML::PotentialMatch.new
-          end
-
-          it "should potentially match '7'" do
-            subject.match('7').should == GRXML::PotentialMatch.new
-          end
-
-          %w{8* 6# *6 *7 1 2 3 4 5 8 9 10 66 26 61}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes a specific digit, followed by a specific digit repeated an exact number of times" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                string '1'
-                item :repeat => 2 do
-                  '6'
-                end
-              end
-            end
-          end
-
-          it "should match '166'" do
-            expected_match = GRXML::Match.new :mode           => :dtmf,
-                                              :confidence     => 1,
-                                              :utterance      => '166',
-                                              :interpretation => 'dtmf-1 dtmf-6 dtmf-6'
-            subject.match('166').should == expected_match
-          end
-
-          %w{1 16}.each do |input|
-            it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
-            end
-          end
-
-          %w{1666 16666 17}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes a specific digit, followed by a specific digit repeated within a range" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                string '1'
-                item :repeat => 0..3 do
-                  '6'
-                end
-              end
-            end
-          end
-
-          {
-            '1' => 'dtmf-1',
-            '16' => 'dtmf-1 dtmf-6',
-            '166' => 'dtmf-1 dtmf-6 dtmf-6',
-            '1666' => 'dtmf-1 dtmf-6 dtmf-6 dtmf-6'
-          }.each_pair do |input, interpretation|
-            it "should match '#{input}'" do
-              expected_match = GRXML::Match.new :mode           => :dtmf,
-                                                :confidence     => 1,
-                                                :utterance      => input,
-                                                :interpretation => interpretation
-              subject.match(input).should == expected_match
-            end
-          end
-
-          %w{6 16666 17}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes a specific digit, followed by a specific digit repeated a minimum number of times" do
-          subject do
-            GRXML.draw :mode => :dtmf, :root => 'digits' do
-              rule :id => 'digits' do
-                string '1'
-                item :repeat => '2-' do
-                  '6'
-                end
-              end
-            end
-          end
-
-          {
-            '166' => 'dtmf-1 dtmf-6 dtmf-6',
-            '1666' => 'dtmf-1 dtmf-6 dtmf-6 dtmf-6',
-            '16666' => 'dtmf-1 dtmf-6 dtmf-6 dtmf-6 dtmf-6'
-          }.each_pair do |input, interpretation|
-            it "should match '#{input}'" do
-              expected_match = GRXML::Match.new :mode           => :dtmf,
-                                                :confidence     => 1,
-                                                :utterance      => input,
-                                                :interpretation => interpretation
-              subject.match(input).should == expected_match
-            end
-          end
-
-          %w{1 16}.each do |input|
-            it "should potentially match '#{input}'" do
-              subject.match(input).should == GRXML::PotentialMatch.new
-            end
-          end
-
-          %w{7 17}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-
-        context "with a grammar that takes a 4 digit pin terminated by hash, or the *9 escape sequence" do
-          subject do
-            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
-          end
-
-          {
-            '*9' => 'dtmf-star dtmf-9',
-            '1234#' => 'dtmf-1 dtmf-2 dtmf-3 dtmf-4 dtmf-pound',
-            '5678#' => 'dtmf-5 dtmf-6 dtmf-7 dtmf-8 dtmf-pound',
-            '1111#' => 'dtmf-1 dtmf-1 dtmf-1 dtmf-1 dtmf-pound'
-          }.each_pair do |input, interpretation|
-            it "should match '#{input}'" do
-              expected_match = GRXML::Match.new :mode           => :dtmf,
-                                                :confidence     => 1,
-                                                :utterance      => input,
-                                                :interpretation => interpretation
-              subject.match(input).should == expected_match
-            end
-          end
-
-          %w{* 1 12 123 1234}.each do |input|
-            it "should potentially match '#{input}'" do
-              pending
-              subject.match(input).should == GRXML::PotentialMatch.new
-            end
-          end
-
-          %w{11111 #1111 *7}.each do |input|
-            it "should not match '#{input}'" do
-              subject.match(input).should == GRXML::NoMatch.new
-            end
-          end
-        end
-      end
     end # Grammar
   end # GRXML
 end # RubySpeech