adhearsion 2.0.0.rc4 → 2.0.0.rc5

data/lib/adhearsion/menu_dsl/range_match_calculator.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-
-    class RangeMatchCalculator < MatchCalculator
-
-      def initialize(pattern, match_payload)
-        raise unless pattern.first.kind_of?(Numeric) && pattern.last.kind_of?(Numeric)
-        super
-      end
-
-      def match(query)
-        numerical_query = coerce_to_numeric query
-        if numerical_query
-          exact_match = pattern.include?(numerical_query) ? query : nil
-          potential_matches = numbers_in_range_like numerical_query
-          potential_matches.reject! { |m| m.to_s == exact_match.to_s } if exact_match
-
-          new_calculated_match :query => query, :exact_matches => exact_match,
-            :potential_matches => potential_matches
-        else
-          CalculatedMatch.failed_match! pattern, query, match_payload
-        end
-      end
-
-      private
-
-      # Returns all numbers in the range (@pattern) that +begin with+ the number given
-      # as the first arguement.
-      #
-      # NOTE: If you're having trouble reading what this method is actually doing. It's
-      # effectively a much more efficient version of this:
-      #
-      # pattern.to_a.select { |x| x.to_s.starts_with? num.to_s }.flatten
-      #
-      # Huge thanks to Dave Troy (http://davetroy.blogspot.com) for this awesomely
-      # efficient code!
-      def numbers_in_range_like(num)
-        return (pattern === 0 ? [0] : nil) if num == 0
-        raise ArgumentError unless num.kind_of?(Numeric)
-        Array.new.tap do |matches|
-          first, last = pattern.first, pattern.last
-          power = 0
-          while num < last
-            ones_count = 10**power - 1
-            range = ([num, first].max..[num + ones_count, last].min).to_a
-            matches.concat range
-            num *= 10
-            power += 1
-          end
-        end
-      end
-
-    end # class RangeMatchCalculator
-
-  end
-end

data/lib/adhearsion/menu_dsl/string_match_calculator.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-
-    class StringMatchCalculator < MatchCalculator
-
-      def match(query)
-        args = { :query => query, :exact_matches => nil, :potential_matches => nil }
-
-        if pattern == query.to_s
-          args[:exact_matches] = [pattern]
-        elsif pattern.starts_with? query.to_s
-          args[:potential_matches] = [pattern]
-        end
-
-        new_calculated_match args
-      end
-
-    end # class StringMatchCalculator
-
-  end
-end

data/spec/adhearsion/menu_dsl/calculated_match_collection_spec.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-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 be == mock_matches_array_1
-
-        subject << mock_matches_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
-        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 be == mock_matches_array_1
-
-        subject << mock_matches_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
-        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

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-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 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 be == [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 be == (10..20)
-        failure.query.should be == 30
-      end
-    end
-  end
-end

data/spec/adhearsion/menu_dsl/fixnum_match_calculator_spec.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-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 be == [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

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-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

@@ -1,149 +0,0 @@
-# encoding: utf-8
-
-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 "#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 be == [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 be == 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 be == 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 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
-          subject.invalid do |baz|
-            bar = baz
-          end
-          subject.execute_hook_for(:invalid, "1")
-          bar.should be == "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

@@ -1,371 +0,0 @@
-# encoding: utf-8
-
-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 be == 0 }
-
-          context 'when no timeout is set' do
-            it "should have the default timeout" do
-              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 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 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 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
-
-          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 be == "" }
-        end
-
-        describe "#<<" do
-          it "should add a digit to the buffer" do
-            subject << '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 be == true
-          end
-
-          it "returns false if buffer is not empty" do
-            subject << 1
-            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 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 be == 1
-            subject.tries_count.should be == 0
-            subject.should_continue?.should be == true
-          end
-        end
-
-        describe "#restart!" do
-          it "increments tries and clears the digit buffer" do
-            subject << 1
-            subject.restart!
-            subject.tries_count.should be == 1
-            subject.digit_buffer_empty?.should be == 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 "#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 options 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
-            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.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
-            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 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 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
-
-        describe Menu::ClearableStringBuffer do
-          subject { Menu::ClearableStringBuffer.new }
-
-          it "adds a string to itself" do
-            subject << 'b'
-            subject << 'c'
-            subject.should be == 'bc'
-          end
-
-          it "clears itself" do
-            subject << 'a'
-            subject.clear!
-            subject.should be == ""
-          end
-        end
-
-    end # describe Menu
-  end
-end