rjr 0.16.6 → 0.17.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: df6830242efa865dde4af4008827688172011746
+  data.tar.gz: 33c559f6fa14957b7aa5929f3030ab4455e93b8e
+SHA512:
+  metadata.gz: 240533c8a5aafa5980337b18fae10bf4f24a9e72e93ce6e88f42c82169ee81fbb5f850a5817a6ed1091f9ed62e96145e3b478f67b2122c15c39dbf13a29ff131
+  data.tar.gz: 56ef3f372c94eead71df0d5b534122a244c3602b4aab84c3c181d40711066c8ab7da303f3cb8f676531d6150e0f1c6be0c2836320bbda749a53f3451cdc7f5f0

data/README.md

@@ -1,4 +1,5 @@
 ## RJR - Ruby Json Rpc Library ##
+[![Build Status](https://travis-ci.org/movitto/rjr.png?branch=dep-fixes)](https://travis-ci.org/movitto/rjr)
 
 Copyright (C) 2012-2013 Mo Morsi <mo@morsi.org>
 
@@ -14,11 +15,9 @@ Currently supported transports include:
 
 Note some transports require additional dependencies, see rjr.gemspec for more info.
 
-**Note** currently there is an [issue](https://github.com/flori/json/issues/179) regarding compatability with the latest json gem.
-Developers wishing to use RJR should use version 1.7.5 or lower (workaround is in progress).
-
-
 ### Intro ###
+RJR is currently built ontop of [eventmachine](http://eventmachine.rubyforge.org/) and [json](https://github.com/flori/json), any dependencies of those are needed to run rjr.
+
 To install rjr simply run:
     gem install rjr
 
@@ -108,8 +107,7 @@ Also see examples and specs for detailed usage.
 
 ### Advanced ###
 
-RJR uses {http://rubyeventmachine.com/ eventmachine} to process server requests.
-Upon being received requests are handed off to a thread pool to free up the reactor.
+Upon receiving requests from eventmachine, rjr hands them off to a thread pool to free up the reactor.
 It is up to the developer to ensure resources accessed in the method handlers
 are protected from concurrent access.
 

data/lib/rjr/dispatcher.rb

@@ -189,11 +189,15 @@ class Dispatcher
 
   # RJR::Dispatcher intializer
   def initialize
-    @handlers = Hash.new()
-    @environments = Hash.new()
-
+    clear!
     @requests_lock = Mutex.new
-    @requests = []
+  end
+
+  # Return dispatcher to its initial state
+  def clear!
+    @handlers      = {}
+    @environments  = {}
+    @requests      = []
   end
 
   # Loads module from fs and adds handlers defined there

data/lib/rjr/nodes/tcp.rb

@@ -49,7 +49,7 @@ class TCPConnection < EventMachine::Connection
   # Send data safely using local connection
   def send_msg(data)
     @send_lock.synchronize{
-      send_data(data)
+      TCP.em.schedule { send_data(data) }
     }
   end
 

data/lib/rjr/nodes/ws.rb

@@ -101,7 +101,7 @@ class WS < RJR::Node
   #
   # Implementation of {RJR::Node#send_msg}
   def send_msg(data, ws)
-    ws.send(data)
+    @@em.schedule { ws.send(data) }
   end
 
   # Instruct Node to start listening for and dispatching rpc requests
@@ -137,7 +137,7 @@ class WS < RJR::Node
 
     @@em.schedule {
       init_client(uri) do |c|
-        c.stream { |msg| handle_message(msg, c) }
+        c.stream { |msg| handle_message(msg.data, c) }
 
         c.send_msg message.to_s
       end
@@ -171,7 +171,7 @@ class WS < RJR::Node
                                       :headers => @message_headers
     @@em.schedule {
       init_client(uri) do |c|
-        c.stream { |msg| handle_message(msg, c) }
+        c.stream { |msg| handle_message(msg.data, c) }
 
         c.send_msg message.to_s
 

data/lib/rjr/version.rb

@@ -0,0 +1,3 @@
+module RJR
+  VERSION = '0.17.1'
+end

data/site/index.html

@@ -20,7 +20,7 @@
     <script type="text/javascript" src="json.js"></script>
     <script type="text/javascript" src="jrw.js"></script>
     <script type="text/javascript">
-      var ws_node = new WSNode('127.0.0.1', '8080');
+      var ws_node = new RJR.WsNode('127.0.0.1', '8080');
       ws_node.onopen = function(){
         ws_node.invoke('stress', 'ws1', function(res){
           alert(res.result);
@@ -33,7 +33,7 @@
       };
       ws_node.open();
 
-      var www_node = new WebNode('http://localhost/rjr');
+      var www_node = new RJR.HttpNode('http://localhost/rjr');
       www_node.invoke('stress', 'http1', function(res){
          alert(res.result);
       })

data/site/jrw.js

@@ -1,302 +1,330 @@
-/* Json-Rpc over HTTP and Websockets
+/* JSON-RPC over HTTP and WebSockets
  *
- *  Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
- *  Licensed under the Apache License, Version 2.0
+ * Copyright (C) 2013 Mohammed Morsi <mo@morsi.org>
+ * Licensed under the Apache License, Version 2.0
  */
 
-///////////////////////////////////////////////////////
-// Helpers to generate a uuid
-function S4() {
+var RJR = { REVISION: '1' };
+
+// Generate a new ascii string of length 4
+RJR.S4 = function() {
   return (((1+Math.random())*0x10000)|0).toString(16).substring(1);
-}
-function guid() {
-  return (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4());
+};
+
+// Generate a new uuid
+RJR.guid = function() {
+  return (RJR.S4()+RJR.S4()+"-"+RJR.S4()+"-"+RJR.S4()+"-"+RJR.S4()+"-"+RJR.S4()+RJR.S4()+RJR.S4());
+};
+
+// Return bool indicating if specified data is a jsonrpc object
+RJR.is_jr_object = function(obj){
+  return obj && obj['json_class'];
 }
 
-///////////////////////////////////////////////////////
-// JRMessage
+// Return bool indicating if specified data is an array
+RJR.is_array = function(obj){
+  return obj && typeof(obj) == 'object' && obj.length != undefined;
+}
 
 // Encapsulates a json-rpc message
-function JRMessage(){
-  this.id = null;
+RJR.JRMessage = function(){
+  // standard jsonrpc message fields
+  this.id         = null;
   this.rpc_method = null;
-  this.args = null;
-
-  this.data = null;
-  this.json = null;
-
-  this.error = null;
-  this.result = null;
+  this.params     =   [];
+  this.error      = null;
+  this.result     = null;
 
+  // extra data used locally
   this.onresponse = null;
-  this.success   = null;
+  this.headers    =   {};
+};
 
-  this.to_json = function(){
-    this.json = $.toJSON(this.data);
-    return this.json;
+RJR.JRMessage.prototype = {
+  // Convert message to json string
+  to_json : function(){
+    var params = RJR.JRMessage.convert_params(this.params);
+    var msg = {jsonrpc: '2.0',
+               method:  this.rpc_method,
+               params:  params,
+               id:      this.id};
+    for(var h in this.headers)
+      msg[h] = this.headers[h];
+    return $.toJSON(msg);
+  },
+
+  // Invoke response handler if registered
+  handle_response : function(res){
+    if(this.onresponse) this.onresponse(res);
   }
+};
 
-  this.handle_response = function(res){
-    res.success = (res.error == undefined);
-    if(this.onresponse)
-      this.onresponse(res);
+// Convert js params to json params
+RJR.JRMessage.convert_params = function(params){
+  var jrparams = [];
+  for(var p = 0; p < params.length; p++){
+    var param = params[p];
+    if(RJR.is_jr_object(param)){
+      // FIXME need to check each param property as well (converting if necessary)
+      var json_class = param['json_class'];
+      delete param['json_class'];
+      jrparams.push({json_class: json_class,
+                     data      :      param});
+    }else if(RJR.is_array(param))
+      jrparams.push(RJR.JRMessage.convert_params(param));
+    else
+      jrparams.push(param);
   }
+  return jrparams;
 }
 
-// Create new request message to send
-JRMessage.new_request = function(rpc_method, args){
-  var msg = new JRMessage();
-  msg.id = guid();
-  msg.rpc_method = rpc_method;
-  msg.args = args;
-  msg.data = {jsonrpc:  '2.0',
-              method: msg.rpc_method,
-              params: msg.args,
-              id: msg.id};
-  return msg;
-}
-
-// Internal helper to generate request from common args.
-//
-// rpc method, parameter list, and optional response callback
-// will be extracted from the 'args' param in that order.
-//
-// node_id and headers will be set on request message before it
-// is returned
-JRMessage.pretty_request = function(args, node_id, headers){
-  // create request message
-  var rpc_method = args[0];
-  var params = [];
-  var cb = null;
-  for(a = 1; a < args.length; a++){
-      if(a == args.length - 1 && typeof args[a] === 'function')
-        cb = args[a];
+// Parse a json string to a JRMessage
+RJR.JRMessage.parse = function(json){
+  var data = $.evalJSON(json);
+
+  var msg        = new RJR.JRMessage();
+  msg.id         = data['id'];
+  msg.rpc_method = data['method'];
+  msg.error      = data['error'];
+
+  var params = data['params'];
+  if(params){
+    for(var d=0; d<params.length; d++){
+      var param = params[d];
+      if(RJR.is_jr_object(param))
+        msg.params.push(RJR.JRMessage.parse_obj(param));
+      else if(RJR.is_array(param))
+        msg.params.push(RJR.JRMessage.parse_array(param));
       else
-        params.push(args[a]);
+        msg.params.push(param);
+    }
   }
-  var req = JRMessage.new_request(rpc_method, params);
-  if(node_id) req.data['node_id'] = node_id;
-  for(var header in headers)
-    req.data[header] = headers[header];
 
-  // register callback if last argument is a function
-  if(cb) req.onresponse = cb;
+  var result = data['result'];
+  if(result){
+    if(RJR.is_jr_object(result))
+      msg.result = RJR.JRMessage.parse_obj(result);
+    else if(RJR.is_array(result))
+      msg.result = RJR.JRMessage.parse_array(result);
+    else
+      msg.result = result;
+  }
 
-  return req;
-}
+  return msg;
+};
 
-// Parse message received in json string
-JRMessage.from_msg = function(dat){
-  var msg = new JRMessage();
-  msg.json = dat;
-  msg.data = $.evalJSON(dat);
-
-  msg.id     = msg.data['id'];
-  msg.rpc_method = msg.data['method'];
-  if(msg.data['params']){
-    msg.params = msg.data['params'];
-    for(p=0;p<msg.params.length;++p){
-      if(JRObject.is_jrobject(msg.params[p]))
-        msg.params[p] = JRObject.from_json(msg.params[p]);
-      else if(JRObject.is_jrobject_array(msg.params[p]))
-        msg.params[p] = JRObject.from_json_array(msg.params[p]);
-    }
+// Parse a json object into a js object
+RJR.JRMessage.parse_obj = function(obj){
+  // TODO mechanism to lookup class and auto
+  // instantiate instead of generic js object
+  var result = {json_class : obj['json_class']};
+  for(var p in obj['data']){
+    var property = obj['data'][p];
+    if(RJR.is_jr_object(property))
+      result[p] = RJR.JRMessage.parse_obj(property);
+    else if(RJR.is_array(obj[p]))
+      result[p] = RJR.JRMessage.parse_array(property);
+    else
+      result[p] = property;
   }
-  msg.error  = msg.data['error'];
-  msg.result = msg.data['result'];
-  if(msg.result && JRObject.is_jrobject(msg.result))
-    msg.result = JRObject.from_json(msg.result);
-  else if(JRObject.is_jrobject_array(msg.result))
-    msg.result = JRObject.from_json_array(msg.result);
-  return msg;
+  return result;
 }
 
-///////////////////////////////////////////////////////
-// JRObject
-
-// Encapsulates an object w/ type
-//  - adaptor for the ruby 'json' library
-function JRObject (type, value, ignore_properties){
-  this.type  = type;
-  this.value = value;
-  this.ignore_properties = (typeof(ignore_properties) != 'undefined') ?
-                            ignore_properties : ["toJSON", "json_class"];
-  this.toJSON = function(){
-     var data = {};
-     for(p in this.value)
-       if($.inArray(p, this.ignore_properties) == -1)
-         data[p] = value[p];
-     return {json_class: this.type, data: data };
-  };
-};
+// Parse an array, potentially containing json data,
+// into a js array
+RJR.JRMessage.parse_array = function(array){
+  var result = [];
+  for(var a=0; a<array.length; a++){
+    var item = array[a];
+    if(RJR.is_jr_object(item))
+      result.push(RJR.JRMessage.parse_obj(item));
+    else if(RJR.is_array(item))
+      result.push(RJR.JRMessage.parse_array(item));
+    else
+      result.push(item);
+  }
+  return result;
+}
 
-// Return boolean indicating if json contains encapsulated JRObject
-JRObject.is_jrobject = function(json){
-  return json && json['json_class'] && json['data'];
+// Create new request message to send
+RJR.JRMessage.new_request = function(rpc_method, params){
+  var msg        = new RJR.JRMessage();
+  msg.id         = RJR.guid();
+  msg.rpc_method = rpc_method;
+  msg.params     = params;
+  return msg;
 };
 
-// Return boolean indicating if json contains array of encapsulated JRObjects
-JRObject.is_jrobject_array = function(json){
-  return json && typeof(json) == "object" && json.length > 0 && JRObject.is_jrobject(json[0]);
-};
+// Helper method to convert method arguments to:
+//  - rpc_method
+//  - parameter list
+//  - callback (if last argument is a function, else null)
+RJR.JRMessage.prepare_args = function(args){
+  var rpc_method = args[0];
+  var cb = null;
+  if(typeof(args[args.length-1]) === 'function')
+    cb = args[args.length-1];
 
-// Convert json to JRObject
-JRObject.from_json = function(json){
-  var obj = json['data'];
-  obj.json_class = json['json_class'];
-  for(var p in obj){
-    if(JRObject.is_jrobject(obj[p]))
-      obj[p] = JRObject.from_json(obj[p]);
-    else if(JRObject.is_jrobject_array(obj[p])){
-      obj[p] = JRObject.from_json_array(obj[p]);
-   }
+  var params = [];
+  for(var a = 1; a < args.length; a++){
+    var arg = args[a];
+    if(typeof(arg) !== 'function')
+      params.push(arg);
   }
-  return obj;
-};
 
-// Convert json to array of JRObjects
-JRObject.from_json_array = function(json){
-  var objs = [];
-  for(var i in json)
-    if(JRObject.is_jrobject(json[i]))
-      objs[i] = JRObject.from_json(json[i]);
-  return objs;
+  return [rpc_method, params, cb];
 };
 
-///////////////////////////////////////////////////////
-// WSNode
+// Helper to prepare a request for the specified node
+RJR.JRMessage.request_for_node = function(node, args){
+  var preq = RJR.JRMessage.prepare_args(args);
+  var req  = RJR.JRMessage.new_request(preq[0], preq[1]);
+  req.onresponse = preq[2];
+  req.headers = node.headers;
+  req.headers['node_id'] = node.node_id;
+  return req;
+};
 
 // Main json-rpc client websocket interface
-function WSNode (host, port){
-  var node      = this;
+RJR.WsNode = function(host, port){
+  this.host     = host;
+  this.port     = port;
   this.opening  = false;
   this.opened   = false;
   this.node_id  = null;
   this.headers  = {};
   this.messages = {};
+};
 
+RJR.WsNode.prototype = {
   // Open socket connection
-  this.open = function(){
+  open : function(){
+    var node = this;
     if(this.opening) return;
     this.opening = true;
-    node.socket = new WebSocket("ws://" + host + ":" + port);
-
-    node.socket.onclose   = function (){
-      if(node.onclose)
-        node.onclose();
-    };
-
-    node.socket.onmessage = function (evnt){
-      var msg = JRMessage.from_msg(evnt.data);
-
-      // match response w/ outstanding request
-      if(msg.id){
-        var req = node.messages[msg.id];
-        delete node.messages[msg.id];
-        req.handle_response(msg)
-
-        // if err msg, run node.onerror
-        if(msg.error)
-          if(node.onerror)
-            node.onerror(msg)
-
-      }
-
-      // relying on clients to handle notifications via message_received
-      // TODO add notification (and request?) handler support here
-      // clients may user this to register additional handlers to be invoked
-      // upon request responses
-      if(node.message_received)
-        node.message_received(msg);
-    };
-
-    node.socket.onerror = function(e){
-      if(node.onerror)
-        node.onerror(e);
+    this.socket = new WebSocket("ws://" + this.host + ":" + this.port);
+    this.socket.onclose   = function(){ node._socket_close(); };
+    this.socket.onmessage = function(evnt){ node._socket_msg(evnt);  };
+    this.socket.onerror   = function(err){ node._socket_err(err);  };
+    this.socket.onopen    = function(){ node._socket_open(); };
+
+  },
+
+  _socket_close : function(){
+    if(this.onclose) this.onclose();
+  },
+
+  _socket_msg : function(evnt){
+    var msg = RJR.JRMessage.parse(evnt.data);
+
+    // match response w/ outstanding request
+    if(msg.id){
+      var req = this.messages[msg.id];
+      delete this.messages[msg.id];
+      req.handle_response(msg)
+
+      // if err msg, run this.onerror
+      if(msg.error)
+        if(this.onerror)
+          this.onerror(msg)
     }
 
-    node.socket.onopen = function (){
-      node.opened = true;
-      node.opening = false;
+    // relying on clients to handle notifications via message_received
+    // TODO add notification (and request?) handler support here
+    // clients may user this to register additional handlers to be invoked
+    // upon request responses
+    if(this.message_received)
+      this.message_received(msg);
+  },
+
+  _socket_err : function(e){
+    if(this.onerror)
+      this.onerror(e);
+  },
+
+  _socket_open : function(){
+    this.opened = true;
+    this.opening = false;
 
-      // send queued messages
-      for(var m in node.messages)
-        node.socket.send(node.messages[m].to_json());
+    // send queued messages
+    for(var m in this.messages)
+      this.socket.send(this.messages[m].to_json());
 
-      // invoke client callback
-      if(node.onopen)
-        node.onopen();
-    };
-  };
+    // invoke client callback
+    if(this.onopen)
+      this.onopen();
+  },
 
   // Close socket connection
-  this.close = function(){
+  close : function(){
     this.socket.close();
-  };
+  },
 
   // Invoke request on socket, may be invoked before or after socket is opened.
   //
   // Pass in the rpc method, arguments to invoke method with, and optional callback
   // to be invoked upon received response.
-  this.invoke = function(){
-    var req = JRMessage.pretty_request(arguments, this.node_id, this.headers);
+  invoke : function(){
+    var req = RJR.JRMessage.request_for_node(this, arguments);
 
     // store requests for later retrieval
     this.messages[req.id] = req;
 
-    if(node.opened)
+    if(this.opened)
       this.socket.send(req.to_json());
 
     return req;
-  };
+  }
 };
 
-///////////////////////////////////////////////////////
-// WebNode
-
-// Main json-rpc www interface
-function WebNode (uri){
-  var node      = this;
+// Main json-rpc http interface
+RJR.HttpNode = function(uri){
+  this.uri      = uri;
   this.node_id  = null;
   this.headers  = {};
+};
 
+RJR.HttpNode.prototype = {
   // Invoke request via http
   //
   // Pass in the rpc method, arguments to invoke method with, and optional callback
   // to be invoked upon received response.
-  this.invoke = function(){
-    var req = JRMessage.pretty_request(arguments, this.node_id, this.headers);
+  invoke : function(){
+    var req = RJR.JRMessage.request_for_node(this, arguments);
 
+    var node      = this;
     $.ajax({type: 'POST',
-            url: uri,
+            url: this.uri,
             data: req.to_json(),
             dataType: 'text', // using text so we can parse json ourselves
-
-            success: function(data){
-              var msg = JRMessage.from_msg(data);
-              // clients may register additional callbacks
-              // to handle web node responses
-              if(node.message_received)
-                node.message_received(msg);
-
-              req.handle_response(msg)
-
-              // if err msg, run node.onerror
-              if(msg.error)
-                if(node.onerror)
-                  node.onerror(msg);
-            },
-
-            error: function(jqXHR, textStatus, errorThrown){
-              var err = { 'error' : {'code' : jqXHR.status,
-                                     'message' : textStatus,
-                                     'class' : errorThrown } };
-              if(node.onerror)
-                node.onerror(err);
-
-              req.handle_response(err)
-            }});
+            success: function(data) { node._http_success(data, req); },
+            error:   function(hr, st, et) { node._http_err(hr, st, et, req); }});
 
     return req;
-  };
+  },
+
+  _http_success : function(data, req){
+    var msg = RJR.JRMessage.parse(data);
+    // clients may register additional callbacks
+    // to handle web node responses
+    if(this.message_received)
+      this.message_received(msg);
+
+    req.handle_response(msg)
+
+    // if err msg, run this.onerror
+    if(msg.error)
+      if(this.onerror)
+        this.onerror(msg);
+  },
+
+  _http_err : function(jqXHR, textStatus, errorThrown, req){
+    var err = { 'error' : {'code' : jqXHR.status,
+                           'message' : textStatus,
+                           'class' : errorThrown } };
+    if(this.onerror)
+      this.onerror(err);
+
+    req.handle_response(err)
+  }
 };

data/specs/nodes/amqp_spec.rb

@@ -7,6 +7,12 @@ puts "Missing AMQP node dependencies, skipping amqp tests"
 else
 # TODO stub out calls to external rabbitmq server
 
+# helper to stop em
+def stop_node(node)
+  Thread.new { ::AMQP.stop { node.halt } }
+  node.join
+end
+
 module RJR::Nodes
   describe AMQP do
     describe "#send_msg" do
@@ -33,7 +39,7 @@ module RJR::Nodes
                  :broker => 'localhost').invoke 'server-queue',
                                                 'test',
                                                 'myparam'
-        node.halt.join
+        stop_node(node)
         invoked.should be_true
         ci.should be_nil
         cp.should be_nil
@@ -55,7 +61,7 @@ module RJR::Nodes
         client = AMQP.new :node_id => 'client', :broker => 'localhost'
         res = client.invoke 'server-queue', 'test', 'myparam'
 
-        server.halt.join
+        stop_node(client)
         res.should == 'retval'
       end
     end
@@ -71,7 +77,7 @@ module RJR::Nodes
         client = AMQP.new :node_id => 'client', :broker => 'localhost'
         res = client.notify 'server-queue', 'test', 'myparam'
 
-        server.halt.join
+        stop_node(server)
         res.should == nil
       end
     end

metadata

@@ -1,62 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: rjr
 version: !ruby/object:Gem::Version
-  version: 0.16.6
-  prerelease: 
+  version: 0.17.1
 platform: ruby
 authors:
-- Mohammed Morsi
+- Mo Morsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-27 00:00:00.000000000 Z
+date: 2013-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: eventmachine
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.7.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.7.6
 description: Ruby Json Rpc library
@@ -80,6 +73,7 @@ files:
 - lib/rjr/em_adapter.rb
 - lib/rjr/errors.rb
 - lib/rjr/inspect.rb
+- lib/rjr/version.rb
 - lib/rjr/node.rb
 - lib/rjr/common.rb
 - lib/rjr/thread_pool.rb
@@ -96,6 +90,13 @@ files:
 - lib/rjr/nodes/missing.rb
 - lib/rjr/nodes/multi.rb
 - lib/rjr/dispatcher.rb
+- site/index.html
+- site/jquery-latest.js
+- site/json.js
+- site/jrw.js
+- LICENSE
+- Rakefile
+- README.md
 - specs/dispatcher_spec.rb
 - specs/node_spec.rb
 - specs/nodes/multi_spec.rb
@@ -109,33 +110,31 @@ files:
 - specs/thread_pool_spec.rb
 - specs/message_spec.rb
 - specs/em_adapter_spec.rb
-- site/index.html
-- site/jquery-latest.js
-- site/json.js
-- site/jrw.js
-- LICENSE
-- Rakefile
-- README.md
 - bin/rjr-server
 - bin/rjr-client
 - bin/rjr-client-launcher
 homepage: http://github.com/movitto/rjr
 licenses:
 - Apache 2.0
-post_install_message: 
+metadata: {}
+post_install_message: |-
+  ---
+  RJR - Optional Transport Requirements
+  The amqp gem and a running rabbitmq server is needed to use the amqp node
+  The eventmachine_httpserver and em-http-request gems are needed to use the web node
+  The em-websocket and em-websocket-client gems are needed to use the web socket node
+  ---
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.8.1
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.3.3
 requirements:
@@ -143,9 +142,22 @@ requirements:
 - The eventmachine_httpserver and em-http-request gems are needed to use the web node
 - The em-websocket and em-websocket-client gems are needed to use the web socket node
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: JSON RPC server and client library over amqp, websockets, http, etc
-test_files: []
+test_files:
+- specs/dispatcher_spec.rb
+- specs/node_spec.rb
+- specs/nodes/multi_spec.rb
+- specs/nodes/tcp_spec.rb
+- specs/nodes/web_spec.rb
+- specs/nodes/local_spec.rb
+- specs/nodes/amqp_spec.rb
+- specs/nodes/ws_spec.rb
+- specs/nodes/easy_spec.rb
+- specs/inspect_spec.rb
+- specs/thread_pool_spec.rb
+- specs/message_spec.rb
+- specs/em_adapter_spec.rb
 has_rdoc: