rubrowser 2.6.0 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0105f708ea3b97b023bb2be41d2d86eb7144083e
-  data.tar.gz: a44cc7253f7e810a2994ae801a8e2940f379bd38
+SHA256:
+  metadata.gz: 16c4a3914f4bee3c490769aff15c24df034f2208a26e1c6d17a0da79f8c5be9b
+  data.tar.gz: 3410a5bb59bf64fe18aad3c0ac5d4f4a71f07ff5afe18d92dede8e1d7e0502a1
 SHA512:
-  metadata.gz: baa24df653d21ed1c87ad867934fe0cf619adec9fec72dcbec1d12ea88b1d5163a5a6a985773f65d13f577f8149f441145da2e71f05c65b94e00f7ceb447f82f
-  data.tar.gz: 4ee9e2d15638d6cb2c24f39673c5ff515f10a2d6d4da7f135592823d1c717af0cdb6d176f4a342760e01ec921ec5dda3e0b46f3a5b332fe8441024d39603550d
+  metadata.gz: d683deffdf39ea8edf19993871a5c7fb72b242a25f02b09b01c5b529e90eb208322d80fcf682fca8b844536788a31a8611be1d0713f925747ffc7a94119038cb
+  data.tar.gz: 3f75f1444103b98756147fe22ed8c36c195e23cb925795eaeb5f2d40731c031c0f14e5d4915d06b05d4c3505ba5bff4e655389cf4e47d98149d1cf3980c77931

data/Gemfile.lock

@@ -1,19 +1,26 @@
 PATH
   remote: .
   specs:
-    rubrowser (2.6.0)
+    rubrowser (2.7.0)
+      litecable
       parser (~> 2.3, >= 2.3.0)
+      puma
+      websocket
 
 GEM
   remote: https://rubygems.org/
   specs:
+    anyway_config (1.2.0)
     ast (2.2.0)
     byebug (9.0.6)
     diff-lcs (1.3)
+    litecable (0.5.0)
+      anyway_config (~> 1.0)
     parallel (1.12.0)
     parser (2.4.0.0)
       ast (~> 2.2)
     powerpack (0.1.1)
+    puma (3.11.2)
     rainbow (2.2.2)
       rake
     rake (10.4.2)
@@ -39,6 +46,7 @@ GEM
       unicode-display_width (~> 1.0, >= 1.0.1)
     ruby-progressbar (1.8.1)
     unicode-display_width (1.3.0)
+    websocket (1.2.5)
 
 PLATFORMS
   ruby

data/bin/rubrowser

@@ -26,6 +26,12 @@ OptionParser.new do |opts|
     'layout file to apply on the resulting graph'
   ) { |layout| options[:layout] = layout }
 
+  opts.on(
+    '-sSERVER:PORT',
+    '--server=SERVER:PORT',
+    'rubrowser server for execution monitoring'
+  ) { |server| options[:server] = server }
+
   opts.on('-T', '--no-toolbox', 'Don\'t display toolbox on the page') do
     options[:toolbox] = false
   end

data/lib/rubrowser.rb

@@ -1,4 +1,5 @@
 require 'rubrowser/version'
+require 'rubrowser/monitor'
 
 module Rubrowser
 end

data/lib/rubrowser/channel.rb

@@ -0,0 +1,9 @@
+module Rubrowser
+  class Channel < LiteCable::Channel::Base
+    identifier :classes
+
+    def subscribed
+      stream_from "classes"
+    end
+  end
+end

data/lib/rubrowser/connection.rb

@@ -0,0 +1,20 @@
+require 'rubrowser/channel'
+
+module Rubrowser
+  class Connection < LiteCable::Connection::Base
+    identified_by :id
+
+    def connect
+      @id = rand(100000)
+      self.class.initiate_reader
+    end
+
+    def self.initiate_reader
+      @reader ||= Thread.new do
+        $rd.each_line do |line|
+          LiteCable.broadcast('classes', message: line.strip)
+        end
+      end
+    end
+  end
+end

data/lib/rubrowser/monitor.rb

@@ -0,0 +1,22 @@
+require 'rubrowser/trace'
+require 'rubrowser/server'
+
+
+module Rubrowser
+  module Monitor
+    module_function
+
+    def run(path: "", port: 8080)
+      $rd, $wr = IO.pipe
+
+      if fork
+        $rd.close
+        Trace.new(path: path).run
+      else
+        $wr.close
+        Server.new(port: port).run
+        exit
+      end
+    end
+  end
+end

data/lib/rubrowser/renderer.rb

@@ -19,11 +19,12 @@ module Rubrowser
 
     include ERB::Util
 
-    attr_reader :files, :output
+    attr_reader :files, :output, :server
 
     def initialize(options)
       @output = output_file(options[:output])
       @layout = options[:layout]
+      @server = options[:server]
       @files = options[:files]
       @toolbox = options[:toolbox]
     end

data/lib/rubrowser/server.rb

@@ -0,0 +1,42 @@
+require 'lite_cable'
+require 'lite_cable/server'
+require 'puma/configuration'
+require 'rubrowser/connection'
+
+module Rubrowser
+  class Server
+    def initialize(port: 8080)
+      @port = port
+    end
+
+    def run
+      launcher.run
+    end
+
+    private
+
+    attr_reader :port
+
+    def launcher
+      @launcher ||= Puma::Launcher.new(conf)
+    end
+
+    def conf
+      @conf ||= Puma::Configuration.new do |user_config|
+        user_config.threads(1, 1)
+        user_config.workers 1
+        user_config.port port
+        user_config.app(rack_app)
+      end
+    end
+
+    def rack_app
+      @app ||= Rack::Builder.new do
+        map '/' do
+          use LiteCable::Server::Middleware, connection_class: Rubrowser::Connection
+          run proc { |_| [200, { 'Content-Type' => 'text/plain' }, ['OK']] }
+        end
+      end
+    end
+  end
+end

data/lib/rubrowser/trace.rb

@@ -0,0 +1,21 @@
+module Rubrowser
+  class Trace
+    def initialize(path: "")
+      @path = path
+    end
+
+    def run
+      trace_point.enable
+    end
+
+    private
+
+    attr_reader :path
+
+    def trace_point
+      @trace_point ||= TracePoint.new(:call) do |tp|
+        $wr.puts tp.defined_class if tp.path.start_with?(path)
+      end
+    end
+  end
+end

data/lib/rubrowser/version.rb

@@ -1,3 +1,3 @@
 module Rubrowser
-  VERSION = '2.6.0'.freeze
+  VERSION = '2.7.0'.freeze
 end

data/public/css/application.css

@@ -45,6 +45,11 @@ text.type{
     display: none;
 }
 
+.running circle{
+    stroke: #18b738;
+    fill: #7dea93;
+}
+
 .highlighted,
 .highlighted_by_namespace,
 .highlighted_by_path,

data/public/javascript/websocket.js

@@ -0,0 +1,613 @@
+(function() {
+  var slice = [].slice;
+
+  this.ActionCable = {
+    INTERNAL: {
+      "message_types": {
+        "welcome": "welcome",
+        "ping": "ping",
+        "confirmation": "confirm_subscription",
+        "rejection": "reject_subscription"
+      },
+      "default_mount_path": "/cable",
+      "protocols": ["actioncable-v1-json", "actioncable-unsupported"]
+    },
+    WebSocket: window.WebSocket,
+    logger: window.console,
+    createConsumer: function(url) {
+      var ref;
+      if (url == null) {
+        url = (ref = this.getConfig("url")) != null ? ref : this.INTERNAL.default_mount_path;
+      }
+      return new ActionCable.Consumer(this.createWebSocketURL(url));
+    },
+    getConfig: function(name) {
+      var element;
+      element = document.head.querySelector("meta[name='action-cable-" + name + "']");
+      return element != null ? element.getAttribute("content") : void 0;
+    },
+    createWebSocketURL: function(url) {
+      var a;
+      if (url && !/^wss?:/i.test(url)) {
+        a = document.createElement("a");
+        a.href = url;
+        a.href = a.href;
+        a.protocol = a.protocol.replace("http", "ws");
+        return a.href;
+      } else {
+        return url;
+      }
+    },
+    startDebugging: function() {
+      return this.debugging = true;
+    },
+    stopDebugging: function() {
+      return this.debugging = null;
+    },
+    log: function() {
+      var messages, ref;
+      messages = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+      if (this.debugging) {
+        messages.push(Date.now());
+        return (ref = this.logger).log.apply(ref, ["[ActionCable]"].concat(slice.call(messages)));
+      }
+    }
+  };
+
+}).call(this);
+(function() {
+  var bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  ActionCable.ConnectionMonitor = (function() {
+    var clamp, now, secondsSince;
+
+    ConnectionMonitor.pollInterval = {
+      min: 3,
+      max: 30
+    };
+
+    ConnectionMonitor.staleThreshold = 6;
+
+    function ConnectionMonitor(connection) {
+      this.connection = connection;
+      this.visibilityDidChange = bind(this.visibilityDidChange, this);
+      this.reconnectAttempts = 0;
+    }
+
+    ConnectionMonitor.prototype.start = function() {
+      if (!this.isRunning()) {
+        this.startedAt = now();
+        delete this.stoppedAt;
+        this.startPolling();
+        document.addEventListener("visibilitychange", this.visibilityDidChange);
+        return ActionCable.log("ConnectionMonitor started. pollInterval = " + (this.getPollInterval()) + " ms");
+      }
+    };
+
+    ConnectionMonitor.prototype.stop = function() {
+      if (this.isRunning()) {
+        this.stoppedAt = now();
+        this.stopPolling();
+        document.removeEventListener("visibilitychange", this.visibilityDidChange);
+        return ActionCable.log("ConnectionMonitor stopped");
+      }
+    };
+
+    ConnectionMonitor.prototype.isRunning = function() {
+      return (this.startedAt != null) && (this.stoppedAt == null);
+    };
+
+    ConnectionMonitor.prototype.recordPing = function() {
+      return this.pingedAt = now();
+    };
+
+    ConnectionMonitor.prototype.recordConnect = function() {
+      this.reconnectAttempts = 0;
+      this.recordPing();
+      delete this.disconnectedAt;
+      return ActionCable.log("ConnectionMonitor recorded connect");
+    };
+
+    ConnectionMonitor.prototype.recordDisconnect = function() {
+      this.disconnectedAt = now();
+      return ActionCable.log("ConnectionMonitor recorded disconnect");
+    };
+
+    ConnectionMonitor.prototype.startPolling = function() {
+      this.stopPolling();
+      return this.poll();
+    };
+
+    ConnectionMonitor.prototype.stopPolling = function() {
+      return clearTimeout(this.pollTimeout);
+    };
+
+    ConnectionMonitor.prototype.poll = function() {
+      return this.pollTimeout = setTimeout((function(_this) {
+        return function() {
+          _this.reconnectIfStale();
+          return _this.poll();
+        };
+      })(this), this.getPollInterval());
+    };
+
+    ConnectionMonitor.prototype.getPollInterval = function() {
+      var interval, max, min, ref;
+      ref = this.constructor.pollInterval, min = ref.min, max = ref.max;
+      interval = 5 * Math.log(this.reconnectAttempts + 1);
+      return Math.round(clamp(interval, min, max) * 1000);
+    };
+
+    ConnectionMonitor.prototype.reconnectIfStale = function() {
+      if (this.connectionIsStale()) {
+        ActionCable.log("ConnectionMonitor detected stale connection. reconnectAttempts = " + this.reconnectAttempts + ", pollInterval = " + (this.getPollInterval()) + " ms, time disconnected = " + (secondsSince(this.disconnectedAt)) + " s, stale threshold = " + this.constructor.staleThreshold + " s");
+        this.reconnectAttempts++;
+        if (this.disconnectedRecently()) {
+          return ActionCable.log("ConnectionMonitor skipping reopening recent disconnect");
+        } else {
+          ActionCable.log("ConnectionMonitor reopening");
+          return this.connection.reopen();
+        }
+      }
+    };
+
+    ConnectionMonitor.prototype.connectionIsStale = function() {
+      var ref;
+      return secondsSince((ref = this.pingedAt) != null ? ref : this.startedAt) > this.constructor.staleThreshold;
+    };
+
+    ConnectionMonitor.prototype.disconnectedRecently = function() {
+      return this.disconnectedAt && secondsSince(this.disconnectedAt) < this.constructor.staleThreshold;
+    };
+
+    ConnectionMonitor.prototype.visibilityDidChange = function() {
+      if (document.visibilityState === "visible") {
+        return setTimeout((function(_this) {
+          return function() {
+            if (_this.connectionIsStale() || !_this.connection.isOpen()) {
+              ActionCable.log("ConnectionMonitor reopening stale connection on visibilitychange. visbilityState = " + document.visibilityState);
+              return _this.connection.reopen();
+            }
+          };
+        })(this), 200);
+      }
+    };
+
+    now = function() {
+      return new Date().getTime();
+    };
+
+    secondsSince = function(time) {
+      return (now() - time) / 1000;
+    };
+
+    clamp = function(number, min, max) {
+      return Math.max(min, Math.min(max, number));
+    };
+
+    return ConnectionMonitor;
+
+  })();
+
+}).call(this);
+(function() {
+  var i, message_types, protocols, ref, supportedProtocols, unsupportedProtocol,
+    slice = [].slice,
+    bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; },
+    indexOf = [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; };
+
+  ref = ActionCable.INTERNAL, message_types = ref.message_types, protocols = ref.protocols;
+
+  supportedProtocols = 2 <= protocols.length ? slice.call(protocols, 0, i = protocols.length - 1) : (i = 0, []), unsupportedProtocol = protocols[i++];
+
+  ActionCable.Connection = (function() {
+    Connection.reopenDelay = 500;
+
+    function Connection(consumer) {
+      this.consumer = consumer;
+      this.open = bind(this.open, this);
+      this.subscriptions = this.consumer.subscriptions;
+      this.monitor = new ActionCable.ConnectionMonitor(this);
+      this.disconnected = true;
+    }
+
+    Connection.prototype.send = function(data) {
+      if (this.isOpen()) {
+        this.webSocket.send(JSON.stringify(data));
+        return true;
+      } else {
+        return false;
+      }
+    };
+
+    Connection.prototype.open = function() {
+      if (this.isActive()) {
+        ActionCable.log("Attempted to open WebSocket, but existing socket is " + (this.getState()));
+        return false;
+      } else {
+        ActionCable.log("Opening WebSocket, current state is " + (this.getState()) + ", subprotocols: " + protocols);
+        if (this.webSocket != null) {
+          this.uninstallEventHandlers();
+        }
+        this.webSocket = new ActionCable.WebSocket(this.consumer.url, protocols);
+        this.installEventHandlers();
+        this.monitor.start();
+        return true;
+      }
+    };
+
+    Connection.prototype.close = function(arg) {
+      var allowReconnect, ref1;
+      allowReconnect = (arg != null ? arg : {
+        allowReconnect: true
+      }).allowReconnect;
+      if (!allowReconnect) {
+        this.monitor.stop();
+      }
+      if (this.isActive()) {
+        return (ref1 = this.webSocket) != null ? ref1.close() : void 0;
+      }
+    };
+
+    Connection.prototype.reopen = function() {
+      var error;
+      ActionCable.log("Reopening WebSocket, current state is " + (this.getState()));
+      if (this.isActive()) {
+        try {
+          return this.close();
+        } catch (error1) {
+          error = error1;
+          return ActionCable.log("Failed to reopen WebSocket", error);
+        } finally {
+          ActionCable.log("Reopening WebSocket in " + this.constructor.reopenDelay + "ms");
+          setTimeout(this.open, this.constructor.reopenDelay);
+        }
+      } else {
+        return this.open();
+      }
+    };
+
+    Connection.prototype.getProtocol = function() {
+      var ref1;
+      return (ref1 = this.webSocket) != null ? ref1.protocol : void 0;
+    };
+
+    Connection.prototype.isOpen = function() {
+      return this.isState("open");
+    };
+
+    Connection.prototype.isActive = function() {
+      return this.isState("open", "connecting");
+    };
+
+    Connection.prototype.isProtocolSupported = function() {
+      var ref1;
+      return ref1 = this.getProtocol(), indexOf.call(supportedProtocols, ref1) >= 0;
+    };
+
+    Connection.prototype.isState = function() {
+      var ref1, states;
+      states = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+      return ref1 = this.getState(), indexOf.call(states, ref1) >= 0;
+    };
+
+    Connection.prototype.getState = function() {
+      var ref1, state, value;
+      for (state in WebSocket) {
+        value = WebSocket[state];
+        if (value === ((ref1 = this.webSocket) != null ? ref1.readyState : void 0)) {
+          return state.toLowerCase();
+        }
+      }
+      return null;
+    };
+
+    Connection.prototype.installEventHandlers = function() {
+      var eventName, handler;
+      for (eventName in this.events) {
+        handler = this.events[eventName].bind(this);
+        this.webSocket["on" + eventName] = handler;
+      }
+    };
+
+    Connection.prototype.uninstallEventHandlers = function() {
+      var eventName;
+      for (eventName in this.events) {
+        this.webSocket["on" + eventName] = function() {};
+      }
+    };
+
+    Connection.prototype.events = {
+      message: function(event) {
+        var identifier, message, ref1, type;
+        if (!this.isProtocolSupported()) {
+          return;
+        }
+        ref1 = JSON.parse(event.data), identifier = ref1.identifier, message = ref1.message, type = ref1.type;
+        switch (type) {
+          case message_types.welcome:
+            this.monitor.recordConnect();
+            return this.subscriptions.reload();
+          case message_types.ping:
+            return this.monitor.recordPing();
+          case message_types.confirmation:
+            return this.subscriptions.notify(identifier, "connected");
+          case message_types.rejection:
+            return this.subscriptions.reject(identifier);
+          default:
+            return this.subscriptions.notify(identifier, "received", message);
+        }
+      },
+      open: function() {
+        ActionCable.log("WebSocket onopen event, using '" + (this.getProtocol()) + "' subprotocol");
+        this.disconnected = false;
+        if (!this.isProtocolSupported()) {
+          ActionCable.log("Protocol is unsupported. Stopping monitor and disconnecting.");
+          return this.close({
+            allowReconnect: false
+          });
+        }
+      },
+      close: function(event) {
+        ActionCable.log("WebSocket onclose event");
+        if (this.disconnected) {
+          return;
+        }
+        this.disconnected = true;
+        this.monitor.recordDisconnect();
+        return this.subscriptions.notifyAll("disconnected", {
+          willAttemptReconnect: this.monitor.isRunning()
+        });
+      },
+      error: function() {
+        return ActionCable.log("WebSocket onerror event");
+      }
+    };
+
+    return Connection;
+
+  })();
+
+}).call(this);
+(function() {
+  var slice = [].slice;
+
+  ActionCable.Subscriptions = (function() {
+    function Subscriptions(consumer) {
+      this.consumer = consumer;
+      this.subscriptions = [];
+    }
+
+    Subscriptions.prototype.create = function(channelName, mixin) {
+      var channel, params, subscription;
+      channel = channelName;
+      params = typeof channel === "object" ? channel : {
+        channel: channel
+      };
+      subscription = new ActionCable.Subscription(this.consumer, params, mixin);
+      return this.add(subscription);
+    };
+
+    Subscriptions.prototype.add = function(subscription) {
+      this.subscriptions.push(subscription);
+      this.consumer.ensureActiveConnection();
+      this.notify(subscription, "initialized");
+      this.sendCommand(subscription, "subscribe");
+      return subscription;
+    };
+
+    Subscriptions.prototype.remove = function(subscription) {
+      this.forget(subscription);
+      if (!this.findAll(subscription.identifier).length) {
+        this.sendCommand(subscription, "unsubscribe");
+      }
+      return subscription;
+    };
+
+    Subscriptions.prototype.reject = function(identifier) {
+      var i, len, ref, results, subscription;
+      ref = this.findAll(identifier);
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        subscription = ref[i];
+        this.forget(subscription);
+        this.notify(subscription, "rejected");
+        results.push(subscription);
+      }
+      return results;
+    };
+
+    Subscriptions.prototype.forget = function(subscription) {
+      var s;
+      this.subscriptions = (function() {
+        var i, len, ref, results;
+        ref = this.subscriptions;
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          s = ref[i];
+          if (s !== subscription) {
+            results.push(s);
+          }
+        }
+        return results;
+      }).call(this);
+      return subscription;
+    };
+
+    Subscriptions.prototype.findAll = function(identifier) {
+      var i, len, ref, results, s;
+      ref = this.subscriptions;
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        s = ref[i];
+        if (s.identifier === identifier) {
+          results.push(s);
+        }
+      }
+      return results;
+    };
+
+    Subscriptions.prototype.reload = function() {
+      var i, len, ref, results, subscription;
+      ref = this.subscriptions;
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        subscription = ref[i];
+        results.push(this.sendCommand(subscription, "subscribe"));
+      }
+      return results;
+    };
+
+    Subscriptions.prototype.notifyAll = function() {
+      var args, callbackName, i, len, ref, results, subscription;
+      callbackName = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
+      ref = this.subscriptions;
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        subscription = ref[i];
+        results.push(this.notify.apply(this, [subscription, callbackName].concat(slice.call(args))));
+      }
+      return results;
+    };
+
+    Subscriptions.prototype.notify = function() {
+      var args, callbackName, i, len, results, subscription, subscriptions;
+      subscription = arguments[0], callbackName = arguments[1], args = 3 <= arguments.length ? slice.call(arguments, 2) : [];
+      if (typeof subscription === "string") {
+        subscriptions = this.findAll(subscription);
+      } else {
+        subscriptions = [subscription];
+      }
+      results = [];
+      for (i = 0, len = subscriptions.length; i < len; i++) {
+        subscription = subscriptions[i];
+        results.push(typeof subscription[callbackName] === "function" ? subscription[callbackName].apply(subscription, args) : void 0);
+      }
+      return results;
+    };
+
+    Subscriptions.prototype.sendCommand = function(subscription, command) {
+      var identifier;
+      identifier = subscription.identifier;
+      return this.consumer.send({
+        command: command,
+        identifier: identifier
+      });
+    };
+
+    return Subscriptions;
+
+  })();
+
+}).call(this);
+(function() {
+  ActionCable.Subscription = (function() {
+    var extend;
+
+    function Subscription(consumer, params, mixin) {
+      this.consumer = consumer;
+      if (params == null) {
+        params = {};
+      }
+      this.identifier = JSON.stringify(params);
+      extend(this, mixin);
+    }
+
+    Subscription.prototype.perform = function(action, data) {
+      if (data == null) {
+        data = {};
+      }
+      data.action = action;
+      return this.send(data);
+    };
+
+    Subscription.prototype.send = function(data) {
+      return this.consumer.send({
+        command: "message",
+        identifier: this.identifier,
+        data: JSON.stringify(data)
+      });
+    };
+
+    Subscription.prototype.unsubscribe = function() {
+      return this.consumer.subscriptions.remove(this);
+    };
+
+    extend = function(object, properties) {
+      var key, value;
+      if (properties != null) {
+        for (key in properties) {
+          value = properties[key];
+          object[key] = value;
+        }
+      }
+      return object;
+    };
+
+    return Subscription;
+
+  })();
+
+}).call(this);
+(function() {
+  ActionCable.Consumer = (function() {
+    function Consumer(url) {
+      this.url = url;
+      this.subscriptions = new ActionCable.Subscriptions(this);
+      this.connection = new ActionCable.Connection(this);
+    }
+
+    Consumer.prototype.send = function(data) {
+      return this.connection.send(data);
+    };
+
+    Consumer.prototype.connect = function() {
+      return this.connection.open();
+    };
+
+    Consumer.prototype.disconnect = function() {
+      return this.connection.close({
+        allowReconnect: false
+      });
+    };
+
+    Consumer.prototype.ensureActiveConnection = function() {
+      if (!this.connection.isActive()) {
+        return this.connection.open();
+      }
+    };
+
+    return Consumer;
+
+  })();
+
+}).call(this);
+
+var glowing = {}
+function glow(cls) {
+  if (!glowing[cls]) {
+    var node = rubrowser.node.filter(function(d){
+      return d.id == cls;
+    });
+
+    if (node.size() > 0){
+      node.classed("running", true);
+      glowing[cls] = true;
+      setTimeout(function(){
+        glowing[cls] = false;
+        node.classed("running", false);
+      }, 2000)
+    }
+  }
+}
+
+var cable = ActionCable.createConsumer(server)
+cable.ensureActiveConnection()
+var channel = cable.subscriptions.create(
+  "classes",
+  {
+    received: function(data){
+      glow(data.message);
+    }
+  }
+)

data/readme.md

@@ -51,9 +51,10 @@ gem install rubrowser
 
 
 ```
-Usage: rubrowser [options] [file] ...
+Usage: /home/emad/code/rubrowser/bin/rubrowser [options] [file] ...
     -o, --output=FILE                output file page, if not specified output will be written to stdout
     -l, --layout=FILE                layout file to apply on the resulting graph
+    -s, --server=SERVER:PORT         rubrowser server for execution monitoring
     -T, --no-toolbox                 Don't display toolbox on the page
     -v, --version                    Print Rubrowser version
     -h, --help                       Prints this help
@@ -71,6 +72,30 @@ it to a file, and open it in your browser
 rubrowser > output.html
 ```
 
+## Monitoring your application execution
+
+Add rubrowser to your ruby project `Gemfile`
+```
+gem 'rubrowser'
+```
+
+Add the following code before your application runs, if it's a rails project
+this should be an initializer
+
+```
+Rubrowser::Monitor.run(path: Rails.root.to_s, port: 8080)
+```
+
+path is your code path, and port is the execution websocket server port, the
+server will open that port and announce any execution happens to the code inside
+your project directory.
+
+now generate a rubrowser HTML output that connect to your server
+
+```
+rubrowser -slocalhost:8080 > output.html
+```
+
 ## Using a saved layout
 
 When you move classes/modules in the graph to fix them in one place, then you
@@ -96,6 +121,7 @@ follow that naming, your project will be ready in that case.
 
 ## Features
 
+* trace your execution in realtime on the graph
 * interactive graph, you can pull any node to fix it to some position
 * to release node double click on it
 * zoom and pan with mouse or touch pad

data/rubrowser.gemspec

@@ -20,6 +20,10 @@ Gem::Specification.new do |s|
   s.require_paths = ['lib']
 
   s.add_runtime_dependency 'parser', '~> 2.3', '>= 2.3.0'
+  s.add_runtime_dependency 'puma'
+  s.add_runtime_dependency 'litecable'
+  s.add_runtime_dependency 'websocket'
+
   s.add_development_dependency 'bundler', '~> 1.14'
   s.add_development_dependency 'rake', '~> 10.0'
   s.add_development_dependency 'byebug'

data/views/index.erb

@@ -26,5 +26,12 @@
       <%= erb :toolbox %>
       <script type='text/javascript'><%= file('javascript/toolbox.js') %></script>
     <% end %>
+
+    <% if server %>
+      <script type='text/javascript'>
+       server = "ws://<%= server %>";
+       <%= file('javascript/websocket.js') %>
+      </script>
+    <% end %>
   </body>
 </html>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubrowser
 version: !ruby/object:Gem::Version
-  version: 2.6.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Emad Elsaid
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-15 00:00:00.000000000 Z
+date: 2018-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -30,6 +30,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.3.0
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: litecable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -121,9 +163,12 @@ files:
 - _config.yml
 - bin/rubrowser
 - lib/rubrowser.rb
+- lib/rubrowser/channel.rb
+- lib/rubrowser/connection.rb
 - lib/rubrowser/data.rb
 - lib/rubrowser/formatter/json.rb
 - lib/rubrowser/graph.rb
+- lib/rubrowser/monitor.rb
 - lib/rubrowser/parser/definition/base.rb
 - lib/rubrowser/parser/definition/class.rb
 - lib/rubrowser/parser/definition/module.rb
@@ -133,10 +178,13 @@ files:
 - lib/rubrowser/parser/file/builder.rb
 - lib/rubrowser/parser/relation/base.rb
 - lib/rubrowser/renderer.rb
+- lib/rubrowser/server.rb
+- lib/rubrowser/trace.rb
 - lib/rubrowser/version.rb
 - public/css/application.css
 - public/javascript/application.js
 - public/javascript/toolbox.js
+- public/javascript/websocket.js
 - readme.md
 - rubrowser.gemspec
 - views/index.erb
@@ -161,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.10
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: A ruby interactive dependency graph visualizer