sant0sk1-adhearsion 0.7.999

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,207 @@
+# Hardcoding require for now since for some reason it's not being loaded
+require 'adhearsion/blank_slate'
+require 'adhearsion/component_manager'
+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_dial_plan.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
+      
+      attr_reader :call
+      def initialize(call, entry_point=nil)
+        @call, @entry_point = call, entry_point
+        extend_with_voip_commands!
+        extend_with_call_variables!
+        extend_with_components_with_call_context!
+      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
+      
+      private
+        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_components_with_call_context!
+          ComponentManager.components_with_call_context.keys.each do |component_name|
+            eval <<-COMPONENT_BUILDER
+              def self.new_#{component_name.underscore}(*args, &block)
+                ComponentManager.components_with_call_context['#{component_name}'].instantiate_with_call_context(self, *args, &block)
+              end
+            COMPONENT_BUILDER
+          end
+        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.new(call)
+          call.extract_failed_reason_from(environment)
+          raise FailedExtensionCallException.new(environment)
+        end
+        
+        if call.hungup_call?
+          raise HungupExtensionCallException.new(ExecutionEnvironment.new(call))
+        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.new(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 entry_point = dial_plan.lookup(call.context.to_sym)
+          entry_point
+        elsif 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)
+          returning new do |loader|
+            inject_dial_plan_component_classes_into dial_plan_as_string
+            loader.load(dial_plan_as_string)
+          end
+        end
+        
+        def load_dial_plan(file_name = default_dial_plan_file_name)
+          load read_dialplan_file(AHN_ROOT.dial_plan_named(file_name))
+        end
+        
+        private
+          def inject_dial_plan_component_classes_into(dial_plan_as_string)
+            dial_plan_as_string[0, 0] = ComponentManager.components_with_call_context.keys.map do |component| 
+              "#{component} = ::Adhearsion::ComponentManager.components_with_call_context['#{component}'] unless defined? #{component}\n"
+            end.join
+          end
+          
+          def read_dialplan_file(filename)
+            File.read filename
+          end
+          
+      end
+      
+      self.default_dial_plan_file_name ||= 'dialplan.rb'
+
+      attr_reader :contexts
+      def initialize
+        @contexts = {}
+      end
+      
+      def load(dial_plan_as_string)
+        contexts.update(ContextNameCollector.build(dial_plan_as_string))
+      end
+      
+      class ContextNameCollector# < ::BlankSlate
+        
+        class << self
+          
+          def build(dial_plan_as_string)
+            builder = new
+            builder.instance_eval(dial_plan_as_string)
+            builder.contexts
+          end
+          
+          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/core_extensions/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