turbograft 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7c5cd11ad075c764ef8376a3e89011fd8a42c85b
-  data.tar.gz: b8958bb7aea77497657f90dc1e0885512f073c90
+  metadata.gz: 2a50ca4a110827a3af168d5ff3647bc8fab4eba0
+  data.tar.gz: d3ab55d748cdec883171f4b3d37bc54ab00ef7c0
 SHA512:
-  metadata.gz: 5ea57c380149b4d2f100f135b7a94429f6721e31ddf5196e3f9e5cd0135f16661d0d37c8981278fd2b1b7f28c1fc615f838cb7c7ccc80354edf5d6facb201fd5
-  data.tar.gz: eead55c4918b3663e4f051a0688a3c33a193435603abefabdc2b8484ff2b2e47c4e4c5c771c4921524b631618dde68dd5d3ad7adcb1c2a21f38d16bfc074f7de
+  metadata.gz: 89c63f79978fb8052c060af6c089b404f10eafe4587b5c46c81d623199f1ac9477884636ac197e82076740eeeed00c28ffeb4f105d24e11132aaf3e80cea39da
+  data.tar.gz: 0e4d0f808b6ff7637d3590169a7d7faeba7cbc28fe98ac7563e54a735238c8f7895c9d999c8b8b9d524075eb0fd803e6903149b3773789ad549c228aee2f7b33

data/README.md

@@ -3,7 +3,7 @@ Turbograft extends [Turbolinks](https://github.com/rails/turbolinks), allowing y
 
 `Graft` - (noun) a shoot or twig inserted into a slit on the trunk or stem of a living plant, from which it receives sap.
 
-In botony, one can take parts of a tree and splice it onto another tree.  The DOM is a tree.  In this library, we're cutting off sub-trees of the DOM and splicing new ones on.
+In botany, one can take parts of a tree and splice it onto another tree.  The DOM is a tree.  In this library, we're cutting off sub-trees of the DOM and splicing new ones on.
 
  Turbolinks works by intercepting navigation requests and loading them via Ajax when possible, swapping the body tag of the document with the newly loaded copy. Turbograft builds on this to allow you to perform a partial page refresh on specified DOM nodes by adding a refresh key. This allows you reduce page load time, while the feeling of a native, single-page application.
 
@@ -71,6 +71,9 @@ The `data-tg-refresh-never` attribute will cause a node only appear once in the
 </div>
 ```
 
+### updatePushState
+Defaults to `true`. When set to false it prevents `Page.refresh()` from updating the url in the browser.
+
 ## data-tg-remote
 
 The `data-tg-remote` option allows you to query methods on or submit forms to different endpoints, and gives partial page replacement on specified refresh keys depending on the response status.
@@ -84,7 +87,7 @@ It requires your `<form>`, `<a>`, or `<button>` to be marked up with:
 * `data-tg-refresh-on-error`: (optional) The refresh keys to be refreshed, but using body of XHR which has failed. Only works with error 422. If the XHR returns and error and you do not supply a refresh-on-error, nothing is changed
 * `data-tg-full-refresh-on-error-except`: (optional) Replaces body except for specified refresh keys, using the body of the XHR which has failed.  Only works with error 422
 * `data-tg-remote-once`: (optional) The action will only be performed once. Removes `data-tg-remote-method` and `data-tg-remote-once` from element after consumption
-* `data-tg-full-refresh`: Rather than using the content of the XHR response for partial page replacement, a full page refresh is performed. If `data-tg-refresh-on-success` is defined, the page will be reloaded on these keys. If `data-tg-refresh-on-success` is not defined, a full page refresh is performed. Defaults to true if neither refresh-on-success nor refresh-on-error are provided
+* `data-tg-full-refresh`: Rather than using the content of the XHR response for partial page replacement, a full page refresh is performed. If `data-tg-refresh-on-success` or `data-tg-refresh-on-error` is defined, the page will be reloaded on those keys. If both `data-tg-refresh-on-success` and `data-tg-refresh-on-error` are not defined, a full page refresh is performed. Defaults to true if neither refresh-on-success nor refresh-on-error are provided
 * `data-tg-remote-norefresh`: Prevents `Page.refresh()` from being called, allowing methods to be executed without updating client state
 
 Note that as `data-tg-refresh-on-*` pertains to partial refreshes and `data-tg-full-refresh-on-*-except` pertains to full refreshes, they are incompatible with each other and should not be combined.
@@ -122,7 +125,7 @@ Post to a remote form:
 * `turbograft:remote:always`: Always fires when XHR is complete
 * `turbograft:remote:success`: Always fires when XHR was successful
 * `turbograft:remote:fail`: Always fires when XHR failed
-* `turbograft:remote:fail:unhandled`: Fires after `turbograft:remote:fail`, but when no partial replacement with refresh-on-error was performed (because no `data-tg-refresh-on-error` was supplied)
+* `turbograft:remote:fail:unhandled`: Fires after `turbograft:remote:fail`, but when no partial replacement with refresh-on-error was performed (because no `data-tg-refresh-on-error` was supplied or because `data-tg-remote-norefresh` was present)
 
 Each event also is sent with a copy of the XHR, as well as a reference to the element that initated the `data-tg-remote-method`.
 

data/lib/assets/javascripts/turbograft/remote.coffee

@@ -153,14 +153,22 @@ class TurboGraft.Remote
       initiator: @initiator
       xhr: xhr
 
-    if @refreshOnError
-      Page.refresh
-        response: xhr
-        onlyKeys: @refreshOnError
-    else if @refreshOnErrorExcept
-      Page.refresh
-        response: xhr
-        exceptKeys: @refreshOnErrorExcept
-    else
+    if TurboGraft.hasTGAttribute(@initiator, 'tg-remote-norefresh')
       triggerEventFor 'turbograft:remote:fail:unhandled', @initiator,
         xhr: xhr
+    else
+      if @opts.fullRefresh && @refreshOnError
+        Page.refresh(onlyKeys: @refreshOnError)
+      else if @opts.fullRefresh
+        Page.refresh()
+      else if @refreshOnError
+        Page.refresh
+          response: xhr
+          onlyKeys: @refreshOnError
+      else if @refreshOnErrorExcept
+        Page.refresh
+          response: xhr
+          exceptKeys: @refreshOnErrorExcept
+      else
+        triggerEventFor 'turbograft:remote:fail:unhandled', @initiator,
+          xhr: xhr

data/lib/turbograft/redirection.rb

@@ -4,6 +4,7 @@ module TurboGraft
   module Redirection
     extend ActiveSupport::Concern
 
+    private
     def redirect_via_turbolinks_to(url = {}, response_status = {})
       redirect_to(url, response_status)
 

data/lib/turbograft/version.rb

@@ -1,3 +1,3 @@
 module TurboGraft
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/lib/turbograft.js

@@ -0,0 +1,978 @@
+(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) {
+  var className, _i, _len, _ref;
+  _ref = node.classList;
+  for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+    className = _ref[_i];
+    if (className === search) {
+      return true;
+    }
+  }
+  return false;
+};
+
+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')
+  };
+  remote = new TurboGraft.Remote(options);
+};
+
+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) {
+    var actualRequestType, formData, xhr;
+    this.opts = opts;
+    if (form) {
+      formData = new FormData(form);
+    } else {
+      formData = new FormData();
+    }
+    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() {
+      return triggerEvent('turbograft:remote:start', xhr);
+    });
+    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() {
+      return triggerEvent('turbograft:remote:always', xhr);
+    });
+    xhr.send(formData);
+    return xhr;
+  }
+
+  Remote.prototype.onSuccess = function(ev) {
+    var redirect, xhr;
+    xhr = ev.target;
+    triggerEvent('turbograft:remote:success', xhr);
+    if (redirect = xhr.getResponseHeader('X-Next-Redirect')) {
+      Page.visit(redirect, {
+        reload: true
+      });
+      return;
+    }
+    if (this.opts.fullRefresh) {
+      return Page.refresh({
+        onlyKeys: this.refreshOnSuccess
+      });
+    } 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);
+    if (this.refreshOnError) {
+      return Page.refresh({
+        response: xhr,
+        onlyKeys: this.refreshOnError
+      });
+    } else {
+      return triggerEvent('turbograft:remote:fail:unhandled', xhr);
+    }
+  };
+
+  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]);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turbograft
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Kristian Plettenberg-Dussault
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-23 00:00:00.000000000 Z
+date: 2016-05-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coffee-rails
@@ -229,6 +229,7 @@ files:
 - lib/assets/javascripts/turbograft/page.coffee
 - lib/assets/javascripts/turbograft/remote.coffee
 - lib/assets/javascripts/turbograft/turbolinks.coffee
+- lib/turbograft.js
 - lib/turbograft.rb
 - lib/turbograft/cookies.rb
 - lib/turbograft/redirection.rb
@@ -256,7 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: turbolinks with partial page replacement