sant0sk1-adhearsion 0.7.999

data/app_generators/ahn/templates/components/simon_game/test/test_simon_game.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + "/test_helper"
+
+class TestSimonGame < Test::Unit::TestCase
+  attr_reader :game
+  def setup
+    @game = SimonGame.new
+    @game.call_context = mock_call_context
+  end
+  
+  def test_game_executes_say_digits_when_asked_to_say_number
+    flexmock(game).should_receive(:random_number).and_return("2")
+    mock_call_context.should_receive(:say_digits).once.with('2')
+    @game.say_number
+  end
+  
+  
+  # Didn't get very far on this
+  def xtest_can_play_one_round_and_receive_the_players_score
+    flexmock(game).should_receive(:random_number).and_return("2")
+    assert_equal(3, 'x')
+  end
+  
+    private
+    def mock_call_context
+      @mock_call_context ||= flexmock("Mock Call Context")
+    end
+    
+    def stub_random_number
+      
+    end
+end

data/app_generators/ahn/templates/config/startup.rb

@@ -0,0 +1,53 @@
+unless defined? Adhearsion
+  if File.exists? File.dirname(__FILE__) + "/../adhearsion/lib/adhearsion.rb"
+    # If you wish to freeze a copy of Adhearsion to this app, simply place a copy of Adhearsion
+    # into a folder named "adhearsion" within this app's main directory.
+    require File.dirname(__FILE__) + "/../adhearsion/lib/adhearsion.rb"
+  else  
+    require 'rubygems'
+    gem 'adhearsion', '>= 0.7.999'
+    require 'adhearsion'
+  end
+end
+
+Adhearsion::Configuration.configure do |config|
+  
+  # Supported levels (in increasing severity) -- :debug < :info < :warn < :error < :fatal
+  config.logging :level => :info
+  
+  # Whether incoming calls be automatically answered. Defaults to true.
+  # config.automatically_answer_incoming_calls = false
+  
+  # Whether the other end hanging up should end the call immediately. Defaults to true.
+  # config.end_call_on_hangup = false
+  
+  # Whether to end the call immediately if an unrescued exception is caught. Defaults to true.
+  # config.end_call_on_error = false
+  
+  # By default Asterisk is enabled with the default settings
+  config.enable_asterisk
+  # config.asterisk.enable_ami :host => "127.0.0.1", :username => "admin", :password => "password"
+  
+  # To change the host IP or port on which the AGI server listens, use this:
+  # config.enable_asterisk :listening_port => 4574, :listening_host => "127.0.0.1"
+  
+  # config.enable_drb 
+  
+  # Streamlined Rails integration! The first argument should be a relative or absolute path to 
+  # the Rails app folder with which you're integrating. The second argument must be one of the 
+  # the following: :development, :production, or :test.
+  
+  # config.enable_rails :path => 'gui', :env => :development
+  
+  # Note: You CANNOT do enable_rails and enable_database at the same time. When you enable Rails,
+  # it will automatically connect to same database Rails does and load the Rails app's models.
+  
+  # Configure a database to use ActiveRecord-backed models. See ActiveRecord::Base.establish_connection
+  # for the appropriate settings here.
+  # config.enable_database :adapter  => 'mysql',
+  #                        :username => 'joe', 
+  #                        :password => 'secret',
+  #                        :host     => 'db.example.org'
+end
+
+Adhearsion::Initializer.start_from_init_file(__FILE__, File.dirname(__FILE__) + "/..")

data/app_generators/ahn/templates/dialplan.rb

@@ -0,0 +1,4 @@
+adhearsion {
+  simon = new_simon_game
+  simon.start
+}

data/bin/ahn

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+# This is the main executable file.
+
+# 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
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'adhearsion'
+require 'adhearsion/cli'
+
+Adhearsion::CLI::AhnCommand.execute!

data/bin/ahnctl

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# 
+#  ahnctl - Adhearsion daemon controller
+#
+# 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
+
+USAGE = "Usage: ahnctl start|stop|restart /path/to/adhearsion/app [--pid-file=/path/to/pid_file.pid]" 
+
+# Blow up if the CLI arguments are invalid
+abort USAGE unless (2..3).include?(ARGV.size) && %w[start stop restart].include?(ARGV.first)
+
+# By default, ahnctl will use the version of Adhearsion it was installed with.
+
+pid_file    = ARGV.pop if ARGV.size == 3
+ahn_command = File.expand_path File.dirname(__FILE__) + "/ahn"
+app_dir     = File.expand_path ARGV.last
+
+pid_file_path_regexp = /^--pid-file=(.+)$/
+abort USAGE if pid_file && pid_file !~ pid_file_path_regexp
+
+# If pid_file is not nil, let's extract the path specified.
+pid_file &&= File.expand_path pid_file[pid_file_path_regexp,1]
+
+# If there was no third argument and pid_file is still nil, let's use the default.
+pid_file ||= app_dir + '/adhearsion.pid'
+
+abort "Directory is not an Adhearsion application!" unless File.exists?(app_dir + "/.ahnrc")
+
+def terminate(pid) `kill -s TERM #{pid} 2> /dev/null` end
+def      kill(pid) `kill -s KILL #{pid} 2> /dev/null` end
+
+# Even if we're starting Adhearsion, we need to make sure to clean up after any stale
+# pid files. In effect, start is the same as restart.
+puts "Stopping Adhearsion app at #{app_dir}" if %w[stop restart].include? ARGV.first
+
+if File.exists?(pid_file)
+  # An Adhearsion process may still be running. Let's kill the other one as cleanly as possible
+  pid = File.read(pid_file).to_i
+  
+  # Time to spend waiting for Adhearsion to exit
+  waiting_timeout = Time.now + 15
+  
+  terminate pid
+  sleep 0.25 until `ps -p #{pid} | sed -e '1d'`.strip.empty? || Time.now > waiting_timeout
+  kill pid
+  
+  `rm -f #{pid_file}`
+end
+
+if ['start', 'restart'].include? ARGV.first
+  puts "Starting Adhearsion app at #{app_dir}"
+  `#{ahn_command} start daemon #{app_dir} --pid-file=#{pid_file}`
+end

data/bin/jahn

@@ -0,0 +1,32 @@
+#!/usr/bin/env jruby
+
+# This "jahn" script is "ahn" for JRUBY!
+
+# 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
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + "/../lib")
+
+require 'rubygems'
+require 'adhearsion'
+require 'adhearsion/cli'
+
+# jahn will soon have JRuby-specific behavior such as creating a compiled .jar
+# file from an app.
+# require 'adhearsion/jruby'
+
+Adhearsion::CLI::AhnCommand.execute!

data/lib/adhearsion.rb

@@ -0,0 +1,32 @@
+# Check the Ruby version
+STDERR.puts "WARNING: You are running Adhearsion in an unsupported
+version of Ruby (Ruby #{RUBY_VERSION} #{RUBY_RELEASE_DATE})!
+Please upgrade to at least Ruby v1.8.5." if RUBY_VERSION < "1.8.5"
+
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'adhearsion/version'
+require 'adhearsion/voip/call'
+require 'adhearsion/voip/dial_plan'
+require 'adhearsion/voip/asterisk/special_dial_plan_managers'
+require 'adhearsion/core_extensions/all'
+require 'adhearsion/blank_slate'
+require 'adhearsion/hooks'
+# require 'adhearsion/events_support'
+require 'adhearsion/logging'
+require 'adhearsion/initializer/configuration'
+require 'adhearsion/initializer'
+require 'adhearsion/voip/dsl/numerical_string'
+require 'adhearsion/voip/dsl/dialplan/parser'
+require 'adhearsion/voip/commands'
+require 'adhearsion/voip/asterisk/commands'
+require 'adhearsion/voip/dsl/dialing_dsl'
+require 'adhearsion/voip/call_routing'
+
+module Adhearsion
+  # Sets up the Gem require path.
+  AHN_INSTALL_DIR = File.expand_path(File.dirname(__FILE__) + "/..")
+  CONFIG = {}
+  AHN_CONFIG = Configuration.new
+end

data/lib/adhearsion/blank_slate.rb

@@ -0,0 +1,5 @@
+class BlankSlate
+  instance_methods.each do |method| 
+    undef_method method unless method =~ /^__/ || method == 'instance_eval'
+  end
+end

data/lib/adhearsion/cli.rb

@@ -0,0 +1,106 @@
+require 'fileutils'
+
+module Adhearsion
+  module CLI
+    module AhnCommand
+      USAGE = <<USAGE
+Usage:
+   ahn create /path/to/directory
+   ahn start [daemon] [directory]
+   ahn version|-v|--v|-version|--version
+   ahn help|-h|--h|--help|-help
+
+Under development:
+   ahn create:projectname /path/to/directory
+USAGE
+    
+      def self.execute!
+        CommandHandler.send(*parse_arguments)
+      end
+      
+      def self.parse_arguments(args=ARGV.clone)
+        action = args.shift
+        case action
+          when /^-?-?h(elp)?$/, nil   then [:help]
+          when /^-?-?v(ersion)?$/     then [:version]
+          when /^create(:([\w_.]+))?$/
+            [:create, args.shift, $LAST_PAREN_MATCH || :default]
+          when 'start'
+            pid_file_regexp = /^--pid-file=(.+)$/
+            if args.size > 3
+              raise CommandHandler::UnknownCommand, "Too many arguments supplied!" if args.size > 3
+            elsif args.size == 3
+              raise CommandHandler::UnknownCommand, "Unrecognized final argument #{args.last}" unless args.last =~ pid_file_regexp
+              pid_file = args.pop[pid_file_regexp, 1]
+            else
+              pid_file = nil
+            end
+            
+            if args.first == 'daemon' && args.size == 2
+              path   = args.last
+              daemon = true
+            elsif args.size == 1
+              path, daemon = args.first, false
+            else
+              raise CommandHandler::UnknownCommand, "Invalid format for the start CLI command!"
+            end
+            [:start, path, daemon, pid_file]
+          when '-'
+            [:start, Dir.pwd]
+          else
+            [action, *args]
+        end
+      end
+      
+      module CommandHandler
+        class << self
+          def create(path, project=:default)
+            raise UnknownProject.new(project) if project != :default # TODO: Support other projects
+            require 'rubigen'
+            require 'rubigen/scripts/generate'
+            source = RubiGen::PathSource.new(:application, 
+              File.join(File.dirname(__FILE__), "../../app_generators"))
+            RubiGen::Base.reset_sources
+            RubiGen::Base.append_sources source
+            RubiGen::Scripts::Generate.new.run([path], :generator => 'ahn')
+          end
+        
+          def start(path, daemon=false, pid_file=nil)
+            raise PathInvalid, path unless File.exists? path + "/.ahnrc"
+            Adhearsion::Initializer.start path, :daemon => daemon, :pid_file => pid_file
+          end
+        
+          def version
+            puts "Adhearsion v#{Adhearsion::VERSION::STRING}"
+          end
+        
+          def help
+            puts USAGE
+          end
+        
+          def method_missing(action, *args)
+            raise UnknownCommand, [action, *args] * " "
+          end
+        end
+        
+        class UnknownCommand < Exception
+          def initialize(cmd)
+            super "Unknown command: #{cmd}\n#{USAGE}"
+          end
+        end
+        
+        class UnknownProject < Exception
+          def initialize(project)
+            super "Application #{project} does not exist! Have you installed it?"
+          end
+        end
+        
+        class PathInvalid < Exception
+          def initialize(path)
+            super "Directory #{path} does not contain an Adhearsion project!"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/component_manager.rb

@@ -0,0 +1,277 @@
+module Adhearsion
+
+  module Components
+    class Manager
+      attr_reader :active_components, :host_information, :started_components, :components_with_call_context
+      def initialize
+        @active_components            = {}
+        @started_components           = []
+        @components_with_call_context = {}
+      end
+
+      def [](component_name)
+        active_components[component_name].component_class.instance
+      end
+    
+      def component(component_name)
+        active_components[component_name]
+      end
+    
+      def has_component?(component_name)
+        active_components.has_key?(component_name)
+      end
+      
+      def component_gems
+        @repository ||= RubygemsRepository.new
+        @repository.adhearsion_gems
+      end
+    
+      def load
+        return unless File.exist?(AHN_ROOT.component_path)
+        component_directories = Dir.glob(File.join(AHN_ROOT.component_path, "*"))
+        component_directories.each do |component_directory|
+          component_name = File.basename(component_directory).to_sym
+          @active_components[component_name] = Component.new(self, component_name, component_directory)
+        end
+      end
+    
+      def start
+        @active_components.keys.each do |name|
+          @active_components[name].start
+        end
+      end
+
+      def stop
+        @started_components.reverse.each do |name|
+          @active_components[name].stop
+        end
+      end
+
+      class RubygemsRepository
+        def initialize
+          require 'rubygems'
+          Gem.manage_gems
+        end
+
+        def adhearsion_gems
+          gems = {}
+          Gem.source_index.each {|name, spec| gems[spec.name] = spec.full_gem_path if spec.requirements.include?("adhearsion")}
+          gems
+        end
+      end
+    end
+    
+    ClassToGetCallContext = Struct.new(:component_class, :instance_variable)
+    class ClassToGetCallContext
+      def instantiate_with_call_context(call_context, *args, &block)
+        component = component_class.allocate
+        component.instance_variable_set(("@"+instance_variable.to_s).to_sym, call_context)
+        component.send(:initialize, *args, &block)
+        component
+      end
+    end
+    
+    
+    #component behavior is shared across components
+    module Behavior
+      def self.included(component_class)
+        component_class.extend(ClassMethods)
+      end
+      
+      def component_name
+        Component.name
+      end
+
+      def component_description
+        Configuration.description || Component.name
+      end
+      
+      module ClassMethods
+        def add_call_context(params = {:as => :call_context})
+          attr_reader params[:as]
+          ComponentManager.components_with_call_context[name] = ClassToGetCallContext.new(self, params[:as])
+        end
+      end
+    end
+    
+    class Component
+      class << self
+        def prepare_component_class(component_module, name)
+          component_class_name = name.to_s.camelize
+          component_module.module_eval(<<-EVAL, __FILE__, __LINE__)
+            class #{component_class_name}
+              def self.name
+                '#{component_class_name}'
+              end
+              include Adhearsion::Components::Behavior
+            end
+          EVAL
+        end
+      end
+        
+      attr_reader :manager, :name, :path, :component_module, :component_class
+      def initialize(manager, name, path)
+        @manager = manager
+        @name    = name
+        @path    = path
+        unless File.exist?(main_file_name)
+          gem_path = @manager.component_gems[@name.to_s]
+          raise "The component '#{@name}' does not have the main file: #{main_file_name}" unless gem_path
+          @path = gem_path
+        end
+        @started = false
+      end
+      
+      def start
+        return if @started
+        manager.started_components << @name
+        @started = true
+        @component_module = ComponentModule.new(self) do |component_module|
+          Component.prepare_component_class(component_module, @name)
+          component_module.load_configuration_file
+        end
+        @component_module.require(File.join("lib", @name.to_s))
+      end
+      
+      def configuration
+        @component_module.const_get(:Configuration)
+      end
+      
+      def stop
+        #@component_class.unload if @component_class && @component_class.respond_to?(:unload)
+      end
+      
+      def configuration_file
+         File.join(path, configuration_file_name)
+      end
+      
+      private
+      
+        def main_file_name
+          File.join(@path, "lib", @name.to_s+".rb")
+        end
+      
+        def configuration_file_name
+          "configuration.rb"
+        end
+    end
+
+    class ComponentModule < Module
+      # The file with which the Script was instantiated.
+      attr_reader :main_file
+
+      # The directory in which main_file is located, and relative to which
+      # #load searches for files before falling back to Kernel#load.
+      attr_reader :dir
+
+      # A hash that maps <tt>filename=>true</tt> for each file that has been
+      # required locally by the script. This has the same semantics as <tt>$"</tt>,
+      # alias <tt>$LOADED_FEATURES</tt>, except that it is local to this script.
+      attr_reader :loaded_features
+
+      class << self
+        alias load new
+      end
+
+      # Creates new Script, and loads _main_file_ in the scope of the Script. If a
+      # block is given, the script is passed to it before loading from the file, and
+      # constants can be defined as inputs to the script.
+      attr_reader :component
+      def initialize(component)   # :yields: self
+        extend ComponentModuleMethods
+        @component       = component        
+        @loaded_features = {}
+
+        const_set :Component, component
+        const_set :Configuration, OpenStruct.new(:description => nil)
+
+        yield self if block_given?
+      end
+      
+      def load_configuration_file
+        load_in_module(component.configuration_file)
+      end
+
+      # Loads _file_ into this Script. Searches relative to the local dir, that is,
+      # the dir of the file given in the original call to
+      # <tt>Script.load(file)</tt>, loads the file, if found, into this Script's
+      # scope, and returns true. If the file is not found, falls back to
+      # <tt>Kernel.load</tt>, which searches on <tt>$LOAD_PATH</tt>, loads the file,
+      # if found, into global scope, and returns true. Otherwise, raises
+      # <tt>LoadError</tt>.
+      #
+      # The _wrap_ argument is passed to <tt>Kernel.load</tt> in the fallback case,
+      # when the file is not found locally.
+      #
+      # Typically called from within the main file to load additional sub files, or
+      # from those sub files.
+
+      def load(file, wrap = false)
+        load_in_module(File.join(component.path, file))
+        true
+      rescue MissingFile
+        super
+      end
+
+      # Analogous to <tt>Kernel#require</tt>. First tries the local dir, then falls
+      # back to <tt>Kernel#require</tt>. Will load a given _feature_ only once.
+      #
+      # Note that extensions (*.so, *.dll) can be required in the global scope, as
+      # usual, but not in the local scope. (This is not much of a limitation in
+      # practice--you wouldn't want to load an extension more than once.) This
+      # implementation falls back to <tt>Kernel#require</tt> when the argument is an
+      # extension or is not found locally.
+
+      def require(feature)
+        unless @loaded_features[feature]
+          @loaded_features[feature] = true
+          file = feature
+          file += ".rb" unless /\.rb$/ =~ file
+          load_in_module(File.join(component.path, file))
+        end
+      rescue MissingFile
+        @loaded_features[feature] = false
+        super
+      end
+
+      # Raised by #load_in_module, caught by #load and #require.
+      class MissingFile < LoadError; end
+
+      # Loads _file_ in this module's context. Note that <tt>\_\_FILE\_\_</tt> and
+      # <tt>\_\_LINE\_\_</tt> work correctly in _file_.
+      # Called by #load and #require; not normally called directly.
+
+      def load_in_module(file)
+        module_eval(File.read(file), File.expand_path(file))
+      rescue Errno::ENOENT => e
+        if /#{file}$/ =~ e.message
+          raise MissingFile, e.message
+        else
+          raise
+        end
+      end
+
+      def to_s
+        "#<#{self.class}:#{File.basename(component.path)}>"
+      end
+
+      module ComponentModuleMethods
+        # This is so that <tt>def meth...</tt> behaves like in Ruby's top-level
+        # context. The implementation simply calls
+        # <tt>Module#module_function(name)</tt>.
+        def method_added(name) # :nodoc:
+          module_function(name)
+        end
+
+        def start_component_after(*others)
+          others.each do |component_name|
+            component.manager.active_components[component_name].start
+          end
+        end
+
+      end
+    end
+  end
+  
+  ComponentManager = Components::Manager.new unless defined? ComponentManager
+end