unpoly-rails 0.57.0 → 0.60.0

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

@@ -0,0 +1,37 @@
+u = up.util
+$ = jQuery
+
+describe 'up.toast', ->
+
+  describe 'JavaScript functions', ->
+
+    describe 'up.toast.open()', ->
+
+      it 'opens a toast box with the given message', ->
+        up.toast.open('This is a message')
+        expect('.up-toast').toBeAttached()
+        expect($('.up-toast-message').text()).toContain('This is a message')
+
+      it 'opens a toast box with a close link', ->
+        up.toast.open('This is a message')
+        expect('.up-toast').toBeAttached()
+        $closeButton = $('.up-toast-action:contains("Close")')
+        expect($closeButton).toBeAttached()
+
+        Trigger.clickSequence($closeButton)
+
+        expect('.up-toast').not.toBeAttached()
+
+      it 'opens a toast box with the given custom action', ->
+        action =
+          label: 'Custom action'
+          callback: jasmine.createSpy('action callback')
+        up.toast.open('This is a message', { action })
+        $actionButton = $('.up-toast-action:contains("Custom action")')
+        expect($actionButton).toBeAttached()
+        expect(action.callback).not.toHaveBeenCalled()
+
+        Trigger.clickSequence($actionButton)
+
+        expect(action.callback).toHaveBeenCalled()
+

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

@@ -1,36 +1,38 @@
-describe 'up.tooltip', ->
+u = up.util
+e = up.element
+$ = jQuery
 
-  u = up.util
+describe 'up.tooltip', ->
 
   describe 'JavaScript functions', ->
     
     describe 'up.tooltip.attach', ->
       
       it 'opens a tooltip with the given text', (done) ->
-        $link = affix('span')
+        $link = $fixture('span')
         up.tooltip.attach($link, html: 'tooltip text').then ->
           $tooltip = $('.up-tooltip')
           expect($tooltip).toHaveText('tooltip text')
           done()
 
       it 'allows HTML for the tooltip text when contents are given as { html } option', (done) ->
-        $link = affix('span')
+        $link = $fixture('span')
         up.tooltip.attach($link, html: '<b>text</b>').then ->
           $tooltip = $('.up-tooltip')
-          expect($tooltip.html()).toEqual('<b>text</b>')
+          expect($tooltip.html()).toContain('<b>text</b>')
           done()
 
       it 'escapes HTML for the tooltip text when contents given as { text } option', (done) ->
-        $link = affix('span')
+        $link = $fixture('span')
         up.tooltip.attach($link, text: '<b>text</b>').then ->
           $tooltip = $('.up-tooltip')
-          expect($tooltip.html()).toEqual('&lt;b&gt;text&lt;/b&gt;')
+          expect($tooltip.html()).toContain('&lt;b&gt;text&lt;/b&gt;')
           done()
 
       describe 'positioning', ->
 
         beforeEach ->
-          @$link = affix('span').text('button label')
+          @$link = $fixture('span').text('button label')
           @$link.css(
             position: 'absolute'
             left: '200px'
@@ -40,10 +42,12 @@ describe 'up.tooltip', ->
           )
 
         beforeEach ->
-          @restoreBodyHeight = u.writeTemporaryStyle('body', minHeight: '3000px')
+          @restoreBodyHeight = e.setTemporaryStyle(document.body, minHeight: '3000px')
 
         afterEach ->
           @restoreBodyHeight()
+          
+        distanceFromOrigin = 10
 
         describe 'with { position: "top" }', ->
 
@@ -52,8 +56,8 @@ describe 'up.tooltip', ->
             up.tooltip.attach(@$link, html: 'tooltip text', position: 'top').then =>
               $tooltip = $('.up-tooltip')
               tooltipBox = $tooltip.get(0).getBoundingClientRect()
-              expect(tooltipBox.top).toBeAround(@linkBox.top - tooltipBox.height, 15)
-              expect(tooltipBox.left).toBeAround(@linkBox.left + 0.5 * (@linkBox.width - tooltipBox.width), 15)
+              expect(tooltipBox.top).toBeAround(@linkBox.top - tooltipBox.height - distanceFromOrigin, 1)
+              expect(tooltipBox.left).toBeAround(@linkBox.left + 0.5 * (@linkBox.width - tooltipBox.width), 1)
               done()
 
         describe 'with { position: "right" }', ->
@@ -63,8 +67,8 @@ describe 'up.tooltip', ->
             up.tooltip.attach(@$link, html: 'tooltip text', position: 'right').then =>
               $tooltip = $('.up-tooltip')
               tooltipBox = $tooltip.get(0).getBoundingClientRect()
-              expect(tooltipBox.top).toBeAround(@linkBox.top + 0.5 * (@linkBox.height - tooltipBox.height), 15)
-              expect(tooltipBox.left).toBeAround(@linkBox.left + @linkBox.width, 15)
+              expect(tooltipBox.top).toBeAround(@linkBox.top + 0.5 * (@linkBox.height - tooltipBox.height), 1)
+              expect(tooltipBox.left).toBeAround(@linkBox.left + @linkBox.width + distanceFromOrigin, 1)
               done()
 
         describe 'with { position: "bottom" }', ->
@@ -74,8 +78,8 @@ describe 'up.tooltip', ->
             up.tooltip.attach(@$link, html: 'tooltip text', position: 'bottom').then =>
               $tooltip = $('.up-tooltip')
               tooltipBox = $tooltip.get(0).getBoundingClientRect()
-              expect(tooltipBox.top).toBeAround(@linkBox.top + @linkBox.height, 15)
-              expect(tooltipBox.left).toBeAround(@linkBox.left + 0.5 * (@linkBox.width - tooltipBox.width), 15)
+              expect(tooltipBox.top).toBeAround(@linkBox.top + @linkBox.height + distanceFromOrigin, 1)
+              expect(tooltipBox.left).toBeAround(@linkBox.left + 0.5 * (@linkBox.width - tooltipBox.width), 1)
               done()
 
         describe 'with { position: "left" }', ->
@@ -85,33 +89,13 @@ describe 'up.tooltip', ->
             up.tooltip.attach(@$link, html: 'tooltip text', position: 'left').then =>
               $tooltip = $('.up-tooltip')
               tooltipBox = $tooltip.get(0).getBoundingClientRect()
-              expect(tooltipBox.top).toBeAround(@linkBox.top + 0.5 * (@linkBox.height - tooltipBox.height), 15)
-              expect(tooltipBox.left).toBeAround(@linkBox.left - tooltipBox.width, 15)
+              expect(tooltipBox.top).toBeAround(@linkBox.top + 0.5 * (@linkBox.height - tooltipBox.height), 1)
+              expect(tooltipBox.left).toBeAround(@linkBox.left - tooltipBox.width - distanceFromOrigin, 1)
               done()
 
-        it 'gives the tooltip { position: "fixed" } if the given link is fixed', (done) ->
-          # Let's test the harder case where the document is scrolled
-          up.layout.scroll(document, 50)
-          @$link.css(position: 'fixed')
-          @linkBox = @$link.get(0).getBoundingClientRect()
-
-          up.tooltip.attach(@$link, html: 'tooltip text', position: 'top').then =>
-            $tooltip = $('.up-tooltip')
-            tooltipBox = $tooltip.get(0).getBoundingClientRect()
-            expect($tooltip.css('position')).toEqual('fixed')
-            expect(tooltipBox.top).toBeAround(@linkBox.top - tooltipBox.height, 15)
-            expect(tooltipBox.left).toBeAround(@linkBox.left + 0.5 * (@linkBox.width - tooltipBox.width), 15)
-            done()
-
-      it 'closes an existing tooltip'
-      
-      describe 'with position option', ->
-        
-        it 'anchors the tooltip at a different edge of the element'
-      
     describe 'up.tooltip.close', ->
 
-      it 'should have tests'
+      it 'closes an existing tooltip'
   
   describe 'unobtrusive behavior', ->
     
@@ -129,7 +113,7 @@ describe 'up.tooltip', ->
         up.motion.config.enabled = false
 
       it 'closes the tooltip', asyncSpec (next) ->
-        $link = affix('.link')
+        $link = $fixture('.link')
         up.tooltip.attach($link, text: 'Tooltip text')
 
         next =>
@@ -140,9 +124,9 @@ describe 'up.tooltip', ->
           expect(up.tooltip.isOpen()).toBe(false)
 
       it 'closes the tooltip when a an [up-instant] link removes its parent (and thus a click event never bubbles up to the document)', asyncSpec (next) ->
-        $parent = affix('.parent')
+        $parent = $fixture('.parent')
         $parentReplacingLink = $parent.affix('a[href="/foo"][up-target=".parent"][up-instant]')
-        $tooltipOpener = affix('.link')
+        $tooltipOpener = $fixture('.link')
         up.tooltip.attach($tooltipOpener, text: 'Tooltip text')
 
         next =>
@@ -153,9 +137,9 @@ describe 'up.tooltip', ->
           expect(up.tooltip.isOpen()).toBe(false)
 
       it 'closes a tooltip when the user clicks on an [up-target] link outside the tooltip', asyncSpec (next) ->
-        $target = affix('.target')
-        $outsideLink = affix('a[href="/foo"][up-target=".target"]')
-        $tooltipOpener = affix('.link')
+        $target = $fixture('.target')
+        $outsideLink = $fixture('a[href="/foo"][up-target=".target"]')
+        $tooltipOpener = $fixture('.link')
         up.tooltip.attach($tooltipOpener, text: 'Tooltip text')
 
         next =>
@@ -166,9 +150,9 @@ describe 'up.tooltip', ->
           expect(up.tooltip.isOpen()).toBe(false)
 
       it 'closes a tooltip when the user clicks on an [up-instant] link outside the tooltip', asyncSpec (next) ->
-        $target = affix('.target')
-        $outsideLink = affix('a[href="/foo"][up-target=".target"][up-instant]')
-        $tooltipOpener = affix('.link')
+        $target = $fixture('.target')
+        $outsideLink = $fixture('a[href="/foo"][up-target=".target"][up-instant]')
+        $tooltipOpener = $fixture('.link')
         up.tooltip.attach($tooltipOpener, text: 'Tooltip text')
 
         next =>

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

@@ -1,15 +1,321 @@
-describe 'up.util', ->
+u = up.util
+e = up.element
+$ = jQuery
 
-  u = up.util
+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.isEqual', ->
+
+      describe 'for an Element', ->
+
+        it 'returns true for the same Element reference', ->
+          div = document.createElement('div')
+          expect(up.util.isEqual(div, div)).toBe(true)
+
+        it 'returns false for a different Element reference', ->
+          div1 = document.createElement('div')
+          div2 = document.createElement('div')
+          expect(up.util.isEqual(div1, div2)).toBe(false)
+
+        it 'returns false for a value this is no Element', ->
+          div = document.createElement('div')
+          expect(up.util.isEqual(div, 'other')).toBe(false)
+
+      describe 'for an Array', ->
+
+        it 'returns true for a different Array reference with the same elements', ->
+          array1 = ['foo', 'bar']
+          array2 = ['foo', 'bar']
+          expect(up.util.isEqual(array1, array2)).toBe(true)
+
+        it 'returns false for an Array with different elements', ->
+          array1 = ['foo', 'bar']
+          array2 = ['foo', 'qux']
+          expect(up.util.isEqual(array1, array2)).toBe(false)
+
+        it 'returns false for an Array that is a suffix', ->
+          array1 = ['foo', 'bar']
+          array2 = [       'bar']
+          expect(up.util.isEqual(array1, array2)).toBe(false)
+
+        it 'returns false for an Array that is a prefix', ->
+          array1 = ['foo', 'bar']
+          array2 = ['foo'       ]
+          expect(up.util.isEqual(array1, array2)).toBe(false)
+
+        it 'returns true for a NodeList with the same elements', ->
+          parent = e.affix(document.body, '.parent')
+          child1 = e.affix(parent, '.child.one')
+          child2 = e.affix(parent, '.child.two')
+
+          array = [child1, child2]
+          nodeList = parent.querySelectorAll('.child')
+
+          expect(up.util.isEqual(array, nodeList)).toBe(true)
+
+        it 'returns true for a HTMLCollection with the same elements', ->
+          parent = e.affix(document.body, '.parent')
+          child1 = e.affix(parent, '.child.one')
+          child2 = e.affix(parent, '.child.two')
+
+          array = [child1, child2]
+          htmlCollection = parent.children
+
+          expect(up.util.isEqual(array, htmlCollection)).toBe(true)
+
+        it 'returns true for an arguments object with the same elements', ->
+          toArguments = -> return arguments
+          array = ['foo', 'bar']
+          args = toArguments('foo', 'bar')
+
+          expect(up.util.isEqual(array, args)).toBe(true)
+
+        it 'returns false for a value that is no Array', ->
+          array = ['foo', 'bar']
+          expect(up.util.isEqual(array, 'foobar')).toBe(false)
+
+      describe 'for a string', ->
+
+        it 'returns true for a different string reference with the same characters', ->
+          string1 = 'bar'
+          string2 = 'bar'
+          expect(up.util.isEqual(string1, string2)).toBe(true)
+
+        it 'returns false for a string with different characters', ->
+          string1 = 'foo'
+          string2 = 'bar'
+          expect(up.util.isEqual(string1, string2)).toBe(false)
+
+        it 'returns true for a String() object with the same characters', ->
+          stringLiteral = 'bar'
+          stringObject = new String('bar')
+          expect(up.util.isEqual(stringLiteral, stringObject)).toBe(true)
+
+        it 'returns false for a String() object with different characters', ->
+          stringLiteral = 'foo'
+          stringObject = new String('bar')
+          expect(up.util.isEqual(stringLiteral, stringObject)).toBe(false)
+
+        it 'returns false for a value that is no string', ->
+          expect(up.util.isEqual('foo', ['foo'])).toBe(false)
+
+      describe 'for a number', ->
+
+        it 'returns true for a different number reference with the same integer value', ->
+          number1 = 123
+          number2 = 123
+          expect(up.util.isEqual(number1, number2)).toBe(true)
+
+        it 'returns true for a different number reference with the same floating point value', ->
+          number1 = 123.4
+          number2 = 123.4
+          expect(up.util.isEqual(number1, number2)).toBe(true)
+
+        it 'returns false for a number with a different value', ->
+          number1 = 123
+          number2 = 124
+          expect(up.util.isEqual(number1, number2)).toBe(false)
+
+        it 'returns true for a Number() object with the same value', ->
+          numberLiteral = 123
+          numberObject = new Number(123)
+          expect(up.util.isEqual(numberLiteral, numberObject)).toBe(true)
+
+        it 'returns false for a Number() object with a different value', ->
+          numberLiteral = 123
+          numberObject = new Object(124)
+          expect(up.util.isEqual(numberLiteral, numberObject)).toBe(false)
+
+        it 'returns false for a value that is no number', ->
+          expect(up.util.isEqual(123, '123')).toBe(false)
+
+      describe 'for undefined', ->
+
+        it 'returns true for undefined', ->
+          expect(up.util.isEqual(undefined, undefined)).toBe(true)
+
+        it 'returns false for null', ->
+          expect(up.util.isEqual(undefined, null)).toBe(false)
+
+        it 'returns false for NaN', ->
+          expect(up.util.isEqual(undefined, NaN)).toBe(false)
+
+        it 'returns false for an empty Object', ->
+          expect(up.util.isEqual(undefined, {})).toBe(false)
+
+        it 'returns false for an empty string', ->
+          expect(up.util.isEqual(undefined, '')).toBe(false)
+
+      describe 'for null', ->
+
+        it 'returns true for null', ->
+          expect(up.util.isEqual(null, null)).toBe(true)
+
+        it 'returns false for undefined', ->
+          expect(up.util.isEqual(null, undefined)).toBe(false)
+
+        it 'returns false for NaN', ->
+          expect(up.util.isEqual(null, NaN)).toBe(false)
+
+        it 'returns false for an empty Object', ->
+          expect(up.util.isEqual(null, {})).toBe(false)
+
+        it 'returns false for an empty string', ->
+          expect(up.util.isEqual(null, '')).toBe(false)
+
+      describe 'for NaN', ->
+
+        it "returns false for NaN because it represents multiple values", ->
+          expect(up.util.isEqual(NaN, NaN)).toBe(false)
+
+        it 'returns false for null', ->
+          expect(up.util.isEqual(NaN, null)).toBe(false)
+
+        it 'returns false for undefined', ->
+          expect(up.util.isEqual(NaN, undefined)).toBe(false)
+
+        it 'returns false for an empty Object', ->
+          expect(up.util.isEqual(NaN, {})).toBe(false)
+
+        it 'returns false for an empty string', ->
+          expect(up.util.isEqual(NaN, '')).toBe(false)
+
+      describe 'for a Date', ->
+
+        it 'returns true for another Date object that points to the same millisecond', ->
+          d1 = new Date('1995-12-17T03:24:00')
+          d2 = new Date('1995-12-17T03:24:00')
+          expect(up.util.isEqual(d1, d2)).toBe(true)
+
+        it 'returns false for another Date object that points to another millisecond', ->
+          d1 = new Date('1995-12-17T03:24:00')
+          d2 = new Date('1995-12-17T03:24:01')
+          expect(up.util.isEqual(d1, d2)).toBe(false)
+
+        it 'returns true for another Date object that points to the same millisecond in another time zone', ->
+          d1 = new Date('2019-01-20T17:35:00+01:00')
+          d2 = new Date('2019-01-20T16:35:00+00:00')
+          expect(up.util.isEqual(d1, d2)).toBe(true)
+
+        it 'returns false for a value that is not a Date', ->
+          d1 = new Date('1995-12-17T03:24:00')
+          d2 = '1995-12-17T03:24:00'
+          expect(up.util.isEqual(d1, d2)).toBe(false)
+
+      describe 'for a plain Object', ->
+
+        it 'returns true for the same reference', ->
+          obj = {}
+          reference = obj
+          expect(up.util.isEqual(obj, reference)).toBe(true)
+
+        it 'returns true for another plain object with the same keys and values', ->
+          obj1 = { foo: 'bar', baz: 'bam' }
+          obj2 = { foo: 'bar', baz: 'bam' }
+          expect(up.util.isEqual(obj1, obj2)).toBe(true)
+
+        it 'returns false for another plain object with the same keys, but different values', ->
+          obj1 = { foo: 'bar', baz: 'bam' }
+          obj2 = { foo: 'bar', baz: 'qux' }
+          expect(up.util.isEqual(obj1, obj2)).toBe(false)
+
+        it 'returns false for another plain object that is missing a key', ->
+          obj1 = { foo: 'bar', baz: 'bam' }
+          obj2 = { foo: 'bar'             }
+          expect(up.util.isEqual(obj1, obj2)).toBe(false)
+
+        it 'returns false for another plain object that has an additional key', ->
+          obj1 = { foo: 'bar'             }
+          obj2 = { foo: 'bar', baz: 'bam' }
+          expect(up.util.isEqual(obj1, obj2)).toBe(false)
+
+        it 'returns false for a non-plain Object, even if it has the same keys and values', ->
+          class Account
+            constructor: (@email) ->
+
+          accountInstance = new Account('foo@example.com')
+          accountPlain = {}
+          for key, value of accountInstance
+            accountPlain[key] = value
+          expect(up.util.isEqual(accountPlain, accountInstance)).toBe(false)
+
+        it 'returns false for a value that is no object', ->
+          obj = { foo: 'bar' }
+          expect(up.util.isEqual(obj, 'foobar')).toBe(false)
+
+      describe 'for a non-Plain object', ->
+
+        it 'returns true for the same reference', ->
+          obj = new FormData()
+          reference = obj
+          expect(up.util.isEqual(obj, reference)).toBe(true)
+
+        it 'returns false for different references', ->
+          obj1 = new FormData()
+          obj2 = new FormData()
+          expect(up.util.isEqual(obj1, obj2)).toBe(false)
+
+        it 'returns false for a different object with the same keys and values', ->
+          class Account
+            constructor: (@email) ->
+
+          account1 = new Account('foo@example.com')
+          account2 = new Account('bar@example.com')
+
+          expect(up.util.isEqual(account1, account2)).toBe(false)
+
+        it 'allows the object to hook into the comparison protocol by implementing a method called `up.util.isEqual.key`', ->
+          class Account
+            constructor: (@email) ->
+            "#{up.util.isEqual.key}": (other) ->
+              @email == other.email
+
+          account1 = new Account('foo@example.com')
+          account2 = new Account('bar@example.com')
+          account3 = new Account('foo@example.com')
+
+          expect(up.util.isEqual(account1, account2)).toBe(false)
+          expect(up.util.isEqual(account1, account3)).toBe(true)
+
+        it 'returns false for a value that is no object', ->
+          class Account
+            constructor: (@email) ->
+
+          account = new Account('foo@example.com')
+
+          expect(up.util.isEqual(account, 'foo@example.com')).toBe(false)
+
+    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])
+
+      it 'builds an array from mixed function return values of scalar values and lists', ->
+        fun = (x) ->
+          if x == 1
+            1
+          else
+            [x, x]
+
+        result = up.util.flatMap([0, 1, 2], fun)
+        expect(result).toEqual [0, 0, 1, 2, 2]
+
+
+      it 'flattens return values that are NodeLists', ->
+        fun = (selector) -> document.querySelectorAll(selector)
+
+        foo1 = $fixture('.foo-element')[0]
+        foo2 = $fixture('.foo-element')[0]
+        bar = $fixture('.bar-element')[0]
+
+        result = up.util.flatMap(['.foo-element', '.bar-element'], fun)
+
+        expect(result).toEqual [foo1, foo2, bar]
+
 
     describe 'up.util.uniq', ->
 
@@ -92,6 +398,58 @@ describe 'up.util', ->
 #        path = up.util.parsePath('foo.bar[baz]["bam"][\'qux\']')
 #        expect(path).toEqual ['foo', 'bar', 'baz', 'bam', 'qux']
 
+    describe 'up.util.parseUrl', ->
+
+      it 'parses a full URL', ->
+        url = up.util.parseUrl('https://subdomain.domain.tld:123/path?search#hash')
+        expect(url.protocol).toEqual('https:')
+        expect(url.hostname).toEqual('subdomain.domain.tld')
+        expect(url.port).toEqual('123')
+        expect(url.pathname).toEqual('/path')
+        expect(url.search).toEqual('?search')
+        expect(url.hash).toEqual('#hash')
+
+      it 'parses an absolute path', ->
+        url = up.util.parseUrl('/qux/foo?search#bar')
+        expect(url.protocol).toEqual(location.protocol)
+        expect(url.hostname).toEqual(location.hostname)
+        expect(url.port).toEqual(location.port)
+        expect(url.pathname).toEqual('/qux/foo')
+        expect(url.search).toEqual('?search')
+        expect(url.hash).toEqual('#bar')
+
+      it 'parses a relative path', ->
+        up.history.config.enabled = true
+        up.history.replace('/qux/')
+        url = up.util.parseUrl('foo?search#bar')
+        expect(url.protocol).toEqual(location.protocol)
+        expect(url.hostname).toEqual(location.hostname)
+        expect(url.port).toEqual(location.port)
+        expect(url.pathname).toEqual('/qux/foo')
+        expect(url.search).toEqual('?search')
+        expect(url.hash).toEqual('#bar')
+
+      it 'allows to pass a link element', ->
+        link = document.createElement('a')
+        link.href = '/qux/foo?search#bar'
+        url = up.util.parseUrl(link)
+        expect(url.protocol).toEqual(location.protocol)
+        expect(url.hostname).toEqual(location.hostname)
+        expect(url.port).toEqual(location.port)
+        expect(url.pathname).toEqual('/qux/foo')
+        expect(url.search).toEqual('?search')
+        expect(url.hash).toEqual('#bar')
+
+      it 'allows to pass a link element as a jQuery collection', ->
+        $link = $('<a></a>').attr(href: '/qux/foo?search#bar')
+        url = up.util.parseUrl($link)
+        expect(url.protocol).toEqual(location.protocol)
+        expect(url.hostname).toEqual(location.hostname)
+        expect(url.port).toEqual(location.port)
+        expect(url.pathname).toEqual('/qux/foo')
+        expect(url.search).toEqual('?search')
+        expect(url.hash).toEqual('#bar')
+
     describe 'up.util.map', ->
 
       it 'creates a new array of values by calling the given function on each item of the given array', ->
@@ -109,9 +467,19 @@ describe 'up.util', ->
         mapped = up.util.map(array, (element, i) -> i)
         expect(mapped).toEqual [0, 1, 2]
 
+    describe 'up.util.mapObject', ->
+
+      it 'creates an object from the given array and pairer', ->
+        array = ['foo', 'bar', 'baz']
+        object = up.util.mapObject(array, (str) -> ["#{str}Key", "#{str}Value"])
+        expect(object).toEqual
+          fooKey: 'fooValue'
+          barKey: 'barValue'
+          bazKey: 'bazValue'
+
     describe 'up.util.each', ->
 
-      it 'calls the given function once for each itm of the given array', ->
+      it 'calls the given function once for each item of the given array', ->
         args = []
         array = ["apple", "orange", "cucumber"]
         up.util.each array, (item) -> args.push(item)
@@ -123,23 +491,43 @@ describe 'up.util', ->
         up.util.each array, (item, index) -> args.push(index)
         expect(args).toEqual [0, 1, 2]
 
-    describe 'up.util.select', ->
+      it 'iterates over an array-like value', ->
+        one = fixture('.qwertz')
+        two = fixture('.qwertz')
+        nodeList = document.querySelectorAll('.qwertz')
+
+        callback = jasmine.createSpy()
+
+        up.util.each nodeList, callback
+        expect(callback.calls.allArgs()).toEqual [[one, 0], [two, 1]]
+
+    describe 'up.util.filter', ->
 
       it 'returns an array of those elements in the given array for which the given function returns true', ->
         array = ["foo", "orange", "cucumber"]
-        results = up.util.select array, (item) -> item.length > 3
+        results = up.util.filter array, (item) -> item.length > 3
         expect(results).toEqual ['orange', 'cucumber']
 
       it 'passes the iteration index as second argument to the given function', ->
         array = ["apple", "orange", "cucumber", "banana"]
-        results = up.util.select array, (item, index) -> index % 2 == 0
+        results = up.util.filter array, (item, index) -> index % 2 == 0
         expect(results).toEqual ['apple', 'cucumber']
 
       it 'accepts a property name instead of a function, which checks that property from each item', ->
         array = [ { name: 'a', prop: false }, { name: 'b', prop: true } ]
-        results = up.util.select array, 'prop'
+        results = up.util.filter array, 'prop'
         expect(results).toEqual [{ name: 'b', prop: true }]
 
+      it 'iterates over an array-like value', ->
+        one = fixture('.qwertz')
+        two = fixture('.qwertz')
+        nodeList = document.querySelectorAll('.qwertz')
+
+        callback = jasmine.createSpy()
+
+        up.util.filter nodeList, callback
+        expect(callback.calls.allArgs()).toEqual [[one, 0], [two, 1]]
+
     describe 'up.util.reject', ->
 
       it 'returns an array of those elements in the given array for which the given function returns false', ->
@@ -157,6 +545,16 @@ describe 'up.util', ->
         results = up.util.reject array, 'prop'
         expect(results).toEqual [{ name: 'a', prop: false }]
 
+      it 'iterates over an array-like value', ->
+        one = fixture('.qwertz')
+        two = fixture('.qwertz')
+        nodeList = document.querySelectorAll('.qwertz')
+
+        callback = jasmine.createSpy()
+
+        up.util.reject nodeList, callback
+        expect(callback.calls.allArgs()).toEqual [[one, 0], [two, 1]]
+
     describe 'up.util.previewable', ->
 
       it 'wraps a function into a proxy function with an additional .promise attribute', ->
@@ -171,10 +569,10 @@ describe 'up.util', ->
         proxy = up.util.previewable(fun)
         callback = jasmine.createSpy('promise callback')
         proxy.promise.then(callback)
-        u.nextFrame ->
+        u.task ->
           expect(callback).not.toHaveBeenCalled()
           proxy()
-          u.nextFrame ->
+          u.task ->
             expect(callback).toHaveBeenCalledWith('return value')
             done()
 
@@ -185,141 +583,13 @@ describe 'up.util', ->
         callback = jasmine.createSpy('promise callback')
         proxy.promise.then(callback)
         proxy()
-        u.nextFrame ->
+        u.task ->
           expect(callback).not.toHaveBeenCalled()
           funDeferred.resolve('return value')
-          u.nextFrame ->
+          u.task ->
             expect(callback).toHaveBeenCalledWith('return value')
             done()
 
-    describe 'up.util.kebabCase', ->
-
-      it 'converts a string of multiple words from camel-case to kebap-case', ->
-        result = up.util.kebabCase('fooBarBaz')
-        expect(result).toEqual('foo-bar-baz')
-
-      it 'does not change a single word', ->
-        result = up.util.kebabCase('foo')
-        expect(result).toEqual('foo')
-
-      it 'downcases the first word when it starts with a capital letter', ->
-        result = up.util.kebabCase('FooBar')
-        expect(result).toEqual('foo-bar')
-
-      it 'does not change a string that is already in kebab-case', ->
-        result = up.util.kebabCase('foo-bar-baz')
-        expect(result).toEqual('foo-bar-baz')
-
-    describe 'up.util.camelCase', ->
-
-      it 'converts a string of multiple words from kebap-case to camel-case', ->
-        result = up.util.camelCase('foo-bar-baz')
-        expect(result).toEqual('fooBarBaz')
-
-      it 'does not change a single word', ->
-        result = up.util.camelCase('foo')
-        expect(result).toEqual('foo')
-
-      it 'downcases the first word when it starts with a capital letter', ->
-        result = up.util.camelCase('Foo-Bar')
-        expect(result).toEqual('fooBar')
-
-      it 'does not change a string that is already in camel-case', ->
-        result = up.util.camelCase('fooBarBaz')
-        expect(result).toEqual('fooBarBaz')
-
-    describe 'up.util.kebabCaseKeys', ->
-
-      it "converts the given object's keys from camel-case to kebab-case", ->
-        input =
-          fooBar: 'one'
-          barBaz: 'two'
-        result = up.util.kebabCaseKeys(input)
-        expect(result).toEqual
-          'foo-bar': 'one'
-          'bar-baz': 'two'
-
-      it "does not change an object whose keys are already kebab-case", ->
-        input =
-          'foo-bar': 'one'
-          'bar-baz': 'two'
-        result = up.util.kebabCaseKeys(input)
-        expect(result).toEqual
-          'foo-bar': 'one'
-          'bar-baz': 'two'
-
-    describe 'up.util.camelCaseKeys', ->
-
-      it "converts the given object's keys from kebab-case to camel-case", ->
-        input =
-          'foo-bar': 'one'
-          'bar-baz': 'two'
-        result = up.util.camelCaseKeys(input)
-        expect(result).toEqual
-          fooBar: 'one'
-          barBaz: 'two'
-
-      it "does not change an object whose keys are already camel-case", ->
-        input =
-          fooBar: 'one'
-          barBaz: 'two'
-        result = up.util.camelCaseKeys(input)
-        expect(result).toEqual
-          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) ->
-        chain = new up.util.DivertibleChain()
-
-        timer1Spy = jasmine.createSpy('timer1 has been called')
-        timer1 = ->
-          timer1Spy()
-          u.promiseTimer(50)
-
-        timer2Spy = jasmine.createSpy('timer2 has been called')
-        timer2 = ->
-          timer2Spy()
-          u.promiseTimer(50)
-
-        timer3Spy = jasmine.createSpy('timer3 has been called')
-        timer3 = ->
-          timer3Spy()
-          u.promiseTimer(50)
-
-        timer4Spy = jasmine.createSpy('timer4 has been called')
-        timer4 = ->
-          timer4Spy()
-          u.promiseTimer(50)
-
-        chain.asap(timer1)
-        u.nextFrame ->
-          expect(timer1Spy).toHaveBeenCalled()
-          chain.asap(timer2)
-          u.nextFrame ->
-            # 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.setTimer 80, ->
-              expect(timer2Spy).not.toHaveBeenCalled()
-              expect(timer3Spy).toHaveBeenCalled()
-              u.setTimer 70, ->
-                expect(timer4Spy).toHaveBeenCalled()
-                done()
-
     describe 'up.util.sequence', ->
 
       it 'combines the given functions into a single function', ->
@@ -327,128 +597,52 @@ describe 'up.util', ->
         one = -> values.push('one')
         two = -> values.push('two')
         three = -> values.push('three')
-        sequence = up.util.sequence(one, two, three)
+        sequence = up.util.sequence([one, two, three])
         expect(values).toEqual([])
         sequence()
         expect(values).toEqual(['one', 'two', 'three'])
 
-    describe 'up.util.createElementFromHtml', ->
-
-      it 'parses a string that contains a serialized HTML document', ->
-        string = """
-          <html lang="foo">
-            <head>
-              <title>document title</title>
-            </head>
-            <body data-env='production'>
-              <div>line 1</div>
-              <div>line 2</div>
-            </body>
-          </html>
-          """
-
-        element = up.util.createElementFromHtml(string)
-
-        expect(element.querySelector('head title').textContent).toEqual('document title')
-        expect(element.querySelector('body').getAttribute('data-env')).toEqual('production')
-        expect(element.querySelectorAll('body div').length).toBe(2)
-        expect(element.querySelectorAll('body div')[0].textContent).toEqual('line 1')
-        expect(element.querySelectorAll('body div')[1].textContent).toEqual('line 2')
-
-      it 'parses a string that contains carriage returns (bugfix)', ->
-        string = """
-          <html>\r
-            <body>\r
-              <div>line</div>\r
-            </body>\r
-          </html>\r
-          """
-
-        $element = up.util.createElementFromHtml(string)
-        expect($element.querySelector('body')).toBeGiven()
-        expect($element.querySelector('body div').textContent).toEqual('line')
-
-      it 'does not run forever if a page has a <head> without a <title> (bugfix)', ->
-        html = """
-          <!doctype html>
-          <html>
-            <head>
-              <meta charset="utf-8" />
-          <meta name="format-detection" content="telephone=no">
-          <link href='/images/favicon.png' rel='shortcut icon' type='image/png'>
-          <meta name='viewport' content='width=device-width, initial-scale=1, maximum-scale=1, minimum-scale=1'>
-
-              <base href="/examples/update-fragment/" />
-              <link href='http://fonts.googleapis.com/css?family=Orbitron:400|Ubuntu+Mono:400,700|Source+Sans+Pro:300,400,700,400italic,700italic' rel='stylesheet' type='text/css'>
-          <link href="//netdna.bootstrapcdn.com/font-awesome/4.1.0/css/font-awesome.min.css" rel="stylesheet">
-              <link href="/stylesheets/example/all.css" rel="stylesheet" />
-              <script src="/javascripts/example.js"></script>
-            </head>
-            <body>
-              <div class="page">
-                <div class="story">
-
-            <h1>Full story</h1>
-            <p>Lorem ipsum dolor sit amet.</p>
-
-            <a href="preview.html" up-target=".story">
-              Read summary
-            </a>
-          </div>
-
-              </div>
-            </body>
-          </html>
-          """
-        element = up.util.createElementFromHtml(html)
-        expect(element.querySelector("title")).toBeMissing()
-        expect(element.querySelector("h1").textContent).toEqual('Full story')
-
-      it 'can parse HTML without a <head>', ->
-        html = """
-          <html>
-            <body>
-              <h1>Full story</h1>
-            </body>
-          </html>
-          """
-        element = up.util.createElementFromHtml(html)
-        expect(element.querySelector("title")).toBeMissing()
-        expect(element.querySelector("h1").textContent).toEqual('Full story')
-
-      it 'can parse a HTML fragment without a <body>', ->
-        html = """
-          <h1>Full story</h1>
-          """
-        element = up.util.createElementFromHtml(html)
-        expect(element.querySelector("title")).toBeMissing()
-        expect(element.querySelector("h1").textContent).toEqual('Full story')
-
-    describe 'up.util.isFixed', ->
-
-      it 'returns true if the given element or one of its ancestors has a "fixed" CSS position', ->
-        $grandGrandParent = affix('.grand-parent')
-        $grandParent = $grandGrandParent.affix('.grand-parent')
-        $parent = $grandParent.affix('.parent')
-        $child = $parent.affix('.child')
-        $grandParent.css(position: 'fixed')
-        expect(up.util.isFixed($child)).toBe(true)
-        expect(up.util.isFixed($parent)).toBe(true)
-        expect(up.util.isFixed($grandParent)).toBe(true)
-        expect(up.util.isFixed($grandGrandParent)).toBe(false)
-
-      it 'returns false if the given element and its ancestors all have a non-"fixed" CSS position', ->
-        $element = affix('.element')
-        expect(up.util.isFixed($element)).toBe(false)
-
-    describe 'up.util.setTimer', ->
+    describe 'up.util.muteRejection', ->
+
+      it 'returns a promise that fulfills when the given promise fulfills', (done) ->
+        fulfilledPromise = Promise.resolve()
+        mutedPromise = up.util.muteRejection(fulfilledPromise)
+
+        u.task ->
+          promiseState(mutedPromise).then (result) ->
+            expect(result.state).toEqual('fulfilled')
+            done()
+
+      it 'returns a promise that fulfills when the given promise rejects', (done) ->
+        rejectedPromise = Promise.reject()
+        mutedPromise = up.util.muteRejection(rejectedPromise)
+
+        u.task ->
+          promiseState(mutedPromise).then (result) ->
+            expect(result.state).toEqual('fulfilled')
+            done()
+
+    describe 'up.util.simpleEase', ->
+
+      it 'returns 0 for 0', ->
+        expect(up.util.simpleEase(0)).toBe(0)
+
+      it 'returns 1 for 1', ->
+        expect(up.util.simpleEase(1)).toBe(1)
+
+      it 'returns steadily increasing values between 0 and 1', ->
+        expect(up.util.simpleEase(0.25)).toBeAround(0.25, 0.2)
+        expect(up.util.simpleEase(0.50)).toBeAround(0.50, 0.2)
+        expect(up.util.simpleEase(0.75)).toBeAround(0.75, 0.2)
+
+    describe 'up.util.timer', ->
 
       it 'calls the given function after waiting the given milliseconds', (done) ->
         callback = jasmine.createSpy()
         expectNotCalled = -> expect(callback).not.toHaveBeenCalled()
         expectCalled = -> expect(callback).toHaveBeenCalled()
 
-        up.util.setTimer(100, callback)
+        up.util.timer(100, callback)
 
         expectNotCalled()
         setTimeout(expectNotCalled, 50)
@@ -459,7 +653,7 @@ describe 'up.util', ->
 
         it 'calls the given function in the next execution frame', ->
           callback = jasmine.createSpy()
-          up.util.setTimer(0, callback)
+          up.util.timer(0, callback)
           expect(callback).not.toHaveBeenCalled()
 
           setTimeout((-> expect(callback).toHaveBeenCalled()), 0)
@@ -470,12 +664,6 @@ describe 'up.util', ->
 #        fun = ($element, data) ->
 #        expect(up.util.argNames(fun)).toEqual(['$element', 'data'])
 
-    describe 'up.util.trim', ->
-
-      it 'removes leading and trailing whitespace from the given string', ->
-        string = "\t\n\r abc \r\n\t"
-        expect(up.util.trim(string)).toEqual('abc')
-
     describe 'up.util.only', ->
 
       it 'returns a copy of the given object with only the given whitelisted properties', ->
@@ -502,91 +690,6 @@ describe 'up.util', ->
         expect(whitelisted).toHaveOwnProperty('foo')
         expect(whitelisted).not.toHaveOwnProperty('bar')
 
-    describe 'up.util.readInlineStyle', ->
-      
-      describe 'with a string as second argument', ->
-
-        it 'returns a CSS value string from an inline [style] attribute', ->
-          $div = affix('div').attr('style', 'background-color: #ff0000')
-          style = up.util.readInlineStyle($div, 'backgroundColor')
-          # Browsers convert colors to rgb() values, even IE11
-          expect(style).toEqual('rgb(255, 0, 0)')
-
-        it 'returns a blank value if the element does not have the given property in the [style] attribute', ->
-          $div = affix('div').attr('style', 'background-color: red')
-          style = up.util.readInlineStyle($div, 'color')
-          expect(style).toBeBlank()
-
-        it 'returns a blank value the given property is a computed property, but not in the [style] attribute', ->
-          $div = affix('div[class="red-background"]')
-          inlineStyle = up.util.readInlineStyle($div, 'backgroundColor')
-          computedStyle = up.util.readComputedStyle($div, 'backgroundColor')
-          expect(computedStyle).toEqual('rgb(255, 0, 0)')
-          expect(inlineStyle).toBeBlank()
-
-      describe 'with an array as second argument', ->
-
-        it 'returns an object with the given inline [style] properties', ->
-          $div = affix('div').attr('style', 'background-color: #ff0000; color: #0000ff')
-          style = up.util.readInlineStyle($div, ['backgroundColor', 'color'])
-          expect(style).toEqual
-            backgroundColor: 'rgb(255, 0, 0)'
-            color: 'rgb(0, 0, 255)'
-
-        it 'returns blank keys if the element does not have the given property in the [style] attribute', ->
-          $div = affix('div').attr('style', 'background-color: #ff0000')
-          style = up.util.readInlineStyle($div, ['backgroundColor', 'color'])
-          expect(style).toHaveOwnProperty('color')
-          expect(style.color).toBeBlank()
-
-        it 'returns a blank value the given property is a computed property, but not in the [style] attribute', ->
-          $div = affix('div[class="red-background"]')
-          inlineStyleHash = up.util.readInlineStyle($div, ['backgroundColor'])
-          computedBackground = up.util.readComputedStyle($div, 'backgroundColor')
-          expect(computedBackground).toEqual('rgb(255, 0, 0)')
-          expect(inlineStyleHash).toHaveOwnProperty('backgroundColor')
-          expect(inlineStyleHash.backgroundColor).toBeBlank()
-
-    describe 'up.util.writeInlineStyle', ->
-
-      it "sets the given style properties as the given element's [style] attribute", ->
-        $div = affix('div')
-        up.util.writeInlineStyle($div, { color: 'red', backgroundColor: 'blue' })
-        style = $div.attr('style')
-        expect(style).toContain('color: red')
-        expect(style).toContain('background-color: blue')
-
-      it "merges the given style properties into the given element's existing [style] value", ->
-        $div = affix('div[style="color: red"]')
-        up.util.writeInlineStyle($div, { backgroundColor: 'blue' })
-        style = $div.attr('style')
-        expect(style).toContain('color: red')
-        expect(style).toContain('background-color: blue')
-
-      it "converts the values of known length properties to px values automatically", ->
-        $div = affix('div')
-        up.util.writeInlineStyle($div, { paddingTop: 100 })
-        style = $div.attr('style')
-        expect(style).toContain('padding-top: 100px')
-
-    describe 'up.util.writeTemporaryStyle', ->
-
-      it "sets the given inline styles and returns a function that will restore the previous inline styles", ->
-        $div = affix('div[style="color: red"]')
-        restore = up.util.writeTemporaryStyle($div, { color: 'blue' })
-        expect($div.attr('style')).toContain('color: blue')
-        expect($div.attr('style')).not.toContain('color: red')
-        restore()
-        expect($div.attr('style')).not.toContain('color: blue')
-        expect($div.attr('style')).toContain('color: red')
-
-      it "does not restore inherited styles", ->
-        $div = affix('div[class="red-background"]')
-        restore = up.util.writeTemporaryStyle($div, { backgroundColor: 'blue' })
-        expect($div.attr('style')).toContain('background-color: blue')
-        restore()
-        expect($div.attr('style')).not.toContain('background-color')
-
     describe 'up.util.except', ->
 
       it 'returns a copy of the given object but omits the given blacklisted properties', ->
@@ -606,133 +709,19 @@ describe 'up.util', ->
           baz: 'baz-value'
           bam: 'bam-value'
 
-    describe 'up.util.selectorForElement', ->
-
-      it "prefers using the element's 'up-id' attribute to using the element's ID", ->
-        $element = affix('div[up-id=up-id-value]#id-value')
-        expect(up.util.selectorForElement($element)).toBe('[up-id="up-id-value"]')
-
-      it "prefers using the element's ID to using the element's name", ->
-        $element = affix('div#id-value[name=name-value]')
-        expect(up.util.selectorForElement($element)).toBe("#id-value")
-
-      it "selects the ID with an attribute selector if the ID contains a slash", ->
-        $element = affix('div').attr(id: 'foo/bar')
-        expect(up.util.selectorForElement($element)).toBe('[id="foo/bar"]')
-
-      it "selects the ID with an attribute selector if the ID contains a space", ->
-        $element = affix('div').attr(id: 'foo bar')
-        expect(up.util.selectorForElement($element)).toBe('[id="foo bar"]')
-
-      it "selects the ID with an attribute selector if the ID contains a dot", ->
-        $element = affix('div').attr(id: 'foo.bar')
-        expect(up.util.selectorForElement($element)).toBe('[id="foo.bar"]')
-
-      it "selects the ID with an attribute selector if the ID contains a quote", ->
-        $element = affix('div').attr(id: 'foo"bar')
-        expect(up.util.selectorForElement($element)).toBe('[id="foo\\"bar"]')
-
-      it "prefers using the element's tagName + [name] to using the element's classes", ->
-        $element = affix('input[name=name-value].class1.class2')
-        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[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", ->
-        $element = affix('div[aria-label="ARIA label value"]')
-        expect(up.util.selectorForElement($element)).toBe('[aria-label="ARIA label value"]')
-
-      it "uses the element's tag name if no better description is available", ->
-        $element = affix('div')
-        expect(up.util.selectorForElement($element)).toBe("div")
-
-      it 'escapes quotes in attribute selector values', ->
-        $element = affix('div')
-        $element.attr('aria-label', 'foo"bar')
-        expect(up.util.selectorForElement($element)).toBe('[aria-label="foo\\"bar"]')
-
-
-    describe 'up.util.addTemporaryClass', ->
-
-      it 'adds the given class to the given element', ->
-        $element = affix('.foo.bar')
-        element = $element.get(0)
-
-        expect(element.className).toEqual('foo bar')
-
-        up.util.addTemporaryClass(element, 'baz')
-
-        expect(element.className).toEqual('foo bar baz')
-
-      it 'returns a function that restores the original class', ->
-        $element = affix('.foo.bar')
-        element = $element.get(0)
-
-        restoreClass = up.util.addTemporaryClass(element, 'baz')
-        expect(element.className).toEqual('foo bar baz')
-
-        restoreClass()
-        expect(element.className).toEqual('foo bar')
-
-
-    describe 'up.util.castedAttr', ->
-
-      it 'returns true if the attribute value is the string "true"', ->
-        $element = affix('div').attr('foo', 'true')
-        expect(up.util.castedAttr($element, 'foo')).toBe(true)
-
-      it 'returns true if the attribute value is the name of the attribute', ->
-        $element = affix('div').attr('foo', 'foo')
-        expect(up.util.castedAttr($element, 'foo')).toBe(true)
-
-      it 'returns false if the attribute value is the string "false"', ->
-        $element = affix('div').attr('foo', 'false')
-        expect(up.util.castedAttr($element, 'foo')).toBe(false)
-
-      it 'returns undefined if the element has no such attribute', ->
-        $element = affix('div')
-        expect(up.util.castedAttr($element, 'foo')).toBe(undefined)
-
-      it 'returns the attribute value unchanged if the value is some string', ->
-        $element = affix('div').attr('foo', 'some text')
-        expect(up.util.castedAttr($element, 'foo')).toBe('some text')
-
-    describe 'up.util.any', ->
-
-      it 'returns true if an element in the array returns true for the given function', ->
-        result = up.util.any [null, undefined, 'foo', ''], up.util.isPresent
-        expect(result).toBe(true)
-
-      it 'returns false if no element in the array returns true for the given function', ->
-        result = up.util.any [null, undefined, ''], up.util.isPresent
-        expect(result).toBe(false)
-
-      it 'short-circuits once an element returns true', ->
-        count = 0
-        up.util.any [null, undefined, 'foo', ''], (element) ->
-          count += 1
-          up.util.isPresent(element)
-        expect(count).toBe(3)
-
-    describe 'up.util.all', ->
+    describe 'up.util.every', ->
 
       it 'returns true if all element in the array returns true for the given function', ->
-        result = up.util.all ['foo', 'bar', 'baz'], up.util.isPresent
+        result = up.util.every ['foo', 'bar', 'baz'], up.util.isPresent
         expect(result).toBe(true)
 
       it 'returns false if an element in the array returns false for the given function', ->
-        result = up.util.all ['foo', 'bar', null, 'baz'], up.util.isPresent
+        result = up.util.every ['foo', 'bar', null, 'baz'], up.util.isPresent
         expect(result).toBe(false)
 
       it 'short-circuits once an element returns false', ->
         count = 0
-        up.util.all ['foo', 'bar', '', 'baz'], (element) ->
+        up.util.every ['foo', 'bar', '', 'baz'], (element) ->
           count += 1
           up.util.isPresent(element)
         expect(count).toBe(3)
@@ -740,7 +729,7 @@ describe 'up.util', ->
       it 'passes the iteration index as second argument to the given function', ->
         array = ["apple", "orange", "cucumber"]
         args = []
-        up.util.all array, (item, index) ->
+        up.util.every array, (item, index) ->
           args.push(index)
           true
         expect(args).toEqual [0, 1, 2]
@@ -748,8 +737,8 @@ describe 'up.util', ->
       it 'accepts a property name instead of a function, which collects that property from each item', ->
         allTrue = [ { prop: true }, { prop: true } ]
         someFalse = [ { prop: true }, { prop: false } ]
-        expect(up.util.all(allTrue, 'prop')).toBe(true)
-        expect(up.util.all(someFalse, 'prop')).toBe(false)
+        expect(up.util.every(allTrue, 'prop')).toBe(true)
+        expect(up.util.every(someFalse, 'prop')).toBe(false)
 
 #    describe 'up.util.none', ->
 #
@@ -782,20 +771,20 @@ describe 'up.util', ->
 #        expect(up.util.none(allFalse, 'prop')).toBe(true)
 #        expect(up.util.none(someTrue, 'prop')).toBe(false)
 
-    describe 'up.util.any', ->
+    describe 'up.util.some', ->
 
       it 'returns true if at least one element in the array returns true for the given function', ->
-        result = up.util.any ['', 'bar', null], up.util.isPresent
+        result = up.util.some ['', 'bar', null], up.util.isPresent
         expect(result).toBe(true)
 
       it 'returns false if no element in the array returns true for the given function', ->
-        result = up.util.any ['', null, undefined], up.util.isPresent
+        result = up.util.some ['', null, undefined], up.util.isPresent
         expect(result).toBe(false)
 
       it 'passes the iteration index as second argument to the given function', ->
         array = ["apple", "orange", "cucumber"]
         args = []
-        up.util.any array, (item, index) ->
+        up.util.some array, (item, index) ->
           args.push(index)
           false
         expect(args).toEqual [0, 1, 2]
@@ -803,8 +792,57 @@ describe 'up.util', ->
       it 'accepts a property name instead of a function, which collects that property from each item', ->
         someTrue = [ { prop: true }, { prop: false } ]
         allFalse = [ { prop: false }, { prop: false } ]
-        expect(up.util.any(someTrue, 'prop')).toBe(true)
-        expect(up.util.any(allFalse, 'prop')).toBe(false)
+        expect(up.util.some(someTrue, 'prop')).toBe(true)
+        expect(up.util.some(allFalse, 'prop')).toBe(false)
+
+      it 'short-circuits once an element returns true', ->
+        count = 0
+        up.util.some [null, undefined, 'foo', ''], (element) ->
+          count += 1
+          up.util.isPresent(element)
+        expect(count).toBe(3)
+
+      it 'iterates over an array-like value', ->
+        one = fixture('.qwertz')
+        two = fixture('.qwertz')
+        nodeList = document.querySelectorAll('.qwertz')
+
+        callback = jasmine.createSpy()
+
+        up.util.some nodeList, callback
+        expect(callback.calls.allArgs()).toEqual [[one, 0], [two, 1]]
+
+    describe 'up.util.findResult', ->
+
+      it 'consecutively applies the function to each array element and returns the first truthy return value', ->
+        map = {
+          a: '',
+          b: null,
+          c: undefined,
+          d: 'DEH',
+          e: 'EH'
+        }
+        fn = (el) -> map[el]
+
+        result = up.util.findResult ['a', 'b', 'c', 'd', 'e'], fn
+        expect(result).toEqual('DEH')
+
+      it 'returns undefined if the function does not return a truthy value for any element in the array', ->
+        map = {}
+        fn = (el) -> map[el]
+
+        result = up.util.findResult ['a', 'b', 'c'], fn
+        expect(result).toBeUndefined()
+
+      it 'iterates over an array-like value', ->
+        one = fixture('.qwertz')
+        two = fixture('.qwertz')
+        nodeList = document.querySelectorAll('.qwertz')
+
+        callback = jasmine.createSpy()
+
+        up.util.findResult nodeList, callback
+        expect(callback.calls.allArgs()).toEqual [[one, 0], [two, 1]]
 
     describe 'up.util.isBlank', ->
 
@@ -847,10 +885,26 @@ describe 'up.util', ->
       it 'returns true for an object with at least one key', ->
         expect(up.util.isBlank({key: 'value'})).toBe(false)
 
+      it 'returns true for an object with an [up.util.isBlank.key] method that returns true', ->
+        value = {}
+        value[up.util.isBlank.key] = -> true
+        expect(up.util.isBlank(value)).toBe(true)
+
+      it 'returns false for an object with an [up.util.isBlank.key] method that returns false', ->
+        value = {}
+        value[up.util.isBlank.key] = -> false
+        expect(up.util.isBlank(value)).toBe(false)
+
+      it 'returns false for a DOM element', ->
+        value = document.body
+        expect(up.util.isBlank(value)).toBe(false)
+
     describe 'up.util.normalizeUrl', ->
 
       it 'normalizes a relative path', ->
-        expect(up.util.normalizeUrl('foo')).toBe("http://#{location.hostname}:#{location.port}/foo")
+        up.history.config.enabled = true
+        up.history.replace('/qux/')
+        expect(up.util.normalizeUrl('foo')).toBe("http://#{location.hostname}:#{location.port}/qux/foo")
 
       it 'normalizes an absolute path', ->
         expect(up.util.normalizeUrl('/foo')).toBe("http://#{location.hostname}:#{location.port}/foo")
@@ -879,45 +933,17 @@ describe 'up.util', ->
       it 'puts a #hash behind the query string', ->
         expect(up.util.normalizeUrl('http://example.com/foo/bar?key=value#fragment', hash: true)).toBe('http://example.com/foo/bar?key=value#fragment')
 
-    describe 'up.util.detect', ->
+    describe 'up.util.find', ->
 
       it 'finds the first element in the given array that matches the given tester', ->
         array = ['foo', 'bar', 'baz']
         tester = (element) -> element[0] == 'b'
-        expect(up.util.detect(array, tester)).toEqual('bar')
+        expect(up.util.find(array, tester)).toEqual('bar')
 
       it "returns undefined if the given array doesn't contain a matching element", ->
         array = ['foo', 'bar', 'baz']
         tester = (element) -> element[0] == 'z'
-        expect(up.util.detect(array, tester)).toBeUndefined()
-
-    describe 'up.util.config', ->
-
-      it 'creates an object with the given attributes', ->
-        object = up.util.config(a: 1, b: 2)
-        expect(object.a).toBe(1)
-        expect(object.b).toBe(2)
-
-      it 'does not allow to set a key that was not included in the factory settings', ->
-        object = up.util.config(a: 1)
-        object.b = 2
-        expect(object.b).toBeUndefined()
-
-      describe '#reset', ->
-
-        it 'resets the object to its original state', ->
-          object = up.util.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 = up.util.config(a: 1)
-          object.b = 2
-          object.reset()
-          expect(object.reset).toBeDefined()
+        expect(up.util.find(array, tester)).toBeUndefined()
 
     describe 'up.util.remove', ->
 
@@ -966,60 +992,41 @@ describe 'up.util', ->
         expect(object.b).toBe('b value')
         expect(object.c).toBe('a value')
 
-    describe 'up.util.selectInSubtree', ->
-
-      it 'finds the selector in ancestors and descendants of the given element', ->
-        $grandMother = affix('.grand-mother.match')
-        $mother = $grandMother.affix('.mother')
-        $element = $mother.affix('.element')
-        $child = $element.affix('.child.match')
-        $grandChild = $child.affix('.grand-child.match')
-
-        $matches = up.util.selectInSubtree($element, '.match')
-        $expected = $child.add($grandChild)
-        expect($matches).toEqual $expected
-
-      it 'finds the element itself if it matches the selector', ->
-        $element = affix('.element.match')
-        $matches = up.util.selectInSubtree($element, '.match')
-        expect($matches).toEqual $element
-
-      describe 'when given a jQuery collection with multiple elements', ->
-
-        it 'searches in a all subtrees of the given elements', ->
-          $a_grandMother = affix('.grand-mother.match')
-          $a_mother = $a_grandMother.affix('.mother')
-          $a_element = $a_mother.affix('.element')
-          $a_child = $a_element.affix('.child.match')
-          $a_grandChild = $a_child.affix('.grand-child.match')
-
-          $b_grandMother = affix('.grand-mother.match')
-          $b_mother = $b_grandMother.affix('.mother')
-          $b_element = $b_mother.affix('.element')
-          $b_child = $b_element.affix('.child.match')
-          $b_grandChild = $b_child.affix('.grand-child.match')
-
-          $matches = up.util.selectInSubtree($a_element.add($b_element), '.match')
-          expect($matches).toEqual $a_child.add($a_grandChild).add($b_child).add($b_grandChild)
-
-
-    describe 'up.util.selectInDynasty', ->
-
-      it 'finds the selector in both ancestors and descendants of the given element', ->
-        $grandMother = affix('.grand-mother.match')
-        $mother = $grandMother.affix('.mother')
-        $element = $mother.affix('.element')
-        $child = $element.affix('.child.match')
-        $grandChild = $child.affix('.grand-child.match')
-
-        $matches = up.util.selectInDynasty($element, '.match')
-        $expected = $grandMother.add($child).add($grandChild)
-        expect($matches).toEqual $expected
-
-      it 'finds the element itself if it matches the selector', ->
-        $element = affix('.element.match')
-        $matches = up.util.selectInDynasty($element, '.match')
-        expect($matches).toEqual $element
+#    describe 'up.util.offsetParent', ->
+#
+#      it 'returns the first ascendant that has a "position" style', ->
+#        $a = $fixture('.a')
+#        $b = $a.affix('.b').css(position: 'relative')
+#        $c = $b.affix('.c')
+#        $d = $c.affix('.d')
+#
+#        expect(up.util.offsetParent($d[0])).toBe($b[0])
+#
+#      it 'does not return the given element, even when it has position', ->
+#        $a = $fixture('.a').css(position: 'absolute')
+#        $b = $a.affix('.b').css(position: 'relative')
+#
+#        expect(up.util.offsetParent($b[0])).toBe($a[0])
+#
+#      it 'returns the <body> element if there is no closer offset parent', ->
+#        $a = $fixture('.a')
+#        $b = $a.affix('.b')
+#
+#        expect(up.util.offsetParent($b[0])).toBe(document.body)
+#
+#      it 'returns the offset parent for a detached element', ->
+#        $a = $fixture('.a').detach()
+#        $b = $a.affix('.b').css(position: 'relative')
+#        $c = $b.affix('.c')
+#        $d = $c.affix('.d')
+#
+#        expect(up.util.offsetParent($d[0])).toBe($b[0])
+#
+#      it 'returns a missing value (and not <body>) if the given detached element has no ancestor with position', ->
+#        $a = $fixture('.a').detach()
+#        $b = $a.affix('.b')
+#
+#        expect(up.util.offsetParent($b[0])).toBeMissing()
 
     describe 'up.util.isCrossDomain', ->
 
@@ -1240,4 +1247,160 @@ describe 'up.util', ->
 
           expect(target).toEqual { a: 1, b: 2, c: 3, d: 4, e: 5 }
 
+    describe 'up.util.copy', ->
+
+      it 'returns a shallow copy of the given array', ->
+        original = ['a', { b: 'c' }, 'd']
+
+        copy = up.util.copy(original)
+        expect(copy).toEqual(original)
+
+        # Test that changes to copy don't change original
+        copy.pop()
+        expect(copy.length).toBe(2)
+        expect(original.length).toBe(3)
+
+        # Test that the copy is shallow
+        copy[1].x = 'y'
+        expect(original[1].x).toEqual('y')
+
+      it 'returns a shallow copy of the given plain object', ->
+        original = {a: 'b', c: [1, 2], d: 'e'}
+
+        copy = up.util.copy(original)
+        expect(copy).toEqual(original)
+
+        # Test that changes to copy don't change original
+        copy.f = 'g'
+        expect(original.f).toBeMissing()
+
+        # Test that the copy is shallow
+        copy.c.push(3)
+        expect(original.c).toEqual [1, 2, 3]
+
+      it 'allows custom classes to hook into the copy protocol by implementing a method named `up.util.copy.key`', ->
+        class TestClass
+          "#{up.util.copy.key}": ->
+            return "custom copy"
+
+        instance = new TestClass()
+        expect(up.util.copy(instance)).toEqual("custom copy")
+
+      it 'copies the given jQuery collection into an array', ->
+        $one = $fixture('.one')
+        $two = $fixture('.two')
+        $collection = $one.add($two)
+
+        copy = up.util.copy($collection)
+
+        copy[0] = document.body
+        expect($collection[0]).toBe($one[0])
+
+      it 'copies the given arguments object into an array', ->
+        args = undefined
+        (-> args = arguments)(1)
+
+        copy = up.util.copy(args)
+        expect(copy).toBeArray()
+
+        copy[0] = 2
+        expect(args[0]).toBe(1)
+
+      it 'returns the given string (which is immutable)', ->
+        str = "foo"
+        copy = up.util.copy(str)
+        expect(copy).toBe(str)
+
+      it 'returns the given number (which is immutable)', ->
+        number = 123
+        copy = up.util.copy(number)
+        expect(copy).toBe(number)
+
+      it 'copies the given Date object', ->
+        date = new Date('1995-12-17T03:24:00')
+        expect(date.getFullYear()).toBe(1995)
+
+        copy = up.util.copy(date)
+
+        expect(copy.getFullYear()).toBe(1995)
+        expect(copy.getHours()).toBe(3)
+        expect(copy.getMinutes()).toBe(24)
+
+        date.setFullYear(2018)
+
+        expect(copy.getFullYear()).toBe(1995)
+
+
+    describe 'up.util.deepCopy', ->
+
+      it 'returns a deep copy of the given array', ->
+        original = ['a', { b: 'c' }, 'd']
+
+        copy = up.util.deepCopy(original)
+        expect(copy).toEqual(original)
+
+        # Test that changes to copy don't change original
+        copy.pop()
+        expect(copy.length).toBe(2)
+        expect(original.length).toBe(3)
+
+        # Test that the copy is deep
+        copy[1].x = 'y'
+        expect(original[1].x).toBeUndefined()
+
+      it 'returns a deep copy of the given object', ->
+        original = {a: 'b', c: [1, 2], d: 'e'}
+
+        copy = up.util.deepCopy(original)
+        expect(copy).toEqual(original)
+
+        # Test that changes to copy don't change original
+        copy.f = 'g'
+        expect(original.f).toBeMissing()
+
+        # Test that the copy is deep
+        copy.c.push(3)
+        expect(original.c).toEqual [1, 2]
+
+    describe 'up.util.isList', ->
+
+      it 'returns true for an array', ->
+        value = [1, 2, 3]
+        expect(up.util.isList(value)).toBe(true)
+
+      it 'returns true for an HTMLCollection', ->
+        value = document.getElementsByTagName('div')
+        expect(up.util.isList(value)).toBe(true)
+
+      it 'returns true for a NodeList', ->
+        value = document.querySelectorAll('div')
+        expect(up.util.isList(value)).toBe(true)
+
+      it 'returns true for an arguments object', ->
+        value = undefined
+        (-> value = arguments)()
+        expect(up.util.isList(value)).toBe(true)
+
+      it 'returns false for an object', ->
+        value = { foo: 'bar' }
+        expect(up.util.isList(value)).toBe(false)
+
+      it 'returns false for a string', ->
+        value = 'foo'
+        expect(up.util.isList(value)).toBe(false)
+
+      it 'returns false for a number', ->
+        value = 123
+        expect(up.util.isList(value)).toBe(false)
+
+      it 'returns false for undefined', ->
+        value = undefined
+        expect(up.util.isList(value)).toBe(false)
+
+      it 'returns false for null', ->
+        value = null
+        expect(up.util.isList(value)).toBe(false)
 
+      it 'returns false for NaN', ->
+        value = NaN
+        expect(up.util.isList(value)).toBe(false)