adhearsion 0.7.7 → 0.8.0

data/app_generators/ahn/templates/components/simon_game/simon_game.rb

@@ -0,0 +1,56 @@
+methods_for :dialplan do
+  def simon_game
+    SimonGame.new(self).start
+  end
+end
+
+class SimonGame
+
+  def initialize(call)
+    @call = call
+    reset
+  end
+  
+  def start
+    loop do
+      say_number
+      collect_attempt
+      verify_attempt
+    end
+  end
+
+  def random_number
+    rand(10).to_s
+  end
+
+  def update_number
+    @number << random_number
+  end
+
+  def say_number
+    update_number
+    @call.say_digits @number
+  end
+
+  def collect_attempt
+    @attempt = @call.input @number.length
+  end
+
+  def verify_attempt
+    if attempt_correct? 
+      @call.play 'good'
+    else
+      @call.play %W[#{@number.length-1} times wrong-try-again-smarty]
+      reset
+    end
+  end
+
+  def attempt_correct?
+    @attempt == @number
+  end
+  
+  def reset
+    @attempt, @number = '', ''
+  end
+  
+end

data/app_generators/ahn/templates/config/startup.rb

@@ -0,0 +1,50 @@
+unless defined? Adhearsion
+  if File.exists? File.dirname(__FILE__) + "/../adhearsion/lib/adhearsion.rb"
+    # If you wish to freeze a copy of Adhearsion to this app, simply place a copy of Adhearsion
+    # into a folder named "adhearsion" within this app's main directory.
+    require File.dirname(__FILE__) + "/../adhearsion/lib/adhearsion.rb"
+  else  
+    require 'rubygems'
+    gem 'adhearsion', '>= 0.7.999'
+    require 'adhearsion'
+  end
+end
+
+Adhearsion::Configuration.configure do |config|
+  
+  # Supported levels (in increasing severity) -- :debug < :info < :warn < :error < :fatal
+  config.logging :level => :info
+  
+  # Whether incoming calls be automatically answered. Defaults to true.
+  # config.automatically_answer_incoming_calls = false
+  
+  # Whether the other end hanging up should end the call immediately. Defaults to true.
+  # config.end_call_on_hangup = false
+  
+  # Whether to end the call immediately if an unrescued exception is caught. Defaults to true.
+  # config.end_call_on_error = false
+  
+  # By default Asterisk is enabled with the default settings
+  config.enable_asterisk
+  # config.asterisk.enable_ami :host => "127.0.0.1", :username => "admin", :password => "password", :events => true
+  
+  # config.enable_drb
+  
+  # Streamlined Rails integration! The first argument should be a relative or absolute path to 
+  # the Rails app folder with which you're integrating. The second argument must be one of the 
+  # the following: :development, :production, or :test.
+  
+  # config.enable_rails :path => 'gui', :env => :development
+  
+  # Note: You CANNOT do enable_rails and enable_database at the same time. When you enable Rails,
+  # it will automatically connect to same database Rails does and load the Rails app's models.
+  
+  # Configure a database to use ActiveRecord-backed models. See ActiveRecord::Base.establish_connection
+  # for the appropriate settings here.
+  # config.enable_database :adapter  => 'mysql',
+  #                        :username => 'joe', 
+  #                        :password => 'secret',
+  #                        :host     => 'db.example.org'
+end
+
+Adhearsion::Initializer.start_from_init_file(__FILE__, File.dirname(__FILE__) + "/..")

data/app_generators/ahn/templates/dialplan.rb

@@ -0,0 +1,3 @@
+adhearsion {
+  simon_game
+}

data/app_generators/ahn/templates/events.rb

@@ -0,0 +1,32 @@
+##
+# In this file you can define callbacks for different aspects of the framework. Below is an example:
+##
+#
+# events.asterisk.before_call.each do |call|
+#   # This simply logs the extension for all calls going through this Adhearsion app.
+#   extension = call.variables[:extension]
+#   ahn_log "Got a new call with extension #{extension}"
+# end
+#
+##
+# Asterisk Manager Interface example:
+#
+# events.asterisk.manager_interface.each do |event|
+#   ahn_log.events event.inspect
+# end
+#
+# This assumes you gave :events => true to the config.asterisk.enable_ami method in config/startup.rb
+#
+##
+# Here is a list of the events included by default:
+#
+# - events.asterisk.manager_interface
+# - events.after_initialized
+# - events.shutdown
+# - events.asterisk.before_call
+# - events.asterisk.failed_call
+# - events.asterisk.call_hangup
+#
+#
+# Note: events are mostly for components to register and expose to you.
+##

data/bin/ahn

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# This is the main executable file.
+
+# Adhearsion, open source collaboration framework
+# Copyright (C) 2006,2007,2008 Jay Phillips
+# 
+# This library is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 2.1 of the License, or (at your option)
+# any later version.
+# 
+# This library is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+# 
+# You should have received a copy of the GNU Lesser General Public License along
+# with this library; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'adhearsion'
+require 'adhearsion/cli'
+
+Adhearsion::CLI::AhnCommand.execute!

data/bin/ahnctl

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# 
+#  ahnctl - Adhearsion daemon controller
+#
+# Adhearsion, open source collaboration framework
+# Copyright (C) 2006,2007,2008 Jay Phillips
+# 
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+# 
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+USAGE = "Usage: ahnctl start|stop|restart /path/to/adhearsion/app [--pid-file=/path/to/pid_file.pid]" 
+
+# Blow up if the CLI arguments are invalid
+abort USAGE unless (2..3).include?(ARGV.size) && %w[start stop restart].include?(ARGV.first)
+
+# By default, ahnctl will use the version of Adhearsion it was installed with.
+
+pid_file    = ARGV.pop if ARGV.size == 3
+ahn_command = File.expand_path File.dirname(__FILE__) + "/ahn"
+app_dir     = File.expand_path ARGV.last
+
+pid_file_path_regexp = /^--pid-file=(.+)$/
+abort USAGE if pid_file && pid_file !~ pid_file_path_regexp
+
+# If pid_file is not nil, let's extract the path specified.
+pid_file &&= File.expand_path pid_file[pid_file_path_regexp,1]
+
+# If there was no third argument and pid_file is still nil, let's use the default.
+pid_file ||= app_dir + '/adhearsion.pid'
+
+abort "Directory is not an Adhearsion application!" unless File.exists?(app_dir + "/.ahnrc")
+
+def terminate(pid) `kill -s TERM #{pid} 2> /dev/null` end
+def      kill(pid) `kill -s KILL #{pid} 2> /dev/null` end
+
+# Even if we're starting Adhearsion, we need to make sure to clean up after any stale
+# pid files. In effect, start is the same as restart.
+puts "Stopping Adhearsion app at #{app_dir}" if %w[stop restart].include? ARGV.first
+
+if File.exists?(pid_file)
+  # An Adhearsion process may still be running. Let's kill the other one as cleanly as possible
+  pid = File.read(pid_file).to_i
+  
+  # Time to spend waiting for Adhearsion to exit
+  waiting_timeout = Time.now + 15
+  
+  terminate pid
+  sleep 0.25 until `ps -p #{pid} | sed -e '1d'`.strip.empty? || Time.now > waiting_timeout
+  kill pid
+  
+  `rm -f #{pid_file}`
+end
+
+if ['start', 'restart'].include? ARGV.first
+  puts "Starting Adhearsion app at #{app_dir}"
+  `#{ahn_command} start daemon #{app_dir} --pid-file=#{pid_file}`
+end

data/bin/jahn

@@ -0,0 +1,42 @@
+#!/usr/bin/env jruby
+
+# This "jahn" script is "ahn" for JRUBY!
+
+# Adhearsion, open source collaboration framework
+# Copyright (C) 2006,2007,2008 Jay Phillips
+# 
+# This library is free software; you can redistribute it and/or modify it under
+# the terms of the GNU Lesser General Public License as published by the Free
+# Software Foundation; either version 2.1 of the License, or (at your option)
+# any later version.
+# 
+# This library is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+# details.
+# 
+# You should have received a copy of the GNU Lesser General Public License along
+# with this library; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'adhearsion'
+require 'adhearsion/cli'
+
+# jahn will soon have JRuby-specific behavior such as creating a compiled .jar
+# file from an app.
+# require 'adhearsion/jruby'
+
+abort(<<-MESSAGE) unless RUBY_PLATFORM =~ /java/
+You must use jahn with JRuby! Are you running this script after installing Adhearsion with non-JRuby RubyGems?
+
+If you don't want to install Adhearsion with the JRuby version of RubyGems, try running jahn directly with an absolute path:
+
+#{File.expand_path(__FILE__)} start your_app_name
+
+Note: You must have the jruby executable in your $PATH and $JRUBY_HOME set.
+MESSAGE
+
+Adhearsion::CLI::AhnCommand.execute!

data/examples/asterisk_manager_interface/standalone.rb

@@ -0,0 +1,51 @@
+# This is a file which shows you how to use the Asterisk Manager Interface library in a standalone Ruby script.
+
+PATH_TO_ADHEARSION = File.join(File.dirname(__FILE__), "/../..")
+
+MANAGER_CONNECTION_INFORMATION = {
+  :host     => "10.0.1.97",
+  :username => "jicksta",
+  :password => "roflcopter",
+  :events   => true
+}
+
+require 'rubygems'
+begin
+  require 'adhearsion'
+rescue LoadError
+  begin
+    require File.join(PATH_TO_ADHEARSION, "/lib/adhearsion")
+  rescue LoadError
+    abort "Could not find Adhearsion! Please update the PATH_TO_ADHEARSION constant in this file"
+  end
+end
+
+require 'adhearsion/voip/asterisk/manager_interface'
+
+# If you'd like to see the AMI protocol data, change this to :debug
+Adhearsion::Logging.logging_level = :warn
+
+# This makes addressing the ManagerInterface class a little cleaner
+include Adhearsion::VoIP::Asterisk::Manager
+
+# Let's instantiate a new ManagerInterface object and have it automatically connect using the Hash we defined above.
+interface = ManagerInterface.connect MANAGER_CONNECTION_INFORMATION
+
+# Send an AMI action with our new ManagerInterface object. This will return an Array of SIPPeer events.
+sip_peers = interface.send_action "SIPPeers"
+
+# Pretty-print the SIP peers on the server
+
+if sip_peers.any?
+  sip_peers.each do |peer|
+    # Uncomment the following line to view all the headers for each peer.
+    # p peer.headers
+    
+    peer_name   = peer.headers["ObjectName"]
+    peer_status = peer.headers["Status"]
+    
+    puts "#{peer_name}: #{peer_status}"
+  end
+else
+  puts "This Asterisk server has no SIP peers!"
+end

data/lib/adhearsion.rb

@@ -1,955 +1,37 @@
-# Adhearsion, open source technology integrator
-# Copyright (C) 2006,2007 Jay Phillips
-# 
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-# 
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-# Lesser General Public License for more details.
-# 
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-require 'core_extensions'
-require 'phone_number'
-
-module Asterisk
-	
-	# The exec method allows any traditional Asterisk applications to be called
-  # within Adhearsion. The first argument should be the case-insensitive name
-  # of the application and any arguments needed by the application can simply
-  # by trailed onto the end of the method. For a full list of Asterisk's
-  # applications, see
-  # "this":http://www.voip-info.org/wiki/index.php?page=Asterisk+-+documentation+of+application+commands
-	def exec(app, *options)
-		result = rawr "EXEC #{app} " + (options * '|')
-		result = result[/-?\d+$/]
-		result == "-2" ? false : result
-	end
-  
-  # If this method is invoked during a call, the Call Detail Records (the logs
-  # Asterisk keeps on its calls) will not be written when the call completes.
-  def no_cdr() rawr :NoCDR end
-  alias do_not_bill no_cdr
-  
-	# This method of receiving user input uses the fantastic Asterisk
-  # Read() application, but its results are pretty inconsitent over
-  # AGI. This code has been kept here in case these bugs are fixed.
-	def old_input digits=nil, user_options=Hash.new('')
-    used_options = {:variable => String.random, :digits => digits}
-    used_options.default = ''
-    used_options.merge! user_options
-    args = []
-    %w(variable soundfile digits option attempts timeout).each do |x|
-    	args << used_options[x.to_sym]
-    end
-    log "THESE ARE THE INPUT ARGS: " + args.inspect
-    exec :read, args
-    $OSCAR[:VARS] << args.first
-    x = get_variable(args.first).gsub(/[\(\)]/, "")
-    debug "RETURN: #{x.inspect}"
-    x.simplify
-	end
-	
-	# Input is used to receive keypad input from the user, pausing until they
-	# have entered the desired number of digits (specified with the first
-	# parameter) or the timeout has been reached (specified as a hash argument
-	# with the key :timeout). By default, there is no timeout, waiting infinitely.
-	#
-	# If you desire a sound to be played other than a simple beep to instruct
-	# the callee to input data, pass the filename as an hash argument with either
-	# the :play or :file key.
-	#
-	# When called without any arguments (or a first argument of -1), the user is
-	# able to enter digits ad infinitum until they press the pound (#) key.
-	#
-	# Note: input() does NOT catch "#" character! Use wait_for_digit instead.
-  def input digits=nil, hash={}
-    timeout, file = (hash[:timeout] || -1), (hash[:play] || hash[:file] || 'beep')
-    result = rawr "GET DATA #{file} #{timeout} #{digits}"
-    result = result[/\=-?[\d*]+/]
-    result ? result[1..-1] : false
-  end
-
-  # Does as you'd imagine: returns the amount of time the given block takes to
-  # execute. This is particularly useful in VoIP since billing and such often
-  # requires time keeping beyond the Call Detail Records. This method is also
-  # aliased to bill() as well.
-  def time
-    return 0 unless block_given?
-    start = Time.now
-    yield start
-    Time.now - start
-  end
-  alias bill time
-
-  # When called, this command will record the current channel to a file. The
-  # recording will stop either when the caller hangs up or when she presses
-  # the # key. Four arguments exist for your use:
-  #
-  # - :file defaults to "/tmp/recording_%d.wav" where %d is a number cleverly
-  #   incremented by Asterisk. If you override this argument, you too can
-  #   use '%d' in the filename to have it automatically incremented for you.
-  #   The return value of record() will be whatever filename Asterisk just used.
-  #   Filenames can be either an absolute path or simple name. When no apparent
-  #   directory is given, Asterisk will use /var/lib/asterisk/sounds. Ensure this
-  #   directory is writable to the user account with which Asterisk runs.
-  #
-  # - :silence specifies the number of seconds Asterisk should wait in silence
-  #   before ending the call. 
-  #
-  # - :max is the maximum length of the sound file in seconds. Feel free to use
-  #   Adhearsion's Fixnum convenience methods here (e.g. 1.minute, 12.hours)
-  #
-  # - :options can be 'skip' to return immediately if the line is not up, or
-  #   'noanswer' to record even if the line is not up.
-  #
-  # === Notes
-  #
-  # Keep in mind if you user decides to hang up to end the recording, the thread
-  # handling the call will end but the file will still be saved. Try to do any
-  # necessary processing before-hand. If you're trying to use the return value
-  # of record(), you may not get it if the thread gets terminated. Instead, create
-  # your own filename and save it somewhere safe (in a database for example) and
-  # then record the user to your pre-created filename.
-  #
-  # === Examples
-  #
-  #   record # A filename will be made for you and returned
-  #   record :file => 'foo.wav'
-  #   record :max => 2.minutes + 30.seconds
-  #   record :file => '/tmp/recordings/COMPLAINT_%d.gsm', :silence => 5
-  #
-  def record hash={}
-    raise NotImplementedError if block_given? # TODO support recording a block of code
-    defaults = {:file => "/tmp/recording_%d.wav", :silence => 0, :max => 0}
-    args = defaults.merge hash
-    
-    exec :Record, args[:file], args[:silence], args[:max], args[:options]
-    args[:file].index('%d') ? get_variable('RECORDED_FILE')[1..-2] : args[:file]
-  end
-  
-  # Invokes the AGI RECORD FILE method as outlined below
-  # Note that the timeout value must be expressed in milliseconds
-  def record_file file, hash={}
-		#RECORD FILE <filename> <format> <escape digits> <timeout>
-		format, digits, timeout, beep, silence = (hash[:format] || 'gsm'), (hash[:digits] || '#'), 
-																						 (hash[:timeout] || 15000), (hash[:beep] ? 'BEEP' : nil), ("s=#{hash[:silence]}" || nil)
-		result = rawr "RECORD FILE #{file} #{format} \"#{digits}\" #{timeout} #{beep} #{silence}"
-    result = result[/\=-?\d+/]
-    result ? result[1..-1] : false
-	end
-
-  # Waits for single digit numpad key response from the user. If no timeout argument
-  # is given, the system will wait indefinitely. The argument is the desired time
-  # to wait for the response in seconds. Feel free to use the ActiveSupport extensions
-  # for using this method like wait_for_digit(2.minutes) or something similar. When the
-  # timeout is encountered (or an error occurs receiving the input), the method
-  # returns nil. If the asterisk or pound key was pressed, a String is returned of that
-  # response. In all other cases, the Fixnum of the number pressed is returned.
-  def wait_for_digit timeout=-1
-    digit = rawr("WAIT FOR DIGIT #{timeout < 0 ? -1 : timeout * 1000.0}").match(/=(.*)$/)[1].to_i
-    return nil if digit <= 0 # If there was an error or timeout
-    return digit.chr if (32..45).include? digit
-    digit - ?0
-  end
-
-  # An abstracted remote mutator for setting Asterisk variables.
-  # You may optionally pass as a third argument ":normally" to
-  # have the variable set with Set() instead of AGI.
-	def set_variable(key,value,mode=:abnormally)
-	  case mode
-	    when :abnormally then rawr "SET VARIABLE #{key} #{value}"
-	    when :normally then exec :Set, "#{key}=#{value}"
-	    else raise "Invalid mode when setting variable!"
-    end
-  end
-  
-  def detach!
-    PBX.io.close
-  end
-  
-	# An abstracted remote accessor for retrieving Asterisk variables.
-	def get_variable(key, default=nil)
-		result = rawr "GET VARIABLE #{key}"
-		result[0..12] == "200 result=0" ? default : result[14..-2].strip
-	end
-
-  # Plays a tone over the call.
-  #
-  # Usage:
-  #  - tone:busy
-  #  - tone:dial
-  #  - tone:info
-  #  - tone:record
-  #  - tone "3333/33,0/15000" # Random custom tone
-  def tone type
-    exec 'PlayTones', (case type
-      when :busy   then "480+620/500,0/500"
-      when :dial   then "440+480/2000,0/4000"
-      when :info   then "!950/330,!1400/330,!1800/330,0"
-      when :record then "1400/500,0/15000"
-      else type
-    end)
-  end
-
-  # == Dialing Users
-  # 
-  # This method will be used in most dial plans written with Adhearsion.
-  # The first argument is the destination which can be given in a number
-  # of syntactically sweet formats:
-  #
-  #   - A "Group" of users. This is determined by whether the passed group
-  #     responds to the members, users, member, or user methods. If
-  #     so, all members of that group will ring simultaneously. This would
-  #     be especially useful for, say, technical support groups which all
-  #     share the same line. When the first person picks up the line, the
-  #     rest of the phones will stop ringing. The array of users supplied
-  #     by one of the aforementioned methods can follow any of the
-  #     standards below.
-  #   - An Array of "Users".
-  #   - A single "User". A User is defined by something that responds to the
-  #     extension or extensions methods. The return value of these two
-  #     methods can either be any of the following formats:
-  #   - A String. The String can contain a simple number or be a fully
-  #     qualified Asterisk-ready String. e.g. 'SIP/codemecca@sipphone'.
-  #   - A Numeric or Symbol. In this case, the SIP technology is used by
-  #     default. See the examples below.
-  #
-  # == Dialing Examples
-  #
-  #   - dial 123             # => SIP/123
-  #   - dial "123"           # => SIP/123
-  #   - dial SIP/123         # => SIP/123
-  #   - dial "SIP/123"       # => SIP/123
-  #   - dial IAX/123         # => IAX2/123
-  #   - dial IAX/:jay        # => IAX2/jay
-  #   - dial IAX2/123        # => IAX2/123
-  #   - dial ZAP/123         # => Zap/123
-  #   - dial Zap/:out        # => Zap/out
-  #   - dial :mikey          # => SIP/mikey
-  #   - dial SIP/:mikey      # => SIP/mikey
-  #   - dial "SIP/:mikey"    # Don't do this
-  #   - dial SIP/'mikey'     # => SIP/mikey
-  #   - dial 1_555_123_7890  # => SIP/1_555_123_7890
-  #   - dial 'SIP/15551237890@sipphone' # => SIP/15551237890@sipphone
-  #
-  # Note, in the last example, the part following the @ sign is a section
-  # from sip.conf.
-  #
-  # == More complex usage
-  # 
-  # If you should want to have the phone ring for only a pre-determined set
-  # of time (which you likely will to have the call redirect to voicemail for
-  # example), then a :for => 15.seconds type of syntax can be used. Examples:
-  #
-  #   dial :jay, :for => 2.minutes
-  #
-  # The result of the last call can be retrieved by using the dial plan
-  # methods last_call_successful?, last_call_unsuccessful?, or
-  # last_dial_status. Note: last_dial_status returns a Symbol representing
-  # the result of the last call. For more information, see its appropriate
-  # documentation.
-  #
-  # === Setting CallerID
-  #
-  # To set the callerid number, simply pass either a number or a String of the
-  # digits to dial() as a Symbol key argument.
-  #
-  #   dial :crusher, :callerid => 1_555_123_4567
-  #   dial :picard, :callerid => 12224561701
-  #   dial :laforge, :callerid => '14442223333'
-  #
-  # === Dial options
-  #
-  # Additionally, you can use the :options hash key argument to specify options
-  # which Asterisk's Dial() application normally takes. For example:
-  # 
-  #   dial :jay, :for => 30.seconds, :options => 'tmw'
-  #   dial 1_444_555_6666, :options => 'S(30)'
-  #
-  # == Resources
-  #
-  # For more information, see the VoIP-Info.org page on dialing in Asterisk at
-  # http://www.voip-info.org/wiki-Asterisk+cmd+Dial
-	def dial who, hash={}
-    # if who.is_a_group? TODO: Set the CDR GROUP() value if a Group is dialed.
-    
-    # TODO Must be provided as a number until the Set(CALLERID(name)=something)
-    # stuff is figured out.
-    cid = hash.delete :callerid
-    if cid
-      cid = cid.to_s
-      cid = "1" << cid if cid.size == 10
-      rawr %(SET CALLERID "#{cid}") if cid
-    end
-    
-		exec :dial, PBX.properize(who), *[hash[:for], hash[:options]]
-	end
-  
-  # As you might expect, last_call_successful? returns a boolean depending on whether
-  # the last call to dial() finished successfully. Success is determined only if the
-  # call was answered.
-  def last_call_successful?
-    last_dial_status == :answer
-  end
-  
-  # The opposite of last_call_successful?. Here for syntactical sugar.
-  def last_call_unsuccessful?
-    !last_call_successful?
-  end
-
-  # Send a DTMF tone over the line
-	def dtmf digits
-		exec "SendDTMF", digits.to_s
-	end
-  
-  # The stream_file() method comes right over from the AGI protocol.
-  # Its use is very similar to the Background() application from
-  # Asterisk's extensions.conf language. A file is played in the
-  # background while optionally waiting for input. In the event
-  # the second argument is given, Asterisk will listen for that
-  # sequence of digits and return control to Adhearsion, informing
-  # us of the digits the user pressed. These digits are returned
-  # as a String. If you would also like to know the ending position
-  # at which the streaming stopped, see stream_file_with_offset().
-  def stream_file file, digits='', offset=0
-    stream_file_with_offset(file, digits, offset).first
-  end
-
-  # Similar to stream_file(), but returning an array of length 2
-  # instead. If supplied a first argument, the return value will
-  # be digits pressed by the user to end
-  def stream_file_with_offset file, digits='', offset=0
-    response = rawr "STREAM FILE #{file} #{digits} #{offset}"
-    return nil unless response.starts_with? '200'
-
-    result_index = response.index(?=)  + 1
-    spacer_index = response.rindex(' ')
-    endpos_index = spacer_index + 8 # " endpos=".length == 8
-
-    result = response[result_index...spacer_index].to_i
-    endpos = response[endpos_index..-1].to_i
-
-    return [nil,nil] if (result.zero? && endpos.zero?) || result == -1
-
-    [result, endpos]
-  end
-  
-  # Festival is pretty buggy (and pretty inefficient). In theory,
-  # this should speak out any text supplied to it.
-  def speak text
-    text.gsub! "\n",''
-    text.gsub! "\r",''
-    text.strip!
-    exec :Festival, "#{text.inspect}"
-  end
-
-  def build_local first, second=nil
-    num = 1
-    context = nil
-    if first.kind_of? Fixnum
-      num = first
-      context = second if second
-    else
-      context = first
-      num = second if second
-    end
-    returning("Local/#{num}") do |s|
-      s << "@#{context}" if context
-    end
-  end
-
-  def external_invoke *args
-    dial build_local(*args)
-  end
-  
-  # Since voicemail is used so frequently, extra effort has been made to
-  # make it syntactically sweet. voicemail() takes the mailbox number of
-  # a user as its first or second argument and the mailbox type as its
-  # first or second argument (the order doesn't matter). If a specific
-  # voicemail context is necessary, trail it to the end of the method
-  # with the ":at => 'contextname'" syntax. The mailbox type can be
-  # :busy, :unavailable, or :normal, though if no type is given, the
-  # type :normal is assumed.
-  #
-  # Usage: voicemail :busy, 4544
-  #    or: voicemail 4544
-  #    or: voicemail 4544, :unavailable, :at => 'codemecca'
-  def voicemail *args
-    hash = args.last.is_a?(Hash) ? args.pop : {}
-    type = [:skip, :busy, :unavailable] & args
-
-    box = (args - type).to_s # Destination mailbox
-    box = type.map { |x| x.to_s[0].chr }.to_s + box
-    box += "@#{hash[:at]}" if hash[:at]
-
-    exec :Voicemail, box
-  end
-
-  # Execute VoiceMailMain behind the scenes to check a specified
-  # user's voicemail inbox or, if no arguments are passed, prompt
-  # the user for their mailbox number.
-  #
-  # Usage: check_voicemail 'jay', :at => 'default', :args => 's'
-  #   or : check_voicemail
-  #   or : check_voicemail 'hubbard'
-  def check_voicemail name=nil, hash={}
-    args = [ [name, hash[:at]].compact * '@', hash[:args]]
-    exec :VoiceMailMain, args.compact
-  end
-
-  # Used to join a particular conference with the MeetMe application. To
-  # use MeetMe, be sure you have a proper timing device configured on your
-  # Asterisk box. MeetMe is Asterisk's built-in conferencing program.
-  # More info: http://www.voip-info.org/wiki-Asterisk+cmd+MeetMe
-  def join conference=nil, hash={}
-    unless conference.kind_of? Numeric
-      raise ArgumentError, "If you want to use named conferences, " +
-                           "specify them in adhearsion.yml" unless CONFIG['conferences']
-      conference = CONFIG['conferences'][conference.to_s]
-    end
-    exec :MeetMe, conference, hash[:options], hash[:pin]
-  end
-  alias meetme join
-
-  # Play is a long-overdue easy way to play audio files in a dialplan with Asterisk. It can take a
-  # single String of the filename (defaults to /var/lib/asterisk/sounds) just as you
-  # would give it to Playback(), or it can take any number of trailed on Strings.
-  # If you pass it an Array, it will traverse the array, playing each of the items
-  # in order. If you're doing this, make your life *incredibly* easier by using the
-  # fantastic Ruby Array literal for Arrays of Strings: %w(). Within this, one
-  # specifies separate, simple Strings by placing whitespace bewtween them. Since 
-  # no Asterisk files contain whitespace, this works _very_ well! Example:
-  #
-  #   play %w(a-connect-charge-of 22 cents-per-minute will-apply)
-  #
-  # Note here that numbers can be play()ed as well. By convention, play() will call
-  # SayNumber() on these indices instead of Playback().
-  def play *files
-    files.flatten!
-    files.each do |f|
-      if f.kind_of? Time
-        exec :SayUnixTime, f.to_i
-      elsif f.kind_of? Symbol then exec :playback, f
-      elsif f[0] == ?$
-        # Speak a currency. TODO: support currencies other than dollars.
-        full,dollars,decimal,cents = *f.match(/^\$(\d+)(\.(\d{1,2}).*)?$/)
-        if full
-          exec :saynumber, dollars
-          exec :playback, (dollars == '1') ? 'dollar' : 'dollars'
-          if decimal
-            exec :playback, 'and'
-            exec :saynumber, cents
-            exec :playback, (cents == '1') ? 'cent' : 'cents'
-          end
-        else exec :playback, f
-        end
-      elsif f.simplify.kind_of? Numeric then exec :saynumber, f
-      else exec :playback, f
-      end
-    end
-  end
-
-  # Compiles the provided Asterisk dialplan pattern into a Ruby regular
-  # expression. For more usage of Asterisk's pattern syntax, see
-  # http://www.voip-info.org/wiki/view/Asterisk+Dialplan+Patterns
-  def _ pattern
-    # Uncomment the following code fragment for complete compatability.
-    # The fragment handles the seldom-used hyphen number spacer with no
-    # meaning.
-  	Regexp.new '^' << pattern.#gsub(/(?!\[[\w+-]+)-(?![\w-]+\])/,'').
-  	  gsub('X', '[0-9]').gsub('Z', '[1-9]').gsub('N','[2-9]').
-  	  gsub('.','.+').gsub('!','.*') << '$'
-  end
-
-  # == Dialplan Instruction Caching
-  #
-  # If a cynic ever says Ruby doesn't make an efficient dial plan manager,
-  # point them to this little method. The cache() method is given a block
-  # of code and will automagically cache whatever's inside it. The caching
-  # mechanism can even be refined by specifying a time-to-live on the cache
-  # and special variables on which the cache depends.
-  #
-  # Here is a sample block of dial plan code that would be cached indefinitely:
-  #
-  #   play_commands {
-  #     cache do
-  #       File.read('commands.txt').each { |sound_file| play sound_file }
-  #     end
-  #   }
-  # 
-  # This example reads commands.txt, an arbitrary file containing sound file names
-  # on each line and plays them. Because the file access and String
-  # manipulation may be resource intensive, the commands sent to Asterisk
-  # will be cached indefinitely (until Adhearsion restarts in this case), but
-  # the file will be read and parsed only once, improving performance significantly.
-  #
-  # == Caching for a Certain Amount of Time
-  #
-  # Often you may want to cache a block of code, but not indefinitely. A
-  # hash key argument can be given to the cache method to have the stored
-  # code expire after a certain duration.
-  # 
-  #   cache :for => 1.hour do
-  #     play weather_report('Dallas, Texas')
-  #   end
-  #
-  # This example uses the weather helper to pull down information from the internet
-  # and process it. While on a small scale calling this method often would only be
-  # inconvenient to the user waiting for the content, having potentially hundreds
-  # of users calling this method would greatly drag the system down. Caching it for
-  # one hour keeps the system snappy and the users happy.
-  #
-  # == Caching Per a Variable
-  #
-  #   cache :per => extension do
-  #     employee = User.find_by_extension extension
-  #     dial extension
-  #   end
-  # 
-  # Another more creative example:
-  #
-  #   cache :per => extension / 100 do
-  #     # This would be useful if you separated your IVR's endpoints into
-  #     # blocks of 100. For example, say every employee had an extension
-  #     # between 100 and 199. In this case, (extension / 100) would
-  #     # return 1. In this way, any numbers between 100 and 199 would have
-  #     # instructions unique to them cached. Say extension 200 through 299
-  #     # dialed in conference. In this case, instructions pertaining only
-  #     # to conferences would be cached (extension/100 == 2).
-  #   end
-  #
-  # But don't do this:
-  #
-  #   cache :per => extension do
-  #     user = User.find_by_extension extension
-  #     speak "Calling #{user.name}"
-  #     im user.jabber, "Incoming call!"
-  #     dial user
-  #   end
-  #
-  # In this case, the instant message will be sent only once until the cache
-  # expires. This is probably not what you wanted. A working (albeit trivially
-  # simplistic) way to do this would be:
-  # 
-  #   user = User.find_by_extension extension
-  #   cache :per => extension do
-  #     speak "Calling #{user.name}"
-  #   end
-  #   im user.jabber, "Incoming call from #{calleridname}!"
-  #   cache :per => extension do
-  #     dial user
-  #   end
-  #
-  # Yet another cool example:
-  #
-  #   cache :per => Time.now.wday, :for => 1.month do
-  #     # Cache your instructions based on the day of the week, refreshing
-  #     # no more than once a month.
-  #   end
-  #
-  # === Caching Per Multiple Variables
-  # 
-  # If you should wish to cache per several variables, simply encapsulate them in an
-  # Array. For example:
-  # 
-  #   cache :per => [extension, callerid], :for => 1.day+2.hours+30.minutes do
-  #     # Do your crazy crap here
-  #   end
-  #
-  # == Notes on Caching
-  #
-  # - All caches are flushed completely when Adhearsion restarts
-  #
-  # - If a phone call ends before a cache block finishes, nothing will be cached (a good thing).
-  #
-  # - Presently, you cannot nest cache blocks. Doing this will produce bizarre results.
-  #
-  # - Common sense should tell you not to cache per constantly changing things.
-  #   For example, if you're receiving calls from all over the country, don't
-  #   cache per everyone's phone number. This will probably result in an
-  #   OutOfMemoryError as everyone's number will have cached instructions. The
-  #   better way to do this would be to cache the blocks that all numbers share,
-  #   then execute content-specific
-  #
-  # - Variables declared inside of the block won't be accessible outside of the block.
-  #   If you don't want this, declare them outside of the block and use them inside.
-  #
-  # - If you're doing non-dialplan related stuff within a cache, it will only be
-  #   performed once. Don't put your logic to count billing time or something
-  #   similar because that varies between each call. Caching only caches what is
-  #   sent to Asterisk, not your Ruby code (of course).
-  #
-  # - If cached code relies on data from a database, it's best to set its expiration
-  #   to something brief (5 or 10 minutes) because database content is *supposed*
-  #   to change, but the demand of pulling the content out may affect scaling. Having
-  #   the data cached for a short amount of time is happy middle ground.
-  def cache hash={}, &block
-    raise ArgumentError, "Must provide a block to cache!" unless block_given?
-    
-    constraint = hash[:per]
-    ttl = hash[:for]
-    
-    # $cache_dir is a Hash of caller()s. The repository from $cache_dir is
-    # another Hash mapping the :per elements to the cached queue (Array) of
-    # rawr() commands.
-    
-    repo = nil
-    $cache_dir.synchronize do |dir|
-      repo = dir[caller]
-      repo = dir[caller] = {} unless repo
-    end
-    
-    # The first element of each queue is a Time to be used for comparison
-    # with Time.now to determine whether the cache is stale.
-    queue = repo[constraint]
-    queue = nil if queue && queue.first && queue.first < Time.now
-    
-    # If a unexpired queue exists, let's ship its commands off to rawr()
-    if queue then queue[1..-1].each { |cmd| rawr cmd }
-    else
-      # Here, several things may have happened. The call to cache 
-      # could have been executed for the first time, there was no cached
-      # queue for a particular constraint, or the cached expiration's
-      # date has been met.
-      
-      # We cache the commands by setting Thread.current[:cache] which rawr()
-      # will fill with commands it gets. yield then executes the block and
-      # we pull out the commands rawr() gave.
-      Thread.current[:cache] = []
-      yield
-      queue = Thread.current[:cache]
-      queue.unshift ttl ? ttl.from_now : nil
-      $cache_dir.synchronize { repo[constraint] = queue }
-      Thread.current[:cache] = nil
-    end
-  end
-  $cache_dir = {}
-
-  # The rawr() method is the main way of receiving a raw response from the Asterisk
-  # server. When no argument is given, it will immediately ask for a response,
-  # returning that String. When an argument +is+ given, it will first send that
-  # command and then return the response that command generated. Everything is
-  # chomp()ed before returned.
-  def rawr(what=nil)
-    if what
-      putc what
-      Thread.current[:cache] << what if Thread.current[:cache]
-    end
-    PBX.io.gets.chomp!
-  rescue
-    log "Call likely ended (socket closed). It's okay if exceptions follow."
-  end
-
-  # Very simply sends the command over the AGI IO socket and forgets about it.
-  def putc(what) PBX.io.print "#{what}" end  
-
-	# Returns the status of the last dial(). Possible dial
-  # statuses include :answer, :busy, :noanswer, :cancel,
-  # :congestion, and :chanunavail. If :cancel is
-	# returned, the caller hung up before the callee picked
-	# up. If :congestion is returned, the dialed extension
-	# probably doesn't exist. If :chanunavail, the callee
-	# phone may not be registered.
-	def last_dial_status
-		get_variable(:DIALSTATUS)[1..-2].downcase.to_sym
-	end
-	
-	# Answer the channel. Adhearsion is configured by default to automatically do this
-	# when a call comes in. This behavior can be specified in adhearsion.yml.
-	def answer() rawr 'ANSWER' end
-	# Hangs up the channel. Adhearsion is configured by default to matically do this
-	# when a context completes execution. This behavior can be specified in adhearsion.yml.
-	def hangup() rawr 'HANGUP' end
-	# Direct translation of the Asterisk NoOp() application. Used primarily for
-	# viewing debug information in the Asterisk CLI.
-	def noop(*options) rawr "NOOP #{options}" end	
-	
-end
-
-# # This Endpoint module is only used when using the
-# # forward-slash operator on the dialplan technology
-# # classes such as IAX, SIP, Zap, Local, SCCP, etc.
-# # The String's eigencalss returned from IAX/:foobar
-# # extends this module.
-# module Endpoint
-#   def /(x) to_s << "/" << x.to_s end
-# end
-# 
-# # Use like IAX/:trunk/12345
-# class IAX
-#   def self./(x) "IAX2/#{x}".extend Endpoint end
-# end
-# # Use like SIP/:trunk/12345
-# class SIP
-#   def self./(x) "SIP/#{x}".extend Endpoint end
-# end
-# # Use like SCCP/:trunk/12345
-# class SCCP
-#   def self./(x) "SCCP/#{x}".extend Endpoint end
-# end
-# # Use like Zap/:channel/12345
-# class Zap
-#   def self./(x) "ZAP/#{x}".extend Endpoint end
-# end
-# # Use like Local/'extension@context'
-# class Local
-#   def self./(x) "Local/#{x}".extend Endpoint end
-# end
-# class GTalk
-#   def self./(x) "gtalk/#{x}".extend Endpoint end
-# end
-# 
-# # Use like IAX2/:trunk/12345
-# class IAX2 < IAX;end
-# # Use like ZAP/:channel/12345
-# class ZAP < Zap;end
-
-# Contributed by Bruce Williams of Five Runs.
-module DialplanTechnologies
-  module Endpoint
-  	def /(x) to_s << "/" << x.to_s end
-  end
-  
-  class Base
-    def self./(x) "#{self}/#{x}".extend(Endpoint) end
-  end
-  
-  class << self
-    def define(&block)
-      instance_eval(&block)
-    end
-    def add(*technologies)
-      options = technologies.last.is_a?(Hash) ? technologies.pop : {}
-      technologies.each do |name|
-        eval %{class ::#{name} < Base; def self.to_s; "#{options[:as] || name}"; end; end}
-      end
-    end
-  end
-  
-end
-
-DialplanTechnologies.define do
-  add :IAX2, :SIP, :SCCP, :ZAP, :Local
-  add :GTalk, :as => :gtalk
-  add :Zap, :as => :ZAP
-  add :IAX, :as => :IAX2
-end
-
-
-# The PBX object is an object manifestation of the PBX with which Adhearsion will be
-# associated. Helpers often open up this class and add methods to it. Note: when doing
-# this in your own helpers, all methods will need to be class (a.k.a. static) methods
-# since no actual instance of this object is passed around.
-class PBX
-  def self.method_missing name
-    raise NameError, "Method #{name} not found! Are you sure manager_proxy is configured properly?"
-  end
-
-  # The magical method that handles how objects passed to dial() are converted to their
-  # corresponding Asterisk-recognizable technology/extension identifier. This likely
-  # wouldn't be used much outside of dial(), but you may find it useful.
-	def self.properize who
-    
-    group_method = who.is_a_group?
-    
-    # If 'who' has any of the possible_methods, replace 'who' with the return value
-    # of that method
-    who = who.send group_method if group_method
-    return nil unless who
-    
-    # In case we can't perform collection algorithms on 'who', let's encapsulate it in
-    # an Array
-    who = [who] unless who.kind_of?(Enumerable) && !who.kind_of?(String)
-    
-    user_method = who.first.is_a_user?
-    # If the first thing in the Enumerable responds to a User-like convention, then 
-    #	set 'who' equal to the extension(s) accessor of those objects. We refine the "who"
-    # argument more and more in this way until it's finally in a way Asterisk can read.
-    who.map! { |p| p.send user_method }.compact! if user_method
-    
-    # Now replace each item in the Enumerable with its form converted to
-    # extension (assuming it's not already in that format)
-    who.map! do |ext|
-      (ext.kind_of?(String) && ext.index(?/)) ? ext : "SIP/#{ext}"
-    end
-    who * '&' # Finally, join() anything left in the Array with an '&'
-	end
-  
-  def self.io() Thread.current[:io] end
-end
-
-# The Contexts class is a blank slate in which the extensions.rb file is evaluated.
-# Its method_missing() simply takes a block and, given the name of attempted method,
-# meta_def()s a new accessor method in Contexts with this name that returns the block
-# given. This is how contexts can be included anywhere in extensions.rb using the
-# easy "+context_name" syntax.
-class Contexts
-  
-  (instance_methods - %w(__send__ __id__ define_method instance_eval)).each do |m|
-    undef_method m
-  end
-  
-  def method_missing name, *args, &block
-    super(name, *args, &block) unless block
-    Thread.current[:container].run_inside do
-      meta_def name do
-        block
-      end
-    end
-  end
-  
-  # This Container object is a container in which each context is executed (not instantiated).
-  # It extends the Asterisk module from adhearsion.rb and thus inherits all of the functionality
-  # declared there. This class can be monkey patched if necessary.
-  class Container
-    include Asterisk
-    def initialize
-      class << self
-        def metaclass; class << self; self; end; end
-        def meta_eval &blk; metaclass.instance_eval(&blk); end
-        def meta_def name, &blk
-          meta_eval { define_method name, &blk }
-        end
-      end
-    end
-    
-    def method_missing name, *args, &block
-      Object::method_missing name, *args, &block
-    end
-    
-    def run_inside &code
-      instance_eval(&code)
-    end
-    
-    def eval_inside code
-      run_inside { eval code }
-    end
-  end
-end
-
-# An Exception thrown when the directory supplied in the constructor of a
-# new RailsApp object is invalid.
-class InvalidRailsDirectory < Exception;end
-
-# When instantiated with an absolute location to a Rails app, the new RailsApp will perform
-# a number of useful observations about the files and directories available, such as loading
-# the database configuration and listing all of the models. All observations are made accessible
-# through attribute accessors. Note: This implementation is experimental.
-class RailsApp                                                                                                                                                                                                                      
-  def initialize path=Dir.pwd                                                                                                                                                                                                       
-    update! path                                                                                                                                                                                                                    
-  end                                                                                                                                                                                                                               
-                                                                                                                                                                                                                                    
-  # Performs the observations on the Rails app once more.                                                                                                                                                                           
-  def update! path                                                                                                                                                                                                                  
-    @path = path                                                                                                                                                                                                                    
-    @database_config_file = File.join @path, 'config', 'database.yml'                                                                                                                                                               
-    if File.readable? @database_config_file                                                                                                                                                                                         
-      @database_config = YAML.load_file @database_config_file                                                                                                                                                                       
-    else raise InvalidRailsDirectory.new("Database config file #{@database_config_file} not found!")                                                                                                                                
-    end                                                                                                                                                                                                                             
-    @models_folder = File.join path, 'app', 'models'                                                                                                                                                                                
-    @models_files  = Dir[ File.join(@models_folder, '*.rb') ]                                                                                                                                                                       
-    @time_updated = Time.now                                                                                                                                                                                                        
-  end                                                                                                                                                                                                                               
-  attr_reader :database_config_file, :database_config, :path, :models_folder, :models_files,                                                                                                                                        
-              :models_names, :time_updated                                                                                                                                                                                          
-end
-
-# This class is the subsystem for anything that may facilitate instant messaging with Adhearsion.
-# If you've seen the im() method used in Adhearsion before, its features can be attributed to
-# the way the InstantMessenger class handles any number of helpers wanting to provide IM
-# functionality.
-#
-# If you're wanting to write your own instant messaging helper, you simply need to create some
-# kind of object that has all of the InstantMessenger::MANDATORY_METHODS. Calling
-# InstantMessenger.use_service(your_instance) and passing this conforming object will keep it
-# referenced internally and potentially used when im() is called. 
-class InstantMessenger
-  
-  # Here is a synopsis of what the MANDATORY_METHODS do:
-  #  * your_username?(screenname) takes a screenname and checks whether its own instance
-  #    uses it.
-  #  * may_be_yours?(screename) takes a screenname account and returns a boolean
-  #    for whether the screen name *could* belong to the instance. For example, in the
-  #    MultiMessenger helper, this argument is checked against a regular expression for
-  #    email addresses because all Jabber accounts use this format.
-  #  * im(sn,msg) is a method all instances ultimately receive to send a message.
-  #    The Hash argument can be :through (for service) and :with (for username)
-  MANDATORY_METHODS = [:your_username?, :may_be_yours?, :im, :your_service?, :connected?]
-  @@messengers ||= []
+# 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"
+
+$: << 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/foundation/all'
+require 'adhearsion/events_support'
+require 'adhearsion/logging'
+require 'adhearsion/component_manager'
+require 'adhearsion/initializer/configuration'
+require 'adhearsion/initializer'
+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'
+
+module Adhearsion
+  # Sets up the Gem require path.
+  AHN_INSTALL_DIR = File.expand_path(File.dirname(__FILE__) + "/..")
+  AHN_CONFIG = Configuration.new
+  
+  ##
+  # This Array holds all the Threads whose life matters. Adhearsion will not exit until all of these have died.
+  #
+  IMPORTANT_THREADS = []
   
-  # If you're writing your own instant messaging system, you would call this method
-  # method on the object that conforms to InstantMessenger::MANDATORY_METHODS. It's
-  # placed in a class Array variable and available to the im() method throughout Adhearsion.
-  def InstantMessenger.use_service instance
-    MANDATORY_METHODS.each do |m|
-      raise ArgumentError, "#{instance} must implement '#{m}'!" unless instance.respond_to? m
-    end
-    @@messengers << instance
-  end
-  
-  cattr_reader :messengers
-  
-  def InstantMessenger.im sn, msg, hash={}
-    if hash[:through] && hash[:with]
-      candidates = @@messengers.select do |c|
-        # Find the service that both matches the service name and the username.
-        c.your_service?(hash[:through]) && c.your_username?(hash[:with]) && c.connected?
-      end
-    elsif hash[:through] || hash[:with]
-      candidates = @@messengers.select(&:connected?)
-      if hash[:through]
-        candidates += @@messengers.select do |c|
-          c.your_service?(hash[:through]) && c.connected?
-        end
-      end
-      if hash[:with]
-        candidates += @@messengers.select do |c|
-          c.your_username?(hash[:with]) && c.connected?
-        end
-      end
-    else
-      candidates = @@messengers.select { |x| x.may_be_yours? sn }
-    end
-    
-    if candidates.size == 1
-      # We've found our match!
-      candidates.first.im sn, msg
-    elsif candidates.empty?
-      # The app creator probably didn't enable their IMing helper
-      raise ArgumentError, "No instant messaging services found! Did you enable your helper?"
-    else
-      raise ArgumentError, "Too ambiguous! " +
-      "Please pass a :with => 'screenname' or :through => :your_service argument to clarify!"
-    end
-  end
 end
-
-# Send a message to anyone, provided a proper instant messaging helper has been installed
-# and configured. Simply pass the screen name and message of the user. If you're using
-# multiple helpers for different services, you may need to pass in Hash-key arguments to
-# clarify.
-#
-# Understood Hash-key arguments include:
-# * :through => The service name (as a symbol or string) for the instant message.
-# * :with => The username with which the account is signed on
-#
-# It is sometimes unnecessary to provide Hash-key arguments when your helper can intelligently
-# distinguish its format from others'. For example, if you have both an AIM IM helper and a
-# GTalk/Jabber/XMPP helper registered, then the latter knows its screen names take the format
-# of email addresses, thus im("Jicksta", "AIM!!!") and im("x@Gmail.com", "GTalk!!!") both
-# work without having to do im("Jicksta", "AIM!!!", :through => :AIM) 
-# or im(x@Gmail.com,"GTalk!!!", :through => :GTalk). If multiple AIM users were logged on, you
-# would *need* to do im("Jicksta","Was gibt's?", :with => "RegisteredUser") where "RegisteredUser"
-# is one of the names you're signed into AIM with. Note: this example doesn't use the :through
-# Hash-key argument because it assumes no other helpers are installed with this same format.
-# If you had a MSN or Yahoo helper installed too, you'd need to do specify :through because
-def im(sn, msg, hash={}) InstantMessenger.im(sn,msg,hash) end