unpoly-rails 0.61.1 → 2.0.0.pre.rc4

data/spec_app/spec/javascripts/helpers/wait_until_dom_ready.js.coffee

@@ -1,5 +0,0 @@
-u = up.util
-$ = jQuery
-
-beforeAll (done) ->
-  $(done)

data/spec_app/spec/javascripts/support/jasmine.yml

@@ -1,51 +0,0 @@
-# path to parent directory of src_files
-# relative path from Rails.root
-# defaults to app/assets/javascripts
-src_dir: "app/assets/javascripts"
-
-# path to additional directory of source file that are not part of assets pipeline and need to be included
-# relative path from Rails.root
-# defaults to []
-# include_dir:
-#   - ../mobile_app/public/js
-
-# path to parent directory of css_files
-# relative path from Rails.root
-# defaults to app/assets/stylesheets
-css_dir: "app/assets/stylesheets"
-
-# list of file expressions to include as source files
-# relative path from src_dir
-src_files:
- - "jasmine_specs.{js.coffee,js,coffee}"
-
-# list of file expressions to include as css files
-# relative path from css_dir
-css_files:
- - "jasmine_specs.{css.sass,css,sass}"
-
-# path to parent directory of spec_files
-# relative path from Rails.root
-#
-# Alternatively accept an array of directory to include external spec files
-# spec_dir:
-#   - spec/javascripts
-#   - ../engine/spec/javascripts
-#
-# defaults to spec/javascripts
-spec_dir: spec/javascripts
-
-# list of file expressions to include as helpers into spec runner
-# relative path from spec_dir
-helpers:
-  - "helpers/**/*.{js.coffee,js,coffee}"
-
-# list of file expressions to include as specs into spec runner
-# relative path from spec_dir
-spec_files:
-  - "**/*[Ss]pec.{js.coffee,js,coffee}"
-
-# path to directory of temporary files
-# (spec runner and asset cache)
-# defaults to tmp/jasmine
-tmp_dir: "tmp/jasmine"

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

@@ -1,150 +0,0 @@
-u = up.util
-$ = jQuery
-
-describe 'up.browser', ->
-
-  describe 'JavaScript functions', ->
-
-    describe 'up.browser.navigate', ->
-
-      afterEach ->
-        # We're preventing the form to be submitted during tests,
-        # so we need to remove it manually after each example.
-        $('form.up-page-loader').remove()
-
-      describe "for GET requests", ->
-
-        it "creates a GET form, adds all { params } as hidden fields and submits the form", ->
-          submitForm = spyOn(up.browser, 'submitForm')
-          up.browser.navigate('/foo', method: 'GET', params: { param1: 'param1 value', param2: 'param2 value' })
-          expect(submitForm).toHaveBeenCalled()
-
-          $form = $('form.up-page-loader')
-
-          expect($form).toBeAttached()
-          # GET forms cannot have an URL with a query section in their [action] attribute.
-          # The query section would be overridden by the serialized input values on submission.
-          expect($form.attr('action')).toMatchUrl('/foo')
-
-          expect($form.find('input[name="param1"][value="param1 value"]')).toBeAttached()
-          expect($form.find('input[name="param2"][value="param2 value"]')).toBeAttached()
-
-        it 'merges params from the given URL and the { params } option', ->
-          submitForm = spyOn(up.browser, 'submitForm')
-          up.browser.navigate('/foo?param1=param1%20value', method: 'GET', params: { param2: 'param2 value' })
-          expect(submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          expect($form).toBeAttached()
-          # GET forms cannot have an URL with a query section in their [action] attribute.
-          # The query section would be overridden by the serialized input values on submission.
-          expect($form.attr('action')).toMatchUrl('/foo')
-          expect($form.find('input[name="param1"][value="param1 value"]')).toBeAttached()
-          expect($form.find('input[name="param2"][value="param2 value"]')).toBeAttached()
-
-      describe "for POST requests", ->
-
-        it "creates a POST form, adds all { params } params as hidden fields and submits the form", ->
-          submitForm = spyOn(up.browser, 'submitForm')
-          up.browser.navigate('/foo', method: 'POST', params: { param1: 'param1 value', param2: 'param2 value' })
-          expect(submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          expect($form).toBeAttached()
-          expect($form.attr('action')).toMatchUrl('/foo')
-          expect($form.attr('method')).toEqual('POST')
-          expect($form.find('input[name="param1"][value="param1 value"]')).toBeAttached()
-          expect($form.find('input[name="param2"][value="param2 value"]')).toBeAttached()
-
-        it 'merges params from the given URL and the { params } option', ->
-          submitForm = spyOn(up.browser, 'submitForm')
-          up.browser.navigate('/foo?param1=param1%20value', method: 'POST', params: { param2: 'param2 value' })
-          expect(submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          expect($form).toBeAttached()
-          expect($form.attr('action')).toMatchUrl('/foo')
-          expect($form.attr('method')).toEqual('POST')
-          expect($form.find('input[name="param1"][value="param1 value"]')).toBeAttached()
-          expect($form.find('input[name="param2"][value="param2 value"]')).toBeAttached()
-
-      u.each ['PUT', 'PATCH', 'DELETE'], (method) ->
-
-        describe "for #{method} requests", ->
-
-          it "uses a POST form and sends the actual method as a { _method } param", ->
-            submitForm = spyOn(up.browser, 'submitForm')
-            up.browser.navigate('/foo', method: method)
-            expect(submitForm).toHaveBeenCalled()
-            $form = $('form.up-page-loader')
-            expect($form).toBeAttached()
-            expect($form.attr('method')).toEqual('POST')
-            expect($form.find('input[name="_method"]').val()).toEqual(method)
-
-      describe 'CSRF', ->
-
-        beforeEach ->
-          up.protocol.config.csrfToken = -> 'csrf-token'
-          up.protocol.config.csrfParam = -> 'csrf-param'
-          @submitForm = spyOn(up.browser, 'submitForm')
-
-        it 'submits an CSRF token as another hidden field', ->
-          up.browser.navigate('/foo', method: 'post')
-          expect(@submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          $tokenInput = $form.find('input[name="csrf-param"]')
-          expect($tokenInput).toBeAttached()
-          expect($tokenInput.val()).toEqual('csrf-token')
-
-        it 'does not add a CSRF token if there is none', ->
-          up.protocol.config.csrfToken = -> ''
-          up.browser.navigate('/foo', method: 'post')
-          expect(@submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          $tokenInput = $form.find('input[name="csrf-param"]')
-          expect($tokenInput).not.toBeAttached()
-
-        it 'does not add a CSRF token for GET requests', ->
-          up.browser.navigate('/foo', method: 'get')
-          expect(@submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          $tokenInput = $form.find('input[name="csrf-param"]')
-          expect($tokenInput).not.toBeAttached()
-
-        it 'does not add a CSRF token when loading content from another domain', ->
-          up.browser.navigate('http://other-domain.tld/foo', method: 'get')
-          expect(@submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          $tokenInput = $form.find('input[name="csrf-param"]')
-          expect($tokenInput).not.toBeAttached()
-
-    describe 'up.browser.whenConfirmed', ->
-
-      it 'shows a confirmation dialog with the given message and fulfills when the user presses OK', (done) ->
-        spyOn(window, 'confirm').and.returnValue(true)
-        promise = up.browser.whenConfirmed(confirm: 'Do action?')
-        promiseState(promise).then (result) ->
-          expect(window.confirm).toHaveBeenCalledWith('Do action?')
-          expect(result.state).toEqual('fulfilled')
-          done()
-
-      it 'emits the event and rejects the returned promise when any listener calls event.preventDefault()', (done) ->
-        spyOn(window, 'confirm').and.returnValue(false)
-        promise = up.browser.whenConfirmed(confirm: 'Do action?')
-        promiseState(promise).then (result) ->
-          expect(window.confirm).toHaveBeenCalledWith('Do action?')
-          expect(result.state).toEqual('rejected')
-          done()
-
-      it 'does now show a conformation dialog and fulfills if no { confirm } option is given', (done) ->
-        spyOn(window, 'confirm')
-        promise = up.browser.whenConfirmed({})
-        promiseState(promise).then (result) ->
-          expect(window.confirm).not.toHaveBeenCalled()
-          expect(result.state).toEqual('fulfilled')
-          done()
-
-      it "does now show a conformation dialog and fulfills if a { confirm } option is given but we're also preloading", (done) ->
-        spyOn(window, 'confirm')
-        promise = up.browser.whenConfirmed(confirm: 'Do action?', preload: true)
-        promiseState(promise).then (result) ->
-          expect(window.confirm).not.toHaveBeenCalled()
-          expect(result.state).toEqual('fulfilled')
-          done()

data/spec_app/spec/javascripts/up/classes/cache_spec.js.coffee

@@ -1,82 +0,0 @@
-u = up.util
-$ = jQuery
-
-describe 'up.Cache', ->
-
-  describe '#get', ->
-
-    it 'returns an item that was previously set', ->
-      store = new up.Cache()
-      store.set('foo', 'value of foo')
-      store.set('bar', 'value of bar')
-
-      expect(store.get('foo')).toEqual('value of foo')
-      expect(store.get('bar')).toEqual('value of bar')
-
-    it 'returns undefined if no item with that key was set', ->
-      store = new up.Cache()
-      store.set('foo', 'value of foo')
-
-      expect(store.get('bar')).toBeUndefined()
-
-    it 'returns undefined if the item has expired', ->
-      jasmine.clock().install()
-      jasmine.clock().mockDate(new Date())
-
-      store = new up.Cache(expiry: 100, logPrefix: 'cache')
-      store.set('foo', 'value of foo')
-
-      jasmine.clock().tick(80)
-      expect(store.get('foo')).toEqual('value of foo')
-
-      jasmine.clock().tick(40)
-      expect(store.get('foo')).toBeUndefined()
-
-  describe '#set', ->
-
-    it 'removes the oldest item if setting a new item would exceed the cache size', ->
-      jasmine.clock().install()
-      store = new up.Cache(size: 2, logPrefix: 'cache')
-
-      store.set('foo', 'value of foo')
-      jasmine.clock().tick(10)
-      store.set('bar', 'value of bar')
-      jasmine.clock().tick(10)
-      store.set('baz', 'value of baz')
-
-      expect(store.get('foo')).toBeUndefined()
-      expect(store.get('bar')).toEqual('value of bar')
-      expect(store.get('baz')).toEqual('value of baz')
-
-  describe '#keys', ->
-
-    it 'returns an array of keys in the store', ->
-      store = new up.Cache()
-      store.set('foo', 'value of foo')
-      store.set('bar', 'value of bar')
-
-      expect(store.keys().sort()).toEqual ['bar', 'foo']
-
-  describe '#clear', ->
-
-    it 'removes all keys from the store', ->
-      store = new up.Cache()
-      store.set('foo', 'value of foo')
-      store.set('bar', 'value of bar')
-
-      store.clear()
-
-      expect(store.get('foo')).toBeUndefined()
-      expect(store.get('bar')).toBeUndefined()
-
-  describe '#remove', ->
-
-    it 'removes the given key from the store', ->
-      store = new up.Cache()
-      store.set('foo', 'value of foo')
-      store.set('bar', 'value of bar')
-
-      store.remove('foo')
-
-      expect(store.get('foo')).toBeUndefined()
-      expect(store.get('bar')).toEqual('value of bar')

data/spec_app/spec/javascripts/up/classes/config_spec.coffee

@@ -1,24 +0,0 @@
-describe 'up.Config', ->
-
-  describe 'constructor', ->
-
-    it 'creates an object with the given attributes', ->
-      object = new up.Config(a: 1, b: 2)
-      expect(object.a).toBe(1)
-      expect(object.b).toBe(2)
-
-  describe '#reset', ->
-
-    it 'resets the object to its original state', ->
-      object = new up.Config(a: 1)
-      expect(object.b).toBeUndefined()
-      object.a = 2
-      expect(object.a).toBe(2)
-      object.reset()
-      expect(object.a).toBe(1)
-
-    it 'does not remove the #reset or #update method from the object', ->
-      object = new up.Config(a: 1)
-      object.b = 2
-      object.reset()
-      expect(object.reset).toBeDefined()

data/spec_app/spec/javascripts/up/classes/divertible_chain_spec.coffee

@@ -1,45 +0,0 @@
-u = up.util
-
-describe 'up.DivertibleChain', ->
-
-  describe '#asap', ->
-
-    it "cancels all unstarted tasks, waits for the current task and starts the given task", (done) ->
-      chain = new up.DivertibleChain()
-
-      timer1Spy = jasmine.createSpy('timer1')
-      timer1 = ->
-        timer1Spy()
-        up.specUtil.promiseTimer(100) # delay execution of next timer
-
-      timer2Spy = jasmine.createSpy('timer2')
-      timer2 = ->
-        timer2Spy()
-        up.specUtil.promiseTimer(100) # delay execution of next timer
-
-      timer3Spy = jasmine.createSpy('timer3')
-      timer3 = ->
-        timer3Spy()
-        up.specUtil.promiseTimer(100) # delay execution of next timer
-
-      timer4Spy = jasmine.createSpy('timer4')
-      timer4 = ->
-        timer4Spy()
-        up.specUtil.promiseTimer(100) # delay execution of next timer
-
-      chain.asap(timer1)
-      u.task ->
-        expect(timer1Spy).toHaveBeenCalled()
-        chain.asap(timer2)
-        u.task ->
-          # timer2 is still waiting for timer1 to finish
-          expect(timer2Spy).not.toHaveBeenCalled()
-          # Override the (2..n)th tasks. This unschedules timer2.
-          chain.asap(timer3, timer4)
-          u.timer 150, ->
-            expect(timer2Spy).not.toHaveBeenCalled() # Has been canceled
-            expect(timer3Spy).toHaveBeenCalled() # timer3 overrode timer2
-            expect(timer4Spy).not.toHaveBeenCalled()
-            u.timer 150, ->
-              expect(timer4Spy).toHaveBeenCalled()
-              done()

data/spec_app/spec/javascripts/up/classes/focus_tracker_spec.coffee

@@ -1,34 +0,0 @@
-#u = up.util
-#$ = jQuery
-#
-#describe 'up.FocusTracker', ->
-#
-#  describe '#lastField', ->
-#
-#    it 'returns undefined if no field is focused', ->
-#      tracker = new up.FocusTracker()
-#      expect(tracker.lastField()).toBeUndefined()
-#
-#    it 'returns a <input type="text"> after it was focused', ->
-#      tracker = new up.FocusTracker()
-#      $form = $fixture('form')
-#      $input = $form.affix('input[type=text]')
-#      $input.focus()
-#      expect(tracker.lastField()).toEqual($input[0])
-#
-#    it 'returns a <select> after it was focused', ->
-#      tracker = new up.FocusTracker()
-#      $form = $fixture('form')
-#      $select = $form.affix('select')
-#      $option = $select.affix('option')
-#      $select.focus()
-#      expect(tracker.lastField()).toEqual($select[0])
-#
-#    it 'returns the field that was most recently focused after a series of focus/blur'
-#
-#    it 'returns undefined after a field was focused, but then detached'
-#
-#    it 'returns a previously focused field for some time after it was blurred, so we can retrieve the last field after the user submits'
-#
-#    it 'returns undefined after a field was blurred and some time has passed'
-#

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

@@ -1,557 +0,0 @@
-u = up.util
-$ = jQuery
-
-describe 'up.Params', ->
-
-  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)
-
-  toObject = (value) -> new up.Params(value).toObject()
-  toQuery = (value) -> new up.Params(value).toQuery()
-  toArray = (value) -> new up.Params(value).toArray()
-  toFormData = (value) -> new up.Params(value).toFormData()
-
-  describe '#toQuery', ->
-
-    encodedSpace = '%20'
-
-    it 'returns the query section for the given object', ->
-      string = 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 = 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 = toQuery('foo=bar')
-      expect(string).toEqual('foo=bar')
-
-    it 'returns an empty string for an empty object', ->
-      string = toQuery({})
-      expect(string).toEqual('')
-
-    it 'returns an empty string for an empty string', ->
-      string = toQuery('')
-      expect(string).toEqual('')
-
-    it 'returns an empty string for undefined', ->
-      string = toQuery(undefined)
-      expect(string).toEqual('')
-
-    it 'URL-encodes characters in the key and value', ->
-      string = 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 = 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 = toQuery(string: 'foo', blob: blob)
-      expect(string).toEqual('string=foo')
-
-    it "omits an equal sign if a key's value is null", ->
-      string = toQuery({'foo': null})
-      expect(string).toEqual('foo')
-
-    it 'URL-encodes plus characters', ->
-      string = 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 = toQuery(fd)
-#        expect(string).toEqual('key1=value1&key2=value2')
-
-  describe '#toArray', ->
-
-    it 'normalized null to an empty array', ->
-      array = toArray(null)
-      expect(array).toEqual([])
-
-    it 'normalized undefined to an empty array', ->
-      array = toArray(undefined)
-      expect(array).toEqual([])
-
-    it 'normalizes an object hash to an array of objects with { name } and { value } keys', ->
-      array = 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 'builds multiple entries if the given object has array values', ->
-      array = toArray(
-        foo: ['1', '2']
-        bar: '3'
-      )
-      expect(array).toEqual([
-        { name: 'foo', value: '1' },
-        { name: 'foo', value: '2' },
-        { name: 'bar', value: '3' },
-      ])
-
-    it 'returns a given array without modification', ->
-      array = 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 = toArray(
-        'äpfel': 'bäume'
-      )
-      expect(array).toEqual([
-        { name: 'äpfel', value: 'bäume' },
-      ])
-
-    it 'does not URL-encode spaces in keys or values', ->
-      array = 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 = 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 = 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 = toArray(fd)
-#        expect(array).toEqual([
-#          { name: 'key1', value: 'value1' },
-#          { name: 'key2', value: 'value2' },
-#        ])
-
-
-  describe '#toFormData', ->
-
-    describeCapability 'canInspectFormData', ->
-
-      it 'converts undefined to an empty FormData object', ->
-        params = undefined
-        formData = toFormData(params)
-        expect(toArray(formData)).toEqual []
-
-      it 'converts null to an empty FormData object', ->
-        params = null
-        formData = toFormData(params)
-        expect(toArray(formData)).toEqual []
-
-      it 'converts an object to a FormData object', ->
-        params = {
-          key1: 'value1',
-          key2: 'value2'
-        }
-        formData = toFormData(params)
-        expect(toArray(formData)).toEqual [
-          { name: 'key1', value: 'value1' },
-          { name: 'key2', value: 'value2' },
-        ]
-
-      it 'returns a FormData with the same values', ->
-        input = new FormData()
-        input.append('foo', 'bar')
-
-        formData = toFormData(input)
-        expect(formData.get('foo')).toEqual('bar')
-
-      it 'converts a query string to a FormData object', ->
-        params = 'key1=value1&key2=value2'
-        formData = toFormData(params)
-        expect(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 = toFormData(params)
-        expect(toArray(formData)).toEqual [
-          { name: 'my key', value: 'my value' }
-        ]
-
-
-  describe '#toObject', ->
-
-    it "parses a query string of flat key/value pairs", ->
-      expect(toObject("xfoo")).toEqual("xfoo": null)
-      expect(toObject("foo=")).toEqual("foo": "")
-      expect(toObject("foo=bar")).toEqual("foo": "bar")
-      expect(toObject("foo=\"bar\"")).toEqual("foo": "\"bar\"")
-
-      expect(toObject("foo=bar&foo=quux")).toEqual("foo": "quux")
-      expect(toObject("foo&foo=")).toEqual("foo": "")
-      expect(toObject("foo=1&bar=2")).toEqual("foo": "1", "bar": "2")
-      expect(toObject("&foo=1&&bar=2")).toEqual("foo": "1", "bar": "2")
-      expect(toObject("foo&bar=")).toEqual("foo": null, "bar": "")
-      expect(toObject("foo=bar&baz=")).toEqual("foo": "bar", "baz": "")
-
-    it 'URL-decodes keys and values', ->
-      expect(toObject("my%20weird%20field=q1%212%22%27w%245%267%2Fz8%29%3F")).toEqual("my weird field": "q1!2\"'w$5&7/z8)?")
-      expect(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 'keeps the last value if the same key appears multiple time in the input', ->
-      expect(toObject("foo=1&bar=2&foo=3")).toEqual("foo": "3", "bar": "2")
-
-    it 'builds an array value if the key ends in "[]"', ->
-      expect(toObject("foo[]=1&bar=2&foo[]=3")).toEqual("foo[]": ["1", "3"], "bar": "2")
-
-    it 'ignores keys that would overwrite an Object prototype property', ->
-      obj = toObject("foo=bar&hasOwnProperty=baz")
-      expect(obj['foo']).toEqual('bar')
-      expect(u.isFunction obj['hasOwnProperty']).toBe(true)
-
-  describe '#add', ->
-
-    it 'adds a single key and value', ->
-      params = new up.Params(foo: 'one')
-      params.add('bar', 'two')
-      expect(params.toObject()).toEqual { foo: 'one', bar: 'two' }
-
-    it 'stores multiple entries with the same name', ->
-      params = new up.Params(foo: 'one')
-      params.add('foo', 'two')
-      expect(params.toArray()).toEqual [
-        { name: 'foo', value: 'one' },
-        { name: 'foo', value: 'two' }
-      ]
-
-  describe '#get', ->
-
-    describe '(with object)', ->
-
-      it 'returns the value for the given name', ->
-        params = new up.Params(foo: 'one', bar: 'two')
-        value = params.get('bar')
-        expect(value).toEqual('two')
-
-      it 'returns undefined if no value is set for the given name', ->
-        params = new up.Params(foo: 'one')
-        value = params.get('bar')
-        expect(value).toBeUndefined()
-
-      it 'returns undefined for names that are also a basic object property', ->
-        params = new up.Params({})
-        value = params.get('hasOwnProperty')
-        expect(value).toBeUndefined()
-
-      it 'returns the first matching entries if there are are multiple entries with the same name', ->
-        params = new up.Params('foo=one&foo=two')
-        value = params.get('foo')
-        expect(value).toEqual('one')
-
-  describe '#getAll', ->
-
-    it 'returns all entries with the given name'
-
-  describe '#delete', ->
-
-    it 'deletes all entries with the given name'
-
-  describe '#set', ->
-
-    it 'adds an entry with the given name and value'
-
-    it 'deletes any previous entries with the same name'
-
-    describe '#toURL', ->
-
-    it 'composes a URL from a base URL (without query section) and a query section', ->
-      base = 'http://foo.bar/path'
-      params = new up.Params('key=value')
-      expect(params.toURL(base)).toEqual('http://foo.bar/path?key=value')
-
-    it 'accepts other forms of params (instead of query sections)', ->
-      base = 'http://foo.bar/path'
-      params = new up.Params(key: 'value')
-      expect(params.toURL(base)).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 = new up.Params(key2: 'value2')
-      expect(params.toURL(base)).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 = new up.Params([])
-      expect(params.toURL(base)).toEqual('http://foo.bar/path')
-
-  describe '.fromURL', ->
-
-    it 'parses the query section from an URL, without leading question mark', ->
-      url = 'http://foo.bar/path?key=value'
-      params = up.Params.fromURL(url)
-      expect(params.toQuery()).toEqual('key=value')
-
-    it 'parses no params if the URL has no query section', ->
-      url = 'http://foo.bar/path'
-      params = up.Params.fromURL(url)
-      expect(params.toArray()).toEqual([])
-
-  describe '.fromForm', ->
-
-    it 'serializes a form with multiple inputs', ->
-      $form = $fixture('form')
-      $form.append('<input name="key1" value="value1">')
-      $form.append('<input name="key2" value="value2">')
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual [
-        { name: 'key1', value: 'value1' },
-        { name: 'key2', value: 'value2' },
-      ]
-
-    it 'serializes an <input type="text"> with its default [value]', ->
-      $form = $fixture('form')
-      $form.append('<input type="text" name="key" value="value-from-attribute">')
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual [
-        { name: 'key', value: 'value-from-attribute' }
-      ]
-
-    it 'serializes an <input type="text"> that had its value property changed by a script', ->
-      $form = $fixture('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.toArray()).toEqual [
-        { name: 'key', value: 'value-from-script' }
-      ]
-
-    it 'serializes an <input type="hidden"> with its default [value]', ->
-      $form = $fixture('form')
-      $form.append('<input type="hidden" name="key" value="value-from-attribute">')
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual [
-        { name: 'key', value: 'value-from-attribute' }
-      ]
-
-    it 'serializes an <input type="hidden"> that had its value property changed by a script', ->
-      $form = $fixture('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.toArray()).toEqual [
-        { name: 'key', value: 'value-from-script' }
-      ]
-
-    it 'seralizes a <select> with its default selected option', ->
-      $form = $fixture('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.toArray()).toEqual [
-        { name: 'key', value: 'value2' }
-      ]
-
-    it 'seralizes a <select> that had its selection changed by a script', ->
-      $form = $fixture('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.toArray()).toEqual [
-        { name: 'key', value: 'value3' }
-      ]
-
-    it 'serializes a <select multiple> with multiple selected options into multiple params', ->
-      $form = $fixture('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.toArray()).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 = $fixture('form')
-      $input = $('<input type="checkbox" name="key" value="value" checked>').appendTo($form)
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual [
-        { name: 'key', value: 'value' }
-      ]
-
-    it 'includes an <input type="checkbox"> that was checked by a script', ->
-      $form = $fixture('form')
-      $input = $('<input type="checkbox" name="key" value="value">').appendTo($form)
-      $input[0].checked = true
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual [
-        { name: 'key', value: 'value' }
-      ]
-
-    it 'excludes an <input type="checkbox"> that is unchecked', ->
-      $form = $fixture('form')
-      $input = $('<input type="checkbox" name="key" value="value">').appendTo($form)
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual []
-
-    it 'includes a checked <input type="radio"> in a radio button group that was [checked] by default', ->
-      $form = $fixture('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.toArray()).toEqual [
-        { name: 'key', value: 'value2' }
-      ]
-
-    it 'includes a checked <input type="radio"> in a radio button group that was checked by a script', ->
-      $form = $fixture('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.toArray()).toEqual [
-        { name: 'key', value: 'value3' }
-      ]
-
-    it 'excludes an radio button group if no button is selected', ->
-      $form = $fixture('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.toArray()).toEqual []
-
-    it 'excludes an <input> that is [disabled] by default', ->
-      $form = $fixture('form')
-      $input = $('<input type="text" name="key" value="value" disabled>').appendTo($form)
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual []
-
-    it 'excludes an <input> that was disabled by a script', ->
-      $form = $fixture('form')
-      $input = $('<input type="text" name="key" value="value">').appendTo($form)
-      $input[0].disabled = true
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual []
-
-    it 'excludes an <input> without a [name] attribute', ->
-      $form = $fixture('form')
-      $input = $('<input type="text" value="value">').appendTo($form)
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual []
-
-    it 'includes an <input readonly>', ->
-      $form = $fixture('form')
-      $input = $('<input type="text" name="key" value="value" readonly>').appendTo($form)
-
-      params = up.Params.fromForm($form)
-      expect(params.toArray()).toEqual [
-        { name: 'key', value: 'value' }
-      ]
-
-    it 'includes the focused submit button', ->
-      $form = $fixture('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.toArray()).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 = $fixture('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.toArray()).toEqual [
-        { name: 'input-key', value: 'input-value' },
-        { name: 'submit1-key', value: 'submit1-value' }
-      ]
-
-    it 'excludes a submit button without a [name] attribute', ->
-      $form = $fixture('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.toArray()).toEqual [
-        { name: 'input-key', value: 'input-value' }
-      ]
-
-