orator 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDJhNWFlYjk5NjdjZTI1Nzk5MGEzMzVhMjc5N2NhNjRkY2JkMGVlZA==
+  data.tar.gz: !binary |-
+    Zjk5YzBmNjNiMzFhZTNkMGNlYTZiYmMxN2ExMWRkNTAwMDk4OWU1MQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZWE2N2Y4ZTU3ZWM4ZDRiNmZhMWQyNGRlY2RkNzQ5ZWVhMTRhZmUyODc1ZGMy
+    ZjYwMWY4YWU3Y2FjN2QxOGQ2YzBiMzQ4MzQ1YmVhOWZhMjk0NDNkYzNhYzgx
+    MTk2ZWQxMjdmMGViZmVlODg3ZTU3MmIwOTFmMThmOGQ4NDE1OGY=
+  data.tar.gz: !binary |-
+    NzJhODQzZWNhZDhkZDU3NGViN2ZiYmYzYTY4NDU3NTVkZWQ0ZGE3YmJjYzc3
+    ZTkxYTJlOGExZjI5MmQ0NzFhNDI0MGE2YTBhZGNmOTRhOWE0Mjg0YzA0MzU2
+    YTFjYTM0ZmE1ODcwYTFiZmM1MWI4OTQyNjgxMjUyMGZiNDQ3ODU=

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Jeremy Rodi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 
+of the Software, and to permit persons to whom the Software is furnished to do 
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
+SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Orator [![Code Climate](https://codeclimate.com/github/redjazz96/orator.png)](https://codeclimate.com/github/redjazz96/orator) [![Build Status](https://travis-ci.org/redjazz96/orator.png?branch=master)](https://travis-ci.org/redjazz96/orator)
+
+Orator is a websocket client/server combination that uses events in order to
+talk to each other.  It is still early in its development.
+
+This project uses [web-socket-js](https://github.com/gimite/web-socket-js/) as
+well as [em-websocket](https://github.com/igrigorik/em-websocket).
+
+## Ruby on Rails Integration
+Orator integrates easily with Ruby on Rails.  Just add
+  
+    gem 'orator', :github => "redjazz96/orator"
+
+to your Gemfile and `bundle install` away.  In order to use it, you'll need to
+add the following line to your `application.js` file:
+
+    //= require orator
+
+Now you can use the orator client in your JavaScript!  If the browser doesn't
+support JavaScript, it'll fall back to a flash object.
+
+## JavaScript Client
+Let's go through an example together.
+    
+    $(document).ready(function() {      
+      Orator.setup("ws://host:port/path?query", function(events){
+
+`Orator.setup` handles setting up our socket for us.  It also sets up the
+events and routing, as well.  There are some locally defined events that are
+triggered even if the server hadn't sent them, such as `socket.open` and
+`socket.close`.
+        
+        events.on('some.event', function() {})
+
+Here we're binding some event named `some.event` to an empty function.  Boring.
+Note that the name of the event doesn't matter here.
+
+        events.on('test.ping', function() { 
+          this.server.send('test.pong', { message: 'pong' });
+        });
+
+Here we're responding to a ping that a server might send to this client.  We
+send back a `test.pong` event, with the message 'pong'.  The contents of the
+event can be anything.
+
+        events.on('test.pong', function(data) {
+          console.log(data.message) # => "pong"
+        });
+
+Here we received a pong back from the server - this was triggered by the server
+in response to our ping, which we could have sent at any time.
+
+        events.on('socket.open', function() {
+          this.user = {}
+
+          this.server.send('user.alias', { name: some_name })
+        });
+
+Here we defined an event that will set up a an empty object on the property
+user of `this`.  This will become important.  We then send the event
+`user.alias` to the server (which probably changes the name of the user) with
+the new name (assuming `some_name` has a string value).
+
+        events.on('user.alias', function(data) {
+          this.user.name = data.name;
+        });
+
+It is common place for the server's response events to be named the same as the
+request events (although the response events may be sent at any time, with no
+context).  Here we see setting the name of the user object to the name the
+server sent back.  This is the same user object that we defined in the event
+above.
+
+      });
+
+    });
+
+And we close our braces.
+
+## Server Stuff
+I'm not entirely sure how to set this part up...  any ideas?
+
+I'm trying to provide support for all types of rails applications, including
+those on passenger.  I'll probably require a settings file in 
+`Rails.root/config` for orator...

data/bin/orator

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+library_path = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift library_path unless $LOAD_PATH.include? library_path
+require "orator"
+require "orator/cli"
+
+cli = Orator::CLI.new
+cli.parse_arguments ARGV
+cli.handle_command

data/lib/orator/cli.rb

@@ -0,0 +1,163 @@
+require 'optparse'
+require 'yaml'
+
+module Orator
+
+  # Handles the command line interface for Orator.
+  class CLI
+
+    DEFAULT_OPTIONS = {
+      :command   => :help,
+      :file      => "./orator_config.yml",
+      :daemonize => false
+    }
+
+    def initialize
+      @options = {}.merge DEFAULT_OPTIONS
+    end
+
+    def parse_arguments(args)
+      OptionParser.new do |opts|
+
+        opts.on('--config FILE', "Loads the configuration settings from FILE.") do |file|
+          @options[:file] = file
+        end
+
+        opts.on('-cCOMMAND', '--command COMMAND', "The command to run.") do |command|
+          @options[:command] = command
+        end
+
+        opts.on('-D', '--[no-]daemonize', "Whether or not to daemonize the process.") do |d|
+          @options[:daemonize] = d
+        end
+
+        opts.on('-h', '--help', "Shows this message.") { puts opts; exit }
+        opts.on('-v', '--version', "Shows the version of orator.") do
+          puts Orator::VERSION
+          exit
+        end
+
+        opts.separator ""
+        opts.separator "Valid Commands:"
+        opts.separator "\tstart: start the orator server."
+        opts.separator "\tstop: stop the orator server."
+      end.parse!(args)
+    end
+
+    def handle_command
+      Orator.debug = yaml_options[:debug]
+      send(@options[:command])
+    end
+
+    def start
+      daemonize? do
+        load_handlers
+        server = Orator::Server.new(yaml_options[:server_options])
+        handlers = self.class.handlers
+
+        puts "Starting server..." if Orator.debug
+        server.run do
+          handlers.each do |handler|
+            if handler.is_a? Proc
+              handler.call(self)
+            else
+              handler.register_with(self)
+            end
+          end
+        end
+      end
+    end
+
+    def stop
+      if File.exists? yaml_options[:pid_file]
+        Process.kill 1, File.open(yaml_options[:pid_file], 'r').read.to_i
+        puts "Stopped Orator."
+        File.unlink yaml_options[:pid_file]
+      end
+    end
+
+    # Add a handler to be used by the server.
+    #
+    # @param klass [Class] the class to use as a handler.
+    # @return [Array<Class>] a list of handlers that will be used for the
+    #   server.
+    def self.add_handler(klass = nil, &block)
+      handlers << (klass || block)
+    end
+
+    # A list of handlers.
+    #
+    # @return [Array<Class>] the handlers.
+    def self.handlers
+      @handlers ||= []
+    end
+
+    private
+
+    # Grab the options from the options file.
+    #
+    # @returns [Hash]
+    def yaml_options
+      @yaml_options ||= YAML::load_file @options[:file]
+    end
+
+    # Checks the PID file (assuming it exists) to see if the process is still
+    # running.
+    #
+    # @raises [ProcessExistsError] if the process is still running.
+    def check_pid_file
+      pid = File.open(yaml_options[:pid_file], 'r').read.to_i
+
+      begin
+        Process.kill 0, pid
+        raise ProcessExistsError
+      rescue Errno::ESRCH
+      end
+    end
+
+    # Loads the handlers from the YAML file by requiring each file.
+    #
+    # @return [void]
+    def load_handlers
+      handlers = []
+      if yaml_options[:handler]
+        handlers << yaml_options[:handler]
+      end
+
+      if yaml_options[:handlers]
+        handlers.concat(yaml_options[:handlers])
+      end
+
+      handlers.each do |handler|
+        begin
+          require_relative handler
+        rescue LoadError
+          require handler
+        end
+      end
+    end
+
+    # Daemonizes the block, if it's applicable.
+    #
+    # @yields [] in the new process, if daemonized; otherwise, a normal yield.
+    def daemonize?
+      if @options[:daemonize]
+        check_pid_file if File.exists? yaml_options[:pid_file]
+        child_process = fork do
+          $stdout = $stderr = File.open(yaml_options[:log_file], 'a')
+          $stdout.sync = true
+
+          yield
+        end
+
+        File.open(yaml_options[:pid_file], 'w') { |f| f.write child_process }
+        Process.detach child_process
+      else
+        yield
+      end
+    end
+
+    class ProcessExistsError < StandardError; end
+
+  end
+end

data/lib/orator/client.rb

@@ -0,0 +1,44 @@
+module Orator
+
+  # A representation of a client.
+  class Client
+
+    # The event handler for this client.
+    #
+    # @return [EventHandler]
+    attr_accessor :event_handler
+
+    # The context to be used by the client.
+    #
+    # @return [Object]
+    attr_accessor :context
+
+    # The socket to be used to talk to the client.
+    #
+    # @return [#send]
+    attr_accessor :socket
+
+    # Initialize.
+    #
+    # @param data [Hash] the keys are used to set data on the client to the
+    #   values of the hash.  If the attribute doesn't exist on the client,
+    #   it is ignored.
+    # @example
+    #   client = Client.new :something => "foo"
+    #   client.something # => "foo"
+    def initialize(data)
+      data.each do |k, v|
+        send "#{k}=", v if respond_to? "#{k}="
+      end
+    end
+
+    # This forwards the method call to [EventHandler#trigger], but removes an
+    # argument: the context.
+    #
+    # @see [EventHandler#trigger]
+    def trigger(event, *args)
+      event_handler.trigger(event, context, *args)
+    end
+    
+  end
+end

data/lib/orator/engine.rb

@@ -0,0 +1,5 @@
+module Orator
+  class Engine < Rails::Engine
+
+  end
+end

data/lib/orator/event_handler.rb

@@ -0,0 +1,97 @@
+module Orator
+
+  # This handles events and calls the callbacks for them.
+  class EventHandler
+
+    # Initialize the event handler.
+    #
+    # @yields [] in the current instance.  Mainly for setting up the events.
+    # @return [void]
+    def initialize(&block)
+      @events  = []
+      @_number = 0
+      instance_exec &block if block_given?
+    end
+
+    # This adds an event to the set.  It can accept a block or a class.  If
+    # it's a class, the class should inherit from [Handlers::Base].  If both
+    # a class and a block is given, the block is preferred.
+    #
+    # @param event [String, Symbol] the event to bind it to.
+    # @param klass [Handlers::Base, nil] the class that contains the method to 
+    #   use for the event.
+    # @param count [Numeric, nil] the number of times to run this event.  No
+    #   value is an infinite number of times.
+    # @raise [ArgumentError] if klass isn't a subclass of Handlers::Base.
+    # @return [void]
+    def on(event, klass = nil, count = nil, &block)
+      puts "Binding #{event} to #{klass || block}..." if Orator.debug
+      data = { :event => event.to_s, :count => count }
+
+      if block_given?
+        data[:block] = block
+      elsif klass and klass < Handlers::Base
+        data[:class] = klass
+      else
+        raise ArgumentError, "No class or block was given."
+      end
+
+      @events << data unless @events.include?(data)
+    end
+
+    # This triggers the events.  The events aren't triggered in any particular
+    # order, since they are stored in a [Set].  Extra arguments are passed to
+    # the block/class.
+    #
+    # @param event [String, Symbol] the event to trigger.
+    # @param context [Object] the context to run in.  If the event is mapped to
+    #   a block, the block is executed in the context.  In all cases, the
+    #   context is appended to the end of the arguments.
+    # @return [Object, nil]
+    def trigger(event, context, *args)
+      puts "Running event #{event}..." if Orator.debug
+      events(event).map do |event|
+        puts "Found responder #{event[:block] || event[:class]}" if Orator.debug
+        if event[:block]
+          context.instance_exec *args, context, &event[:block]
+        elsif event[:class]
+          event[:class].new(context).__trigger(event[:event], *args)
+        end
+
+        if event[:count] then event[:count] -= 1 end
+      end
+
+      clear_events
+    end
+
+    # Accessor for events.  If the first parameter is passed, it checks for
+    # events that match that event.
+    #
+    # @param matching [String, Symbol] the event to find.
+    # @return [Set<Hash>]
+    def events(matching = nil)
+      if matching
+        @events.select { |e| e[:event] == matching.to_s }
+      else
+        @events.dup
+      end
+    end
+
+    private
+
+    # This removes events where their [:count] is less than or equal to zero.
+    #
+    # @return [void]
+    def clear_events
+      @events.delete_if do |event|
+        if event[:count]
+          event[:count] <= 0
+        else
+          false
+        end
+      end
+    end
+
+  end
+
+end

data/lib/orator/handlers/base.rb

@@ -0,0 +1,158 @@
+module Orator
+  module Handlers
+
+    # A base for the handlers to split off of.  It handles contexts and running
+    # methods.  Most of the methods defined in this  class are prefixed with
+    # two dashes to prevent polluting the namespace. 
+    #
+    # @abstract
+    class Base
+
+      # Initialize the handler with the context.
+      #
+      # @param context [Object]
+      def initialize(context)
+        @__context = context
+      end
+
+      # This triggers an event if it's defined on this handler.  If it is not
+      # defined, it raises an error.
+      #
+      # @param event [Symbol, String] the event to trigger.
+      # @raise [NoMethodError] if the event isn't defined on the handler.
+      # @return [Array<Object>] the values of the trigger.
+      def __trigger(event, *args)
+        handler, method_name = event.to_s.split('.')
+
+        if handler != self.class.name 
+          raise NoMethodError, 
+            "Event #{handler} does not match #{self.class.name}"
+          return
+        elsif !__method_exists?(method_name)
+          raise NoMethodError, 
+            "Method #{method_name} does not exist on #{self.class.name}"
+          return
+        end
+
+        self.class.before_list.map { |b| instance_exec &b }
+
+        __run_event(method_name, args) unless @__prevent_event
+      end
+
+      # Checks the event list to see if this class responds to it.
+      #
+      # @return [Set<Symbol, Proc>, nil]
+      def __method_exists?(method)
+        __event_list[method]
+      end
+
+      # A map of the events that determine how this class will respond.
+      #
+      # @return [Hash]
+      # @see [ClassMethods::event_list]
+      def __event_list
+        self.class.event_list
+      end
+
+      # This tells the handler to not execute the events in the class.  This
+      # should only be called in a `before` block.
+      def prevent_event
+        @__prevent_event = true
+      end
+
+      # Handles missing methods by delegating them to the context.  Should
+      # never be called directly.
+      #
+      # @return [Object]
+      def method_missing(method, *args, &block)
+        super unless respond_to_missing?(method)
+
+        @__context.public_send(method, *args, &block)
+      end
+
+      # Lets Ruby know that there are some undefined methods on this class.
+      #
+      # @return [Boolean]
+      def respond_to_missing?(method, include_private = false)
+        @__context.respond_to?(method, include_private)
+      end
+
+      # This forwards {#send} on to the context.
+      #
+      # @return [Object]
+      def send(*args, &block)
+        @__context.send(*args, &block)
+      end
+
+      private
+
+      def __run_event(method_name, args)
+        result = __event_list[method_name].map do |responder|
+          responder = method(responder) if responder.is_a? Symbol
+          instance_exec *args, &responder
+        end
+
+        self.class.after_list.map { |a| instance_exec &a }
+
+        result
+      end
+
+      module ClassMethods
+        # The name of the handler.  This is used to determine whether or not
+        # the handler can run it.
+        #
+        # @return [String]
+        attr_accessor :name
+
+        # This registers a method for this Handler.
+        #
+        # @param event [Symbol] the event to register it to.
+        # @return [void]
+        def on(event, method = nil, &block)
+          event_list[event.to_s] ||= []
+
+          if block_given?
+            event_list[event.to_s] << block
+          else
+            event_list[event.to_s] << (method || event).to_sym
+          end
+        end
+
+        # The event matchings.  The keys are the event name, the values can be
+        # an array of mappings or a the mapping itself.
+        #
+        # @return [Hash] the event list.
+        def event_list
+          @event_list ||= {}
+        end
+
+        # This registers this handler with the event handler by telling it what
+        # methods it responds to.
+        #
+        # @param event_handler [EventHandler]
+        def register_with(event_handler)
+          event_list.keys.each do |event|
+            event_handler.on("#{self.name}.#{event}", self)
+          end
+        end
+
+        [:before, :after].each do |type|
+          module_eval <<-METHOD, __FILE__, __LINE__
+            def #{type}(method = nil, &block)
+              #{type}_list << (method || block)
+            end
+       
+            def #{type}_list
+              @#{type}_list ||= Set.new
+            end
+          METHOD
+        end
+      end
+
+      extend ClassMethods
+      self.name = ''
+
+    end
+
+  end
+end

data/lib/orator/handlers.rb

@@ -0,0 +1,9 @@
+require 'orator/handlers/base'
+
+module Orator
+
+  # Handlers to be used by orator.
+  module Handlers
+
+  end
+end

data/lib/orator/middle_ground.rb

@@ -0,0 +1,38 @@
+module Orator
+
+  # This is used as a context for the client execution.
+  class MiddleGround
+
+    # Provides access to the client.
+    #
+    # @return [Client]
+    attr_reader :client
+
+    # Initialize the class.
+    def initialize(client)
+      @client = client
+    end
+
+    # This sends a message to the client.
+    #
+    # @param data [Hash] the data to be sent to the client.
+    # @return [void]
+    def send(data)
+      @client.socket.send Oj.dump(data, :mode => :null)
+    end
+
+    # This builds a message from a hash and an event.
+    #
+    # @param event [String, Symbol] the event for the message.
+    # @param data [Hash] the data for the message.
+    def message(event, data)
+      new_data = { "event" => event.to_s }
+
+      data.each do |k, v|
+        new_data[k.to_s] = v
+      end
+
+      new_data
+    end
+  end
+end

data/lib/orator/server.rb

@@ -0,0 +1,70 @@
+module Orator
+
+  # Handles the server connections and passing stuff to the event handler.
+  class Server
+
+    # The options defined for the server.
+    #
+    # @return [Hash]
+    attr_reader :options
+
+    # The list of clients that are connected.
+    #
+    # @return [Set<Client>]
+    attr_reader :clients
+
+    # The event handler that is duplicated for every client.  This is to reduce
+    # the overhead of reinitializing the event handler for every client.
+    #
+    # @return [EventHandler]
+    attr_reader :event_handler
+
+    # Initialize the server.
+    #
+    # @return [void]
+    def initialize(options)
+      @options = options
+      @clients = Set.new
+    end
+
+    # Runs the server with the given options.
+    def run(&block)
+      @event_handler = EventHandler.new(&block)
+      EM::WebSocket.start(@options, &method(:handle_socket))
+    end
+
+    private
+
+    # Handles setting up the socket.  This binds the [#onopen], [#onclose],
+    # [#onerror], and [#onmessage] events.
+    #
+    # @param [Object]
+    def handle_socket(socket)
+      client = Client.new :event_handler => @event_handler.dup, 
+        :socket => socket, :context => nil
+      client.context = MiddleGround.new(client)
+      clients << client
+
+      socket.onopen do |handshake|
+        client.trigger 'socket.open', handshake
+      end
+
+      socket.onerror do |error|
+        client.trigger 'socket.error', error
+      end
+
+      socket.onclose do |message|
+        client.trigger 'socket.close', message
+        clients.delete client
+      end
+
+      socket.onmessage do |data|
+        json_data = Oj.load data, :mode => :null
+        client.trigger json_data["event"], json_data
+      end
+
+    end
+
+  end
+    
+end

data/lib/orator/version.rb

@@ -0,0 +1,5 @@
+module Orator
+
+  # Version of Orator.
+  VERSION = '0.0.1'
+end

data/lib/orator.rb

@@ -0,0 +1,21 @@
+# A websocket server.
+
+require 'oj'
+require 'set'
+require 'em-websocket'
+
+require 'orator/server'
+require 'orator/client'
+require 'orator/version'
+require 'orator/handlers'
+require 'orator/event_handler'
+require 'orator/middle_ground'
+
+require 'orator/engine' if defined? Rails
+
+module Orator
+
+  class << self; attr_accessor :debug; end
+  Orator.debug = false
+  
+end

data/spec/base_handler_spec.rb

@@ -0,0 +1,45 @@
+describe Orator::Handlers::Base do
+  it "should call before blocks" do
+    something = double('something')
+    something.should_receive(:to_call)
+    klass = Class.new(described_class) do
+      self.name = 'test'
+      before { something.to_call }
+      on 'some_event'
+      def some_event; end
+    end
+
+    klass.new(nil).__trigger('test.some_event')
+  end
+
+  it "should raise error when it doesn't match the event" do
+    expect { described_class.new(nil).__trigger('other.thing') }.to raise_error(NoMethodError)
+    expect { described_class.new(nil).__trigger('.thing') }.to raise_error(NoMethodError)
+  end
+
+  it "should not run the event if the before callback prevents it" do
+    something = double('something')
+    something.should_not_receive(:to_call)
+    klass = Class.new(described_class) do
+      self.name = 'test'
+      before { prevent_event }
+      on('some_event') { something.to_call }
+    end
+
+    klass.new(nil).__trigger('test.some_event')
+  end
+
+  it "should register itself with an event handler" do
+    event_handler = double('event_handler')
+
+    klass = Class.new(described_class) do
+      self.name = 'test'
+
+      on('some_event') { }
+    end
+
+    event_handler.should_receive(:on).with("test.some_event", klass)
+
+    klass.register_with(event_handler)
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,14 @@
+describe Orator::Client do
+  it "should accept a hash" do
+    client = described_class.new :context => 42, :other_thing => 124
+
+    client.context.should be 42
+  end
+
+  it "should trigger event with context" do
+    client = described_class.new :context => 42, 
+      :event_handler => double('event_handler')
+    client.event_handler.should_receive(:trigger).with('some.event', 42, 54)
+    client.trigger('some.event', 54)
+  end
+end

data/spec/event_handler_spec.rb

@@ -0,0 +1,62 @@
+describe Orator::EventHandler do
+  it "should initalize with block" do
+    expect { 
+      EventHandler.new { raise StandardError } 
+    }.to raise_error(StandardError)
+  end
+
+  it "should add an event with a block" do
+    subject.events.length.should be 0
+    subject.on(:some_event) { something }
+    subject.events.length.should be 1
+    subject.events.first[:event].should eq "some_event"
+    subject.events.first[:block].should be_kind_of Proc
+  end
+
+  class SomeClass < Orator::Handlers::Base; end
+
+  it "should accept a class for an event" do
+    subject.on(:some_event, SomeClass)
+    subject.events.first[:class].should be SomeClass
+  end
+
+  it "should accept a count" do
+    subject.on(:some_event, SomeClass, 4)
+    subject.events.first[:count].should be 4
+  end
+
+  it "should decrease the count by one" do
+    something = double("something")
+    something.should_receive(:to_call)
+    subject.on(:some_event, nil, 4) { something.to_call }
+    subject.events.first[:count].should be 4
+    subject.trigger(:some_event, self)
+    subject.events.first[:count].should be 3
+  end
+
+  it "shouldn't add the same event twice" do
+    subject.on(:some_event, SomeClass)
+    subject.events.length.should be 1
+    subject.on(:some_event, SomeClass)
+    subject.events.length.should be 1
+  end
+
+  it "should remove events with a count of 0" do
+    something = double("something")
+    something.should_receive(:to_call)
+    subject.on(:some_event, nil, 1) { something.to_call }
+    subject.on(:another_event) { }
+    subject.events.length.should be 2
+    subject.trigger(:some_event, self)
+    subject.events.length.should be 1
+  end
+
+  it "should select events with the same event" do
+    subject.on(:some_event) { }
+    subject.on(:another_event) { }
+    subject.on(:some_event) { do_something }
+
+    subject.events.length.should be 3
+    subject.events(:some_event).length.should be 2
+  end
+end

data/spec/middle_ground_spec.rb

@@ -0,0 +1,19 @@
+describe Orator::MiddleGround do
+  #it "should build a message" do
+  #  subje
+  #end
+
+  subject { described_class.new(double('client')) }
+
+  it "should build a message" do
+    subject.message('some.thing', :data => 'value').should eq(
+      "event" => "some.thing", "data" => "value")
+  end
+
+  it "should send a message to the client" do
+    socket = double('socket')
+    socket.should_receive(:send).with('{"event":"some.thing","data":"value"}')
+    subject.client.should_receive(:socket).and_return(socket)
+    subject.send("event" => "some.thing", "data" => "value")
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: orator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jeremy Rodi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: em-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.10
+- !ruby/object:Gem::Dependency
+  name: swf_fu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+description: ! '  An implementation of an evented websocket system for rails.
+
+'
+email: redjazz96@gmail.com
+executables:
+- orator
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/orator/middle_ground.rb
+- lib/orator/version.rb
+- lib/orator/handlers.rb
+- lib/orator/server.rb
+- lib/orator/cli.rb
+- lib/orator/client.rb
+- lib/orator/handlers/base.rb
+- lib/orator/engine.rb
+- lib/orator/event_handler.rb
+- lib/orator.rb
+- bin/orator
+- spec/client_spec.rb
+- spec/middle_ground_spec.rb
+- spec/event_handler_spec.rb
+- spec/base_handler_spec.rb
+- README.md
+- Rakefile
+- LICENSE
+homepage: http://github.com/redjazz96/orator
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: Magic for your browser.
+test_files: []
+has_rdoc: false