rubrowser 2.5.0 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e67fd969c9155da49e88d2cc1fd703ac364064841a3800ad03c70bc7c922bfc7
-  data.tar.gz: 478c3f44d920a685109f24630e17658f3854adc3db675596baa285e4ec8e4538
+  metadata.gz: 42ce16c03f4558e78873eb558f1c516e5ce9cad721b951d9f7ecdf31c14c3cc8
+  data.tar.gz: 5c39ffdef3e17fc6a13ee5a2ac12007983111686a557faa7c45143f9009527d1
 SHA512:
-  metadata.gz: 454bcb581e7fa255cce469d2b82f4321aa0d9f2cf127d2439a99ab437836028587d05a75214b224e1930c971c8b93739aa85838f1a3588658c3909c9d7c84d50
-  data.tar.gz: 5281d603a1ab859d8609fb05a04ecb63b923beb65977e89ce628a8e6716d17c817eae2ec43e53496f377d348aced37f923374022cf9b5540191157a332bc0f25
+  metadata.gz: dbbe9eb3162ec5570ef422675937c174852e16efd7fef2e761cb618cd53b932887dc8e9607ce521bd6a4fe3cb8d2ebf821b9f77ad3abb4361fbddc8afd015e35
+  data.tar.gz: bf19b719776bf0c35c60dc250fef2ce29225f2b7158632c19b0c2b1bbba5aec18d31b8e227d33443f89d278c3f84f995e06d399187dc3fa283b17e0b9d1ee45c

data/.rubocop.yml

@@ -5,3 +5,7 @@ Style/Documentation:
   Enabled: false
 Style/FrozenStringLiteralComment:
   Enabled: false
+Style/GlobalVars:
+  Enabled: false
+Metrics/BlockLength:
+  Enabled: false

data/.rubrowser

@@ -1 +1 @@
-[{"id":"Rubrowser::Data","x":905.0088057752334,"y":437.04147016200284},{"id":"Rubrowser","x":712.6220053486966,"y":770.3251873644217},{"id":"Rubrowser::Formatter::JSON","x":1114.4368770370438,"y":560.0312580369882},{"id":"Rubrowser::Formatter","x":1113.6584254066838,"y":601.6487084046246},{"id":"Graph","x":1115.7752854976002,"y":436.6211350242928},{"id":"Rubrowser::Parser::Definition::Base","x":-8.218934126737395,"y":322.74585638398685},{"id":"Rubrowser::Parser::Definition","x":-191.1839782278871,"y":318.6377197576412},{"id":"Rubrowser::Parser","x":713.688310910547,"y":660.9646559993857},{"id":"Rubrowser::Parser::Definition::Class","x":186.15033111747857,"y":246.30753307276427},{"id":"Rubrowser::Parser::Definition::Module","x":188.36911863082037,"y":324.35744429623855},{"id":"Rubrowser::Parser::Directory","x":786.9998045114313,"y":239.74214301898786},{"id":"Rubrowser::Parser::Factory","x":788.0050388528484,"y":325.70343641742613},{"id":"Rubrowser::Parser::File::Builder","x":506.8969046429671,"y":189.48025894394402},{"id":"Rubrowser::Parser::File","x":505.82216034587793,"y":322.6733725221146},{"id":"Rubrowser::Parser::Relation::Base","x":185.12905462589924,"y":402.5519743127113},{"id":"Rubrowser::Parser::Relation","x":187.0097719718301,"y":461.8654698954514},{"id":"Rubrowser::Renderer","x":905.2158605930458,"y":560.8807631671766}]
+[{"id":"A","x":3145.151252107328,"y":1255.7202242818169},{"id":"B","x":3041.815436574058,"y":1133.5156582815155},{"id":"C","x":3199.274701857475,"y":1105.1153162475819},{"id":"ClassWithOneClassDependency","x":1557.2872222716092,"y":-43.47687773940923},{"id":"ModuleWithNoRelations","x":1306.9528557451522,"y":1102.2650375990502},{"id":"ClassWithOneIncludedMixin","x":1498.1264029065396,"y":1151.463703990889},{"id":"ClassWithOneExtendedMixin","x":1505.8925222231119,"y":1066.3427953527182},{"id":"ModuleWithOneClassDependency","x":1506.2730755201367,"y":108.22508398850451},{"id":"ClassWithNoRelations","x":1400.4239271808685,"y":-11.760907506717134},{"id":"Rubrowser::Data","x":905.0088057752334,"y":437.04147016200284},{"id":"Rubrowser","x":712.6220053486966,"y":770.3251873644217},{"id":"Rubrowser::Trace","x":197.20494882540459,"y":735.0751347963624},{"id":"Rubrowser::Monitor","x":430.7305845891392,"y":680.3256207864202},{"id":"Graph","x":1115.7752854976002,"y":436.6211350242928},{"id":"Rubrowser::Connection","x":4.873283667279907,"y":680.4067753374231},{"id":"Rubrowser::Channel","x":1366.414402671432,"y":185.96446885474367},{"id":"Rubrowser::Renderer","x":905.2158605930458,"y":560.8807631671766},{"id":"Rubrowser::Server","x":208.96464998862217,"y":631.2323207047698},{"id":"Rubrowser::Formatter::JSON","x":1114.4368770370438,"y":560.0312580369882},{"id":"Rubrowser::Formatter","x":1113.6584254066838,"y":601.6487084046246},{"id":"Rubrowser::Parser::Definition::Module","x":188.36911863082037,"y":324.35744429623855},{"id":"Rubrowser::Parser::Definition","x":-191.1839782278871,"y":318.6377197576412},{"id":"Rubrowser::Parser","x":713.688310910547,"y":660.9646559993857},{"id":"Rubrowser::Parser::Definition::Base","x":-8.218934126737395,"y":322.74585638398685},{"id":"Rubrowser::Parser::Definition::Class","x":186.15033111747857,"y":246.30753307276427},{"id":"Rubrowser::Parser::Relation::Base","x":185.12905462589924,"y":402.5519743127113},{"id":"Rubrowser::Parser::Relation","x":187.0097719718301,"y":461.8654698954514},{"id":"Rubrowser::Parser::Factory","x":788.0050388528484,"y":325.70343641742613},{"id":"Rubrowser::Parser::File::Builder","x":506.8969046429671,"y":189.48025894394402},{"id":"Rubrowser::Parser::File","x":505.82216034587793,"y":322.6733725221146},{"id":"Rubrowser::Parser::Directory","x":786.9998045114313,"y":239.74214301898786}]

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.2
+  - 2.3
+  - 2.4
+  - 2.5

data/Gemfile.lock

@@ -1,55 +1,71 @@
 PATH
   remote: .
   specs:
-    rubrowser (2.5.0)
-      parser (~> 2.3, >= 2.3.0)
+    rubrowser (2.9.0)
+      litecable
+      parser
+      puma
+      websocket
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ast (2.2.0)
-    byebug (9.0.6)
-    diff-lcs (1.3)
-    parallel (1.12.0)
-    parser (2.4.0.0)
-      ast (~> 2.2)
-    powerpack (0.1.1)
-    rainbow (2.2.2)
-      rake
-    rake (10.4.2)
-    rspec (3.6.0)
-      rspec-core (~> 3.6.0)
-      rspec-expectations (~> 3.6.0)
-      rspec-mocks (~> 3.6.0)
-    rspec-core (3.6.0)
-      rspec-support (~> 3.6.0)
-    rspec-expectations (3.6.0)
+    anyway_config (2.0.6)
+      ruby-next-core (>= 0.8.0)
+    ast (2.4.1)
+    byebug (11.1.3)
+    diff-lcs (1.4.4)
+    litecable (0.7.0)
+      anyway_config (>= 1.0)
+    nio4r (2.5.2)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
+    puma (4.3.5)
+      nio4r (~> 2.0)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    regexp_parser (1.7.1)
+    rexml (3.2.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-mocks (3.6.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.6.0)
-    rspec-support (3.6.0)
-    rubocop (0.49.1)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    rubocop (0.88.0)
       parallel (~> 1.10)
-      parser (>= 2.3.3.1, < 3.0)
-      powerpack (~> 0.1)
-      rainbow (>= 1.99.1, < 3.0)
+      parser (>= 2.7.1.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.1.0, < 1.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.0, >= 1.0.1)
-    ruby-progressbar (1.8.1)
-    unicode-display_width (1.3.0)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.3.0)
+      parser (>= 2.7.1.4)
+    ruby-next-core (0.9.2)
+    ruby-progressbar (1.10.1)
+    unicode-display_width (1.7.0)
+    websocket (1.2.8)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.14)
+  bundler
   byebug
-  rake (~> 10.0)
+  rake
   rspec
   rubocop
   rubrowser!
 
 BUNDLED WITH
-   1.16.1
+   2.1.4

data/bin/rubrowser

@@ -12,20 +12,34 @@ options = {
 }
 
 OptionParser.new do |opts|
-  opts.banner = "Usage: #{__FILE__} [options] [file] ..."
-
-  opts.on('-oFILE', '--output=FILE', 'output file page, if not specified output will be written to stdout') do |output|
-    options[:output] = output
-  end
-
-  opts.on('-lFILE', '--layout=FILE', 'layout file to apply on the resulting graph') do |layout|
-    options[:layout] = layout
-  end
+  opts.banner = "Usage: #{File.basename(__FILE__)} [options] [file] ..."
+
+  opts.on(
+    '-oFILE',
+    '--output=FILE',
+    'output file page, if not specified output will be written to stdout'
+  ) { |output| options[:output] = output }
+
+  opts.on(
+    '-lFILE',
+    '--layout=FILE',
+    '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
 
+  opts.on('-j', '--json', 'Do export data as JSON instead of HTML') do
+    options[:json] = true
+  end
+
   opts.on('-v', '--version', 'Print Rubrowser version') do
     puts "Rubrowser #{Rubrowser::VERSION}"
     exit

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(100_000)
+      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,21 @@
+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

@@ -12,20 +12,26 @@ module Rubrowser
     end
 
     def call
-      output.write(erb(:index))
+      if @json
+        output.write(data)
+      else
+        output.write(erb(:index))
+      end
     end
 
     private
 
     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]
+      @json = !!options[:json]
     end
 
     def output_file(path)

data/lib/rubrowser/server.rb

@@ -0,0 +1,43 @@
+require 'lite_cable'
+require 'lite_cable/server'
+require 'puma/configuration'
+require 'puma/launcher'
+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: 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.5.0'.freeze
+  VERSION = '2.9.0'.freeze
 end

data/public/css/application.css

@@ -4,18 +4,19 @@ html, body, .dependency_graph, .dependency_graph svg{
     padding: 0px;
     margin: 0px;
     font-size: 13px;
+    overflow: hidden;
 }
 
 .link {
-  fill: none;
-  stroke: #666;
-  stroke-width: 1.5px;
+    fill: none;
+    stroke: #666;
+    stroke-width: 1.5px;
 }
 
 circle {
-  fill: #fff;
-  stroke: #333;
-  stroke-width: 1.5px;
+    fill: #fff;
+    stroke: #333;
+    stroke-width: 1.5px;
 }
 
 .circular {
@@ -23,13 +24,13 @@ circle {
 }
 
 .fixed circle {
-  stroke-width: 3px;
+    stroke-width: 3px;
 }
 
 text {
-  font: 10px sans-serif;
-  pointer-events: none;
-  text-shadow: 0 1px 0 #fff, 1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
+    font: 10px sans-serif;
+    pointer-events: none;
+    text-shadow: 0 1px 0 #fff, 1px 0 0 #fff, 0 -1px 0 #fff, -1px 0 0 #fff;
 }
 
 text.type{
@@ -44,6 +45,11 @@ text.type{
     display: none;
 }
 
+.running circle{
+    stroke: #18b738;
+    fill: #7dea93;
+}
+
 .highlighted,
 .highlighted_by_namespace,
 .highlighted_by_path,
@@ -83,3 +89,24 @@ ul, ol{
     padding-left: 0px;
     overflow: auto;
 }
+
+#information_panel{
+    position: fixed;
+    bottom: 0px;
+    left: 0px;
+    height: 5rem;
+    background: rgba(255,255,255,0.8);
+    width: 100%;
+    margin-left: 250px;
+    padding-right: 250px;
+}
+
+#information_panel div{
+    margin: 1rem;
+    display: inline-block;
+}
+
+#information_panel:hover{
+    height: 33%;
+    overflow: auto;
+}

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);
+    }
+  }
+)