ruby_speech 2.1.0-java

data/spec/ruby_speech/grxml/max_match_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe MaxMatch do
+      it_behaves_like "match"
+
+      it { should be_a Match }
+
+      describe "equality" do
+        it "should never be equal to a MaxMatch" do
+          described_class.new.should_not eql(Match.new)
+        end
+      end
+    end
+  end
+end

data/spec/ruby_speech/grxml/no_match_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe NoMatch do
+      describe "equality" do
+        it "should be equal to another NoMatch" do
+          NoMatch.new.should == NoMatch.new
+        end
+
+        it "should not equal a match" do
+          NoMatch.new.should_not == Match.new
+        end
+      end
+    end
+  end
+end

data/spec/ruby_speech/grxml/one_of_spec.rb

@@ -0,0 +1,49 @@
+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 document }
+
+        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/potential_match_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module RubySpeech
+  module GRXML
+    describe PotentialMatch do
+      describe "equality" do
+        it "should be equal to another PotentialMatch" do
+          PotentialMatch.new.should == PotentialMatch.new
+        end
+
+        it "should not equal a match" do
+          PotentialMatch.new.should_not == Match.new
+        end
+      end
+    end
+  end
+end

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 document }
+
+        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 document }
+
+        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 document }
+
+        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,62 @@
+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 document }
+
+        it { should be_instance_of Token }
+
+        its(:content) { should == 'hello' }
+      end
+
+      describe "#language" do
+        before { subject.language = 'jp' }
+
+        its(:language) { should == 'jp' }
+      end
+
+      describe "#normalize_whitespace" do
+        it "should remove leading & trailing whitespace and collapse multiple spaces down to 1" do
+          element = Element.import '<token> Welcome to  San Francisco </token>'
+
+          element.normalize_whitespace
+
+          element.content.should == 'Welcome to San Francisco'
+        end
+      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
+
+        it "should allow chaining" do
+          subject << 'foo' << 'bar'
+          subject.content.should == 'foobar'
+        end
+      end
+    end # Token
+  end # GRXML
+end # RubySpeech