adhearsion 2.0.0.beta1 → 2.0.0.rc1

data/spec/adhearsion/logging_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe Adhearsion::Logging do
@@ -26,7 +28,7 @@ describe Adhearsion::Logging do
   end
 
   it 'should create the predefined set of log levels' do
-    ::Logging::LEVELS.keys.should == Adhearsion::Logging::LOG_LEVELS.map(&:downcase)
+    ::Logging::LEVELS.keys.should be == Adhearsion::Logging::LOG_LEVELS.map(&:downcase)
   end
 
   it "should log to the Object logger when given arguments" do
@@ -93,9 +95,9 @@ describe Adhearsion::Logging do
     Adhearsion.config.platform.logging['level'] = :warn
     Adhearsion::Logging.level = :warn
     Adhearsion::Logging.toggle_trace!
-    Adhearsion::Logging.level.should == 0
+    Adhearsion::Logging.level.should be == 0
     Adhearsion::Logging.toggle_trace!
-    Adhearsion::Logging.level.should == 3
+    Adhearsion::Logging.level.should be == 3
     Adhearsion.config.platform.logging['level'] = orig_level
   end
 
@@ -106,18 +108,18 @@ describe Adhearsion::Logging do
 
     it 'changing the logging level should affect all loggers' do
       loggers = [::Foo.logger, ::Foo::Bar.logger]
-      loggers.map(&:level).should_not == [Adhearsion::Logging::DEBUG] * 2
-      loggers.map(&:level).should == [Adhearsion::Logging::INFO] * 2
+      loggers.map(&:level).should_not be == [Adhearsion::Logging::DEBUG] * 2
+      loggers.map(&:level).should be == [Adhearsion::Logging::INFO] * 2
       Adhearsion::Logging.logging_level = :warn
-      loggers.map(&:level).should == [Adhearsion::Logging::WARN] * 2
+      loggers.map(&:level).should be == [Adhearsion::Logging::WARN] * 2
     end
 
     it 'changing the logging level, using level=, should affect all loggers' do
       loggers = [Foo.logger, ::Foo::Bar.logger]
-      loggers.map(&:level).should_not == [::Logging::LEVELS["debug"]] * 2
-      loggers.map(&:level).should == [::Logging::LEVELS["info"]] * 2
+      loggers.map(&:level).should_not be == [::Logging::LEVELS["debug"]] * 2
+      loggers.map(&:level).should be == [::Logging::LEVELS["info"]] * 2
       Adhearsion::Logging.level = :warn
-      loggers.map(&:level).should == [::Logging::LEVELS["warn"]] * 2
+      loggers.map(&:level).should be == [::Logging::LEVELS["warn"]] * 2
     end
 
     it 'should change all the Logger instance level' do

data/spec/adhearsion/menu_dsl/calculated_match_collection_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion
@@ -23,10 +25,10 @@ module Adhearsion
         mock_matches_2 = mock_with_potential_matches mock_matches_array_2
 
         subject << mock_matches_1
-        subject.actual_potential_matches.should == mock_matches_array_1
+        subject.actual_potential_matches.should be == mock_matches_array_1
 
         subject << mock_matches_2
-        subject.actual_potential_matches.should == mock_matches_array_1 + mock_matches_array_2
+        subject.actual_potential_matches.should be == mock_matches_array_1 + mock_matches_array_2
       end
 
       it "the <<() method should collect the exact matches into the actual_exact_matches Array" do
@@ -36,10 +38,10 @@ module Adhearsion
         mock_matches_2 = mock_with_exact_matches mock_matches_array_2
 
         subject << mock_matches_1
-        subject.actual_exact_matches.should == mock_matches_array_1
+        subject.actual_exact_matches.should be == mock_matches_array_1
 
         subject << mock_matches_2
-        subject.actual_exact_matches.should == mock_matches_array_1 + mock_matches_array_2
+        subject.actual_exact_matches.should be == mock_matches_array_1 + mock_matches_array_2
       end
 
       it "if any exact matches exist, the exact_match?() method should return true" do

data/spec/adhearsion/menu_dsl/calculated_match_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion
@@ -34,11 +36,11 @@ module Adhearsion
       end
 
       it "#exact_matches should return an array of exact matches" do
-        CalculatedMatch.new(:exact_matches => [0,3,5]).exact_matches.should == [0,3,5]
+        CalculatedMatch.new(:exact_matches => [0,3,5]).exact_matches.should be == [0,3,5]
       end
 
       it "#potential_matches should return an array of potential matches" do
-        CalculatedMatch.new(:potential_matches => [88,99,77]).potential_matches.should == [88,99,77]
+        CalculatedMatch.new(:potential_matches => [88,99,77]).potential_matches.should be == [88,99,77]
       end
 
       it "::failed_match! should return a match that *really* failed" do
@@ -49,8 +51,8 @@ module Adhearsion
         failure.type_of_match.should be nil
 
         failure.match_payload.should be :match_payload_does_not_matter
-        failure.pattern.should == (10..20)
-        failure.query.should == 30
+        failure.pattern.should be == (10..20)
+        failure.query.should be == 30
       end
     end
   end

data/spec/adhearsion/menu_dsl/fixnum_match_calculator_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion
@@ -10,7 +12,7 @@ module Adhearsion
         match = calculator.match 4
         match.potential_match?.should be true
         match.exact_match?.should_not be true
-        match.potential_matches.should == [444]
+        match.potential_matches.should be == [444]
       end
 
       it "a multi-digit exact match scenario" do

data/spec/adhearsion/menu_dsl/match_calculator_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion

data/spec/adhearsion/menu_dsl/menu_builder_spec.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion
   module MenuDSL
 
     describe MenuBuilder do
-      subject{ MenuDSL::MenuBuilder.new } 
+      subject{ MenuDSL::MenuBuilder.new }
 
       describe "#build" do
         it "sets the context and instance_eval's the block" do
@@ -17,12 +19,13 @@ module Adhearsion
 
       describe "#match" do
         let(:match_block) { Proc.new() {} }
+
         it "raises an exception if called without a CallController and no block" do
           expect { subject.match 1 }.to raise_error(ArgumentError)
         end
 
         it "raises an exception if given both a payload and a block" do
-          expect { subject.match(1, Object) {} }.to raise_error(ArgumentError) 
+          expect { subject.match(1, Object) {} }.to raise_error(ArgumentError)
         end
 
         it "raises an exception if given no patterns" do
@@ -38,6 +41,7 @@ module Adhearsion
           flexmock(MenuDSL::MatchCalculator).should_receive(:build_with_pattern).with("1", nil, match_block)
           subject.match("1", &match_block)
         end
+
         it "creates multiple patterns if multiple arguments are passed in" do
           flexmock(MenuDSL::MatchCalculator).should_receive(:build_with_pattern).with(1, Object)
           flexmock(MenuDSL::MatchCalculator).should_receive(:build_with_pattern).with(2, Object)
@@ -45,13 +49,27 @@ module Adhearsion
         end
       end#match
 
+      describe "#has_matchers?" do
+        context "with no matchers specified" do
+          its(:has_matchers?) { should be false }
+        end
+
+        context "with at least one matcher specified" do
+          before do
+            subject.match(1) {}
+          end
+
+          its(:has_matchers?) { should be true }
+        end
+      end
+
       describe "#weighted_match_calculators" do
         let(:expected_pattern) { MenuDSL::MatchCalculator.build_with_pattern("1", Object) }
-        
+
         it "returns the generated patterns" do
           flexmock(MenuDSL::MatchCalculator).should_receive(:build_with_pattern).with("1", Object).and_return(expected_pattern)
           subject.match("1", Object)
-          subject.weighted_match_calculators.should == [expected_pattern]
+          subject.weighted_match_calculators.should be == [expected_pattern]
         end
       end#weighted_match_calculators
 
@@ -59,12 +77,12 @@ module Adhearsion
         let(:callback) { Proc.new() {} }
 
         it "raises an error if not passed a block" do
-          expect { subject.invalid }.to raise_error(LocalJumpError) 
+          expect { subject.invalid }.to raise_error(LocalJumpError)
         end
 
         it "sets the invalid callback" do
           subject.invalid(&callback)
-          subject.menu_callbacks[:invalid].should == callback
+          subject.menu_callbacks[:invalid].should be == callback
         end
       end#invalid
 
@@ -72,12 +90,12 @@ module Adhearsion
         let(:callback) { Proc.new() {} }
 
         it "raises an error if not passed a block" do
-          expect { subject.timeout }.to raise_error(LocalJumpError) 
+          expect { subject.timeout }.to raise_error(LocalJumpError)
         end
 
         it "sets the timeout callback" do
           subject.timeout(&callback)
-          subject.menu_callbacks[:timeout].should == callback
+          subject.menu_callbacks[:timeout].should be == callback
         end
       end#timeout
 
@@ -85,15 +103,28 @@ module Adhearsion
         let(:callback) { Proc.new() {} }
 
         it "raises an error if not passed a block" do
-          expect { subject.failure }.to raise_error(LocalJumpError) 
+          expect { subject.failure }.to raise_error(LocalJumpError)
         end
 
         it "sets the failure callback" do
           subject.failure(&callback)
-          subject.menu_callbacks[:failure].should == callback
+          subject.menu_callbacks[:failure].should be == callback
         end
       end#failure
 
+      describe "#validator" do
+        let(:callback) { Proc.new() {} }
+
+        it "raises an error if not passed a block" do
+          expect { subject.validator }.to raise_error(LocalJumpError)
+        end
+
+        it "sets the invalid callback" do
+          subject.validator(&callback)
+          subject.menu_callbacks[:validator].should be == callback
+        end
+      end#invalid
+
       describe "#execute_hook_for" do
         it "executes the correct hook" do
           bar = nil
@@ -101,7 +132,7 @@ module Adhearsion
             bar = baz
           end
           subject.execute_hook_for(:invalid, "1")
-          bar.should == "1"
+          bar.should be == "1"
         end
       end#execute_hook_for
 

data/spec/adhearsion/menu_dsl/menu_spec.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
 module Adhearsion
@@ -5,38 +7,128 @@ module Adhearsion
     describe Menu do
 
         let(:options) { Hash.new }
-        subject { Menu.new(options) {}  }
+        subject { Menu.new(options) }
 
         describe "#initialize" do
-
-          its(:tries_count) { should == 0 }
-
+          its(:tries_count) { should be == 0 }
 
           context 'when no timeout is set' do
             it "should have the default timeout" do
-              subject.timeout.should == 5
+              subject.timeout.should be == 5
             end
           end
+
           context 'when a timeout is set' do
             let(:options) {
               {:timeout => 20}
             }
+
             it 'should have the passed timeout' do
-              subject.timeout.should == 20
+              subject.timeout.should be == 20
             end
           end
 
           context 'when no max number of tries is set' do
             it "should have the default max number of tries" do
-              subject.max_number_of_tries.should == 1
+              subject.max_number_of_tries.should be == 1
             end
           end
+
           context 'when a max number of tries is set' do
             let(:options) {
               {:tries => 3}
             }
+
             it 'should have the passed max number of tries' do
-              subject.max_number_of_tries.should == 3
+              subject.max_number_of_tries.should be == 3
+            end
+          end
+
+          context 'when no terminator is set' do
+            it "should have no terminator" do
+              subject.terminator.should be == ''
+            end
+
+            it 'should not validate successfully' do
+              lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+            end
+          end
+
+          context 'when a terminator is set' do
+            let(:options) {
+              {:terminator => 3}
+            }
+
+            it 'should have the passed terminator' do
+              subject.terminator.should be == '3'
+            end
+
+            it 'should validate(:basic) successfully' do
+              subject.validate(:basic).should be true
+            end
+
+            it 'should not validate successfully' do
+              lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+            end
+          end
+
+          context 'when no limit is set' do
+            it "should have no limit" do
+              subject.limit.should be nil
+            end
+
+            it 'should not validate successfully' do
+              lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+            end
+          end
+
+          context 'when a limit is set' do
+            let(:options) {
+              {:limit => 3}
+            }
+
+            it 'should have the passed limit' do
+              subject.limit.should be == 3
+            end
+
+            it 'should validate(:basic) successfully' do
+              subject.validate(:basic).should be true
+            end
+
+            it 'should not validate successfully' do
+              lambda { subject.validate }.should raise_error(Menu::InvalidStructureError)
+            end
+          end
+
+          context 'when no interruptibility is set' do
+            it "should be interruptible" do
+              subject.interruptible.should be true
+            end
+          end
+
+          context 'when interruptible is set false' do
+            let(:options) {
+              {:interruptible => false}
+            }
+
+            it 'should be interruptible' do
+              subject.interruptible.should be false
+            end
+          end
+
+          context 'when matchers are specified' do
+            subject do
+              Menu.new do
+                match(1) { }
+              end
+            end
+
+            it 'should validate successfully' do
+              subject.validate.should be true
+            end
+
+            it 'should not validate(:basic) successfully' do
+              lambda { subject.validate :basic }.should raise_error(Menu::InvalidStructureError)
             end
           end
 
@@ -47,7 +139,7 @@ module Adhearsion
               mock_menu_builder = flexmock(MenuBuilder.new)
               flexmock(MenuBuilder).should_receive(:new).and_return(mock_menu_builder)
               mock_menu_builder.should_receive(:match).once.with(1)
-              Menu.new {match 1}
+              Menu.new { match 1 }
             end
           end
 
@@ -55,38 +147,40 @@ module Adhearsion
 
         describe "#digit_buffer" do
           its(:digit_buffer) { should be_a Menu::ClearableStringBuffer }
-          its(:digit_buffer) { should == "" }
+          its(:digit_buffer) { should be == "" }
         end
 
         describe "#<<" do
           it "should add a digit to the buffer" do
             subject << 'a'
-            subject.digit_buffer.should == 'a'
+            subject.digit_buffer.should be == 'a'
+            subject.result.should be == 'a'
           end
         end
 
         describe "#digit_buffer_empty?" do
           it "returns true if buffer is empty" do
-            subject.digit_buffer_empty?.should == true
+            subject.digit_buffer_empty?.should be == true
           end
+
           it "returns false if buffer is not empty" do
             subject << 1
-            subject.digit_buffer_empty?.should == false
+            subject.digit_buffer_empty?.should be == false
           end
         end
 
         describe "#digit_buffer_string" do
           it "returns the digit buffer as a string" do
             subject << 1
-            subject.digit_buffer_string.should == "1"
+            subject.digit_buffer_string.should be == "1"
           end
         end
 
         describe "#should_continue?" do
           it "returns true if the number of tries is less than the maximum" do
-            subject.max_number_of_tries.should == 1
-            subject.tries_count.should == 0
-            subject.should_continue?.should == true
+            subject.max_number_of_tries.should be == 1
+            subject.tries_count.should be == 0
+            subject.should_continue?.should be == true
           end
         end
 
@@ -94,8 +188,8 @@ module Adhearsion
           it "increments tries and clears the digit buffer" do
             subject << 1
             subject.restart!
-            subject.tries_count.should == 1
-            subject.digit_buffer_empty?.should == true
+            subject.tries_count.should be == 1
+            subject.digit_buffer_empty?.should be == true
           end
         end
 
@@ -104,7 +198,7 @@ module Adhearsion
             mock_menu_builder = flexmock(MenuBuilder.new)
             flexmock(MenuBuilder).should_receive(:new).and_return(mock_menu_builder)
             mock_menu_builder.should_receive(:execute_hook_for).with(:invalid, "")
-            menu_instance = Menu.new() {}
+            menu_instance = Menu.new
             menu_instance.execute_invalid_hook
           end
         end
@@ -114,7 +208,7 @@ module Adhearsion
             mock_menu_builder = flexmock(MenuBuilder.new)
             flexmock(MenuBuilder).should_receive(:new).and_return(mock_menu_builder)
             mock_menu_builder.should_receive(:execute_hook_for).with(:timeout, "")
-            menu_instance = Menu.new() {}
+            menu_instance = Menu.new
             menu_instance.execute_timeout_hook
           end
         end
@@ -124,17 +218,28 @@ module Adhearsion
             mock_menu_builder = flexmock(MenuBuilder.new)
             flexmock(MenuBuilder).should_receive(:new).and_return(mock_menu_builder)
             mock_menu_builder.should_receive(:execute_hook_for).with(:failure, "")
-            menu_instance = Menu.new() {}
+            menu_instance = Menu.new
             menu_instance.execute_failure_hook
           end
         end
 
+        describe "#execute_validator_hook" do
+          it "calls the builder's execute_hook_for with :validator" do
+            mock_menu_builder = flexmock(MenuBuilder.new)
+            flexmock(MenuBuilder).should_receive(:new).and_return(mock_menu_builder)
+            mock_menu_builder.should_receive(:execute_hook_for).with(:validator, "")
+            menu_instance = Menu.new
+            menu_instance.execute_validator_hook
+          end
+        end
+
         describe "#continue" do
           class MockControllerA; end
           class MockControllerB; end
           class MockControllerC; end
+          let(:options) { {} }
           let(:menu_instance) {
-            Menu.new do
+            Menu.new options do
               match 1, MockControllerA
               match 21, MockControllerA
               match 23, MockControllerA
@@ -145,46 +250,102 @@ module Adhearsion
               match 6..8, MockControllerA
             end
           }
+
           it "returns a MenuGetAnotherDigitOrTimeout if the digit buffer is empty" do
             subject.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
+            menu_instance.status.should be nil
           end
 
           it "asks for another digit if it has potential matches" do
             menu_instance << 2
-            menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout 
+            menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
+            menu_instance.status.should be == :potential
           end
 
           it "returns a MenuResultInvalid if there are no matches" do
             menu_instance << 9
             menu_instance.continue.should be_a Menu::MenuResultInvalid
-          end
-
-          it "returns a MenuGetAnotherDigitOrFinish if it has exact and potential matches" do
-            menu_instance << 3
-            menu_result = menu_instance.continue
-            menu_result.should be_a Menu::MenuGetAnotherDigitOrFinish
+            menu_instance.status.should be == :invalid
           end
 
           it "returns the first exact match when it has exact and potentials" do
             menu_instance << 3
             menu_result = menu_instance.continue
             menu_result.should be_a Menu::MenuGetAnotherDigitOrFinish
-            menu_result.match_object.should == MockControllerB
-            menu_result.new_extension.should == "3"
+            menu_result.match_object.should be == MockControllerB
+            menu_result.new_extension.should be == "3"
+            menu_instance.status.should be == :multi_matched
           end
 
           it "returns a MenuResultFound if it has exact matches" do
             menu_instance << 6
             menu_result = menu_instance.continue
             menu_result.should be_a Menu::MenuResultFound
+            menu_instance.status.should be == :matched
           end
 
           it "returns the first exact match when it has only exact matches" do
             menu_instance << 6
             menu_result = menu_instance.continue
             menu_result.should be_a Menu::MenuResultFound
-            menu_result.match_object.match_payload.should == MockControllerC
-            menu_result.match_object.pattern.to_s.should == "6"
+            menu_result.match_object.match_payload.should be == MockControllerC
+            menu_result.match_object.pattern.to_s.should be == "6"
+          end
+
+          context "with no matchers" do
+            let(:menu_instance) { Menu.new options }
+
+            context "when a terminator digit is set" do
+              let(:options) { { :terminator => '#' } }
+
+              it "buffers until the terminator is issued then returns a MenuTerminated and sets the status to :terminated, removing the terminator from the buffer" do
+                menu_instance << 2
+                menu_instance << 4
+                menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
+                menu_instance.status.should be == :potential
+                menu_instance << '#'
+                menu_instance.continue.should be_a Menu::MenuTerminated
+                menu_instance.continue.should be_a Menu::MenuResultDone
+                menu_instance.status.should be == :terminated
+                menu_instance.result.should be == '24'
+              end
+            end
+
+            context "when a digit limit is set" do
+              let(:options) { { :limit => 3 } }
+
+              it "buffers until the limit is reached, then returns MenuLimitReached and sets the status to :limited" do
+                menu_instance << 2
+                menu_instance << 4
+                menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
+                menu_instance.status.should be == :potential
+                menu_instance << 2
+                menu_instance.continue.should be_a Menu::MenuLimitReached
+                menu_instance.continue.should be_a Menu::MenuResultDone
+                menu_instance.status.should be == :limited
+                menu_instance.result.should be == '242'
+              end
+            end
+
+            context "when a validator is defined" do
+              let(:menu_instance) do
+                Menu.new options do
+                  validator { |buffer| buffer == "242" }
+                end
+              end
+
+              it "buffers until the validator returns true, then returns MenuValidatorTerminated and sets the status to :validator_terminated" do
+                menu_instance << 2
+                menu_instance << 4
+                menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
+                menu_instance.status.should be == :potential
+                menu_instance << 2
+                menu_instance.continue.should be_a Menu::MenuValidatorTerminated
+                menu_instance.continue.should be_a Menu::MenuResultDone
+                menu_instance.status.should be == :validator_terminated
+                menu_instance.result.should be == '242'
+              end
+            end
           end
 
         end#continue
@@ -195,13 +356,13 @@ module Adhearsion
           it "adds a string to itself" do
             subject << 'b'
             subject << 'c'
-            subject.should == 'bc'
+            subject.should be == 'bc'
           end
 
           it "clears itself" do
             subject << 'a'
             subject.clear!
-            subject.should == ""
+            subject.should be == ""
           end
         end