mtrudel-adhearsion 0.8.3

data/lib/adhearsion/voip/call_routing.rb

@@ -0,0 +1,64 @@
+module Adhearsion
+  module VoIP
+    module CallRouting
+      class Rule
+        attr_reader :patterns, :providers, :options
+        
+        def initialize(*args, &block)
+          @options   = args.pop
+          @patterns  = Array(args)
+          @providers = Array(options[:to])
+        end
+      end
+      
+      class RuleSet < Array
+        def [](index)
+          case index
+          when String
+            detect do |rule|
+              rule.patterns.any? do |pattern|
+                index =~ pattern
+              end
+            end
+          else
+            super
+          end
+        end
+      end
+      
+      class Router
+        class << self
+          attr_accessor :rules
+          
+          def define(&block)
+            returning new do |router|
+              router.define(&block)
+              rules.concat router.rules
+            end
+          end
+          
+          def calculate_route_for(end_point)
+            if rule = rules[end_point.to_s]
+              rule.providers
+            end
+          end
+        end
+        
+        self.rules ||= RuleSet.new
+        
+        attr_reader :rules
+        def initialize
+          @rules = []
+        end
+        
+        def define(&block)
+          instance_eval(&block)
+        end
+        
+        def route(*args, &block)
+          rules << Rule.new(*args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/commands.rb

@@ -0,0 +1,9 @@
+module Adhearsion
+  module VoIP
+    module Commands
+      def self.for(platform_name)
+        Adhearsion::VoIP.const_get(platform_name.to_s.classify).const_get("Commands")
+      end
+    end
+  end
+end

data/lib/adhearsion/voip/constants.rb

@@ -0,0 +1,39 @@
+# 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
+
+module Adhearsion
+  module VoIP
+    
+    # Please help adjust these if they may be inaccurate!
+    module Constants
+      US_LOCAL_NUMBER = /^[1-9]\d{6}$/
+      US_NATIONAL_NUMBER = /^1?[1-9]\d{2}[1-9]\d{6}$/
+      ISN = /^\d+\*\d+$/ # See http://freenum.org
+      SIP_URI = /^sip:[\w\._%+-]+@[\w\.-]+\.[a-zA-Z]{2,4}$/
+      
+      # Type of Number definitions given over PRI. Taken from the Q.931-ITU spec, page 68.
+      Q931_TYPE_OF_NUMBER = Hash.new(:unknown).merge 0b001 => :international,
+                                                     0b010 => :national,
+                                                     0b011 => :network_specific,
+                                                     0b100 => :subscriber,
+                                                     0b110 => :abbreviated_number
+    end
+    
+    include Constants
+    
+  end
+end

data/lib/adhearsion/voip/conveniences.rb

@@ -0,0 +1,18 @@
+module Adhearsion
+  module VoIP
+    module Conveniences
+    
+      # 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 compatibility.
+        # 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
+    end
+  end
+end

data/lib/adhearsion/voip/dial_plan.rb

@@ -0,0 +1,218 @@
+# Hardcoding require for now since for some reason it's not being loaded
+require 'adhearsion/voip/dsl/dialplan/control_passing_exception'
+
+module Adhearsion
+  class DialPlan
+    attr_accessor :loader, :entry_points
+    def initialize(loader = Loader)
+      @loader       = loader
+      @entry_points = @loader.load_dialplans.contexts
+    end
+    
+    ##
+    # Lookup and return an entry point by context name
+    #
+    def lookup(context_name)
+      entry_points[context_name]
+    end
+    
+    ##
+    # Executable environment for a dial plan in the scope of a call. This class has all the dialplan methods mixed into it.
+    #
+    class ExecutionEnvironment
+      
+      class << self
+        def create(*args)
+          returning(new(*args)) { |instance| instance.stage! }
+        end
+      end
+      
+      attr_reader :call
+      def initialize(call, entry_point)
+        @call, @entry_point = call, entry_point
+      end
+      
+      ##
+      # Adds the methods to this ExecutionEnvironment which make it useful. e.g. dialplan-related methods, call variables,
+      # and component methods.
+      #
+      def stage!
+        extend_with_voip_commands!
+        extend_with_call_variables!
+        extend_with_dialplan_component_methods!
+      end
+      
+      def run
+        raise "Cannot run ExecutionEnvironment without an entry point!" unless entry_point
+        current_context = entry_point
+        answer if AHN_CONFIG.automatically_answer_incoming_calls
+        begin
+          instance_eval(&current_context)
+        rescue Adhearsion::VoIP::DSL::Dialplan::ControlPassingException => exception
+          current_context = exception.target
+          retry
+        end
+      end
+      
+      protected
+
+      attr_reader :entry_point
+      def extend_with_voip_commands!
+        extend Adhearsion::VoIP::Conveniences
+        extend Adhearsion::VoIP::Commands.for(call.originating_voip_platform)
+      end
+      
+      def extend_with_call_variables!
+        call.define_variable_accessors self
+      end
+      
+      def extend_with_dialplan_component_methods!        
+        Components.component_manager.extend_object_with(self, :dialplan) if Components.component_manager
+      end
+      
+    end
+    
+    class Manager
+      
+      class NoContextError < Exception; end
+      
+      class << self
+        def handle(call)
+          new.handle(call)
+        end
+      end
+      
+      attr_accessor :dial_plan, :context
+      def initialize
+        @dial_plan = DialPlan.new
+      end
+      
+      def handle(call)
+        if call.failed_call?
+          environment = ExecutionEnvironment.create(call, nil)
+          call.extract_failed_reason_from environment
+          raise FailedExtensionCallException.new(environment)
+        end
+        
+        if call.hungup_call?
+          raise HungupExtensionCallException.new(ExecutionEnvironment.new(call, nil))
+        end
+        
+        starting_entry_point = entry_point_for call
+        raise NoContextError, "No dialplan entry point for call context '#{call.context}' -- Ignoring call!" unless starting_entry_point
+        @context = ExecutionEnvironment.create(call, starting_entry_point)
+        inject_context_names_into_environment @context
+        @context.run
+      end
+      
+      # Find the dialplan by the context name from the call or from the 
+      # first path entry in the AGI URL
+      def entry_point_for(call)        
+        if (call.context.is_a? Symbol || !call.context.empty?) && entry_point = dial_plan.lookup(call.context.to_sym)
+          entry_point
+        elsif call.respond_to?(:request) && m = call.request.path.match(%r{/([^/]+)})
+          dial_plan.lookup(m[1].to_sym)
+        end
+      end
+      
+      protected
+      
+      def inject_context_names_into_environment(environment)
+        return unless dial_plan.entry_points
+        dial_plan.entry_points.each do |name, context|
+          environment.meta_def(name) { context }
+        end
+      end
+      
+    end
+    
+    class Loader
+      class << self
+        attr_accessor :default_dial_plan_file_name
+        
+        def load(dial_plan_as_string)
+          string_io = StringIO.new dial_plan_as_string
+          def string_io.path
+            "(eval)"
+          end
+          load_dialplans string_io
+        end
+        
+        def load_dialplans(*files)
+          files = Adhearsion::AHN_CONFIG.files_from_setting("paths", "dialplan") if files.empty?
+          files = Array files
+          files.map! do |file|
+            case file
+              when File, StringIO
+                file
+              when String
+                File.new file
+              else
+                raise ArgumentError, "Unrecognized type of file #{file.inspect}"
+            end
+          end
+          returning new do |loader|
+            files.each do |file|
+              loader.load file
+            end
+          end
+        end
+        
+      end
+      
+      self.default_dial_plan_file_name ||= 'dialplan.rb'
+
+      def initialize
+        @context_collector = ContextNameCollector.new
+      end
+      
+      def contexts
+        @context_collector.contexts
+      end
+      
+      def load(dialplan_file)
+        dialplan_code = dialplan_file.read
+        @context_collector.instance_eval(dialplan_code, dialplan_file.path)
+        nil
+      end
+      
+      class ContextNameCollector# < ::BlankSlate
+        
+        class << self
+
+          def const_missing(name)
+            super
+          rescue ArgumentError
+            raise NameError, %(undefined constant "#{name}")
+          end
+          
+        end
+        
+        attr_reader :contexts
+        def initialize
+          @contexts = {}
+        end
+        
+        def method_missing(name, *args, &block)
+          super if !block_given? || args.any?
+          contexts[name] = DialplanContextProc.new(name, &block)
+        end
+        
+      end
+    end
+    class DialplanContextProc < Proc
+      
+      attr_reader :name
+      
+      def initialize(name, &block)
+        super(&block)
+        @name = name
+      end
+      
+      def +@
+        raise Adhearsion::VoIP::DSL::Dialplan::ControlPassingException.new(self)
+      end
+      
+    end
+  end
+end

data/lib/adhearsion/voip/dsl/dialing_dsl.rb

@@ -0,0 +1,151 @@
+# 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
+
+require 'adhearsion/foundation/metaprogramming'
+require 'adhearsion/voip/conveniences'
+require 'adhearsion/voip/constants'
+require 'adhearsion/voip/dsl/dialing_dsl/dialing_dsl_monkey_patches'
+
+module Adhearsion
+  module VoIP
+    module DSL
+      class DialingDSL
+        
+        extend  Conveniences
+        include Constants
+        
+        Regexp.class_eval do
+          include Adhearsion::VoIP::DSL::DialingDSL::MonkeyPatches::RegexpMonkeyPatch
+        end
+        
+        def self.inherited(klass)
+          klass.class_eval do
+            [:@@providers, :@@routes].each do |var|
+              class_variable_set(var, [])
+              cattr_reader var.to_s.gsub('@@', '')
+            end
+          end
+        end
+        
+        def self.calculate_routes_for(destination)
+          destination = destination.to_s
+          routes.select { |defined_route| defined_route === destination }.map &:providers
+        end
+        
+        class ProviderDefinition < OpenStruct
+          
+          def initialize(name)
+            super()
+            self.name = name.to_s.to_sym
+          end
+          
+          def >>(other)
+            RouteRule.new :providers => [self, other]
+          end
+          
+          def format_number_for_platform(number, platform=:asterisk)
+            case platform
+              when :asterisk
+                [protocol || "SIP", name || "default", number].join '/'
+              else
+                raise "Unsupported platform #{platform}!"
+            end
+          end
+          
+          def format_number_for_platform(number, platform=:asterisk)
+            case platform
+              when :asterisk
+                [protocol || "SIP", name || "default", number].join '/'
+              else
+                raise "Unsupported platform #{platform}!"
+            end
+          end
+          
+          def defined_properties_without_name
+            returning @table.clone do |copy|
+              copy.delete :name
+            end
+          end
+          
+        end
+        
+        protected
+
+        def self.provider(name, &block)
+          raise ArgumentError, "no block given" unless block_given?
+        
+          options = ProviderDefinition.new name
+          yield options
+        
+          providers << options
+          meta_def(name) { options }
+        end
+    
+        def self.route(route)
+          routes << route
+        end
+        
+        class RouteRule
+        
+          attr_reader :patterns, :providers
+
+          def initialize(hash={})
+            @patterns  = Array hash[:patterns]
+            @providers = Array hash[:providers]
+          end
+        
+          def merge!(other)
+            providers.concat other.providers
+            patterns.concat  other.patterns
+            self
+          end
+          
+          def >>(other)
+            case other
+              when RouteRule: merge! other
+              when ProviderDefinition: providers << other
+              else raise RouteException, "Unrecognized object in route definition: #{other.inspect}"
+            end
+            self
+          end
+
+          def |(other)
+            case other
+              when RouteRule: merge! other
+              when Regexp
+                patterns << other
+                self
+              else raise other.inspect
+            end
+          end
+          
+          def ===(other)
+            patterns.each { |pattern| return true if pattern === other }
+            false
+          end
+          
+          def unshift_pattern(pattern)
+            patterns.unshift pattern
+          end
+
+          class RouteException < Exception; end
+
+        end
+      end
+    end
+  end
+end