plezi 0.12.18 → 0.12.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f4a5058846b5a4228065d751c7bc7019a1b505b
-  data.tar.gz: 96ab017b8e3d590173fea18733bd018e6f857590
+  metadata.gz: 9f3d155857b95dc2f0f7a16994780b14ac4cdf1a
+  data.tar.gz: e7a44459df52631f7893c15338da94b4f1e464c7
 SHA512:
-  metadata.gz: f696aabd61dfca64e7aad33eb98487421518fa830f31ca2289e852d4f6842d52f9a6cf868879aa9f52332f6eaac3dca7b5c5cc2df04b8dcb966a39be42de7c88
-  data.tar.gz: cbb3aa6d07560314171fcdab50b63062ac74c13a7c88b9b7f1de85f59d1cd2fb3f230975ca3361f7afa290942032499a8eaaabeeeb7da562d96f7372303cb692
+  metadata.gz: c502627effcdaf0b6e4478122349236524f095f76184c0691f3902ac96a52c7d0afe4027e096a69e3ed34f8b1c31fe893cee7fddf8ab50aea2ec21070649b410
+  data.tar.gz: daafec0faebb5c8eeecd8be08b47ea15f13935c2c0a1be902cccaebeb0dbf4fb1642174bf9f65ebb6ec74ca15f1ee1a026524202904053779fff279d774e37c4

data/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ***
 
+Change log v.0.12.19
+
+**Updates**: Auto-Dispatch updates:
+
+* Updated the Auto-Dispatch API conventions, so that the client and the server conventions are the same (both map events to methods with the same name (without the `on` prefix) and map unknown events to the `unknown` callback).
+
+* Auto-Dispatch callbacks can return a Hash as well as a String when the return value is meant to be written to the websockets.
+
+* Auto-Dispatch sends an `_ack_` event whenever an event contains an event ID (`_EID_`) property.
+
+* Auto-Dispatch client's `emit` supports timeout callbacks (for easier fallback to AJAX).
+
+* A `:client` route allows serving Auto-Dispatch's updated client rather than the original client provided in the template. This allows the application to serve the updated client when Plezi is updated.
+
+***
+
 Change log v.0.12.18
 
 **Feature**: Auto-dispatching allows, when enabled, to automatically map JSON websocket messages to controller methods, according to their `event` property. Also, when using the auto-dispatch, Plezi will automatically send the returned value for dispatch methods that return a String (just like when using Http). This means that unifying Websocket and RESTful APIs is now easier than ever.

data/bin/plezi

@@ -50,7 +50,6 @@ end
 if ARGV[0] == 'new' || ARGV[0] == 'n' || ARGV[0] == "force" || ARGV[0] == 'mini' || ARGV[0] == 'm' 
 	#########
 	## set up building environment
-	NO_PLEZI_AUTO_START = true
 	ARGV[1] = ARGV[1].gsub /[^a-zA-Z0-9]/, '_'
 	if Dir.exists?(ARGV[1]) && ARGV[0] != "force"
 		puts ""

data/lib/plezi/common/api.rb

@@ -13,6 +13,11 @@ module Plezi
 
 	# adds a route to the last server created
 	def route(path, controller = nil, &block)
+		if controller == :client
+			client_path = File.expand_path(File.join('..','..','..','..','resources','plezi_client.js'), __FILE__)
+			controller = nil
+			block = Proc.new {  Plezi.cache_needs_update?(client_path) ? Plezi.reload_file(client_path) : Plezi.load_file(client_path) }
+		end
 		::Plezi::Base::HTTPRouter.add_route path, controller, &block
 	end
 

data/lib/plezi/handlers/controller_core.rb

@@ -56,6 +56,7 @@ module Plezi
 					end
 					begin
 						data = JSON.parse data
+						return close unless data.is_a?(Hash)
 					rescue
 						return close
 					end
@@ -64,12 +65,22 @@ module Plezi
 							Plezi::Base::WSObject::SuperInstanceMethods.instance_methods +
 							Plezi::ControllerMagic::InstanceMethods.instance_methods +
 							Plezi::Base::ControllerCore::InstanceMethods.instance_methods +
-							[:before, :after, :initialize]) ).delete_if {|m| m.to_s[0] == '_'}).to_set unless self.class.instance_variable_get(:@allow_dispatch)
+							[:before, :after, :initialize, :unknown , :unknown_event]) ).delete_if {|m| m.to_s[0] == '_'}).to_set unless self.class.instance_variable_get(:@allow_dispatch)
 					Plezi::Base::Helpers.make_hash_accept_symbols data
-					unless self.class.has_super_method?(data['event'.freeze] = data['event'.freeze].to_s.to_sym) && self.class.instance_variable_get(:@allow_dispatch).include?(data['event'.freeze])
-						return (self.class.has_super_method?(:unknown_event) && ( unknown_event(data) || true)) || write({ event: :err, status: 404, result: "not found", request: data }.to_json)
+					ret = nil
+					begin
+						if data['_EID_'.freeze]
+							write "{\"event\":\"_ack_\",\"_EID_\":#{data['_EID_'.freeze]}}"
+						end
+						if self.class.has_super_method?(data['event'.freeze] = data['event'.freeze].to_s.to_sym) && self.class.instance_variable_get(:@allow_dispatch).include?(data['event'.freeze])
+							ret = self.__send__(data['event'.freeze], data)
+						else
+							ret = (self.class.has_super_method?(:unknown) && ( unknown(data) || true)) || (self.class.has_super_method?(:unknown_event) && Iodine.warn('Auto-Dispatch API updated: use `unknown` instead of `unknown_event`') && ( unknown_event(data) || true)) || ({ event: :err, status: 404, result: "not found", request: data }.to_json)
+						end
+					rescue ArgumentError => e
+						Iodine.error "Auto-Dispatch Error for event :#{data['event'.freeze]} - #{e.message}"
 					end
-					ret = self.__send__(data['event'.freeze], data)
+					ret = ret.to_json if ret.is_a?(Hash)
 					write(ret) if ret.is_a?(String)
 				end 
 

data/lib/plezi/handlers/ws_object.rb

@@ -103,6 +103,13 @@ module Plezi
 					(@ws_io || @response) << data
 				end
 
+				# @!visibility public
+				# Closes the connection
+				def close
+					# @request[:io] contains the Websockets Protocol instance
+					(@ws_io || @request[:io]).go_away
+				end
+
 				# @!visibility public
 				# Performs a websocket unicast to the specified target.
 				def unicast target_uuid, method_name, *args

data/lib/plezi/version.rb

@@ -1,3 +1,3 @@
 module Plezi
-    VERSION = "0.12.18"
+    VERSION = "0.12.19"
 end

data/plezi.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "iodine", "~> 0.1.18"
+  spec.add_dependency "iodine", "~> 0.1.19"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 

data/resources/plezi_client.js

@@ -1,7 +1,9 @@
 // This is a commonly used structure for WebSocket messanging.
+// The documentation is available on the www.plezi.io website:
+// http://www.plezi.io/docs/websockets#websocket-json-auto-dispatch
 //
-// To open a websocket connection to the current location
-// (i.e, "https://example.com/path" => "wss://example.com/path"), use:
+// Basics:
+// To open a websocket connection to the current location:
 //
 //      var client = new PleziClient()
 //
@@ -9,104 +11,128 @@
 //
 //      var client = new PleziClient(PleziClient.origin + "/path")
 //
-// i.e., to open a connection to the root ("/"), use:
-//
-//      var client = new PleziClient(PleziClient.origin + "/")
-//
-// To open a connection to a different URL or path, use:
-//
-//      var client = new PleziClient("ws://full.url.com/path")
-//
 // To automatically renew the connection when disconnections are reported by the browser, use:
 //
-//      client.reconnect = true
-//      client.reconnect_interval = 250 // sets how long to wait before reconnection attempts. default is 50 ms.
+//      client.autoreconnect = true
+//      client.reconnect_interval = 250 // sets how long to wait before reconnection attempts. default is 250 ms.
 //
-// The automatic renew flag can be used when creating the client, using:
+// To set up event handling, directly set an `<event name>` callback. i.e., for an event called `chat`:
 //
-//      var client = new PleziClient(PleziClient.origin + "/path", true)
-//      client.reconnect_interval = 250 // Or use the default 50 ms.
-//
-// To set up event handling, directly set an `on<event name>` callback. i.e., for an event called `chat`:
-//
-//      client.onchat = function(event) { "..." }
+//      client.chat = function(event) { "..." }
 //
 // To sent / emit event in JSON format, use the `emit` method:
 //
 //      client.emit({event: "chat", data: "the message"})
 //
-// To sent raw websocket data, use the `send` method.
-// This might cause disconnetions if Plezi's controller uses `auto_dispatch`.
-// i.e. sending a string:
-//
-//      client.send("string")
-//
-// Manually closing the connection will prevent automatic reconnection:
-//
-//      client.close()
-//
-function PleziClient(url, reconnect) {
-    this.connected = NaN;
+function PleziClient(url, autoreconnect) {
+    // Set URL
     if(url) {
         this.url = url
     } else {
         this.url = PleziClient.origin + window.location.pathname
     }
-    
-    this.ws = new WebSocket(this.url);
-    this.ws.owner = this
-    this.reconnect = false;
-    this.reconnect_interval = 50
-    if(reconnect) {this.reconnect = true;}
-    this.ws.onopen = function(e) {
-        this.owner.connected = true;
-        if (this.owner.onopen) { this.owner.onopen(e) }
-    }
-    this.ws.onclose = function(e) {
-        this.connected = false;
-        if (this.owner.onclose) { this.owner.onclose(e) }
-        if(this.owner.reconnect) {
-            setTimeout( function(obj) {
-                obj.connected = NaN;
-                obj.ws = new Websocket(obj.url);
-                obj.ws.owner = obj
-            }, this.reconnect_interval, this.owner);
-        }
+    // Connect Websocket
+    this.reconnect();
+    // auto-reconnection
+    this.autoreconnect = false;
+    this.reconnect_interval = 200
+    // the timeout for a message ack receipt
+    this.emit_timeout = false
+    // Set the autoreconnect property
+    if(autoreconnect) {this.autoreconnect = true;}
+}
+// The Websocket onopen callback
+PleziClient.prototype.___on_open = function(e) {
+    this.owner.connected = true;
+    if (this.owner.onopen) { this.owner.onopen(e) }
+}
+// The Websocket onclose callback
+PleziClient.prototype.___on_close = function(e) {
+    this.owner.connected = false;
+    if (this.owner.onclose) { this.owner.onclose(e) }
+    if(this.owner.autoreconnect) {
+        setTimeout( function(obj) {
+            obj.reconnect();
+        }, this.owner.reconnect_interval, this.owner);
     }
-    this.ws.onerror = function(e) { if (this.owner.onerror) {this.owner.onerror(e)} }
-    this.ws.onmessage = this.___on_message
 }
-
+// The Websocket onerror callback
+PleziClient.prototype.___on_error = function(e) {
+    if (this.owner.onerror) {this.owner.onerror(e)}
+}
+// The Websocket onmessage callback
 PleziClient.prototype.___on_message = function(e) {
     try {
         var msg = JSON.parse(e.data);
-        if ( (msg.event) && (this.owner['on' + msg.event])) {
+        if ( msg.event == '_ack_') { clearTimeout(msg._EID_) }
+        if ( (msg.event) && (this.owner[msg.event])) {
+            this.owner[msg.event](msg);
+        } else if ( (msg.event) && (this.owner['on' + msg.event])) {
+            console.warn('PleziClient: use a callback called "' + msg.event +
+                '" instead of of "on' + msg.event + '"');
             this.owner['on' + msg.event](msg);
         } else
         {
-            if (this.owner['unknown']) {this.owner['unknown'](msg)};
+            if (this.owner['unknown'] && (msg.event != '_ack_') ) {this.owner['unknown'](msg)};
         }
     } catch(err) {
-        console.error(err)
+        console.error("PleziClient experienced an error while responding to the following onmessage event",
+            err, e)
     }
 }
+// Sets a timeout for the websocket message
+PleziClient.prototype.___set_failed_timeout = function(event, callback, timeout) {
+    if(event._EID_) {return event;};
+    if(!timeout) { timeout = this.emit_timeout; };
+    if(!callback) { callback = this.___on_timeout; };
+    if(!timeout) { return event; };
+    event._EID_ = setTimeout(callback, timeout, event, this);
+    return event;
+}
+// Removes the _client_ property from the event and calls
+// the ontimeout callback within the correct scope
+PleziClient.prototype.___on_timeout = function(event, client) {
+    client.ontimeout(event)
+}
+// The timeout callback
+PleziClient.prototype.ontimeout = function(event) {
+    console.warn("Timeout reached - it's assumed the connection was lost " +
+        "and the following event was ignored by the server:", event);
+    console.log(this);
+}
+
+PleziClient.prototype.reconnect = function() {
+    this.connected = NaN;
+    this.ws = new WebSocket(this.url);
+    // lets us access the client from the callbacks
+    this.ws.owner = this
+    // The Websocket onopen callback
+    this.ws.on_open = this.___on_open
+    // The Websocket onclose callback
+    this.ws.onclose = this.___on_close
+    // The Websocket onerror callback
+    this.ws.onerror = this.___on_error
+    // The Websocket onmessage callback
+    this.ws.onmessage = this.___on_message
+}
 
 PleziClient.prototype.close = function() {
-    this.reconnect = false;
+    this.autoreconnect = false;
     this.ws.close();
 }
 
 PleziClient.origin = (window.location.protocol.match(/https/) ? 'wws' : 'ws') + '://' + window.location.hostname + (window.location.port == '' ? '' : (':' + window.location.port) );
 
-PleziClient.prototype.send = function(data) {
+PleziClient.prototype.sendraw = function(data) {
     if (this.ws.readyState != 1) { return false; }
     this.ws.send(data);
     if (this.ws.readyState != 1) { return false; }
     return true
 }
 
-PleziClient.prototype.emit = function(data) {
-    return this.send( JSON.stringify(data) );
+PleziClient.prototype.emit = function(event, callback, timeout) {
+    this.___set_failed_timeout(event, callback, timeout)
+    return this.sendraw( JSON.stringify(event) );
 }
 
 PleziClient.prototype.readyState = function() { return this.ws.readyState; }

data/test/dispatch

@@ -25,22 +25,23 @@ class DispatchTest
 		data[:data] ||= "test"
 		{event: 'alert', data: data[:data]}.to_json
 	end
-	def index
-		%q{<html><head><script src='/assets/plezi_client.js'></script>
+	def index event = nil
+		%q{<html><head><script src='/client.js'></script>
 </head>
 <body>
 <button onclick='connection.emit({event: "test", data: "Woohooo!"});' value='test'>Test!</button>
 <script>
 document.body.onload = function() {
 	connection = new PleziClient();
-	connection.onalert = function(data) {
+	connection.alert = function(data) {
 		alert(JSON.stringify(data));
 		console.log(data);
 	}
-//	connection.onerr = function(data) {
-//		alert("Error: " + JSON.stringify(data));
-//		console.log(data);
-//	}
+	connection.err = function(data) {
+		alert("Error: " + JSON.stringify(data));
+		console.log(data);
+	}
+	connection.emit_timeout = 3000;
 	connection.unknown = function(data) {
 		alert("Unknown event: " + JSON.stringify(data));
 		console.log(data);
@@ -49,5 +50,6 @@ document.body.onload = function() {
 </script></body></html>}
 	end
 end
-host assets: File.expand_path(File.join('..','..', 'resources'), __FILE__)
+host
+route '/client.js', :client
 route '/', DispatchTest

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: plezi
 version: !ruby/object:Gem::Version
-  version: 0.12.18
+  version: 0.12.19
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-30 00:00:00.000000000 Z
+date: 2015-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iodine
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.18
+        version: 0.1.19
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.18
+        version: 0.1.19
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement