unpoly-rails 0.56.7 → 0.57.0

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

@@ -7,19 +7,28 @@ describe 'up.proxy', ->
     describe 'up.request', ->
 
       it 'makes a request with the given URL and params', ->
-        up.request('/foo', data: { key: 'value' }, method: 'post')
+        up.request('/foo', params: { key: 'value' }, method: 'post')
         request = @lastRequest()
         expect(request.url).toMatchUrl('/foo')
         expect(request.data()).toEqual(key: ['value'])
         expect(request.method).toEqual('POST')
 
       it 'also allows to pass the URL as a { url } option instead', ->
-        up.request(url: '/foo', data: { key: 'value' }, method: 'post')
+        up.request(url: '/foo', params: { key: 'value' }, method: 'post')
         request = @lastRequest()
         expect(request.url).toMatchUrl('/foo')
         expect(request.data()).toEqual(key: ['value'])
         expect(request.method).toEqual('POST')
 
+      it 'allows to pass in an up.Request instance instead of an options object', ->
+        requestArg = new up.Request(url: '/foo', params: { key: 'value' }, method: 'post')
+        up.request(requestArg)
+
+        jasmineRequest = @lastRequest()
+        expect(jasmineRequest.url).toMatchUrl('/foo')
+        expect(jasmineRequest.data()).toEqual(key: ['value'])
+        expect(jasmineRequest.method).toEqual('POST')
+
       it 'submits the replacement targets as HTTP headers, so the server may choose to only frender the requested fragments', asyncSpec (next) ->
         up.request(url: '/foo', target: '.target', failTarget: '.fail-target')
 
@@ -31,7 +40,7 @@ describe 'up.proxy', ->
       it 'resolves to a Response object that contains information about the response and request', (done) ->
         promise = up.request(
           url: '/url'
-          data: { key: 'value' }
+          params: { key: 'value' }
           method: 'post'
           target: '.target'
         )
@@ -44,7 +53,7 @@ describe 'up.proxy', ->
 
           promise.then (response) ->
             expect(response.request.url).toMatchUrl('/url')
-            expect(response.request.data).toEqual(key: 'value')
+            expect(response.request.params).toEqual(key: 'value')
             expect(response.request.method).toEqual('POST')
             expect(response.request.target).toEqual('.target')
             expect(response.request.hash).toBeBlank()
@@ -57,6 +66,22 @@ describe 'up.proxy', ->
 
             done()
 
+      it 'resolves to a Response that contains the response headers', (done) ->
+        promise = up.request(url: '/url')
+
+        u.nextFrame =>
+          @respondWith
+            responseHeaders: { 'foo': 'bar', 'baz': 'bam' }
+            responseText: 'hello'
+
+        promise.then (response) ->
+          expect(response.getHeader('foo')).toEqual('bar')
+
+          # Lookup is case-insensitive
+          expect(response.getHeader('BAZ')).toEqual('bam')
+
+          done()
+
       it "preserves the URL hash in a separate { hash } property, since although it isn't sent to server, code might need it to process the response", (done) ->
         promise = up.request('/url#hash')
 
@@ -77,7 +102,7 @@ describe 'up.proxy', ->
         it 'updates the { method } property in the response object', (done) ->
           promise = up.request(
             url: '/url'
-            data: { key: 'value' }
+            params: { key: 'value' }
             method: 'post'
             target: '.target'
           )
@@ -164,8 +189,8 @@ describe 'up.proxy', ->
             # See that an additional request was made
             expect(jasmine.Ajax.requests.count()).toEqual(2)
 
-        it "does not explode if the original request's { data } is a FormData object", asyncSpec (next) ->
-          up.request('/foo', method: 'post', data: new FormData()) # POST requests are not cached
+        it "does not explode if the original request's { params } is a FormData object", asyncSpec (next) ->
+          up.request('/foo', method: 'post', params: new FormData()) # POST requests are not cached
 
           next =>
             expect(jasmine.Ajax.requests.count()).toEqual(1)
@@ -286,11 +311,11 @@ describe 'up.proxy', ->
             headers = @lastRequest().requestHeaders
             expect(headers['X-Requested-With']).toEqual('Love')
 
-      describe 'with { data } option', ->
+      describe 'with { params } option', ->
 
         it "uses the given params as a non-GET request's payload", asyncSpec (next) ->
           givenParams = { 'foo-key': 'foo-value', 'bar-key': 'bar-value' }
-          up.request(url: '/path', method: 'put', data: givenParams)
+          up.request(url: '/path', method: 'put', params: givenParams)
 
           next =>
             expect(@lastRequest().data()['foo-key']).toEqual(['foo-value'])
@@ -298,7 +323,7 @@ describe 'up.proxy', ->
 
         it "encodes the given params into the URL of a GET request", (done) ->
           givenParams = { 'foo-key': 'foo-value', 'bar-key': 'bar-value' }
-          promise = up.request(url: '/path', method: 'get', data: givenParams)
+          promise = up.request(url: '/path', method: 'get', params: givenParams)
 
           u.nextFrame =>
             expect(@lastRequest().url).toMatchUrl('/path?foo-key=foo-value&bar-key=bar-value')
@@ -310,7 +335,7 @@ describe 'up.proxy', ->
               # See that the response object has been updated by moving the data options
               # to the URL. This is important for up.dom code that works on response.request.
               expect(response.request.url).toMatchUrl('/path?foo-key=foo-value&bar-key=bar-value')
-              expect(response.request.data).toBeBlank()
+              expect(response.request.params).toBeBlank()
               done()
 
       it 'caches server responses for the configured duration', asyncSpec (next) ->
@@ -384,8 +409,8 @@ describe 'up.proxy', ->
         next => expect(jasmine.Ajax.requests.count()).toEqual(2)
 
       it "doesn't reuse responses when asked for the same path, but different params", asyncSpec (next) ->
-        next => up.request(url: '/path', data: { query: 'foo' })
-        next => up.request(url: '/path', data: { query: 'bar' })
+        next => up.request(url: '/path', params: { query: 'foo' })
+        next => up.request(url: '/path', params: { query: 'bar' })
         next => expect(jasmine.Ajax.requests.count()).toEqual(2)
 
       it "reuses a response for an 'html' selector when asked for the same path and any other selector", asyncSpec (next) ->
@@ -460,6 +485,7 @@ describe 'up.proxy', ->
               request = @lastRequest()
               expect(request.method).toEqual('POST')
               expect(request.data()['_method']).toEqual([method])
+#              expect(request.data()['foo']).toEqual('bar')
 
       describe 'with config.maxRequests set', ->
 
@@ -656,7 +682,7 @@ describe 'up.proxy', ->
 
         it 'does not emit up:proxy:recover if a delayed up:proxy:slow was never emitted due to a fast response', asyncSpec (next) ->
           next =>
-            up.proxy.config.slowDelay = 100
+            up.proxy.config.slowDelay = 200
             up.request(url: '/foo')
 
           next =>
@@ -664,13 +690,13 @@ describe 'up.proxy', ->
               'up:proxy:load'
             ])
 
-          next.after 50, =>
+          next.after 100, =>
             jasmine.Ajax.requests.at(0).respondWith
               status: 200
               contentType: 'text/html'
               responseText: 'foo'
 
-          next.after 150, =>
+          next.after 250, =>
             expect(@events).toEqual([
               'up:proxy:load',
               'up:proxy:loaded'
@@ -756,11 +782,24 @@ describe 'up.proxy', ->
             cachedPromise = up.proxy.get(url: '/path', target: '.target')
             expect(u.isPromise(cachedPromise)).toBe(true)
 
-        it "does not load a link whose method has side-effects", asyncSpec (next) ->
-          $link = affix('a[href="/path"][data-method="post"]')
-          up.proxy.preload($link)
+        it "does not load a link whose method has side-effects", (done) ->
+          affix('.target')
+          $link = affix('a[href="/path"][up-target=".target"][data-method="post"]')
+          preloadPromise = up.proxy.preload($link)
+
+          promiseState(preloadPromise).then (result) ->
+            expect(result.state).toEqual('rejected')
+            expect(up.proxy.get(url: '/path', target: '.target')).toBeUndefined()
+            done()
+
+        it 'accepts options', asyncSpec (next) ->
+          affix('.target')
+          $link = affix('a[href="/path"][up-target=".target"]')
+          up.proxy.preload($link, url: '/options-path')
 
-          next => expect(up.proxy.get(url: '/path')).toBeUndefined()
+          next =>
+            cachedPromise = up.proxy.get(url: '/options-path', target: '.target')
+            expect(u.isPromise(cachedPromise)).toBe(true)
 
         describe 'for an [up-target] link', ->
 
@@ -784,7 +823,7 @@ describe 'up.proxy', ->
             up.proxy.preload($link)
 
             next =>
-              expect(requestSpy).toHaveBeenCalledWith(jasmine.objectContaining(url: '/path', preload: true))
+              expect(requestSpy).toHaveBeenCalledWith(jasmine.objectContaining(preload: true))
 
         describe 'for an [up-modal] link', ->
 
@@ -851,7 +890,7 @@ describe 'up.proxy', ->
             up.proxy.preload($link)
 
             next =>
-              expect(requestSpy).toHaveBeenCalledWith(jasmine.objectContaining(url: '/path', preload: true))
+              expect(requestSpy).toHaveBeenCalledWith(jasmine.objectContaining(preload: true))
 
         describe 'for an [up-popup] link', ->
 
@@ -921,7 +960,7 @@ describe 'up.proxy', ->
             up.proxy.preload($link)
 
             next =>
-              expect(requestSpy).toHaveBeenCalledWith(jasmine.objectContaining(url: '/path', preload: true))
+              expect(requestSpy).toHaveBeenCalledWith(jasmine.objectContaining(preload: true))
 
       describeFallback 'canPushState', ->
 
@@ -935,16 +974,16 @@ describe 'up.proxy', ->
     describe 'up.proxy.get', ->
 
       it 'returns an existing cache entry for the given request', ->
-        promise1 = up.request(url: '/foo', data: { key: 'value' })
-        promise2 = up.proxy.get(url: '/foo', data: { key: 'value' })
+        promise1 = up.request(url: '/foo', params: { key: 'value' })
+        promise2 = up.proxy.get(url: '/foo', params: { key: 'value' })
         expect(promise1).toBe(promise2)
 
       it 'returns undefined if the given request is not cached', ->
-        promise = up.proxy.get(url: '/foo', data: { key: 'value' })
+        promise = up.proxy.get(url: '/foo', params: { key: 'value' })
         expect(promise).toBeUndefined()
 
-      it "returns undefined if the given request's { data } is a FormData object", ->
-        promise = up.proxy.get(url: '/foo', data: new FormData())
+      it "returns undefined if the given request's { params } is a FormData object", ->
+        promise = up.proxy.get(url: '/foo', params: new FormData())
         expect(promise).toBeUndefined()
 
     describe 'up.proxy.set', ->
@@ -962,7 +1001,7 @@ describe 'up.proxy', ->
       it 'does nothing if the given request is not cached'
 
       it 'does not crash when passed a request with FormData (bugfix)', ->
-        removal = -> up.proxy.remove(url: '/path', data: new FormData())
+        removal = -> up.proxy.remove(url: '/path', params: new FormData())
         expect(removal).not.toThrowError()
 
     describe 'up.proxy.clear', ->
@@ -1041,7 +1080,7 @@ describe 'up.proxy', ->
 
         Trigger.hoverSequence($link)
 
-        next.after 2, =>
+        next.after 50, =>
           expect(jasmine.Ajax.requests.count()).toEqual(1)
 
           @respondWith
@@ -1067,7 +1106,7 @@ describe 'up.proxy', ->
           expect(window).not.toHaveUnhandledRejections() if REJECTION_EVENTS_SUPPORTED
 
       it 'triggers a separate AJAX request when hovered multiple times and the cache expires between hovers', asyncSpec (next)  ->
-        up.proxy.config.cacheExpiry = 50
+        up.proxy.config.cacheExpiry = 100
         up.proxy.config.preloadDelay = 0
 
         $element = affix('a[href="/foo"][up-preload]')
@@ -1075,17 +1114,17 @@ describe 'up.proxy', ->
 
         Trigger.hoverSequence($element)
 
-        next.after 1, =>
+        next.after 10, =>
           expect(jasmine.Ajax.requests.count()).toEqual(1)
 
-        next.after 1, =>
+        next.after 10, =>
           Trigger.hoverSequence($element)
 
-        next.after 1, =>
+        next.after 10, =>
           expect(jasmine.Ajax.requests.count()).toEqual(1)
 
-        next.after 60, =>
+        next.after 150, =>
           Trigger.hoverSequence($element)
 
-        next.after 1, =>
+        next.after 30, =>
           expect(jasmine.Ajax.requests.count()).toEqual(2)

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

@@ -1,4 +1,6 @@
 describe 'up.syntax', ->
+
+  u = up.util
   
   describe 'JavaScript functions', ->
   
@@ -96,28 +98,38 @@ describe 'up.syntax', ->
           promiseState(promise).then (result) ->
             expect(result.state).toEqual('fulfilled')
 
-      it 'parses an up-data attribute as JSON and passes the parsed object as a second argument to the initializer', ->
+      describe 'passing of [up-data]', ->
+
+        it 'parses an [up-data] attribute as JSON and passes the parsed object as a second argument to the compiler', ->
+          observeArgs = jasmine.createSpy()
+          up.compiler '.child', ($element, data) ->
+            observeArgs($element.attr('class'), data)
+
+          data = { key1: 'value1', key2: 'value2' }
+
+          $tag = affix(".child").attr('up-data', JSON.stringify(data))
+          up.hello($tag)
 
-        observeArgs = jasmine.createSpy()
-        up.compiler '.child', ($element, data) ->
-          observeArgs($element.attr('class'), data)
+          expect(observeArgs).toHaveBeenCalledWith('child', data)
 
-        data = { key1: 'value1', key2: 'value2' }
+        it 'passes an empty object as a second argument to the compiler if there is no [up-data] attribute', ->
+          observeArgs = jasmine.createSpy()
+          up.compiler '.child', ($element, data) ->
+            observeArgs($element.attr('class'), data)
 
-        $tag = affix(".child").attr('up-data', JSON.stringify(data))
-        up.hello($tag)
+          up.hello(affix(".child"))
 
-        expect(observeArgs).toHaveBeenCalledWith('child', data)
+          expect(observeArgs).toHaveBeenCalledWith('child', {})
 
-      it 'passes an empty object as a second argument to the initializer if there is no up-data attribute', ->
+        it 'does not parse an [up-data] attribute if the compiler function only takes a single argument', ->
+          parseDataSpy = spyOn(up.syntax, 'data').and.returnValue({})
 
-        observeArgs = jasmine.createSpy()
-        up.compiler '.child', ($element, data) ->
-          observeArgs($element.attr('class'), data)
+          $child = affix(".child")
 
-        up.hello(affix(".child"))
+          up.compiler '.child', ($element) -> # no-op
+          up.hello($child)
 
-        expect(observeArgs).toHaveBeenCalledWith('child', {})
+          expect(parseDataSpy).not.toHaveBeenCalled()
 
       it 'compiles matching elements one-by-one', ->
         compiler = jasmine.createSpy('compiler')
@@ -143,6 +155,13 @@ describe 'up.syntax', ->
           expect(compiler.calls.count()).toEqual(1)
           expect(compiler).toHaveBeenCalledWith($both)
 
+        it 'throws an error if the batch compiler returns a destructor', ->
+          destructor = ->
+          up.compiler '.element', { batch: true }, ($element) -> destructor
+          $container = affix('.element')
+          compile = -> up.hello($container)
+          expect(compile).toThrowError(/cannot return destructor/i)
+
       describe 'with { keep } option', ->
 
         it 'adds an up-keep attribute to the fragment during compilation', ->
@@ -238,4 +257,18 @@ describe 'up.syntax', ->
 
       it 'should have tests'
       
-     
+    describe 'up.syntax.data', ->
+
+      it 'returns the [up-data] attribute of the given element, parsed as JSON', ->
+        $element = affix('.element').attr('up-data', '{ "foo": 1, "bar": 2 }')
+        data = up.syntax.data($element)
+        expect(data).toEqual(foo: 1, bar: 2)
+
+      it 'returns en empty object if the given element has no [up-data] attribute', ->
+        $element = affix('.element')
+        data = up.syntax.data($element)
+        expect(data).toEqual({})
+
+      it 'returns undefined if undefined is passed instead of an element', ->
+        data = up.syntax.data(undefined)
+        expect(data).toBeUndefined()

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

@@ -4,6 +4,13 @@ describe 'up.util', ->
 
   describe 'JavaScript functions', ->
 
+#    describe 'up.util.flatMap', ->
+#
+#      it 'collects the Array results of the given map function, then concatenates the result arrays into one flat array', ->
+#        fun = (x) -> [x, x]
+#        result = up.util.flatMap([1, 2, 3], fun)
+#        expect(result).toEqual([1, 1, 2, 2, 3, 3])
+
     describe 'up.util.uniq', ->
 
       it 'returns the given array with duplicates elements removed', ->
@@ -35,6 +42,56 @@ describe 'up.util', ->
         result = up.util.uniqBy(input, 'length')
         expect(result).toEqual ['foo', 'apple', 'orange']
 
+#    describe 'up.util.parsePath', ->
+#
+#      it 'parses a plain name', ->
+#        path = up.util.parsePath("foo")
+#        expect(path).toEqual ['foo']
+#
+#      it 'considers underscores to be part of a name', ->
+#        path = up.util.parsePath("foo_bar")
+#        expect(path).toEqual ['foo_bar']
+#
+#      it 'considers dashes to be part of a name', ->
+#        path = up.util.parsePath("foo-bar")
+#        expect(path).toEqual ['foo-bar']
+#
+#      it 'parses dot-separated names into multiple path segments', ->
+#        path = up.util.parsePath('foo.bar.baz')
+#        expect(path).toEqual ['foo', 'bar', 'baz']
+#
+#      it 'parses nested params notation with square brackets', ->
+#        path = up.util.parsePath('user[account][email]')
+#        expect(path).toEqual ['user', 'account', 'email']
+#
+#      it 'parses double quotes in square brackets', ->
+#        path = up.util.parsePath('user["account"]["email"]')
+#        expect(path).toEqual ['user', 'account', 'email']
+#
+#      it 'parses single quotes in square brackets', ->
+#        path = up.util.parsePath("user['account']['email']")
+#        expect(path).toEqual ['user', 'account', 'email']
+#
+#      it 'allows square brackets inside quotes', ->
+#        path = up.util.parsePath("element['a[up-href]']")
+#        expect(path).toEqual ['element', 'a[up-href]']
+#
+#      it 'allows single quotes inside double quotes', ->
+#        path = up.util.parsePath("element[\"a[up-href='foo']\"]")
+#        expect(path).toEqual ['element', "a[up-href='foo']"]
+#
+#      it 'allows double quotes inside single quotes', ->
+#        path = up.util.parsePath("element['a[up-href=\"foo\"]']")
+#        expect(path).toEqual ['element', 'a[up-href="foo"]']
+#
+#      it 'allows dots in square brackets when it is quoted', ->
+#        path = up.util.parsePath('elements[".foo"]')
+#        expect(path).toEqual ['elements', '.foo']
+#
+#      it 'allows different notation for each segment', ->
+#        path = up.util.parsePath('foo.bar[baz]["bam"][\'qux\']')
+#        expect(path).toEqual ['foo', 'bar', 'baz', 'bam', 'qux']
+
     describe 'up.util.map', ->
 
       it 'creates a new array of values by calling the given function on each item of the given array', ->
@@ -211,6 +268,17 @@ describe 'up.util', ->
           fooBar: 'one'
           barBaz: 'two'
 
+#    describe 'up.util.lowerCaseKeys', ->
+#
+#      it "returns a copy of the given object will all keys in lower case", ->
+#        input =
+#          'A-B': 'C-D'
+#          'E-F': 'G-H'
+#        result = up.util.lowerCaseKeys(input)
+#        expect(result).toEqual
+#          'a-b': 'C-D'
+#          'e-f': 'G-H'
+
     describe 'up.util.DivertibleChain', ->
 
       it "instantiates a task queue whose (2..n)th tasks can be changed by calling '.asap'", (done) ->
@@ -569,7 +637,11 @@ describe 'up.util', ->
         expect(up.util.selectorForElement($element)).toBe('input[name="name-value"]')
 
       it "prefers using the element's classes to using the element's ARIA label", ->
-        $element = affix('div.class1.class2')
+        $element = affix('div.class1.class2[aria-label="ARIA label value"]')
+        expect(up.util.selectorForElement($element)).toBe(".class1.class2")
+
+      it 'does not use Unpoly classes to compose a class selector', ->
+        $element = affix('div.class1.up-current.class2')
         expect(up.util.selectorForElement($element)).toBe(".class1.class2")
 
       it "prefers using the element's ARIA label to using the element's tag name", ->
@@ -862,56 +934,6 @@ describe 'up.util', ->
         up.util.remove(array, obj2)
         expect(array).toEqual [obj1, obj3]
 
-
-    describe 'up.util.requestDataAsQuery', ->
-
-      encodedOpeningBracket = '%5B'
-      encodedClosingBracket = '%5D'
-      encodedSpace = '%20'
-
-      it 'returns the query section for the given object', ->
-        string = up.util.requestDataAsQuery('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 nested object', ->
-        string = up.util.requestDataAsQuery('foo-key': { 'bar-key': 'bar-value' }, 'bam-key': 'bam-value')
-        expect(string).toEqual("foo-key#{encodedOpeningBracket}bar-key#{encodedClosingBracket}=bar-value&bam-key=bam-value")
-
-      it 'returns the query section for the given array with { name } and { value } keys', ->
-        string = up.util.requestDataAsQuery([
-          { 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.util.requestDataAsQuery('foo=bar')
-        expect(string).toEqual('foo=bar')
-
-      it 'strips a leading question mark from the given query string', ->
-        string = up.util.requestDataAsQuery('?foo=bar')
-        expect(string).toEqual('foo=bar')
-
-      it 'returns an empty string for an empty object', ->
-        string = up.util.requestDataAsQuery({})
-        expect(string).toEqual('')
-
-      it 'returns an empty string for an empty string', ->
-        string = up.util.requestDataAsQuery('')
-        expect(string).toEqual('')
-
-      it 'returns an empty string for undefined', ->
-        string = up.util.requestDataAsQuery(undefined)
-        expect(string).toEqual('')
-
-      it 'URL-encodes characters in the key and value', ->
-        string = up.util.requestDataAsQuery({ 'äpfel': 'bäume' })
-        expect(string).toEqual('%C3%A4pfel=b%C3%A4ume')
-
-      it 'URL-encodes plus characters', ->
-        string = up.util.requestDataAsQuery({ 'my+key': 'my+value' })
-        expect(string).toEqual('my%2Bkey=my%2Bvalue')
-
     describe 'up.util.unresolvablePromise', ->
 
       it 'return a pending promise', (done) ->
@@ -925,84 +947,6 @@ describe 'up.util', ->
         two = up.util.unresolvablePromise()
         expect(one).not.toBe(two)
 
-    describe 'up.util.requestDataAsArray', ->
-
-      it 'normalized null to an empty array', ->
-        array = up.util.requestDataAsArray(null)
-        expect(array).toEqual([])
-
-      it 'normalized undefined to an empty array', ->
-        array = up.util.requestDataAsArray(undefined)
-        expect(array).toEqual([])
-
-      it 'normalizes an object hash to an array of objects with { name } and { value } keys', ->
-        array = up.util.requestDataAsArray(
-          'foo-key': 'foo-value'
-          'bar-key': 'bar-value'
-        )
-        expect(array).toEqual([
-          { name: 'foo-key', value: 'foo-value' },
-          { name: 'bar-key', value: 'bar-value' },
-        ])
-
-      it 'normalizes a nested object hash to a flat array using param naming conventions', ->
-        array = up.util.requestDataAsArray(
-          'foo-key': 'foo-value'
-          'bar-key': {
-            'bam-key': 'bam-value'
-            'baz-key': {
-              'qux-key': 'qux-value'
-            }
-          }
-        )
-        expect(array).toEqual([
-          { name: 'foo-key', value: 'foo-value' },
-          { name: 'bar-key[bam-key]', value: 'bam-value' },
-          { name: 'bar-key[baz-key][qux-key]', value: 'qux-value' },
-        ])
-
-      it 'returns a given array without modification', ->
-        array = up.util.requestDataAsArray([
-          { 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 keys or values', ->
-        array = up.util.requestDataAsArray(
-          'äpfel': { 'bäume': 'börse' }
-        )
-        expect(array).toEqual([
-          { name: 'äpfel[bäume]', value: 'börse' },
-        ])
-
-      it 'does not URL-encode spaces in keys or values', ->
-        array = up.util.requestDataAsArray(
-          '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.util.requestDataAsArray(
-          '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.util.requestDataAsArray(
-          'my=key': 'my=value'
-        )
-        expect(array).toEqual([
-          { name: 'my=key', value: 'my=value' },
-        ])
-
     describe 'up.util.flatten', ->
 
       it 'flattens the given array', ->
@@ -1105,6 +1049,9 @@ describe 'up.util', ->
       it 'returns true for an object literal', ->
         expect(up.util.isOptions({ foo: 'bar'})).toBe(true)
 
+      it 'returns true for a prototype-less object', ->
+        expect(up.util.isOptions(Object.create(null))).toBe(true)
+
       it 'returns false for undefined', ->
         expect(up.util.isOptions(undefined)).toBe(false)
 
@@ -1116,18 +1063,24 @@ describe 'up.util', ->
         fn.key = 'value'
         expect(up.util.isOptions(fn)).toBe(false)
 
-      it 'returns false for an array', ->
+      it 'returns false for an Array', ->
         expect(up.util.isOptions(['foo'])).toBe(false)
 
       it 'returns false for a jQuery collection', ->
         expect(up.util.isOptions($('body'))).toBe(false)
 
-      it 'returns false for a promise', ->
+      it 'returns false for a Promise', ->
         expect(up.util.isOptions(Promise.resolve())).toBe(false)
 
       it 'returns false for a FormData object', ->
         expect(up.util.isOptions(new FormData())).toBe(false)
 
+      it 'returns false for a Date', ->
+        expect(up.util.isOptions(new Date())).toBe(false)
+
+      it 'returns false for a RegExp', ->
+        expect(up.util.isOptions(new RegExp('foo'))).toBe(false)
+
     describe 'up.util.isObject', ->
 
       it 'returns true for an Object instance', ->
@@ -1159,6 +1112,70 @@ describe 'up.util', ->
       it 'returns true for a FormData object', ->
         expect(up.util.isObject(new FormData())).toBe(true)
 
+    describe 'up.util.merge', ->
+
+      it 'merges the given objects', ->
+        obj = { a: '1', b: '2' }
+        other = { b: '3', c: '4' }
+        obj = up.util.merge(obj, other)
+        expect(obj).toEqual { a: '1', b: '3', c: '4' }
+
+      it 'overrides (not merges) keys with object value', ->
+        obj = { a: '1', b: { c: '2', d: '3' } }
+        other = { e: '4', b: { f: '5', g: '6' }}
+        obj = up.util.merge(obj, other)
+        expect(obj).toEqual { a: '1', e: '4', b: { f: '5', g: '6' } }
+
+      it 'ignores undefined arguments', ->
+        obj = { a: 1, b: 2 }
+
+        result = up.util.merge(obj, undefined)
+        expect(result).toEqual { a: 1, b: 2 }
+
+        reverseResult = up.util.merge(undefined, obj)
+        expect(reverseResult).toEqual { a: 1, b: 2 }
+
+      it 'ignores null arguments', ->
+        obj = { a: 1, b: 2 }
+
+        result = up.util.merge(obj, null)
+        expect(result).toEqual { a: 1, b: 2 }
+
+        reverseResult = up.util.merge(null, obj)
+        expect(reverseResult).toEqual { a: 1, b: 2 }
+
+#    describe 'up.util.deepMerge', ->
+#
+#      it 'recursively merges the given objects', ->
+#        obj = { a: '1', b: { c: '2', d: '3' } }
+#        other = { e: '4', b: { f: '5', g: '6' }}
+#        obj = up.util.deepMerge(obj, other)
+#        expect(obj).toEqual { a: '1', e: '4', b: { c: '2', d: '3', f: '5', g: '6' } }
+#
+#      it 'ignores undefined arguments', ->
+#        obj = { a: 1, b: 2 }
+#
+#        result = up.util.deepMerge(obj, undefined)
+#        expect(result).toEqual { a: 1, b: 2 }
+#
+#        reverseResult = up.util.deepMerge(undefined, obj)
+#        expect(reverseResult).toEqual { a: 1, b: 2 }
+#
+#      it 'ignores null arguments', ->
+#        obj = { a: 1, b: 2 }
+#
+#        result = up.util.deepMerge(obj, null)
+#        expect(result).toEqual { a: 1, b: 2 }
+#
+#        reverseResult = up.util.deepMerge(null, obj)
+#        expect(reverseResult).toEqual { a: 1, b: 2 }
+#
+#      it 'overwrites (and does not concatenate) array values', ->
+#        obj = { a: ['1', '2'] }
+#        other = { a: ['3', '4'] }
+#        obj = up.util.deepMerge(obj, other)
+#        expect(obj).toEqual { a: ['3', '4'] }
+
     describe 'up.util.memoize', ->
 
       it 'returns a function that calls the memoized function', ->