rails_auth 1.0.4

data/test/dummy/node_modules/turbolinks/src/turbolinks/history.coffee

@@ -0,0 +1,48 @@
+class Turbolinks.History
+  constructor: (@delegate) ->
+
+  start: ->
+    unless @started
+      addEventListener("popstate", @onPopState, false)
+      addEventListener("load", @onPageLoad, false)
+      @started = true
+
+  stop: ->
+    if @started
+      removeEventListener("popstate", @onPopState, false)
+      removeEventListener("load", @onPageLoad, false)
+      @started = false
+
+  push: (location, restorationIdentifier) ->
+    location = Turbolinks.Location.wrap(location)
+    @update("push", location, restorationIdentifier)
+
+  replace: (location, restorationIdentifier) ->
+    location = Turbolinks.Location.wrap(location)
+    @update("replace", location, restorationIdentifier)
+
+  # Event handlers
+
+  onPopState: (event) =>
+    if @shouldHandlePopState()
+      if turbolinks = event.state?.turbolinks
+        location = Turbolinks.Location.wrap(window.location)
+        restorationIdentifier = turbolinks.restorationIdentifier
+        @delegate.historyPoppedToLocationWithRestorationIdentifier(location, restorationIdentifier)
+
+  onPageLoad: (event) =>
+    Turbolinks.defer =>
+      @pageLoaded = true
+
+  # Private
+
+  shouldHandlePopState: ->
+    # Safari dispatches a popstate event after window's load event, ignore it
+    @pageIsLoaded()
+
+  pageIsLoaded: ->
+    @pageLoaded or document.readyState is "complete"
+
+  update: (method, location, restorationIdentifier) ->
+    state = turbolinks: {restorationIdentifier}
+    history[method + "State"](state, null, location)

data/test/dummy/node_modules/turbolinks/src/turbolinks/http_request.coffee

@@ -0,0 +1,88 @@
+class Turbolinks.HttpRequest
+  @NETWORK_FAILURE = 0
+  @TIMEOUT_FAILURE = -1
+
+  @timeout = 60
+
+  constructor: (@delegate, location, referrer) ->
+    @url = Turbolinks.Location.wrap(location).requestURL
+    @referrer = Turbolinks.Location.wrap(referrer).absoluteURL
+    @createXHR()
+
+  send: ->
+    if @xhr and not @sent
+      @notifyApplicationBeforeRequestStart()
+      @setProgress(0)
+      @xhr.send()
+      @sent = true
+      @delegate.requestStarted?()
+
+  cancel: ->
+    if @xhr and @sent
+      @xhr.abort()
+
+  # XMLHttpRequest events
+
+  requestProgressed: (event) =>
+    if event.lengthComputable
+      @setProgress(event.loaded / event.total)
+
+  requestLoaded: =>
+    @endRequest =>
+      if 200 <= @xhr.status < 300
+        @delegate.requestCompletedWithResponse(@xhr.responseText, @xhr.getResponseHeader("Turbolinks-Location"))
+      else
+        @failed = true
+        @delegate.requestFailedWithStatusCode(@xhr.status, @xhr.responseText)
+
+  requestFailed: =>
+    @endRequest =>
+      @failed = true
+      @delegate.requestFailedWithStatusCode(@constructor.NETWORK_FAILURE)
+
+  requestTimedOut: =>
+    @endRequest =>
+      @failed = true
+      @delegate.requestFailedWithStatusCode(@constructor.TIMEOUT_FAILURE)
+
+  requestCanceled: =>
+    @endRequest()
+
+
+  # Application events
+
+  notifyApplicationBeforeRequestStart: ->
+    Turbolinks.dispatch("turbolinks:request-start", data: { url: @url, xhr: @xhr })
+
+  notifyApplicationAfterRequestEnd: ->
+    Turbolinks.dispatch("turbolinks:request-end", data: { url: @url, xhr: @xhr })
+
+  # Private
+
+  createXHR: ->
+    @xhr = new XMLHttpRequest
+    @xhr.open("GET", @url, true)
+    @xhr.timeout = @constructor.timeout * 1000
+    @xhr.setRequestHeader("Accept", "text/html, application/xhtml+xml")
+    @xhr.setRequestHeader("Turbolinks-Referrer", @referrer)
+    @xhr.onprogress = @requestProgressed
+    @xhr.onload = @requestLoaded
+    @xhr.onerror = @requestFailed
+    @xhr.ontimeout = @requestTimedOut
+    @xhr.onabort = @requestCanceled
+
+  endRequest: (callback) ->
+    if @xhr
+      @notifyApplicationAfterRequestEnd()
+      callback?.call(this)
+      @destroy()
+
+  setProgress: (progress) ->
+    @progress = progress
+    @delegate.requestProgressed?(@progress)
+
+  destroy: ->
+    @setProgress(1)
+    @delegate.requestFinished?()
+    @delegate = null
+    @xhr = null

data/test/dummy/node_modules/turbolinks/src/turbolinks/index.coffee

@@ -0,0 +1,22 @@
+#= require ./BANNER
+#= export Turbolinks
+#= require_self
+#= require ./helpers
+#= require ./controller
+#= require ./script_warning
+#= require ./start
+
+@Turbolinks =
+  supported: do ->
+    window.history.pushState? and
+      window.requestAnimationFrame? and
+      window.addEventListener?
+
+  visit: (location, options) ->
+    Turbolinks.controller.visit(location, options)
+
+  clearCache: ->
+    Turbolinks.controller.clearCache()
+
+  setProgressBarDelay: (delay) ->
+    Turbolinks.controller.setProgressBarDelay(delay)

data/test/dummy/node_modules/turbolinks/src/turbolinks/location.coffee

@@ -0,0 +1,70 @@
+class Turbolinks.Location
+  @wrap: (value) ->
+    if value instanceof this
+      value
+    else
+      new this value
+
+  constructor: (url = "") ->
+    linkWithAnchor = document.createElement("a")
+    linkWithAnchor.href = url.toString()
+
+    @absoluteURL = linkWithAnchor.href
+
+    anchorLength = linkWithAnchor.hash.length
+    if anchorLength < 2
+      @requestURL = @absoluteURL
+    else
+      @requestURL = @absoluteURL.slice(0, -anchorLength)
+      @anchor = linkWithAnchor.hash.slice(1)
+
+  getOrigin: ->
+    @absoluteURL.split("/", 3).join("/")
+
+  getPath: ->
+    @requestURL.match(/\/\/[^/]*(\/[^?;]*)/)?[1] ? "/"
+
+  getPathComponents: ->
+    @getPath().split("/").slice(1)
+
+  getLastPathComponent: ->
+    @getPathComponents().slice(-1)[0]
+
+  getExtension: ->
+    @getLastPathComponent().match(/\.[^.]*$/)?[0] ? ""
+
+  isHTML: ->
+    @getExtension().match(/^(?:|\.(?:htm|html|xhtml))$/)
+
+  isPrefixedBy: (location) ->
+    prefixURL = getPrefixURL(location)
+    @isEqualTo(location) or stringStartsWith(@absoluteURL, prefixURL)
+
+  isEqualTo: (location) ->
+    @absoluteURL is location?.absoluteURL
+
+  toCacheKey: ->
+    @requestURL
+
+  toJSON: ->
+    @absoluteURL
+
+  toString: ->
+    @absoluteURL
+
+  valueOf: ->
+    @absoluteURL
+
+  # Private
+
+  getPrefixURL = (location) ->
+    addTrailingSlash(location.getOrigin() + location.getPath())
+
+  addTrailingSlash = (url) ->
+    if stringEndsWith(url, "/") then url else url + "/"
+
+  stringStartsWith = (string, prefix) ->
+    string.slice(0, prefix.length) is prefix
+
+  stringEndsWith = (string, suffix) ->
+    string.slice(-suffix.length) is suffix

data/test/dummy/node_modules/turbolinks/src/turbolinks/progress_bar.coffee

@@ -0,0 +1,83 @@
+class Turbolinks.ProgressBar
+  ANIMATION_DURATION = 300
+
+  @defaultCSS: """
+    .turbolinks-progress-bar {
+      position: fixed;
+      display: block;
+      top: 0;
+      left: 0;
+      height: 3px;
+      background: #0076ff;
+      z-index: 9999;
+      transition: width #{ANIMATION_DURATION}ms ease-out, opacity #{ANIMATION_DURATION / 2}ms #{ANIMATION_DURATION / 2}ms ease-in;
+      transform: translate3d(0, 0, 0);
+    }
+  """
+
+  constructor: ->
+    @stylesheetElement = @createStylesheetElement()
+    @progressElement = @createProgressElement()
+
+  show: ->
+    unless @visible
+      @visible = true
+      @installStylesheetElement()
+      @installProgressElement()
+      @startTrickling()
+
+  hide: ->
+    if @visible and not @hiding
+      @hiding = true
+      @fadeProgressElement =>
+        @uninstallProgressElement()
+        @stopTrickling()
+        @visible = false
+        @hiding = false
+
+  setValue: (@value) ->
+    @refresh()
+
+  # Private
+
+  installStylesheetElement: ->
+    document.head.insertBefore(@stylesheetElement, document.head.firstChild)
+
+  installProgressElement: ->
+    @progressElement.style.width = 0
+    @progressElement.style.opacity = 1
+    document.documentElement.insertBefore(@progressElement, document.body)
+    @refresh()
+
+  fadeProgressElement: (callback) ->
+    @progressElement.style.opacity = 0
+    setTimeout(callback, ANIMATION_DURATION * 1.5)
+
+  uninstallProgressElement: ->
+    if @progressElement.parentNode
+      document.documentElement.removeChild(@progressElement)
+
+  startTrickling: ->
+    @trickleInterval ?= setInterval(@trickle, ANIMATION_DURATION)
+
+  stopTrickling: ->
+    clearInterval(@trickleInterval)
+    @trickleInterval = null
+
+  trickle: =>
+    @setValue(@value + Math.random() / 100)
+
+  refresh: ->
+    requestAnimationFrame =>
+      @progressElement.style.width = "#{10 + (@value * 90)}%"
+
+  createStylesheetElement: ->
+    element = document.createElement("style")
+    element.type = "text/css"
+    element.textContent = @constructor.defaultCSS
+    element
+
+  createProgressElement: ->
+    element = document.createElement("div")
+    element.className = "turbolinks-progress-bar"
+    element

data/test/dummy/node_modules/turbolinks/src/turbolinks/renderer.coffee

@@ -0,0 +1,28 @@
+class Turbolinks.Renderer
+  @render: (delegate, callback, args...) ->
+    renderer = new this args...
+    renderer.delegate = delegate
+    renderer.render(callback)
+    renderer
+
+  renderView: (callback) ->
+    @delegate.viewWillRender(@newBody)
+    callback()
+    @delegate.viewRendered(@newBody)
+
+  invalidateView: ->
+    @delegate.viewInvalidated()
+
+  createScriptElement: (element) ->
+    if element.getAttribute("data-turbolinks-eval") is "false"
+      element
+    else
+      createdScriptElement = document.createElement("script")
+      createdScriptElement.textContent = element.textContent
+      createdScriptElement.async = false
+      copyElementAttributes(createdScriptElement, element)
+      createdScriptElement
+
+  copyElementAttributes = (destinationElement, sourceElement) ->
+    for {name, value} in sourceElement.attributes
+      destinationElement.setAttribute(name, value)

data/test/dummy/node_modules/turbolinks/src/turbolinks/script_warning.coffee

@@ -0,0 +1,16 @@
+do ->
+  return unless element = script = document.currentScript
+  return if script.hasAttribute("data-turbolinks-suppress-warning")
+
+  while element = element.parentNode
+    if element is document.body
+      return console.warn """
+        You are loading Turbolinks from a <script> element inside the <body> element. This is probably not what you meant to do!
+
+        Load your application’s JavaScript bundle inside the <head> element instead. <script> elements in <body> are evaluated with each page change.
+
+        For more information, see: https://github.com/turbolinks/turbolinks#working-with-script-elements
+
+        ——
+        Suppress this warning by adding a `data-turbolinks-suppress-warning` attribute to: %s
+      """, script.outerHTML

data/test/dummy/node_modules/turbolinks/src/turbolinks/scroll_manager.coffee

@@ -0,0 +1,28 @@
+class Turbolinks.ScrollManager
+  constructor: (@delegate) ->
+    @onScroll = Turbolinks.throttle(@onScroll)
+
+  start: ->
+    unless @started
+      addEventListener("scroll", @onScroll, false)
+      @onScroll()
+      @started = true
+
+  stop: ->
+    if @started
+      removeEventListener("scroll", @onScroll, false)
+      @started = false
+
+  scrollToElement: (element) ->
+    element.scrollIntoView()
+
+  scrollToPosition: ({x, y}) ->
+    window.scrollTo(x, y)
+
+  onScroll: (event) =>
+    @updatePosition(x: window.pageXOffset, y: window.pageYOffset)
+
+  # Private
+
+  updatePosition: (@position) ->
+    @delegate?.scrollPositionChanged(@position)

data/test/dummy/node_modules/turbolinks/src/turbolinks/snapshot.coffee

@@ -0,0 +1,65 @@
+#= require ./head_details
+
+class Turbolinks.Snapshot
+  @wrap: (value) ->
+    if value instanceof this
+      value
+    else if typeof value == "string"
+      @fromHTMLString(value)
+    else
+      @fromHTMLElement(value)
+
+  @fromHTMLString: (html) ->
+    htmlElement = document.createElement("html")
+    htmlElement.innerHTML = html
+    @fromHTMLElement(htmlElement)
+
+  @fromHTMLElement: (htmlElement) ->
+    headElement = htmlElement.querySelector("head")
+    bodyElement = htmlElement.querySelector("body") ? document.createElement("body")
+    headDetails = Turbolinks.HeadDetails.fromHeadElement(headElement)
+    new this headDetails, bodyElement
+
+  constructor: (@headDetails, @bodyElement) ->
+
+  clone: ->
+    new @constructor @headDetails, @bodyElement.cloneNode(true)
+
+  getRootLocation: ->
+    root = @getSetting("root") ? "/"
+    new Turbolinks.Location root
+
+  getCacheControlValue: ->
+    @getSetting("cache-control")
+
+  getElementForAnchor: (anchor) ->
+    try @bodyElement.querySelector("[id='#{anchor}'], a[name='#{anchor}']")
+
+  getPermanentElements: ->
+    @bodyElement.querySelectorAll("[id][data-turbolinks-permanent]")
+
+  getPermanentElementById: (id) ->
+    @bodyElement.querySelector("##{id}[data-turbolinks-permanent]")
+
+  getPermanentElementsPresentInSnapshot: (snapshot) ->
+    element for element in @getPermanentElements() when snapshot.getPermanentElementById(element.id)
+
+  findFirstAutofocusableElement: ->
+    @bodyElement.querySelector("[autofocus]")
+
+  hasAnchor: (anchor) ->
+    @getElementForAnchor(anchor)?
+
+  isPreviewable: ->
+    @getCacheControlValue() isnt "no-preview"
+
+  isCacheable: ->
+    @getCacheControlValue() isnt "no-cache"
+
+  isVisitable: ->
+    @getSetting("visit-control") isnt "reload"
+
+  # Private
+
+  getSetting: (name) ->
+    @headDetails.getMetaValue("turbolinks-#{name}")

data/test/dummy/node_modules/turbolinks/src/turbolinks/snapshot_cache.coffee

@@ -0,0 +1,43 @@
+class Turbolinks.SnapshotCache
+  constructor: (@size) ->
+    @keys = []
+    @snapshots = {}
+
+  has: (location) ->
+    key = keyForLocation(location)
+    key of @snapshots
+
+  get: (location) ->
+    return unless @has(location)
+    snapshot = @read(location)
+    @touch(location)
+    snapshot
+
+  put: (location, snapshot) ->
+    @write(location, snapshot)
+    @touch(location)
+    snapshot
+
+  # Private
+
+  read: (location) ->
+    key = keyForLocation(location)
+    @snapshots[key]
+
+  write: (location, snapshot) ->
+    key = keyForLocation(location)
+    @snapshots[key] = snapshot
+
+  touch: (location) ->
+    key = keyForLocation(location)
+    index = @keys.indexOf(key)
+    @keys.splice(index, 1) if index > -1
+    @keys.unshift(key)
+    @trim()
+
+  trim: ->
+    for key in @keys.splice(@size)
+      delete @snapshots[key]
+
+  keyForLocation = (location) ->
+    Turbolinks.Location.wrap(location).toCacheKey()

data/test/dummy/node_modules/turbolinks/src/turbolinks/snapshot_renderer.coffee

@@ -0,0 +1,104 @@
+#= require ./renderer
+
+class Turbolinks.SnapshotRenderer extends Turbolinks.Renderer
+  constructor: (@currentSnapshot, @newSnapshot, @isPreview) ->
+    @currentHeadDetails = @currentSnapshot.headDetails
+    @newHeadDetails = @newSnapshot.headDetails
+    @currentBody = @currentSnapshot.bodyElement
+    @newBody = @newSnapshot.bodyElement
+
+  render: (callback) ->
+    if @shouldRender()
+      @mergeHead()
+      @renderView =>
+        @replaceBody()
+        @focusFirstAutofocusableElement() unless @isPreview
+        callback()
+    else
+      @invalidateView()
+
+  mergeHead: ->
+    @copyNewHeadStylesheetElements()
+    @copyNewHeadScriptElements()
+    @removeCurrentHeadProvisionalElements()
+    @copyNewHeadProvisionalElements()
+
+  replaceBody: ->
+    placeholders = @relocateCurrentBodyPermanentElements()
+    @activateNewBodyScriptElements()
+    @assignNewBody()
+    @replacePlaceholderElementsWithClonedPermanentElements(placeholders)
+
+  shouldRender: ->
+    @newSnapshot.isVisitable() and @trackedElementsAreIdentical()
+
+  trackedElementsAreIdentical: ->
+    @currentHeadDetails.getTrackedElementSignature() is @newHeadDetails.getTrackedElementSignature()
+
+  copyNewHeadStylesheetElements: ->
+    for element in @getNewHeadStylesheetElements()
+      document.head.appendChild(element)
+
+  copyNewHeadScriptElements: ->
+    for element in @getNewHeadScriptElements()
+      document.head.appendChild(@createScriptElement(element))
+
+  removeCurrentHeadProvisionalElements: ->
+    for element in @getCurrentHeadProvisionalElements()
+      document.head.removeChild(element)
+
+  copyNewHeadProvisionalElements: ->
+    for element in @getNewHeadProvisionalElements()
+      document.head.appendChild(element)
+
+  relocateCurrentBodyPermanentElements: ->
+    for permanentElement in @getCurrentBodyPermanentElements()
+      placeholder = createPlaceholderForPermanentElement(permanentElement)
+      newElement = @newSnapshot.getPermanentElementById(permanentElement.id)
+      replaceElementWithElement(permanentElement, placeholder.element)
+      replaceElementWithElement(newElement, permanentElement)
+      placeholder
+
+  replacePlaceholderElementsWithClonedPermanentElements: (placeholders) ->
+    for { element, permanentElement } in placeholders
+      clonedElement = permanentElement.cloneNode(true)
+      replaceElementWithElement(element, clonedElement)
+
+  activateNewBodyScriptElements: ->
+    for inertScriptElement in @getNewBodyScriptElements()
+      activatedScriptElement = @createScriptElement(inertScriptElement)
+      replaceElementWithElement(inertScriptElement, activatedScriptElement)
+
+  assignNewBody: ->
+    document.body = @newBody
+
+  focusFirstAutofocusableElement: ->
+    @newSnapshot.findFirstAutofocusableElement()?.focus()
+
+  getNewHeadStylesheetElements: ->
+    @newHeadDetails.getStylesheetElementsNotInDetails(@currentHeadDetails)
+
+  getNewHeadScriptElements: ->
+    @newHeadDetails.getScriptElementsNotInDetails(@currentHeadDetails)
+
+  getCurrentHeadProvisionalElements: ->
+    @currentHeadDetails.getProvisionalElements()
+
+  getNewHeadProvisionalElements: ->
+    @newHeadDetails.getProvisionalElements()
+
+  getCurrentBodyPermanentElements: ->
+    @currentSnapshot.getPermanentElementsPresentInSnapshot(@newSnapshot)
+
+  getNewBodyScriptElements: ->
+    @newBody.querySelectorAll("script")
+
+createPlaceholderForPermanentElement = (permanentElement) ->
+  element = document.createElement("meta")
+  element.setAttribute("name", "turbolinks-permanent-placeholder")
+  element.setAttribute("content", permanentElement.id)
+  { element, permanentElement }
+
+replaceElementWithElement = (fromElement, toElement) ->
+  if parentElement = fromElement.parentNode
+    parentElement.replaceChild(toElement, fromElement)

data/test/dummy/node_modules/turbolinks/src/turbolinks/start.coffee

@@ -0,0 +1,18 @@
+Turbolinks.start = ->
+  if installTurbolinks()
+    Turbolinks.controller ?= createController()
+    Turbolinks.controller.start()
+
+installTurbolinks = ->
+  window.Turbolinks ?= Turbolinks
+  moduleIsInstalled()
+
+createController = ->
+  controller = new Turbolinks.Controller
+  controller.adapter = new Turbolinks.BrowserAdapter(controller)
+  controller
+
+moduleIsInstalled = ->
+  window.Turbolinks is Turbolinks
+
+Turbolinks.start() if moduleIsInstalled()

data/test/dummy/node_modules/turbolinks/src/turbolinks/view.coffee

@@ -0,0 +1,37 @@
+#= require ./snapshot
+#= require ./snapshot_renderer
+#= require ./error_renderer
+
+class Turbolinks.View
+  constructor: (@delegate) ->
+    @htmlElement = document.documentElement
+
+  getRootLocation: ->
+    @getSnapshot().getRootLocation()
+
+  getElementForAnchor: (anchor) ->
+    @getSnapshot().getElementForAnchor(anchor)
+
+  getSnapshot: ->
+    Turbolinks.Snapshot.fromHTMLElement(@htmlElement)
+
+  render: ({snapshot, error, isPreview}, callback) ->
+    @markAsPreview(isPreview)
+    if snapshot?
+      @renderSnapshot(snapshot, isPreview, callback)
+    else
+      @renderError(error, callback)
+
+  # Private
+
+  markAsPreview: (isPreview) ->
+    if isPreview
+      @htmlElement.setAttribute("data-turbolinks-preview", "")
+    else
+      @htmlElement.removeAttribute("data-turbolinks-preview")
+
+  renderSnapshot: (snapshot, isPreview, callback) ->
+    Turbolinks.SnapshotRenderer.render(@delegate, callback, @getSnapshot(), Turbolinks.Snapshot.wrap(snapshot), isPreview)
+
+  renderError: (error, callback) ->
+    Turbolinks.ErrorRenderer.render(@delegate, callback, error)