unpoly-rails 0.37.0 → 0.50.0

data/lib/assets/javascripts/unpoly/proxy.coffee

@@ -17,12 +17,12 @@ The cache holds up to 70 responses for 5 minutes. You can configure the cache si
 Also the entire cache is cleared with every non-`GET` request (like `POST` or `PUT`).
 
 If you need to make cache-aware requests from your [custom JavaScript](/up.syntax),
-use [`up.ajax()`](/up.ajax).
+use [`up.request()`](/up.request).
 
 \#\#\# Preloading links
 
 Unpoly also lets you speed up reaction times by [preloading
-links](/up-preload) when the user hovers over the click area (or puts the mouse/finger
+links](/a-up-preload) when the user hovers over the click area (or puts the mouse/finger
 down). This way the response will already be cached when
 the user releases the mouse/finger.
 
@@ -35,8 +35,8 @@ that appears during a long-running request.
 
 Other Unpoly modules contain even more tricks to outsmart network latency:
 
-- [Instantaneous feedback for links that are currently loading](/up-active)
-- [Follow links on `mousedown` instead of `click`](/up-instant)
+- [Instantaneous feedback for links that are currently loading](/a.up-active)
+- [Follow links on `mousedown` instead of `click`](/a-up-instant)
 
 @class up.proxy  
 ###
@@ -50,23 +50,23 @@ up.proxy = (($) ->
   pendingCount = undefined
   slowEventEmitted = undefined
 
-  queuedRequests = []
+  queuedLoaders = []
 
   ###*
   @property up.proxy.config
-  @param {Number} [config.preloadDelay=75]
-    The number of milliseconds to wait before [`[up-preload]`](/up-preload)
+  @param {number} [config.preloadDelay=75]
+    The number of milliseconds to wait before [`[up-preload]`](/a-up-preload)
     starts preloading.
-  @param {Number} [config.cacheSize=70]
+  @param {number} [config.cacheSize=70]
     The maximum number of responses to cache.
     If the size is exceeded, the oldest items will be dropped from the cache.
-  @param {Number} [config.cacheExpiry=300000]
+  @param {number} [config.cacheExpiry=300000]
     The number of milliseconds until a cache entry expires.
     Defaults to 5 minutes.
-  @param {Number} [config.slowDelay=300]
+  @param {number} [config.slowDelay=300]
     How long the proxy waits until emitting the [`up:proxy:slow` event](/up:proxy:slow).
     Use this to prevent flickering of spinners.
-  @param {Number} [config.maxRequests=4]
+  @param {number} [config.maxRequests=4]
     The maximum number of concurrent requests to allow before additional
     requests are queued. This currently ignores preloading requests.
 
@@ -75,14 +75,14 @@ up.proxy = (($) ->
 
     Note that your browser might [impose its own request limit](http://www.browserscope.org/?category=network)
     regardless of what you configure here.
-  @param {Array<String>} [config.wrapMethods]
+  @param {Array<string>} [config.wrapMethods]
     An array of uppercase HTTP method names. AJAX requests with one of these methods
     will be converted into a `POST` request and carry their original method as a `_method`
     parameter. This is to [prevent unexpected redirect behavior](https://makandracards.com/makandra/38347).
-  @param {Array<String>} [config.safeMethods]
-    An array of uppercase HTTP method names that are considered idempotent.
-    The proxy cache will only cache idempotent requests and will clear the entire
-    cache after a non-idempotent request.
+  @param {Array<string>} [config.safeMethods]
+    An array of uppercase HTTP method names that are considered [safe](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.1).
+    The proxy cache will only cache safe requests and will clear the entire
+    cache after an unsafe request.
   @stable
   ###
   config = u.config
@@ -94,19 +94,12 @@ up.proxy = (($) ->
     wrapMethods: ['PATCH', 'PUT', 'DELETE']
     safeMethods: ['GET', 'OPTIONS', 'HEAD']
 
-  cacheKey = (request) ->
-    normalizeRequest(request)
-    [ request.url,
-      request.method,
-      u.requestDataAsQuery(request.data),
-      request.target
-    ].join('|')
-
-  cache = u.cache
+  cache = new up.Cache
     size: -> config.cacheSize
     expiry: -> config.cacheExpiry
-    key: cacheKey
-    # log: 'up.proxy'
+    key: (request) -> up.Request.wrap(request).cacheKey()
+    cachable: (request) -> up.Request.wrap(request).isCachable()
+    # logPrefix: 'up.proxy'
 
   ###*
   Returns a cached response for the given request.
@@ -114,24 +107,30 @@ up.proxy = (($) ->
   Returns `undefined` if the given request is not currently cached.
 
   @function up.proxy.get
-  @return {Promise}
-    A promise for the response that is API-compatible with the
-    promise returned by [`jQuery.ajax`](http://api.jquery.com/jquery.ajax/).
+  @return {Promise<up.Response>}
+    A promise for the response.
   @experimental
   ###
   get = (request) ->
-    request = normalizeRequest(request)
-    if isCachable(request)
-      candidates = [request]
-      unless request.target is 'html'
-        requestForHtml = u.merge(request, target: 'html')
-        candidates.push(requestForHtml)
-        unless request.target is 'body'
-          requestForBody = u.merge(request, target: 'body')
-          candidates.push(requestForBody)
-      for candidate in candidates
-        if response = cache.get(candidate)
-          return response
+    request = up.Request.wrap(request)
+    candidates = [request]
+
+    if request.target != 'html'
+      # Since <html> is the root tag, a request for the `html` selector
+      # will contain all other selectors.
+      requestForHtml = request.copy(target: 'html')
+      candidates.push(requestForHtml)
+
+      # Although <body> is not the root tag, we consider it the selector developers
+      # will use when they want to replace the entire page. Hence we consider it
+      # a suitable match for all other selectors, including `html`.
+      if request.target != 'body'
+        requestForBody = request.copy(target: 'body')
+        candidates.push(requestForBody)
+
+    for candidate in candidates
+      if response = cache.get(candidate)
+        return response
 
   cancelPreloadDelay = ->
     clearTimeout(preloadDelayTimer)
@@ -149,108 +148,100 @@ up.proxy = (($) ->
     config.reset()
     cache.clear()
     slowEventEmitted = false
-    queuedRequests = []
+    queuedLoaders = []
 
   reset()
 
-  normalizeRequest = (request) ->
-    unless request._normalized
-      request.method = u.normalizeMethod(request.method)
-      request.url = u.normalizeUrl(request.url) if request.url
-      request.target ||= 'body'
-      request._normalized = true
-    request
-
   ###*
-  Makes a request to the given URL and caches the response.
-  If the response was already cached, returns the HTML instantly.
-  
-  If requesting a URL that is not read-only, the response will
-  not be cached and the entire cache will be cleared.
-  Only requests with a method of `GET`, `OPTIONS` and `HEAD`
-  are considered to be read-only.
+  Makes an AJAX request to the given URL.
 
   \#\#\# Example
 
-      up.ajax('/search', data: { query: 'sunshine' }).then(function(data, status, xhr) {
-        console.log('The response body is %o', data);
-      }).fail(function(xhr, status, error) {
+      up.request('/search', data: { query: 'sunshine' }).then(function(response) {
+        console.log('The response text is %o', response.text);
+      }).fail(function() {
         console.error('The request failed');
       });
 
+  \#\#\# Caching
+
+  All responses are cached by default. If requesting a URL with a non-`GET` method, the response will
+  not be cached and the entire cache will be cleared.
+
+  You can configure caching with the [`up.proxy.config`](/up.proxy.config) property.
+
   \#\#\# Events
 
   If a network connection is attempted, the proxy will emit
   a [`up:proxy:load`](/up:proxy:load) event with the `request` as its argument.
-  Once the response is received, a [`up:proxy:receive`](/up:proxy:receive) event will
+  Once the response is received, a [`up:proxy:loaded`](/up:proxy:loaded) event will
   be emitted.
   
-  @function up.ajax
-  @param {String} url
-  @param {String} [request.method='GET']
-  @param {String} [request.target='body']
-  @param {Boolean} [request.cache]
-    Whether to use a cached response, if available.
-    If set to `false` a network connection will always be attempted.
-  @param {Object} [request.headers={}]
-    An object of additional header key/value pairs to send along
-    with the request.
-  @param {Object} [request.data={}]
-    An object of request parameters.
-  @param {String} [request.url]
+  @function up.request
+  @param {string} [url]
+    The URL for the request.
+
+    Instead of passing the URL as a string argument, you can also pass it as an `{ url }` option.
+  @param {string} [options.url]
     You can omit the first string argument and pass the URL as
     a `request` property instead.
-  @param {String} [request.timeout]
-    A timeout in milliseconds for the request.
+  @param {string} [options.method='GET']
+    The HTTP method for the options.
+  @param {boolean} [options.cache]
+    Whether to use a cached response for [safe](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.1)
+    requests, if available. If set to `false` a network connection will always be attempted.
+  @param {Object} [options.headers={}]
+    An object of additional HTTP headers.
+  @param {Object|Array|FormData} [options.data={}]
+    Parameters that should be sent as the request's payload.
+
+    Parameters may be passed as one of the following forms:
+
+    1. An object where keys are param names and the values are param values
+    2. An array of `{ name: 'param-name', value: 'param-value' }` objects
+    3. A [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) object
+  @param {string} [options.timeout]
+    A timeout in milliseconds.
 
     If [`up.proxy.config.maxRequests`](/up.proxy.config#config.maxRequests) is set, the timeout
     will not include the time spent waiting in the queue.
-  @return
-    A promise for the response that is API-compatible with the
-    promise returned by [`jQuery.ajax`](http://api.jquery.com/jquery.ajax/).
+  @param {string} [options.target='body']
+    The CSS selector that will be sent as an [`X-Up-Target` header](/up.protocol#optimizing-responses).
+  @param {string} [options.failTarget='body']
+    The CSS selector that will be sent as an [`X-Up-Fail-Target` header](/up.protocol#optimizing-responses).
+  @return {Promise<up.Response>}
+    A promise for the response.
   @stable
   ###
-  ajax = (args...) ->
-
+  makeRequest = (args...) ->
     options = u.extractOptions(args)
     options.url = args[0] if u.isGiven(args[0])
 
-    forceCache = (options.cache == true)
     ignoreCache = (options.cache == false)
 
-    request = u.only options,
-      'url',
-      'method',
-      'data',
-      'target',
-      'headers',
-      'timeout',
-      '_normalized'
-
-    request = normalizeRequest(request)
-
-    pending = true
+    request = up.Request.wrap(options)
 
     # Non-GET requests always touch the network
     # unless `options.cache` is explicitly set to `true`.
     # These requests are never cached.
-    if !isIdempotent(request) && !forceCache
+    if !request.isSafe()
+      # We clear the entire cache before an unsafe request, since we
+      # assume the user is writing a change.
       clear()
-      promise = loadOrQueue(request)
+
     # If we have an existing promise matching this new request,
     # we use it unless `options.cache` is explicitly set to `false`.
-    # The promise might still be pending.
-    else if (promise = get(request)) && !ignoreCache
+    if !ignoreCache && (promise = get(request))
       up.puts 'Re-using cached response for %s %s', request.method, request.url
-      pending = (promise.state() == 'pending')
-    # If no existing promise is available, we make a network request.
     else
+      # If no existing promise is available, we make a network request.
       promise = loadOrQueue(request)
       set(request, promise)
-      # Don't cache failed requests
-      promise.fail -> remove(request)
+      # Uncache failed requests
+      promise.catch (e) ->
+        remove(request)
 
-    if pending && !options.preload
+    if !options.preload
       # This might actually make `pendingCount` higher than the actual
       # number of outstanding requests. However, we need to cover the
       # following case:
@@ -262,27 +253,69 @@ up.proxy = (($) ->
       # - The request finishes.
       #   This triggers `up:proxy:recover`.
       loadStarted()
-      promise.always(loadEnded)
+      u.always promise, loadEnded
 
     promise
 
   ###*
-  Returns whether the proxy is capable of caching the given request.
-  Even if this returns `true`, only idempodent requests will be
-  cached by default.
+  Makes an AJAX request to the given URL and caches the response.
 
-  @function up.proxy.isCachable
-  @internal
+  The function returns a promise that fulfills with the response text.
+
+  \#\#\# Example
+
+      up.request('/search', data: { query: 'sunshine' }).then(function(text) {
+        console.log('The response text is %o', text);
+      }).fail(function() {
+        console.error('The request failed');
+      });
+
+  @function up.ajax
+  @param {string} [url]
+    The URL for the request.
+
+    Instead of passing the URL as a string argument, you can also pass it as an `{ url }` option.
+  @param {string} [request.url]
+    You can omit the first string argument and pass the URL as
+    a `request` property instead.
+  @param {string} [request.method='GET']
+    The HTTP method for the request.
+  @param {boolean} [request.cache]
+    Whether to use a cached response for [safe](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.1)
+    requests, if available. If set to `false` a network connection will always be attempted.
+  @param {Object} [request.headers={}]
+    An object of additional header key/value pairs to send along
+    with the request.
+  @param {Object|Array|FormData} [options.data]
+    Parameters that should be sent as the request's payload.
+
+    Parameters may be passed as one of the following forms:
+
+    1. An object where keys are param names and the values are param values
+    2. An array of `{ name: 'param-name', value: 'param-value' }` objects
+    3. A [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData) object
+  @param {string} [request.timeout]
+    A timeout in milliseconds for the request.
+
+    If [`up.proxy.config.maxRequests`](/up.proxy.config#config.maxRequests) is set, the timeout
+    will not include the time spent waiting in the queue.
+  @return {Promise<string>}
+    A promise for the response text.
+  @deprecated
+    Use [`up.request()`](/up.request) instead.
   ###
-  isCachable = (request) ->
-    not u.isFormData(request.data)
+  ajax = (args...) ->
+    up.log.warn('up.ajax() has been deprecated. Use up.request() instead.')
+    new Promise (resolve, reject) ->
+      pickResponseText = (response) -> resolve(response.text)
+      makeRequest(args...).then(pickResponseText, reject)
 
   ###*
   Returns `true` if the proxy is not currently waiting
   for a request to finish. Returns `false` otherwise.
 
   @function up.proxy.isIdle
-  @return {Boolean}
+  @return {boolean}
     Whether the proxy is idle
   @experimental
   ###
@@ -294,7 +327,7 @@ up.proxy = (($) ->
   for a request to finish. Returns `false` otherwise.
 
   @function up.proxy.isBusy
-  @return {Boolean}
+  @return {boolean}
     Whether the proxy is busy
   @experimental
   ###
@@ -302,19 +335,19 @@ up.proxy = (($) ->
     pendingCount > 0
 
   loadStarted = ->
-    wasIdle = isIdle()
     pendingCount += 1
-    if wasIdle
+    unless slowDelayTimer
       # Since the emission of up:proxy:slow might be delayed by config.slowDelay,
       # we wrap the mission in a function for scheduling below.
       emission = ->
         if isBusy() # a fast response might have beaten the delay
-          up.emit('up:proxy:slow', message: 'Proxy is busy')
+          up.emit('up:proxy:slow', message: 'Proxy is slow to respond')
           slowEventEmitted = true
       slowDelayTimer = u.setTimer(config.slowDelay, emission)
 
+
   ###*
-  This event is [emitted](/up.emit) when [AJAX requests](/up.ajax)
+  This event is [emitted](/up.emit) when [AJAX requests](/up.request)
   are taking long to finish.
 
   By default Unpoly will wait 300 ms for an AJAX request to finish
@@ -367,12 +400,15 @@ up.proxy = (($) ->
 
   loadEnded = ->
     pendingCount -= 1
-    if isIdle() && slowEventEmitted
-      up.emit('up:proxy:recover', message: 'Proxy is idle')
-      slowEventEmitted = false
+
+    if isIdle()
+      cancelSlowDelay()
+      if slowEventEmitted
+        up.emit('up:proxy:recover', message: 'Proxy has recovered from slow response')
+        slowEventEmitted = false
 
   ###*
-  This event is [emitted](/up.emit) when [AJAX requests](/up.ajax)
+  This event is [emitted](/up.emit) when [AJAX requests](/up.request)
   have [taken long to finish](/up:proxy:slow), but have finished now.
 
   See [`up:proxy:slow`](/up:proxy:slow) for more documentation on
@@ -391,49 +427,88 @@ up.proxy = (($) ->
 
   queue = (request) ->
     up.puts('Queuing request for %s %s', request.method, request.url)
-    deferred = $.Deferred()
-    entry =
-      deferred: deferred
-      request: request
-    queuedRequests.push(entry)
-    deferred.promise()
+    loader = -> load(request)
+    loader = u.previewable(loader)
+    queuedLoaders.push(loader)
+    loader.promise
 
   load = (request) ->
-    up.emit('up:proxy:load', u.merge(request, message: ['Loading %s %s', request.method, request.url]))
+    eventProps =
+      request: request
+      message: ['Loading %s %s', request.method, request.url]
 
-    # We will modify the request below for features like method wrapping.
-    # Let's not change the original request which would confuse API clients
-    # and cache key logic.
-    request = u.copy(request)
+    if up.bus.nobodyPrevents('up:proxy:load', eventProps)
+      responsePromise = request.send()
+      u.always responsePromise, responseReceived
+      u.always responsePromise, pokeQueue
+      responsePromise
+    else
+      u.microtask(pokeQueue)
+      Promise.reject(new Error('Event up:proxy:load was prevented'))
 
-    request.headers ||= {}
-    request.headers[up.protocol.config.targetHeader] = request.target
+  ###*
+  This event is [emitted](/up.emit) before an [AJAX request](/up.request)
+  is sent over the network.
 
-    if u.contains(config.wrapMethods, request.method)
-      request.data = u.appendRequestData(request.data, up.protocol.config.methodParam, request.method)
-      request.method = 'POST'
+  @event up:proxy:load
+  @param {up.Request} event.request
+  @param event.preventDefault()
+    Event listeners may call this method to prevent the request from being sent.
+  @experimental
+  ###
 
-    if u.isFormData(request.data)
-      # Disable jQuery's request data processing so we can pass
-      # a FormData object (http://stackoverflow.com/a/5976031)
-      request.contentType = false
-      request.processData = false
+  registerAliasForRedirect = (response) ->
+    request = response.request
+    if request.url != response.url
+      newRequest = request.copy(
+        method: response.method
+        url: response.url
+      )
+      up.proxy.alias(request, newRequest)
+
+  responseReceived = (response) ->
+    if response.isFatalError()
+      up.emit 'up:proxy:fatal',
+        message: 'Fatal error during request'
+        request: response.request
+        response: response
+    else
+      registerAliasForRedirect(response) unless response.isError()
+      up.emit 'up:proxy:loaded',
+        message: ['Server responded with HTTP %d (%d bytes)', response.status, response.text.length]
+        request: response.request
+        response: response
 
-    promise = $.ajax(request)
-    promise.done (data, textStatus, xhr) -> responseReceived(request, xhr)
-    promise.fail (xhr, textStatus, errorThrown) -> responseReceived(request, xhr)
-    promise
+  ###*
+  This event is [emitted](/up.emit) when the response to an
+  [AJAX request](/up.request) has been received.
+
+  Note that this event will also be emitted when the server signals an
+  error with an HTTP status like `500`. Only if the request
+  encounters a fatal error (like a loss of network connectivity),
+  [`up:proxy:fatal`](/up:proxy:fatal) is emitted instead.
+
+  @event up:proxy:loaded
+  @param {up.Request} event.request
+  @param {up.Response} event.response
+  @experimental
+  ###
 
-  responseReceived = (request, xhr) ->
-    up.emit('up:proxy:received', u.merge(request, message: ['Server responded with %s %s (%d bytes)', xhr.status, xhr.statusText, xhr.responseText?.length]))
-    pokeQueue()
+  ###*
+  This event is [emitted](/up.emit) when an [AJAX request](/up.request)
+  encounters fatal error like a timeout or loss of network connectivity.
+
+  Note that this event will *not* be emitted when the server produces an
+  error message with an HTTP status like `500`. When the server can produce
+  any response, [`up:proxy:loaded`](/up:proxy:loaded) is emitted instead.
+
+  @event up:proxy:fatal
+  ###
 
   pokeQueue = ->
-    if entry = queuedRequests.shift()
-      promise = load(entry.request)
-      promise.done (args...) -> entry.deferred.resolve(args...)
-      promise.fail (args...) -> entry.deferred.reject(args...)
-      return
+    queuedLoaders.shift()?()
+    # Don't return the promise from the loader above
+    return undefined
 
   ###*
   Makes the proxy assume that `newRequest` has the same response as the
@@ -453,12 +528,11 @@ up.proxy = (($) ->
   Manually stores a promise for the response to the given request.
 
   @function up.proxy.set
-  @param {String} request.url
-  @param {String} [request.method='GET']
-  @param {String} [request.target='body']
-  @param {Promise} response
-    A promise for the response that is API-compatible with the
-    promise returned by [`jQuery.ajax`](http://api.jquery.com/jquery.ajax/).
+  @param {string} request.url
+  @param {string} [request.method='GET']
+  @param {string} [request.target='body']
+  @param {Promise<up.Response>} response
+    A promise for the response.
   @experimental
   ###
   set = cache.set
@@ -470,9 +544,9 @@ up.proxy = (($) ->
   automatically removes cache entries.
 
   @function up.proxy.remove
-  @param {String} request.url
-  @param {String} [request.method='GET']
-  @param {String} [request.target='body']
+  @param {string} request.url
+  @param {string} [request.method='GET']
+  @param {string} [request.target='body']
   @experimental
   ###
   remove = cache.remove
@@ -481,41 +555,18 @@ up.proxy = (($) ->
   Removes all cache entries.
 
   Unpoly also automatically clears the cache whenever it processes
-  a request with a non-GET HTTP method.
+  a request with an [unsafe](https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.1.1)
+  HTTP method like `POST`.
 
   @function up.proxy.clear
   @stable
   ###
   clear = cache.clear
 
-  ###*
-  This event is [emitted](/up.emit) before an [AJAX request](/up.ajax)
-  is starting to load.
-
-  @event up:proxy:load
-  @param event.url
-  @param event.method
-  @param event.target
-  @experimental
-  ###
-
-  ###*
-  This event is [emitted](/up.emit) when the response to an [AJAX request](/up.ajax)
-  has been received.
-
-  @event up:proxy:received
-  @param event.url
-  @param event.method
-  @param event.target
-  @experimental
-  ###
-
-  isIdempotent = (request) ->
-    normalizeRequest(request)
-    u.contains(config.safeMethods, request.method)
+  up.bus.renamedEvent('up:proxy:received', 'up:proxy:loaded')
 
   checkPreload = ($link) ->
-    delay = parseInt(u.presentAttr($link, 'up-delay')) || config.preloadDelay 
+    delay = parseInt(u.presentAttr($link, 'up-delay')) || config.preloadDelay
     unless $link.is($waitingLink)
       $waitingLink = $link
       cancelPreloadDelay()
@@ -528,60 +579,80 @@ up.proxy = (($) ->
     preloadDelayTimer = setTimeout(block, delay)
 
   ###*
+  Preloads the given link.
+
+  When the link is clicked later, the response will already be cached,
+  making the interaction feel instant.
+
   @function up.proxy.preload
-  @param {String|Element|jQuery}
+  @param {string|Element|jQuery}
     The element whose destination should be preloaded.
   @return
-    A promise that will be resolved when the request was loaded and cached
+    A promise that will be fulfilled when the request was loaded and cached
   @experimental
   ###
-  preload = (linkOrSelector, options) ->
+  preload = (linkOrSelector) ->
     $link = $(linkOrSelector)
-    options = u.options(options)
 
-    method = up.link.followMethod($link, options)
-    if isIdempotent(method: method)
-      up.log.group "Preloading link %o", $link, ->
-        options.preload = true
-        up.follow($link, options)
+    if up.link.isSafe($link)
+      up.log.group "Preloading link %o", $link.get(0), ->
+        variant = up.link.followVariantForLink($link)
+        variant.preloadLink($link)
     else
-      up.puts("Won't preload %o due to unsafe method %s", $link, method)
-      u.resolvedPromise()
+      Promise.reject(new Error("Won't preload unsafe link"))
+
+  ###*
+  @internal
+  ###
+  isSafeMethod = (method) ->
+    u.contains(config.safeMethods, method)
+
+  ###*
+  @internal
+  ###
+  wrapMethod = (method, data, appendOpts) ->
+    if u.contains(config.wrapMethods, method)
+      data = u.appendRequestData(data, up.protocol.config.methodParam, method, appendOpts)
+      method = 'POST'
+    [method, data]
 
   ###*
   Links with an `up-preload` attribute will silently fetch their target
   when the user hovers over the click area, or when the user puts her
-  mouse/finger down (before releasing). This way the
-  response will already be cached when the user performs the click,
+  mouse/finger down (before releasing).
+
+  When the link is clicked later, the response will already be cached,
   making the interaction feel instant.   
 
-  @selector [up-preload]
+  @selector a[up-preload]
   @param [up-delay=75]
     The number of milliseconds to wait between hovering
     and preloading. Increasing this will lower the load in your server,
     but will also make the interaction feel less instant.
   @stable
   ###
-  up.on 'mouseover mousedown touchstart', '[up-preload]', (event, $element) ->
-    # Don't do anything if we are hovering over the child
-    # of a link. The actual link will receive the event
-    # and bubble in a second.
-    unless up.link.childClicked(event, $element)
+  up.on 'mouseover mousedown touchstart', 'a[up-preload], [up-href][up-preload]', (event, $element) ->
+    # Don't do anything if we are hovering over the child of a link.
+    # The actual link will receive the event and bubble in a second.
+    if !up.link.childClicked(event, $element) && up.link.isSafe($element)
       checkPreload($element)
 
   up.on 'up:framework:reset', reset
 
   preload: preload
   ajax: ajax
+  request: makeRequest
   get: get
   alias: alias
   clear: clear
   remove: remove
   isIdle: isIdle
   isBusy: isBusy
-  isCachable: isCachable
+  isSafeMethod: isSafeMethod
+  wrapMethod: wrapMethod
   config: config
   
 )(jQuery)
 
 up.ajax = up.proxy.ajax
+up.request = up.proxy.request