adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/menu_dsl/calculated_match_collection_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+    describe CalculatedMatchCollection do
+      def mock_with_potential_matches(potential_matches)
+        CalculatedMatch.new :potential_matches => potential_matches
+      end
+
+      def mock_with_exact_matches(exact_matches)
+        CalculatedMatch.new :exact_matches => exact_matches
+      end
+
+      def mock_with_potential_and_exact_matches(potential_matches, exact_matches)
+        CalculatedMatch.new :potential_matches => potential_matches,
+                            :exact_matches => exact_matches
+      end
+
+      it "the <<() method should collect the potential matches into the actual_potential_matches Array" do
+        mock_matches_array_1 = [:foo, :bar, :qaz],
+        mock_matches_array_2 = [10, 20, 30]
+        mock_matches_1 = mock_with_potential_matches mock_matches_array_1
+        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 << mock_matches_2
+        subject.actual_potential_matches.should == mock_matches_array_1 + mock_matches_array_2
+      end
+
+      it "the <<() method should collect the exact matches into the actual_exact_matches Array" do
+        mock_matches_array_1 = [:blam, :blargh],
+        mock_matches_array_2 = [5,4,3,2,1]
+        mock_matches_1 = mock_with_exact_matches mock_matches_array_1
+        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 << mock_matches_2
+        subject.actual_exact_matches.should == mock_matches_array_1 + mock_matches_array_2
+      end
+
+      it "if any exact matches exist, the exact_match?() method should return true" do
+        subject << mock_with_exact_matches([1,2,3])
+        subject.exact_match?.should be true
+      end
+
+      it "if any potential matches exist, the potential_match?() method should return true" do
+        subject << mock_with_potential_matches([1,2,3])
+        subject.potential_match?.should be true
+      end
+    end
+  end
+end

data/spec/adhearsion/menu_dsl/calculated_match_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+    describe CalculatedMatch do
+      it "should make accessible the context name" do
+        CalculatedMatch.new(:match_payload => :foobar).match_payload.should be :foobar
+      end
+
+      it "should make accessible the original pattern" do
+        CalculatedMatch.new(:pattern => :something).pattern.should be :something
+      end
+
+      it "should make accessible the matched query" do
+        CalculatedMatch.new(:query => 123).query.should be 123
+      end
+
+      it "#type_of_match should return :exact, :potential, or nil" do
+        CalculatedMatch.new(:potential_matches => [1]).type_of_match.should be :potential
+        CalculatedMatch.new(:exact_matches => [3,3]).type_of_match.should be :exact
+        CalculatedMatch.new(:exact_matches => [8,3], :potential_matches => [0,9]).type_of_match.should be :exact
+      end
+
+      it "#exact_match? should return true if the match was exact" do
+        CalculatedMatch.new(:exact_matches => [0,3,5]).exact_match?.should be true
+      end
+
+      it "#potential_match? should return true if the match was exact" do
+        CalculatedMatch.new(:potential_matches => [88,99,77]).potential_match?.should be true
+      end
+
+      it "#failed_match? should return false if the match was exact" do
+        CalculatedMatch.new(:potential_matches => [88,99,77]).failed_match?.should be false
+      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]
+      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]
+      end
+
+      it "::failed_match! should return a match that *really* failed" do
+        failure = CalculatedMatch.failed_match! 10..20, 30, :match_payload_does_not_matter
+        failure.exact_match?.should_not be true
+        failure.potential_match?.should_not be true
+        failure.failed_match?.should be true
+        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
+      end
+    end
+  end
+end

data/spec/adhearsion/menu_dsl/fixnum_match_calculator_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+    describe FixnumMatchCalculator do
+      let(:match_payload) { :main }
+
+      it "a potential match scenario" do
+        calculator = FixnumMatchCalculator.new(444, match_payload)
+        match = calculator.match 4
+        match.potential_match?.should be true
+        match.exact_match?.should_not be true
+        match.potential_matches.should == [444]
+      end
+
+      it "a multi-digit exact match scenario" do
+        calculator = FixnumMatchCalculator.new(5555, match_payload)
+        calculator.match(5555).exact_match?.should be true
+      end
+
+      it "a single-digit exact match scenario" do
+        calculator = FixnumMatchCalculator.new(1, match_payload)
+        calculator.match(1).exact_match?.should be true
+      end
+
+      it "the context name given to the calculator should be passed on the CalculatedMatch" do
+        match_payload = :icanhascheezburger
+        calculator = FixnumMatchCalculator.new(1337, match_payload)
+        calculator.match(1337).match_payload.should be match_payload
+      end
+    end
+  end
+end

data/spec/adhearsion/menu_dsl/match_calculator_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+    describe MatchCalculator do
+      describe ".build_with_pattern" do
+        it "should return an appropriate subclass instance based on the pattern's class" do
+          MatchCalculator.build_with_pattern(1..2, :main).should be_an_instance_of RangeMatchCalculator
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/menu_dsl/menu_builder_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+
+    describe MenuBuilder do
+      subject{ MenuDSL::MenuBuilder.new } 
+
+      describe "#build" do
+        it "sets the context and instance_eval's the block" do
+          flexmock(subject).should_receive(:foo).with(:bar)
+          subject.build do
+            foo :bar
+          end
+        end
+      end#build
+
+      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) 
+        end
+
+        it "raises an exception if given no patterns" do
+          expect { subject.match() {} }.to raise_error(ArgumentError, "You cannot call this method without patterns.")
+        end
+
+        it "creates a pattern based on a payload" do
+          flexmock(MenuDSL::MatchCalculator).should_receive(:build_with_pattern).with("1", Object)
+          subject.match "1", Object
+        end
+
+        it "creates a pattern based on a block" do
+          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)
+          subject.match(1, 2, Object)
+        end
+      end#match
+
+      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]
+        end
+      end#weighted_match_calculators
+
+      describe "#invalid" do
+        let(:callback) { Proc.new() {} }
+
+        it "raises an error if not passed a block" do
+          expect { subject.invalid }.to raise_error(LocalJumpError) 
+        end
+
+        it "sets the invalid callback" do
+          subject.invalid(&callback)
+          subject.menu_callbacks[:invalid].should == callback
+        end
+      end#invalid
+
+      describe "#timeout" do
+        let(:callback) { Proc.new() {} }
+
+        it "raises an error if not passed a block" do
+          expect { subject.timeout }.to raise_error(LocalJumpError) 
+        end
+
+        it "sets the timeout callback" do
+          subject.timeout(&callback)
+          subject.menu_callbacks[:timeout].should == callback
+        end
+      end#timeout
+
+      describe "#failure" do
+        let(:callback) { Proc.new() {} }
+
+        it "raises an error if not passed a block" do
+          expect { subject.failure }.to raise_error(LocalJumpError) 
+        end
+
+        it "sets the failure callback" do
+          subject.failure(&callback)
+          subject.menu_callbacks[:failure].should == callback
+        end
+      end#failure
+
+      describe "#execute_hook_for" do
+        it "executes the correct hook" do
+          bar = nil
+          subject.invalid do |baz|
+            bar = baz
+          end
+          subject.execute_hook_for(:invalid, "1")
+          bar.should == "1"
+        end
+      end#execute_hook_for
+
+      describe "#calculate_matches_for" do
+        it "returns a calculated match collection" do
+          subject.match("1", Object)
+          subject.calculate_matches_for("1").should be_a CalculatedMatchCollection
+        end
+      end
+
+    end# describe MenuBuilder
+
+  end# module MenuDSL
+end

data/spec/adhearsion/menu_dsl/menu_spec.rb

@@ -0,0 +1,210 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+    describe Menu do
+
+        let(:options) { Hash.new }
+        subject { Menu.new(options) {}  }
+
+        describe "#initialize" do
+
+          its(:tries_count) { should == 0 }
+
+
+          context 'when no timeout is set' do
+            it "should have the default timeout" do
+              subject.timeout.should == 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
+            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
+            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
+            end
+          end
+
+          context 'menu builder setup' do
+            its(:builder) { should be_a MenuBuilder }
+
+            it "should evaluate the block on the builder object" do
+              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}
+            end
+          end
+
+        end # describe #initialize
+
+        describe "#digit_buffer" do
+          its(:digit_buffer) { should be_a Menu::ClearableStringBuffer }
+          its(:digit_buffer) { should == "" }
+        end
+
+        describe "#<<" do
+          it "should add a digit to the buffer" do
+            subject << 'a'
+            subject.digit_buffer.should == 'a'
+          end
+        end
+
+        describe "#digit_buffer_empty?" do
+          it "returns true if buffer is empty" do
+            subject.digit_buffer_empty?.should == true
+          end
+          it "returns false if buffer is not empty" do
+            subject << 1
+            subject.digit_buffer_empty?.should == 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"
+          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
+          end
+        end
+
+        describe "#restart!" do
+          it "increments tries and clears the digit buffer" do
+            subject << 1
+            subject.restart!
+            subject.tries_count.should == 1
+            subject.digit_buffer_empty?.should == true
+          end
+        end
+
+        describe "#execute_invalid_hook" do
+          it "calls the builder's execute_hook_for with :invalid" 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(:invalid, "")
+            menu_instance = Menu.new() {}
+            menu_instance.execute_invalid_hook
+          end
+        end
+
+        describe "#execute_timeout_hook" do
+          it "calls the builder's execute_hook_for with :timeout" 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(:timeout, "")
+            menu_instance = Menu.new() {}
+            menu_instance.execute_timeout_hook
+          end
+        end
+
+        describe "#execute_failure_hook" do
+          it "calls the builder's execute_hook_for with :failure" 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(:failure, "")
+            menu_instance = Menu.new() {}
+            menu_instance.execute_failure_hook
+          end
+        end
+
+        describe "#continue" do
+          class MockControllerA; end
+          class MockControllerB; end
+          class MockControllerC; end
+          let(:menu_instance) {
+            Menu.new do
+              match 1, MockControllerA
+              match 21, MockControllerA
+              match 23, MockControllerA
+              match 3, MockControllerB
+              match 3..5, MockControllerC
+              match 33, MockControllerA
+              match 6, MockControllerC
+              match 6..8, MockControllerA
+            end
+          }
+          it "returns a MenuGetAnotherDigitOrTimeout if the digit buffer is empty" do
+            subject.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout
+          end
+
+          it "asks for another digit if it has potential matches" do
+            menu_instance << 2
+            menu_instance.continue.should be_a Menu::MenuGetAnotherDigitOrTimeout 
+          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
+          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"
+          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
+          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"
+          end
+
+        end#continue
+
+        describe Menu::ClearableStringBuffer do
+          subject { Menu::ClearableStringBuffer.new }
+
+          it "adds a string to itself" do
+            subject << 'b'
+            subject << 'c'
+            subject.should == 'bc'
+          end
+
+          it "clears itself" do
+            subject << 'a'
+            subject.clear!
+            subject.should == ""
+          end
+        end
+
+    end # describe Menu
+  end
+end