adhearsion 1.2.6 → 2.0.0.alpha1

data/lib/adhearsion/initializer/logging.rb

@@ -0,0 +1,33 @@
+require 'logging'
+
+module Adhearsion
+  class Initializer
+    class Logging
+      class << self
+
+        def start(_appenders = nil, level = :info, formatter = nil)
+          ::Logging.init Adhearsion::Logging::LOG_LEVELS
+
+          ::Logging.logger.root.appenders = _appenders.nil? ? appenders : _appenders
+
+          ::Logging.logger.root.level = level
+
+          ::Logging.logger.root.appenders.each do |appender|
+            appender.layout = formatter
+          end unless formatter.nil?
+        end
+
+        # default appenders
+        def appenders
+          @appenders ||= [::Logging.appenders.stdout(
+                            'stdout',
+                            :layout => ::Logging.layouts.pattern(
+                              :pattern => Adhearsion::Logging.adhearsion_pattern,
+                              :color_scheme => 'bright'
+                            )
+                          )]
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/logging.rb

@@ -1,12 +1,29 @@
-require 'log4r'
+require 'logging'
 
 module Adhearsion
   module Logging
 
-    @@logging_level_lock = Mutex.new
+    LOG_LEVELS = %w(TRACE DEBUG INFO WARN ERROR FATAL)
+
+    METHOD = :logger
 
     class << self
 
+      ::Logging.color_scheme 'bright',
+        :levels => {
+          :info  => :green,
+          :warn  => :yellow,
+          :error => :red,
+          :fatal => [:white, :on_red]
+        },
+        :date     => :blue,
+        :logger   => :cyan,
+        :message  => :magenta
+
+      def adhearsion_pattern
+        '[%d] %-5l %c: %m\n'
+      end
+
       def silence!
         self.logging_level = :fatal
       end
@@ -15,96 +32,75 @@ module Adhearsion
         self.logging_level = :info
       end
 
-      def logging_level=(new_logging_level)
-        new_logging_level = Log4r.const_get(new_logging_level.to_s.upcase)
-        @@logging_level_lock.synchronize do
-          @@logging_level = new_logging_level
-          Log4r::Logger.each_logger do |logger|
-            logger.level = new_logging_level
-          end
-        end
+      def reset
+        ::Logging.reset
       end
-      alias :level= :logging_level=
 
-      def logging_level(level = nil)
-        return self.logging_level= level unless level.nil?
-        @@logging_level_lock.synchronize do
-          return @@logging_level ||= Log4r::INFO
+      def start
+        ::Logging.init LOG_LEVELS
+        ::Logging::Logger[:root].level = :info
+        ::Logging.logger.root.appenders = [::Logging.appenders.stdout('stdout')]
+        self.send :_set_formatter, ::Logging::Layouts.basic(:format_as => :string, :backtrace => true)
+
+        LOG_LEVELS.each do |level|
+          Adhearsion::Logging.const_defined?(level) or Adhearsion::Logging.const_set(level, ::Logging::LEVELS[::Logging.levelify(level)])
         end
       end
-      alias :level :logging_level
-    end
 
-    class AdhearsionLogger < Log4r::Logger
+      def logging_level=(new_logging_level)
+        ::Logging::Logger[:root].level = new_logging_level
+      end
 
-      @@outputters = [Log4r::Outputter.stdout]
+      alias :level= :logging_level=
 
-      class << self
-        def sanitized_logger_name(name)
-          name.to_s.gsub(/\W/, '').downcase
-        end
+      def logging_level
+        ::Logging::Logger[:root].level
+      end
 
-        def outputters
-          @@outputters
-        end
+      def get_logger(logger_name)
+        ::Logging::Logger[logger_name]
+      end
 
-        def outputters=(other)
-          @@outputters = other
-        end
+      alias :level :logging_level
 
-        def formatters
-          @@outputters.map &:formatter
-        end
+      def sanitized_logger_name(name)
+        name.to_s.gsub(/\W/, '').downcase
+      end
 
-        def formatters=(other)
-          other.each_with_index do |formatter, i|
-            outputter = @@outputters[i]
-            outputter.formatter = formatter if outputter
-          end
-        end
+      def outputters=(outputters)
+        ::Logging.logger.root.appenders = outputters
       end
 
-      def initialize(*args)
-        super
-        redefine_outputters
+      alias :appenders= :outputters=
+
+      def outputters
+        ::Logging.logger.root.appenders
       end
 
-      def redefine_outputters
-        self.outputters = @@outputters
+      alias :appenders :outputters
+
+      def formatter=(formatter)
+        _set_formatter(formatter)
       end
 
-      def method_missing(logger_name, *args, &block)
-        define_logging_method logger_name, self.class.new(logger_name.to_s)
-        send self.class.sanitized_logger_name(logger_name), *args, &block
+      alias :layout= :formatter=
+
+      def formatter
+        ::Logging.logger.root.appenders.first.layout
       end
 
+      alias :layout :formatter
+
       private
 
-      def define_logging_method(name, logger)
-        # Can't use Module#define_method() because blocks in Ruby 1.8.x can't
-        # have their own block arguments.
-        self.class.class_eval(<<-CODE, __FILE__, __LINE__)
-          def #{self.class.sanitized_logger_name name}(*args, &block)
-            logger = Log4r::Logger['#{name}']
-            if args.any? || block_given?
-              logger.info(*args, &block)
-            else
-              logger
-            end
-          end
-        CODE
+      def _set_formatter(formatter)
+        ::Logging.logger.root.appenders.each do |appender|
+          appender.layout = formatter
+        end
       end
-    end
-
-    DefaultAdhearsionLogger = AdhearsionLogger.new 'ahn'
 
-  end
-end
+    end
 
-def ahn_log(*args)
-  if args.any?
-    Adhearsion::Logging::DefaultAdhearsionLogger.info(*args)
-  else
-    Adhearsion::Logging::DefaultAdhearsionLogger
+    start unless ::Logging.const_defined? :MAX_LEVEL_LENGTH
   end
 end

data/lib/adhearsion/menu_dsl.rb

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

data/lib/adhearsion/menu_dsl/calculated_match.rb

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

data/lib/adhearsion/menu_dsl/calculated_match_collection.rb

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

data/lib/adhearsion/menu_dsl/fixnum_match_calculator.rb

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

data/lib/adhearsion/menu_dsl/match_calculator.rb

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

data/lib/adhearsion/{voip/menu_state_machine/menu_class.rb → menu_dsl/menu.rb}

@@ -1,22 +1,20 @@
-require 'adhearsion/voip/menu_state_machine/menu_builder'
 module Adhearsion
-  module VoIP
+  module MenuDSL
+
     class Menu
 
       DEFAULT_MAX_NUMBER_OF_TRIES = 1
-      DEFAULT_TIMEOUT             = 5 # seconds
-
-      relationships :menu_builder => MenuBuilder
+      DEFAULT_TIMEOUT             = 5
 
       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
+      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              = MenuDSL::MenuBuilder.new
 
-        @builder = menu_builder.new
-        yield @builder
+        @builder.build &block
 
         initialize_digit_buffer
       end
@@ -38,17 +36,16 @@ module Adhearsion
       end
 
       def continue
-        raise MenuGetAnotherDigitOrTimeout if digit_buffer_empty?
+        return get_another_digit_or_timeout! 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
+            menu_result_found! first_exact_match, digit_buffer_string
           else
-            get_another_digit_or_finish!(first_exact_match.match_payload, first_exact_match.query)
+            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!
@@ -67,56 +64,59 @@ module Adhearsion
       end
 
       def execute_invalid_hook
-        builder.execute_hook_for(:invalid, digit_buffer_string)
+        builder.execute_hook_for :invalid, digit_buffer_string
       end
 
       def execute_timeout_hook
-        builder.execute_hook_for(:premature_timeout, digit_buffer_string)
+        builder.execute_hook_for :timeout, digit_buffer_string
       end
 
       def execute_failure_hook
-        builder.execute_hook_for(:failure, digit_buffer_string)
+        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
+      # digit buffer, digit_buffer_empty, and digit_buffer_string methods
       def initialize_digit_buffer
         @digit_buffer = ClearableStringBuffer.new
       end
 
       def invalid!
-        raise MenuResultInvalid
+        MenuResultInvalid.new
       end
 
-      def menu_result_found!(match_payload, new_extension)
-        raise MenuResultFound.new(match_payload, new_extension)
+      def menu_result_found!(match_object, new_extension)
+        MenuResultFound.new(match_object, new_extension)
       end
 
       def get_another_digit_or_finish!(match_payload, new_extension)
-        raise MenuGetAnotherDigitOrFinish.new(match_payload, new_extension)
+        MenuGetAnotherDigitOrFinish.new(match_payload, new_extension)
       end
 
       def get_another_digit_or_timeout!
-        raise MenuGetAnotherDigitOrTimeout
+        MenuGetAnotherDigitOrTimeout.new
       end
 
       # The superclass from which all message-like exceptions descend. It should never
       # be instantiated directly.
-      class MenuResult < StandardError; end
+      MenuResult      = Class.new
+      MenuResultDone  = Class.new MenuResult
 
-      # Raised when the user's input matches
       class MenuResultFound < MenuResult
-        attr_reader :match_payload, :new_extension
-        def initialize(match_payload, new_extension)
+
+        attr_reader :match_object, :new_extension
+
+        def initialize(match_object, new_extension)
           super()
-          @match_payload  = match_payload
+          @match_object = match_object
           @new_extension = new_extension
         end
-      end
 
-      module MenuGetAnotherDigit; end
+      end #class MenuResultFound < MenuResult
+
+      MenuGetAnotherDigit = Module.new
 
       class MenuGetAnotherDigitOrFinish < MenuResultFound
         include MenuGetAnotherDigit
@@ -126,13 +126,10 @@ module Adhearsion
         include MenuGetAnotherDigit
       end
 
-      class MenuResultFound < MenuResult; end
-
-      # Raised when the user's input matches no patterns
-      class MenuResultInvalid < MenuResult; end
+      MenuResultInvalid = Class.new MenuResult
 
-      # 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).
+      # For our default purpose, we need the digit_buffer to behave much like a normal String except that it should
+      # handle its own resetting (clearing)
       class ClearableStringBuffer < String
         def clear!
           replace ""
@@ -141,9 +138,10 @@ module Adhearsion
         def <<(other)
           super other.to_s
         end
-
       end
 
-    end
+
+    end # class Menu
+
   end
-end
+end