adhearsion 1.2.6 → 2.0.0.alpha1

data/lib/adhearsion/component_manager.rb

@@ -1,278 +0,0 @@
-module Adhearsion
-  module Components
-
-    mattr_accessor :component_manager
-
-    class ConfigurationError < Exception; end
-
-    class ComponentManager
-
-      class << self
-
-        def scopes_valid?(*scopes)
-          unrecognized_scopes = (scopes.flatten - SCOPE_NAMES).map(&:inspect)
-          raise ArgumentError, "Unrecognized scopes #{unrecognized_scopes.to_sentence}" if unrecognized_scopes.any?
-          true
-        end
-
-      end
-
-      SCOPE_NAMES = [:dialplan, :events, :generators, :rpc, :global]
-
-      attr_reader :scopes, :lazy_config_loader
-      def initialize(path_to_container_directory)
-        @path_to_container_directory = path_to_container_directory
-        @scopes = SCOPE_NAMES.inject({}) do |scopes, name|
-          scopes[name] = Module.new
-          scopes
-        end
-        @lazy_config_loader = LazyConfigLoader.new(self)
-      end
-
-      ##
-      # Includes the anonymous Module created for the :global scope in Object, making its methods globally accessible.
-      #
-      def globalize_global_scope!
-        Object.send :include, @scopes[:global]
-      end
-
-      def load_components
-        components = Dir.glob(File.join(@path_to_container_directory + "/*")).select do |path|
-          File.directory?(path)
-        end
-        components.map! { |path| File.basename path }
-        components.each do |component|
-          next if component == "disabled"
-          component_file = File.join(@path_to_container_directory, component, 'lib', component + ".rb")
-          if File.exists? component_file
-            load_file component_file
-            next
-          end
-
-          # Try the old-style components/<component>/<component>.rb
-          component_file = File.join(@path_to_container_directory, component, component + ".rb")
-          if File.exists? component_file
-            load_file component_file
-          else
-            ahn_log.warn "Component directory does not contain a matching .rb file! Was expecting #{component_file.inspect}"
-          end
-        end
-
-        # Load configured system- or gem-provided components
-        AHN_CONFIG.components_to_load.each do |component|
-          require component
-        end
-
-      end
-
-      ##
-      # Loads the configuration file for a given component name.
-      #
-      # @return [Hash] The loaded YAML for the given component name. An empty Hash if no YAML file exists.
-      #
-      def configuration_for_component_named(component_name)
-        # Look for configuration in #{AHN_ROOT}/config/components first
-        # Look for configuration in #{AHN_ROOT}/components/#{component_name}/config next
-        # Next try the local app component directory
-        %W{
-          #{AHN_ROOT}/config/components/#{component_name}.yml
-          #{AHN_ROOT}/components/#{component_name}/config/#{component_name}.yml
-          #{File.join @path_to_container_directory, component_name, "#{component_name}.yml"}
-        }.each do |filename|
-          return YAML.load_file filename if File.exists?(filename)
-        end
-
-        # Nothing found? Return an empty hash
-        ahn_log.warn "No configuration found for requested component #{component_name}"
-        {}
-      end
-
-      def extend_object_with(object, *scopes)
-        raise ArgumentError, "Must supply at least one scope!" if scopes.empty?
-
-        self.class.scopes_valid? scopes
-
-        scopes.each do |scope|
-          methods = @scopes[scope]
-          if object.kind_of?(Module)
-            object.send :include, methods
-          else
-            object.extend methods
-          end
-        end
-        object
-      end
-
-      def load_code(code)
-        load_container ComponentDefinitionContainer.load_code(code)
-      end
-
-      def load_file(filename)
-        load_container ComponentDefinitionContainer.load_file(filename)
-      end
-
-      def require(filename)
-        load_container ComponentDefinitionContainer.require(filename)
-      end
-
-      protected
-
-      def load_container(container)
-        container.constants.each do |constant_name|
-          constant_value = container.const_get(constant_name)
-          Object.const_set(constant_name, constant_value)
-        end
-        metadata = container.metaclass.send(:instance_variable_get, :@metadata)
-        metadata[:initialization_block].call if metadata[:initialization_block]
-
-        self.class.scopes_valid? metadata[:scopes].keys
-
-        metadata[:scopes].each_pair do |scope, method_definition_blocks|
-          method_definition_blocks.each do |method_definition_block|
-            @scopes[scope].module_eval(&method_definition_block)
-          end
-        end
-        container
-      rescue StandardError => e
-        # Non-fatal errors
-        Events.trigger(['exception'], e)
-      rescue Exception => e
-        # Fatal errors.  Log them and keep passing them upward
-        Events.trigger(['exception'], e)
-        raise e
-      end
-
-      class ComponentDefinitionContainer < Module
-
-        class << self
-          def load_code(code)
-            new.tap do |instance|
-              instance.module_eval code
-            end
-          end
-
-          def load_file(filename)
-            new.tap do |instance|
-              instance.module_eval File.read(filename), filename
-            end
-          end
-
-          def require(filename)
-            filename = filename + ".rb" if !(filename =~ /\.rb$/)
-            begin
-              # Try loading the exact filename first
-              load_file(filename)
-            rescue LoadError, Errno::ENOENT
-            end
-
-            # Next try Rubygems
-            filepath = get_gem_path_for(filename)
-            return load_file(filepath) if !filepath.nil?
-
-            # Finally try the system search path
-            filepath = get_system_path_for(filename)
-            return load_file(filepath) if !filepath.nil?
-
-            # Raise a LoadError exception if the file is still not found
-            raise LoadError, "File not found: #{filename}"
-          end
-
-        end
-
-        def initialize(&block)
-          # Hide our instance variables in the singleton class
-          metadata = {}
-          metaclass.send(:instance_variable_set, :@metadata, metadata)
-
-          metadata[:scopes] = ComponentManager::SCOPE_NAMES.inject({}) do |scopes, name|
-            scopes[name] = []
-            scopes
-          end
-
-          super
-
-          meta_def(:initialize) { raise "This object has already been instantiated. Are you sure you didn't mean initialization()?" }
-        end
-
-        def methods_for(*scopes, &block)
-          raise ArgumentError if scopes.empty?
-
-          ComponentManager.scopes_valid? scopes
-
-          metadata = metaclass.send(:instance_variable_get, :@metadata)
-          scopes.each { |scope| metadata[:scopes][scope] << block }
-        end
-
-        def initialization(&block)
-          # Raise an exception if the initialization block has already been set
-          metadata = metaclass.send(:instance_variable_get, :@metadata)
-          if metadata[:initialization_block]
-            raise "You should only have one initialization() block!"
-          else
-            metadata[:initialization_block] = block
-          end
-        end
-        alias initialisation initialization
-
-        protected
-
-        class << self
-          def self.method_added(method_name)
-            @methods ||= []
-            @methods << method_name
-          end
-
-          def get_gem_path_for(filename)
-            # Look for component files provided by rubygems
-            spec = Gem.searcher.find(filename)
-            return nil if spec.nil?
-            File.join(spec.full_gem_path, spec.require_path, filename)
-          rescue NameError
-            # In case Rubygems are not available
-            nil
-          end
-
-          def get_system_path_for(filename)
-            $:.each do |path|
-              filepath = File.join(path, filename)
-              return filepath if File.exists?(filepath)
-            end
-
-            # Not found? Return nil
-            return nil
-          end
-        end
-
-      end
-
-      class ComponentMethodDefinitionContainer < Module
-        class << self
-          def method_added(method_name)
-            @methods ||= []
-            @methods << method_name
-          end
-        end
-
-        attr_reader :scopes
-        def initialize(*scopes, &block)
-          @scopes = []
-          super(&block)
-        end
-
-      end
-
-      class LazyConfigLoader
-        def initialize(component_manager)
-          @component_manager = component_manager
-        end
-
-        def method_missing(component_name)
-          config = @component_manager.configuration_for_component_named(component_name.to_s)
-          (class << self; self; end).send(:define_method, component_name) { config }
-          config
-        end
-      end
-
-    end
-  end
-end

data/lib/adhearsion/component_manager/component_tester.rb

@@ -1,54 +0,0 @@
-module ComponentTester
-
-  class << self
-
-    ##
-    #
-    #
-    # @return [Module] an anonymous module which includes the ComponentTester module.
-    #
-    def new(component_name, component_directory, main_file = nil)
-      component_directory = File.expand_path component_directory
-      main_file ||= "/#{component_name}/#{component_name}.rb"
-      main_file.insert 0, component_directory
-
-      component_manager = Adhearsion::Components::ComponentManager.new(component_directory)
-      component_module  = Adhearsion::Components::ComponentManager::ComponentDefinitionContainer.load_file main_file
-
-      Module.new do
-
-        extend ComponentTester
-
-        (class << self; self; end).send(:define_method, :component_manager)   { component_manager   }
-        (class << self; self; end).send(:define_method, :component_name)      { component_name      }
-        (class << self; self; end).send(:define_method, :component_module)    { component_module    }
-        (class << self; self; end).send(:define_method, :component_directory) { component_directory }
-
-
-        define_method(:component_manager)   { component_manager   }
-        define_method(:component_name)      { component_name      }
-        define_method(:component_module)    { component_module    }
-        define_method(:component_directory) { component_directory }
-
-        def self.const_missing(name)
-          component_module.const_get name
-        end
-
-      end
-    end
-  end
-
-  def helper_method(name)
-    Object.new.extend(component_module).method(name)
-  end
-
-  def config
-    component_manager.configuration_for_component_named component_name
-  end
-
-  def initialize!
-    metadata = component_module.metaclass.send(:instance_variable_get, :@metadata)
-    metadata[:initialization_block].call if metadata && metadata[:initialization_block].kind_of?(Proc)
-  end
-
-end

data/lib/adhearsion/component_manager/spec_framework.rb

@@ -1,18 +0,0 @@
-require 'adhearsion/component_manager/component_tester'
-begin
-  require 'rspec'
-rescue LoadError
-  abort "You do not have the 'rspec' gem installed! You must install it to continue.\n\nsudo gem install rspec\n\n"
-end
-
-module ComponentConfigurationSpecHelper
-  def mock_component_config_with(new_config)
-    Object.send(:remove_const, :COMPONENTS) rescue nil
-    Object.send(:const_set, :COMPONENTS, OpenStruct.new(new_config))
-  end
-end
-
-RSpec.configure do |config|
-  config.mock_with :rspec
-  config.include ComponentConfigurationSpecHelper
-end

data/lib/adhearsion/events_support.rb

@@ -1,65 +0,0 @@
-require 'theatre'
-
-module Adhearsion
-  module Events
-
-    DEFAULT_FRAMEWORK_EVENT_NAMESPACES = %w[
-      /after_initialized
-      /shutdown
-      /exception
-      /asterisk/manager_interface
-      /asterisk/before_call
-      /asterisk/after_call
-      /asterisk/hungup_call
-      /asterisk/failed_call
-    ]
-
-    class << self
-
-      def framework_theatre
-        defined?(@@framework_theatre) ? @@framework_theatre : reinitialize_theatre!
-      end
-
-      def trigger(*args)
-        framework_theatre.trigger(*args)
-      end
-
-      def trigger_immediately(*args)
-        framework_theatre.trigger_immediately(*args)
-      end
-
-      def reinitialize_theatre!
-        @@framework_theatre.gracefully_stop! if defined? @@framework_theatre
-      rescue
-        # Recover and reinitalize
-      ensure
-        # TODO: Extract number of threads to use from AHN_CONFIG
-        @@framework_theatre = Theatre::Theatre.new
-        DEFAULT_FRAMEWORK_EVENT_NAMESPACES.each do |namespace|
-          register_namespace_name namespace
-        end
-        return @@framework_theatre
-      end
-
-      def register_namespace_name(name)
-        framework_theatre.register_namespace_name name
-      end
-
-      def stop!
-        Events.trigger :shutdown
-        framework_theatre.graceful_stop!
-        framework_theatre.join
-      end
-
-      def register_callback(namespace, block_arg=nil, &method_block)
-        raise ArgumentError, "Cannot supply two blocks!" if block_arg && block_given?
-        block = method_block || block_arg
-        raise ArgumentError, "Must supply a callback!" unless block
-
-        framework_theatre.register_callback_at_namespace(namespace, block)
-      end
-
-    end
-
-  end
-end

data/lib/adhearsion/foundation/blank_slate.rb

@@ -1,3 +0,0 @@
-class BlankSlate
-  (instance_methods.map{|m| m.to_sym} - [:instance_eval, :object_id]).each { |m| undef_method m unless m.to_s =~ /^__/ }
-end

data/lib/adhearsion/foundation/event_socket.rb

@@ -1,205 +0,0 @@
-##
-# EventSocket is a small abstraction of TCPSocket which causes it to behave much like an EventMachine Connection object for
-# the sake of better testability. The EventMachine Connection paradigm (as well as other networking libraries such as the
-# Objective-C HTTP library) uses callbacks to signal different stages of a socket's lifecycle.
-#
-# A handler can be registered in one of two ways: through registrations on an object yielded by the constructor or
-# pre-defined on the object given as a constructor parameter. Below is an example definition which uses the block way:
-#
-#   EventSocket.new do |handler|
-#     def handler.receive_data(data)
-#       # Do something here
-#     end
-#     def handler.disconnected
-#       # Do something here
-#     end
-#     def handler.connected
-#       # Do something here
-#     end
-#   end
-#
-# Note: this is also a valid way of defining block callbacks:
-#
-#   EventSocket.new do |handler|
-#     handler.receive_data { |data| do_something }
-#     handler.disconnected { do_something }
-#     handler.connected    { do_something }
-#   end
-#
-# and here is an example of using a handler object:
-#
-#   class MyCallbackHandler
-#     def receive_data(data) end
-#     def connected() end
-#     def disconnected() end
-#   end
-#   EventSocket.new(MyCallbackHandler.new)
-#
-# If you wish to ask the EventSocket what state it is in, you can call the Thread-safe EventSocket#state method. The
-# supported states are:
-#
-#  - :new
-#  - :connected
-#  - :stopped
-#  - :connection_dropped
-#
-# Note: the EventSocket's state will be changed before these callbacks are executed. For example, if your "connected"
-# callback queried its own EventSocket for its state, it will have already transitioned to the connected() state.
-#
-# Warning: If an exception occurs in your EventSocket callbacks, they will be "eaten" and never bubbled up the call stack.
-# You should always wrap your callbacks in a begin/rescue clause and handle exceptions explicitly.
-#
-require "thread"
-require "socket"
-
-class EventSocket
-
-  class << self
-
-    ##
-    # Creates and returns a connected EventSocket instance.
-    #
-    def connect(*args, &block)
-      instance = new(*args, &block)
-      instance.connect!
-      instance
-    end
-  end
-
-  MAX_CHUNK_SIZE = 256 * 1024
-
-  def initialize(host, port, handler=nil, &block)
-    raise ArgumentError, "Cannot supply both a handler object and a block" if handler && block_given?
-    raise ArgumentError, "Must supply either a handler object or a block" if !handler && !block_given?
-
-    @state_lock = Mutex.new
-    @host  = host
-    @port  = port
-
-    @state = :new
-    @handler = handler || new_handler_from_block(&block)
-  end
-
-  def state
-    @state_lock.synchronize { @state }
-  end
-
-  def connect!
-    @state_lock.synchronize do
-      if @state.equal? :connected
-        raise ConnectionError, "Already connected!"
-      else
-        @socket = TCPSocket.new(@host, @port)
-        @state  = :connected
-      end
-    end
-    @handler.connected rescue nil
-    @reader_thread = spawn_reader_thread
-    self
-  rescue => error
-    @state = :failed
-    raise error
-  end
-
-  ##
-  # Thread-safe implementation of write.
-  #
-  # @param [String] data Data to write
-  #
-  def send_data(data)
-    # Note: TCPSocket#write is intrinsically Thread-safe
-    @socket.write data
-  rescue
-    connection_dropped!
-  end
-    ##
-  # Disconnects this EventSocket and sets the state to :stopped
-  #
-  def disconnect!
-    @state_lock.synchronize do
-      @socket.close rescue nil
-      @state = :stopped
-    end
-  end
-
-  ##
-  # Joins the Thread which reads data off the socket.
-  #
-  def join
-    @state_lock.synchronize do
-      if @state.equal? :connected
-        @reader_thread.join
-      else
-        nil
-      end
-    end
-  end
-
-  def receive_data(data)
-    @handler.receive_data(data)
-  end
-
-  protected
-
-  def connection_dropped!
-    @state_lock.synchronize do
-      unless @state.equal? :connection_dropped
-        @socket.close rescue nil
-        @state = :connection_dropped
-        @handler.disconnected
-      end
-    end
-  end
-
-  def spawn_reader_thread
-    Thread.new(&method(:reader_loop))
-  end
-
-  def reader_loop
-    until state.equal? :stopped
-      data = @socket.readpartial(MAX_CHUNK_SIZE)
-      @handler.receive_data data
-    end
-  rescue EOFError
-    connection_dropped!
-  end
-
-  def new_handler_from_block(&handler_block)
-    handler = Object.new
-    handler.metaclass.send :attr_accessor, :set_callbacks
-    handler.metaclass.send :public, :set_callbacks, :set_callbacks=
-    handler.set_callbacks = {:receive_data => false, :disconnected => false, :connected => false }
-
-    def handler.receive_data(&block)
-      self.metaclass.send(:remove_method, :receive_data)
-      self.metaclass.send(:define_method, :receive_data) { |data| block.call data }
-      set_callbacks[:receive_data] = true
-    end
-    def handler.connected(&block)
-      self.metaclass.send(:remove_method, :connected)
-      self.metaclass.send(:define_method, :connected) { block.call }
-      set_callbacks[:connected] = true
-    end
-    def handler.disconnected(&block)
-      self.metaclass.send(:remove_method, :disconnected)
-      self.metaclass.send(:define_method, :disconnected) { block.call }
-      set_callbacks[:disconnected] = true
-    end
-
-    def handler.singleton_method_added(name)
-      set_callbacks[name.to_sym] = true
-    end
-
-    yield handler
-
-    handler.set_callbacks.each_pair do |callback_name,was_set|
-      handler.send(callback_name) {} unless was_set
-    end
-
-    handler
-
-  end
-
-  class ConnectionError < StandardError; end
-
-end