turbograft 0.0.5 → 0.0.6

data/lib/turbograft.js

@@ -0,0 +1,991 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+window.Click = (function() {
+  Click.installHandlerLast = function(event) {
+    if (!event.defaultPrevented) {
+      document.removeEventListener('click', Click.handle, false);
+      return document.addEventListener('click', Click.handle, false);
+    }
+  };
+
+  Click.handle = function(event) {
+    return new Click(event);
+  };
+
+  function Click(event) {
+    this.event = event;
+    if (this.event.defaultPrevented) {
+      return;
+    }
+    this._extractLink();
+    if (this._validForTurbolinks()) {
+      if (!this._pageChangePrevented()) {
+        Turbolinks.visit(this.link.href);
+      }
+      this.event.preventDefault();
+    }
+  }
+
+  Click.prototype._pageChangePrevented = function() {
+    return !triggerEvent('page:before-change');
+  };
+
+  Click.prototype._extractLink = function() {
+    var link;
+    link = this.event.target;
+    while (!(!link.parentNode || link.nodeName === 'A')) {
+      link = link.parentNode;
+    }
+    if (link.nodeName === 'A' && link.href.length !== 0) {
+      return this.link = new Link(link);
+    }
+  };
+
+  Click.prototype._validForTurbolinks = function() {
+    return (this.link != null) && !(this.link.shouldIgnore() || this._nonStandardClick());
+  };
+
+  Click.prototype._nonStandardClick = function() {
+    return this.event.which > 1 || this.event.metaKey || this.event.ctrlKey || this.event.shiftKey || this.event.altKey;
+  };
+
+  return Click;
+
+})();
+
+
+
+},{}],2:[function(require,module,exports){
+window.ComponentUrl = (function() {
+  function ComponentUrl(original) {
+    this.original = original != null ? original : document.location.href;
+    if (this.original.constructor === ComponentUrl) {
+      return this.original;
+    }
+    this._parse();
+  }
+
+  ComponentUrl.prototype.withoutHash = function() {
+    return this.href.replace(this.hash, '');
+  };
+
+  ComponentUrl.prototype.withoutHashForIE10compatibility = function() {
+    return this.withoutHash();
+  };
+
+  ComponentUrl.prototype.hasNoHash = function() {
+    return this.hash.length === 0;
+  };
+
+  ComponentUrl.prototype._parse = function() {
+    var _ref;
+    (this.link != null ? this.link : this.link = document.createElement('a')).href = this.original;
+    _ref = this.link, this.href = _ref.href, this.protocol = _ref.protocol, this.host = _ref.host, this.hostname = _ref.hostname, this.port = _ref.port, this.pathname = _ref.pathname, this.search = _ref.search, this.hash = _ref.hash;
+    this.origin = [this.protocol, '//', this.hostname].join('');
+    if (this.port.length !== 0) {
+      this.origin += ":" + this.port;
+    }
+    this.relative = [this.pathname, this.search, this.hash].join('');
+    return this.absolute = this.href;
+  };
+
+  return ComponentUrl;
+
+})();
+
+
+
+},{}],3:[function(require,module,exports){
+window.CSRFToken = (function() {
+  function CSRFToken() {}
+
+  CSRFToken.get = function(doc) {
+    var tag;
+    if (doc == null) {
+      doc = document;
+    }
+    return {
+      node: tag = doc.querySelector('meta[name="csrf-token"]'),
+      token: tag != null ? typeof tag.getAttribute === "function" ? tag.getAttribute('content') : void 0 : void 0
+    };
+  };
+
+  CSRFToken.update = function(latest) {
+    var current;
+    current = this.get();
+    if ((current.token != null) && (latest != null) && current.token !== latest) {
+      return current.node.setAttribute('content', latest);
+    }
+  };
+
+  return CSRFToken;
+
+})();
+
+
+
+},{}],4:[function(require,module,exports){
+var documentListenerForButtons, hasClass, nodeIsDisabled;
+
+window.TurboGraft = {
+  handlers: {}
+};
+
+hasClass = function(node, search) {
+  return node.classList.contains(search);
+};
+
+nodeIsDisabled = function(node) {
+  return node.getAttribute('disabled') || hasClass(node, 'disabled');
+};
+
+TurboGraft.handlers.partialGraftClickHandler = function(ev) {
+  var href, keys, partialGraft, refresh, target;
+  target = ev.target;
+  partialGraft = target.getAttribute("partial-graft");
+  if (partialGraft == null) {
+    return;
+  }
+  ev.preventDefault();
+  href = target.getAttribute("href");
+  refresh = target.getAttribute("refresh");
+  if (href == null) {
+    throw "TurboGraft developer error: href is not defined on node " + target;
+  }
+  if (refresh == null) {
+    throw "TurboGraft developer error: refresh is not defined on node " + target;
+  }
+  keys = refresh.trim().split(" ");
+  return Page.refresh({
+    url: href,
+    onlyKeys: keys
+  });
+};
+
+TurboGraft.handlers.remoteMethodHandler = function(ev) {
+  var httpRequestType, httpUrl, onlyOnce, options, remote, target;
+  target = ev.target;
+  if (!target.getAttribute('remote-method')) {
+    return;
+  }
+  ev.preventDefault();
+  httpUrl = target.getAttribute('href');
+  httpRequestType = target.getAttribute('remote-method');
+  if (!httpRequestType) {
+    throw "Turbograft developer error: You did not provide a request type for remote-method";
+  }
+  if (!httpUrl) {
+    throw "Turbograft developer error: You did not provide a URL for remote-method";
+  }
+  if (onlyOnce = target.getAttribute("remote-once")) {
+    target.removeAttribute("remote-once");
+    target.removeAttribute("remote-method");
+  }
+  options = {
+    httpRequestType: httpRequestType,
+    httpUrl: httpUrl,
+    fullRefresh: target.getAttribute('full-refresh') != null,
+    refreshOnSuccess: target.getAttribute('refresh-on-success'),
+    refreshOnError: target.getAttribute('refresh-on-error')
+  };
+  if (!options.refreshOnSuccess && !options.refreshOnError) {
+    options.fullRefresh = true;
+  }
+  remote = new TurboGraft.Remote(options, null, target);
+};
+
+documentListenerForButtons = function(eventType, handler, useCapture) {
+  if (useCapture == null) {
+    useCapture = false;
+  }
+  return document.addEventListener(eventType, function(ev) {
+    var target;
+    target = ev.target;
+    if (!(target.nodeName === "A" || target.nodeName === "BUTTON") || nodeIsDisabled(target)) {
+      return;
+    }
+    return handler(ev);
+  });
+};
+
+documentListenerForButtons('click', TurboGraft.handlers.partialGraftClickHandler, true);
+
+documentListenerForButtons('click', TurboGraft.handlers.remoteMethodHandler, true);
+
+
+
+},{}],5:[function(require,module,exports){
+var __hasProp = {}.hasOwnProperty,
+  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
+  __slice = [].slice;
+
+window.Link = (function(_super) {
+  __extends(Link, _super);
+
+  Link.HTML_EXTENSIONS = ['html'];
+
+  Link.allowExtensions = function() {
+    var extension, extensions, _i, _len;
+    extensions = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+    for (_i = 0, _len = extensions.length; _i < _len; _i++) {
+      extension = extensions[_i];
+      Link.HTML_EXTENSIONS.push(extension);
+    }
+    return Link.HTML_EXTENSIONS;
+  };
+
+  function Link(link) {
+    this.link = link;
+    if (this.link.constructor === Link) {
+      return this.link;
+    }
+    this.original = this.link.href;
+    Link.__super__.constructor.apply(this, arguments);
+  }
+
+  Link.prototype.shouldIgnore = function() {
+    return this._crossOrigin() || this._anchored() || this._nonHtml() || this._optOut() || this._target();
+  };
+
+  Link.prototype._crossOrigin = function() {
+    return this.origin !== (new ComponentUrl).origin;
+  };
+
+  Link.prototype._anchored = function() {
+    var current;
+    return ((this.hash && this.withoutHash()) === (current = new ComponentUrl).withoutHash()) || (this.href === current.href + '#');
+  };
+
+  Link.prototype._nonHtml = function() {
+    return this.pathname.match(/\.[a-z]+$/g) && !this.pathname.match(new RegExp("\\.(?:" + (Link.HTML_EXTENSIONS.join('|')) + ")?$", 'g'));
+  };
+
+  Link.prototype._optOut = function() {
+    var ignore, link;
+    link = this.link;
+    while (!(ignore || link === document || link === null)) {
+      ignore = link.getAttribute('data-no-turbolink') != null;
+      link = link.parentNode;
+    }
+    return ignore;
+  };
+
+  Link.prototype._target = function() {
+    return this.link.target.length !== 0;
+  };
+
+  return Link;
+
+})(ComponentUrl);
+
+
+
+},{}],6:[function(require,module,exports){
+if (!window.Page) {
+  window.Page = {};
+}
+
+Page.visit = function(url, opts) {
+  if (opts == null) {
+    opts = {};
+  }
+  if (opts.reload) {
+    return window.location = url;
+  } else {
+    return Turbolinks.visit(url);
+  }
+};
+
+Page.refresh = function(options, callback) {
+  var newUrl, paramString;
+  if (options == null) {
+    options = {};
+  }
+  newUrl = options.url ? options.url : options.queryParams ? (paramString = $.param(options.queryParams), paramString ? paramString = "?" + paramString : void 0, location.pathname + paramString) : location.href;
+  if (options.response) {
+    return Turbolinks.loadPage(null, options.response, true, callback, options.onlyKeys || []);
+  } else {
+    return Turbolinks.visit(newUrl, true, options.onlyKeys || [], function() {
+      return typeof callback === "function" ? callback() : void 0;
+    });
+  }
+};
+
+Page.open = function() {
+  return window.open.apply(window, arguments);
+};
+
+
+
+},{}],7:[function(require,module,exports){
+window.PageCache = (function() {
+  var simultaneousAdditionOffset, storage;
+
+  storage = {};
+
+  simultaneousAdditionOffset = 0;
+
+  function PageCache(cacheSize) {
+    this.cacheSize = cacheSize != null ? cacheSize : 10;
+    storage = {};
+    return this;
+  }
+
+  PageCache.prototype.get = function(key) {
+    return storage[key];
+  };
+
+  PageCache.prototype.set = function(key, value) {
+    if (typeof value !== "object") {
+      throw "Developer error: You must store objects in this cache";
+    }
+    value['cachedAt'] = new Date().getTime() + (simultaneousAdditionOffset += 1);
+    storage[key] = value;
+    return this.constrain();
+  };
+
+  PageCache.prototype.clear = function() {
+    return storage = {};
+  };
+
+  PageCache.prototype.setCacheSize = function(newSize) {
+    if (/^[\d]+$/.test(newSize)) {
+      this.cacheSize = parseInt(newSize, 10);
+      return this.constrain();
+    } else {
+      throw "Developer error: Invalid parameter '" + newSize + "' for PageCache; must be integer";
+    }
+  };
+
+  PageCache.prototype.constrain = function() {
+    var cacheTimesRecentFirst, key, pageCacheKeys, _i, _len, _results;
+    pageCacheKeys = Object.keys(storage);
+    cacheTimesRecentFirst = pageCacheKeys.map((function(_this) {
+      return function(url) {
+        return storage[url].cachedAt;
+      };
+    })(this)).sort(function(a, b) {
+      return b - a;
+    });
+    _results = [];
+    for (_i = 0, _len = pageCacheKeys.length; _i < _len; _i++) {
+      key = pageCacheKeys[_i];
+      if (!(storage[key].cachedAt <= cacheTimesRecentFirst[this.cacheSize])) {
+        continue;
+      }
+      triggerEvent('page:expire', storage[key]);
+      _results.push(delete storage[key]);
+    }
+    return _results;
+  };
+
+  PageCache.prototype.length = function() {
+    return Object.keys(storage).length;
+  };
+
+  return PageCache;
+
+})();
+
+
+
+},{}],8:[function(require,module,exports){
+TurboGraft.Remote = (function() {
+  function Remote(opts, form, target) {
+    var actualRequestType, formData, xhr;
+    this.opts = opts;
+    formData = form ? new FormData(form) : new FormData();
+    this.initiator = target;
+    actualRequestType = this.opts.httpRequestType.toLowerCase() === 'get' ? 'GET' : 'POST';
+    formData.append("_method", this.opts.httpRequestType);
+    if (this.opts.refreshOnSuccess) {
+      this.refreshOnSuccess = this.opts.refreshOnSuccess.split(" ");
+    }
+    if (this.opts.refreshOnError) {
+      this.refreshOnError = this.opts.refreshOnError.split(" ");
+    }
+    xhr = new XMLHttpRequest;
+    xhr.open(actualRequestType, this.opts.httpUrl, true);
+    xhr.setRequestHeader('Accept', 'text/html, application/xhtml+xml, application/xml');
+    xhr.addEventListener('loadstart', (function(_this) {
+      return function() {
+        return triggerEvent('turbograft:remote:start', {
+          xhr: xhr,
+          initiator: _this.initiator
+        });
+      };
+    })(this));
+    xhr.addEventListener('error', this.onError);
+    xhr.addEventListener('load', (function(_this) {
+      return function(event) {
+        if (xhr.status < 400) {
+          return _this.onSuccess(event);
+        } else {
+          return _this.onError(event);
+        }
+      };
+    })(this));
+    xhr.addEventListener('loadend', (function(_this) {
+      return function() {
+        return triggerEvent('turbograft:remote:always', {
+          xhr: xhr,
+          initiator: _this.initiator
+        });
+      };
+    })(this));
+    xhr.send(formData);
+    return xhr;
+  }
+
+  Remote.prototype.onSuccess = function(ev) {
+    var redirect, xhr;
+    xhr = ev.target;
+    triggerEvent('turbograft:remote:success', {
+      xhr: xhr,
+      initiator: this.initiator
+    });
+    if (redirect = xhr.getResponseHeader('X-Next-Redirect')) {
+      Page.visit(redirect, {
+        reload: true
+      });
+      return;
+    }
+    if (this.opts.fullRefresh && this.refreshOnSuccess) {
+      return Page.refresh({
+        onlyKeys: this.refreshOnSuccess
+      });
+    } else if (this.opts.fullRefresh) {
+      return Page.refresh();
+    } else if (this.refreshOnSuccess) {
+      return Page.refresh({
+        response: xhr,
+        onlyKeys: this.refreshOnSuccess
+      });
+    }
+  };
+
+  Remote.prototype.onError = function(ev) {
+    var xhr;
+    xhr = ev.target;
+    triggerEvent('turbograft:remote:fail', {
+      xhr: xhr,
+      initiator: this.initiator
+    });
+    if (this.refreshOnError) {
+      return Page.refresh({
+        response: xhr,
+        onlyKeys: this.refreshOnError
+      });
+    } else {
+      return triggerEvent('turbograft:remote:fail:unhandled', {
+        xhr: xhr,
+        initiator: this.initiator
+      });
+    }
+  };
+
+  return Remote;
+
+})();
+
+
+
+},{}],9:[function(require,module,exports){
+var browserIsntBuggy, browserSupportsCustomEvents, browserSupportsPushState, browserSupportsTurbolinks, historyStateIsDefined, installDocumentReadyPageEventTriggers, installJqueryAjaxSuccessPageUpdateTrigger, popCookie, requestMethodIsSafe, xhr, _ref,
+  __slice = [].slice,
+  __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; };
+
+xhr = null;
+
+installDocumentReadyPageEventTriggers = function() {
+  return document.addEventListener('DOMContentLoaded', (function() {
+    triggerEvent('page:change');
+    return triggerEvent('page:update');
+  }), true);
+};
+
+installJqueryAjaxSuccessPageUpdateTrigger = function() {
+  if (typeof jQuery !== 'undefined') {
+    return jQuery(document).on('ajaxSuccess', function(event, xhr, settings) {
+      if (!jQuery.trim(xhr.responseText)) {
+        return;
+      }
+      return triggerEvent('page:update');
+    });
+  }
+};
+
+historyStateIsDefined = window.history.state !== void 0 || navigator.userAgent.match(/Firefox\/2[6|7]/);
+
+browserSupportsPushState = window.history && window.history.pushState && window.history.replaceState && historyStateIsDefined;
+
+browserIsntBuggy = !navigator.userAgent.match(/CriOS\//);
+
+window.triggerEvent = function(name, data) {
+  var event;
+  event = document.createEvent('Events');
+  if (data) {
+    event.data = data;
+  }
+  event.initEvent(name, true, true);
+  return document.dispatchEvent(event);
+};
+
+popCookie = function(name) {
+  var value, _ref;
+  value = ((_ref = document.cookie.match(new RegExp(name + "=(\\w+)"))) != null ? _ref[1].toUpperCase() : void 0) || '';
+  document.cookie = name + '=; expires=Thu, 01-Jan-70 00:00:01 GMT; path=/';
+  return value;
+};
+
+requestMethodIsSafe = (_ref = popCookie('request_method')) === 'GET' || _ref === '';
+
+browserSupportsTurbolinks = browserSupportsPushState && browserIsntBuggy && requestMethodIsSafe;
+
+browserSupportsCustomEvents = document.addEventListener && document.createEvent;
+
+if (browserSupportsCustomEvents) {
+  installDocumentReadyPageEventTriggers();
+  installJqueryAjaxSuccessPageUpdateTrigger();
+}
+
+window.Turbolinks = (function() {
+  var browserCompatibleDocumentParser, bypassOnLoadPopstate, changePage, createDocument, currentState, deleteRefreshNeverNodes, executeScriptTag, executeScriptTags, extractTitleAndBody, fetch, fetchHistory, fetchReplacement, installHistoryChangeHandler, loadedAssets, pageCache, pageChangePrevented, processResponse, recallScrollPosition, referer, reflectNewUrl, reflectRedirectedUrl, refreshNodesWithKeys, rememberReferer, removeNoscriptTags, resetScrollPosition, transitionCacheFor, usePageCache;
+
+  function Turbolinks() {}
+
+  createDocument = null;
+
+  currentState = null;
+
+  loadedAssets = null;
+
+  referer = null;
+
+  usePageCache = false;
+
+  Turbolinks.pageCache = pageCache = new PageCache();
+
+  fetch = function(url, partialReplace, replaceContents, callback) {
+    var cachedPage;
+    if (partialReplace == null) {
+      partialReplace = false;
+    }
+    if (replaceContents == null) {
+      replaceContents = [];
+    }
+    url = new ComponentUrl(url);
+    rememberReferer();
+    if (usePageCache) {
+      Turbolinks.cacheCurrentPage();
+    }
+    if (usePageCache && (cachedPage = transitionCacheFor(url.absolute))) {
+      fetchHistory(cachedPage);
+      return fetchReplacement(url, partialReplace, null, replaceContents);
+    } else {
+      return fetchReplacement(url, partialReplace, function() {
+        if (!replaceContents.length) {
+          resetScrollPosition();
+        }
+        return typeof callback === "function" ? callback() : void 0;
+      }, replaceContents);
+    }
+  };
+
+  Turbolinks.pageCacheEnabled = function() {
+    return usePageCache;
+  };
+
+  Turbolinks.usePageCache = function(status) {
+    return usePageCache = status;
+  };
+
+  transitionCacheFor = function(url) {
+    var cachedPage;
+    cachedPage = pageCache.get(url);
+    if (cachedPage && !cachedPage.transitionCacheDisabled) {
+      return cachedPage;
+    }
+  };
+
+  Turbolinks.pushState = function(state, title, url) {
+    return window.history.pushState(state, title, url);
+  };
+
+  Turbolinks.replaceState = function(state, title, url) {
+    return window.history.replaceState(state, title, url);
+  };
+
+  fetchReplacement = function(url, partialReplace, onLoadFunction, replaceContents) {
+    triggerEvent('page:fetch', {
+      url: url.absolute
+    });
+    if (xhr != null) {
+      xhr.abort();
+    }
+    xhr = new XMLHttpRequest;
+    xhr.open('GET', url.withoutHashForIE10compatibility(), true);
+    xhr.setRequestHeader('Accept', 'text/html, application/xhtml+xml, application/xml');
+    xhr.setRequestHeader('X-XHR-Referer', referer);
+    xhr.onload = function() {
+      if (xhr.status >= 500) {
+        return document.location.href = url.absolute;
+      } else {
+        return Turbolinks.loadPage(url, xhr, partialReplace, onLoadFunction, replaceContents);
+      }
+    };
+    xhr.onloadend = function() {
+      return xhr = null;
+    };
+    xhr.onerror = function() {
+      return document.location.href = url.absolute;
+    };
+    xhr.send();
+  };
+
+  Turbolinks.loadPage = function(url, xhr, partialReplace, onLoadFunction, replaceContents) {
+    var doc, nodes;
+    if (partialReplace == null) {
+      partialReplace = false;
+    }
+    if (onLoadFunction == null) {
+      onLoadFunction = (function() {});
+    }
+    if (replaceContents == null) {
+      replaceContents = [];
+    }
+    triggerEvent('page:receive');
+    if (doc = processResponse(xhr, partialReplace)) {
+      reflectNewUrl(url);
+      nodes = changePage.apply(null, __slice.call(extractTitleAndBody(doc)).concat([partialReplace], [replaceContents]));
+      reflectRedirectedUrl(xhr);
+      triggerEvent('page:load', nodes);
+      if (typeof onLoadFunction === "function") {
+        onLoadFunction();
+      }
+    } else {
+      document.location.href = url.absolute;
+    }
+  };
+
+  fetchHistory = function(cachedPage) {
+    if (xhr != null) {
+      xhr.abort();
+    }
+    changePage(cachedPage.title, cachedPage.body, false);
+    recallScrollPosition(cachedPage);
+    return triggerEvent('page:restore');
+  };
+
+  Turbolinks.cacheCurrentPage = function() {
+    var currentStateUrl;
+    currentStateUrl = new ComponentUrl(currentState.url);
+    pageCache.set(currentStateUrl.absolute, {
+      url: currentStateUrl.relative,
+      body: document.body,
+      title: document.title,
+      positionY: window.pageYOffset,
+      positionX: window.pageXOffset,
+      transitionCacheDisabled: document.querySelector('[data-no-transition-cache]') != null
+    });
+  };
+
+  changePage = function(title, body, csrfToken, runScripts, partialReplace, replaceContents) {
+    if (replaceContents == null) {
+      replaceContents = [];
+    }
+    if (title) {
+      document.title = title;
+    }
+    if (replaceContents.length) {
+      return refreshNodesWithKeys(replaceContents, body);
+    } else {
+      deleteRefreshNeverNodes(body);
+      triggerEvent('page:before-replace');
+      document.documentElement.replaceChild(body, document.body);
+      if (csrfToken != null) {
+        CSRFToken.update(csrfToken);
+      }
+      if (runScripts) {
+        executeScriptTags();
+      }
+      currentState = window.history.state;
+      triggerEvent('page:change');
+      triggerEvent('page:update');
+    }
+  };
+
+  deleteRefreshNeverNodes = function(body) {
+    var node, _i, _len, _ref1;
+    _ref1 = body.querySelectorAll('[refresh-never]');
+    for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+      node = _ref1[_i];
+      node.parentNode.removeChild(node);
+    }
+  };
+
+  refreshNodesWithKeys = function(keys, body) {
+    var allNodesToBeRefreshed, existingNode, key, newNode, node, nodeId, parentIsRefreshing, refreshedNodes, _i, _j, _k, _l, _len, _len1, _len2, _len3, _ref1, _ref2;
+    allNodesToBeRefreshed = [];
+    _ref1 = document.querySelectorAll("[refresh-always]");
+    for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+      node = _ref1[_i];
+      allNodesToBeRefreshed.push(node);
+    }
+    for (_j = 0, _len1 = keys.length; _j < _len1; _j++) {
+      key = keys[_j];
+      _ref2 = document.querySelectorAll("[refresh=" + key + "]");
+      for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
+        node = _ref2[_k];
+        allNodesToBeRefreshed.push(node);
+      }
+    }
+    triggerEvent('page:before-partial-replace', allNodesToBeRefreshed);
+    parentIsRefreshing = function(node) {
+      var potentialParent, _l, _len3;
+      for (_l = 0, _len3 = allNodesToBeRefreshed.length; _l < _len3; _l++) {
+        potentialParent = allNodesToBeRefreshed[_l];
+        if (node !== potentialParent) {
+          if (potentialParent.contains(node)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    refreshedNodes = [];
+    for (_l = 0, _len3 = allNodesToBeRefreshed.length; _l < _len3; _l++) {
+      existingNode = allNodesToBeRefreshed[_l];
+      if (parentIsRefreshing(existingNode)) {
+        continue;
+      }
+      if (!(nodeId = existingNode.getAttribute('id'))) {
+        throw new Error("Turbolinks refresh: Refresh key elements must have an id.");
+      }
+      if (newNode = body.querySelector("#" + nodeId)) {
+        existingNode.parentNode.replaceChild(newNode, existingNode);
+        if (newNode.nodeName === 'SCRIPT' && newNode.getAttribute("data-turbolinks-eval") !== "false") {
+          executeScriptTag(newNode);
+        } else {
+          refreshedNodes.push(newNode);
+        }
+      } else if (existingNode.getAttribute("refresh-always") === null) {
+        existingNode.parentNode.removeChild(existingNode);
+      }
+    }
+    return refreshedNodes;
+  };
+
+  executeScriptTags = function() {
+    var script, scripts, _i, _len, _ref1;
+    scripts = Array.prototype.slice.call(document.body.querySelectorAll('script:not([data-turbolinks-eval="false"])'));
+    for (_i = 0, _len = scripts.length; _i < _len; _i++) {
+      script = scripts[_i];
+      if ((_ref1 = script.type) === '' || _ref1 === 'text/javascript') {
+        executeScriptTag(script);
+      }
+    }
+  };
+
+  executeScriptTag = function(script) {
+    var attr, copy, nextSibling, parentNode, _i, _len, _ref1;
+    copy = document.createElement('script');
+    _ref1 = script.attributes;
+    for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+      attr = _ref1[_i];
+      copy.setAttribute(attr.name, attr.value);
+    }
+    copy.appendChild(document.createTextNode(script.innerHTML));
+    parentNode = script.parentNode, nextSibling = script.nextSibling;
+    parentNode.removeChild(script);
+    parentNode.insertBefore(copy, nextSibling);
+  };
+
+  removeNoscriptTags = function(node) {
+    node.innerHTML = node.innerHTML.replace(/<noscript[\S\s]*?<\/noscript>/ig, '');
+    return node;
+  };
+
+  reflectNewUrl = function(url) {
+    if ((url = new ComponentUrl(url)).absolute !== referer) {
+      Turbolinks.pushState({
+        turbolinks: true,
+        url: url.absolute
+      }, '', url.absolute);
+    }
+  };
+
+  reflectRedirectedUrl = function(xhr) {
+    var location, preservedHash;
+    if (location = xhr.getResponseHeader('X-XHR-Redirected-To')) {
+      location = new ComponentUrl(location);
+      preservedHash = location.hasNoHash() ? document.location.hash : '';
+      Turbolinks.replaceState(currentState, '', location.href + preservedHash);
+    }
+  };
+
+  rememberReferer = function() {
+    return referer = document.location.href;
+  };
+
+  Turbolinks.rememberCurrentUrl = function() {
+    return Turbolinks.replaceState({
+      turbolinks: true,
+      url: document.location.href
+    }, '', document.location.href);
+  };
+
+  Turbolinks.rememberCurrentState = function() {
+    return currentState = window.history.state;
+  };
+
+  recallScrollPosition = function(page) {
+    return window.scrollTo(page.positionX, page.positionY);
+  };
+
+  resetScrollPosition = function() {
+    if (document.location.hash) {
+      return document.location.href = document.location.href;
+    } else {
+      return window.scrollTo(0, 0);
+    }
+  };
+
+  pageChangePrevented = function() {
+    return !triggerEvent('page:before-change');
+  };
+
+  processResponse = function(xhr, partial) {
+    var assetsChanged, changed, clientOrServerError, doc, extractTrackAssets, intersection, validContent;
+    if (partial == null) {
+      partial = false;
+    }
+    clientOrServerError = function() {
+      var _ref1;
+      if (xhr.status === 422) {
+        return false;
+      }
+      return (400 <= (_ref1 = xhr.status) && _ref1 < 600);
+    };
+    validContent = function() {
+      return xhr.getResponseHeader('Content-Type').match(/^(?:text\/html|application\/xhtml\+xml|application\/xml)(?:;|$)/);
+    };
+    extractTrackAssets = function(doc) {
+      var node, _i, _len, _ref1, _results;
+      _ref1 = doc.head.childNodes;
+      _results = [];
+      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+        node = _ref1[_i];
+        if ((typeof node.getAttribute === "function" ? node.getAttribute('data-turbolinks-track') : void 0) != null) {
+          _results.push(node.getAttribute('src') || node.getAttribute('href'));
+        }
+      }
+      return _results;
+    };
+    assetsChanged = function(doc) {
+      var fetchedAssets;
+      loadedAssets || (loadedAssets = extractTrackAssets(document));
+      fetchedAssets = extractTrackAssets(doc);
+      return fetchedAssets.length !== loadedAssets.length || intersection(fetchedAssets, loadedAssets).length !== loadedAssets.length;
+    };
+    intersection = function(a, b) {
+      var value, _i, _len, _ref1, _results;
+      if (a.length > b.length) {
+        _ref1 = [b, a], a = _ref1[0], b = _ref1[1];
+      }
+      _results = [];
+      for (_i = 0, _len = a.length; _i < _len; _i++) {
+        value = a[_i];
+        if (__indexOf.call(b, value) >= 0) {
+          _results.push(value);
+        }
+      }
+      return _results;
+    };
+    if (!clientOrServerError() && validContent()) {
+      doc = createDocument(xhr.responseText);
+      changed = assetsChanged(doc);
+      if (doc && (!changed || partial)) {
+        return doc;
+      }
+    }
+  };
+
+  extractTitleAndBody = function(doc) {
+    var title;
+    title = doc.querySelector('title');
+    return [title != null ? title.textContent : void 0, removeNoscriptTags(doc.body), CSRFToken.get(doc).token, 'runScripts'];
+  };
+
+  installHistoryChangeHandler = function(event) {
+    var cachedPage, _ref1;
+    if ((_ref1 = event.state) != null ? _ref1.turbolinks : void 0) {
+      if (cachedPage = pageCache.get((new ComponentUrl(event.state.url)).absolute)) {
+        Turbolinks.cacheCurrentPage();
+        return fetchHistory(cachedPage);
+      } else {
+        return Turbolinks.visit(event.target.location.href);
+      }
+    }
+  };
+
+  bypassOnLoadPopstate = function(fn) {
+    return setTimeout(fn, 500);
+  };
+
+  browserCompatibleDocumentParser = function() {
+    var createDocumentUsingDOM, createDocumentUsingParser, createDocumentUsingWrite, e, testDoc, _ref1;
+    createDocumentUsingParser = function(html) {
+      return (new DOMParser).parseFromString(html, 'text/html');
+    };
+    createDocumentUsingDOM = function(html) {
+      var doc;
+      doc = document.implementation.createHTMLDocument('');
+      doc.documentElement.innerHTML = html;
+      return doc;
+    };
+    createDocumentUsingWrite = function(html) {
+      var doc;
+      doc = document.implementation.createHTMLDocument('');
+      doc.open('replace');
+      doc.write(html);
+      doc.close();
+      return doc;
+    };
+    try {
+      if (window.DOMParser) {
+        testDoc = createDocumentUsingParser('<html><body><p>test');
+        return createDocumentUsingParser;
+      }
+    } catch (_error) {
+      e = _error;
+      testDoc = createDocumentUsingDOM('<html><body><p>test');
+      return createDocumentUsingDOM;
+    } finally {
+      if ((testDoc != null ? (_ref1 = testDoc.body) != null ? _ref1.childNodes.length : void 0 : void 0) !== 1) {
+        return createDocumentUsingWrite;
+      }
+    }
+  };
+
+  if (browserSupportsTurbolinks) {
+    Turbolinks.visit = fetch;
+    Turbolinks.rememberCurrentUrl();
+    Turbolinks.rememberCurrentState();
+    createDocument = browserCompatibleDocumentParser();
+    document.addEventListener('click', Click.installHandlerLast, true);
+    bypassOnLoadPopstate(function() {
+      return window.addEventListener('popstate', installHistoryChangeHandler, false);
+    });
+  } else {
+    Turbolinks.visit = function(url) {
+      return document.location.href = url;
+    };
+  }
+
+  return Turbolinks;
+
+})();
+
+
+
+},{}]},{},[1,2,3,5,6,7,9,4,8]);