real_time_rails 0.0.2

data/.gitignore

@@ -0,0 +1,3 @@
+*.gemspec
+pkg
+Gemfile.lock

data/Gemfile

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

data/README.md

@@ -0,0 +1,35 @@
+About
+=====
+
+RealTimeRails gem to enable seamless websocket integration with rails.
+
+
+Purpose
+=======
+
+Implement a gem that will add a new render method that sets up a connection to a websocket server and notifies the server it's waiting for updates to content related to the specific partial. 
+
+During an update to an active record object, the websocket server gets a notice from the server to send updates to the connected clients for the content they are listening for.
+
+
+Disclaimer
+----------
+
+All source code at this point is to portray ideas to further cooperative design. It is not ready for use nor tested for validity.
+
+Beta Usage
+----------
+
+The gem is now loading and running correctly in the project. Still some bugs to iron out.
+
+To start the websocket server just run the websocket_server.rb ruby script.
+
+in your models that you want real time updates
+
+`include RealTimeRails:AR`
+
+then in your view that you want a real time update. At this point partial paths must be full view paths.
+
+`render_real_time partial: '/test/test', locals: {chats: @chats}`
+
+I still have a lot of debugging stuff in the view and javascript wrapper so ignore those for now.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new

data/lib/real_time_rails.rb

@@ -0,0 +1,13 @@
+require 'real_time_rails/version.rb'
+require 'real_time_rails/real_time_helper.rb'
+require 'real_time_rails/render_real_time_controller.rb'
+require 'real_time_rails/ar.rb'
+require 'real_time_rails/rt_helper.rb'
+
+if defined?(ActionView::Base)
+  ActionView::Base.send :include, RealTimeRails::RealTimeHelper
+end
+
+
+
+

data/lib/real_time_rails/ar.rb

@@ -0,0 +1,25 @@
+module RealTimeRails
+  
+  # include RealTimeRails:AR in your model for access to realtime updates.
+  module AR
+    #after every save send notification to the realtimerails socket server.
+    def self.included(klass)
+      klass.send :after_save, :send_rtr_update
+    end
+    
+    private
+
+    def send_rtr_update
+      # TODO figure out why i have to make 2 connections to send 2 messages instead of just one connection.
+      
+      mySock = TCPSocket::new('127.0.0.1', 2000)
+      mySock.puts("{\"command\":\"update1\",\"model\":\"#{self.class.name}\",\"id\":\"#{self.id}\"}")
+      mySock.close
+
+      mySock = TCPSocket::new('127.0.0.1', 2000)
+      mySock.puts("{\"command\":\"updateall\",\"model\":\"#{self.class.name}\"}")
+      mySock.close
+    end
+  end
+  
+end

data/lib/real_time_rails/real_time_helper.rb

@@ -0,0 +1,12 @@
+module RealTimeRails
+  module RealTimeHelper
+  
+    def render_real_time(options = {})
+      RealTimeRails::RtrHelper.new(options) do
+        render options
+      end.html
+    end
+  
+  end
+end
+

data/lib/real_time_rails/render_real_time_controller.rb

@@ -0,0 +1,30 @@
+class RenderRealTimeController < ActionController::Base
+  
+  # Updates will pull data from this controller.
+  # url in the form of '/render_real_time/id/#{md5_hash_id}'
+  # The information is pulled from Rails.cache by the md5 hash id
+  
+  def id
+    websocket_options = YAML.load(Rails.cache.read("real_time_#{params[:id]}"))
+    options = YAML.load(Rails.cache.read("real_time_#{params[:id]}_options"))
+    locals = {}
+    websocket_options[:models].each do |rtmodel|
+      
+      case rtmodel[:type]
+        when :single
+          locals[rtmodel[:key]] = eval("#{rtmodel[:name]}.find(rtmodel[:id])")
+        when :array
+          locals[rtmodel[:key]] = eval("#{rtmodel[:name]}.find(rtmodel[:ids])")
+        when :relation
+          rtmodel[:sql] = rtmodel[:sql].gsub('\"','"')
+          locals[rtmodel[:key]] = eval("#{rtmodel[:name]}.find_by_sql(rtmodel[:sql])") #TODO This needs to recreate the arel object. Not just find_by_sql.
+        else
+          
+      end
+    end
+    render :update do |page|
+      page.replace_html params[:id], :partial => options[:partial], :locals => locals
+    end
+  end
+  
+end

data/lib/real_time_rails/rt_helper.rb

@@ -0,0 +1,127 @@
+module RealTimeRails
+  class RtrHelper
+
+    require 'digest/md5'
+
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::PrototypeHelper
+    include ActionView::Helpers::JavaScriptHelper
+
+    def protect_against_forgery?
+      false
+    end
+
+    attr_accessor   :options, 
+                    :id,
+                    :html,
+                    :websocket_options, 
+                    :javascript_options,
+                    :render_options,
+                    :wrap_options,
+                    :remote_f_options
+
+
+    def initialize(options = {})
+      @options = options
+      set_options
+      register_partial
+      html = load_javascript
+      html += manual_buttons #TODO remove test helper for ajax update calls. 
+      html += wrap_render do
+        yield
+      end
+      @html = html
+    end
+
+    def set_options
+      model_list = []
+      @options[:locals].each do |key,value|
+        if value.is_a?(ActiveRecord::Base)
+          model_list << {type: :single, key: key, name: value.class.name, id: value.id}
+        end
+        if value.is_a?(Array)
+          if (class_name = value.map{|v| v.class.name}.uniq).length==1
+            model_list << {type: :array, key: key, name: class_name.first, ids: value.map(&:id)}
+          else
+            raise "Can not do real time updates on arrays containing different models.\n#{value.map{|v| v.class.name}.uniq.to_yaml}"
+          end
+        end
+        if value.is_a?(ActiveRecord::Relation)
+          model_list << {type: :relation, key: key, name: value.ancestors.first.name, sql: value.to_sql.gsub('"','\"')}
+        end
+      end
+      @websocket_options = {
+        models: model_list,
+        command: 'listen'
+      }
+      @id = Digest::MD5.hexdigest(@websocket_options.to_yaml)
+      @websocket_options = {
+        models: model_list,
+        command: 'listen',
+        id: @id
+      }
+    end
+
+    # TODO remove test helper method for ajax update calls.
+    def manual_buttons
+      "<a href='#' onclick='real_time_update_#{@id}();'>Manual Update</a>\n"
+    end
+
+    def load_javascript
+      @remote_f_options = {
+        url: "/render_real_time/id/#{@id}"
+      }
+
+      html = "<script>\n"
+      html += js_after_update
+      html += js_remote_function
+      html += js_start_websocket
+      html += "</script>\n"
+      return html
+    end
+
+
+    # Adds the wrapper for creating the connection to the websocket server as well as registering for the correct channel on the server.
+    def js_start_websocket
+      "
+      ws_#{@id} = new WebSocket('ws://localhost:8080');
+      ws_#{@id}.onmessage = function(evt) { if(evt.data=='update'){real_time_update_#{@id}()}else{alert(evt.data)}; };
+      ws_#{@id}.onclose = function() {  };
+      ws_#{@id}.onopen = function() {
+        ws_#{@id}.send('#{@websocket_options.to_json}');
+      };
+      "
+    end
+
+    def js_after_update
+      if @options[:after_update]
+        @remote_f_options[:complete] = "after_real_time_update_#{@id}();"
+        return "function after_real_time_update_#{@id}(){#{@options[:after_update]}}"
+      else
+        return ""
+      end
+    end
+
+    # Creates the js method wrapper for ajax calls.
+    def js_remote_function
+      "function real_time_update_#{@id}(){
+        #{remote_function(remote_f_options)}
+      }"
+    end
+
+    def wrap_render
+      html = "<div id='#{@id}' class='real_time_wrapper'>\n"
+      html += yield
+      html += @websocket_options.to_yaml # TODO remove debugging data.
+      html += "</div>\n"
+      return html
+    end
+
+    
+    # Writes data to cache for later use in the render_real_time controller.
+    def register_partial
+      Rails.cache.write("real_time_#{@id}", @websocket_options.to_yaml)
+      Rails.cache.write("real_time_#{@id}_options", @options.to_yaml)
+    end
+  end
+end

data/lib/real_time_rails/version.rb

@@ -0,0 +1,5 @@
+module RealTimeRails
+  
+  VERSION = "0.0.2"
+  
+end

data/lib/websocket_server/websocket_server.rb

@@ -0,0 +1,143 @@
+# to start the server just run "ruby websocket_server.rb"
+
+require 'em-websocket'
+require 'json'
+require 'yaml'
+
+class RTChannel < EM::Channel
+  
+  attr_accessor   :id,
+                  :models,
+                  :subscribers
+                  
+  def self.create(id, models)
+    sid = self.new
+    sid.id=id
+    sid.models=models
+    sid.subscribers=[]
+    return sid
+  end
+  
+  def join(subscriber)
+    @subscribers << subscriber
+  end
+  
+  def leave(subscriber, subscription_id)
+    @subscribers.delete(subscriber)
+    self.unsubscribe(subscription_id)
+  end
+  
+end
+
+EventMachine.run {
+
+
+  #$global_channel = EM::Channel.new
+  $channel_list = []
+
+
+  EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080) do |ws|
+    ws.onopen do
+      puts "opened conneciton"
+    end
+    ws.onmessage do |msg|
+      data = JSON.parse(msg)
+      puts "new message:\n#{msg}"
+      @subscriber = data["subscriber"]
+      case data["command"]
+        when "listen"
+          unless @channel = $channel_list.find{|channel| channel.id == data["id"]}
+            @channel = RTChannel.create(data["id"], data["models"])
+            $channel_list << @channel
+          end
+          @sid = @channel.subscribe{|msg| ws.send msg}
+          @channel.join(@subscriber)
+        else
+          puts "unknown command: #{msg}"
+      end
+    end
+    ws.onclose { 
+      # $channel_list.each do |channel|
+      #   if channel.subscribers.include?(@subscriber)
+          @channel.leave(@subscriber, @sid)
+      #   end
+      # end
+    }
+  end
+
+  module MessageServer
+
+      def post_init
+         send_data "connected to update server\n"
+         puts "new connection\n"
+      end
+
+      def unbind
+        #puts "-- someone disconnected from the server!"
+      end
+      
+      def find_channels_by_id(model_name, id =nil)
+        channel_list = []
+        $channel_list.each{|channel| 
+          if models = channel.models.select{|m| m["name"]==model_name}
+            models.each do |m|
+              if (m["type"] == "single") && (m["id"].to_s == id.to_s) && (m["name"] == model_name)
+                channel_list << channel
+              end
+              if (m["type"] == "array") && (m["ids"].map(&:to_s).include?(id.to_s)) && (m["name"] == model_name)
+                channel_list << channel
+              end
+            end
+            
+          end
+        }
+        return channel_list
+      end
+      
+      def find_all_channels(model_name)
+        $channel_list.select{|channel| 
+          channel.models.map{|m| m["name"]}.include?(model_name) &&
+          channel.models.map{|m| m["type"]}.include?("relation")
+        }
+      end
+      
+
+      def receive_data data
+          close_connection if data =~ /quit/i
+          if data =~ /info/i
+            send_data "channels:\n#{$channel_list.to_yaml}\n"
+          else
+            begin
+              command = JSON.parse(data)
+              puts command
+              case command["command"]
+                when "update1"
+                  channels = find_channels_by_id(command["model"], command["id"])
+                  channels.each{|c| c.push "update"}
+                when "updateall"
+                  channels=find_all_channels(command["model"])
+                  channels.each{|c| c.push "update"}
+                when "info"
+                  send_data "channels:\n#{$channel_list.to_yaml}\n"
+                else
+                  puts "unknown command: #{command["command"]}\n"
+                  send_data "unknown command: #{command["command"]}\n"
+              end
+            rescue JSON::ParserError
+              puts "unknown command: \n#{data}"
+              send_data "unknown command:\n#{data}"
+            end
+          end
+      end
+  end
+
+  EventMachine::start_server "0.0.0.0", 2000, MessageServer
+  puts 'Running message server on 2000'
+
+  # is ping needed to keep a connection open?
+  # EventMachine::PeriodicTimer.new(5) do 
+  #   $channel.push "ping"
+  # end
+
+  puts "loaded"
+}

data/real_time_rails.gemspec

@@ -0,0 +1,28 @@
+Gem::Specification.new do |s|
+    s.name = "real_time_rails"
+    s.version = '0.0.2' 
+    s.platform = Gem::Platform::RUBY
+    s.authors = ["Kelly Mahan"]
+    s.email = 'kmahan@kmahan.com'
+    s.summary = 'A gem to enable seamless websocket integration with rails.'
+    s.homepage = 'http://github.com/kellymahan/RealTimeRails'
+    s.description = 'A gem to enable seamless websocket integration with rails.'
+
+
+    s.rubyforge_project = 'real_time_rails'
+
+
+    s.files = `git ls-files`.split("\n")
+    s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+    s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+    s.require_path = 'lib'
+
+
+    s.requirements << "em-websocket"
+    s.requirements << "json"
+    
+
+    s.add_dependency "em-websocket", ">= 0.3.0"
+    s.add_dependency "rails", ">= 3.0.5"
+
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: real_time_rails
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Kelly Mahan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-01 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: em-websocket
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.5
+  type: :runtime
+  version_requirements: *id002
+description: A gem to enable seamless websocket integration with rails.
+email: kmahan@kmahan.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/real_time_rails.rb
+- lib/real_time_rails/ar.rb
+- lib/real_time_rails/real_time_helper.rb
+- lib/real_time_rails/render_real_time_controller.rb
+- lib/real_time_rails/rt_helper.rb
+- lib/real_time_rails/version.rb
+- lib/websocket_server/websocket_server.rb
+- real_time_rails.gemspec
+has_rdoc: true
+homepage: http://github.com/kellymahan/RealTimeRails
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: 
+- em-websocket
+- json
+rubyforge_project: real_time_rails
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A gem to enable seamless websocket integration with rails.
+test_files: []
+