sevenscale-adhearsion 0.7.1000

data/lib/adhearsion/voip/menu_state_machine/matchers.rb

@@ -0,0 +1,123 @@
+require File.join(File.dirname(__FILE__), 'calculated_match')
+
+module Adhearsion
+  module VoIP
+    class MatchCalculator
+
+      class << self
+
+        def build_with_pattern(pattern, match_payload, &block)
+          class_for_pattern_type(pattern.class.name).new(pattern, match_payload, &block)
+        end
+
+        def inherited(klass)
+          subclasses << klass
+        end
+
+        private
+
+        def class_for_pattern_type(pattern_type)
+          sought_class_name = "Adhearsion::VoIP::#{pattern_type.camelize}MatchCalculator"
+          subclasses.find { |klass| klass.name == sought_class_name }
+        end
+
+        def subclasses
+          @@subclasses ||= []
+        end
+
+      end
+
+      attr_reader :pattern, :match_payload
+      def initialize(pattern, match_payload)
+        @pattern, @match_payload = pattern, match_payload
+      end
+
+      protected
+
+      def new_calculated_match(options)
+        CalculatedMatch.new({:pattern => pattern, :match_payload => match_payload}.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 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 argument.
+      #
+      # 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)
+        returning Array.new do |matches|
+          first, last = pattern.first, pattern.last
+          power = 0
+          while num < last
+            ones_count = 10**power - 1
+            matches.concat((([num, first].max)..[(num+ones_count), last].min).to_a)
+            num *= 10
+            power += 1
+          end
+        end
+      end
+    end
+
+    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 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
+  end
+end

data/lib/adhearsion/voip/menu_state_machine/menu_builder.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'matchers.rb')
+
+module Adhearsion
+  module VoIP
+    class MenuBuilder
+
+      def initialize
+        @patterns = []
+        @menu_callbacks = {}
+      end
+
+      def method_missing(match_payload, *patterns, &block)
+        name_string = match_payload.to_s
+        if patterns.any?
+          patterns.each do |pattern|
+            @patterns << MatchCalculator.build_with_pattern(pattern, match_payload)
+          end
+        else
+          raise ArgumentError, "You cannot call this method without patterns!"
+        end
+        nil
+      end
+
+      def weighted_match_calculators
+        @patterns
+      end
+
+      def execute_hook_for(symbol, input)
+        callback = @menu_callbacks[symbol]
+        callback.call input if callback
+      end
+
+      def on_invalid(&block)
+        raise LocalJumpError, "Must supply a block!" unless block_given?
+        @menu_callbacks[:invalid] = block
+      end
+
+      def on_premature_timeout(&block)
+        raise LocalJumpError, "Must supply a block!" unless block_given?
+        @menu_callbacks[:premature_timeout] = block
+      end
+
+      def on_failure(&block)
+        raise LocalJumpError, "Must supply a block!" unless block_given?
+        @menu_callbacks[:failure] = block
+      end
+
+      def calculate_matches_for(result)
+        returning CalculatedMatchCollection.new do |collection|
+          weighted_match_calculators.each do |pattern|
+            collection << pattern.match(result)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/adhearsion/voip/menu_state_machine/menu_class.rb

@@ -0,0 +1,149 @@
+require 'adhearsion/voip/menu_state_machine/menu_builder'
+module Adhearsion
+  module VoIP
+    class Menu
+
+      DEFAULT_MAX_NUMBER_OF_TRIES = 1
+      DEFAULT_TIMEOUT             = 5 # seconds
+
+      relationships :menu_builder => MenuBuilder
+
+      attr_reader :builder, :timeout, :tries_count, :max_number_of_tries
+      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
+
+        @builder = menu_builder.new
+        yield @builder
+
+        initialize_digit_buffer
+      end
+
+      def <<(other)
+        digit_buffer << other
+      end
+      
+      def digit_buffer
+        @digit_buffer
+      end
+      
+      def digit_buffer_string
+        digit_buffer.to_s
+      end
+      
+      def digit_buffer_empty?
+        digit_buffer.empty?
+      end
+
+      def continue
+        raise MenuGetAnotherDigitOrTimeout if digit_buffer_empty?
+
+        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?
+            # Match found with no extenuating ambiguities! Go with the first exact match
+            menu_result_found! first_exact_match.match_payload, 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
+          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(:premature_timeout, digit_buffer_string)
+      end
+
+      def execute_failure_hook
+        builder.execute_hook_for(:failure, 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!
+        raise MenuResultInvalid
+      end
+
+      def menu_result_found!(match_payload, new_extension)
+        raise MenuResultFound.new(match_payload, new_extension)
+      end
+
+      def get_another_digit_or_finish!(match_payload, new_extension)
+        raise MenuGetAnotherDigitOrFinish.new(match_payload, new_extension)
+      end
+
+      def get_another_digit_or_timeout!
+        raise MenuGetAnotherDigitOrTimeout
+      end
+
+      # The superclass from which all message-like exceptions decend. It should never
+      # be instantiated directly.
+      class MenuResult < Exception; end
+
+      # Raised when the user's input matches
+      class MenuResultFound < MenuResult
+        attr_reader :match_payload, :new_extension
+        def initialize(match_payload, new_extension)
+          super()
+          @match_payload  = match_payload
+          @new_extension = new_extension
+        end
+      end
+
+      module MenuGetAnotherDigit; end
+
+      class MenuGetAnotherDigitOrFinish < MenuResultFound
+        include MenuGetAnotherDigit
+      end
+
+      class MenuGetAnotherDigitOrTimeout < MenuResult
+        include MenuGetAnotherDigit
+      end
+
+      class MenuResultFound < MenuResult; end
+
+      # Raised when the user's input matches no patterns
+      class MenuResultInvalid < MenuResult; end
+
+      # For our default purposes, 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
+  end
+end

data/lib/adhearsion.rb

@@ -0,0 +1,31 @@
+# Check the Ruby version
+STDERR.puts "WARNING: You are running Adhearsion in an unsupported
+version of Ruby (Ruby #{RUBY_VERSION} #{RUBY_RELEASE_DATE})!
+Please upgrade to at least Ruby v1.8.5." if RUBY_VERSION < "1.8.5"
+
+module Adhearsion
+  # Sets up the Gem require path.
+  AHN_INSTALL_DIR = File.expand_path(File.dirname(__FILE__) + "/..")
+  CONFIG = {}
+end
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'adhearsion/version'
+require 'adhearsion/voip/call'
+require 'adhearsion/voip/dial_plan'
+require 'adhearsion/voip/asterisk/special_dial_plan_managers'
+require 'adhearsion/core_extensions/all'
+require 'adhearsion/blank_slate'
+require 'adhearsion/hooks'
+require 'adhearsion/logging'
+require 'adhearsion/initializer/configuration'
+require 'adhearsion/initializer'
+require 'adhearsion/initializer/paths'
+require 'adhearsion/voip/dsl/numerical_string'
+require 'adhearsion/voip/dsl/dialplan/parser'
+require 'adhearsion/voip/commands'
+require 'adhearsion/voip/asterisk/commands'
+require 'adhearsion/voip/dsl/dialing_dsl'
+require 'adhearsion/voip/call_routing'

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, "test_unit"]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, "test_unit"]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/fixtures/dialplan.rb

@@ -0,0 +1,3 @@
+sample_context {
+  raise 'the body of this context should not have been evaluated'
+}

data/spec/initializer/test_configuration.rb

@@ -0,0 +1,267 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+context "Configuration defaults" do
+  include ConfigurationTestHelper
+  attr_reader :config
+  
+  setup do
+    @config = default_config
+  end
+  
+  test "incoming calls are answered by default" do
+    assert config.automatically_answer_incoming_calls
+  end
+  
+  test "calls are ended when hung up" do
+    assert config.end_call_on_hangup
+  end
+  
+  test "if an error occurs, a call is hungup" do
+    assert config.end_call_on_error
+  end
+  
+  test "asterisk is enabled by default" do
+    assert config.asterisk_enabled?
+  end
+  
+  test "default asterisk configuration is available" do
+    assert_kind_of Adhearsion::Configuration::AsteriskConfiguration, config.asterisk
+  end
+  
+  test "database access is NOT enabled by default" do
+    assert !config.database_enabled?
+  end
+  
+  test "freeswith is NOT enabled by default" do
+    assert !config.freeswitch_enabled?
+  end
+  
+  test "AMI is NOT enabled by default" do
+    assert !config.asterisk.ami_enabled?
+  end
+  
+  test "Drb is NOT enabled by default" do
+    assert !config.drb_enabled?
+  end
+end
+
+context "Asterisk AGI configuration defaults" do
+  attr_reader :config
+  
+  setup do
+    @config = Adhearsion::Configuration::AsteriskConfiguration.new
+  end
+  
+  test "asterisk configuration sets default listening port" do
+    config.listening_port.should.equal Adhearsion::Configuration::AsteriskConfiguration.default_listening_port
+  end
+  
+  test "asterisk configuration sets default listening host" do
+    config.listening_host.should.equal Adhearsion::Configuration::AsteriskConfiguration.default_listening_host
+  end
+end
+
+context 'Logging configuration' do
+  
+  attr_reader :config
+  before :each do
+    @config = Adhearsion::Configuration.new
+  end
+  
+  after :each do
+    Adhearsion::Logging.logging_level = :fatal
+  end
+  
+  test 'the logging level should translate from symbols into Log4r constants' do
+    Adhearsion::Logging.logging_level.should.not.equal Log4r::WARN
+    config.logging :level => :warn
+    Adhearsion::Logging.logging_level.should.equal Log4r::WARN
+  end
+  
+end
+
+context "AMI configuration defaults" do
+  attr_reader :config
+  
+  setup do
+    @config = Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.new
+  end
+  
+  test "ami configuration sets default port" do
+    config.port.should.equal Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration.default_port
+  end
+  
+  test "ami allows you to configure a username and a password, both of which default to nil" do
+    config.username.should.be.nil
+    config.password.should.be.nil
+  end
+end
+
+context "Rails configuration defaults" do
+  test "should require the path to the Rails app in the constructor" do
+    config = Adhearsion::Configuration::RailsConfiguration.new :path => "path here doesn't matter right now", :env => :development
+    config.rails_root.should.not.be.nil
+  end
+  
+  test "should expand_path() the first constructor parameter" do
+    rails_root = "gui"
+    flexmock(File).should_receive(:expand_path).once.with(rails_root)
+    config = Adhearsion::Configuration::RailsConfiguration.new :path => rails_root, :env => :development
+  end
+  
+  test "should ensure that the environment provided is one supported by Rails" do
+    the_following_code {
+      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :this_is_not_a_rails_env
+    }.should.raise ArgumentError
+    
+    the_following_code {
+      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :development
+      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :production
+      Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => :test
+    }.should.not.raise ArgumentError
+  end
+  
+  test "should convert the environment into a Symbol" do
+    Adhearsion::Configuration::RailsConfiguration::SUPPORTED_RAILS_ENVIRONMENTS.should.not.be.empty
+    Adhearsion::Configuration::RailsConfiguration::SUPPORTED_RAILS_ENVIRONMENTS.each do |env|
+      config = Adhearsion::Configuration::RailsConfiguration.new :path => "doesnt matter", :env => env.to_s
+      config.environment.should.equal env
+    end
+  end
+end
+
+context "Database configuration defaults" do
+  
+  setup do
+    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined?(:AHN_CONFIG)
+    Adhearsion::Configuration.configure {}
+  end
+  
+  it "should store the constructor's argument in connection_options()" do
+    sample_options = { :adapter => "sqlite3", :dbfile => "foo.sqlite3" }
+    config = Adhearsion::Configuration::DatabaseConfiguration.new(sample_options)
+    config.connection_options.should.equal sample_options
+  end
+  it "should remove the :orm key from the connection options" do
+    sample_options = { :orm => :active_record, :adapter => "mysql", :host => "::1",
+                       :user => "a", :pass => "b", :database => "ahn" }
+    config = Adhearsion::Configuration::DatabaseConfiguration.new(sample_options.clone)
+    config.orm.should.equal sample_options.delete(:orm)
+    config.connection_options.should.equal sample_options
+  end
+end
+
+context "Freeswitch configuration defaults" do
+  attr_reader :config
+  
+  setup do
+    @config = Adhearsion::Configuration::FreeswitchConfiguration.new
+  end
+  
+  test "freeswitch configuration sets default listening port" do
+    config.listening_port.should.equal Adhearsion::Configuration::FreeswitchConfiguration.default_listening_port
+  end
+  
+  test "freeswitch configuration sets default listening host" do
+    config.listening_host.should.equal Adhearsion::Configuration::FreeswitchConfiguration.default_listening_host
+  end
+end
+
+context "Configuration scenarios" do
+  include ConfigurationTestHelper
+  
+  test "enabling AMI using all its defaults" do
+    config = enable_ami
+    
+    assert config.asterisk.ami_enabled?
+    config.asterisk.ami.should.be.kind_of Adhearsion::Configuration::AsteriskConfiguration::AMIConfiguration
+  end
+  
+  test "enabling AMI with custom configuration overrides the defaults" do
+    overridden_port = 911
+    config = enable_ami :port => overridden_port
+    config.asterisk.ami.port.should.equal overridden_port
+  end
+  
+  test "enabling Drb without any configuration" do
+    config = enable_drb
+    assert config.drb
+    config.drb.should.be.kind_of Adhearsion::Configuration::DrbConfiguration
+  end
+  
+  test "enabling Drb with a port specified sets the port" do
+    target_port = 911
+    config = enable_drb :port => target_port
+    config.drb.port.should.be.equal target_port
+  end
+  
+  private
+    def enable_ami(*overrides)
+      default_config do |config|
+        config.asterisk.enable_ami(*overrides)
+      end
+    end
+    
+    def enable_drb(*overrides)
+      default_config do |config|
+        config.enable_drb *overrides
+      end
+    end
+end
+
+context "AHN_CONFIG" do
+  setup do
+    Adhearsion.send(:remove_const, :AHN_CONFIG) if Adhearsion.const_defined?(:AHN_CONFIG)
+  end
+  
+  test "Running configure sets configuration to Adhearsion::AHN_CONFIG" do
+    assert !Adhearsion.const_defined?(:AHN_CONFIG)
+    Adhearsion::Configuration.configure do |config|
+      # Nothing needs to happen here
+    end
+    
+    assert Adhearsion.const_defined?(:AHN_CONFIG)
+    Adhearsion::AHN_CONFIG.should.be.kind_of(Adhearsion::Configuration)
+  end
+end
+
+context "DRb configuration" do
+  test "should not add any ACL rules when :raw_acl is passed in" do
+    config = Adhearsion::Configuration::DrbConfiguration.new :raw_acl => :this_is_an_acl
+    config.acl.should.equal :this_is_an_acl
+  end
+  
+  test "should, by default, allow only localhost connections" do
+    config = Adhearsion::Configuration::DrbConfiguration.new
+    config.acl.should == %w[allow 127.0.0.1]
+  end
+  
+  test "should add ACL 'deny' rules before 'allow' rules" do
+    config = Adhearsion::Configuration::DrbConfiguration.new :allow => %w[1.1.1.1  2.2.2.2],
+                                                             :deny  => %w[9.9.9.9]
+    config.acl.should == %w[deny 9.9.9.9 allow 1.1.1.1 allow 2.2.2.2]
+  end
+  
+  test "should allow both an Array and a String to be passed as an allow/deny ACL rule" do
+    config = Adhearsion::Configuration::DrbConfiguration.new :allow => "1.1.1.1", :deny => "9.9.9.9"
+    config.acl.should == %w[deny 9.9.9.9 allow 1.1.1.1]
+  end
+  
+  test "should have a default host and port" do
+    config = Adhearsion::Configuration::DrbConfiguration.new
+    config.host.should.not.equal nil
+    config.port.should.not.equal nil
+  end
+  
+end
+
+BEGIN {
+  module ConfigurationTestHelper
+    def default_config(&block)
+      Adhearsion::Configuration.new do |config|
+        config.enable_asterisk
+        yield config if block_given?
+      end
+    end
+  end
+}