ruby_speech 2.3.1-java → 3.0.1-java

data/spec/ruby_speech/grxml/one_of_spec.rb

@@ -10,7 +10,7 @@ module RubySpeech
       its(:name) { should == 'one-of' }
 
       it 'registers itself' do
-        Element.class_from_registration(:'one-of').should == OneOf
+        expect(Element.class_from_registration(:'one-of')).to eq(OneOf)
       end
 
       describe "from a document" do
@@ -18,7 +18,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of OneOf }
+        it { is_expected.to be_instance_of OneOf }
       end
 
       describe "#language" do
@@ -29,22 +29,22 @@ module RubySpeech
 
       describe "<<" do
         it "should accept Item" do
-          lambda { subject << Item.new(doc) }.should_not raise_error
+          expect { subject << Item.new(doc) }.not_to 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")
+          expect { subject << 1 }.to 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(doc, :language => "jp").should == OneOf.new(doc, :language => "jp")
+          expect(OneOf.new(doc, :language => "jp")).to eq(OneOf.new(doc, :language => "jp"))
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            OneOf.new(doc, :language => "jp").should_not == OneOf.new(doc, :content => "fr-CA")
+            expect(OneOf.new(doc, :language => "jp")).not_to eq(OneOf.new(doc, :content => "fr-CA"))
           end
         end
       end

data/spec/ruby_speech/grxml/potential_match_spec.rb

@@ -5,11 +5,11 @@ module RubySpeech
     describe PotentialMatch do
       describe "equality" do
         it "should be equal to another PotentialMatch" do
-          PotentialMatch.new.should == PotentialMatch.new
+          expect(PotentialMatch.new).to eq(PotentialMatch.new)
         end
 
         it "should not equal a match" do
-          PotentialMatch.new.should_not == Match.new
+          expect(PotentialMatch.new).not_to eq(Match.new)
         end
       end
     end

data/spec/ruby_speech/grxml/rule_spec.rb

@@ -13,7 +13,7 @@ module RubySpeech
       its(:scope) { should == :public }
 
       it 'registers itself' do
-        Element.class_from_registration(:rule).should == Rule
+        expect(Element.class_from_registration(:rule)).to eq(Rule)
       end
 
       describe "from a document" do
@@ -21,7 +21,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Rule }
+        it { is_expected.to be_instance_of Rule }
 
         its(:id)    { should == :one }
         its(:scope) { should == :public }
@@ -54,73 +54,73 @@ module RubySpeech
         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
+          expect { subject.scope = :public }.not_to raise_error
+          expect { subject.scope = :private }.not_to 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'")
+          expect { subject.scope = :something }.to 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(doc, :language => 'jp', :id => :main, :scope => :public, :content => "hello").should == Rule.new(doc, :language => 'jp', :id => :main, :scope => :public, :content => "hello")
+          expect(Rule.new(doc, :language => 'jp', :id => :main, :scope => :public, :content => "hello")).to eq(Rule.new(doc, :language => 'jp', :id => :main, :scope => :public, :content => "hello"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Rule.new(doc, :content => "Hello").should_not == Rule.new(doc, :content => "Hello there")
+            expect(Rule.new(doc, :content => "Hello")).not_to eq(Rule.new(doc, :content => "Hello there"))
           end
         end
 
         describe "when the language is different" do
           it "should not be equal" do
-            Rule.new(doc, :language => "jp").should_not == Rule.new(doc, :language => "esperanto")
+            expect(Rule.new(doc, :language => "jp")).not_to eq(Rule.new(doc, :language => "esperanto"))
           end
         end
 
         describe "when the id is different" do
           it "should not be equal" do
-            Rule.new(doc, :id => :main).should_not == Rule.new(doc, :id => :dtmf)
+            expect(Rule.new(doc, :id => :main)).not_to eq(Rule.new(doc, :id => :dtmf))
           end
         end
 
         describe "when the scope is different" do
           it "should not be equal" do
-            Rule.new(doc, :scope => :public).should_not == Rule.new(doc, :scope => :private)
+            expect(Rule.new(doc, :scope => :public)).not_to eq(Rule.new(doc, :scope => :private))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should accept OneOf" do
-          lambda { subject << OneOf.new(doc) }.should_not raise_error
+          expect { subject << OneOf.new(doc) }.not_to raise_error
         end
 
         it "should accept Item" do
-          lambda { subject << Item.new(doc) }.should_not raise_error
+          expect { subject << Item.new(doc) }.not_to raise_error
         end
 
         it "should accept Ruleref" do
-          lambda { subject << Ruleref.new(doc) }.should_not raise_error
+          expect { subject << Ruleref.new(doc) }.not_to raise_error
         end
 
         it "should accept Tag" do
-          lambda { subject << Tag.new(doc) }.should_not raise_error
+          expect { subject << Tag.new(doc) }.not_to raise_error
         end
 
         it "should accept Token" do
-          lambda { subject << Token.new(doc) }.should_not raise_error
+          expect { subject << Token.new(doc) }.not_to raise_error
         end
       end
 
       it "should raise ArgumentError with any other scope" do
-        lambda { Rule.new doc, :id => 'one', :scope => 'invalid_scope' }.should raise_error(ArgumentError, "A Rule's scope can only be 'public' or 'private'")
+        expect { Rule.new doc, :id => 'one', :scope => 'invalid_scope' }.to raise_error(ArgumentError, "A Rule's scope can only be 'public' or 'private'")
       end
     end # Rule
   end # GRXML

data/spec/ruby_speech/grxml/ruleref_spec.rb

@@ -11,7 +11,7 @@ module RubySpeech
       its(:uri)   { should == '#testrule' }
 
       it 'registers itself' do
-        Element.class_from_registration(:ruleref).should == Ruleref
+        expect(Element.class_from_registration(:ruleref)).to eq(Ruleref)
       end
 
       describe "from a document" do
@@ -19,7 +19,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Ruleref }
+        it { is_expected.to be_instance_of Ruleref }
 
         its(:uri) { should == '#one' }
       end
@@ -29,27 +29,27 @@ module RubySpeech
 
         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
+            expect { subject.special = :NULL }.not_to raise_error
+            expect { subject.special = :VOID }.not_to raise_error
+            expect { subject.special = 'GARBAGE' }.not_to raise_error
           end
           it "with an invalid value" do
-            lambda { subject.special = :SOMETHINGELSE }.should raise_error
+            expect { subject.special = :SOMETHINGELSE }.to 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
+          expect { subject.uri = '#dtmf' }.not_to raise_error
+          expect { subject.uri = '../test.grxml' }.not_to raise_error
+          expect { subject.uri = 'http://grammar.example.com/world-cities.grxml#canada' }.not_to raise_error
         end
       end
 
       describe "only uri or special can be specified" do
         it "should raise an error" do
-          lambda { subject << Ruleref.new(doc, :uri => '#test', :special => :NULL) }.should raise_error(ArgumentError, "A Ruleref can only take uri or special")
+          expect { subject << Ruleref.new(doc, :uri => '#test', :special => :NULL) }.to raise_error(ArgumentError, "A Ruleref can only take uri or special")
         end
       end
     end # Ruleref

data/spec/ruby_speech/grxml/tag_spec.rb

@@ -10,7 +10,7 @@ module RubySpeech
       its(:name) { should == 'tag' }
 
       it 'registers itself' do
-        Element.class_from_registration(:tag).should == Tag
+        expect(Element.class_from_registration(:tag)).to eq(Tag)
       end
 
       describe "from a document" do
@@ -18,26 +18,26 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Tag }
+        it { is_expected.to 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(doc, :content => "hello").should == Tag.new(doc, :content => "hello")
+          expect(Tag.new(doc, :content => "hello")).to eq(Tag.new(doc, :content => "hello"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Tag.new(doc, :content => "Hello").should_not == Tag.new(doc, :content => "Hello there")
+            expect(Tag.new(doc, :content => "Hello")).not_to eq(Tag.new(doc, :content => "Hello there"))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
       end
     end # Tag

data/spec/ruby_speech/grxml/token_spec.rb

@@ -10,7 +10,7 @@ module RubySpeech
       its(:name) { should == 'token' }
 
       it 'registers itself' do
-        Element.class_from_registration(:token).should == Token
+        expect(Element.class_from_registration(:token)).to eq(Token)
       end
 
       describe "from a document" do
@@ -18,7 +18,7 @@ module RubySpeech
 
         subject { Element.import document }
 
-        it { should be_instance_of Token }
+        it { is_expected.to be_instance_of Token }
 
         its(:content) { should == 'hello' }
       end
@@ -35,30 +35,30 @@ module RubySpeech
 
           element.normalize_whitespace
 
-          element.content.should == 'Welcome to San Francisco'
+          expect(element.content).to eq('Welcome to San Francisco')
         end
       end
 
       describe "comparing objects" do
         it "should be equal if the content is the same" do
-          Token.new(doc, :content => "hello").should == Token.new(doc, :content => "hello")
+          expect(Token.new(doc, :content => "hello")).to eq(Token.new(doc, :content => "hello"))
         end
 
         describe "when the content is different" do
           it "should not be equal" do
-            Token.new(doc, :content => "Hello").should_not == Token.new(doc, :content => "Hello there")
+            expect(Token.new(doc, :content => "Hello")).not_to eq(Token.new(doc, :content => "Hello there"))
           end
         end
       end
 
       describe "<<" do
         it "should accept String" do
-          lambda { subject << 'anything' }.should_not raise_error
+          expect { subject << 'anything' }.not_to raise_error
         end
 
         it "should allow chaining" do
           subject << 'foo' << 'bar'
-          subject.content.should == 'foobar'
+          expect(subject.content).to eq('foobar')
         end
       end
     end # Token

data/spec/ruby_speech/grxml_spec.rb

@@ -5,11 +5,11 @@ module RubySpeech
     describe ".from_uri" do
       context "with a builtin URI" do
         it "should fetch a simple builtin grammar by type" do
-          subject.from_uri("builtin:dtmf/phone").should == GRXML::Builtins.phone
+          expect(subject.from_uri("builtin:dtmf/phone")).to eq(GRXML::Builtins.phone)
         end
 
         it "should fetch a parameterized builtin grammar" do
-          subject.from_uri("builtin:dtmf/boolean?y=3;n=4").should == GRXML::Builtins.boolean(y: 3, n: 4)
+          expect(subject.from_uri("builtin:dtmf/boolean?y=3;n=4")).to eq(GRXML::Builtins.boolean(y: 3, n: 4))
         end
 
         context "for speech" do
@@ -36,26 +36,26 @@ module RubySpeech
       let(:doc) { Nokogiri::XML::Document.new }
 
       it "should create a GRXML document" do
-        GRXML.draw.should == GRXML::Grammar.new(doc)
-        GRXML.draw.document.xpath('ns:grammar', ns: 'http://www.w3.org/2001/06/grammar').size.should == 1
+        expect(GRXML.draw).to eq(GRXML::Grammar.new(doc))
+        expect(GRXML.draw.document.xpath('ns:grammar', ns: 'http://www.w3.org/2001/06/grammar').size).to eq(1)
       end
 
       context "with a root rule name specified but not found" do
         it "should raise an error" do
-          lambda do
+          expect do
             GRXML.draw :root => 'foo' do
               rule :id => 'bar' do
                 '6'
               end
             end
-          end.should raise_error(GRXML::InvalidChildError, "A GRXML document must have a rule matching the root rule name")
+          end.to raise_error(GRXML::InvalidChildError, "A GRXML document must have a rule matching the root rule name")
         end
       end
 
       # TODO: Maybe GRXML#draw should create a Rule to pass the string
       describe "when the return value of the block is a string" do
         it "should be inserted into the document" do
-          lambda { GRXML.draw { "Hello Fred" }}.should raise_error(GRXML::InvalidChildError, "A Grammar can only accept Rule and Tag as children")
+          expect { GRXML.draw { "Hello Fred" }}.to raise_error(GRXML::InvalidChildError, "A Grammar can only accept Rule and Tag as children")
         end
       end
 
@@ -66,7 +66,7 @@ module RubySpeech
         rule = GRXML::Rule.new(doc, :id => "main")
         rule << "Hello Fred"
         expected_doc << rule
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       it "should allow accessing methods defined outside the block" do
@@ -81,12 +81,12 @@ module RubySpeech
         expected_doc = GRXML::Grammar.new doc
         rule = GRXML::Rule.new(doc, :id => foo)
         expected_doc << rule
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       it "should raise error if given an empty rule" do
         pending 'Reject empty rules -- http://www.w3.org/TR/2002/CR-speech-grammar-20020626/#S3.1 http://www.w3.org/Voice/2003/srgs-ir/test/rule-no-empty.grxml'
-        lambda { GRXML.draw { rule :id => 'main' }}.should raise_error
+        expect { GRXML.draw { rule :id => 'main' }}.to raise_error
       end
 
       it "should allow nested block return values" do
@@ -97,7 +97,7 @@ module RubySpeech
         end
         expected_doc = GRXML::Grammar.new doc
         expected_doc << GRXML::Rule.new(doc, :scope => :public, :id => :main, :content => "Hello Fred")
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       it "should allow nested GRXML elements" do
@@ -117,7 +117,7 @@ module RubySpeech
         rule << oneof
         expected_doc = GRXML::Grammar.new doc
         expected_doc << rule
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       # TODO: maybe turn a rule embedded in anthoer rule into a ruleref??
@@ -157,7 +157,7 @@ module RubySpeech
           end
 
           it "should embed the document" do
-            doc2.should == expected_doc
+            expect(doc2).to eq(expected_doc)
           end
 
           context "of different modes (dtmf in voice or vice-versa)" do
@@ -176,7 +176,7 @@ module RubySpeech
             end
 
             it "should raise an exception" do
-              lambda { voice_doc }.should raise_error(GRXML::InvalidChildError, "Embedded grammars must have the same mode")
+              expect { voice_doc }.to raise_error(GRXML::InvalidChildError, "Embedded grammars must have the same mode")
             end
           end
         end
@@ -198,7 +198,7 @@ module RubySpeech
             end
           end
 
-          doc.should == expected_doc
+          expect(doc).to eq(expected_doc)
         end
 
         it "strings" do
@@ -216,7 +216,7 @@ module RubySpeech
             end
           end
 
-          doc.should == expected_doc
+          expect(doc).to eq(expected_doc)
         end
       end
 
@@ -230,7 +230,7 @@ module RubySpeech
         3.times do
           expected_doc << GRXML::Rule.new(doc, :native_content => "I <3 nachos.")
         end
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       # TODO: verfify rule is in document if named in a ruleref
@@ -242,7 +242,7 @@ module RubySpeech
             string "HELLO?"
             item :weight => 2.5
             one_of do
-              item { "1" }
+              item { string 1 }
               item { "2" }
             end
             ruleref :uri => '#test'
@@ -285,7 +285,7 @@ module RubySpeech
         oneof << GRXML::Item.new(doc, :content => "single item")
         rule << oneof
         expected_doc << rule
-        drawn_doc.should == expected_doc
+        expect(drawn_doc).to eq(expected_doc)
       end
 
       describe "importing nested tags" do
@@ -307,10 +307,10 @@ module RubySpeech
         subject { import }
 
         it "should work" do
-          lambda { subject }.should_not raise_error
+          expect { subject }.not_to raise_error
         end
 
-        it { should be_a GRXML::Grammar }
+        it { is_expected.to be_a GRXML::Grammar }
 
         its(:children) { should == [rule] }
 
@@ -331,7 +331,7 @@ module RubySpeech
         tag = GRXML::Tag.new doc
         item << tag
 
-        item.children(:item, :weight => 0.5).should == [item1]
+        expect(item.children(:item, :weight => 0.5)).to eq([item1])
       end
 
       it "should be able to traverse up the tree" do
@@ -344,13 +344,13 @@ module RubySpeech
         end
 
         rule = grammar.children.first
-        rule.parent.should == grammar
+        expect(rule.parent).to eq(grammar)
 
         item = rule.children.first
-        item.parent.should == rule
+        expect(item.parent).to eq(rule)
 
         text = item.nokogiri_children.first
-        text.parent.should == item
+        expect(text.parent).to eq(item)
       end
     end
   end # GRXML

data/spec/ruby_speech/nlsml_spec.rb

@@ -52,7 +52,23 @@ describe RubySpeech::NLSML do
         end
       end
 
-      document.to_xml.should == expected_document
+      expect(document.to_xml).to eq(expected_document)
+    end
+
+    it "should return a structured/parsed document" do
+      document = RubySpeech::NLSML.draw(grammar: 'http://flight') do
+        interpretation confidence: 0.6 do
+          input "I want to go to Pittsburgh", mode: :speech
+
+          instance do
+            airline do
+              to_city 'Pittsburgh'
+            end
+          end
+        end
+      end
+
+      expect(document).to be_match
     end
 
     context "with a string instance" do
@@ -76,7 +92,7 @@ describe RubySpeech::NLSML do
           end
         end
 
-        document.to_xml.should == expected_document
+        expect(document.to_xml).to eq(expected_document)
       end
     end
   end
@@ -90,7 +106,7 @@ describe RubySpeech::NLSML do
 
     its(:grammar) { should == 'http://flight' }
 
-    it { should be_match }
+    it { is_expected.to be_match }
 
     let(:expected_best_interpretation) do
       {
@@ -117,11 +133,11 @@ describe RubySpeech::NLSML do
     its(:best_interpretation) { should == expected_best_interpretation }
 
     it "should be equal if the XML is the same" do
-      subject.should be == RubySpeech.parse(example_document)
+      expect(subject).to eq(RubySpeech.parse(example_document))
     end
 
     it "should not be equal if the XML is different" do
-      subject.should_not be == RubySpeech.parse(empty_result)
+      expect(subject).not_to eq(RubySpeech.parse(empty_result))
     end
 
     context "when the XML is already parsed and is not the root of a document" do
@@ -198,6 +214,38 @@ describe RubySpeech::NLSML do
       its(:best_interpretation) { should == expected_best_interpretation }
     end
 
+    context "with an interpretation that has no input" do
+      let :example_document do
+        '''
+<result xmlns="http://www.ietf.org/xml/ns/mrcpv2" grammar="http://flight">
+  <interpretation confidence="0.6">
+    <instance>
+      <airline>
+        <to_city>Pittsburgh</to_city>
+      </airline>
+    </instance>
+  </interpretation>
+</result>
+        '''
+      end
+
+      let(:expected_best_interpretation) do
+        {
+          confidence: 0.6,
+          input: nil,
+          instance: { airline: { to_city: 'Pittsburgh' } },
+          instances: [{ airline: { to_city: 'Pittsburgh' } }]
+        }
+      end
+
+      let(:expected_interpretations) do
+        [expected_best_interpretation]
+      end
+
+      its(:interpretations)     { should == expected_interpretations }
+      its(:best_interpretation) { should == expected_best_interpretation }
+    end
+
     context "with a string instance" do
       let :example_document do
         '''
@@ -232,7 +280,7 @@ describe RubySpeech::NLSML do
         RubySpeech.parse empty_result
       end
 
-      it { should_not be_match }
+      it { is_expected.not_to be_match }
     end
 
     context "with interpretations out of confidence order" do
@@ -341,7 +389,7 @@ describe RubySpeech::NLSML do
         '''
       end
 
-      it { should_not be_match }
+      it { is_expected.not_to be_match }
     end
 
     context "with multiple interpretations where one is a nomatch input" do
@@ -365,7 +413,7 @@ describe RubySpeech::NLSML do
         '''
       end
 
-      it { should be_match }
+      it { is_expected.to be_match }
     end
 
     context "with a single interpretation with a noinput" do
@@ -381,8 +429,8 @@ describe RubySpeech::NLSML do
         '''
       end
 
-      it { should_not be_match }
-      it { should be_noinput }
+      it { is_expected.not_to be_match }
+      it { is_expected.to be_noinput }
     end
   end
 end