RubyGems - rack-livereload - Versions diffs - 0.1.0 - Mend

rack-livereload 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

data/.gitignore +4 -0
data/Gemfile +4 -0
data/Guardfile +9 -0
data/README.md +47 -0
data/Rakefile +11 -0
data/config.ru +13 -0
data/js/livereload.js +804 -0
data/lib/rack-livereload.rb +6 -0
data/lib/rack/livereload.rb +55 -0
data/rack-livereload.gemspec +34 -0
data/spec/rack/livereload_spec.rb +74 -0
data/spec/spec_helper.rb +7 -0
metadata +169 -0

data/.gitignore ADDED

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile ADDED

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+# Specify your gem's dependencies in rack-livereload.gemspec
+gemspec

data/Guardfile ADDED

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md ADDED

@@ -0,0 +1,47 @@
+Hey, you've got [LiveReload](http://www.livereload.com/) in my [Rack](http://rack.rubyforge.org/)!
+No need for browser extensions anymore! Just plug it in your middleware stack and go!
+Use this with [guard-livereload](http://github.com/guard/guard-livereload) for maximum fun!
+## Using in...
+### Rails
+In `config/environments/development.rb`:
+``` ruby
+MyApp::Application.configure do
+  config.middleware.insert_before(Rack::Lock, Rack::LiveReload)
+  # ...or, change some options...
+  config.middleware.insert_before(
+    Rack::Lock, Rack::LiveReload,
+    :min_delay => 500,
+    :max_delay => 10000,
+    :port => 56789,
+    :host => 'myhost.cool.wow'
+  )
+end
+```
+### config.ru/Sinatra
+``` ruby
+require 'rack-livereload'
+use Rack::LiveReload
+# ...or...
+use Rack::LiveReload, :min_delay => 500, ...
+```
+## How it works
+The necessary `script` tag to bring in a vendored copy of [livereload.js](https://github.com/livereload/livereload-js) is
+injected right before the closing `head` tag in any `text/html` pages that come through. The `script` tag is built in
+such a way that the `HTTP_HOST` is used as the LiveReload host, so you can connect from external machines (say, to
+`mycomputer:3000` instead of `localhost:3000`) and as long as the LiveReload port is accessible from the external machine,
+you'll connect and be LiveReloading away!
+As usual, super-alpha!

data/Rakefile ADDED

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+desc 'Update livereload.js'
+task :update_livereload_js do
+  require 'httparty'
+  File.open('js/livereload.js', 'wb') { |fh|
+    fh.print HTTParty.get('https://raw.github.com/livereload/livereload-js/master/dist/livereload.js').body
+  }
+end

data/config.ru ADDED

@@ -0,0 +1,13 @@
+require 'sinatra'
+$: << 'lib'
+require 'rack/livereload'
+use Rack::LiveReload
+get '/' do
+  "<html><head><title>Hi</title></head><body>Hi</body></html>"
+end
+run Sinatra::Application

data/js/livereload.js ADDED

@@ -0,0 +1,804 @@
+(function() {
+var __customevents = {}, __protocol = {}, __connector = {}, __timer = {}, __options = {}, __reloader = {}, __livereload = {}, __startup = {};
+// customevents
+(function() {
+  var CustomEvents;
+  CustomEvents = {
+    bind: function(element, eventName, handler) {
+      if (element.addEventListener) {
+        return element.addEventListener(eventName, handler, false);
+      } else if (element.attachEvent) {
+        element[eventName] = 1;
+        return element.attachEvent('onpropertychange', function(event) {
+          if (event.propertyName === eventName) {
+            return handler();
+          }
+        });
+      } else {
+        throw new Error("Attempt to attach custom event " + eventName + " to something which isn't a DOMElement");
+      }
+    },
+    fire: function(element, eventName) {
+      var event;
+      if (element.addEventListener) {
+        event = document.createEvent('HTMLEvents');
+        event.initEvent(eventName, true, true);
+        return document.dispatchEvent(event);
+      } else if (element.attachEvent) {
+        if (element[eventName]) {
+          return element[eventName]++;
+        }
+      } else {
+        throw new Error("Attempt to fire custom event " + eventName + " on something which isn't a DOMElement");
+      }
+    }
+  };
+  __customevents.bind = CustomEvents.bind;
+  __customevents.fire = CustomEvents.fire;
+}).call(this);
+// protocol
+(function() {
+  var PROTOCOL_6, PROTOCOL_7, Parser, ProtocolError;
+  var __indexOf = Array.prototype.indexOf || function(item) {
+    for (var i = 0, l = this.length; i < l; i++) {
+      if (this[i] === item) return i;
+    }
+    return -1;
+  };
+  __protocol.PROTOCOL_6 = PROTOCOL_6 = 'http://livereload.com/protocols/official-6';
+  __protocol.PROTOCOL_7 = PROTOCOL_7 = 'http://livereload.com/protocols/official-7';
+  __protocol.ProtocolError = ProtocolError = (function() {
+    function ProtocolError(reason, data) {
+      this.message = "LiveReload protocol error (" + reason + ") after receiving data: \"" + data + "\".";
+    }
+    return ProtocolError;
+  })();
+  __protocol.Parser = Parser = (function() {
+    function Parser(handlers) {
+      this.handlers = handlers;
+      this.reset();
+    }
+    Parser.prototype.reset = function() {
+      return this.protocol = null;
+    };
+    Parser.prototype.process = function(data) {
+      var command, message, options, _ref;
+      try {
+        if (!(this.protocol != null)) {
+          if (data.match(/^!!ver:([\d.]+)$/)) {
+            this.protocol = 6;
+          } else if (message = this._parseMessage(data, ['hello'])) {
+            if (!message.protocols.length) {
+              throw new ProtocolError("no protocols specified in handshake message");
+            } else if (__indexOf.call(message.protocols, PROTOCOL_7) >= 0) {
+              this.protocol = 7;
+            } else if (__indexOf.call(message.protocols, PROTOCOL_6) >= 0) {
+              this.protocol = 6;
+            } else {
+              throw new ProtocolError("no supported protocols found");
+            }
+          }
+          return this.handlers.connected(this.protocol);
+        } else if (this.protocol === 6) {
+          message = JSON.parse(data);
+          if (!message.length) {
+            throw new ProtocolError("protocol 6 messages must be arrays");
+          }
+          command = message[0], options = message[1];
+          if (command !== 'refresh') {
+            throw new ProtocolError("unknown protocol 6 command");
+          }
+          return this.handlers.message({
+            command: 'reload',
+            path: options.path,
+            liveCSS: (_ref = options.apply_css_live) != null ? _ref : true
+          });
+        } else {
+          message = this._parseMessage(data, ['reload', 'alert']);
+          return this.handlers.message(message);
+        }
+      } catch (e) {
+        if (e instanceof ProtocolError) {
+          return this.handlers.error(e);
+        } else {
+          throw e;
+        }
+      }
+    };
+    Parser.prototype._parseMessage = function(data, validCommands) {
+      var message, _ref;
+      try {
+        message = JSON.parse(data);
+      } catch (e) {
+        throw new ProtocolError('unparsable JSON', data);
+      }
+      if (!message.command) {
+        throw new ProtocolError('missing "command" key', data);
+      }
+      if (_ref = message.command, __indexOf.call(validCommands, _ref) < 0) {
+        throw new ProtocolError("invalid command '" + message.command + "', only valid commands are: " + (validCommands.join(', ')) + ")", data);
+      }
+      return message;
+    };
+    return Parser;
+  })();
+}).call(this);
+// connector
+(function() {
+  var Connector, PROTOCOL_6, PROTOCOL_7, Parser, _ref;
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  _ref = __protocol, Parser = _ref.Parser, PROTOCOL_6 = _ref.PROTOCOL_6, PROTOCOL_7 = _ref.PROTOCOL_7;
+  __connector.Connector = Connector = (function() {
+    function Connector(options, WebSocket, Timer, handlers) {
+      this.options = options;
+      this.WebSocket = WebSocket;
+      this.Timer = Timer;
+      this.handlers = handlers;
+      this._uri = "ws://" + this.options.host + ":" + this.options.port + "/livereload";
+      this._nextDelay = this.options.mindelay;
+      this._connectionDesired = false;
+      this.protocolParser = new Parser({
+        connected: __bind(function(protocol) {
+          this._handshakeTimeout.stop();
+          this._nextDelay = this.options.mindelay;
+          this._disconnectionReason = 'broken';
+          return this.handlers.connected(protocol);
+        }, this),
+        error: __bind(function(e) {
+          this.handlers.error(e);
+          return this._closeOnError();
+        }, this),
+        message: __bind(function(message) {
+          return this.handlers.message(message);
+        }, this)
+      });
+      this._handshakeTimeout = new Timer(__bind(function() {
+        if (!this._isSocketConnected()) {
+          return;
+        }
+        this._disconnectionReason = 'handshake-timeout';
+        return this.socket.close();
+      }, this));
+      this._reconnectTimer = new Timer(__bind(function() {
+        if (!this._connectionDesired) {
+          return;
+        }
+        return this.connect();
+      }, this));
+      this.connect();
+    }
+    Connector.prototype._isSocketConnected = function() {
+      return this.socket && this.socket.readyState === this.WebSocket.OPEN;
+    };
+    Connector.prototype.connect = function() {
+      this._connectionDesired = true;
+      if (this._isSocketConnected()) {
+        return;
+      }
+      if (this._reconnectTimer) {
+        clearTimeout(this._reconnectTimer);
+      }
+      this._disconnectionReason = 'cannot-connect';
+      this.protocolParser.reset();
+      this.handlers.connecting();
+      this.socket = new this.WebSocket(this._uri);
+      this.socket.onopen = __bind(function(e) {
+        return this._onopen(e);
+      }, this);
+      this.socket.onclose = __bind(function(e) {
+        return this._onclose(e);
+      }, this);
+      this.socket.onmessage = __bind(function(e) {
+        return this._onmessage(e);
+      }, this);
+      return this.socket.onerror = __bind(function(e) {
+        return this._onerror(e);
+      }, this);
+    };
+    Connector.prototype.disconnect = function() {
+      this._connectionDesired = false;
+      this._reconnectTimer.stop();
+      if (!this._isSocketConnected()) {
+        return;
+      }
+      this._disconnectionReason = 'manual';
+      return this.socket.close();
+    };
+    Connector.prototype._scheduleReconnection = function() {
+      if (!this._connectionDesired) {
+        return;
+      }
+      if (!this._reconnectTimer.running) {
+        this._reconnectTimer.start(this._nextDelay);
+        return this._nextDelay = Math.min(this.options.maxdelay, this._nextDelay * 2);
+      }
+    };
+    Connector.prototype.sendCommand = function(command) {
+      if (this.protocol == null) {
+        return;
+      }
+      return this._sendCommand(command);
+    };
+    Connector.prototype._sendCommand = function(command) {
+      return this.socket.send(JSON.stringify(command));
+    };
+    Connector.prototype._closeOnError = function() {
+      this._handshakeTimeout.stop();
+      this._disconnectionReason = 'error';
+      return this.socket.close();
+    };
+    Connector.prototype._onopen = function(e) {
+      this.handlers.socketConnected();
+      this._disconnectionReason = 'handshake-failed';
+      this._sendCommand({
+        command: 'hello',
+        protocols: [PROTOCOL_6, PROTOCOL_7]
+      });
+      return this._handshakeTimeout.start(this.options.handshake_timeout);
+    };
+    Connector.prototype._onclose = function(e) {
+      this.handlers.disconnected(this._disconnectionReason, this._nextDelay);
+      return this._scheduleReconnection();
+    };
+    Connector.prototype._onerror = function(e) {};
+    Connector.prototype._onmessage = function(e) {
+      return this.protocolParser.process(e.data);
+    };
+    return Connector;
+  })();
+}).call(this);
+// timer
+(function() {
+  var Timer;
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  __timer.Timer = Timer = (function() {
+    function Timer(func) {
+      this.func = func;
+      this.running = false;
+      this.id = null;
+      this._handler = __bind(function() {
+        this.running = false;
+        this.id = null;
+        return this.func();
+      }, this);
+    }
+    Timer.prototype.start = function(timeout) {
+      if (this.running) {
+        clearTimeout(this.id);
+      }
+      this.id = setTimeout(this._handler, timeout);
+      return this.running = true;
+    };
+    Timer.prototype.stop = function() {
+      if (this.running) {
+        clearTimeout(this.id);
+        this.running = false;
+        return this.id = null;
+      }
+    };
+    return Timer;
+  })();
+  Timer.start = function(timeout, func) {
+    return setTimeout(func, timeout);
+  };
+}).call(this);
+// options
+(function() {
+  var Options;
+  __options.Options = Options = (function() {
+    function Options() {
+      this.host = null;
+      this.port = 35729;
+      this.snipver = null;
+      this.ext = null;
+      this.extver = null;
+      this.mindelay = 1000;
+      this.maxdelay = 60000;
+      this.handshake_timeout = 5000;
+    }
+    Options.prototype.set = function(name, value) {
+      switch (typeof this[name]) {
+        case 'undefined':
+          break;
+        case 'number':
+          return this[name] = +value;
+        default:
+          return this[name] = value;
+      }
+    };
+    return Options;
+  })();
+  Options.extract = function(document) {
+    var element, keyAndValue, m, mm, options, pair, src, _i, _j, _len, _len2, _ref, _ref2;
+    _ref = document.getElementsByTagName('script');
+    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+      element = _ref[_i];
+      if ((src = element.src) && (m = src.match(/^[^:]+:\/\/(.*)\/z?livereload\.js(?:\?(.*))?$/))) {
+        options = new Options();
+        if (mm = m[1].match(/^([^\/:]+)(?::(\d+))?$/)) {
+          options.host = mm[1];
+          if (mm[2]) {
+            options.port = parseInt(mm[2], 10);
+          }
+        }
+        if (m[2]) {
+          _ref2 = m[2].split('&');
+          for (_j = 0, _len2 = _ref2.length; _j < _len2; _j++) {
+            pair = _ref2[_j];
+            if ((keyAndValue = pair.split('=')).length > 1) {
+              options.set(keyAndValue[0].replace(/-/g, '_'), keyAndValue.slice(1).join('='));
+            }
+          }
+        }
+        return options;
+      }
+    }
+    return null;
+  };
+}).call(this);
+// reloader
+(function() {
+  var IMAGE_STYLES, Reloader, numberOfMatchingSegments, pathFromUrl, pathsMatch, pickBestMatch, splitUrl;
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  splitUrl = function(url) {
+    var hash, index, params;
+    if ((index = url.indexOf('#')) >= 0) {
+      hash = url.slice(index);
+      url = url.slice(0, index);
+    } else {
+      hash = '';
+    }
+    if ((index = url.indexOf('?')) >= 0) {
+      params = url.slice(index);
+      url = url.slice(0, index);
+    } else {
+      params = '';
+    }
+    return {
+      url: url,
+      params: params,
+      hash: hash
+    };
+  };
+  pathFromUrl = function(url) {
+    var path;
+    url = splitUrl(url).url;
+    if (url.indexOf('file://') === 0) {
+      path = url.replace(/^file:\/\/(localhost)?/, '');
+    } else {
+      path = url.replace(/^([^:]+:)?\/\/([^:\/]+)(:\d*)?\//, '/');
+    }
+    return decodeURIComponent(path);
+  };
+  pickBestMatch = function(path, objects, pathFunc) {
+    var bestMatch, object, score, _i, _len;
+    bestMatch = {
+      score: 0
+    };
+    for (_i = 0, _len = objects.length; _i < _len; _i++) {
+      object = objects[_i];
+      score = numberOfMatchingSegments(path, pathFunc(object));
+      if (score > bestMatch.score) {
+        bestMatch = {
+          object: object,
+          score: score
+        };
+      }
+    }
+    if (bestMatch.score > 0) {
+      return bestMatch;
+    } else {
+      return null;
+    }
+  };
+  numberOfMatchingSegments = function(path1, path2) {
+    var comps1, comps2, eqCount, len;
+    path1 = path1.replace(/^\/+/, '').toLowerCase();
+    path2 = path2.replace(/^\/+/, '').toLowerCase();
+    if (path1 === path2) {
+      return 10000;
+    }
+    comps1 = path1.split('/').reverse();
+    comps2 = path2.split('/').reverse();
+    len = Math.min(comps1.length, comps2.length);
+    eqCount = 0;
+    while (eqCount < len && comps1[eqCount] === comps2[eqCount]) {
+      ++eqCount;
+    }
+    return eqCount;
+  };
+  pathsMatch = function(path1, path2) {
+    return numberOfMatchingSegments(path1, path2) > 0;
+  };
+  IMAGE_STYLES = [
+    {
+      selector: 'background',
+      styleNames: ['backgroundImage']
+    }, {
+      selector: 'border',
+      styleNames: ['borderImage', 'webkitBorderImage', 'MozBorderImage']
+    }
+  ];
+  __reloader.Reloader = Reloader = (function() {
+    function Reloader(window, console, Timer) {
+      this.window = window;
+      this.console = console;
+      this.Timer = Timer;
+      this.document = this.window.document;
+      this.stylesheetGracePeriod = 200;
+      this.importCacheWaitPeriod = 200;
+    }
+    Reloader.prototype.reload = function(path, options) {
+      if (options.liveCSS) {
+        if (path.match(/\.css$/i)) {
+          if (this.reloadStylesheet(path)) {
+            return;
+          }
+        }
+        if (path.match(/\.less$/i) && this.window.less && this.window.less.refresh) {
+          this.window.less.refresh(true);
+          return;
+        }
+      }
+      if (options.liveImg) {
+        if (path.match(/\.(jpe?g|png|gif)$/i)) {
+          this.reloadImages(path);
+          return;
+        }
+      }
+      return this.reloadPage();
+    };
+    Reloader.prototype.reloadPage = function() {
+      return this.window.document.location.reload();
+    };
+    Reloader.prototype.reloadImages = function(path) {
+      var expando, img, selector, styleNames, styleSheet, _i, _j, _k, _l, _len, _len2, _len3, _len4, _ref, _ref2, _ref3, _ref4, _results;
+      expando = this.generateUniqueString();
+      _ref = this.document.images;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        img = _ref[_i];
+        if (pathsMatch(path, pathFromUrl(img.src))) {
+          img.src = this.generateCacheBustUrl(img.src, expando);
+        }
+      }
+      if (this.document.querySelectorAll) {
+        for (_j = 0, _len2 = IMAGE_STYLES.length; _j < _len2; _j++) {
+          _ref2 = IMAGE_STYLES[_j], selector = _ref2.selector, styleNames = _ref2.styleNames;
+          _ref3 = this.document.querySelectorAll("[style*=" + selector + "]");
+          for (_k = 0, _len3 = _ref3.length; _k < _len3; _k++) {
+            img = _ref3[_k];
+            this.reloadStyleImages(img.style, styleNames, path, expando);
+          }
+        }
+      }
+      if (this.document.styleSheets) {
+        _ref4 = this.document.styleSheets;
+        _results = [];
+        for (_l = 0, _len4 = _ref4.length; _l < _len4; _l++) {
+          styleSheet = _ref4[_l];
+          _results.push(this.reloadStylesheetImages(styleSheet, path, expando));
+        }
+        return _results;
+      }
+    };
+    Reloader.prototype.reloadStylesheetImages = function(styleSheet, path, expando) {
+      var rule, rules, styleNames, _i, _j, _len, _len2;
+      try {
+        rules = styleSheet != null ? styleSheet.cssRules : void 0;
+      } catch (e) {
+      }
+      if (!rules) {
+        return;
+      }
+      for (_i = 0, _len = rules.length; _i < _len; _i++) {
+        rule = rules[_i];
+        switch (rule.type) {
+          case CSSRule.IMPORT_RULE:
+            this.reloadStylesheetImages(rule.styleSheet, path, expando);
+            break;
+          case CSSRule.STYLE_RULE:
+            for (_j = 0, _len2 = IMAGE_STYLES.length; _j < _len2; _j++) {
+              styleNames = IMAGE_STYLES[_j].styleNames;
+              this.reloadStyleImages(rule.style, styleNames, path, expando);
+            }
+            break;
+          case CSSRule.MEDIA_RULE:
+            this.reloadStylesheetImages(rule, path, expando);
+        }
+      }
+    };
+    Reloader.prototype.reloadStyleImages = function(style, styleNames, path, expando) {
+      var newValue, styleName, value, _i, _len;
+      for (_i = 0, _len = styleNames.length; _i < _len; _i++) {
+        styleName = styleNames[_i];
+        value = style[styleName];
+        if (typeof value === 'string') {
+          newValue = value.replace(/\burl\s*\(([^)]*)\)/, __bind(function(match, src) {
+            if (pathsMatch(path, pathFromUrl(src))) {
+              return "url(" + (this.generateCacheBustUrl(src, expando)) + ")";
+            } else {
+              return match;
+            }
+          }, this));
+          if (newValue !== value) {
+            style[styleName] = newValue;
+          }
+        }
+      }
+    };
+    Reloader.prototype.reloadStylesheet = function(path) {
+      var imported, link, links, match, _i, _j, _len, _len2;
+      links = (function() {
+        var _i, _len, _ref, _results;
+        _ref = this.document.getElementsByTagName('link');
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          link = _ref[_i];
+          if (link.rel === 'stylesheet' && !link.__LiveReload_pendingRemoval) {
+            _results.push(link);
+          }
+        }
+        return _results;
+      }).call(this);
+      imported = [];
+      for (_i = 0, _len = links.length; _i < _len; _i++) {
+        link = links[_i];
+        this.collectImportedStylesheets(link, link.sheet, imported);
+      }
+      this.console.log("LiveReload found " + links.length + " LINKed stylesheets, " + imported.length + " @imported stylesheets");
+      match = pickBestMatch(path, links.concat(imported), function(l) {
+        return pathFromUrl(l.href);
+      });
+      if (match) {
+        if (match.object.rule) {
+          this.console.log("LiveReload is reloading imported stylesheet: " + match.object.href);
+          this.reattachImportedRule(match.object);
+        } else {
+          this.console.log("LiveReload is reloading stylesheet: " + match.object.href);
+          this.reattachStylesheetLink(match.object);
+        }
+      } else {
+        this.console.log("LiveReload will reload all stylesheets because path '" + path + "' did not match any specific one");
+        for (_j = 0, _len2 = links.length; _j < _len2; _j++) {
+          link = links[_j];
+          this.reattachStylesheetLink(link);
+        }
+      }
+      return true;
+    };
+    Reloader.prototype.collectImportedStylesheets = function(link, styleSheet, result) {
+      var index, rule, rules, _len;
+      try {
+        rules = styleSheet != null ? styleSheet.cssRules : void 0;
+      } catch (e) {
+      }
+      if (rules && rules.length) {
+        for (index = 0, _len = rules.length; index < _len; index++) {
+          rule = rules[index];
+          switch (rule.type) {
+            case CSSRule.CHARSET_RULE:
+              continue;
+            case CSSRule.IMPORT_RULE:
+              result.push({
+                link: link,
+                rule: rule,
+                index: index,
+                href: rule.href
+              });
+              this.collectImportedStylesheets(link, rule.styleSheet, result);
+              break;
+            default:
+              break;
+          }
+        }
+      }
+    };
+    Reloader.prototype.reattachStylesheetLink = function(link) {
+      var clone, parent, timer;
+      if (link.__LiveReload_pendingRemoval) {
+        return;
+      }
+      link.__LiveReload_pendingRemoval = true;
+      clone = link.cloneNode(false);
+      clone.href = this.generateCacheBustUrl(link.href);
+      parent = link.parentNode;
+      if (parent.lastChild === link) {
+        parent.appendChild(clone);
+      } else {
+        parent.insertBefore(clone, link.nextSibling);
+      }
+      timer = new this.Timer(function() {
+        if (link.parentNode) {
+          return link.parentNode.removeChild(link);
+        }
+      });
+      return timer.start(this.stylesheetGracePeriod);
+    };
+    Reloader.prototype.reattachImportedRule = function(_arg) {
+      var href, index, link, media, newRule, parent, rule, tempLink;
+      rule = _arg.rule, index = _arg.index, link = _arg.link;
+      parent = rule.parentStyleSheet;
+      href = this.generateCacheBustUrl(rule.href);
+      media = rule.media.length ? [].join.call(rule.media, ', ') : '';
+      newRule = "@import url(\"" + href + "\") " + media + ";";
+      rule.__LiveReload_newHref = href;
+      tempLink = this.document.createElement("link");
+      tempLink.rel = 'stylesheet';
+      tempLink.href = href;
+      tempLink.__LiveReload_pendingRemoval = true;
+      if (link.parentNode) {
+        link.parentNode.insertBefore(tempLink, link);
+      }
+      return this.Timer.start(this.importCacheWaitPeriod, __bind(function() {
+        if (tempLink.parentNode) {
+          tempLink.parentNode.removeChild(tempLink);
+        }
+        if (rule.__LiveReload_newHref !== href) {
+          return;
+        }
+        parent.insertRule(newRule, index);
+        parent.deleteRule(index + 1);
+        rule = parent.cssRules[index];
+        rule.__LiveReload_newHref = href;
+        return this.Timer.start(this.importCacheWaitPeriod, __bind(function() {
+          if (rule.__LiveReload_newHref !== href) {
+            return;
+          }
+          parent.insertRule(newRule, index);
+          return parent.deleteRule(index + 1);
+        }, this));
+      }, this));
+    };
+    Reloader.prototype.generateUniqueString = function() {
+      return 'livereload=' + Date.now();
+    };
+    Reloader.prototype.generateCacheBustUrl = function(url, expando) {
+      var hash, oldParams, params, _ref;
+      if (expando == null) {
+        expando = this.generateUniqueString();
+      }
+      _ref = splitUrl(url), url = _ref.url, hash = _ref.hash, oldParams = _ref.params;
+      params = oldParams.replace(/(\?|&)livereload=(\d+)/, function(match, sep) {
+        return "" + sep + expando;
+      });
+      if (params === oldParams) {
+        if (oldParams.length === 0) {
+          params = "?" + expando;
+        } else {
+          params = "" + oldParams + "&" + expando;
+        }
+      }
+      return url + params + hash;
+    };
+    return Reloader;
+  })();
+}).call(this);
+// livereload
+(function() {
+  var Connector, LiveReload, Options, Reloader, Timer;
+  var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+  Connector = __connector.Connector;
+  Timer = __timer.Timer;
+  Options = __options.Options;
+  Reloader = __reloader.Reloader;
+  __livereload.LiveReload = LiveReload = (function() {
+    function LiveReload(window) {
+      this.window = window;
+      this.listeners = {};
+      this.console = this.window.console && this.window.console.log && this.window.console.error ? this.window.console : {
+        log: function() {},
+        error: function() {}
+      };
+      if (!(this.WebSocket = this.window.WebSocket || this.window.MozWebSocket)) {
+        console.error("LiveReload disabled because the browser does not seem to support web sockets");
+        return;
+      }
+      if (!(this.options = Options.extract(this.window.document))) {
+        console.error("LiveReload disabled because it could not find its own <SCRIPT> tag");
+        return;
+      }
+      this.reloader = new Reloader(this.window, this.console, Timer);
+      this.connector = new Connector(this.options, this.WebSocket, Timer, {
+        connecting: __bind(function() {}, this),
+        socketConnected: __bind(function() {}, this),
+        connected: __bind(function(protocol) {
+          var _base;
+          if (typeof (_base = this.listeners).connect === "function") {
+            _base.connect();
+          }
+          return this.log("LiveReload is connected to " + this.options.host + ":" + this.options.port + " (protocol v" + protocol + ").");
+        }, this),
+        error: __bind(function(e) {
+          if (e instanceof ProtocolError) {
+            return console.log("" + e.message + ".");
+          } else {
+            return console.log("LiveReload internal error: " + e.message);
+          }
+        }, this),
+        disconnected: __bind(function(reason, nextDelay) {
+          var _base;
+          if (typeof (_base = this.listeners).disconnect === "function") {
+            _base.disconnect();
+          }
+          switch (reason) {
+            case 'cannot-connect':
+              return this.log("LiveReload cannot connect to " + this.options.host + ":" + this.options.port + ", will retry in " + nextDelay + " sec.");
+            case 'broken':
+              return this.log("LiveReload disconnected from " + this.options.host + ":" + this.options.port + ", reconnecting in " + nextDelay + " sec.");
+            case 'handshake-timeout':
+              return this.log("LiveReload cannot connect to " + this.options.host + ":" + this.options.port + " (handshake timeout), will retry in " + nextDelay + " sec.");
+            case 'handshake-failed':
+              return this.log("LiveReload cannot connect to " + this.options.host + ":" + this.options.port + " (handshake failed), will retry in " + nextDelay + " sec.");
+            case 'manual':
+              break;
+            case 'error':
+              break;
+            default:
+              return this.log("LiveReload disconnected from " + this.options.host + ":" + this.options.port + " (" + reason + "), reconnecting in " + nextDelay + " sec.");
+          }
+        }, this),
+        message: __bind(function(message) {
+          switch (message.command) {
+            case 'reload':
+              return this.performReload(message);
+            case 'alert':
+              return this.performAlert(message);
+          }
+        }, this)
+      });
+    }
+    LiveReload.prototype.on = function(eventName, handler) {
+      return this.listeners[eventName] = handler;
+    };
+    LiveReload.prototype.log = function(message) {
+      return this.console.log("" + message);
+    };
+    LiveReload.prototype.performReload = function(message) {
+      var _ref, _ref2;
+      this.log("LiveReload received reload request for " + message.path + ".");
+      return this.reloader.reload(message.path, {
+        liveCSS: (_ref = message.liveCSS) != null ? _ref : true,
+        liveImg: (_ref2 = message.liveImg) != null ? _ref2 : true
+      });
+    };
+    LiveReload.prototype.performAlert = function(message) {
+      return alert(message.message);
+    };
+    LiveReload.prototype.shutDown = function() {
+      var _base;
+      this.connector.disconnect();
+      this.log("LiveReload disconnected.");
+      return typeof (_base = this.listeners).shutdown === "function" ? _base.shutdown() : void 0;
+    };
+    return LiveReload;
+  })();
+}).call(this);
+// startup
+(function() {
+  var CustomEvents, LiveReload;
+  CustomEvents = __customevents;
+  LiveReload = window.LiveReload = new (__livereload.LiveReload)(window);
+  LiveReload.on('shutdown', function() {
+    return delete window.LiveReload;
+  });
+  LiveReload.on('connect', function() {
+    return CustomEvents.fire(document, 'LiveReloadConnect');
+  });
+  LiveReload.on('disconnect', function() {
+    return CustomEvents.fire(document, 'LiveReloadDisconnect');
+  });
+  CustomEvents.bind(document, 'LiveReloadShutDown', function() {
+    return LiveReload.shutDown();
+  });
+}).call(this);
+})();

data/lib/rack-livereload.rb ADDED

@@ -0,0 +1,6 @@
+require "rack/livereload"
+class Rack::LiveReload
+  VERSION = '0.1.0'
+end

data/lib/rack/livereload.rb ADDED

@@ -0,0 +1,55 @@
+module Rack
+  class LiveReload
+    LIVERELOAD_JS_PATH = '/__rack/livereload.js'
+    attr_reader :app
+    def initialize(app, options = {})
+      @app = app
+      @options = options
+    end
+    def call(env)
+      if env['PATH_INFO'] == LIVERELOAD_JS_PATH
+        deliver_file(::File.expand_path('../../../js/livereload.js', __FILE__))
+      else
+        status, headers, body = @app.call(env)
+        case headers['Content-Type']
+        when %r{text/html}
+          content_length = 0
+          body.each do |line|
+            if !headers['X-Rack-LiveReload'] && line['</head>']
+              src = LIVERELOAD_JS_PATH.dup
+              if @options[:host]
+                src << "?host=#{@options[:host]}"
+              else
+                src << "?host=#{env['HTTP_HOST'].gsub(%r{:.*}, '')}" if env['HTTP_HOST']
+              end
+              src << "&mindelay=#{@options[:min_delay]}" if @options[:min_delay]
+              src << "&maxdelay=#{@options[:max_delay]}" if @options[:max_delay]
+              src << "&port=#{@options[:port]}" if @options[:port]
+              line.gsub!('</head>', %{<script type="text/javascript" src="#{src}"></script></head>})
+              headers["X-Rack-LiveReload"] = '1'
+            end
+            content_length += line.length
+          end
+          headers['Content-Length'] = content_length.to_s
+        end
+        [ status, headers, body ]
+      end
+    end
+    private
+    def deliver_file(file)
+      [ 200, { 'Content-Type' => 'text/javascript', 'Content-Length' => ::File.size(file).to_s }, [ ::File.read(file) ] ]
+    end
+  end
+end

data/rack-livereload.gemspec ADDED

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rack-livereload"
+Gem::Specification.new do |s|
+  s.name        = "rack-livereload"
+  s.version     = Rack::LiveReload::VERSION
+  s.authors     = ["John Bintz"]
+  s.email       = ["john@coswellproductions.com"]
+  s.homepage    = ""
+  s.summary     = %q{Insert LiveReload into your app easily as Rack middleware}
+  s.description = %q{Insert LiveReload into your app easily as Rack middleware}
+  s.rubyforge_project = "rack-livereload"
+  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_development_dependency "httparty"
+  s.add_development_dependency "sinatra"
+  s.add_development_dependency "shotgun"
+  s.add_development_dependency "thin"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_runtime_dependency "rack"
+end

data/spec/rack/livereload_spec.rb ADDED

@@ -0,0 +1,74 @@
+require 'spec_helper'
+describe Rack::LiveReload do
+  let(:middleware) { described_class.new(app) }
+  let(:app) { stub }
+  subject { middleware }
+  its(:app) { should == app }
+  let(:env) { {} }
+  context 'not text/html' do
+    let(:ret) { [ 200, { 'Content-Type' => 'image/png' }, [ '<head></head>' ] ] }
+    before do
+      app.stubs(:call).with(env).returns(ret)
+    end
+    it 'should pass through' do
+      middleware.call(env).should == ret
+    end
+  end
+  context 'text/html' do
+    before do
+      app.stubs(:call).with(env).returns([ 200, { 'Content-Type' => 'text/html', 'Content-Length' => 0 }, [ '<head></head>' ] ])
+    end
+    let(:host) { 'host' }
+    let(:env) { { 'HTTP_HOST' => host } }
+    let(:ret) { middleware.call(env) }
+    let(:body) { ret.last.join }
+    let(:length) { ret[1]['Content-Length'] }
+    it 'should add the livereload js script tag' do
+      body.should include("script")
+      body.should include(described_class::LIVERELOAD_JS_PATH)
+      length.should == body.length.to_s
+      described_class::LIVERELOAD_JS_PATH.should_not include(host)
+    end
+    context 'set options' do
+      let(:middleware) { described_class.new(app, :host => new_host, :port => port, :min_delay => min_delay, :max_delay => max_delay) }
+      let(:min_delay) { 5 }
+      let(:max_delay) { 10 }
+      let(:port) { 23 }
+      let(:new_host) { 'myhost' }
+      it 'should add the livereload.js script tag' do
+        body.should include("mindelay=#{min_delay}")
+        body.should include("maxdelay=#{max_delay}")
+        body.should include("port=#{port}")
+        body.should include("host=#{new_host}")
+      end
+    end
+  end
+  context '/__rack/livereload.js' do
+    let(:env) { { 'PATH_INFO' => described_class::LIVERELOAD_JS_PATH } }
+    before do
+      middleware.expects(:deliver_file).returns(true)
+    end
+    it 'should return the js file' do
+      middleware.call(env).should be_true
+    end
+  end
+end

data/spec/spec_helper.rb ADDED

@@ -0,0 +1,7 @@
+require 'mocha'
+require 'rack-livereload'
+RSpec.configure do |c|
+  c.mock_with :mocha
+end

metadata ADDED

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: rack-livereload
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease:
+platform: ruby
+authors:
+- John Bintz
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2011-11-07 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2153313940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153313940
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: &2153313340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153313340
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: &2153312520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153312520
+- !ruby/object:Gem::Dependency
+  name: shotgun
+  requirement: &2153311420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153311420
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: &2153309720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153309720
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2153299320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153299320
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &2153298900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153298900
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &2153298480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153298480
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &2153298000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153298000
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &2153297500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2153297500
+description: Insert LiveReload into your app easily as Rack middleware
+email:
+- john@coswellproductions.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- config.ru
+- js/livereload.js
+- lib/rack-livereload.rb
+- lib/rack/livereload.rb
+- rack-livereload.gemspec
+- spec/rack/livereload_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rack-livereload
+rubygems_version: 1.8.11
+signing_key:
+specification_version: 3
+summary: Insert LiveReload into your app easily as Rack middleware
+test_files:
+- spec/rack/livereload_spec.rb
+- spec/spec_helper.rb