rspectacles 0.0.1

data/lib/rspectacles/app/public/js/riffle.js

@@ -0,0 +1,200 @@
+(function (definition) {
+    // AMD
+    if (typeof define === "function") {
+        define(definition);
+    // CommonJS
+    } else if (typeof exports === "object") {
+        definition(this, exports);
+    // Browser
+    } else {
+        definition(this);
+    }
+}(function (require, exports, module) {
+    "use strict";
+    var old,
+        _;
+
+    exports = exports || window;
+
+    if (!window.setTimeout) {
+        return;
+    }
+
+    function stream(userSuppliedStreamFn) {
+        var chain = {};
+
+        function defaultStreamFn(output) {
+            var inputs = _.argumentsToArray(arguments);
+            inputs.shift();
+            if (inputs.length === 0) {
+                window.setTimeout(function () {
+                    output();
+                }, 0);
+            }
+            _.each(inputs, function invokeOutput(input) {
+                if (!_.isUndefined(input)) {
+                    window.setTimeout(function delayedInvokeOutput() {
+                        output(input);
+                    }, 0);
+                }
+            });
+        }
+
+        (function () {
+            var outputFns = [], streamFn;
+            function outputAllFns() {
+                var outputs = _.argumentsToArray(arguments);
+                _.each(outputFns, function applyFunction(f) {
+                    _.applyArgsToFn(f, outputs);
+                });
+            }
+            streamFn = _.isFunction(userSuppliedStreamFn) ? userSuppliedStreamFn : defaultStreamFn;
+            chain.invoke = function invoke() {
+                var outputs = _.argumentsToArray(arguments);
+                outputs.unshift(outputAllFns);
+                _.applyArgsToFn(streamFn, outputs);
+                return chain;
+            };
+            chain.onOutput = function onOutput(f) {
+                if (!_.isFunction(f)) {
+                    throw new Error('onOutput expecting callback function');
+                }
+                outputFns.push(f);
+                return chain;
+            };
+            chain.offOutput = function offOutput(f) {
+                if (!_.isFunction(f)) {
+                    throw new Error('offOutput expecting callback function');
+                }
+                outputFns = _.reject(outputFns, function isSameAsReferenceInScope(x) {
+                    return x === f;
+                });
+                return chain;
+            };
+        }());
+
+        (function () {
+            var callbacks = [],
+                inputStreams = [];
+            function wait(streams, idx) {
+                var unbindStreams = inputStreams[idx];
+                function invokeWithOneArg(x) {
+                    var outputs = [];
+                    outputs.length = idx + 1;
+                    outputs[idx] = x;
+                    chain.invoke.apply(window, _.isUndefined(x) ? [] : outputs);
+                }
+                if (unbindStreams) {
+                    _.each(unbindStreams, function unbindInputs(s) {
+                        s.offOutput(callbacks[idx]);
+                    });
+                    delete callbacks[idx];
+                    delete inputStreams[idx];
+                }
+                _.each(streams, function registerOnOutput(stream) {
+                    stream.onOutput(invokeWithOneArg);
+                });
+                callbacks[idx] = invokeWithOneArg;
+                inputStreams[idx] = streams;
+            }
+            chain.input = function input() {
+                var i, removeStreamIndexes = [];
+                _.each(arguments, function bindInputs(inputs, inIdx) {
+                    if (stream.isStream(inputs)) {
+                        inputs = [inputs];
+                    }
+                    if (_.isArray(inputs)) {
+                        inputs = _.reject(inputs, function isNotStream(obj) {
+                            return !stream.isStream(obj);
+                        });
+                        wait(inputs, inIdx);
+                    }
+                });
+                for (i = arguments.length; i < inputStreams.length; i += 1) {
+                    removeStreamIndexes.push(i);
+                }
+                _.each(removeStreamIndexes, function (idx) {
+                    _.each(inputStreams[idx], function (stream) { stream.offOutput(callbacks[idx]); });
+                    delete callbacks[idx];
+                    delete inputStreams[idx];
+                });
+                return chain;
+            };
+        }());
+        return chain;
+    }
+
+    stream.isStream = function isStream(x) {
+        return !!(x && x.invoke && x.onOutput && x.offOutput && x.input);
+    };
+
+    old = exports.stream;
+    stream.noConflict = function noConflict() {
+        exports.stream = old;
+        return stream;
+    };
+    exports.stream = stream;
+
+    _ = {
+        breaker: {},
+        arrayProto: Array.prototype,
+        objProto: Object.prototype,
+        isArray: Array.isArray || function isArray(obj) {
+            return _.objProto.toString.call(obj) === '[object Array]';
+        },
+        isFunction: function isFunction(obj) {
+            return _.objProto.toString.call(obj) === '[object Function]';
+        },
+        isUndefined: function isUndefined(obj) {
+            return obj === void 0;
+        },
+        argumentsToArray: function argumentsToArray(args) {
+            return _.arrayProto.slice.call(args);
+        },
+        applyArgsToFn: function applyArgsToFn(fn, args) {
+            try {
+                fn.apply(window, args);
+            } catch (e) {
+                if (console && console.exception) {
+                    console.exception(e);
+                }
+            }
+        },
+        each: function each(obj, iterator, context) {
+            var i, l, key;
+            if (obj === null) {
+                return;
+            }
+            if (_.arrayProto.forEach && obj.forEach === _.arrayProto.forEach) {
+                obj.forEach(iterator, context);
+            } else if (obj.length === +obj.length) {
+                for (i = 0, l = obj.length; i < l; i += 1) {
+                    if (obj.hasOwnProperty(i) && iterator.call(context, obj[i], i, obj) === _.breaker) {
+                        return;
+                    }
+                }
+            } else {
+                for (key in obj) {
+                    if (obj.hasOwnProperty(key)) {
+                        if (iterator.call(context, obj[key], key, obj) === _.breaker) {
+                            return;
+                        }
+                    }
+                }
+            }
+        },
+        reject: function reject(obj, iterator, context) {
+            var results = [];
+            if (obj === null) {
+                return results;
+            }
+            _.each(obj, function exclude(value, index, list) {
+                if (!iterator.call(context, value, index, list)) {
+                    results[results.length] = value;
+                }
+            });
+            return results;
+        }
+    };
+
+}));

data/lib/rspectacles/app/public/js/script.js

@@ -0,0 +1,26 @@
+/*global require: true */
+require(['chart', 'exampleStream'], function (chart, examples) {
+  'use strict';
+
+  var
+      bodyEl = document.querySelector('body')
+    , uri = bodyEl.dataset.streamUrl
+    , streams = examples(uri)
+    , c = chart()
+    ;
+
+  streams.start.onOutput(function (data) {
+    c.reset();
+  });
+
+  streams.message.onOutput(function (data) {
+    console.log('message logged', data);
+  });
+
+  streams.example.onOutput(function (data) {
+    c.push(data);
+  });
+
+  c.render();
+  window.c = c;
+});

data/lib/rspectacles/app/views/index.erb

@@ -0,0 +1,29 @@
+<!DOCTYPE html>
+
+<html>
+<head>
+  <title>RSpectacles</title>
+  <link rel='stylesheet' href='<%= url 'css/style.css' %>' />
+</head>
+<body data-stream-url=<%= url '/stream' %>>
+  <form>
+    <label><input type="radio" name="mode" value="size" checked> Time</label>
+    <label><input type="radio" name="mode" value="count"> Count</label>
+  </form>
+
+  <div class='example-wrapper' id='template'>
+    <ul class='example-details'>
+      <li id='name'></li>
+      <li>Line Number: <span id='line_number'></span></li>
+      <li>Status: <span id='status'></span></li>
+      <li>
+        <span id='value'></span> <span id='time_or_count'></span>
+      </li>
+    </ul>
+  </div>
+
+  <script type='text/javascript' src='<%= url '/js/d3.js' %>'></script>
+  <script type='text/javascript' src='<%= url '/js/plates.js' %>'></script>
+  <script type='text/javascript' data-main='<%= url 'js/script' %>' src='<%= url '/js/require.js' %>'></script>
+</body>
+</html>

data/lib/rspectacles/app.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'json'
+require 'em-hiredis'
+require 'uri'
+require 'thin'
+require 'pry'
+
+# Helpers
+# require './lib/render_partial'
+# require './db/config'
+
+
+module RSpectacles
+  class App < Sinatra::Base
+    connections = []
+    dir = File.dirname(File.expand_path(__FILE__))
+    set :app_file, __FILE__
+    set :root, dir
+    set :views, "#{dir}/app/views"
+    set :static, true
+
+    if respond_to? :public_folder
+      set :public_folder, "#{dir}/app/public"
+    else
+      set :public, "#{dir}/app/public"
+    end
+
+    uri = URI.parse 'redis://127.0.0.1:6379/'
+    $emredis = nil
+
+    # Routes
+    get '/' do
+      erb :index
+    end
+
+    get '/stream', :provides => 'text/event-stream' do
+      stream :keep_open do |out|
+        connections << out
+        out.callback { connections.delete(out) }
+        dump_last_run out
+      end
+    end
+
+    def dump_last_run(out)
+      $emredis.lrange('redis-rspec-last-run', 0, -1) do |list|
+        list.each { |msg| out << "data: #{msg}\n\n" }
+      end
+    end
+
+    EM.next_tick do
+      $emredis = EM::Hiredis.connect(uri)
+
+      $emredis.pubsub.subscribe 'redis-rspec-examples' do |message|
+        connections.each { |out| out << "data: #{message}\n\n" }
+      end
+    end
+  end
+end
+

data/lib/rspectacles/redis_formatter.rb

@@ -0,0 +1,84 @@
+require 'rspec/core/formatters/base_formatter'
+require 'ostruct'
+require 'redis'
+
+module RSpectacles
+  class RedisFormatter < RSpec::Core::Formatters::BaseFormatter
+    attr_accessor :redis
+
+    class << self
+      def config
+        OpenStruct.new({
+          channel_name: 'redis-rspec-examples',
+          last_run_key: 'redis-rspec-last-run',
+          port: 6379,
+          host: '127.0.0.1',
+          password: ''
+        })
+      end
+    end
+
+    def initialize(output)
+      self.redis = Redis.new host: config.host, port: config.port
+    end
+
+    def message(message)
+      log "message:#{message}"
+    end
+
+    def start(example_count)
+      log 'status:start'
+      redis.del config.last_run_key
+    end
+
+    def stop
+      log 'status:stop'
+    end
+
+    def example_started(example)
+    end
+
+    def example_passed(example)
+      log_formatted example
+    end
+
+    def example_pending(example)
+      log_formatted example
+    end
+
+    def example_failed(example)
+      log_formatted example
+    end
+
+    def close
+    end
+
+    private
+
+    def config
+      self.class.config
+    end
+
+    def log(message)
+      redis.publish config.channel_name, message
+      redis.lpush config.last_run_key, message
+    end
+
+    def log_formatted(example)
+      message = format_example(example)
+      redis.publish config.channel_name, message
+      redis.lpush config.last_run_key, message
+    end
+
+    def format_example(example)
+      {
+        :description => example.description,
+        :full_description => example.full_description,
+        :status => example.execution_result[:status],
+        :duration => example.execution_result[:run_time],
+        :file_path => example.metadata[:file_path],
+        :line_number  => example.metadata[:line_number]
+      }.to_json
+    end
+  end
+end

data/lib/rspectacles/version.rb

@@ -0,0 +1,3 @@
+module RSpectacles
+  VERSION='0.0.1'
+end

data/lib/rspectacles.rb

@@ -0,0 +1 @@
+require 'rspectacles/app.rb'

data/rspectacles.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'rspectacles/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'rspectacles'
+  s.version     = RSpectacles::VERSION
+  s.authors     = ['Michael Wheeler']
+  s.email       = ['mwheeler@g2crowd.com']
+  s.homepage    = 'https://github.com/wheeyls/rspectacles'
+  s.summary     = %q{Visualize rspec test running in the browser}
+  s.description = %q{Visualize rspec test running in the browser}
+
+  s.rubyforge_project = 'rspectacles'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency 'rspec'
+  s.add_dependency 'rake'
+  s.add_dependency 'thin', '>= 1.5.0'
+  s.add_dependency 'sinatra', '~> 1.4.3'
+  s.add_dependency 'em-hiredis', '~> 0.2.1'
+end

data/spec/javascripts/resources/qunit.css

@@ -0,0 +1,244 @@
+/**
+ * QUnit v1.12.0 - A JavaScript Unit Testing Framework
+ *
+ * http://qunitjs.com
+ *
+ * Copyright 2012 jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ */
+
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
+	margin: 0;
+	padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+	padding: 0.5em 0 0.5em 1em;
+
+	color: #8699a4;
+	background-color: #0d3349;
+
+	font-size: 1.5em;
+	line-height: 1em;
+	font-weight: normal;
+
+	border-radius: 5px 5px 0 0;
+	-moz-border-radius: 5px 5px 0 0;
+	-webkit-border-top-right-radius: 5px;
+	-webkit-border-top-left-radius: 5px;
+}
+
+#qunit-header a {
+	text-decoration: none;
+	color: #c2ccd1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+	color: #fff;
+}
+
+#qunit-testrunner-toolbar label {
+	display: inline-block;
+	padding: 0 .5em 0 .1em;
+}
+
+#qunit-banner {
+	height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+	padding: 0.5em 0 0.5em 2em;
+	color: #5E740B;
+	background-color: #eee;
+	overflow: hidden;
+}
+
+#qunit-userAgent {
+	padding: 0.5em 0 0.5em 2.5em;
+	background-color: #2b81af;
+	color: #fff;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+#qunit-modulefilter-container {
+	float: right;
+}
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+	list-style-position: inside;
+}
+
+#qunit-tests li {
+	padding: 0.4em 0.5em 0.4em 2.5em;
+	border-bottom: 1px solid #fff;
+	list-style-position: inside;
+}
+
+#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
+	display: none;
+}
+
+#qunit-tests li strong {
+	cursor: pointer;
+}
+
+#qunit-tests li a {
+	padding: 0.5em;
+	color: #c2ccd1;
+	text-decoration: none;
+}
+#qunit-tests li a:hover,
+#qunit-tests li a:focus {
+	color: #000;
+}
+
+#qunit-tests li .runtime {
+	float: right;
+	font-size: smaller;
+}
+
+.qunit-assert-list {
+	margin-top: 0.5em;
+	padding: 0.5em;
+
+	background-color: #fff;
+
+	border-radius: 5px;
+	-moz-border-radius: 5px;
+	-webkit-border-radius: 5px;
+}
+
+.qunit-collapsed {
+	display: none;
+}
+
+#qunit-tests table {
+	border-collapse: collapse;
+	margin-top: .2em;
+}
+
+#qunit-tests th {
+	text-align: right;
+	vertical-align: top;
+	padding: 0 .5em 0 0;
+}
+
+#qunit-tests td {
+	vertical-align: top;
+}
+
+#qunit-tests pre {
+	margin: 0;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+}
+
+#qunit-tests del {
+	background-color: #e0f2be;
+	color: #374e0c;
+	text-decoration: none;
+}
+
+#qunit-tests ins {
+	background-color: #ffcaca;
+	color: #500;
+	text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+	padding: 5px;
+	background-color: #fff;
+	border-bottom: none;
+	list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+	color: #3c510c;
+	background-color: #fff;
+	border-left: 10px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+	color: #710909;
+	background-color: #fff;
+	border-left: 10px solid #EE5757;
+	white-space: pre;
+}
+
+#qunit-tests > li:last-child {
+	border-radius: 0 0 5px 5px;
+	-moz-border-radius: 0 0 5px 5px;
+	-webkit-border-bottom-right-radius: 5px;
+	-webkit-border-bottom-left-radius: 5px;
+}
+
+#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
+
+
+/** Result */
+
+#qunit-testresult {
+	padding: 0.5em 0.5em 0.5em 2.5em;
+
+	color: #2b81af;
+	background-color: #D2E0E6;
+
+	border-bottom: 1px solid white;
+}
+#qunit-testresult .module-name {
+	font-weight: bold;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+	position: absolute;
+	top: -10000px;
+	left: -10000px;
+	width: 1000px;
+	height: 1000px;
+}