unpoly-rails 0.57.0 → 0.60.0

data/lib/assets/javascripts/unpoly/classes/record.coffee

@@ -8,9 +8,15 @@ class up.Record
   constructor: (options) ->
     u.assign(this, @attributes(options))
 
-  attributes: (source = @) =>
+  attributes: (source = @) ->
     u.only(source, @fields()...)
 
-  copy: (changes = {}) =>
+  "#{u.copy.key}": ->
+    @variant()
+
+  variant: (changes = {}) ->
     attributesWithChanges = u.merge(@attributes(), changes)
     new @constructor(attributesWithChanges)
+
+  "#{u.isEqual.key}": (other) ->
+    other && (@constructor == other.constructor) && u.isEqual(@attributes(), other.attributes())

data/lib/assets/javascripts/unpoly/classes/rect.js

@@ -0,0 +1,21 @@
+(function() {
+  var u = up.util
+
+  up.Rect = function(props) {
+    u.assign(this, u.only(props, 'left', 'top', 'width', 'height'))
+  }
+
+  up.Rect.prototype = {
+    get bottom() {
+      return this.top + this.height
+    },
+    get right() {
+      return this.left + this.width
+    }
+  }
+
+  up.Rect.fromElement = function(element) {
+    return new up.Rect(element.getBoundingClientRect())
+  }
+
+})()

data/lib/assets/javascripts/unpoly/classes/request.coffee

@@ -1,6 +1,7 @@
 #= require ./record
 
 u = up.util
+e = up.element
 
 ###**
 Instances of `up.Request` normalizes properties of an [`AJAX request`](/up.request)
@@ -27,10 +28,10 @@ class up.Request extends up.Record
   ###
 
   ###**
-  [Parameters](/up.params) that should be sent as the request's payload.
+  [Parameters](/up.Params) that should be sent as the request's payload.
 
   @property up.Request#params
-  @param {object|FormData|string|Array} params
+  @param {Object|FormData|string|Array} params
   @stable
   ###
 
@@ -54,7 +55,7 @@ class up.Request extends up.Record
   An object of additional HTTP headers.
 
   @property up.Request#headers
-  @param {object} headers
+  @param {Object} headers
   @stable
   ###
 
@@ -65,7 +66,7 @@ class up.Request extends up.Record
   the timeout will not include the time spent waiting in the queue.
 
   @property up.Request#timeout
-  @param {object|undefined} timeout
+  @param {Object|undefined} timeout
   @stable
   ###
   fields: ->
@@ -73,7 +74,6 @@ class up.Request extends up.Record
       'method',
       'url',
       'params',
-      'data', # deprecated. use #params.
       'target',
       'failTarget',
       'headers',
@@ -83,15 +83,27 @@ class up.Request extends up.Record
     ]
 
   ###**
+  Creates a new `up.Request` object.
+
+  This will not actually send the request over the network. For that use `up.request()`.
+
   @constructor up.Request
-  @param {string} [attributes]
+  @param {string} attrs.url
+  @param {string} [attrs.method='get']
+  @param {up.Params|string|Object|Array} [attrs.params]
+  @param {string} [attrs.target]
+  @param {string} [attrs.failTarget]
+  @param {Object<string, string>} [attrs.headers]
+  @param {number} [attrs.timeout]
+  @internal
   ###
   constructor: (options) ->
+    up.legacy.fixKey(options, 'data', 'params')
     super(options)
     @normalize()
 
   normalize: =>
-    u.deprecateRenamedKey(@, 'data', 'params')
+    @params = new up.Params(@params) # copies, which we want
     @method = u.normalizeMethod(@method)
     @headers ||= {}
     @extractHashFromUrl()
@@ -109,15 +121,16 @@ class up.Request extends up.Record
     @url = u.normalizeUrl(urlParts, hash: false)
 
   transferParamsToUrl: =>
-    if @params && !u.isFormData(@params)
+    unless u.isBlank(@params)
       # GET methods are not allowed to have a payload, so we transfer { params } params to the URL.
-      @url = up.params.buildURL(@url, @params)
+      @url = @params.toURL(@url)
       # Now that we have transfered the params into the URL, we delete them from the { params } option.
-      @params = undefined
+      @params.clear()
 
   transferSearchToParams: =>
-    if query = up.params.fromURL(@url)
-      @params = up.params.merge(@params, query)
+    paramsFromQuery = up.Params.fromURL(@url)
+    unless u.isBlank(paramsFromQuery)
+      @params.addAll(paramsFromQuery)
       @url = u.normalizeUrl(@url, search: false)
 
   isSafe: =>
@@ -130,18 +143,14 @@ class up.Request extends up.Record
       xhr = new XMLHttpRequest()
 
       xhrHeaders = u.copy(@headers)
-      xhrPayload = @params
-      xhrMethod = @method
       xhrUrl = @url
+      xhrParams = u.copy(@params)
+      xhrMethod = up.proxy.wrapMethod(@method, xhrParams)
 
-      [xhrMethod, xhrPayload] = up.proxy.wrapMethod(xhrMethod, xhrPayload)
-
-      if xhrPayload
+      xhrPayload = null
+      unless u.isBlank(xhrParams)
         delete xhrHeaders['Content-Type'] # let the browser set the content type
-        xhrPayload = up.params.toFormData(xhrPayload)
-      else
-        # XMLHttpRequest expects null for an empty body
-        xhrPayload = null
+        xhrPayload = xhrParams.toFormData()
 
       pc = up.protocol.config
       xhrHeaders[pc.targetHeader] = @target if @target
@@ -176,9 +185,10 @@ class up.Request extends up.Record
     # The query section would be overridden by the serialized input values on submission.
     @transferSearchToParams()
 
-    $form = $('<form class="up-page-loader"></form>')
+    form = e.affix(document.body, 'form.up-page-loader')
 
-    addField = (field) -> $('<input type="hidden">').attr(field).appendTo($form)
+    addField = (attrs) ->
+      e.affix(form, 'input[type=hidden]', attrs)
 
     if @method == 'GET'
       formMethod = 'GET'
@@ -189,17 +199,18 @@ class up.Request extends up.Record
       addField(name: up.protocol.config.methodParam, value: @method)
       formMethod = 'POST'
 
-    $form.attr(method: formMethod, action: @url)
+    e.setAttrs(form, method: formMethod, action: @url)
 
     if (csrfParam = up.protocol.csrfParam()) && (csrfToken = @csrfToken())
       addField(name: csrfParam, value: csrfToken)
 
     # @params will be undefined for GET requests, since we have already
     # transfered all params to the URL during normalize().
-    u.each(up.params.toArray(@params), addField)
+    u.each(@params.toArray(), addField)
 
-    $form.hide().appendTo('body')
-    up.browser.submitForm($form)
+    e.hide(form)
+
+    up.browser.submitForm(form)
 
   # Returns a csrfToken if this request requires it
   csrfToken: =>
@@ -231,12 +242,7 @@ class up.Request extends up.Record
     @isSafe() && !u.isFormData(@params)
 
   cacheKey: =>
-    query = up.params.toQuery(@params)
-    [@url, @method, query, @target].join('|')
+    [@url, @method, @params.toQuery(), @target].join('|')
 
-  @wrap: (object) ->
-    if object instanceof @
-      # This object has gone through instantiation and normalization before.
-      object
-    else
-      new @(object)
+  @wrap: (value) ->
+    u.wrapValue(value, @)

data/lib/assets/javascripts/unpoly/classes/response.coffee

@@ -8,9 +8,9 @@ Instances of `up.Response` describe the server response to an [`AJAX request`](/
 \#\#\# Example
 
     up.request('/foo').then(function(response) {
-      console.log(response.status); // 200
-      console.log(response.text);   // "<html><body>..."
-    });
+      console.log(response.status) // 200
+      console.log(response.text)   // "<html><body>..."
+    })
 
 @class up.Response
 ###
@@ -97,6 +97,10 @@ class up.Response extends up.Record
       'title',
     ]
 
+  ###**
+  @constructor up.Response
+  @internal
+  ###
   constructor: (options) ->
     super(options)
 

data/lib/assets/javascripts/unpoly/classes/reveal_motion.coffee

@@ -0,0 +1,102 @@
+e = up.element
+
+class up.RevealMotion
+
+  constructor: (@element, options = {}) ->
+    layoutConfig = up.viewport.config
+    @viewport = options.viewport ? up.viewport.closest(@element)
+    up.legacy.fixKey(layoutConfig, 'snap', 'revealSnap')
+    snapDefault = layoutConfig.revealSnap
+    @snap = options.snap ? options.revealSnap ? snapDefault
+    if @snap == false
+      @snap = 0
+    else if @snap == true
+      @snap = snapDefault
+    @padding = options.padding ? options.revealPadding ? layoutConfig.revealPadding
+    @top = options.top
+    @fixedTop = options.fixedTop ? layoutConfig.fixedTop
+    @fixedBottom = options.fixedBottom ? layoutConfig.fixedBottom
+
+    # Options for up.ScrollMotion
+    @speed = options.speed ? options.scrollSpeed ? layoutConfig.scrollSpeed
+    @behavior = options.behavior ? options.scrollBehavior
+
+  start: ->
+    elementRect = up.Rect.fromElement(@element)
+    viewportRect = @getViewportRect(@viewport)
+
+    @addPadding(elementRect)
+    @substractObstructions(viewportRect)
+
+    if viewportRect.height <= 0
+      return Promise.reject(new Error('Viewport has no visible area'))
+
+    originalScrollTop = @viewport.scrollTop
+    newScrollTop = originalScrollTop
+
+    if @top || elementRect.height > viewportRect.height
+      # Element is either larger than the viewport,
+      # or the user has explicitely requested for the element to align at top
+      # => Scroll the viewport so the first element row is the first viewport row
+      diff = elementRect.top - viewportRect.top
+      newScrollTop += diff
+    else if elementRect.top < viewportRect.top
+      # Element fits within viewport, but sits too high
+      # => Scroll up (reduce scrollY), so the element comes down
+      newScrollTop -= (viewportRect.top - elementRect.top)
+    else if elementRect.bottom > viewportRect.bottom
+      # Element fits within viewport, but sits too low
+      # => Scroll down (increase scrollY), so the element comes up
+      newScrollTop += (elementRect.bottom - viewportRect.bottom)
+    else
+      # Element is fully visible within viewport
+      # => Do nothing
+
+    if newScrollTop < @snap && elementRect.top < (0.5 * viewportRect.height)
+      newScrollTop = 0
+
+    if newScrollTop != originalScrollTop
+      @scrollTo(newScrollTop)
+    else
+      Promise.resolve()
+
+  scrollTo: (newScrollTop) ->
+    scrollOptions =
+      speed: @speed
+      behavior: @behavior
+    @scrollMotion = new up.ScrollMotion(@viewport, newScrollTop, scrollOptions)
+    @scrollMotion.start()
+
+  getViewportRect: ->
+    if up.viewport.isRoot(@viewport)
+      # Other than an element with overflow-y, the document viewport
+      # stretches to the full height of its contents. So we create a viewport
+      # sized to the usuable screen area.
+      new up.Rect
+        left: 0
+        top: 0
+        width: up.viewport.rootWidth()
+        height: up.viewport.rootHeight()
+    else
+      up.Rect.fromElement(@viewport)
+
+  addPadding: (elementRect) ->
+    elementRect.top -= @padding
+    elementRect.height += 2 * @padding
+
+  substractObstructions: (viewportRect) ->
+    for obstruction in e.list(@fixedTop...)
+      obstructionRect = up.Rect.fromElement(obstruction)
+      diff = obstructionRect.bottom - viewportRect.top
+      if diff > 0
+        viewportRect.top += diff
+        viewportRect.height -= diff
+
+    for obstruction in e.list(@fixedBottom...)
+      obstructionRect = up.Rect.fromElement(obstruction)
+      diff = viewportRect.bottom - obstructionRect.top
+      if diff > 0
+        viewportRect.height -= diff
+
+  finish: ->
+    @scrollMotion?.finish()

data/lib/assets/javascripts/unpoly/classes/scroll_motion.coffee

@@ -0,0 +1,67 @@
+u = up.util
+
+class up.ScrollMotion
+
+  # We want to make the default speed mimic Chrome's smooth scrolling behavior.
+  # We also want to keep the default  valuein up.viewport.config.scrollSpeed to be 1.
+  # For our calculation in #animationFrame() we need to multiply it with this factor.
+  SPEED_CALIBRATION = 0.065
+
+  constructor: (@scrollable, @targetTop, options = {}) ->
+    # The option for up.scroll() is { behavior }, but coming
+    # from up.replace() it's { scrollBehavior }.
+    @behavior = options.behavior ? options.scrollBehavior ? 'instant'
+
+    # The option for up.scroll() is { behavior }, but coming
+    # from up.replace() it's { scrollSpeed }.
+    @speed = (options.speed ? options.scrollSpeed ? up.viewport.config.scrollSpeed) * SPEED_CALIBRATION
+
+  start: =>
+    return new Promise (@resolve, @reject) =>
+      if @behavior == 'smooth' && up.motion.isEnabled()
+        @startAnimation()
+      else
+        @finish()
+
+  startAnimation: ->
+    @startTime = Date.now()
+    @startTop = @scrollable.scrollTop
+    @topDiff = @targetTop - @startTop
+    # We're applying a square root to become slower for small distances
+    # and faster for large distances.
+    @duration = Math.sqrt(Math.abs(@topDiff)) / @speed
+    requestAnimationFrame(@animationFrame)
+
+  animationFrame: =>
+    return if @settled
+
+    # When the scroll position is not the one we previously set, we assume
+    # that the user has tried scrolling on her own. We then cancel the scrolling animation.
+    if @frameTop && Math.abs(@frameTop - @scrollable.scrollTop) > 1.5
+      @cancel('Animation aborted due to user intervention')
+
+    currentTime = Date.now()
+    timeElapsed = currentTime - @startTime
+    timeFraction = Math.min(timeElapsed / @duration, 1)
+
+    @frameTop = @startTop + (u.simpleEase(timeFraction) * @topDiff)
+
+    # When we're very close to the target top, finish the animation
+    # directly to deal with rounding errors.
+    if Math.abs(@targetTop - @frameTop) < 0.3
+      @finish()
+    else
+      @scrollable.scrollTop = @frameTop
+      requestAnimationFrame(@animationFrame)
+
+  cancel: (reason) =>
+    @settled = true
+    @reject(new Error(reason))
+
+  finish: =>
+    # In case we're animating with emulation, cancel the next scheduled frame
+    @settled = true
+    # Setting the { scrollTop } prop will also finish a native scrolling
+    # animation in Firefox and Chrome.
+    @scrollable.scrollTop = @targetTop
+    @resolve()

data/lib/assets/javascripts/unpoly/classes/selector.coffee

@@ -0,0 +1,60 @@
+u = up.util
+
+class up.Selector
+
+  CSS_HAS_SUFFIX_PATTERN = new RegExp("\\:has\\(([^\\)]+)\\)$")
+  MATCH_FN_NAME = if up.browser.isIE11() then 'msMatchesSelector' else 'matches'
+
+  constructor: (@selector, @filterFn) ->
+
+  matches: (element) ->
+    doesMatch = element[MATCH_FN_NAME](@selector)
+    doesMatch &&= @filterFn(element) if @filterFn
+    doesMatch
+
+  descendants: (root) ->
+    matches = root.querySelectorAll(@selector)
+    if @filterFn
+      matches = u.filter(matches, @filterFn)
+    matches
+
+  descendant: (root) ->
+    if !@filterFn
+     root.querySelector(@selector)
+    else
+      candidates = root.querySelectorAll(@selector)
+      u.find(candidates, @filterFn)
+
+  subtree: (root) ->
+    matches = []
+    if @matches(root)
+      matches.push(root)
+    matches.push(@descendants(root)...)
+    matches
+
+  closest: (root) ->
+    if root.closest && !@filterFn
+      return root.closest(@selector)
+    else
+      return @closestPolyfill(root)
+
+  closestPolyfill: (root) ->
+    if @matches(root, @selector)
+      root
+    else
+      @ancestor(root)
+
+  ancestor: (element) ->
+    if parentElement = element.parentElement
+      if @matches(parentElement)
+        parentElement
+      else
+        @ancestor(parentElement)
+
+  @parse: (selector) ->
+    filter = null
+    selector = selector.replace CSS_HAS_SUFFIX_PATTERN, (match, descendantSelector) ->
+      filter = (element) ->
+        element.querySelector(descendantSelector)
+      return ''
+    new @(selector, filter)