RubyGems - rocket-js - Versions diffs - 0.0.1 - Mend

rocket-js 0.0.1

Files changed (30) hide show

data/.gitignore +24 -0
data/LICENSE +20 -0
data/README.md +1 -0
data/Rakefile +70 -0
data/bin/rocket-js +13 -0
data/lib/rocket-js.rb +2 -0
data/lib/rocket/js.rb +8 -0
data/lib/rocket/js/builder.rb +83 -0
data/lib/rocket/js/cli.rb +24 -0
data/lib/rocket/js/version.rb +14 -0
data/rocket-0.0.1.min.js +45 -0
data/rocket-js.gemspec +84 -0
data/spec/js/app.rb +15 -0
data/spec/js/public/WebSocketMain.swf +0 -0
data/spec/js/public/favicon.ico +0 -0
data/spec/js/public/jquery-1.4.2.min.js +154 -0
data/spec/js/public/qunit.css +119 -0
data/spec/js/public/qunit.js +1069 -0
data/spec/js/public/test.js +131 -0
data/spec/js/public/testing/WebSocketMain.swf +0 -0
data/spec/js/public/testing/WebSocketMainInsecure.zip +0 -0
data/spec/js/public/testing/rocket-0.0.1.js +1445 -0
data/spec/js/views/index.erb +40 -0
data/spec/ruby/spec_helper.rb +8 -0
data/src/rocket.channels.js +127 -0
data/src/rocket.core.js +213 -0
data/src/rocket.defaults.js +50 -0
data/src/rocket.license.js +42 -0
data/src/vendor/json/json2.js +482 -0
metadata +175 -0

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html>
+<head>
+<link rel="stylesheet" href="/qunit.css">
+<script src="/qunit.js"></script>
+<script src="/jquery-1.4.2.min.js"></script>
+<script src="/testing/rocket-<%= Rocket::JS.version %>.js"></script>
+<script>
+  // The web-socket-js configuration.
+  WEB_SOCKET_SWF_LOCATION = 'rocket/WebSocketMain.swf';
+  WEB_SOCKET_DEBUG = false;
+  $(document).ready(function() {
+    // Logger...
+    Rocket.log = function(msg) { $("#log").append("<li>"+msg+"</li>") };
+    // Build new rocket
+    rocket = new Rocket('ws://localhost:9772', 'test_app');
+    // Subscribe a channel.
+    testChannel = rocket.subscribe('test-channel');
+    // Bind callback to event.
+    //testChannel.bind('test-event', function(data) {
+    //  alert('hello!');
+    //});
+  });
+</script>
+</head>
+<body>
+  <ul id="log">
+  <ul>
+<!--
+  <h1 id="qunit-header">Pusher Tests</h1>
+  <h2 id="qunit-banner"></h2>
+  <h2 id="qunit-userAgent"></h2>
+  <ol id="qunit-tests"></ol>
+-->
+</body>
+</html>

data/spec/ruby/spec_helper.rb ADDED

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'mocha'
+require 'rspec'
+require 'rocket-js'
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

data/src/rocket.channels.js ADDED

@@ -0,0 +1,127 @@
+/**
+ * This object helps with channels management. Examples:
+ *
+ *   channels = new Rocket.Channels();
+ *   channels.add('test');
+ *   channels.find('test');
+ *   channels.remove('test');
+ *   // ...
+ *
+ * @class
+ * @constructor
+ */
+Rocket.Channels = function() {
+  this.all = {};
+};
+Rocket.Channels.prototype = {
+  /**
+   * Append new channel to the list of registered.
+   *
+   * @param {string} channelName
+   * @return Rocket.Channel
+   */
+  add: function(channelName) {
+    existingChannel = this.find(channelName)
+    if (!existingChannel) {
+      return (this.all[channelName] = new Rocket.Channel());
+    } else {
+      return existingChannel;
+    }
+  },
+  /**
+   * Returns channel with specified name when it exists.
+   *
+   * @param {string} channelName
+   * @return Rocket.Channel
+   */
+  find: function(channelName) {
+    return this.all[channelName];
+  },
+  /**
+   * Remove specified channel from the list.
+   *
+   * @param {string} channelName
+   * @return void
+   */
+  remove: function(channelName) {
+    delete this.all[channelName];
+  }
+};
+/**
+ * Single channel. It keeps eg. list of callbacks for all binded events,
+ * and helps with events dispatching.
+ *
+ *   channel = new Rocket.Channel();
+ *   channel.bind('my-event', function(data) {
+ *     // do something with given data ...
+ *   })
+ *
+ * @class
+ * @constructor
+ */
+Rocket.Channel = function() {
+  this.callbacks = {};
+  this.globalCallbacks = [];
+};
+Rocket.Channel.prototype = {
+  /**
+   * Assign callback to given event. More than one callback can be assigned
+   * to one event, eg:
+   *
+   *   channel.bind('my-event', function(data){ alert('first one!') });
+   *   channel.bind('my-event', function(data){ alert('second one!') });
+   *
+   * @param {string} eventName
+   * @param {function} callback
+   * @return self
+   */
+  bind: function(eventName, callback) {
+    this.callbacks[eventName] = this.callbacks[eventName] || [];
+    this.callbacks[eventName].push(callback);
+    return this;
+  },
+  /**
+   * Creates global callback which will be invoked on all events just after
+   * processing callbacks assigned to it.
+   *
+   *   channel.bindAll(function(event, data){ alert(event) });
+   *
+   * @param {function} callback
+   * @return self
+   */
+  bindAll: function(callback) {
+    this.globalCallbacks.push(callback);
+    return this;
+  },
+  /**
+   * Dispatch given event with passing data to all registered callbacks.
+   * All global callbacks will be called here too.
+   *
+   *   channel.dispatch('my-event', {'hello': 'world'});
+   *
+   * @param {string} eventName
+   * @param {Object} eventData
+   * @return void
+   */
+  dispatch: function(eventName, eventData) {
+    var callbacks = this.callbacks[eventName]
+    if (callbacks) {
+      Rocket.log('Rocket : executing callbacks for ' + eventName)
+      for (var i = 0; i < callbacks.length; i++) {
+        callbacks[i](eventData);
+      }
+    } else if (!this.isGlobal) {
+      Rocket.log('Rocket : no callbacks for ' + eventName)
+    }
+    for (var i = 0; i < this.globalCallbacks.length; i++) {
+      this.globalCallbacks[i](eventName, eventData);
+    }
+  }
+};

data/src/rocket.core.js ADDED

@@ -0,0 +1,213 @@
+/**
+ * Rocket base class. Examples:
+ *
+ *   rocket = new Rocket('ws://host.com:8080', 'my-app'); // no trailing slash in url!
+ *   rocket = new Rocket('wss://host.com:433', 'my-secured-app');
+ *
+ * @class
+ * @constructor
+ */
+var Rocket = function(url, appID) {
+  this.socketId;
+  this.url = url + '/app/' + appID;
+  this.appID = appID;
+  this.channels = new Rocket.Channels();
+  this.retryCounter = 0;
+  this.isConnected = false;
+  this.globalChannel = new Rocket.Channel();
+  this.globalChannel.isGlobal = true
+  this.connect();
+  var self = this;
+  this.globalChannel.bind('rocket:connected', function(data) {
+    self.isConnected = true;
+    self.retryCounter = 0;
+    self.socketId = data.socket_id;
+    self.subscribeAll();
+  });
+  this.globalChannel.bind('rocket:error', function(data) {
+    //self.log("Rocket : error : " + data.message);
+  });
+};
+Rocket.prototype = {
+  /**
+   * Establish connection with specified web socket server.
+   *
+   * @return self
+   */
+  connect: function() {
+    Rocket.log('Rocket : connecting with ' + this.url);
+    this.allowReconnect = true
+    var self = this;
+    if (window["WebSocket"]) {
+      this.connection = new WebSocket(this.url);
+      this.connection.onmessage = function(msg) { self.onmessage(msg); };
+      this.connection.onclose = function() { self.onclose(); };
+      this.connection.onopen = function() { self.onopen(); };
+    } else {
+      Rocket.log("Rocket : can't establish connection")
+      this.connection = {};
+      this.onclose();
+    }
+    return this;
+  },
+  /**
+   * Close connection with web socket server and cleanup configuration.
+   *
+   * @return self
+   */
+  disconnect: function() {
+    Rocket.log('Rocket : disconnecting');
+    this.allowReconnect = false;
+    this.isConnected = false;
+    this.retryCount = 0;
+    this.connection.close();
+    return this;
+  },
+  /**
+   * Trying reconnect to socket after specified time.
+   *
+   * @param {integer} delay
+   * @return self
+   */
+  reconnect: function(delay) {
+    var self = this;
+    setTimeout(function(){ self.connect(); }, delay);
+    return this;
+  },
+  /**
+   * Searches for given channel and return it when exists.
+   *
+   * @param {string} channelName
+   * @return Rocket.Channel
+   */
+  channel: function(channelName) {
+    return this.channels.find(channelName)
+  },
+  /**
+   * Trigger given event by sending specified data.
+   *
+   *   rocket.trigger('rocket:unsubscribe', { channel: 'my-channel' });
+   *
+   * @param {string} eventName
+   * @param {Object} data
+   * @return self
+   */
+  trigger: function(eventName, data) {
+    if (this.isConnected) {
+      var payload = JSON.stringify({ event: eventName, data: data });
+      Rocket.log("Rocket : triggering event : " + payload);
+      this.connection.send(payload);
+    } else {
+      Rocket.log("Rocket : not connected : can't trigger event " + eventName);
+    }
+    return this;
+  },
+  /**
+   * Subscribes specified channel and returns it.
+   *
+   *   myChannel = rocket.subscribe('my-channel');
+   *   myChannel.bind('my-event', function(data) {
+   *     // do something with received data...
+   *   });
+   *
+   * @param {string} channelName
+   * @return Rocket.Channel
+   */
+  subscribe: function(channelName) {
+    var channel = this.channels.add(channelName);
+    this.trigger('rocket:subscribe', { channel: channelName });
+    return channel;
+  },
+  /**
+   * Unsubscribes specified channel.
+   *
+   *   myChannel = rocket.subscribe('my-channel');
+   *   myChannel.bind('unsubscribe', function(data) {
+   *     rocket.unsubscribe('my-channel');
+   *   });
+   *
+   * @param {string} channelName
+   * @return self
+   */
+  unsubscribe: function(channelName) {
+    this.channels.remove(channelName);
+    this.trigger('rocket:unsubscribe', { channel: channelName });
+    return this;
+  },
+  /**
+   * Subscribe all registered channels. It's usualy used to subscribe all
+   * registered just after open connetion (or to re-subscribe after reconnect).
+   *
+   * @return void
+   */
+  subscribeAll: function() {
+    for (var channel in this.channels.all) {
+      if (this.channels.all.hasOwnProperty(channel)) {
+        this.subscribe(channel);
+      }
+    };
+  },
+  /**
+   * Callback invoked when conneciton is closed.
+   *
+   * @return void
+   */
+  onclose: function() {
+    Rocket.log("Rocket : socket closed");
+    this.globalChannel.dispatch('rocket:close', null);
+    var time = Rocket.reconnectDelay;
+    if (!(this.isConnected)) {
+      this.globalChannel.dispatch("rocket:disconnected", {});
+      if (Rocket.allowReconnect) {
+        Rocket.log('Pusher : reconnecting in 5 seconds...');
+        this.reconnect(time);
+      }
+    } else {
+      this.globalChannel("rocket:connection_failed", {});
+      if (this.retryCounter == 0){
+        time = 100;
+      }
+      this.retryCounter = this.retryCounter + 1
+      this.reconnect(time);
+    }
+    this.connected = false;
+  },
+  /**
+   * Callback invoked when connection is established.
+   *
+   * @return void
+   */
+  onopen: function() {
+    this.globalChannel.dispatch('rocket:open', null);
+  },
+  /**
+   * Callback invoked when message is received.
+   *
+   * @param {string} msg
+   * @return void
+   */
+  onmessage: function(msg) {
+    Rocket.log("Rocket : received message : " + msg.data)
+    var params = JSON.parse(msg.data);
+    var channel = params.channel ? this.channel(params.channel) : this.globalChannel;
+    channel.dispatch(params.event, params.data);
+  },
+};

data/src/rocket.defaults.js ADDED

@@ -0,0 +1,50 @@
+// The web-socket-js default configuration.
+// Where your WebSocketMain.swf is located?
+var WEB_SOCKET_SWF_LOCATION = 'WebSocketMain.swf';
+// Run web socket in debug mode?
+var WEB_SOCKET_DEBUG = false;
+// Rocket defaults.
+/**
+ * How many miliseconds system will wait until next reconnect try.
+ *
+ * @type integer
+ */
+Rocket.reconnectDelay = 5000;
+/**
+ * Allow socket reconnect?
+ *
+ * @type boolean
+ */
+Rocket.allowReconnect = true;
+/**
+ * Default logger. You can replace it with your own, eg.
+ *
+ *   Rocket.log = function(msg) { console.log(msg) };
+ *
+ * @param {string} msg
+ * @return void
+ */
+Rocket.log = function(msg) {
+  // nothing to do...
+};
+/**
+ * Default data parser. By default received data is treated as JSON. You
+ * can change this behaviour by replacing this parser.
+ *
+ * @param {string} data
+ * @return Object or string
+ */
+Rocket.parser = function(data) {
+  try {
+    return JSON.parse(data);
+  } catch(e) {
+    Pusher.log("Rocket : data attribute not valid JSON - you may wish to implement your own Rocket.parser");
+    return data;
+  }
+};

data/src/rocket.license.js ADDED

@@ -0,0 +1,42 @@
+/**
+ * Rocket JavaScript Library v<%= VERSION %>
+ *
+ * Copyright 2010, Araneo Ltd. <http://www.araneo.pl>
+ * Released under the MIT license.
+ *
+ * Author: Chris Kowalik <chris@nu7hat.ch>
+ */
+/**
+ * This code is strongly inspired by and based on the Pusher JavaScript Library.
+ *
+ * Pusher JavaScript Library:
+ *
+ *   Copyright 2010, New Bamboo <http://new-bamboo.co.uk/>
+ *   Released under the MIT licence.
+ *   Reference: http://pusherapp.com
+ *
+ * This library contains also code with the following licences:
+ *
+ * web_socket.js:
+ *
+ *   Copyright: Hiroshi Ichikawa <http://gimite.net/en/>
+ *   License: New BSD License
+ *   Reference: http://dev.w3.org/html5/websockets/
+ *   Reference: http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol
+ *
+ * swfobject.js:
+ *
+ *   SWFObject v2.2 <http://code.google.com/p/swfobject/>
+ *   is released under the MIT License <http://www.opensource.org/licenses/mit-license.php>
+ *
+ * FABridge.js:
+ *
+ *   Copyright 2006 Adobe Systems Incorporated
+ *
+ *   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.
+ */