websocket-rails-js 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08228ce10d8e4fb42c6d438673760224b7f01bac
+  data.tar.gz: b9e8c58acee13e1fde180bec6bc5b582a9786d28
+SHA512:
+  metadata.gz: c6d67c1fc3391737d8e2763919d8a84c2edac191fb5564ff295f184c2c88080922a491c44798f406da35e202bb38f52728f52d3752a39b311d8179d5108ff9db
+  data.tar.gz: f1e815c159b453a6fefec193f2213e129fe7e8e2676e9d9184cd2e1ff0e9ba665e85f72ec3a1249c91f757ba416105b8b3a66b45889a8d4da15f72dcbdebf90f

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/javascripts/generated/*.js
+spec/javascripts/helpers/*.js

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in websocket-rails-js.gemspec
+gemspec
+
+gem 'guard'
+gem 'guard-coffeescript'
+gem 'terminal-notifier-guard'
+
+gem 'jasmine'
+gem 'uglifier'

data/Guardfile

@@ -0,0 +1,6 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'coffeescript', :input => 'assets/javascripts', :output => 'src/'
+guard 'coffeescript', :input => 'spec/javascripts/websocket_rails', :output => 'spec/javascripts/generated'
+guard 'coffeescript', :input => 'spec/javascripts/helpers', :output => 'spec/javascripts/helpers'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dan Knox
+
+MIT License
+
+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,13 @@
+# Websocket Rails JavaScript Client
+
+Refer to the [Websocket-Rails
+Wiki](https://github.com/websocket-rails/websocket-rails/wiki) for usage
+instructions.
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/websocket-rails-js/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,36 @@
+require "bundler/gem_tasks"
+require 'websocket_rails/js/version'
+require "uglifier"
+require 'jasmine'
+
+load 'jasmine/tasks/jasmine.rake'
+
+
+task :build_js_release do
+  PATH = 'src/websocket_rails/'
+
+  SOURCE_FILES = %w(
+    websocket_rails.js
+    event.js
+    abstract_connection.js
+    websocket_connection.js
+    channel.js
+  )
+
+  tempfile = Tempfile.new('websocket_rails.min.js')
+
+  SOURCE_FILES.each do |fname|
+    tempfile.write(File.read(PATH + fname))
+  end
+  tempfile.rewind
+
+  uglifier = Uglifier.new(:mangle => false)
+
+  uglified = uglifier.compile(tempfile.read)
+
+  tempfile.unlink
+
+  File.open("websocket_rails.#{WebsocketRails::Js::VERSION}.min.js", "w+") do |f|
+    f.write(uglified)
+  end
+end

data/app/assets/javascripts/websocket_rails/abstract_connection.js.coffee

@@ -0,0 +1,45 @@
+###
+ Abstract Interface for the WebSocketRails client.
+###
+class WebSocketRails.AbstractConnection
+
+  constructor: (url, @dispatcher) ->
+    @message_queue   = []
+
+  close: ->
+
+  trigger: (event) ->
+    if @dispatcher.state != 'connected'
+      @message_queue.push event
+    else
+      @send_event event
+
+  send_event: (event) ->
+    # Events queued before connecting do not have the correct
+    # connection_id set yet. We need to update it before dispatching.
+    event.connection_id = @connection_id if @connection_id?
+
+    # ...
+
+  on_close: (event) ->
+    if @dispatcher && @dispatcher._conn == @
+      close_event = new WebSocketRails.Event(['connection_closed', event])
+      @dispatcher.state = 'disconnected'
+      @dispatcher.dispatch close_event
+
+  on_error: (event) ->
+    if @dispatcher && @dispatcher._conn == @
+      error_event = new WebSocketRails.Event(['connection_error', event])
+      @dispatcher.state = 'disconnected'
+      @dispatcher.dispatch error_event
+
+  on_message: (event_data) ->
+    if @dispatcher && @dispatcher._conn == @
+      @dispatcher.new_message event_data
+
+  setConnectionId: (@connection_id) ->
+
+  flush_queue: ->
+    for event in @message_queue
+      @trigger event
+    @message_queue = []

data/app/assets/javascripts/websocket_rails/channel.js.coffee

@@ -0,0 +1,66 @@
+###
+The channel object is returned when you subscribe to a channel.
+
+For instance:
+  var dispatcher = new WebSocketRails('localhost:3000/websocket');
+  var awesome_channel = dispatcher.subscribe('awesome_channel');
+  awesome_channel.bind('event', function(data) { console.log('channel event!'); });
+  awesome_channel.trigger('awesome_event', awesome_object);
+###
+class WebSocketRails.Channel
+
+  constructor: (@name, @_dispatcher, @is_private, @on_success, @on_failure) ->
+    if @is_private
+      event_name = 'websocket_rails.subscribe_private'
+    else
+      event_name = 'websocket_rails.subscribe'
+
+    @connection_id = @_dispatcher._conn?.connection_id
+    event = new WebSocketRails.Event([event_name, {channel: @name}, {connection_id: @connection_id}], @_success_launcher, @_failure_launcher)
+    @_dispatcher.trigger_event event
+    @_callbacks = {}
+    @_token = undefined
+    @_queue = []
+
+  is_public: ->
+    !@is_private
+
+  destroy: ->
+    if @connection_id == @_dispatcher._conn?.connection_id
+      event_name = 'websocket_rails.unsubscribe'
+      event =  new WebSocketRails.Event([event_name, {channel: @name}, {connection_id: @connection_id, token: @_token}])
+      @_dispatcher.trigger_event event
+    @_callbacks = {}
+
+  bind: (event_name, callback) ->
+    @_callbacks[event_name] ?= []
+    @_callbacks[event_name].push callback
+
+  unbind: (event_name) ->
+    delete @_callbacks[event_name]
+
+  trigger: (event_name, message) ->
+    event = new WebSocketRails.Event([event_name, message, {connection_id: @connection_id, channel: @name, token: @_token}])
+    if !@_token
+      @_queue.push event
+    else
+      @_dispatcher.trigger_event event
+
+  dispatch: (event_name, message) ->
+    if event_name == 'websocket_rails.channel_token'
+      @_token = message['token']
+      for event in @_queue
+        @_dispatcher.trigger_event event
+      @_queue = []
+    else
+      return unless @_callbacks[event_name]?
+      for callback in @_callbacks[event_name]
+        callback message
+
+  # using this method because @on_success will not be defined when the constructor is executed
+  _success_launcher: (data) =>
+    @on_success(data) if @on_success?
+
+  # using this method because @on_failure will not be defined when the constructor is executed
+  _failure_launcher: (data) =>
+    @on_failure(data) if @on_failure?

data/app/assets/javascripts/websocket_rails/connection.js.coffee

@@ -0,0 +1,62 @@
+###
+WebSocket Interface for the WebSocketRails client.
+###
+class WebSocketRails.Connection
+
+  constructor: (@url, @dispatcher) ->
+    @message_queue = []
+    @state = 'connecting'
+    @connection_id
+
+
+    unless @url.match(/^wss?:\/\//) || @url.match(/^ws?:\/\//)
+      if window.location.protocol == 'https:'
+        @url = "wss://#{@url}"
+      else
+        @url = "ws://#{@url}"
+
+    @_conn = new WebSocket(@url)
+
+    @_conn.onmessage = (event) =>
+      event_data = JSON.parse event.data
+      @on_message(event_data)
+
+    @_conn.onclose = (event) =>
+      @on_close(event)
+
+    @_conn.onerror = (event) =>
+      @on_error(event)
+
+  on_message: (event) ->
+    @dispatcher.new_message event
+
+  on_close: (event) ->
+    @dispatcher.state = 'disconnected'
+    # Pass event.data here if this was triggered by the WebSocket directly
+    data = if event?.data then event.data else event
+    @dispatcher.dispatch new WebSocketRails.Event(['connection_closed', data])
+
+  on_error: (event) ->
+    @dispatcher.state = 'disconnected'
+    # Pass event.data here since this was triggered by the WebSocket directly
+    @dispatcher.dispatch new WebSocketRails.Event(['connection_error', event.data])
+
+  trigger: (event) ->
+    if @dispatcher.state != 'connected'
+      @message_queue.push event
+    else
+      @send_event event
+
+  close: ->
+    @_conn.close()
+
+  setConnectionId: (connection_id) ->
+    @connection_id = connection_id
+
+  send_event: (event) ->
+    @_conn.send event.serialize()
+
+  flush_queue: ->
+    for event in @message_queue
+      @trigger event
+    @message_queue = []

data/app/assets/javascripts/websocket_rails/event.js.coffee

@@ -0,0 +1,43 @@
+###
+The Event object stores all the relevant event information.
+###
+
+class WebSocketRails.Event
+
+  constructor: (message, @success_callback, @failure_callback) ->
+    @name   = message[0]
+    @data   = message[1]
+    options = message[2]
+
+    if options?
+      @id = if options['id']? then options['id'] else (((1+Math.random())*0x10000)|0)
+      @channel = options.channel
+      @token = options.token
+      @connection_id = options.connection_id
+      if options.success?
+        @result  = true
+        @success = options.success
+
+  is_channel: ->
+    @channel?
+
+  is_result: ->
+    typeof @result != 'undefined'
+
+  is_ping: ->
+    @name == 'websocket_rails.ping'
+
+  serialize: ->
+    JSON.stringify [@name, @data, @meta_data()]
+
+  meta_data: ->
+    id: @id,
+    connection_id: @connection_id,
+    channel: @channel,
+    token: @token
+
+  run_callbacks: (@success, @result) ->
+    if @success == true
+      @success_callback?(@result)
+    else
+      @failure_callback?(@result)

data/app/assets/javascripts/websocket_rails/http_connection.js.coffee

@@ -0,0 +1,56 @@
+###
+ HTTP Interface for the WebSocketRails client.
+###
+class WebSocketRails.HttpConnection extends WebSocketRails.AbstractConnection
+  connection_type: 'http'
+
+  _httpFactories: -> [
+    -> new XMLHttpRequest(),
+    -> new ActiveXObject("Msxml2.XMLHTTP"),
+    -> new ActiveXObject("Msxml3.XMLHTTP"),
+    -> new ActiveXObject("Microsoft.XMLHTTP")
+  ]
+
+  constructor: (url, @dispatcher) ->
+    super
+    @_url          = "http://#{url}"
+    @_conn         = @_createXMLHttpObject()
+    @last_pos      = 0
+    @_conn.onreadystatechange = => @_parse_stream()
+    @_conn.addEventListener("load", @on_close, false)
+    @_conn.open "GET", @_url, true
+    @_conn.send()
+
+  close: ->
+    @_conn.abort()
+
+  send_event: (event) ->
+    super
+    @_post_data event.serialize()
+
+  _post_data: (payload) ->
+    $.ajax @_url,
+      type: 'POST'
+      data:
+        client_id: @connection_id
+        data: payload
+      success: ->
+
+  _createXMLHttpObject: ->
+    xmlhttp   = false
+    factories = @_httpFactories()
+    for factory in factories
+      try
+        xmlhttp = factory()
+      catch e
+        continue
+      break
+    xmlhttp
+
+  _parse_stream: ->
+    if @_conn.readyState == 3
+      data         = @_conn.responseText.substring @last_pos
+      @last_pos    = @_conn.responseText.length
+      data = data.replace( /\]\]\[\[/g, "],[" )
+      event_data = JSON.parse data
+      @on_message(event_data)

data/app/assets/javascripts/websocket_rails/main.js

@@ -0,0 +1,6 @@
+//= require ./websocket_rails
+//= require ./event
+//= require ./abstract_connection
+//= require ./http_connection
+//= require ./websocket_connection
+//= require ./channel

data/app/assets/javascripts/websocket_rails/websocket_connection.js.coffee

@@ -0,0 +1,29 @@
+###
+WebSocket Interface for the WebSocketRails client.
+###
+class WebSocketRails.WebSocketConnection extends WebSocketRails.AbstractConnection
+  connection_type: 'websocket'
+
+  constructor: (@url, @dispatcher) ->
+    super
+    if @url.match(/^wss?:\/\//)
+        console.log "WARNING: Using connection urls with protocol specified is depricated"
+    else if window.location.protocol == 'https:'
+        @url             = "wss://#{@url}"
+    else
+        @url             = "ws://#{@url}"
+    @_conn           = new WebSocket(@url)
+    @_conn.onmessage = (event) =>
+      event_data = JSON.parse event.data
+      @on_message(event_data)
+    @_conn.onclose   = (event) =>
+      @on_close(event)
+    @_conn.onerror   = (event) =>
+      @on_error(event)
+
+  close: ->
+    @_conn.close()
+
+  send_event: (event) ->
+    super
+    @_conn.send event.serialize()

data/app/assets/javascripts/websocket_rails/websocket_rails.js.coffee

@@ -0,0 +1,148 @@
+###
+WebsocketRails JavaScript Client
+
+Setting up the dispatcher:
+  var dispatcher = new WebSocketRails('localhost:3000/websocket');
+  dispatcher.on_open = function() {
+    // trigger a server event immediately after opening connection
+    dispatcher.trigger('new_user',{user_name: 'guest'});
+  })
+
+Triggering a new event on the server
+  dispatcherer.trigger('event_name',object_to_be_serialized_to_json);
+
+Listening for new events from the server
+  dispatcher.bind('event_name', function(data) {
+    console.log(data.user_name);
+  });
+
+Stop listening for new events from the server
+  dispatcher.unbind('event')
+###
+class @WebSocketRails
+  constructor: (@url, @use_websockets = true) ->
+    @callbacks = {}
+    @channels  = {}
+    @queue     = {}
+
+    @connect()
+
+  connect: ->
+    @state = 'connecting'
+
+    unless @supports_websockets() and @use_websockets
+      @_conn = new WebSocketRails.HttpConnection @url, this
+    else
+      @_conn = new WebSocketRails.WebSocketConnection @url, this
+
+    @_conn.new_message = @new_message
+
+  disconnect: ->
+    if @_conn
+      @_conn.close()
+      delete @_conn._conn
+      delete @_conn
+
+    @state     = 'disconnected'
+
+  # Reconnects the whole connection,
+  # keeping the messages queue and its' connected channels.
+  #
+  # After successfull connection, this will:
+  # - reconnect to all channels, that were active while disconnecting
+  # - resend all events from which we haven't received any response yet
+  reconnect: =>
+    old_connection_id = @_conn?.connection_id
+
+    @disconnect()
+    @connect()
+
+    # Resend all unfinished events from the previous connection.
+    for id, event of @queue
+      if event.connection_id == old_connection_id && !event.is_result()
+        @trigger_event event
+
+    @reconnect_channels()
+
+  new_message: (data) =>
+    event = new WebSocketRails.Event(data)
+    if event.is_result()
+      @queue[event.id]?.run_callbacks(event.success, event.data)
+      @queue[event.id] = null
+    else if event.is_channel()
+      @dispatch_channel event
+    else
+      @dispatch event
+
+    if @state == 'connecting' and event.name == 'client_connected'
+      @connection_established event
+
+  connection_established: (event) =>
+    @state = 'connected'
+    @_conn.setConnectionId(event.connection_id)
+    @_conn.flush_queue()
+    if @on_open?
+      @on_open(event.data)
+
+  bind: (event_name, callback) =>
+    @callbacks[event_name] ?= []
+    @callbacks[event_name].push callback
+
+  trigger: (event_name, data, success_callback, failure_callback) =>
+    event = new WebSocketRails.Event([event_name, data, {connection_id: @connection_id}], success_callback, failure_callback)
+    @queue[event.id] = event
+    @_conn.trigger event
+
+  trigger_event: (event) =>
+    @queue[event.id] ?= event # Prevent replacing an event that has callbacks stored
+    @_conn.trigger event
+    event
+
+  dispatch: (event) =>
+    return unless @callbacks[event.name]?
+    for callback in @callbacks[event.name]
+      callback event.data
+
+  subscribe: (channel_name, success_callback, failure_callback) =>
+    unless @channels[channel_name]?
+      channel = new WebSocketRails.Channel channel_name, @, false, success_callback, failure_callback
+      @channels[channel_name] = channel
+      channel
+    else
+      @channels[channel_name]
+
+  subscribe_private: (channel_name, success_callback, failure_callback) =>
+    unless @channels[channel_name]?
+      channel = new WebSocketRails.Channel channel_name, @, true, success_callback, failure_callback
+      @channels[channel_name] = channel
+      channel
+    else
+      @channels[channel_name]
+
+  unsubscribe: (channel_name) =>
+    return unless @channels[channel_name]?
+    @channels[channel_name].destroy()
+    delete @channels[channel_name]
+
+  dispatch_channel: (event) =>
+    return unless @channels[event.channel]?
+    @channels[event.channel].dispatch event.name, event.data
+
+  supports_websockets: =>
+    (typeof(WebSocket) == "function" or typeof(WebSocket) == "object")
+
+  connection_stale: =>
+    @state != 'connected'
+
+  reconnect_channels: ->
+    for name, channel of @channels
+      callbacks = channel._callbacks
+      channel.destroy()
+      delete @channels[name]
+
+      channel = if channel.is_private
+        @subscribe_private name
+      else
+        @subscribe name
+      channel._callbacks = callbacks
+      channel