adhearsion 1.2.6 → 2.0.0.alpha1

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

@@ -1,123 +0,0 @@
-require File.join(File.dirname(__FILE__), 'calculated_match')
-
-module Adhearsion
-  module VoIP
-    class MatchCalculator
-
-      class << self
-
-        def build_with_pattern(pattern, match_payload, &block)
-          class_for_pattern_type(pattern.class.name).new(pattern, match_payload, &block)
-        end
-
-        def inherited(klass)
-          subclasses << klass
-        end
-
-        private
-
-        def class_for_pattern_type(pattern_type)
-          sought_class_name = "Adhearsion::VoIP::#{pattern_type.camelize}MatchCalculator"
-          subclasses.find { |klass| klass.name == sought_class_name }
-        end
-
-        def subclasses
-          @@subclasses ||= []
-        end
-
-      end
-
-      attr_reader :pattern, :match_payload
-      def initialize(pattern, match_payload)
-        @pattern, @match_payload = pattern, match_payload
-      end
-
-      protected
-
-      def new_calculated_match(options)
-        CalculatedMatch.new({:pattern => pattern, :match_payload => match_payload}.merge(options))
-      end
-
-      def coerce_to_numeric(victim)
-        victim.kind_of?(Numeric) ? victim : (victim.to_s =~ /^\d+$/ ? victim.to_s.to_i : nil )
-      end
-    end
-
-    class RangeMatchCalculator < MatchCalculator
-
-      def initialize(pattern, match_payload)
-        raise unless pattern.first.kind_of?(Numeric) && pattern.last.kind_of?(Numeric)
-        super
-      end
-
-      def match(query)
-        numerical_query = coerce_to_numeric query
-        if numerical_query
-          exact_match = pattern.include?(numerical_query) ? query : nil
-          potential_matches = numbers_in_range_like numerical_query
-          potential_matches.reject! { |m| m.to_s == exact_match.to_s } if exact_match
-
-          new_calculated_match :query => query, :exact_matches => exact_match,
-                               :potential_matches => potential_matches
-        else
-          CalculatedMatch.failed_match!(pattern, query, match_payload)
-        end
-      end
-
-      private
-
-      # Returns all numbers in the range (@pattern) that +begin with+ the number given
-      # as the first argument.
-      #
-      # NOTE! If you're having trouble reading what this method is actually doing, it's
-      # effectively a much more efficient version of this:
-      #
-      # pattern.to_a.select { |x| x.to_s.starts_with? num.to_s }.flatten
-      #
-      # Huge thanks to Dave Troy (http://davetroy.blogspot.com) for this awesomely
-      # efficient code!
-      def numbers_in_range_like(num)
-        return (pattern === 0 ? [0] : nil) if num == 0
-        raise ArgumentError unless num.kind_of?(Numeric)
-        Array.new.tap do |matches|
-          first, last = pattern.first, pattern.last
-          power = 0
-          while num < last
-            ones_count = 10**power - 1
-            matches.concat((([num, first].max)..[(num+ones_count), last].min).to_a)
-            num *= 10
-            power += 1
-          end
-        end
-      end
-    end
-
-    class FixnumMatchCalculator < MatchCalculator
-      def match(query)
-        numeric_query = coerce_to_numeric query
-        exact_match, potential_match = nil
-        if pattern == numeric_query
-          exact_match = pattern
-        elsif pattern.to_s.starts_with? query.to_s
-          potential_match = pattern
-        end
-        new_calculated_match :query => query, :exact_matches => exact_match, :potential_matches => potential_match
-      end
-    end
-
-    class StringMatchCalculator < MatchCalculator
-      def match(query)
-        args = { :query => query, :exact_matches => nil,
-                 :potential_matches => nil }
-
-        if pattern == query.to_s
-          args[:exact_matches] = [pattern]
-        elsif pattern.starts_with? query.to_s
-          args[:potential_matches] = [pattern]
-        end
-
-        new_calculated_match args
-      end
-    end
-  end
-end

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

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

data/lib/adhearsion/xmpp/connection.rb

@@ -1,61 +0,0 @@
-module Adhearsion
-  module XMPP
-    module Connection
-
-      mattr_accessor :client
-      class << self
-
-        # Open the XMPP connection
-        #
-        # @param [String] jid the client/component JID to connect to
-        # @param [String] password
-        # @param [String] server
-        # @param [Integer] port
-        def start(jid, password, server, port)
-          Blather.logger = ahn_log.xmpp
-          setup_client_object(jid, password, server, port)
-          register_event_namespaces
-          register_default_client_handlers
-          Events.register_callback(:after_initialized) do
-            connect
-          end
-        end
-
-        # Close the XMPP connection
-        def stop
-          shutdown
-        end
-
-        private
-
-        def setup_client_object(jid, password, server, port)
-          self.client = Blather::Client.setup(jid, password, server, port)
-        end
-
-        def connect
-          EventMachine.run {client.connect}
-        end
-
-        def register_event_namespaces
-          Events.register_namespace_name "/xmpp"
-        end
-
-        def register_default_client_handlers
-          client.register_handler(:ready) do
-            ahn_log.xmpp.info "Connected to XMPP server! Send messages to #{client.jid.stripped}."
-          end
-
-          client.register_handler(:disconnected) do
-            if Adhearsion.status == :running
-              ahn_log.xmpp.warning "XMPP Disconnected. Reconnecting."
-              connect
-            end
-            # TODO: fix this to reconnect XMPP cleanly
-          end
-        end
-
-      end
-
-    end
-  end
-end

data/lib/theatre.rb

@@ -1,147 +0,0 @@
-require 'thread'
-require 'rubygems'
-
-$: << File.expand_path(File.dirname(__FILE__))
-
-require 'theatre/version'
-require 'theatre/namespace_manager'
-require 'theatre/invocation'
-require 'theatre/callback_definition_loader'
-
-module Theatre
-
-  class Theatre
-
-    attr_reader :namespace_manager
-
-    ##
-    # Creates a new stopped Theatre. You must call start!() after you instantiate this for it to begin processing events.
-    #
-    # @param [Fixnum] thread_count Number of Threads to spawn when started.
-    #
-    def initialize(thread_count=6)
-      @thread_count      = thread_count
-      @started           = false
-      @namespace_manager = ActorNamespaceManager.new
-      @thread_group      = ThreadGroup.new
-      @master_queue      = Queue.new
-      @loader_mixins     = []
-    end
-
-    ##
-    # Send a message to this Theatre for asynchronous processing.
-    #
-    # @param [String] namespace The namespace to which the payload should be sent
-    # @param [Object] payload The actual content to be sent to the callback. Optional.
-    # @return [Array<Theatre::Invocation>] An Array of Invocation objects
-    # @raise Theatre::NamespaceNotFound Raised when told to enqueue an unrecognized namespace
-    #
-    def trigger(namespace, payload=:argument_undefined)
-      @namespace_manager.callbacks_for_namespaces(namespace).map do |callback|
-        invocation = if payload.equal?(:argument_undefined)
-          Invocation.new(namespace, callback)
-        else
-          Invocation.new(namespace, callback, payload)
-        end
-        invocation.queued
-        @master_queue << invocation
-        invocation
-      end
-    end
-
-    ##
-    # Send a message to this Theatre for synchronous processing. The execution of this will not go through this Theatre's
-    # Thread pool. If an error occurred in any of callbacks, the Exception object will be placed in the returned Array
-    # instead for you to act upon.
-    #
-    # @param [String] namespace The namespace to which the payload should be sent
-    # @param [Object] payload The actual content to be sent to the callback. Optional.
-    # @return [Array] An Array containing each callback's return value (or Exception raised, if any) when given the payload
-    # @raise Theatre::NamespaceNotFound Raised when told to enqueue an unrecognized namespace
-    #
-    def trigger_immediately(namespace, payload=:argument_undefined)
-      @namespace_manager.callbacks_for_namespaces(namespace).map do |callback|
-        begin
-          invocation = if payload.equal?(:argument_undefined)
-            callback.call
-          else
-            callback.call payload
-          end
-        rescue => captured_error_to_be_returned
-          Adhearsion::Events.trigger '/exception', captured_error_to_be_returned
-          captured_error_to_be_returned
-        end
-      end
-    end
-
-    def load_events_code(code, *args)
-      loader = CallbackDefinitionLoader.new(self, *args)
-      loader.load_events_code code
-    end
-
-    def load_events_file(file, *args)
-      loader = CallbackDefinitionLoader.new(self, *args)
-      loader.load_events_file file
-    end
-
-    def register_namespace_name(*args)
-      @namespace_manager.register_namespace_name(*args)
-    end
-
-    def register_callback_at_namespace(*args)
-      @namespace_manager.register_callback_at_namespace(*args)
-    end
-
-    def register_loader_mixin(mod)
-      @loader_mixins << mod
-    end
-
-    def join
-      @thread_group.list.each do |thread|
-        begin
-          thread.join
-        rescue
-          # Ignore any exceptions
-        end
-      end
-    end
-
-    ##
-    # Starts this Theatre.
-    #
-    # When this method is called, the Threads are spawned and begin pulling messages off this Theatre's master queue.
-    #
-    def start!
-      return false if @thread_group.list.any? # Already started
-      @started_time = Time.now
-      @thread_count.times do
-        @thread_group.add Thread.new(&method(:thread_loop))
-      end
-    end
-
-    ##
-    # Notifies all Threads for this Theatre to stop by sending them special messages. Any messages which were queued and
-    # untriggered when this method is received will still be processed. Note: you may start this Theatre again later once it
-    # has been stopped.
-    #
-    def graceful_stop!
-      @thread_count.times { @master_queue << :THEATRE_SHUTDOWN! }
-      @started_time = nil
-    end
-
-    protected
-
-    def thread_loop
-      loop do
-        begin
-          next_invocation = @master_queue.pop
-          return :stopped if next_invocation.equal? :THEATRE_SHUTDOWN!
-          next_invocation.start
-        rescue StandardError => error
-          Adhearsion::Events.trigger(['exception'], error)
-        end
-      end
-    end
-
-  end
-end

data/lib/theatre/README.markdown

@@ -1,64 +0,0 @@
-Theatre
-=======
-
-Present status: stable
-
-A library for choreographing a dynamic pool of hierarchically organized actors. This was originally extracted from the [Adhearsion](http://adhearsion.com) framework by Jay Phillips.
-
-In the Adhearsion framework, it was necessary to develop an internal message-passing system that could work either synchronously or asynchronously. This is used by the framework itself and for framework extensions (called _components_) to talk with each other. The source of the events is completely undefined -- events could originate from within the framework out outside the framework. For example, a Message Queue such as [Stomp](http://stomp.codehaus.org) can wire incoming events into Theatre and catch events going to a particular destination so it can proxy them out to the server.
-
-Motivations and Design Decisions
---------------------------------
-
-* Must maintain Ruby 1.8 and JRuby compatibility
-* Must be Thread-safe
-* Must provide some level of transparency into the events going through it
-* Must be dynamic enough to reallocate the number of triggerrs based on load
-* Must help facilitate test-driven development of Actor functionality
-* Must allow external persistence in case of a crash
-
-Example
--------
-
-Below is an example taken from Adhearsion for executing framework-level callbacks. Note: the framework treats this callback synchronously.
-
-    events.framework.asterisk.before_call.each do |event|
-      # Pull headers from event and respond to it here.
-    end
-
-Below is an example of integration with [Stomp](http://stomp.codehaus.org/), a simple yet robust open-protocol message queue.
-
-    events.stomp.new_call.each do |event|
-      # Handle all events from the Stomp MQ server whose name is "new_call" (the String)
-    end
-
-This will filter all events whose name is "new_call" and yield the Stomp::Message to the block.
-
-Framework terminology
---------------------
-
-Below are definitions of terms I use in Theatre. See the respective links for more information.
-
-* **callback**: This is the block given to the `each` method which triggers events coming in.
-* **payload**: This is the "message" sent to the Theatre and is what will ultimately be yielded to the callback
-* **[Actor](http://en.wikipedia.org/wiki/Actor_model)**: This refers to concurrent responders to events in a concurrent system.
-
-Synchronous vs. Asynchronous
-----------------------------
-
-With Theatre, all events are asynchronous with the optional ability to synchronously block until the event is scheduled, triggered, and has returned. If you wish to synchronously trigger the event, simple call `wait` on an `Invocation` object returned from `trigger` and then check the `Invocation#current_state` property for `:success` or `:error`. Optionally the `Invocation#success?` and `Invocation#error?` methods also provide more intuitive access to the finished state. If the event finished with `:success`, you may retrieve the returned value of the event Proc by calling `Invocation#returned_value`. If the event finished with `:error`, you may get the Exception with `Invocation#error`.
-
-Because many callbacks can be registered for a particular namespace, each needing its own Invocation object, the `Theatre#trigger` method returns an Array of Invocation objects.
-
-    # We'll assume only one callback is registered and call #first on the Array of Invocations returned by #trigger
-    invocation = my_theatre.trigger("your/namespace/here", YourSpecialClass.new("this can be anything")).first
-    invocation.wait
-    raise invocation.error if invocation.error?
-    log "Actor finished with return value #{invocation.returned_value}"
-
-Ruby 1.8 vs. Ruby 1.9 vs. JRuby
--------------------------------
-
-Theatre was created for Ruby 1.8 because no good Actor system existed on Ruby 1.8 that met Adhearsion's needs (e.g. hierarchal with synchronous and asynchronous modes. If you wish to achieve real processor-level concurrency, use JRuby.
-
-Presently Ruby 1.9 compatibility is not a priority but patches for compatibility will be accepted, as long as they preserve compatibility with both MRI and JRuby.