adhearsion 2.0.0.rc4 → 2.0.0.rc5

data/lib/adhearsion/call_controller/menu_dsl/menu_builder.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Adhearsion
+  class CallController
+    module MenuDSL
+
+      class MenuBuilder
+
+        attr_accessor :patterns, :menu_callbacks
+
+        def initialize
+          @patterns = []
+          @menu_callbacks = {}
+          @context = nil
+        end
+
+        def build(&block)
+          @context = eval "self", block.binding
+          instance_eval(&block)
+        end
+
+        def match(*args, &block)
+          payload = if block_given?
+            raise ArgumentError, "You cannot specify both a block and a controller name." if args.last.is_a? Class
+            nil
+          else
+            raise ArgumentError, "You need to provide a block or a controller name." unless args.last.is_a? Class
+            args.pop
+          end
+
+          raise ArgumentError, "You cannot call this method without patterns." if args.empty?
+
+          args.each do |pattern|
+            @patterns << MatchCalculator.build_with_pattern(pattern, payload, &block)
+          end
+        end
+
+        def weighted_match_calculators
+          @patterns
+        end
+
+        def has_matchers?
+          @patterns.size > 0
+        end
+
+        def execute_hook_for(symbol, input)
+          callback = @menu_callbacks[symbol]
+          return unless callback
+          @context.instance_exec input, &callback
+        end
+
+        def invalid(&block)
+          raise LocalJumpError, "Must supply a block!" unless block_given?
+          @menu_callbacks[:invalid] = block
+        end
+
+        def timeout(&block)
+          raise LocalJumpError, "Must supply a block!" unless block_given?
+          @menu_callbacks[:timeout] = block
+        end
+
+        def failure(&block)
+          raise LocalJumpError, "Must supply a block!" unless block_given?
+          @menu_callbacks[:failure] = block
+        end
+
+        def validator(&block)
+          raise LocalJumpError, "Must supply a block!" unless block_given?
+          @menu_callbacks[:validator] = block
+        end
+
+        def calculate_matches_for(result)
+          CalculatedMatchCollection.new.tap do |collection|
+            weighted_match_calculators.each do |pattern|
+              collection << pattern.match(result)
+            end
+          end
+        end
+
+      end # class MenuBuilder
+
+    end
+  end
+end

data/lib/adhearsion/call_controller/menu_dsl/range_match_calculator.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Adhearsion
+  class CallController
+    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
+end

data/lib/adhearsion/call_controller/menu_dsl/string_match_calculator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Adhearsion
+  class CallController
+    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
+end

data/lib/adhearsion/cli.rb

@@ -6,6 +6,5 @@ require 'adhearsion/script_ahn_loader'
 # the rest of this script is not run.
 Adhearsion::ScriptAhnLoader.exec_script_ahn!
 
-require 'bundler/setup'
 require 'adhearsion'
 require 'adhearsion/cli_commands'

data/lib/adhearsion/router/route.rb

@@ -29,9 +29,9 @@ module Adhearsion
             target.new call
           end
 
-          call.execute_controller controller, lambda { |call|
+          call.execute_controller controller, lambda { |call_actor|
             begin
-              call.hangup
+              call_actor.hangup
             rescue Call::Hangup
             end
             callback.call if callback

data/lib/adhearsion/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Adhearsion #:nodoc:
-  VERSION = '2.0.0.rc4'
+  VERSION = '2.0.0.rc5'
 end

data/spec/adhearsion/call_controller/input_spec.rb

@@ -9,7 +9,7 @@ module Adhearsion
 
       describe "#play_sound_files_for_menu" do
         let(:options) { Hash.new }
-        let(:menu_instance) { Adhearsion::MenuDSL::Menu.new(options) }
+        let(:menu_instance) { MenuDSL::Menu.new(options) }
         let(:sound_file) { "press a button" }
         let(:sound_files) { [sound_file] }
 

data/spec/adhearsion/call_controller/menu_dsl/calculated_match_collection_spec.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    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
+end

data/spec/adhearsion/call_controller/menu_dsl/calculated_match_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    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
+end

data/spec/adhearsion/call_controller/menu_dsl/fixnum_match_calculator_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    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
+end

data/spec/adhearsion/call_controller/menu_dsl/match_calculator_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    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
+end

data/spec/adhearsion/call_controller/menu_dsl/menu_builder_spec.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  class CallController
+    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
+end