adhearsion 2.0.0.rc4 → 2.0.0.rc5

data/lib/adhearsion/menu_dsl.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-    extend ActiveSupport::Autoload
-
-    autoload :Exceptions
-    autoload :CalculatedMatch
-    autoload :CalculatedMatchCollection
-    autoload :MatchCalculator
-    autoload :FixnumMatchCalculator
-    autoload :RangeMatchCalculator
-    autoload :StringMatchCalculator
-    autoload :MenuBuilder
-    autoload :Menu
-  end
-end

data/lib/adhearsion/menu_dsl/calculated_match.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-    class CalculatedMatch
-
-      def self.failed_match!(pattern, query, match_payload)
-        new :pattern => pattern, :query => query, :match_payload => match_payload
-      end
-
-      attr_reader :match_payload, :potential_matches, :exact_matches, :pattern, :query, :block
-
-      def initialize(options = {})
-        @pattern, @query, @match_payload, @block = options.values_at :pattern, :query, :match_payload, :block
-        @potential_matches  = options[:potential_matches] ? Array(options[:potential_matches]) : []
-        @exact_matches      = options[:exact_matches] ? Array(options[:exact_matches]) : []
-      end
-
-      def exact_match?
-        exact_matches.any?
-      end
-
-      def potential_match?
-        potential_matches.any?
-      end
-
-      def failed_match?
-        !(potential_match? || exact_match?)
-      end
-
-      def type_of_match
-        if exact_match?
-          :exact
-        elsif potential_match?
-          :potential
-        end
-      end
-
-    end
-  end
-end

data/lib/adhearsion/menu_dsl/calculated_match_collection.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-    class CalculatedMatchCollection
-      attr_reader :calculated_matches, :potential_matches, :exact_matches,
-        :actual_potential_matches, :actual_exact_matches
-
-      def initialize
-        @calculated_matches       = []
-        @potential_matches        = []
-        @exact_matches            = []
-        @actual_potential_matches = []
-        @actual_exact_matches     = []
-      end
-
-      def <<(calculated_match)
-        calculated_matches << calculated_match
-        actual_potential_matches.concat calculated_match.potential_matches
-        actual_exact_matches.concat calculated_match.exact_matches
-
-        potential_matches << calculated_match if calculated_match.potential_match?
-        exact_matches << calculated_match if calculated_match.exact_match?
-      end
-
-      def potential_match_count
-        actual_potential_matches.size
-      end
-
-      def exact_match_count
-        actual_exact_matches.size
-      end
-
-      def potential_match?
-        potential_match_count > 0
-      end
-
-      def exact_match?
-        exact_match_count > 0
-      end
-    end
-  end
-end

data/lib/adhearsion/menu_dsl/fixnum_match_calculator.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-    class FixnumMatchCalculator < MatchCalculator
-
-      def match(query)
-        numeric_query = coerce_to_numeric query
-        exact_match, potential_match = nil
-        if pattern == numeric_query
-          exact_match = pattern
-        elsif pattern.to_s.starts_with? query.to_s
-          potential_match = pattern
-        end
-        new_calculated_match :query => query, :exact_matches => exact_match, :potential_matches => potential_match
-      end
-
-    end # class FixnumMatchCalculator
-  end
-end

data/lib/adhearsion/menu_dsl/match_calculator.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-    class MatchCalculator
-
-      class << self
-
-        def build_with_pattern(pattern, match_payload, &block)
-          class_for_pattern(pattern).new pattern, match_payload, &block
-        end
-
-        private
-
-        def class_for_pattern(pattern)
-          MenuDSL.const_get "#{pattern.class.name.camelize}MatchCalculator"
-        end
-      end
-
-      attr_reader :pattern, :match_payload, :block
-
-      def initialize(pattern, match_payload, &block)
-        @pattern, @match_payload, @block = pattern, match_payload, block
-      end
-
-      protected
-
-      def new_calculated_match(options)
-        CalculatedMatch.new({:pattern => pattern, :match_payload => match_payload, :block => block}.merge(options))
-      end
-
-      def coerce_to_numeric(victim)
-        victim.kind_of?(Numeric) ? victim : (victim.to_s =~ /^\d+$/ ? victim.to_s.to_i : nil )
-      end
-
-    end # class MatchCalculator
-  end
-end

data/lib/adhearsion/menu_dsl/menu.rb

@@ -1,201 +0,0 @@
-# encoding: utf-8
-
-module Adhearsion
-  module MenuDSL
-
-    class Menu
-
-      DEFAULT_MAX_NUMBER_OF_TRIES = 1
-      DEFAULT_TIMEOUT             = 5
-
-      InvalidStructureError = Class.new Adhearsion::Error
-
-      attr_reader :builder, :timeout, :tries_count, :max_number_of_tries, :terminator, :limit, :interruptible, :status
-
-      def initialize(options = {}, &block)
-        @tries_count          = 0 # Counts the number of tries the menu's been executed
-        @timeout              = options[:timeout] || DEFAULT_TIMEOUT
-        @max_number_of_tries  = options[:tries]   || DEFAULT_MAX_NUMBER_OF_TRIES
-        @terminator           = options[:terminator].to_s
-        @limit                = options[:limit]
-        @interruptible        = options.has_key?(:interruptible) ? options[:interruptible] : true
-        @builder              = MenuDSL::MenuBuilder.new
-        @terminated           = false
-
-        @builder.build(&block) if block
-
-        initialize_digit_buffer
-      end
-
-      def validate(mode = nil)
-        case mode
-        when :basic
-          @terminator.present? || !!@limit || raise(InvalidStructureError, "You must specify at least one of limit or terminator")
-        else
-          @builder.has_matchers? || raise(InvalidStructureError, "You must specify one or more matchers")
-        end
-      end
-
-      def <<(other)
-        if other == terminator
-          @terminated = true
-        else
-          digit_buffer << other
-        end
-      end
-
-      def digit_buffer
-        @digit_buffer
-      end
-
-      def digit_buffer_string
-        digit_buffer.to_s
-      end
-      alias :result :digit_buffer_string
-
-      def digit_buffer_empty?
-        digit_buffer.empty?
-      end
-
-      def continue
-        return get_another_digit_or_timeout! if digit_buffer_empty?
-
-        return menu_terminated! if @terminated
-        return menu_limit_reached! if limit && digit_buffer.size >= limit
-
-        return menu_validator_terminated! if execute_validator_hook
-
-        calculated_matches = builder.calculate_matches_for digit_buffer_string
-
-        if calculated_matches.exact_match_count >= 1
-          first_exact_match = calculated_matches.exact_matches.first
-          if calculated_matches.potential_match_count.zero?
-            menu_result_found! first_exact_match, digit_buffer_string
-          else
-            get_another_digit_or_finish! first_exact_match.match_payload, first_exact_match.query
-          end
-        elsif calculated_matches.potential_match_count >= 1 || !@builder.has_matchers?
-          get_another_digit_or_timeout!
-        else
-          invalid!
-        end
-      end
-
-      def should_continue?
-        tries_count < max_number_of_tries
-      end
-
-      def restart!
-        @tries_count += 1
-        digit_buffer.clear!
-      end
-
-      def execute_invalid_hook
-        builder.execute_hook_for :invalid, digit_buffer_string
-      end
-
-      def execute_timeout_hook
-        builder.execute_hook_for :timeout, digit_buffer_string
-      end
-
-      def execute_failure_hook
-        builder.execute_hook_for :failure, digit_buffer_string
-      end
-
-      def execute_validator_hook
-        builder.execute_hook_for :validator, digit_buffer_string
-      end
-
-      protected
-
-      # If you're using a more complex class in subclasses, you may want to override this method in addition to the
-      # digit buffer, digit_buffer_empty, and digit_buffer_string methods
-      def initialize_digit_buffer
-        @digit_buffer = ClearableStringBuffer.new
-      end
-
-      def invalid!
-        @status = :invalid
-        MenuResultInvalid.new
-      end
-
-      def menu_result_found!(match_object, new_extension)
-        @status = :matched
-        MenuResultFound.new(match_object, new_extension)
-      end
-
-      def menu_terminated!
-        @status = :terminated
-        MenuTerminated.new
-      end
-
-      def menu_validator_terminated!
-        @status = :validator_terminated
-        MenuValidatorTerminated.new
-      end
-
-      def menu_limit_reached!
-        @status = :limited
-        MenuLimitReached.new
-      end
-
-      def get_another_digit_or_finish!(match_payload, new_extension)
-        @status = :multi_matched
-        MenuGetAnotherDigitOrFinish.new(match_payload, new_extension)
-      end
-
-      def get_another_digit_or_timeout!
-        @status = :potential
-        MenuGetAnotherDigitOrTimeout.new
-      end
-
-      # The superclass from which all message-like exceptions descend. It should never
-      # be instantiated directly.
-      MenuResult      = Class.new
-      MenuResultDone  = Class.new MenuResult
-
-      class MenuResultFound < MenuResult
-
-        attr_reader :match_object, :new_extension
-
-        def initialize(match_object, new_extension)
-          super()
-          @match_object = match_object
-          @new_extension = new_extension
-        end
-
-      end #class MenuResultFound < MenuResult
-
-      MenuGetAnotherDigit = Module.new
-
-      class MenuGetAnotherDigitOrFinish < MenuResultFound
-        include MenuGetAnotherDigit
-      end
-
-      class MenuGetAnotherDigitOrTimeout < MenuResult
-        include MenuGetAnotherDigit
-      end
-
-      MenuResultInvalid = Class.new MenuResult
-
-      MenuTerminated = Class.new MenuResultDone
-      MenuValidatorTerminated = Class.new MenuResultDone
-      MenuLimitReached = Class.new MenuResultDone
-
-      # For our default purpose, we need the digit_buffer to behave much like a normal String except that it should
-      # handle its own resetting (clearing)
-      class ClearableStringBuffer < String
-        def clear!
-          replace ""
-        end
-
-        def <<(other)
-          super other.to_s
-        end
-      end
-
-
-    end # class Menu
-
-  end
-end

data/lib/adhearsion/menu_dsl/menu_builder.rb

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