adhearsion 1.2.6 → 2.0.0.alpha1

data/lib/theatre/callback_definition_loader.rb

@@ -1,86 +0,0 @@
-module Theatre
-
-  ##
-  # This class provides the a wrapper aroung which an events.rb file can be instance_eval'd.
-  #
-  class CallbackDefinitionLoader
-
-    attr_reader :theatre, :root_name
-    def initialize(theatre, root_name=:events)
-      @theatre   = theatre
-      @root_name = root_name
-
-      create_recorder_method root_name
-    end
-
-    def anonymous_recorder
-      BlankSlateMessageRecorder.new(&method(:callback_registered))
-    end
-
-    ##
-    # Parses the given Ruby source code file and returns this object.
-    #
-    # @param [String, File] file The filename or File object for the Ruby source code file to parse.
-    #
-    def load_events_file(file)
-      file = File.open(file) if file.kind_of? String
-      instance_eval file.read, file.path
-      self
-    ensure
-      file.close
-    end
-
-    ##
-    # Parses the given Ruby source code and returns this object.
-    #
-    # NOTE: Only use this if you're generating the code yourself! If you're loading a file from the filesystem, you should
-    # use load_events_file() since load_events_file() will properly attribute errors in the code to the file from which the
-    # code was loaded.
-    #
-    # @param [String] code The Ruby source code to parse
-    #
-    def load_events_code(code)
-      instance_eval code
-      self
-    end
-
-    protected
-
-    ##
-    # Immediately register the namespace and callback with the Theatre instance given to the constructor. This method is only
-    # called when a new BlankSlateMessageRecorder is instantiated and receives #each().
-    #
-    def callback_registered(namespaces, callback)
-      # Get rid of all arguments passed to the namespaces. Will support arguments in the future.
-      namespaces = namespaces.map { |namespace| namespace.first }
-
-      theatre.namespace_manager.register_callback_at_namespace namespaces, callback
-    end
-
-    def create_recorder_method(record_method_name)
-      (class << self; self; end).send(:alias_method, record_method_name, :anonymous_recorder)
-    end
-
-    class BlankSlateMessageRecorder
-
-      (instance_methods.map{|m| m.to_sym} - [:instance_eval, :object_id]).each { |method| undef_method method unless method.to_s =~ /^__/ }
-
-      def initialize(&notify_on_completion)
-        @notify_on_completion = notify_on_completion
-        @namespaces = []
-      end
-
-      def method_missing(*method_name_and_args)
-        raise ArgumentError, "Supplying a block is not supported" if block_given?
-        @namespaces << method_name_and_args
-        self
-      end
-
-      def each(&callback)
-        @notify_on_completion.call(@namespaces, callback)
-      end
-
-    end
-
-  end
-end

data/lib/theatre/guid.rb

@@ -1,23 +0,0 @@
-# Right now Adhearsion also defines this method. The eventual solution will be to extract the Adhearsion features on which
-# Theatre depends and make that a dependent library.
-
-unless respond_to? :new_guid
-
-  def random_character
-    case random_digit = rand(62)
-      when  0...10 then random_digit.to_s
-      when 10...36 then (random_digit + 55).chr
-      when 36...62 then (random_digit + 61).chr
-    end
-  end
-
-  def random_string(length_of_string=8)
-    Array.new(length_of_string) { random_character }.join
-  end
-
-  # This GUID implementation doesn't adhere to the RFC which wants to make certain segments based on the MAC address of a
-  # network interface card and other wackiness. It's sufficiently random for our needs.
-  def new_guid
-    [8,4,4,4,12].map { |segment_length| random_string(segment_length) }.join('-')
-  end
-end

data/lib/theatre/invocation.rb

@@ -1,131 +0,0 @@
-require 'theatre/guid'
-require 'thread'
-require 'monitor'
-
-module Theatre
-
-  ##
-  # An Invocation is an object which Theatre generates and returns from Theatre#trigger.
-  #
-  class Invocation
-
-    attr_reader :queued_time, :started_time, :finished_time, :unique_id, :callback, :namespace, :error, :returned_value
-
-    class InvalidStateError < StandardError; end
-
-    ##
-    # Create a new Invocation.
-    #
-    # @param [String] namespace The "/foo/bar/qaz" path to the namespace to which this Invocation belongs.
-    # @param [Proc] callback The block which should be executed by an Actor scheduler.
-    # @param [Object] payload The message that will be sent to the callback for processing.
-    #
-    def initialize(namespace, callback, payload=:theatre_no_payload)
-      raise ArgumentError, "Callback must be a Proc" unless callback.kind_of? Proc
-      @namespace     = namespace
-      @callback      = callback
-      @payload       = payload
-      @unique_id     = new_guid.freeze
-      @current_state = :new
-      @state_lock    = Mutex.new
-
-      # Used just to protect access to the @returned_value instance variable
-      @returned_value_lock = Monitor.new
-
-      # Used when wait() is called to notify all waiting threads by using a ConditionVariable
-      @returned_value_blocker = @returned_value_lock.new_cond#Monitor::ConditionVariable.new @returned_value_lock
-    end
-
-    def queued
-      with_state_lock do
-        raise InvalidStateError unless @current_state == :new
-        @current_state = :queued
-        @queued_time = Time.now.freeze
-      end
-      true
-    end
-
-    def current_state
-      with_state_lock { @current_state }
-    end
-
-    def start
-      with_state_lock do
-        raise InvalidStateError unless @current_state == :queued
-        @current_state = :running
-      end
-      @started_time = Time.now.freeze
-
-      begin
-        self.returned_value = if @payload.equal? :theatre_no_payload
-          @callback.call
-        else
-          @callback.call @payload
-        end
-        with_state_lock { @current_state = :success }
-      rescue => e
-        if Array(@namespace).first =~ /exception/
-          # Exception encountered in exception handler.  Do not perpetuate the loop.
-          ahn_log.error "Exception encountered in exception handler!"
-          ahn_log.error e.message
-          ahn_log.error e.backtrace.join("\n")
-        else
-          Adhearsion::Events.trigger('/exception', e)
-        end
-        @error = e
-        with_state_lock { @current_state = :error }
-      ensure
-        @finished_time = Time.now.freeze
-      end
-    end
-
-    def execution_duration
-      return nil unless @finished_time
-      @finished_time - @started_time
-    end
-
-    def error?
-      current_state.equal? :error
-    end
-
-    def success?
-      current_state.equal? :success
-    end
-
-    ##
-    # When this Invocation has been queued, started, and entered either the :success or :error state, this method will
-    # finally return. Until then, it blocks the Thread.
-    #
-    # @return [Object] The result of invoking this Invocation's callback
-    #
-    def wait
-      with_returned_value_lock { return @returned_value if defined? @returned_value }
-      @returned_value_blocker.wait
-      # Return the returned_value
-      with_returned_value_lock { @returned_value }
-    end
-
-    protected
-
-    ##
-    # Protected setter which does some other housework when the returned value is found (such as notifying wait()ers)
-    #
-    # @param [returned_value] The value to set this returned value to.
-    #
-    def returned_value=(returned_value)
-      with_returned_value_lock do
-        @returned_value = returned_value
-        @returned_value_blocker.broadcast
-      end
-    end
-
-    def with_returned_value_lock(&block)
-      @returned_value_lock.synchronize(&block)
-    end
-
-    def with_state_lock(&block)
-      @state_lock.synchronize(&block)
-    end
-
-  end
-end

data/lib/theatre/namespace_manager.rb

@@ -1,153 +0,0 @@
-module Theatre
-
-  ##
-  # Manages the hierarchial namespaces of a Theatre. This class is Thread-safe.
-  #
-  class ActorNamespaceManager
-
-    VALID_NAMESPACE = %r{^(/[\w_]+)+$}
-
-    class << self
-      def valid_namespace_path?(namespace_path)
-        namespace_path =~ VALID_NAMESPACE
-      end
-
-      ##
-      # Since there are a couple ways to represent namespaces, this is a helper method which will normalize
-      # them into the most practical: an Array of Symbols
-      # @param [String, Array] paths The namespace to register. Can be in "/foo/bar" or *[foo,bar] format
-      def normalize_path_to_array(paths)
-        paths = paths.is_a?(Array) ? paths.flatten : Array(paths)
-        paths.map! { |path_segment| path_segment.kind_of?(String) ? path_segment.split('/') : path_segment }
-        paths.flatten!
-        paths.reject! { |path| path.nil? || (path.kind_of?(String) && path.empty?) }
-        paths.map { |path| path.to_sym }
-      end
-
-    end
-
-    def initialize
-      @registry_lock = Mutex.new
-      @root          = RootNamespaceNode.new
-    end
-
-    ##
-    # Have this registry recognize a new path and prepare it for callback registrations. All path segements will be created
-    # in order. For example, when registering "/foo/bar/qaz" when no namespaces at all have been registered, this method will
-    # first register "foo", then "bar", then "qaz". If the namespace was already registered, it will not be affected.
-    #
-    # @param [String, Array] paths The namespace to register. Can be in "/foo/bar" or *[foo,bar] format
-    # @return [NamespaceNode] The NamespaceNode representing the path given.
-    # @raise NamespaceNotFound if a segment has not been registered yet
-    #
-    def register_namespace_name(*paths)
-      paths = self.class.normalize_path_to_array paths
-
-      paths.inject(@root) do |node, name|
-        node.register_namespace_name name
-      end
-    end
-
-    ##
-    # Returns a Proc found after searching with the namespace you provide
-    #
-    # @raise NamespaceNotFound if a segment has not been registered yet
-    #
-    def callbacks_for_namespaces(*paths)
-      search_for_namespace(paths).callbacks
-    end
-
-    ##
-    # Find a namespace in the tree.
-    #
-    # @param [Array, String] paths Must be an Array of segments or a name like "/foo/bar/qaz"
-    # @raise NamespaceNotFound if a segment has not been registered yet
-    #
-    def search_for_namespace(paths)
-      paths = self.class.normalize_path_to_array paths
-      path_string = "/"
-
-      found_namespace = paths.inject(@root) do |last_node,this_node_name|
-        raise NamespaceNotFound.new(path_string) if last_node.nil?
-        path_string << this_node_name.to_s
-        last_node.child_named this_node_name
-      end
-      raise NamespaceNotFound.new("/#{paths.join('/')}") unless found_namespace
-      found_namespace
-    end
-
-    ##
-    # Registers the given callback at a namespace, assuming the namespace was already registered.
-    #
-    # @param [Array] paths Must be an Array of segments
-    # @param [Proc] callback
-    # @raise NamespaceNotFound if a segment has not been registered yet
-    #
-    def register_callback_at_namespace(paths, callback)
-      raise ArgumentError, "callback must be a Proc" unless callback.kind_of? Proc
-      search_for_namespace(paths).register_callback callback
-    end
-
-    protected
-
-    ##
-    # Used by NamespaceManager to build a tree of namespaces. Has a Hash of children which is not
-    # Thread-safe. For Thread-safety, all access should semaphore through the NamespaceManager.
-    class NamespaceNode
-
-      attr_reader :name
-      def initialize(name)
-        @name = name.freeze
-        @children  = {}
-        @callbacks = []
-      end
-
-      def register_namespace_name(name)
-        @children[name] ||= NamespaceNode.new(name)
-      end
-
-      def register_callback(callback)
-        @callbacks << callback
-        callback
-      end
-
-      def callbacks
-        @callbacks.clone
-      end
-
-      def delete_callback(callback)
-        @callbacks.delete callback
-      end
-
-      def child_named(name)
-        @children[name]
-      end
-
-      def destroy_namespace(name)
-        @children.delete name
-      end
-
-      def root?
-        false
-      end
-
-    end
-
-    class RootNamespaceNode < NamespaceNode
-      def initialize
-        super :ROOT
-      end
-      def root?
-        true
-      end
-    end
-
-  end
-
-  class NamespaceNotFound < StandardError
-    def initialize(full_path)
-      super "Could not find #{full_path.inspect} in the namespace registry. Did you register it yet?"
-    end
-  end
-
-end

data/lib/theatre/version.rb

@@ -1,2 +0,0 @@
-THEATRE_VERSION_MAJOR, THEATRE_VERSION_MINOR, THEATRE_VERSION_REVISION = THEATRE_VERSION = [0,8,1]
-THEATRE_VERSION_STRING = THEATRE_VERSION.join '.'

data/spec/adhearsion/cli_spec.rb

@@ -1,306 +0,0 @@
-require 'spec_helper'
-require 'adhearsion/cli'
-
-module AhnCommandSpecHelper
-
-  def simulate_args(*args)
-    ARGV.clear
-    ARGV.concat args
-  end
-
-  def capture_stdout(&block)
-    old = $stdout
-    $stdout = io = StringIO.new
-    yield
-  ensure
-    $stdout = old
-    return io.string
-  end
-
-  def new_tmp_dir(filename=new_guid)
-    File.join Dir.tmpdir, filename
-  end
-
-  def create_component_sandbox
-    new_tmp_dir.tap do |dir|
-      Dir.mkdir dir
-      FileUtils.touch dir + "/.ahnrc"
-      Dir.mkdir dir + "/components"
-    end
-  end
-
-  def execute_ahn_command
-    Adhearsion::CLI::AhnCommand.execute!
-  end
-
-  def executing_ahn_command_should_fail_with(exception)
-    flexmock(Adhearsion::CLI::AhnCommand).should_receive(:fail_and_print_usage).with(exception).once
-    execute_ahn_command
-  end
-
-end
-
-describe 'The Ahn Command helper' do
-
-  include AhnCommandSpecHelper
-
-  it "args are simulated properly" do
-    before = ARGV.clone
-    simulate_args "create", "/tmp/blah"
-    ARGV.should_not be before
-  end
-
-  it "STDOUT should be captured" do
-    capture_stdout do
-      puts "wee"
-    end.should == "wee\n"
-  end
-
-end
-
-describe "A simulated use of the 'ahn' command" do
-
-  include AhnCommandSpecHelper
-
-  it "USAGE is defined" do
-    Adhearsion::CLI::AhnCommand.const_defined?('USAGE').should be true
-  end
-
-  before do
-    flexmock Adhearsion::ScriptAhnLoader, :in_ahn_application? => true
-  end
-
-  it "arguments to 'create' are executed properly" do
-    some_path = "/path/somewhere"
-    simulate_args "create", some_path
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:create).once.with(some_path)
-    capture_stdout { Adhearsion::CLI::AhnCommand.execute! }
-  end
-
-  it "arguments to 'start' are executed properly properly" do
-    some_path = "/tmp/blargh"
-    simulate_args "start", some_path
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:start).once.with(some_path, :foreground, nil)
-    Adhearsion::CLI::AhnCommand.execute!
-  end
-
-  it "should execute arguments to 'start' for daemonizing properly" do
-    somewhere = "/tmp/blarghh"
-    simulate_args "start", 'daemon', somewhere
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:start).once.with(somewhere, :daemon, nil)
-    Adhearsion::CLI::AhnCommand.execute!
-  end
-
-  it "should execute arguments to 'start' for using a console properly" do
-    somewhere = "/tmp/blarghh"
-    simulate_args "start", 'console', somewhere
-    flexmock(Adhearsion::CLI::AhnCommand::CommandHandler).should_receive(:start).once.with(somewhere, :console, nil)
-    Adhearsion::CLI::AhnCommand.execute!
-  end
-
-  it 'parse_arguments should recognize start with daemon properly' do
-    path = '/path/to/somesuch'
-    arguments = ['start', 'daemon', path]
-    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, path, :daemon, nil]
-  end
-
-  it 'should not allow both daemon and console to be specified' do
-    path = '/path/to/somesuch'
-    arguments = ['start', 'daemon', 'console', path]
-    lambda { Adhearsion::CLI::AhnCommand.parse_arguments(arguments) }.should raise_error Adhearsion::CLI::AhnCommand::CommandHandler::CLIException
-  end
-
-  it 'should recognize start with daemon and pid file properly' do
-    project_path  = '/second/star/on/the/right'
-    pid_file_path = '/straight/on/til/morning'
-    arguments = ["start", "daemon", project_path, "--pid-file=#{pid_file_path}"]
-    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, project_path, :daemon, pid_file_path]
-  end
-
-  it 'should recognize start without daemon and with pid file properly' do
-    project_path  = '/second/star/on/the/right'
-    pid_file_path = '/straight/on/til/morning'
-    arguments = ["start", project_path, "--pid-file=#{pid_file_path}"]
-    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, project_path, :foreground, pid_file_path]
-  end
-
-  it 'parse_arguments should recognize start without daemon properly' do
-    path = '/path/to/somewhere'
-    arguments = ['start', path]
-    Adhearsion::CLI::AhnCommand.parse_arguments(arguments).should == [:start, path, :foreground, nil]
-  end
-
-  it "if no path is provided, running Ahn command blows up" do
-    lambda { Adhearsion::CLI::AhnCommand.parse_arguments(['start']) }.should raise_error Adhearsion::CLI::AhnCommand::CommandHandler::CLIException
-  end
-
-  it "printing the version" do
-    capture_stdout do
-      simulate_args 'version'
-      Adhearsion::CLI::AhnCommand.execute!
-    end.should =~ Regexp.new(Regexp.escape(Adhearsion::VERSION::STRING))
-  end
-
-  it "printing the help" do
-    capture_stdout do
-      simulate_args 'help'
-      Adhearsion::CLI::AhnCommand.execute!
-    end.should =~ Regexp.new(Regexp.escape(Adhearsion::CLI::AhnCommand::USAGE))
-  end
-
-  it "reacting to unrecognized commands" do
-    simulate_args "alpha", "beta"
-    flexmock(Adhearsion::CLI::AhnCommand).should_receive(:fail_and_print_usage).once.and_return
-    Adhearsion::CLI::AhnCommand.execute!
-  end
-
-  it "giving a path that doesn't contain a project raises an exception" do
-    simulate_args "start", "/asjdfas/sndjfabsdfbqwb/qnjwejqbwh"
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::PathInvalid
-  end
-
-end
-
-describe "Component-related commands" do
-
-  include AhnCommandSpecHelper
-
-
-  it "should move a folder from the components/disabled/ folder of an app to the components/ directory if it exists" do
-    sandbox      = create_component_sandbox
-    disabled_dir = "#{sandbox}/components/disabled/foobar"
-    enabled_dir  = "#{sandbox}/components/foobar"
-
-    FileUtils.mkdir_p disabled_dir
-    FileUtils.touch disabled_dir + "/foobar.rb"
-
-    flexmock(Dir).should_receive(:pwd).once.and_return disabled_dir
-
-    simulate_args "enable", "component", "foobar"
-    capture_stdout { execute_ahn_command }
-
-    File.directory?(disabled_dir).should_not be true
-    File.exists?(enabled_dir + "/foobar.rb").should be true
-  end
-
-  it "should raise a ComponentError exception if there is no disabled folder" do
-    sandbox = create_component_sandbox
-
-    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
-
-    simulate_args "enable", "component", "foo"
-
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
-  end
-
-  it "should raise an exception if the disabled component exists and there's an enabled component of the same name" do
-    sandbox = create_component_sandbox
-
-    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
-
-    FileUtils.mkdir_p sandbox + "/disabled/lolcats"
-    FileUtils.mkdir_p sandbox + "/lolcats"
-
-    simulate_args "enable", "component", "foo"
-
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
-  end
-
-  it "should raise a PathInvalid error if the current directory does not belong to an Adhearsion app" do
-    flexmock(Dir).should_receive("pwd").and_return "/"
-    simulate_args "enable", "component", "foo"
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::PathInvalid
-  end
-
-  it "should properly create the disabled folder if it doesn't exist when disabling a component" do
-    sandbox = create_component_sandbox
-    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
-
-    FileUtils.mkdir_p sandbox + "/components/rickroller"
-
-    simulate_args 'disable', 'component', 'rickroller'
-    capture_stdout { execute_ahn_command }
-    File.directory?(sandbox + "/components/disabled/rickroller").should be true
-    File.directory?(sandbox + "/components/rickroller").should be false
-  end
-
-  it "should raise an UnknownCommand error when trying to enable a kind of feature which doesn't exist" do
-    simulate_args "enable", "bonobo"
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
-  end
-
-  it "should raise an UnknownCommand error when trying to disable a kind of feature which doesn't exist" do
-    simulate_args "disable", "thanksgiving_dinner"
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
-  end
-
-  it "should raise a ComponentError when the component to disable doesn't exist" do
-    sandbox = create_component_sandbox
-    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
-
-    simulate_args "disable", "component", "monkeybars"
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
-  end
-
-  it "should raise an exception when disabling a component and the component's disabled directory already exists" do
-    sandbox = create_component_sandbox
-
-    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
-
-    FileUtils.mkdir_p sandbox + "/disabled/lolcats"
-    FileUtils.mkdir_p sandbox + "/lolcats"
-
-    simulate_args "disable", "component", "foo"
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
-  end
-
-end
-
-describe 'The "create" command' do
-
-  include AhnCommandSpecHelper
-
-  it "creating a project" do
-    the_following_code {
-      tmp_path = new_tmp_dir
-      simulate_args "create", tmp_path
-      # capture_stdout { Adhearsion::CLI::AhnCommand.execute! }
-      execute_ahn_command
-      File.exists?(File.join(tmp_path, ".ahnrc")).should be true
-    }.should_not raise_error
-  end
-
-  it "should raise an UnknownCommand if running create with no arguments" do
-    simulate_args "create"
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::UnknownCommand
-  end
-
-  it "should raise a ComponentError if the name of the component is not a valid Ruby symbol name" do
-    bad_names = ["!))", "37signals", "foo bar", "*"]
-    bad_names.each do |bad_name|
-      simulate_args "create", "component", bad_name
-      executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
-    end
-  end
-
-  it "should raise a ComponentError if the component name already exists in the folder" do
-    sandbox = create_component_sandbox
-    Dir.mkdir sandbox + "/components/blehhh"
-    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
-    simulate_args "create", "component", "blehhh"
-
-    executing_ahn_command_should_fail_with Adhearsion::CLI::AhnCommand::CommandHandler::ComponentError
-  end
-
-  it "should create a folder with matching .rb file and .yml file when all guards pass" do
-    sandbox = create_component_sandbox
-    flexmock(Dir).should_receive(:pwd).once.and_return sandbox
-
-    simulate_args "create", "component", "ohai"
-    capture_stdout { execute_ahn_command }
-
-    File.exists?(sandbox + "/components/ohai/lib/ohai.rb").should be true
-    File.exists?(sandbox + "/components/ohai/config/ohai.yml").should be true
-  end
-
-end