websocket-rails 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+.bundle/
+log/*.log
+pkg/
+test/dummy/db/*.sqlite3
+test/dummy/log/*.log
+test/dummy/tmp/

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,103 @@
+PATH
+  remote: .
+  specs:
+    websocket-rails (0.0.1)
+      em-websocket (~> 0.3.6)
+      rack
+      thin
+      websocket-rack
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.12)
+      actionpack (= 3.0.12)
+      mail (~> 2.2.19)
+    actionpack (3.0.12)
+      activemodel (= 3.0.12)
+      activesupport (= 3.0.12)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.5)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.12)
+      activesupport (= 3.0.12)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.12)
+      activemodel (= 3.0.12)
+      activesupport (= 3.0.12)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.12)
+      activemodel (= 3.0.12)
+      activesupport (= 3.0.12)
+    activesupport (3.0.12)
+    addressable (2.2.7)
+    arel (2.0.10)
+    builder (2.1.2)
+    daemons (1.1.8)
+    em-websocket (0.3.6)
+      addressable (>= 2.1.1)
+      eventmachine (>= 0.12.9)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    eventmachine (0.12.10)
+    i18n (0.5.0)
+    json (1.6.5)
+    mail (2.2.19)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.18)
+    polyglot (0.3.3)
+    rack (1.2.5)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.12)
+      actionmailer (= 3.0.12)
+      actionpack (= 3.0.12)
+      activerecord (= 3.0.12)
+      activeresource (= 3.0.12)
+      activesupport (= 3.0.12)
+      bundler (~> 1.0)
+      railties (= 3.0.12)
+    railties (3.0.12)
+      actionpack (= 3.0.12)
+      activesupport (= 3.0.12)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.4)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    sqlite3 (1.3.5)
+    thin (1.3.1)
+      daemons (>= 1.0.9)
+      eventmachine (>= 0.12.6)
+      rack (>= 1.0.0)
+    thor (0.14.6)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.32)
+    websocket-rack (0.3.3)
+      em-websocket (~> 0.3.6)
+      rack
+      thin
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rails
+  rake
+  sqlite3
+  websocket-rails!

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+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,79 @@
+# Websocket-Rails
+
+Plug and play WebSocket support for ruby on rails. Includes event router for mapping javascript events to controller actions. There is no need for a separate WebSocket server process. Requests to `/websocket` will be passed through to the embedded WebSocket server provided by the em-websocket gem.
+
+*Important Note*
+
+This gem is not even close to production ready. This is mostly a proof of concept as of right now. Please try it out and let me know what you like or dislike. We will be adding much more soon including a development road map and full test coverage.
+
+## Installation
+
+Add the gem to your Gemfile
+
+*Important Note About Web Servers*
+
+Thin is the only web server currently supported. Use the `thin-websocket` executable provided by the websocket-rack gem to override the Thin connection timeout setting. The full command to start the server in development is `thin-websocket -p 3000 start`. Be sure to enable config.threadsafe! in your rails application and use the Rack::Fiberpool middleware to take advantage of Thin's asynchronous request processing.
+
+````ruby
+gem 'websocket-ruby'
+````
+
+Map WebSocket events to controller actions by creating an `events.rb` file in your app/config/initializers directory
+
+````ruby
+# app/config/initializers
+
+WebsocketRails::Dispatcher.describe_events do
+  subscribe :client_connected, to: ChatController, with_method: :client_connected
+  subscribe :new_message, to: ChatController, with_method: :new_message
+  subscribe :new_user, to: ChatController, with_method: :new_user
+  subscribe :change_username, to: ChatController, with_method: :change_username
+  subscribe :client_disconnected, to: ChatController, with_method: :delete_user
+end
+````
+
+The `subscribe` method takes the event name as the first argument, then a hash where `:to` is the Controller class and `:with_method` is the action to execute.
+
+The websocket client must connect to `/websocket`. You can connect using the following javascript. Replace the port with the port that your web server is running on.
+
+````javascript
+var conn = new WebSocket("ws://localhost:3000/websocket")
+conn.onopen = function(evt) {
+	dispatcher.trigger('new_user',current_user)
+}
+
+conn.onmessage = function(evt) {
+	var data = JSON.parse(evt.data),
+		event_name = data[0],
+		message = data[1];
+	console.log(data)
+}
+````
+
+We will be posting a basic javascript event dispatcher soon.
+
+## Controllers
+
+The Websocket::BaseController class provides methods for working with the WebSocket connection. Make sure you extend this class for controllers that you are using. The two most important methods are `send_data` and `broadcast_data`. The `send_data` method sends a message to the client that initiated this event, the `broadcast_data` method broadcasts messages to all connected clients. Both methods take two arguments, the event name to trigger on the client, and the message that accompanies it.
+
+````ruby
+message = {:message => 'this is a message'}
+broadcast_message :event_name, message
+send_message :event_name, message
+````
+
+The message can be a string, hash, or array. The message is serialized as JSON before being sent to the client.
+
+TODO: Show examples of using these methods.
+
+## Data Store
+
+TODO: write documentation for the data store
+
+## Development
+
+This gem is created and maintained by Dan Knox and Kyle Whalen under the MIT License.
+
+Brought to you by:
+
+Three Dot Loft LLC

data/Rakefile

@@ -0,0 +1,37 @@
+# encoding: UTF-8
+require 'rubygems'
+require 'rake'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'websocket-rails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  match "/websocket", :to => WebsocketRails::ConnectionManager.new
+end

data/lib/websocket-rails.rb

@@ -0,0 +1,18 @@
+require "active_support/dependencies"
+
+module WebsocketRails
+  mattr_accessor :app_root
+  
+  def self.setup
+    yield self
+  end
+  
+end
+
+require "websocket_rails/engine"
+require 'websocket_rails/connection_manager'
+require 'websocket_rails/dispatcher'
+require 'websocket_rails/base_controller'
+require 'websocket_rails/extensions/common'
+
+WebsocketRails::Extensions::Common.apply!

data/lib/websocket_rails/base_controller.rb

@@ -0,0 +1,29 @@
+require 'websocket_rails/data_store'
+
+module WebsocketRails
+  class BaseController
+    def initialize
+      @data_store = DataStore.new(self)
+    end
+    
+    def client_id
+      @_message.first
+    end
+
+    def message
+      @_message.last
+    end
+
+    def send_message(event,message)
+      @_dispatcher.send_message event.to_s, [client_id,message]
+    end
+
+    def broadcast_message(event,message)
+      @_dispatcher.broadcast_message event.to_s, message
+    end
+    
+    def data_store
+      @data_store
+    end  
+  end
+end

data/lib/websocket_rails/connection_manager.rb

@@ -0,0 +1,38 @@
+require 'rack'
+require 'rack/websocket'
+require 'json'
+module WebsocketRails
+  class ConnectionManager < Rack::WebSocket::Application
+    def initialize(*args)
+      @dispatcher = Dispatcher.new(self)
+      super
+    end
+  
+    def on_open(env)
+      puts "Client connected\n"
+      @dispatcher.dispatch('client_connected',{},env)
+    end
+    
+    def on_message(env, msg)
+      @dispatcher.receive( msg, env )
+    end
+    
+    def on_error(env, error)
+      puts "Error occured: " + error.message
+    end
+    
+    def on_close(env)
+      close_connection(env['websocket.client_id'])
+      @dispatcher.dispatch('client_disconnected',{},env)
+      puts "Client disconnected\n"
+    end
+  
+    def send_message(msg,uid)
+      send_data msg, uid
+    end
+  
+    def broadcast_message(msg)
+      send_data_all msg
+    end
+  end
+end

data/lib/websocket_rails/data_store.rb

@@ -0,0 +1,49 @@
+module WebsocketRails
+  class DataStore
+    def initialize(base_controller)
+      @base = base_controller
+      @data = Hash.new {|h,k| h[k] = Hash.new}
+      @data = @data.with_indifferent_access
+    end
+
+    def []=(k,v)
+      @data[cid] = Hash.new unless @data[cid]
+      @data[cid][k] = v
+    end
+
+    def [](k)
+      @data[cid][k] = Hash.new unless @data[cid]
+      @data[cid][k]
+    end
+
+    def each(&block)
+      @data.each do |cid,hash|
+        block.call(hash) if block
+      end
+    end
+    
+    def remove_client
+      @data.delete(cid)
+    end
+    
+    def delete(key)
+      @data[cid].delete(key)
+    end
+    
+    def cid
+      @base.client_id
+    end
+    
+    def method_missing(method, *args, &block)
+      if /each_(?<hash_key>\w*)/ =~ method
+        results = []
+        @data.each do |cid,hash|
+          results << hash[hash_key]
+        end
+        results
+      else
+        super
+      end
+    end
+  end
+end

data/lib/websocket_rails/dispatcher.rb

@@ -0,0 +1,71 @@
+require 'json'
+
+module WebsocketRails
+  class Dispatcher  
+    def initialize(connection)
+      puts "Initializing dispatcher\n"
+      @connection = connection
+      @events  = Hash.new {|h,k| h[k] = Array.new}
+      @classes = Hash.new
+      evaluate(&@@event_routes) if @@event_routes
+    end
+  
+    def receive(enc_message,env)
+      message = JSON.parse( enc_message )
+      event_name = message.first
+      data = message.last
+      data['received'] = Time.now.strftime("%I:%M:%p")
+      dispatch( event_name, data, env )
+    end
+  
+    def send_message(event_name,data)
+      @connection.send_message encoded_message( event_name, data.last ), data.first
+    end
+  
+    def broadcast_message(event_name,data)
+      @connection.broadcast_message encoded_message( event_name, data )
+    end
+    
+    def dispatch(event_name,data,env)
+      puts "#{event_name} is handled by #{@events[event_name.to_sym].inspect}\n\n"
+      message = [env['websocket.client_id'],data]
+      Fiber.new {
+        @events[event_name.to_sym].each do |event|
+          handler = event.first
+          klass   = @classes[handler]
+          klass.instance_variable_set(:@_message,message)
+          method  = event.last
+          klass.send( method )
+        end
+      }.resume
+    end
+  
+    def close_connection
+      @connection.close_connection
+    end
+  
+    def encoded_message(event_name,data)
+      [event_name, data].to_json
+    end
+  
+    def subscribe(event_name,options)
+      klass = options[:to] || raise("Must specify a class for to: option in event route")
+      method = options[:with_method] || raise("Must specify a method for with_method: option in event route")
+      controller = klass.new
+      if @classes[klass].nil?
+        @classes[klass] = controller
+        controller.instance_variable_set(:@_dispatcher,self)
+        controller.send :initialize_session if controller.respond_to?(:initialize_session)
+      end
+      @events[event_name] << [klass,method]
+    end
+  
+    def self.describe_events(&block)
+      @@event_routes = block
+    end
+  
+    def evaluate(&block)
+      instance_eval &block
+    end
+  end
+end