turbolinks-noop 3.0.1

data/lib/assets/javascripts/turbolinks.coffee

@@ -0,0 +1,734 @@
+pageCache               = {}
+cacheSize               = 10
+transitionCacheEnabled  = false
+requestCachingEnabled   = true
+progressBar             = null
+progressBarDelay        = 400
+
+currentState            = null
+loadedAssets            = null
+
+referer                 = null
+
+xhr                     = null
+
+EVENTS =
+  BEFORE_CHANGE:  'page:before-change'
+  FETCH:          'page:fetch'
+  RECEIVE:        'page:receive'
+  CHANGE:         'page:change'
+  UPDATE:         'page:update'
+  LOAD:           'page:load'
+  PARTIAL_LOAD:   'page:partial-load'
+  RESTORE:        'page:restore'
+  BEFORE_UNLOAD:  'page:before-unload'
+  AFTER_REMOVE:   'page:after-remove'
+
+isPartialReplacement = (options) ->
+  options.change or options.append or options.prepend
+
+fetch = (url, options = {}) ->
+  url = new ComponentUrl url
+
+  return if pageChangePrevented(url.absolute)
+
+  if url.crossOrigin()
+    document.location.href = url.absolute
+    return
+
+  if isPartialReplacement(options) or options.keep
+    removeCurrentPageFromCache()
+  else
+    cacheCurrentPage()
+
+  rememberReferer()
+  progressBar?.start(delay: progressBarDelay)
+
+  if transitionCacheEnabled and !isPartialReplacement(options) and cachedPage = transitionCacheFor(url.absolute)
+    reflectNewUrl(url)
+    fetchHistory cachedPage
+    options.showProgressBar = false
+    options.scroll = false
+  else
+    options.scroll ?= false if isPartialReplacement(options) and !url.hash
+
+  fetchReplacement url, options
+
+transitionCacheFor = (url) ->
+  return if url is currentState.url
+  cachedPage = pageCache[url]
+  cachedPage if cachedPage and !cachedPage.transitionCacheDisabled
+
+enableTransitionCache = (enable = true) ->
+  transitionCacheEnabled = enable
+
+disableRequestCaching = (disable = true) ->
+  requestCachingEnabled = not disable
+  disable
+
+fetchReplacement = (url, options) ->
+  options.cacheRequest ?= requestCachingEnabled
+  options.showProgressBar ?= true
+
+  triggerEvent EVENTS.FETCH, url: url.absolute
+
+  xhr?.abort()
+  xhr = new XMLHttpRequest
+  xhr.open 'GET', url.formatForXHR(cache: options.cacheRequest), true
+  xhr.setRequestHeader 'Accept', 'text/html, application/xhtml+xml, application/xml'
+  xhr.setRequestHeader 'X-XHR-Referer', referer
+
+  xhr.onload = ->
+    triggerEvent EVENTS.RECEIVE, url: url.absolute
+
+    if doc = processResponse()
+      reflectNewUrl url
+      reflectRedirectedUrl()
+      loadedNodes = changePage extractTitleAndBody(doc)..., options
+      if options.showProgressBar
+        progressBar?.done()
+      updateScrollPosition(options.scroll)
+      triggerEvent (if isPartialReplacement(options) then EVENTS.PARTIAL_LOAD else EVENTS.LOAD), loadedNodes
+      constrainPageCacheTo(cacheSize)
+    else
+      progressBar?.done()
+      document.location.href = crossOriginRedirect() or url.absolute
+
+  if progressBar and options.showProgressBar
+    xhr.onprogress = (event) =>
+      percent = if event.lengthComputable
+        event.loaded / event.total * 100
+      else
+        progressBar.value + (100 - progressBar.value) / 10
+      progressBar.advanceTo(percent)
+
+  xhr.onloadend = -> xhr = null
+  xhr.onerror   = -> document.location.href = url.absolute
+
+  xhr.send()
+
+fetchHistory = (cachedPage, options = {}) ->
+  xhr?.abort()
+  changePage cachedPage.title, cachedPage.body, null, runScripts: false
+  progressBar?.done()
+  updateScrollPosition(options.scroll)
+  triggerEvent EVENTS.RESTORE
+
+cacheCurrentPage = ->
+  currentStateUrl = new ComponentUrl currentState.url
+
+  pageCache[currentStateUrl.absolute] =
+    url:                      currentStateUrl.relative,
+    body:                     document.body,
+    title:                    document.title,
+    positionY:                window.pageYOffset,
+    positionX:                window.pageXOffset,
+    cachedAt:                 new Date().getTime(),
+    transitionCacheDisabled:  document.querySelector('[data-no-transition-cache]')?
+
+removeCurrentPageFromCache = ->
+  delete pageCache[new ComponentUrl(currentState.url).absolute]
+
+pagesCached = (size = cacheSize) ->
+  cacheSize = parseInt(size) if /^[\d]+$/.test size
+
+constrainPageCacheTo = (limit) ->
+  pageCacheKeys = Object.keys pageCache
+
+  cacheTimesRecentFirst = pageCacheKeys.map (url) ->
+    pageCache[url].cachedAt
+  .sort (a, b) -> b - a
+
+  for key in pageCacheKeys when pageCache[key].cachedAt <= cacheTimesRecentFirst[limit]
+    onNodeRemoved(pageCache[key].body)
+    delete pageCache[key]
+
+replace = (html, options = {}) ->
+  loadedNodes = changePage extractTitleAndBody(createDocument(html))..., options
+  triggerEvent (if isPartialReplacement(options) then EVENTS.PARTIAL_LOAD else EVENTS.LOAD), loadedNodes
+
+changePage = (title, body, csrfToken, options) ->
+  title = options.title ? title
+  currentBody = document.body
+
+  if isPartialReplacement(options)
+    nodesToAppend = findNodesMatchingKeys(currentBody, options.append) if options.append
+    nodesToPrepend = findNodesMatchingKeys(currentBody, options.prepend) if options.prepend
+
+    nodesToReplace = findNodes(currentBody, '[data-turbolinks-temporary]')
+    nodesToReplace = nodesToReplace.concat findNodesMatchingKeys(currentBody, options.change) if options.change
+
+    nodesToChange = [].concat(nodesToAppend || [], nodesToPrepend || [], nodesToReplace || [])
+    nodesToChange = removeDuplicates(nodesToChange)
+  else
+    nodesToChange = [currentBody]
+
+  triggerEvent EVENTS.BEFORE_UNLOAD, nodesToChange
+  document.title = title if title isnt false
+
+  if isPartialReplacement(options)
+    appendedNodes = swapNodes(body, nodesToAppend, keep: false, append: true) if nodesToAppend
+    prependedNodes = swapNodes(body, nodesToPrepend, keep: false, prepend: true) if nodesToPrepend
+    replacedNodes = swapNodes(body, nodesToReplace, keep: false) if nodesToReplace
+
+    changedNodes = [].concat(appendedNodes || [], prependedNodes || [], replacedNodes || [])
+    changedNodes = removeDuplicates(changedNodes)
+  else
+    unless options.flush
+      nodesToKeep = findNodes(currentBody, '[data-turbolinks-permanent]')
+      nodesToKeep.push(findNodesMatchingKeys(currentBody, options.keep)...) if options.keep
+      swapNodes(body, removeDuplicates(nodesToKeep), keep: true)
+
+    document.body = body
+    CSRFToken.update csrfToken if csrfToken?
+    setAutofocusElement()
+    changedNodes = [body]
+
+  executeScriptTags(getScriptsToRun(changedNodes, options.runScripts))
+  currentState = window.history.state
+
+  triggerEvent EVENTS.CHANGE, changedNodes
+  triggerEvent EVENTS.UPDATE
+  return changedNodes
+
+findNodes = (body, selector) ->
+  Array::slice.apply(body.querySelectorAll(selector))
+
+findNodesMatchingKeys = (body, keys) ->
+  matchingNodes = []
+  for key in (if Array.isArray(keys) then keys else [keys])
+    matchingNodes.push(findNodes(body, '[id^="'+key+':"], [id="'+key+'"]')...)
+
+  return matchingNodes
+
+swapNodes = (targetBody, existingNodes, options) ->
+  changedNodes = []
+  for existingNode in existingNodes
+    unless nodeId = existingNode.getAttribute('id')
+      throw new Error("Turbolinks partial replace: turbolinks elements must have an id.")
+
+    if targetNode = targetBody.querySelector('[id="'+nodeId+'"]')
+      if options.keep
+        existingNode.parentNode.insertBefore(existingNode.cloneNode(true), existingNode)
+        existingNode = targetNode.ownerDocument.adoptNode(existingNode)
+        targetNode.parentNode.replaceChild(existingNode, targetNode)
+      else
+        if options.append or options.prepend
+          firstChild = existingNode.firstChild
+
+          childNodes = Array::slice.call targetNode.childNodes, 0 # a copy has to be made since the list is mutated while processing
+
+          for childNode in childNodes
+            if !firstChild or options.append # when the parent node is empty, there is no difference between appending and prepending
+              existingNode.appendChild(childNode)
+            else if options.prepend
+              existingNode.insertBefore(childNode, firstChild)
+
+          changedNodes.push(existingNode)
+        else
+          existingNode.parentNode.replaceChild(targetNode, existingNode)
+          onNodeRemoved(existingNode)
+          changedNodes.push(targetNode)
+
+  return changedNodes
+
+onNodeRemoved = (node) ->
+  if typeof jQuery isnt 'undefined'
+    jQuery(node).remove()
+  triggerEvent(EVENTS.AFTER_REMOVE, node)
+
+getScriptsToRun = (changedNodes, runScripts) ->
+  selector = if runScripts is false then 'script[data-turbolinks-eval="always"]' else 'script:not([data-turbolinks-eval="false"])'
+  script for script in document.body.querySelectorAll(selector) when isEvalAlways(script) or (nestedWithinNodeList(changedNodes, script) and not withinPermanent(script))
+
+isEvalAlways = (script) ->
+  script.getAttribute('data-turbolinks-eval') is 'always'
+
+withinPermanent = (element) ->
+  while element?
+    return true if element.hasAttribute?('data-turbolinks-permanent')
+    element = element.parentNode
+
+  return false
+
+nestedWithinNodeList = (nodeList, element) ->
+  while element?
+    return true if element in nodeList
+    element = element.parentNode
+
+  return false
+
+executeScriptTags = (scripts) ->
+  for script in scripts when script.type in ['', 'text/javascript']
+    copy = document.createElement 'script'
+    copy.setAttribute attr.name, attr.value for attr in script.attributes
+    copy.async = false unless script.hasAttribute 'async'
+    copy.appendChild document.createTextNode script.innerHTML
+    { parentNode, nextSibling } = script
+    parentNode.removeChild script
+    parentNode.insertBefore copy, nextSibling
+  return
+
+# Firefox bug: Doesn't autofocus fields that are inserted via JavaScript
+setAutofocusElement = ->
+  autofocusElement = (list = document.querySelectorAll 'input[autofocus], textarea[autofocus]')[list.length - 1]
+  if autofocusElement and document.activeElement isnt autofocusElement
+    autofocusElement.focus()
+
+reflectNewUrl = (url) ->
+  if (url = new ComponentUrl url).absolute not in [referer, document.location.href]
+    window.history.pushState { turbolinks: true, url: url.absolute }, '', url.absolute
+
+reflectRedirectedUrl = ->
+  if location = xhr.getResponseHeader 'X-XHR-Redirected-To'
+    location = new ComponentUrl location
+    preservedHash = if location.hasNoHash() then document.location.hash else ''
+    window.history.replaceState window.history.state, '', location.href + preservedHash
+
+crossOriginRedirect = ->
+  redirect if (redirect = xhr.getResponseHeader('Location'))? and (new ComponentUrl(redirect)).crossOrigin()
+
+rememberReferer = ->
+  referer = document.location.href
+
+rememberCurrentUrlAndState = ->
+  window.history.replaceState { turbolinks: true, url: document.location.href }, '', document.location.href
+  currentState = window.history.state
+
+updateScrollPosition = (position) ->
+  if Array.isArray(position)
+    window.scrollTo position[0], position[1]
+  else if position isnt false
+    if document.location.hash
+      document.location.href = document.location.href
+      rememberCurrentUrlAndState()
+    else
+      window.scrollTo 0, 0
+
+clone = (original) ->
+  return original if not original? or typeof original isnt 'object'
+  copy = new original.constructor()
+  copy[key] = clone value for key, value of original
+  copy
+
+removeDuplicates = (array) ->
+  result = []
+  result.push(obj) for obj in array when result.indexOf(obj) is -1
+  result
+
+popCookie = (name) ->
+  value = document.cookie.match(new RegExp(name+"=(\\w+)"))?[1].toUpperCase() or ''
+  document.cookie = name + '=; expires=Thu, 01-Jan-70 00:00:01 GMT; path=/'
+  value
+
+uniqueId = ->
+  new Date().getTime().toString(36)
+
+triggerEvent = (name, data) ->
+  if typeof Prototype isnt 'undefined'
+    Event.fire document, name, data, true
+
+  event = document.createEvent 'Events'
+  event.data = data if data
+  event.initEvent name, true, true
+  document.dispatchEvent event
+
+pageChangePrevented = (url) ->
+  !triggerEvent EVENTS.BEFORE_CHANGE, url: url
+
+processResponse = ->
+  clientOrServerError = ->
+    400 <= xhr.status < 600
+
+  validContent = ->
+    (contentType = xhr.getResponseHeader('Content-Type'))? and
+      contentType.match /^(?:text\/html|application\/xhtml\+xml|application\/xml)(?:;|$)/
+
+  downloadingFile = ->
+    (disposition = xhr.getResponseHeader('Content-Disposition'))? and
+      disposition.match /^attachment/
+
+  extractTrackAssets = (doc) ->
+    for node in doc.querySelector('head').childNodes when node.getAttribute?('data-turbolinks-track')?
+      node.getAttribute('src') or node.getAttribute('href')
+
+  assetsChanged = (doc) ->
+    loadedAssets ||= extractTrackAssets document
+    fetchedAssets  = extractTrackAssets doc
+    fetchedAssets.length isnt loadedAssets.length or intersection(fetchedAssets, loadedAssets).length isnt loadedAssets.length
+
+  intersection = (a, b) ->
+    [a, b] = [b, a] if a.length > b.length
+    value for value in a when value in b
+
+  if not clientOrServerError() and validContent() and not downloadingFile()
+    doc = createDocument xhr.responseText
+    if doc and !assetsChanged doc
+      return doc
+
+extractTitleAndBody = (doc) ->
+  title = doc.querySelector 'title'
+  [ title?.textContent, doc.querySelector('body'), CSRFToken.get(doc).token ]
+
+CSRFToken =
+  get: (doc = document) ->
+    node:   tag = doc.querySelector 'meta[name="csrf-token"]'
+    token:  tag?.getAttribute? 'content'
+
+  update: (latest) ->
+    current = @get()
+    if current.token? and latest? and current.token isnt latest
+      current.node.setAttribute 'content', latest
+
+createDocument = (html) ->
+  if /<(html|body)/i.test(html)
+    doc = document.documentElement.cloneNode()
+    doc.innerHTML = html
+  else
+    doc = document.documentElement.cloneNode(true)
+    doc.querySelector('body').innerHTML = html
+  doc.head = doc.querySelector('head')
+  doc.body = doc.querySelector('body')
+  doc
+
+# The ComponentUrl class converts a basic URL string into an object
+# that behaves similarly to document.location.
+#
+# If an instance is created from a relative URL, the current document
+# is used to fill in the missing attributes (protocol, host, port).
+class ComponentUrl
+  constructor: (@original = document.location.href) ->
+    return @original if @original.constructor is ComponentUrl
+    @_parse()
+
+  withoutHash: -> @href.replace(@hash, '').replace('#', '')
+
+  # Intention revealing function alias
+  withoutHashForIE10compatibility: -> @withoutHash()
+
+  hasNoHash: -> @hash.length is 0
+
+  crossOrigin: ->
+    @origin isnt (new ComponentUrl).origin
+
+  formatForXHR: (options = {}) ->
+    (if options.cache then @ else @withAntiCacheParam()).withoutHashForIE10compatibility()
+
+  withAntiCacheParam: ->
+    new ComponentUrl(
+      if /([?&])_=[^&]*/.test @absolute
+        @absolute.replace /([?&])_=[^&]*/, "$1_=#{uniqueId()}"
+      else
+        new ComponentUrl(@absolute + (if /\?/.test(@absolute) then "&" else "?") + "_=#{uniqueId()}")
+    )
+
+  _parse: ->
+    (@link ?= document.createElement 'a').href = @original
+    { @href, @protocol, @host, @hostname, @port, @pathname, @search, @hash } = @link
+    @origin = [@protocol, '//', @hostname].join ''
+    @origin += ":#{@port}" unless @port.length is 0
+    @relative = [@pathname, @search, @hash].join ''
+    @absolute = @href
+
+# The Link class derives from the ComponentUrl class, but is built from an
+# existing link element.  Provides verification functionality for Turbolinks
+# to use in determining whether it should process the link when clicked.
+class Link extends ComponentUrl
+  @HTML_EXTENSIONS: ['html']
+
+  @allowExtensions: (extensions...) ->
+    Link.HTML_EXTENSIONS.push extension for extension in extensions
+    Link.HTML_EXTENSIONS
+
+  constructor: (@link) ->
+    return @link if @link.constructor is Link
+    @original = @link.href
+    @originalElement = @link
+    @link = @link.cloneNode false
+    super
+
+  shouldIgnore: ->
+    @crossOrigin() or
+      @_anchored() or
+      @_nonHtml() or
+      @_optOut() or
+      @_target()
+
+  _anchored: ->
+    (@hash.length > 0 or @href.charAt(@href.length - 1) is '#') and
+      (@withoutHash() is (new ComponentUrl).withoutHash())
+
+  _nonHtml: ->
+    @pathname.match(/\.[a-z]+$/g) and not @pathname.match(new RegExp("\\.(?:#{Link.HTML_EXTENSIONS.join('|')})?$", 'g'))
+
+  _optOut: ->
+    link = @originalElement
+    until ignore or link is document
+      ignore = link.getAttribute('data-no-turbolink')?
+      link = link.parentNode
+    ignore
+
+  _target: ->
+    @link.target.length isnt 0
+
+
+# The Click class handles clicked links, verifying if Turbolinks should
+# take control by inspecting both the event and the link. If it should,
+# the page change process is initiated. If not, control is passed back
+# to the browser for default functionality.
+class Click
+  @installHandlerLast: (event) ->
+    unless event.defaultPrevented
+      document.removeEventListener 'click', Click.handle, false
+      document.addEventListener 'click', Click.handle, false
+
+  @handle: (event) ->
+    new Click event
+
+  constructor: (@event) ->
+    return if @event.defaultPrevented
+    @_extractLink()
+    if @_validForTurbolinks()
+      visit @link.href
+      @event.preventDefault()
+
+  _extractLink: ->
+    link = @event.target
+    link = link.parentNode until !link.parentNode or link.nodeName is 'A'
+    @link = new Link(link) if link.nodeName is 'A' and link.href.length isnt 0
+
+  _validForTurbolinks: ->
+    @link? and not (@link.shouldIgnore() or @_nonStandardClick())
+
+  _nonStandardClick: ->
+    @event.which > 1 or
+      @event.metaKey or
+      @event.ctrlKey or
+      @event.shiftKey or
+      @event.altKey
+
+
+class ProgressBar
+  className = 'turbolinks-progress-bar'
+  # Setting the opacity to a value < 1 fixes a display issue in Safari 6 and
+  # iOS 6 where the progress bar would fill the entire page.
+  originalOpacity = 0.99
+
+  @enable: ->
+    progressBar ?= new ProgressBar 'html'
+
+  @disable: ->
+    progressBar?.uninstall()
+    progressBar = null
+
+  constructor: (@elementSelector) ->
+    @value = 0
+    @content = ''
+    @speed = 300
+    @opacity = originalOpacity
+    @install()
+
+  install: ->
+    @element = document.querySelector(@elementSelector)
+    @element.classList.add(className)
+    @styleElement = document.createElement('style')
+    document.head.appendChild(@styleElement)
+    @_updateStyle()
+
+  uninstall: ->
+    @element.classList.remove(className)
+    document.head.removeChild(@styleElement)
+
+  start: ({delay} = {})->
+    clearTimeout(@displayTimeout)
+    if delay
+      @display = false
+      @displayTimeout = setTimeout =>
+        @display = true
+      , delay
+    else
+      @display = true
+
+    if @value > 0
+      @_reset()
+      @_reflow()
+
+    @advanceTo(5)
+
+  advanceTo: (value) ->
+    if value > @value <= 100
+      @value = value
+      @_updateStyle()
+
+      if @value is 100
+        @_stopTrickle()
+      else if @value > 0
+        @_startTrickle()
+
+  done: ->
+    if @value > 0
+      @advanceTo(100)
+      @_finish()
+
+  _finish: ->
+    @fadeTimer = setTimeout =>
+      @opacity = 0
+      @_updateStyle()
+    , @speed / 2
+
+    @resetTimer = setTimeout(@_reset, @speed)
+
+  _reflow: ->
+    @element.offsetHeight
+
+  _reset: =>
+    @_stopTimers()
+    @value = 0
+    @opacity = originalOpacity
+    @_withSpeed(0, => @_updateStyle(true))
+
+  _stopTimers: ->
+    @_stopTrickle()
+    clearTimeout(@fadeTimer)
+    clearTimeout(@resetTimer)
+
+  _startTrickle: ->
+    return if @trickleTimer
+    @trickleTimer = setTimeout(@_trickle, @speed)
+
+  _stopTrickle: ->
+    clearTimeout(@trickleTimer)
+    delete @trickleTimer
+
+  _trickle: =>
+    @advanceTo(@value + Math.random() / 2)
+    @trickleTimer = setTimeout(@_trickle, @speed)
+
+  _withSpeed: (speed, fn) ->
+    originalSpeed = @speed
+    @speed = speed
+    result = fn()
+    @speed = originalSpeed
+    result
+
+  _updateStyle: (forceRepaint = false) ->
+    @_changeContentToForceRepaint() if forceRepaint
+    @styleElement.textContent = @_createCSSRule()
+
+  _changeContentToForceRepaint: ->
+    @content = if @content is '' then ' ' else ''
+
+  _createCSSRule: ->
+    """
+    #{@elementSelector}.#{className}::before {
+      content: '#{@content}';
+      position: fixed;
+      top: 0;
+      left: 0;
+      z-index: 2000;
+      background-color: #0076ff;
+      height: 3px;
+      opacity: #{@opacity};
+      width: #{if @display then @value else 0}%;
+      transition: width #{@speed}ms ease-out, opacity #{@speed / 2}ms ease-in;
+      transform: translate3d(0,0,0);
+    }
+    """
+
+ProgressBarAPI =
+  enable: ProgressBar.enable
+  disable: ProgressBar.disable
+  setDelay: (value) -> progressBarDelay = value
+  start: (options) -> ProgressBar.enable().start(options)
+  advanceTo: (value) -> progressBar?.advanceTo(value)
+  done: -> progressBar?.done()
+
+installDocumentReadyPageEventTriggers = ->
+  document.addEventListener 'DOMContentLoaded', ( ->
+    triggerEvent EVENTS.CHANGE, [document.body]
+    triggerEvent EVENTS.UPDATE
+  ), true
+
+installJqueryAjaxSuccessPageUpdateTrigger = ->
+  if typeof jQuery isnt 'undefined'
+    jQuery(document).on 'ajaxSuccess', (event, xhr, settings) ->
+      return unless jQuery.trim xhr.responseText
+      triggerEvent EVENTS.UPDATE
+
+onHistoryChange = (event) ->
+  if event.state?.turbolinks && event.state.url != currentState.url
+    previousUrl = new ComponentUrl(currentState.url)
+    newUrl = new ComponentUrl(event.state.url)
+
+    if newUrl.withoutHash() is previousUrl.withoutHash()
+      updateScrollPosition()
+    else if cachedPage = pageCache[newUrl.absolute]
+      cacheCurrentPage()
+      fetchHistory cachedPage, scroll: [cachedPage.positionX, cachedPage.positionY]
+    else
+      visit event.target.location.href
+
+initializeTurbolinks = ->
+  rememberCurrentUrlAndState()
+  ProgressBar.enable()
+
+  document.addEventListener 'click', Click.installHandlerLast, true
+  window.addEventListener 'hashchange', rememberCurrentUrlAndState, false
+  window.addEventListener 'popstate', onHistoryChange, false
+
+browserSupportsPushState = window.history and 'pushState' of window.history and 'state' of window.history
+
+# Copied from https://github.com/Modernizr/Modernizr/blob/master/feature-detects/history.js
+ua = navigator.userAgent
+browserIsBuggy =
+  (ua.indexOf('Android 2.') != -1 or ua.indexOf('Android 4.0') != -1) and
+  ua.indexOf('Mobile Safari') != -1 and
+  ua.indexOf('Chrome') == -1 and
+  ua.indexOf('Windows Phone') == -1
+
+requestMethodIsSafe = popCookie('request_method') in ['GET','']
+
+# Disabling Turbolinks for all browsers
+browserSupportsTurbolinks = false
+
+browserSupportsCustomEvents =
+  document.addEventListener and document.createEvent
+
+if browserSupportsCustomEvents
+  installDocumentReadyPageEventTriggers()
+  installJqueryAjaxSuccessPageUpdateTrigger()
+
+if browserSupportsTurbolinks
+  visit = fetch
+  initializeTurbolinks()
+else
+  visit = (url = document.location.href) -> document.location.href = url
+
+# Public API
+#   Turbolinks.visit(url)
+#   Turbolinks.replace(html)
+#   Turbolinks.pagesCached()
+#   Turbolinks.pagesCached(20)
+#   Turbolinks.cacheCurrentPage()
+#   Turbolinks.enableTransitionCache()
+#   Turbolinks.disableRequestCaching()
+#   Turbolinks.ProgressBar.enable()
+#   Turbolinks.ProgressBar.disable()
+#   Turbolinks.ProgressBar.start()
+#   Turbolinks.ProgressBar.advanceTo(80)
+#   Turbolinks.ProgressBar.done()
+#   Turbolinks.allowLinkExtensions('md')
+#   Turbolinks.supported
+#   Turbolinks.EVENTS
+@Turbolinks = {
+  visit,
+  replace,
+  pagesCached,
+  cacheCurrentPage,
+  enableTransitionCache,
+  disableRequestCaching,
+  ProgressBar: ProgressBarAPI,
+  allowLinkExtensions: Link.allowExtensions,
+  supported: browserSupportsTurbolinks,
+  EVENTS: clone(EVENTS)
+}