turbograft 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 787fc4754c128412c6e357c972d57e2fa7296626
-  data.tar.gz: 4003be73065634f0f6ac7a7bc3b7e6dd5c66d658
+  metadata.gz: 0c249b4ccd0c6e283c8a5bf909ebdec4541b4f4d
+  data.tar.gz: 16169d007d25ecc6ac97c05fb604047440a4ec78
 SHA512:
-  metadata.gz: 9ac920f9f81d37e2b272446abe3fcf4f9423ef69dd6de0334d1cf382795359a878cfcf3096046139c00414e0782c220746946e1c79317f221506b63e75778011
-  data.tar.gz: 5f11c59040c76045370b02fa43c23c9b720d4a166554c0cda354334ae80df6237637ebafc936d04b2b5d1ffc009d8aee6af4d83a162f9a236e62372cff5fc243
+  metadata.gz: 1a843ee131ba65714567e500cba001ec560ac8459316c8f146bb30de45145eb9831a1f5ac69a102a573b667ddff50ead11e2b513b300ddc0487e977888418483
+  data.tar.gz: 40ffcb9804a953630b2f58a4f7d909ba3616abdfcf391e3f742ff0bd181dc0e0c9e20e709732a5078b418e3f870ab6b14a7c6fe576884966a276e1c014e8b4a5

data/lib/assets/javascripts/click.coffee

@@ -0,0 +1,37 @@
+# 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 window.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()
+      Turbolinks.visit @link.href unless @_pageChangePrevented()
+      @event.preventDefault()
+
+  _pageChangePrevented: ->
+    !triggerEvent 'page:before-change' # TODO: fix this global
+
+  _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

data/lib/assets/javascripts/component_url.coffee

@@ -0,0 +1,24 @@
+# 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 window.ComponentUrl
+  constructor: (@original = document.location.href) ->
+    return @original if @original.constructor is ComponentUrl
+    @_parse()
+
+  withoutHash: -> @href.replace @hash, ''
+
+  # Intention revealing function alias
+  withoutHashForIE10compatibility: -> @withoutHash()
+
+  hasNoHash: -> @hash.length is 0
+
+  _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

data/lib/assets/javascripts/csrf_token.coffee

@@ -0,0 +1,9 @@
+class window.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

data/lib/assets/javascripts/initializers.coffee

@@ -0,0 +1,16 @@
+partialGraftClickHandler = (ev) ->
+  target = ev.target
+  partialGraft = target.getAttribute("partial-graft")
+  return unless partialGraft?
+  href = target.getAttribute("href")
+  refresh = target.getAttribute("refresh")
+  throw "TurboGraft developer error: href is not defined on node #{target}" if !href?
+  throw "TurboGraft developer error: refresh is not defined on node #{target}" if !refresh?
+
+  keys = refresh.trim().split(" ")
+
+  Page.refresh
+    url: href,
+    onlyKeys: keys
+
+document.addEventListener 'click', partialGraftClickHandler, true

data/lib/assets/javascripts/link.coffee

@@ -0,0 +1,41 @@
+# 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 window.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
+    super
+
+  shouldIgnore: ->
+    @_crossOrigin() or
+      @_anchored() or
+      @_nonHtml() or
+      @_optOut() or
+      @_target()
+
+  _crossOrigin: ->
+    @origin isnt (new ComponentUrl).origin
+
+  _anchored: ->
+    ((@hash and @withoutHash()) is (current = new ComponentUrl).withoutHash()) or
+      (@href is current.href + '#')
+
+  _nonHtml: ->
+    @pathname.match(/\.[a-z]+$/g) and not @pathname.match(new RegExp("\\.(?:#{Link.HTML_EXTENSIONS.join('|')})?$", 'g'))
+
+  _optOut: ->
+    link = @link
+    until ignore or link is document or link is null
+      ignore = link.getAttribute('data-no-turbolink')?
+      link = link.parentNode
+    ignore
+
+  _target: ->
+    @link.target.length isnt 0

data/lib/assets/javascripts/page.coffee

@@ -0,0 +1,25 @@
+window.Page = {} if !window.Page
+
+Page.visit = (url, opts={}) ->
+  if opts.reload
+    window.location = url
+  else
+    Turbolinks.visit(url)
+
+Page.refresh = (options = {}, callback) ->
+  newUrl = if options.url
+    options.url
+  else if options.queryParams
+    paramString = $.param(options.queryParams)
+    paramString = "?#{paramString}" if paramString
+    location.pathname + paramString
+  else
+    location.href
+
+  if options.response
+    Turbolinks.loadPage null, options.response, true, callback, options.onlyKeys || []
+  else
+    Turbolinks.visit newUrl, true, options.onlyKeys || [], -> callback?()
+
+Page.open = ->
+  window.open(arguments...)

data/lib/assets/javascripts/page_cache.coffee

@@ -0,0 +1,42 @@
+class window.PageCache
+  storage = {}
+  simultaneousAdditionOffset = 0
+  constructor: (@cacheSize = 10) ->
+    storage = {}
+    return this
+
+  get: (key) ->
+    storage[key]
+
+  set: (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
+    @constrain()
+
+  clear: ->
+    storage = {}
+
+  setCacheSize: (newSize) ->
+    if /^[\d]+$/.test(newSize)
+      @cacheSize = parseInt(newSize, 10)
+      @constrain()
+    else
+      throw "Developer error: Invalid parameter '#{newSize}' for PageCache; must be integer"
+
+  constrain: ->
+    pageCacheKeys = Object.keys storage
+
+    cacheTimesRecentFirst = pageCacheKeys.map (url) =>
+      storage[url].cachedAt
+    .sort (a, b) -> b - a
+
+    for key in pageCacheKeys when storage[key].cachedAt <= cacheTimesRecentFirst[@cacheSize]
+      triggerEvent 'page:expire', storage[key] # TODO: fix this global
+      delete storage[key]
+
+  length: ->
+    Object.keys(storage).length

data/lib/assets/javascripts/turbograft.coffee

@@ -0,0 +1,8 @@
+#= require click
+#= require component_url
+#= require csrf_token
+#= require link
+#= require page
+#= require page_cache
+#= require turbolinks
+#= require initializers

data/lib/assets/javascripts/turbolinks.coffee

@@ -0,0 +1,353 @@
+xhr                     = null
+
+installDocumentReadyPageEventTriggers = ->
+  document.addEventListener 'DOMContentLoaded', ( ->
+    triggerEvent 'page:change'
+    triggerEvent 'page:update'
+  ), true
+
+installJqueryAjaxSuccessPageUpdateTrigger = ->
+  if typeof jQuery isnt 'undefined'
+    jQuery(document).on 'ajaxSuccess', (event, xhr, settings) ->
+      return unless jQuery.trim xhr.responseText
+      triggerEvent 'page:update'
+
+# Handle bug in Firefox 26/27 where history.state is initially undefined
+historyStateIsDefined =
+  window.history.state != undefined or navigator.userAgent.match /Firefox\/2[6|7]/
+
+browserSupportsPushState =
+  window.history and window.history.pushState and window.history.replaceState and historyStateIsDefined
+
+browserIsntBuggy =
+  !navigator.userAgent.match /CriOS\//
+
+window.triggerEvent = (name, data) ->
+  event = document.createEvent 'Events'
+  event.data = data if data
+  event.initEvent name, true, true
+  document.dispatchEvent event
+
+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
+
+requestMethodIsSafe =
+  popCookie('request_method') in ['GET','']
+
+browserSupportsTurbolinks = browserSupportsPushState and browserIsntBuggy and requestMethodIsSafe
+
+browserSupportsCustomEvents =
+  document.addEventListener and document.createEvent
+
+if browserSupportsCustomEvents
+  installDocumentReadyPageEventTriggers()
+  installJqueryAjaxSuccessPageUpdateTrigger()
+
+# TODO: triggerEvent should be accessible to all these guys
+# on some kind of eventbus
+# TODO: clean up everything above me ^
+# TODO: decide on the public API
+class window.Turbolinks
+  createDocument = null
+  currentState = null
+  loadedAssets = null
+  referer = null
+  usePageCache = false
+  @pageCache = pageCache = new PageCache()
+
+  fetch = (url, partialReplace = false, replaceContents = [], callback) ->
+    url = new ComponentUrl url
+
+    rememberReferer()
+    Turbolinks.cacheCurrentPage() if usePageCache
+
+    if usePageCache and cachedPage = transitionCacheFor(url.absolute)
+      fetchHistory cachedPage
+      fetchReplacement url, partialReplace, null, replaceContents
+    else
+      fetchReplacement url, partialReplace, ->
+        resetScrollPosition() unless replaceContents.length
+        callback?()
+      , replaceContents
+
+  @pageCacheEnabled = ->
+    usePageCache
+
+  @usePageCache = (status) ->
+    usePageCache = status
+
+  transitionCacheFor = (url) ->
+    cachedPage = pageCache.get(url)
+    cachedPage if cachedPage and !cachedPage.transitionCacheDisabled
+
+  @pushState: (state, title, url) ->
+    window.history.pushState(state, title, url)
+
+  @replaceState: (state, title, url) ->
+    window.history.replaceState(state, title, url)
+
+  fetchReplacement = (url, partialReplace, onLoadFunction, replaceContents) ->
+    triggerEvent 'page:fetch', url: url.absolute
+
+    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 = ->
+      if xhr.status >= 500
+        document.location.href = url.absolute
+      else
+        Turbolinks.loadPage(url, xhr, partialReplace, onLoadFunction, replaceContents)
+
+    xhr.onloadend = -> xhr = null
+    xhr.onerror   = ->
+      document.location.href = url.absolute
+
+    xhr.send()
+
+    return
+
+  @loadPage: (url, xhr, partialReplace = false, onLoadFunction = (->), replaceContents = []) ->
+    triggerEvent 'page:receive'
+
+    if doc = processResponse(xhr, partialReplace)
+      reflectNewUrl url
+      nodes = changePage(extractTitleAndBody(doc)..., partialReplace, replaceContents)
+      reflectRedirectedUrl(xhr)
+      triggerEvent 'page:load', nodes
+      onLoadFunction?()
+    else
+      document.location.href = url.absolute
+
+    return
+
+  fetchHistory = (cachedPage) ->
+    xhr?.abort()
+    changePage cachedPage.title, cachedPage.body, false
+    recallScrollPosition cachedPage
+    triggerEvent 'page:restore'
+
+
+  @cacheCurrentPage: ->
+    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]')?
+
+    return
+
+  changePage = (title, body, csrfToken, runScripts, partialReplace, replaceContents = []) ->
+    document.title = title if title
+    if replaceContents.length
+      return refreshNodesWithKeys(replaceContents, body)
+    else
+      deleteRefreshNeverNodes(body)
+
+      triggerEvent 'page:before-replace'
+      document.documentElement.replaceChild body, document.body
+      CSRFToken.update csrfToken if csrfToken?
+      executeScriptTags() if runScripts
+      currentState = window.history.state
+      triggerEvent 'page:change'
+      triggerEvent 'page:update'
+
+    return
+
+  deleteRefreshNeverNodes = (body) ->
+    for node in body.querySelectorAll('[refresh-never]')
+      node.parentNode.removeChild(node)
+
+    return
+
+  refreshNodesWithKeys = (keys, body) ->
+    allNodesToBeRefreshed = []
+    for node in document.querySelectorAll("[refresh-always]")
+      allNodesToBeRefreshed.push(node)
+
+    for key in keys
+      for node in document.querySelectorAll("[refresh=#{key}]")
+        allNodesToBeRefreshed.push(node)
+
+    triggerEvent 'page:before-partial-replace', allNodesToBeRefreshed
+
+    parentIsRefreshing = (node) ->
+      for potentialParent in allNodesToBeRefreshed when node != potentialParent
+        return true if potentialParent.contains(node)
+      false
+
+    refreshedNodes = []
+    for existingNode in allNodesToBeRefreshed
+      continue if parentIsRefreshing(existingNode)
+
+      unless 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)
+
+    refreshedNodes
+
+  executeScriptTags = ->
+    scripts = Array::slice.call document.body.querySelectorAll 'script:not([data-turbolinks-eval="false"])'
+    for script in scripts when script.type in ['', 'text/javascript']
+      executeScriptTag(script)
+    return
+
+  executeScriptTag = (script) ->
+    copy = document.createElement 'script'
+    copy.setAttribute attr.name, attr.value for attr in script.attributes
+    copy.appendChild document.createTextNode script.innerHTML
+    { parentNode, nextSibling } = script
+    parentNode.removeChild script
+    parentNode.insertBefore copy, nextSibling
+    return
+
+  removeNoscriptTags = (node) ->
+    node.innerHTML = node.innerHTML.replace /<noscript[\S\s]*?<\/noscript>/ig, ''
+    node
+
+  reflectNewUrl = (url) ->
+    if (url = new ComponentUrl url).absolute isnt referer
+      Turbolinks.pushState { turbolinks: true, url: url.absolute }, '', url.absolute
+    return
+
+  reflectRedirectedUrl = (xhr) ->
+    if location = xhr.getResponseHeader 'X-XHR-Redirected-To'
+      location = new ComponentUrl location
+      preservedHash = if location.hasNoHash() then document.location.hash else ''
+      Turbolinks.replaceState currentState, '', location.href + preservedHash
+    return
+
+  rememberReferer = ->
+    referer = document.location.href
+
+  @rememberCurrentUrl: ->
+    Turbolinks.replaceState { turbolinks: true, url: document.location.href }, '', document.location.href
+
+  @rememberCurrentState: ->
+    currentState = window.history.state
+
+  recallScrollPosition = (page) ->
+    window.scrollTo page.positionX, page.positionY
+
+  resetScrollPosition = ->
+    if document.location.hash
+      document.location.href = document.location.href
+    else
+      window.scrollTo 0, 0
+
+  pageChangePrevented = ->
+    !triggerEvent 'page:before-change'
+
+  processResponse = (xhr, partial = false) ->
+    clientOrServerError = ->
+      return false if xhr.status == 422 # we want to render form validations
+      400 <= xhr.status < 600
+
+    validContent = ->
+      xhr.getResponseHeader('Content-Type').match /^(?:text\/html|application\/xhtml\+xml|application\/xml)(?:;|$)/
+
+    extractTrackAssets = (doc) ->
+      for node in doc.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 !clientOrServerError() && validContent()
+      doc = createDocument xhr.responseText
+      changed = assetsChanged(doc)
+
+      if doc && (!changed || partial)
+        return doc
+
+  extractTitleAndBody = (doc) ->
+    title = doc.querySelector 'title'
+    [ title?.textContent, removeNoscriptTags(doc.body), CSRFToken.get(doc).token, 'runScripts' ]
+
+  installHistoryChangeHandler = (event) ->
+    if event.state?.turbolinks
+      if cachedPage = pageCache.get((new ComponentUrl(event.state.url)).absolute)
+        Turbolinks.cacheCurrentPage()
+        fetchHistory cachedPage
+      else
+        Turbolinks.visit event.target.location.href
+
+  # Delay execution of function long enough to miss the popstate event
+  # some browsers fire on the initial page load.
+  bypassOnLoadPopstate = (fn) ->
+    setTimeout fn, 500
+
+  browserCompatibleDocumentParser = ->
+    createDocumentUsingParser = (html) ->
+      (new DOMParser).parseFromString html, 'text/html'
+
+    createDocumentUsingDOM = (html) ->
+      doc = document.implementation.createHTMLDocument ''
+      doc.documentElement.innerHTML = html
+      doc
+
+    createDocumentUsingWrite = (html) ->
+      doc = document.implementation.createHTMLDocument ''
+      doc.open 'replace'
+      doc.write html
+      doc.close()
+      doc
+
+    # Use createDocumentUsingParser if DOMParser is defined and natively
+    # supports 'text/html' parsing (Firefox 12+, IE 10)
+    #
+    # Use createDocumentUsingDOM if createDocumentUsingParser throws an exception
+    # due to unsupported type 'text/html' (Firefox < 12, Opera)
+    #
+    # Use createDocumentUsingWrite if:
+    #  - DOMParser isn't defined
+    #  - createDocumentUsingParser returns null due to unsupported type 'text/html' (Chrome, Safari)
+    #  - createDocumentUsingDOM doesn't create a valid HTML document (safeguarding against potential edge cases)
+    try
+      if window.DOMParser
+        testDoc = createDocumentUsingParser '<html><body><p>test'
+        createDocumentUsingParser
+    catch e
+      testDoc = createDocumentUsingDOM '<html><body><p>test'
+      createDocumentUsingDOM
+    finally
+      unless testDoc?.body?.childNodes.length is 1
+        return createDocumentUsingWrite
+
+  if browserSupportsTurbolinks
+    @visit = fetch
+    @rememberCurrentUrl()
+    @rememberCurrentState()
+    createDocument = browserCompatibleDocumentParser()
+
+    document.addEventListener 'click', Click.installHandlerLast, true
+
+    bypassOnLoadPopstate ->
+      window.addEventListener 'popstate', installHistoryChangeHandler, false
+
+  else
+    @visit = (url) -> document.location.href = url

data/lib/turbograft/version.rb

@@ -1,3 +1,3 @@
 module TurboGraft
-  VERSION = '0.0.5'
+  VERSION = '0.0.6'
 end