unpoly-rails 0.56.7 → 0.57.0

data/spec_app/spec/javascripts/up/form_spec.js.coffee

@@ -40,33 +40,33 @@ describe 'up.form', ->
             it 'debounces the callback when the { delay } option is given', asyncSpec (next) ->
               $input = affix('input[value="old-value"]')
               callback = jasmine.createSpy('change callback')
-              up.observe($input, { delay: 100 }, callback)
+              up.observe($input, { delay: 200 }, callback)
               $input.val('new-value-1')
               $input.trigger(eventName)
 
-              next.after 50, ->
-                # 50 ms after change 1: We're still waiting for the 100ms delay to expire
+              next.after 100, ->
+                # 100 ms after change 1: We're still waiting for the 200ms delay to expire
                 expect(callback.calls.count()).toEqual(0)
 
-              next.after 100, ->
-                # 150 ms after change 1: The 100ms delay has expired
+              next.after 200, ->
+                # 300 ms after change 1: The 200ms delay has expired
                 expect(callback.calls.count()).toEqual(1)
                 expect(callback.calls.mostRecent().args[0]).toEqual('new-value-1')
                 $input.val('new-value-2')
                 $input.trigger(eventName)
 
-              next.after 40, ->
-                # 40 ms after change 2: We change again, resetting the delay
+              next.after 80, ->
+                # 80 ms after change 2: We change again, resetting the delay
                 expect(callback.calls.count()).toEqual(1)
                 $input.val('new-value-3')
                 $input.trigger(eventName)
 
-              next.after 85, ->
-                # 125 ms after change 2, which was superseded by change 3
-                # 85 ms after change 3
+              next.after 170, ->
+                # 250 ms after change 2, which was superseded by change 3
+                # 170 ms after change 3
                 expect(callback.calls.count()).toEqual(1)
 
-              next.after 65, ->
+              next.after 130, ->
                 # 190 ms after change 2, which was superseded by change 3
                 # 150 ms after change 3
                 expect(callback.calls.count()).toEqual(2)
@@ -561,8 +561,8 @@ describe 'up.form', ->
           it 'transfers the form fields via FormData', asyncSpec (next) ->
             up.submit(@$form)
             next =>
-              data = @lastRequest().data()
-              expect(u.isFormData(data)).toBe(true)
+              rawData = @lastRequest().params
+              expect(u.isFormData(rawData)).toBe(true)
 
       describeFallback 'canPushState', ->
 

data/spec_app/spec/javascripts/up/layout_spec.js.coffee

@@ -17,17 +17,27 @@ describe 'up.layout', ->
 
           @$elements = []
           @$container = $('<div class="container">').prependTo($body)
+          @$container.css(opacity: 0.2) # reduce flashing during test runs
 
           @clientHeight = u.clientSize().height
 
-          for height in [@clientHeight, '50px', '5000px']
-            $element = $('<div>').css(height: height)
+          elementPlans = [
+            { height: @clientHeight, backgroundColor: 'yellow' }, # [0]
+            { height: '50px',        backgroundColor: 'cyan'   }, # [1]
+            { height: '5000px',      backgroundColor: 'orange' }  # [2]
+          ]
+
+          for elementPlan in elementPlans
+            $element = $('<div>').css(elementPlan)
             $element.appendTo(@$container)
             @$elements.push($element)
 
         afterEach ->
           @$container.remove()
 
+        $documentViewport = ->
+          $(up.browser.documentViewportSelector())
+
         it 'reveals the given element', asyncSpec (next) ->
           up.reveal(@$elements[0])
 
@@ -37,7 +47,7 @@ describe 'up.layout', ->
             # ---------------------
             # [1] ch+0 ...... ch+49
             # [2] ch+50 ... ch+5049
-            expect($(document).scrollTop()).toBe(0)
+            expect($documentViewport().scrollTop()).toBe(0)
 
             up.reveal(@$elements[1])
 
@@ -47,7 +57,7 @@ describe 'up.layout', ->
             # [1] ch+0 ...... ch+49
             # ---------------------
             # [2] ch+50 ... ch+5049
-            expect($(document).scrollTop()).toBe(50)
+            expect($documentViewport().scrollTop()).toBe(50)
 
             up.reveal(@$elements[2])
 
@@ -57,7 +67,7 @@ describe 'up.layout', ->
             # ---------------------
             # [2] ch+50 ... ch+5049
             # ---------------------
-            expect($(document).scrollTop()).toBe(@clientHeight + 50)
+            expect($documentViewport().scrollTop()).toBe(@clientHeight + 50)
 
         it "includes the element's top margin in the revealed area", asyncSpec (next) ->
           @$elements[1].css('margin-top': '20px')
@@ -163,6 +173,36 @@ describe 'up.layout', ->
             # ----------------
             expect($(document).scrollTop()).toBe(@clientHeight + 50 - 100 - 50)
 
+        it 'scrolls far enough so the element is not obstructed by an element fixed to the top with margin, padding, border and non-zero top properties', asyncSpec (next) ->
+          $topNav = affix('[up-fixed=top]').css(
+            position: 'fixed',
+            top: '29px',
+            margin: '16px',
+            border: '7px solid rgba(0, 0, 0, 0.1)',
+            padding: '5px'
+            left: '0',
+            right: '0'
+            height: '100px'
+          )
+
+          up.reveal(@$elements[2], viewport: @viewport)
+
+          next =>
+            # [0] 00000 ...... ch-1  [F] 0 ...... 99+props
+            # [1] ch+0 ...... ch+49
+            # ---------------------  ---------------------
+            # [2] ch+50 ... ch+5049
+            # ---------------------
+
+            expect($(document).scrollTop()).toBe(
+              @clientHeight +  # scroll past @$elements[0]
+              50            -  # scroll past @$elements[1]
+              100           -  # obstruction height
+              29            -  # obstruction's top property
+              (1 * 16)      -  # top margin (bottom margin is not a visual obstruction)
+              (2 * 7)       -  # obstruction top and bottom borders
+              (2 * 5)          # obstruction top and bottom paddings
+            )
 
         it 'scrolls far enough so the element is not obstructed by an element fixed to the bottom', asyncSpec (next) ->
           $bottomNav = affix('[up-fixed=bottom]').css(
@@ -206,6 +246,36 @@ describe 'up.layout', ->
             # [F] 0 ............ 99
             expect($(document).scrollTop()).toBe(@clientHeight + 50)
 
+        it 'scrolls far enough so the element is not obstructed by an element fixed to the bottom with margin, padding, border and non-zero bottom properties', asyncSpec (next) ->
+          $bottomNav = affix('[up-fixed=bottom]').css(
+            position: 'fixed',
+            bottom: '29px',
+            margin: '16px',
+            border: '7px solid rgba(0, 0, 0, 0.2)',
+            padding: '5px',
+            left: '0',
+            right: '0'
+            height: '100px'
+          )
+
+          up.reveal(@$elements[1])
+
+          next =>
+            # ---------------------
+            # [0] 0 .......... ch-1
+            # [1] ch+0 ...... ch+49
+            # ---------------------
+            # [2] ch+50 ... ch+5049
+            # [F] 0 ...... 99+props
+            expect($(document).scrollTop()).toBe(
+              50        +  # height of elements[1]
+              100       +  # obstruction height
+              29        +  # obstruction's bottom property
+              (1 * 16)  +  # bottom margin (top margin is not a visual obstruction)
+              (2 * 7)   +  # obstruction top and bottom borders
+              (2 * 5)      # obstruction top and bottom paddings
+            )
+
         it 'does not crash when called with a CSS selector (bugfix)', (done) ->
           promise = up.reveal('.container')
           promiseState(promise).then (result) ->
@@ -364,35 +434,31 @@ describe 'up.layout', ->
           # Viewing 100 to 199
           expect($viewport.scrollTop()).toBe(100)
 
-    describe 'revealHash', ->
+    describe 'up.layout.revealHash', ->
 
-      it 'reveals an element with an ID matching the hash in the location', asyncSpec (next) ->
+      it 'reveals an element with an ID matching the given #hash', asyncSpec (next) ->
         revealSpy = up.layout.knife.mock('reveal')
         $match = affix('div#hash')
-        location.hash = '#hash'
-        up.layout.revealHash()
-        next => expect(revealSpy).toHaveBeenCalledWith($match)
+        up.layout.revealHash('#hash')
+        next => expect(revealSpy).toHaveBeenCalledWith($match, top: true)
 
-      it 'reveals a named anchor matching the hash in the location', asyncSpec (next) ->
+      it 'reveals a named anchor matching the given #hash', asyncSpec (next) ->
         revealSpy = up.layout.knife.mock('reveal')
         $match = affix('a[name="hash"]')
-        location.hash = '#hash'
-        up.layout.revealHash()
-        next => expect(revealSpy).toHaveBeenCalledWith($match)
+        up.layout.revealHash('#hash')
+        next => expect(revealSpy).toHaveBeenCalledWith($match, top: true)
 
-      it 'does nothing and returns a fulfilled promise if no element or anchor matches the hash in the location', (done) ->
+      it 'does nothing and returns a fulfilled promise if no element or anchor matches the given #hash', (done) ->
         revealSpy = up.layout.knife.mock('reveal')
-        location.hash = '#hash'
-        promise = up.layout.revealHash()
+        promise = up.layout.revealHash('#hash')
         expect(revealSpy).not.toHaveBeenCalled()
         promiseState(promise).then (result) ->
           expect(result.state).toEqual('fulfilled')
           done()
 
-      it 'does nothing and returns a fulfilled promise if the location has no hash', (done) ->
+      it 'does nothing and returns a fulfilled promise if no #hash is given', (done) ->
         revealSpy = up.layout.knife.mock('reveal')
-        location.hash = ''
-        promise = up.layout.revealHash()
+        promise = up.layout.revealHash('')
         expect(revealSpy).not.toHaveBeenCalled()
         promiseState(promise).then (result) ->
           expect(result.state).toEqual('fulfilled')
@@ -416,12 +482,30 @@ describe 'up.layout', ->
         $viewport = affix('.viewport')
         expect(up.layout.viewportOf($viewport)).toEqual($viewport)
 
-      it 'finds the document if no better viewport matches', ->
-        # This actually tests that the hierarchy returned by `$.parent`
-        # is $element => ... => $('body') => $('html') => $(document)
-        up.layout.config.viewports = ['.other-viewport']
-        $element = affix('div')
-        expect(up.layout.viewportOf($element)).toEqual($(document))
+      describe 'when no configured viewport matches', ->
+
+        afterEach ->
+          @resetBodyCss?()
+          @resetHtmlCss?()
+
+        it 'falls back to the scrolling element', ->
+          $element = affix('.element').css(height: '3000px')
+          $result = up.layout.viewportOf($element)
+          expect($result).toMatchSelector(up.browser.documentViewportSelector())
+
+        it 'falls back to the scrolling element if <body> is configured to scroll (fix for Edge)', ->
+          $element = affix('.element').css(height: '3000px')
+          @resetHtmlCss = u.writeTemporaryStyle('html', 'overflow-y': 'hidden')
+          @resetBodyCss = u.writeTemporaryStyle('body', 'overflow-y': 'scroll')
+          $result = up.layout.viewportOf($element)
+          expect($result).toMatchSelector(up.browser.documentViewportSelector())
+
+        it 'falls back to the scrolling element if <html> is configured to scroll (fix for Edge)', ->
+          $element = affix('.element').css(height: '3000px')
+          @resetHtmlCss = u.writeTemporaryStyle('html', 'overflow-y': 'scroll')
+          @resetBodyCss = u.writeTemporaryStyle('body', 'overflow-y': 'hidden')
+          $result = up.layout.viewportOf($element)
+          expect($result).toMatchSelector(up.browser.documentViewportSelector())
 
     describe 'up.layout.restoreScroll', ->
 

data/spec_app/spec/javascripts/up/link_spec.js.coffee

@@ -216,7 +216,7 @@ describe 'up.link', ->
             expect($('.target')).toHaveText('restored text from two')
             expect(location.pathname).toEqual('/two')
 
-        it 'does adds additional history entries when linking to the current URL, but with a different hash', asyncSpec (next) ->
+        it 'does add additional history entries when linking to the current URL, but with a different hash', asyncSpec (next) ->
           up.history.config.enabled = true
 
           # By default, up.history will replace the <body> tag when

data/spec_app/spec/javascripts/up/modal_spec.js.coffee

@@ -381,6 +381,7 @@ describe 'up.modal', ->
         it 'returns the URL behind the modal overlay', (done) ->
           up.history.config.enabled = true
           up.history.replace('/foo')
+
           expect(up.modal.coveredUrl()).toBeMissing()
           visitPromise = up.modal.visit('/bar', target: '.container')
           u.nextFrame =>

data/spec_app/spec/javascripts/up/motion_spec.js.coffee

@@ -10,12 +10,12 @@ describe 'up.motion', ->
         $element = affix('.element').text('content')
         up.animate($element, 'fade-in', duration: 200, easing: 'linear')
 
-        u.setTimer 5, ->
-          expect($element).toHaveOpacity(0.0, 0.25)
+        u.setTimer 1, ->
+          expect($element).toHaveOpacity(0.0, 0.15)
         u.setTimer 100, ->
-          expect($element).toHaveOpacity(0.5, 0.25)
-        u.setTimer 200, ->
-          expect($element).toHaveOpacity(1.0, 0.25)
+          expect($element).toHaveOpacity(0.5, 0.3)
+        u.setTimer 260, ->
+          expect($element).toHaveOpacity(1.0, 0.15)
           done()
 
       it 'returns a promise that is fulfilled when the animation has completed', (done) ->
@@ -41,6 +41,49 @@ describe 'up.motion', ->
         next =>
           expect($element.css('font-size')).toEqual('40px')
 
+      it 'pauses an existing CSS transitions and restores it once the Unpoly animation is done', asyncSpec (next) ->
+        $element = affix('.element').text('content').css
+          backgroundColor: 'yellow'
+          fontSize: '10px'
+          height: '20px'
+
+        expect(parseFloat($element.css('fontSize'))).toBeAround(10, 0.1)
+        expect(parseFloat($element.css('height'))).toBeAround(20, 0.1)
+
+        next.after 10, =>
+          $element.css
+            transition: 'font-size 500ms linear, height 500ms linear'
+            fontSize: '100px'
+            height: '200px'
+
+        next.after 250, =>
+          # Original CSS transition should now be ~50% done
+          @fontSizeBeforeAnimate = parseFloat($element.css('fontSize'))
+          @heightBeforeAnimate = parseFloat($element.css('height'))
+
+          expect(@fontSizeBeforeAnimate).toBeAround(0.5 * (100 - 10), 20)
+          expect(@heightBeforeAnimate).toBeAround(0.5 * (200 - 20), 40)
+
+          up.animate($element, 'fade-in', duration: 500, easing: 'linear')
+
+        next.after 250, =>
+          # Original CSS transition should remain paused at ~50%
+          # Unpoly animation should now be ~50% done
+          expect(parseFloat($element.css('fontSize'))).toBeAround(@fontSizeBeforeAnimate, 10)
+          expect(parseFloat($element.css('height'))).toBeAround(@heightBeforeAnimate, 10)
+          expect(parseFloat($element.css('opacity'))).toBeAround(0.5, 0.3)
+
+        next.after 250, =>
+          # Unpoly animation should now be done
+          # The original transition resumes. For technical reasons it will take
+          # its full duration for the remaining frames of the transition.
+          expect(parseFloat($element.css('opacity'))).toBeAround(1.0, 0.3)
+
+        next.after (500 + (tolerance = 125)), =>
+          expect(parseFloat($element.css('fontSize'))).toBeAround(100, 20)
+          expect(parseFloat($element.css('height'))).toBeAround(200, 40)
+
+
       describe 'when up.animate() is called from inside an animation function', ->
 
         it 'animates', (done) ->
@@ -101,6 +144,7 @@ describe 'up.motion', ->
             animateDone.then(callback)
             next => expect(callback).toHaveBeenCalled()
 
+
     describe 'up.motion.finish', ->
 
       describe 'when called with an element or selector', ->
@@ -158,49 +202,6 @@ describe 'up.motion', ->
             expect(currentTransitionProperty).toContain('font-size')
             expect(currentTransitionProperty).not.toContain('opacity')
 
-        it 'pauses an existing CSS transitions and restores it once the Unpoly animation is done', asyncSpec (next) ->
-          $element = affix('.element').text('content').css
-            backgroundColor: 'yellow'
-            fontSize: '10px'
-            height: '20px'
-
-          expect(parseFloat($element.css('fontSize'))).toBeAround(10, 0.1)
-          expect(parseFloat($element.css('height'))).toBeAround(20, 0.1)
-
-          next.after 10, =>
-            $element.css
-              transition: 'font-size 500ms linear, height 500ms linear'
-              fontSize: '100px'
-              height: '200px'
-
-          next.after 250, =>
-            # Original CSS transition should now be ~50% done
-            @fontSizeBeforeAnimate = parseFloat($element.css('fontSize'))
-            @heightBeforeAnimate = parseFloat($element.css('height'))
-
-            expect(@fontSizeBeforeAnimate).toBeAround(0.5 * (100 - 10), 20)
-            expect(@heightBeforeAnimate).toBeAround(0.5 * (200 - 20), 40)
-
-            up.animate($element, 'fade-in', duration: 500, easing: 'linear')
-
-          next.after 250, =>
-            # Original CSS transition should remain paused at ~50%
-            # Unpoly animation should now be ~50% done
-            expect(parseFloat($element.css('fontSize'))).toBeAround(@fontSizeBeforeAnimate, 2)
-            expect(parseFloat($element.css('height'))).toBeAround(@heightBeforeAnimate, 2)
-            expect(parseFloat($element.css('opacity'))).toBeAround(0.5, 0.3)
-
-          next.after 250, =>
-            # Unpoly animation should now be done
-            # The original transition resumes. For technical reasons it will take
-            # its full duration for the remaining frames of the transition.
-            expect(parseFloat($element.css('opacity'))).toBeAround(1.0, 0.3)
-
-          next.after (500 + (tolerance = 125)), =>
-            expect(parseFloat($element.css('fontSize'))).toBeAround(100, 20)
-            expect(parseFloat($element.css('height'))).toBeAround(200, 40)
-
-
         it 'cancels an existing transition on the old element by instantly jumping to the last frame', asyncSpec (next) ->
           $v1 = affix('.element').text('v1')
           $v2 = affix('.element').text('v2')
@@ -473,7 +474,7 @@ describe 'up.motion', ->
           transition = ($old, $new, options) ->
             up.morph($old, $new, 'cross-fade', options)
 
-          up.morph($old, $new, transition, duration: 200, easing: 'linear')
+          up.morph($old, $new, transition, duration: 400, easing: 'linear')
 
           next =>
             expect(u.measure($old)).toEqual(oldDims)
@@ -482,11 +483,11 @@ describe 'up.motion', ->
             expect(u.opacity($old)).toBeAround(1.0, 0.25)
             expect(u.opacity($new)).toBeAround(0.0, 0.25)
 
-          next.after 100, =>
+          next.after 200, =>
             expect(u.opacity($old)).toBeAround(0.5, 0.25)
             expect(u.opacity($new)).toBeAround(0.5, 0.25)
 
-          next.after (100 + (tolerance = 110)), =>
+          next.after (200 + (tolerance = 110)), =>
             expect(u.opacity($new)).toBeAround(1.0, 0.25)
             expect($old).toBeDetached()
             expect($new).toBeAttached()

data/spec_app/spec/javascripts/up/namespace_spec.js.coffee

@@ -1,9 +1,9 @@
 describe 'window.up namespace', ->
 
-  describe 'renamedModule()', ->
+  describe 'deprecateRenamedModule()', ->
 
     it 'prints a warning and forwards the call to the new module', ->
-      warnSpy = spyOn(up.log, 'warn')
+      warnSpy = spyOn(up, 'warn')
       value = up.flow
       expect(warnSpy).toHaveBeenCalled()
       expect(value).toBe(up.dom)

data/spec_app/spec/javascripts/up/params_spec.coffee

@@ -0,0 +1,768 @@
+describe 'up.params', ->
+
+  u = up.util
+
+  describe 'JavaScript functions', ->
+
+    encodeBrackets = (str) ->
+      str = str.replace(/\[/g, '%5B')
+      str = str.replace(/\]/g, '%5D')
+      str
+
+    beforeEach ->
+      jasmine.addMatchers
+        toEqualAfterEncodingBrackets: (util, customEqualityTesters) ->
+          compare: (actual, expected) ->
+            pass: actual == encodeBrackets(expected)
+
+    describe 'up.params.toQuery', ->
+
+#      encodedOpeningBracket = '%5B'
+#      encodedClosingBracket = '%5D'
+      encodedSpace = '%20'
+
+      it 'returns the query section for the given object', ->
+        string = up.params.toQuery('foo-key': 'foo value', 'bar-key': 'bar value')
+        expect(string).toEqual("foo-key=foo#{encodedSpace}value&bar-key=bar#{encodedSpace}value")
+
+      it 'returns the query section for the given array with { name } and { value } keys', ->
+        string = up.params.toQuery([
+          { name: 'foo-key', value: 'foo value' },
+          { name: 'bar-key', value: 'bar value' }
+        ])
+        expect(string).toEqual("foo-key=foo#{encodedSpace}value&bar-key=bar#{encodedSpace}value")
+
+      it 'returns a given query string', ->
+        string = up.params.toQuery('foo=bar')
+        expect(string).toEqual('foo=bar')
+
+      it 'returns an empty string for an empty object', ->
+        string = up.params.toQuery({})
+        expect(string).toEqual('')
+
+      it 'returns an empty string for an empty string', ->
+        string = up.params.toQuery('')
+        expect(string).toEqual('')
+
+      it 'returns an empty string for undefined', ->
+        string = up.params.toQuery(undefined)
+        expect(string).toEqual('')
+
+      it 'URL-encodes characters in the key and value', ->
+        string = up.params.toQuery({ 'äpfel': 'bäume' })
+        expect(string).toEqual('%C3%A4pfel=b%C3%A4ume')
+
+      it "sets a blank value after the equal sign if a key's value is a blank string", ->
+        string = up.params.toQuery({'foo': ''})
+        expect(string).toEqual('foo=')
+
+      it 'omits non-primitive values (like Files) from the given params', ->
+        # I would like to construct a File, but IE11 does not support the constructor
+        blob = new Blob([])
+        string = up.params.toQuery(string: 'foo', blob: blob)
+        expect(string).toEqual('string=foo')
+
+      it "omits an equal sign if a key's value is null", ->
+        string = up.params.toQuery({'foo': null})
+        expect(string).toEqual('foo')
+
+      it 'URL-encodes plus characters', ->
+        string = up.params.toQuery({ 'my+key': 'my+value' })
+        expect(string).toEqual('my%2Bkey=my%2Bvalue')
+
+      describeCapability 'canInspectFormData', ->
+
+        it 'converts a FormData object to a query string', ->
+          fd = new FormData()
+          fd.append('key1', 'value1')
+          fd.append('key2', 'value2')
+          string = up.params.toQuery(fd)
+          expect(string).toEqual('key1=value1&key2=value2')
+
+    describe 'up.params.toArray', ->
+
+      it 'normalized null to an empty array', ->
+        array = up.params.toArray(null)
+        expect(array).toEqual([])
+
+      it 'normalized undefined to an empty array', ->
+        array = up.params.toArray(undefined)
+        expect(array).toEqual([])
+
+      it 'normalizes an object hash to an array of objects with { name } and { value } keys', ->
+        array = up.params.toArray(
+          'foo-key': 'foo-value'
+          'bar-key': 'bar-value'
+        )
+        expect(array).toEqual([
+          { name: 'foo-key', value: 'foo-value' },
+          { name: 'bar-key', value: 'bar-value' },
+        ])
+
+      it 'returns a given array without modification', ->
+        array = up.params.toArray([
+          { name: 'foo-key', value: 'foo-value' },
+          { name: 'bar-key', value: 'bar-value' },
+        ])
+        expect(array).toEqual([
+          { name: 'foo-key', value: 'foo-value' },
+          { name: 'bar-key', value: 'bar-value' },
+        ])
+
+      it 'does not URL-encode special characters in keys or values', ->
+        array = up.params.toArray(
+          'äpfel': 'bäume'
+        )
+        expect(array).toEqual([
+          { name: 'äpfel', value: 'bäume' },
+        ])
+
+      it 'does not URL-encode spaces in keys or values', ->
+        array = up.params.toArray(
+          'my key': 'my value'
+        )
+        expect(array).toEqual([
+          { name: 'my key', value: 'my value' },
+        ])
+
+      it 'does not URL-encode ampersands in keys or values', ->
+        array = up.params.toArray(
+          'my&key': 'my&value'
+        )
+        expect(array).toEqual([
+          { name: 'my&key', value: 'my&value' },
+        ])
+
+      it 'does not URL-encode equal signs in keys or values', ->
+        array = up.params.toArray(
+          'my=key': 'my=value'
+        )
+        expect(array).toEqual([
+          { name: 'my=key', value: 'my=value' },
+        ])
+
+      describeCapability 'canInspectFormData', ->
+
+        it 'converts a FormData object to an array', ->
+          fd = new FormData()
+          fd.append('key1', 'value1')
+          fd.append('key2', 'value2')
+          array = up.params.toArray(fd)
+          expect(array).toEqual([
+            { name: 'key1', value: 'value1' },
+            { name: 'key2', value: 'value2' },
+          ])
+
+
+    describe 'up.params.toFormData', ->
+
+      describeCapability 'canInspectFormData', ->
+
+        it 'converts undefined to an empty FormData object', ->
+          params = undefined
+          formData = up.params.toFormData(params)
+          expect(up.params.toArray(formData)).toEqual []
+
+        it 'converts null to an empty FormData object', ->
+          params = null
+          formData = up.params.toFormData(params)
+          expect(up.params.toArray(formData)).toEqual []
+
+        it 'converts an object to a FormData object', ->
+          params = {
+            key1: 'value1',
+            key2: 'value2'
+          }
+          formData = up.params.toFormData(params)
+          expect(up.params.toArray(formData)).toEqual [
+            { name: 'key1', value: 'value1' },
+            { name: 'key2', value: 'value2' },
+          ]
+
+        it 'returns a FormData object unchanged', ->
+          params = new FormData()
+          formData = up.params.toFormData(params)
+          expect(formData).toBe(params)
+
+        it 'converts a query string to a FormData object', ->
+          params = 'key1=value1&key2=value2'
+          formData = up.params.toFormData(params)
+          expect(up.params.toArray(formData)).toEqual [
+            { name: 'key1', value: 'value1' },
+            { name: 'key2', value: 'value2' },
+          ]
+
+        it 'unescapes percent-encoded characters from a query string', ->
+          params = 'my%20key=my%20value'
+          formData = up.params.toFormData(params)
+          expect(up.params.toArray(formData)).toEqual [
+            { name: 'my key', value: 'my value' }
+          ]
+
+
+    describe 'up.params.toObject', ->
+
+      it "parses flat key/value pairs", ->
+        expect(up.params.toObject("xfoo")).toEqual("xfoo": null)
+        expect(up.params.toObject("foo=")).toEqual("foo": "")
+        expect(up.params.toObject("foo=bar")).toEqual("foo": "bar")
+        expect(up.params.toObject("foo=\"bar\"")).toEqual("foo": "\"bar\"")
+
+        expect(up.params.toObject("foo=bar&foo=quux")).toEqual("foo": "quux")
+        expect(up.params.toObject("foo&foo=")).toEqual("foo": "")
+        expect(up.params.toObject("foo=1&bar=2")).toEqual("foo": "1", "bar": "2")
+        expect(up.params.toObject("&foo=1&&bar=2")).toEqual("foo": "1", "bar": "2")
+        expect(up.params.toObject("foo&bar=")).toEqual("foo": null, "bar": "")
+        expect(up.params.toObject("foo=bar&baz=")).toEqual("foo": "bar", "baz": "")
+
+      it 'URL-decodes keys and values', ->
+        expect(up.params.toObject("my%20weird%20field=q1%212%22%27w%245%267%2Fz8%29%3F")).toEqual("my weird field": "q1!2\"'w$5&7/z8)?")
+        expect(up.params.toObject("a=b&pid%3D1234=1023")).toEqual("pid=1234": "1023", "a": "b")
+        # expect(-> up.params.toObject("foo%81E=1")).toThrowError() # invalid byte sequence in UTF-8
+
+      it 'ignores keys that would overwrite an Object prototype property', ->
+        obj = up.params.toObject("foo=bar&hasOwnProperty=baz")
+        expect(obj['foo']).toEqual('bar')
+        expect(u.isFunction obj['hasOwnProperty']).toBe(true)
+
+    describe 'up.params.add', ->
+
+      describe '(with object)', ->
+
+        it 'adds a single key and value', ->
+          obj = { foo: 'one' }
+          obj = up.params.add(obj, 'bar', 'two')
+          expect(obj).toEqual { foo: 'one', bar: 'two' }
+
+      describe '(with array)', ->
+
+        it 'adds a single key and value', ->
+          obj = [{ name: 'foo', value: 'one' }]
+          obj = up.params.add(obj, 'bar', 'two')
+          expect(obj).toEqual [{ name: 'foo', value: 'one' }, { name: 'bar', value: 'two' }]
+
+      describe '(with query string)', ->
+
+        it 'adds a new key/value pair to the end of a query', ->
+          query = 'foo=one'
+          query = up.params.add(query, 'bar', 'two')
+          expect(query).toEqual('foo=one&bar=two')
+
+        it 'does not add superfluous ampersands if the previous query was a blank string', ->
+          query = ''
+          query = up.params.add(query, 'bar', 'two')
+          expect(query).toEqual('bar=two')
+
+        it 'escapes special characters in the new key and value', ->
+          query = 'foo=one'
+          query = up.params.add(query, 'bär', 'twö')
+          expect(query).toEqual('foo=one&b%C3%A4r=tw%C3%B6')
+
+      describe '(with FormData)', ->
+
+        describeCapability 'canInspectFormData', ->
+
+          it 'adds a single entry', ->
+            formData = new FormData()
+            formData.append('key1', 'value1')
+            up.params.add(formData, 'key2', 'value2')
+            expect(up.params.toArray(formData)).toEqual [
+              { name: 'key1', value: 'value1' },
+              { name: 'key2', value: 'value2' },
+            ]
+
+      describe '(with missing params)', ->
+
+        it 'returns an object with only the new key and value', ->
+          obj = undefined
+          obj = up.params.add(obj, 'bar', 'two')
+          expect(obj).toEqual { bar: 'two' }
+
+
+    describe 'up.params.get', ->
+
+      describe '(with object)', ->
+
+        it 'returns the value for the given name', ->
+          obj = { foo: 'one', bar: 'two' }
+          value = up.params.get(obj, 'bar')
+          expect(value).toEqual('two')
+
+        it 'returns undefined if no value is set for the given name', ->
+          obj = { foo: 'one' }
+          value = up.params.get(obj, 'bar')
+          expect(value).toBeUndefined()
+
+        it 'returns undefined for names that are also a basic object property', ->
+          obj = {}
+          value = up.params.get(obj, 'hasOwnProperty')
+          expect(value).toBeUndefined()
+
+      describe '(with array)', ->
+
+        it 'returns the value of the first entry with the given name', ->
+          array = [
+            { name: 'foo', value: 'one' }
+            { name: 'bar', value: 'two' }
+            { name: 'foo', value: 'three' }
+          ]
+          value = up.params.get(array, 'foo')
+          expect(value).toEqual('one')
+
+        it 'returns undefined if there is no entry with the given name', ->
+          array = [
+            { name: 'foo', value: 'one' }
+          ]
+          value = up.params.get(array, 'bar')
+          expect(value).toBeUndefined()
+
+      describe '(with query string)', ->
+
+        it 'returns the query param with the given name', ->
+          query = 'foo=one&bar=two'
+          value = up.params.get(query, 'bar')
+          expect(value).toEqual('two')
+
+        it 'returns undefined if there is no query param with the given name', ->
+          query = 'foo=one'
+          query = up.params.get(query, 'bar')
+          expect(query).toBeUndefined()
+
+        it 'unescapes percent-encoded characters in the returned value', ->
+          query = 'foo=one%20two'
+          value = up.params.get(query, 'foo')
+          expect(value).toEqual('one two')
+
+      describe '(with FormData)', ->
+
+        describeCapability 'canInspectFormData', ->
+
+          it 'returns the first entry with the given name', ->
+            formData = new FormData()
+            formData.append('key1', 'value1')
+            formData.append('key2', 'value2')
+            value = up.params.get(formData, 'key2')
+            expect(value).toEqual('value2')
+
+          it 'returns undefined if there is no entry with the given name', ->
+            formData = new FormData()
+            value = up.params.get(formData, 'key')
+            expect(value).toBeUndefined()
+
+      describe '(with missing params)', ->
+
+        it 'returns undefined', ->
+          params = undefined
+          value = up.params.get(params, 'foo')
+          expect(value).toBeUndefined()
+
+    describe 'up.params.merge', ->
+
+      describe '(with object)', ->
+
+        it 'merges a flat object', ->
+          obj = { a: '1', b: '2' }
+          other = { c: '3', d: '4'}
+          obj = up.params.merge(obj, other)
+          expect(obj).toEqual({ a: '1', b: '2', c: '3', d: '4' })
+
+        it 'merges an array', ->
+          obj = { a: '1', b: '2' }
+          other = [
+            { name: 'c', value: '3' },
+            { name: 'd', value: '4' }
+          ]
+          obj = up.params.merge(obj, other)
+          expect(obj).toEqual({ a: '1', b: '2', c: '3', d: '4' })
+
+        it 'merges a query string', ->
+          obj = { a: '1', b: '2' }
+          other = 'c=3&d=4'
+          obj = up.params.merge(obj, other)
+          expect(obj).toEqual({ a: '1', b: '2', c: '3', d: '4' })
+
+        it 'does not change or crash when merged with undefined', ->
+          obj = { a: '1', b: '2' }
+          obj = up.params.merge(obj, undefined)
+          expect(obj).toEqual({ a: '1', b: '2' })
+
+        describeCapability 'canInspectFormData', ->
+
+          it 'merges a FormData object', ->
+            obj = { a: '1', b: '2' }
+            formData = new FormData()
+            formData.append('c', '3')
+            formData.append('d', '4')
+            merged = up.params.merge(obj, formData)
+            expect(merged).toEqual({ a: '1', b: '2', c: '3', d: '4' })
+
+      describe '(with array)', ->
+
+        it 'merges a flat object', ->
+          array = [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' }
+          ]
+          other = { c: '3', d: '4'}
+          array = up.params.merge(array, other)
+          expect(array).toEqual [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' },
+            { name: 'c', value: '3' },
+            { name: 'd', value: '4' }
+          ]
+
+        it 'merges another array', ->
+          array = [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' }
+          ]
+          other = [
+            { name: 'c', value: '3' },
+            { name: 'd', value: '4' }
+          ]
+          array = up.params.merge(array, other)
+          expect(array).toEqual [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' },
+            { name: 'c', value: '3' },
+            { name: 'd', value: '4' }
+          ]
+
+        it 'merges a query string', ->
+          array = [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' }
+          ]
+          other = 'c=3&d=4'
+          array = up.params.merge(array, other)
+          expect(array).toEqual [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' },
+            { name: 'c', value: '3' },
+            { name: 'd', value: '4' }
+          ]
+
+        it 'does not change or crash when merged with undefined', ->
+          array = [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' }
+          ]
+          array = up.params.merge(array, undefined)
+          expect(array).toEqual [
+            { name: 'a', value: '1' },
+            { name: 'b', value: '2' }
+          ]
+
+        describeCapability 'canInspectFormData', ->
+
+          it 'merges a FormData object', ->
+            array = [
+              { name: 'a', value: '1' },
+              { name: 'b', value: '2' }
+            ]
+            formData = new FormData()
+            formData.append('c', '3')
+            formData.append('d', '4')
+            merged = up.params.merge(array, formData)
+            expect(merged).toEqual [
+              { name: 'a', value: '1' },
+              { name: 'b', value: '2' },
+              { name: 'c', value: '3' },
+              { name: 'd', value: '4' }
+            ]
+
+
+      describe '(with query)', ->
+
+        it 'merges a flat object', ->
+          query = 'a=1&b=2'
+          other = { c: '3', d: '4'}
+          query = up.params.merge(query, other)
+          expect(query).toEqual('a=1&b=2&c=3&d=4')
+
+        it 'merges an array', ->
+          query = 'a=1&b=2'
+          other = [
+            { name: 'c', value: '3' },
+            { name: 'd', value: '4' }
+          ]
+          query = up.params.merge(query, other)
+          expect(query).toEqual('a=1&b=2&c=3&d=4')
+
+        it 'merges another query string', ->
+          query = 'a=1&b=2'
+          other = 'c=3&d=4'
+          query = up.params.merge(query, other)
+          expect(query).toEqual('a=1&b=2&c=3&d=4')
+
+        it 'does not change or crash when merged with undefined', ->
+          query = 'a=1&b=2'
+          query = up.params.merge(query, undefined)
+          expect(query).toEqual('a=1&b=2')
+
+        describeCapability 'canInspectFormData', ->
+
+          it 'merges a FormData object', ->
+            query = 'a=1&b=2'
+            formData = new FormData()
+            formData.append('c', '3')
+            formData.append('d', '4')
+            merged = up.params.merge(query, formData)
+            expect(merged).toEqual('a=1&b=2&c=3&d=4')
+
+    describe 'up.params.buildURL', ->
+
+      it 'composes a URL from a base URL (without query section) and a query section', ->
+        base = 'http://foo.bar/path'
+        query = 'key=value'
+        expect(up.params.buildURL(base, query)).toEqual('http://foo.bar/path?key=value')
+
+      it 'accepts other forms of params (instead of query sections)', ->
+        base = 'http://foo.bar/path'
+        params = { key: 'value' }
+        expect(up.params.buildURL(base, params)).toEqual('http://foo.bar/path?key=value')
+
+      it 'adds more params to a base URL that already has a query section', ->
+        base = 'http://foo.bar/path?key1=value1'
+        params = { key2: 'value2' }
+        expect(up.params.buildURL(base, params)).toEqual('http://foo.bar/path?key1=value1&key2=value2')
+
+      it 'does not add a question mark to the base URL if the given params are blank', ->
+        base = 'http://foo.bar/path'
+        params = ''
+        expect(up.params.buildURL(base, params)).toEqual('http://foo.bar/path')
+
+    describe 'up.params.fromURL', ->
+
+      it 'returns the query section from an URL, without leading question mark', ->
+        url = 'http://foo.bar/path?key=value'
+        expect(up.params.fromURL(url)).toEqual('key=value')
+
+      it 'returns undefined if the URL has no query section', ->
+        url = 'http://foo.bar/path'
+        expect(up.params.fromURL(url)).toBeUndefined()
+
+
+    describe 'up.params.fromForm', ->
+
+      it 'serializes a form with multiple inputs', ->
+        $form = affix('form')
+        $form.append('<input name="key1" value="value1">')
+        $form.append('<input name="key2" value="value2">')
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key1', value: 'value1' },
+          { name: 'key2', value: 'value2' },
+        ]
+
+      it 'serializes an <input type="text"> with its default [value]', ->
+        $form = affix('form')
+        $form.append('<input type="text" name="key" value="value-from-attribute">')
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value-from-attribute' }
+        ]
+
+      it 'serializes an <input type="text"> that had its value property changed by a script', ->
+        $form = affix('form')
+        $input = $('<input type="text" name="key" value="value-from-attribute">').appendTo($form)
+        $input[0].value = 'value-from-script'
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value-from-script' }
+        ]
+
+      it 'serializes an <input type="hidden"> with its default [value]', ->
+        $form = affix('form')
+        $form.append('<input type="hidden" name="key" value="value-from-attribute">')
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value-from-attribute' }
+        ]
+
+      it 'serializes an <input type="hidden"> that had its value property changed by a script', ->
+        $form = affix('form')
+        $input = $('<input type="hidden" name="key" value="value-from-attribute">').appendTo($form)
+        $input[0].value = 'value-from-script'
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value-from-script' }
+        ]
+
+      it 'seralizes a <select> with its default selected option', ->
+        $form = affix('form')
+        $select = $('<select name="key"></select>').appendTo($form)
+        $option1 = $('<option value="value1">').appendTo($select)
+        $option2 = $('<option value="value2" selected>').appendTo($select)
+        $option3 = $('<option value="value3">').appendTo($select)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value2' }
+        ]
+
+      it 'seralizes a <select> that had its selection changed by a script', ->
+        $form = affix('form')
+        $select = $('<select name="key"></select>').appendTo($form)
+        $option1 = $('<option value="value1">').appendTo($select)
+        $option2 = $('<option value="value2" selected>').appendTo($select)
+        $option3 = $('<option value="value3">').appendTo($select)
+
+        $option2[0].selected = false
+        $option3[0].selected = true
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value3' }
+        ]
+
+      it 'serializes a <select multiple> with multiple selected options into multiple params', ->
+        $form = affix('form')
+        $select = $('<select name="key" multiple></select>').appendTo($form)
+        $option1 = $('<option value="value1">').appendTo($select)
+        $option2 = $('<option value="value2" selected>').appendTo($select)
+        $option3 = $('<option value="value3" selected>').appendTo($select)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value2' },
+          { name: 'key', value: 'value3' }
+        ]
+
+      it 'serializes an <input type="file">'
+
+      it 'serializes an <input type="file" multiple> into multiple params'
+
+      it 'includes an <input type="checkbox"> that was [checked] by default', ->
+        $form = affix('form')
+        $input = $('<input type="checkbox" name="key" value="value" checked>').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value' }
+        ]
+
+      it 'includes an <input type="checkbox"> that was checked by a script', ->
+        $form = affix('form')
+        $input = $('<input type="checkbox" name="key" value="value">').appendTo($form)
+        $input[0].checked = true
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value' }
+        ]
+
+      it 'excludes an <input type="checkbox"> that is unchecked', ->
+        $form = affix('form')
+        $input = $('<input type="checkbox" name="key" value="value">').appendTo($form)
+        params = up.params.fromForm($form)
+        expect(params).toEqual []
+
+      it 'includes a checked <input type="radio"> in a radio button group that was [checked] by default', ->
+        $form = affix('form')
+        $button1 = $('<input type="radio" name="key" value="value1">').appendTo($form)
+        $button2 = $('<input type="radio" name="key" value="value2" checked>').appendTo($form)
+        $button3 = $('<input type="radio" name="key" value="value3">').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value2' }
+        ]
+
+      it 'includes a checked <input type="radio"> in a radio button group that was checked by a script', ->
+        $form = affix('form')
+        $button1 = $('<input type="radio" name="key" value="value1">').appendTo($form)
+        $button2 = $('<input type="radio" name="key" value="value2" checked>').appendTo($form)
+        $button3 = $('<input type="radio" name="key" value="value3">').appendTo($form)
+
+        $button2[0].checked = false
+        $button3[0].checked = true
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value3' }
+        ]
+
+      it 'excludes an radio button group if no button is selected', ->
+        $form = affix('form')
+        $button1 = $('<input type="radio" name="key" value="value1">').appendTo($form)
+        $button2 = $('<input type="radio" name="key" value="value2">').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual []
+
+      it 'excludes an <input> that is [disabled] by default', ->
+        $form = affix('form')
+        $input = $('<input type="text" name="key" value="value" disabled>').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual []
+
+      it 'excludes an <input> that was disabled by a script', ->
+        $form = affix('form')
+        $input = $('<input type="text" name="key" value="value">').appendTo($form)
+        $input[0].disabled = true
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual []
+
+      it 'excludes an <input> without a [name] attribute', ->
+        $form = affix('form')
+        $input = $('<input type="text" value="value">').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual []
+
+      it 'includes an <input readonly>', ->
+        $form = affix('form')
+        $input = $('<input type="text" name="key" value="value" readonly>').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'key', value: 'value' }
+        ]
+
+      it 'includes the focused submit button', ->
+        $form = affix('form')
+        $input = $('<input type="text" name="input-key" value="input-value">').appendTo($form)
+        $submit1 = $('<button type="submit" name="submit1-key" value="submit1-value">').appendTo($form)
+        $submit2 = $('<input type="submit" name="submit2-key" value="submit2-value">').appendTo($form)
+        $submit3 = $('<input type="submit" name="submit3-key" value="submit3-value">').appendTo($form)
+
+        $submit2.focus()
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'input-key', value: 'input-value' },
+          { name: 'submit2-key', value: 'submit2-value' }
+        ]
+
+      it 'includes a the first submit button if no button is focused', ->
+        $form = affix('form')
+        $input = $('<input type="text" name="input-key" value="input-value">').appendTo($form)
+        $submit1 = $('<button type="submit" name="submit1-key" value="submit1-value">').appendTo($form)
+        $submit2 = $('<input type="submit" name="submit2-key" value="submit2-value">').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'input-key', value: 'input-value' },
+          { name: 'submit1-key', value: 'submit1-value' }
+        ]
+
+      it 'excludes a submit button without a [name] attribute', ->
+        $form = affix('form')
+        $input = $('<input type="text" name="input-key" value="input-value">').appendTo($form)
+        $submit = $('<button type="submit" value="submit-value">').appendTo($form)
+
+        params = up.params.fromForm($form)
+        expect(params).toEqual [
+          { name: 'input-key', value: 'input-value' }
+        ]
+
+