ruby_speech 0.2.2 → 0.3.0

data/spec/ruby_speech/grxml/grammar_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe Grammar do
+      it { should be_a_valid_grxml_document }
+
+      its(:name)      { should == 'grammar' }
+      its(:language)  { should == 'en-US' }
+
+      describe "setting options in initializers" do
+        subject { Grammar.new :language => 'jp', :base_uri => 'blah', :root => "main_rule", :tag_format => "semantics/1.0" }
+
+        its(:language)    { should == 'jp' }
+        its(:base_uri)    { should == 'blah' }
+        its(:root)        { should == 'main_rule' }
+        its(:tag_format)  { should == 'semantics/1.0' }
+      end
+
+      describe "setting dtmf mode" do
+        subject     { Grammar.new :mode => 'dtmf' }
+        its(:mode)  { should == 'dtmf' }
+      end
+
+      describe "setting voice mode" do
+        subject     { Grammar.new :mode => 'voice' }
+        its(:mode)  { should == 'voice' }
+      end
+
+      it 'registers itself' do
+        Element.class_from_registration(:grammar).should == Grammar
+      end
+
+      describe "from a document" do
+        let(:document) { '<grammar mode="dtmf" root="main_rule" version="1.0"  xml:lang="jp" xml:base="blah"
+                                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                                 xsi:schemaLocation="http://www.w3.org/2001/06/grammar
+                                                     http://www.w3.org/TR/speech-grammar/grammar.xsd"
+                                 xmlns="http://www.w3.org/2001/06/grammar" />' }
+
+        subject { Element.import parse_xml(document).root }
+
+        it { should be_instance_of Grammar }
+
+        its(:language)  { pending; should == 'jp' }
+        its(:base_uri)  { should == 'blah' }
+        its(:mode)      { should == 'dtmf' }
+        its(:root)      { should == 'main_rule' }
+      end
+
+      describe "#language" do
+        before { subject.language = 'jp' }
+
+        its(:language) { should == 'jp' }
+      end
+
+      describe "#base_uri" do
+        before { subject.base_uri = 'blah' }
+
+        its(:base_uri) { should == 'blah' }
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content, language and base uri are the same" do
+          Grammar.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there").should == Grammar.new(:language => 'en-GB', :base_uri => 'blah', :content => "Hello there")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Grammar.new(:content => "Hello").should_not == Grammar.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the language is different" do
+          it "should not be equal" do
+            Grammar.new(:language => 'en-US').should_not == Grammar.new(:language => 'en-GB')
+          end
+        end
+
+        describe "when the base URI is different" do
+          it "should not be equal" do
+            Grammar.new(:base_uri => 'foo').should_not == Grammar.new(:base_uri => 'bar')
+          end
+        end
+
+        describe "when the children are different" do
+          it "should not be equal" do
+            g1 = Grammar.new
+            g1 << Rule.new(:id => 'main1')
+            g2 = Grammar.new
+            g2 << Rule.new(:id => 'main2')
+
+            g1.should_not == g2
+          end
+        end
+      end
+
+      it "should allow creating child GRXML elements" do
+        g = Grammar.new
+        g.Rule :id => :main, :scope => 'public'
+        expected_g = Grammar.new
+        expected_g << Rule.new(:id => :main, :scope => 'public')
+        g.should == expected_g
+      end
+
+      describe "<<" do
+        it "should accept Rule" do
+          lambda { subject << Rule.new }.should_not raise_error
+        end
+
+        it "should accept Tag" do
+          lambda { subject << Tag.new }.should_not raise_error
+        end
+
+        it "should raise InvalidChildError with non-acceptable objects" do
+          lambda { subject << 1 }.should raise_error(InvalidChildError, "A Grammar can only accept Rule and Tag as children")
+        end
+      end
+
+      describe "#to_doc" do
+        let(:expected_doc) do
+          Nokogiri::XML::Document.new.tap do |doc|
+            doc << Grammar.new
+          end
+        end
+
+        it "should create an XML document from the grammar" do
+          Grammar.new.to_doc.to_s.should == expected_doc.to_s
+        end
+      end
+
+      describe "#tag_format" do
+        it "should allow setting tag-format identifier" do
+          lambda { subject.tag_format = "semantics/1.0" }.should_not raise_error
+        end
+      end
+
+      describe "concat" do
+        it "should allow concatenation" do
+          grammar1 = Grammar.new
+          grammar1 << Rule.new(:id => 'frank', :scope => 'public', :content => "Hi Frank")
+          grammar2 = Grammar.new
+          grammar2 << Rule.new(:id => 'millie', :scope => 'public', :content => "Hi Millie")
+
+          expected_concat = Grammar.new
+          expected_concat << Rule.new(:id => 'frank', :scope => 'public', :content => "Hi Frank")
+          expected_concat << Rule.new(:id => 'millie', :scope => 'public', :content => "Hi Millie")
+
+          concat = grammar1 + grammar2
+          concat.should == expected_concat
+          concat.to_s.should_not include('default')
+        end
+      end
+    end # Grammar
+  end # GRXML
+end # RubySpeech

data/spec/ruby_speech/grxml/item_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe Item do
+      subject { Item.new :weight => 1.1, :repeat => '1' }
+
+      its(:name) { should == 'item' }
+
+      its(:weight)  { should == 1.1 }
+      its(:repeat)  { should == '1' }
+
+      it 'registers itself' do
+        Element.class_from_registration(:item).should == Item
+      end
+
+      describe "everything from a document" do
+        let(:document) { '<item weight="1.1" repeat="1">one</item>' }
+
+        subject { Element.import parse_xml(document).root }
+
+        it { should be_instance_of Item }
+
+        its(:weight)  { should == 1.1 }
+        its(:repeat)  { should == '1' }
+        its(:content) { should == 'one' }
+      end
+
+      describe "#weight" do
+        context "from a document" do
+          subject { Element.import parse_xml(document).root }
+
+          describe "using .1" do
+            let(:document) { '<item weight=".1" repeat="1">one</item>' }
+            its(:weight)  { should == 0.1 }
+          end
+
+          describe "using 1." do
+            let(:document) { '<item weight="1." repeat="1">one</item>' }
+            its(:weight)  { should == 1.0 }
+          end
+
+          describe "using 1" do
+            let(:document) { '<item weight="1" repeat="1">one</item>' }
+            its(:weight)  { should == 1.0 }
+          end
+        end
+
+        context "positive floating point numbers" do
+          before { subject.weight = 1.1 }
+
+          its(:weight) { should == 1.1 }
+
+          it "with valid value" do
+            lambda { subject.weight = 1 }.should_not raise_error
+            lambda { subject.weight = 1.0 }.should_not raise_error
+            lambda { subject.weight = 0.1 }.should_not raise_error
+            lambda { subject.weight = '.1' }.should_not raise_error
+            lambda { subject.weight = '1.' }.should_not raise_error
+          end
+
+          it "with an invalid value" do
+            lambda { subject.weight = 'one' }.should raise_error(ArgumentError, "A Item's weight attribute must be a positive floating point number")
+            lambda { subject.weight = -1 }.should raise_error(ArgumentError, "A Item's weight attribute must be a positive floating point number")
+          end
+        end
+      end
+
+      # Validate various values for repeat -- http://www.w3.org/TR/speech-grammar/#S2.5
+      describe "#repeat" do
+        context "exact" do
+          it "valid values (0 or a positive integer)" do
+            lambda { subject.repeat = 0 }.should_not raise_error
+            lambda { subject.repeat = 5 }.should_not raise_error
+            lambda { subject.repeat = '1' }.should_not raise_error
+          end
+
+          it "invalid values" do
+            lambda { subject.repeat = -1 }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            lambda { subject.repeat = 'one' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+          end
+        end
+
+        context "ranges" do
+          it "valid ranges from m to n" do
+            lambda { subject.repeat = '1-5' }.should_not raise_error
+            lambda { subject.repeat = '0-5' }.should_not raise_error
+          end
+
+          it "illegal ranges from m to n" do
+            lambda { subject.repeat = '5-1' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            lambda { subject.repeat = '-1-2' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            lambda { subject.repeat = '1-2-3' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            lambda { subject.repeat = '1-B' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+          end
+
+          it "valid ranges of m or more" do
+            lambda { subject.repeat = '3-' }.should_not raise_error
+            lambda { subject.repeat = '0-' }.should_not raise_error
+          end
+
+          it "illegal ranges for m or more" do
+            lambda { subject.repeat = '-1-' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+            lambda { subject.repeat = 'B-' }.should raise_error(ArgumentError, "A Item's repeat must be 0 or a positive integer")
+          end
+        end
+      end
+
+      # repeat probability (repeat-prob) -- http://www.w3.org/TR/speech-grammar/#S2.5.1
+      describe "#repeat_prob" do
+        it "should handle all valid values" do
+          lambda { subject.repeat_prob = 0 }.should_not raise_error
+          lambda { subject.repeat_prob = 1 }.should_not raise_error
+          lambda { subject.repeat_prob = 1.0 }.should_not raise_error
+          lambda { subject.repeat_prob = '1.' }.should_not raise_error
+          lambda { subject.repeat_prob = '1.0' }.should_not raise_error
+          lambda { subject.repeat_prob = '.5' }.should_not raise_error
+        end
+
+        it "should raise an error for invalid values" do
+          lambda { subject.repeat_prob = -1 }.should raise_error(ArgumentError, "A Item's repeat probablity attribute must be a floating point number between 0.0 and 1.0")
+          lambda { subject.repeat_prob = 1.5 }.should raise_error(ArgumentError, "A Item's repeat probablity attribute must be a floating point number between 0.0 and 1.0")
+        end
+      end
+
+      describe "#language" do
+        before { subject.language = 'jp' }
+
+        its(:language) { should == 'jp' }
+      end
+
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+
+        it "should accept OneOf" do
+          lambda { subject << OneOf.new }.should_not raise_error
+        end
+
+        it "should accept Item" do
+          lambda { subject << Item.new }.should_not raise_error
+        end
+
+        it "should accept Ruleref" do
+          lambda { subject << Ruleref.new }.should_not raise_error
+        end
+
+        it "should accept Tag" do
+          lambda { subject << Tag.new }.should_not raise_error
+        end
+
+        it "should accept Token" do
+          lambda { subject << Token.new }.should_not raise_error
+        end
+      end
+    end # Item
+  end # GRXML
+end # RubySpeech

data/spec/ruby_speech/grxml/one_of_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe OneOf do
+      its(:name) { should == 'one-of' }
+
+      it 'registers itself' do
+        Element.class_from_registration(:'one-of').should == OneOf
+      end
+
+      describe "from a document" do
+        let(:document) { '<one-of> <item>test</item> </one-of>' }
+
+        subject { Element.import parse_xml(document).root }
+
+        it { should be_instance_of OneOf }
+      end
+
+      describe "#language" do
+        before { subject.language = 'fr-CA' }
+
+        its(:language) { should == 'fr-CA' }
+      end
+
+      describe "<<" do
+        it "should accept Item" do
+          lambda { subject << Item.new }.should_not raise_error
+        end
+
+        it "should raise InvalidChildError with non-acceptable objects" do
+          lambda { subject << 1 }.should raise_error(InvalidChildError, "A OneOf can only accept Item as children")
+        end
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the language (when specified) is the same" do
+          OneOf.new(:language => "jp").should == OneOf.new(:language => "jp")
+        end
+
+        describe "when the language is different" do
+          it "should not be equal" do
+            OneOf.new(:language => "jp").should_not == OneOf.new(:content => "fr-CA")
+          end
+        end
+      end
+
+    end # OneOf
+  end # GRXML
+end # RubySpeech

data/spec/ruby_speech/grxml/rule_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe Rule do
+      subject { Rule.new :id => 'one', :scope => 'public' }
+
+      its(:name) { should == 'rule' }
+
+      its(:id)    { should == :one }
+      its(:scope) { should == :public }
+
+      it 'registers itself' do
+        Element.class_from_registration(:rule).should == Rule
+      end
+
+      describe "from a document" do
+        let(:document) { '<rule id="one" scope="public"> <item /> </rule>' }
+
+        subject { Element.import parse_xml(document).root }
+
+        it { should be_instance_of Rule }
+
+        its(:id)    { should == :one }
+        its(:scope) { should == :public }
+      end
+
+      describe "#language" do
+        before { subject.language = 'jp' }
+
+        its(:language) { should == 'jp' }
+      end
+
+      describe "#id" do
+        before { subject.id = :main }
+
+        its(:id) { should == :main }
+
+        context "without an id" do
+          before { subject.id = nil }
+          pending
+        end
+
+        context "with a non-unique id" do
+          pending 'this should probably go into the grammar spec'
+        end
+      end
+
+      describe "#scope" do
+        before { subject.scope = :public }
+
+        its(:scope) { should == :public }
+
+        it "with a valid scope" do
+          lambda { subject.scope = :public }.should_not raise_error
+          lambda { subject.scope = :private }.should_not raise_error
+        end
+
+        it "with an invalid scope" do
+          lambda { subject.scope = :something }.should raise_error(ArgumentError, "A Rule's scope can only be 'public' or 'private'")
+        end
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content, language, id, and scope are the same" do
+          Rule.new(:language => 'jp', :id => :main, :scope => :public, :content => "hello").should == Rule.new(:language => 'jp', :id => :main, :scope => :public, :content => "hello")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Rule.new(:content => "Hello").should_not == Rule.new(:content => "Hello there")
+          end
+        end
+
+        describe "when the language is different" do
+          it "should not be equal" do
+            Rule.new(:language => "jp").should_not == Rule.new(:language => "esperanto")
+          end
+        end
+
+        describe "when the id is different" do
+          it "should not be equal" do
+            Rule.new(:id => :main).should_not == Rule.new(:id => :dtmf)
+          end
+        end
+
+        describe "when the scope is different" do
+          it "should not be equal" do
+            Rule.new(:scope => :public).should_not == Rule.new(:scope => :private)
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+
+        it "should accept OneOf" do
+          lambda { subject << OneOf.new }.should_not raise_error
+        end
+
+        it "should accept Item" do
+          lambda { subject << Item.new }.should_not raise_error
+        end
+
+        it "should accept Ruleref" do
+          lambda { subject << Ruleref.new }.should_not raise_error
+        end
+
+        it "should accept Tag" do
+          lambda { subject << Tag.new }.should_not raise_error
+        end
+
+        it "should accept Token" do
+          lambda { subject << Token.new }.should_not raise_error
+        end
+      end
+
+      it "should raise ArgumentError with any other scope" do
+        lambda { Rule.new :id => 'one', :scope => 'invalid_scope' }.should raise_error(ArgumentError, "A Rule's scope can only be 'public' or 'private'")
+      end
+    end # Rule
+  end # GRXML
+end # RubySpeech

data/spec/ruby_speech/grxml/ruleref_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe Ruleref do
+      subject { Ruleref.new :uri => '#testrule' }
+
+      its(:name)  { should == 'ruleref' }
+      its(:uri)   { should == '#testrule' }
+
+      it 'registers itself' do
+        Element.class_from_registration(:ruleref).should == Ruleref
+      end
+
+      describe "from a document" do
+        let(:document) { '<ruleref uri="#one" />' }
+
+        subject { Element.import parse_xml(document).root }
+
+        it { should be_instance_of Ruleref }
+
+        its(:uri) { should == '#one' }
+      end
+
+      describe "#special" do
+        subject { Ruleref.new }
+
+        context "with reserved values" do
+          it "with a valid value" do
+            lambda { subject.special = :NULL }.should_not raise_error
+            lambda { subject.special = :VOID }.should_not raise_error
+            lambda { subject.special = 'GARBAGE' }.should_not raise_error
+          end
+          it "with an invalid value" do
+            lambda { subject.special = :SOMETHINGELSE }.should raise_error
+          end
+        end
+      end
+
+      describe "#uri" do
+        it "allows implict, explicit and external references" do
+          lambda { subject.uri = '#dtmf' }.should_not raise_error
+          lambda { subject.uri = '../test.grxml' }.should_not raise_error
+          lambda { subject.uri = 'http://grammar.example.com/world-cities.grxml#canada' }.should_not raise_error
+        end
+      end
+
+      describe "only uri or special can be specified" do
+        it "should raise an error" do
+          lambda { subject << Ruleref.new(:uri => '#test', :special => :NULL) }.should raise_error(ArgumentError, "A Ruleref can only take uri or special")
+        end
+      end
+    end # Ruleref
+  end # GRXML
+end # RubySpeech

data/spec/ruby_speech/grxml/tag_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe Tag do
+      its(:name) { should == 'tag' }
+
+      it 'registers itself' do
+        Element.class_from_registration(:tag).should == Tag
+      end
+
+      describe "from a document" do
+        let(:document) { '<tag>hello</tag>' }
+
+        subject { Element.import parse_xml(document).root }
+
+        it { should be_instance_of Tag }
+
+        its(:content) { should == 'hello' }
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content is the same" do
+          Tag.new(:content => "hello").should == Tag.new(:content => "hello")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Tag.new(:content => "Hello").should_not == Tag.new(:content => "Hello there")
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+      end
+    end # Tag
+  end # GRXML
+end # RubySpeech

data/spec/ruby_speech/grxml/token_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe Token do
+      its(:name) { should == 'token' }
+
+      it 'registers itself' do
+        Element.class_from_registration(:token).should == Token
+      end
+
+      describe "from a document" do
+        let(:document) { '<token>hello</token>' }
+
+        subject { Element.import parse_xml(document).root }
+
+        it { should be_instance_of Token }
+
+        its(:content) { should == 'hello' }
+      end
+
+      describe "#language" do
+        before { subject.language = 'jp' }
+
+        its(:language) { should == 'jp' }
+      end
+
+      describe "comparing objects" do
+        it "should be equal if the content is the same" do
+          Token.new(:content => "hello").should == Token.new(:content => "hello")
+        end
+
+        describe "when the content is different" do
+          it "should not be equal" do
+            Token.new(:content => "Hello").should_not == Token.new(:content => "Hello there")
+          end
+        end
+      end
+
+      describe "<<" do
+        it "should accept String" do
+          lambda { subject << 'anything' }.should_not raise_error
+        end
+      end
+    end # Token
+  end # GRXML
+end # RubySpeech