unpoly-rails 0.56.7 → 0.57.0

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

@@ -0,0 +1,31 @@
+#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 = affix('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 = affix('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/request_spec.coffee

@@ -0,0 +1,50 @@
+describe 'up.Request', ->
+
+  describe '#url', ->
+
+    it 'returns the given URL', ->
+      request = new up.Request(url: 'http://host.com/foo')
+      expect(request.url).toEqual('http://host.com/foo')
+
+    it 'does not include a hash anchor of the constructed URL', ->
+      request = new up.Request(url: 'http://host.com/foo#hash')
+      expect(request.url).toEqual('http://host.com/foo')
+
+    it "merges { params } for HTTP methods that don't allow a payload", ->
+      request = new up.Request(url: 'http://host.com/foo?urlKey=urlValue', params: { paramsKey: 'paramsValue' }, method: 'get')
+      expect(request.url).toEqual('http://host.com/foo?urlKey=urlValue&paramsKey=paramsValue')
+
+    it 'excludes { params } for HTTP methods that allow a payload', ->
+      request = new up.Request(url: 'http://host.com/foo?key=value', method: 'post')
+      expect(request.url).toEqual('http://host.com/foo')
+
+  describe '#method', ->
+
+    it 'defaults to "GET"', ->
+      request = new up.Request(url: 'http://host.com/foo')
+      expect(request.method).toEqual('GET')
+
+  describe '#hash', ->
+
+    it 'returns the hash anchor from the constructed URL', ->
+      request = new up.Request(url: 'http://host.com/foo#hash')
+      expect(request.hash).toEqual('#hash')
+
+    it 'returns undefined if the constructed URL had no hash anchor', ->
+      request = new up.Request(url: 'http://host.com/foo')
+      expect(request.hash).toBeUndefined()
+
+  describe '#params', ->
+
+    it 'returns the constructed params for HTTP methods that allow a payload', ->
+      params = { key: 'value' }
+      request = new up.Request(url: 'http://host.com/foo', params: params, method: 'post')
+      expect(request.params).toEqual(params)
+
+    it "returns undefined for HTTP methods that don't allow a payload", ->
+      request = new up.Request(url: 'http://host.com/foo', params: { key: 'value' }, method: 'get')
+      expect(request.params).toBeUndefined()
+
+    it 'returns the merged { params } and params from the URL for HTTP methods that allow a payload', ->
+      request = new up.Request(url: 'http://host.com/foo?urlKey=urlValue', params: { paramsKey: 'paramsValue' }, method: 'post')
+      expect(request.params).toEqual(paramsKey: 'paramsValue', urlKey: 'urlValue')

data/spec_app/spec/javascripts/up/classes/store/memory_spec.js.coffee

@@ -0,0 +1,67 @@
+describe 'up.store.Memory', ->
+
+  describe '#get', ->
+
+    it 'returns an item that was previously set', ->
+      store = new up.store.Memory()
+      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.store.Memory()
+      store.set('foo', 'value of foo')
+
+      expect(store.get('bar')).toBeUndefined()
+
+  describe '#keys', ->
+
+    it 'returns an array of keys in the store', ->
+      store = new up.store.Memory()
+      store.set('foo', 'value of foo')
+      store.set('bar', 'value of bar')
+
+      expect(store.keys().sort()).toEqual ['bar', 'foo']
+
+    it 'does not return keys for entries that were removed (bugfix)', ->
+      store = new up.store.Memory()
+      store.set('foo', 'value of foo')
+      store.set('bar', 'value of bar')
+      store.remove('bar')
+
+      expect(store.keys().sort()).toEqual ['foo']
+
+  describe '#values', ->
+
+    it 'returns an array of values in the store', ->
+      store = new up.store.Memory()
+      store.set('foo', 'value of foo')
+      store.set('bar', 'value of bar')
+
+      expect(store.values().sort()).toEqual ['value of bar', 'value of foo']
+
+  describe '#clear', ->
+
+    it 'removes all keys from the store', ->
+      store = new up.store.Memory()
+      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.store.Memory()
+      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/store/session_spec.js.coffee

@@ -0,0 +1,113 @@
+describe 'up.store.Session', ->
+
+  u = up.util
+
+  afterEach ->
+    sessionStorage.removeItem('spec')
+
+  describe '#get', ->
+
+    it 'returns an item that was previously set', ->
+      store = new up.store.Session('spec')
+      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.store.Session('spec')
+      store.set('foo', 'value of foo')
+
+      expect(store.get('bar')).toBeUndefined()
+
+    it 'does not read keys from a store with anotther root key', ->
+      store = new up.store.Session('spec.v1')
+      store.set('foo', 'value of foo')
+      expect(store.get('foo')).toEqual('value of foo')
+
+      store = new up.store.Session('spec.v2')
+      expect(store.get('foo')).toBeUndefined()
+
+  describe '#set', ->
+
+    it 'stores the given item in window.sessionStorage where it survives a follow without Unpoly', ->
+      store = new up.store.Session('spec')
+      store.set('foo', 'value of foo')
+
+      expect(window.sessionStorage.getItem('spec')).toContain('foo')
+
+    it 'stores boolean values across sessions', ->
+      store1 = new up.store.Session('spec')
+      store1.set('foo', true)
+      store1.set('bar', false)
+
+      store2 = new up.store.Session('spec')
+      expect(store2.get('foo')).toEqual(true)
+      expect(store2.get('bar')).toEqual(false)
+
+    it 'stores number values across sessions', ->
+      store1 = new up.store.Session('spec')
+      store1.set('foo', 123)
+
+      store2 = new up.store.Session('spec')
+      expect(store2.get('foo')).toEqual(123)
+
+    it 'stores structured values across sessions', ->
+      store1 = new up.store.Session('spec')
+      store1.set('foo', { bar: ['baz', 'bam'] })
+
+      store2 = new up.store.Session('spec')
+      storedValue = store2.get('foo')
+      expect(u.isObject(storedValue)).toBe(true)
+      expect(storedValue).toEqual { bar: ['baz', 'bam'] }
+
+  describe '#keys', ->
+
+    it 'returns an array of keys in the store', ->
+      store = new up.store.Session('spec')
+      store.set('foo', 'value of foo')
+      store.set('bar', 'value of bar')
+
+      expect(store.keys().sort()).toEqual ['bar', 'foo']
+
+    it 'does not return keys for entries that were removed (bugfix)', ->
+      store = new up.store.Session('spec')
+      store.set('foo', 'value of foo')
+      store.set('bar', 'value of bar')
+      store.remove('bar')
+
+      expect(store.keys().sort()).toEqual ['foo']
+
+  describe '#values', ->
+
+    it 'returns an array of values in the store', ->
+      store = new up.store.Session('spec')
+      store.set('foo', 'value of foo')
+      store.set('bar', 'value of bar')
+
+      expect(store.values().sort()).toEqual ['value of bar', 'value of foo']
+
+  describe '#clear', ->
+
+    it 'removes all keys from the store', ->
+      store = new up.store.Session('spec')
+      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.store.Session('spec')
+      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/dom_spec.js.coffee

@@ -52,7 +52,7 @@ describe 'up.dom', ->
 
           it 'returns a promise that will be fulfilled once the server response was received and the swap transition has completed', asyncSpec (next) ->
             resolution = jasmine.createSpy()
-            promise = up.replace('.middle', '/path', transition: 'cross-fade', duration: 50)
+            promise = up.replace('.middle', '/path', transition: 'cross-fade', duration: 200)
             promise.then(resolution)
             expect(resolution).not.toHaveBeenCalled()
             expect($('.middle')).toHaveText('old-middle')
@@ -61,17 +61,17 @@ describe 'up.dom', ->
               @respond()
               expect(resolution).not.toHaveBeenCalled()
 
-            next.after 20, =>
+            next.after 100, =>
               expect(resolution).not.toHaveBeenCalled()
 
-            next.after 80, =>
+            next.after 200, =>
               expect(resolution).toHaveBeenCalled()
 
-        describe 'with { data } option', ->
+        describe 'with { params } option', ->
 
           it "uses the given params as a non-GET request's payload", asyncSpec (next) ->
             givenParams = { 'foo-key': 'foo-value', 'bar-key': 'bar-value' }
-            up.replace('.middle', '/path', method: 'put', data: givenParams)
+            up.replace('.middle', '/path', method: 'put', params: givenParams)
 
             next =>
               expect(@lastRequest().data()['foo-key']).toEqual(['foo-value'])
@@ -79,7 +79,7 @@ describe 'up.dom', ->
 
           it "encodes the given params into the URL of a GET request", asyncSpec (next) ->
             givenParams = { 'foo-key': 'foo-value', 'bar-key': 'bar-value' }
-            up.replace('.middle', '/path', method: 'get', data: givenParams)
+            up.replace('.middle', '/path', method: 'get', params: givenParams)
             next => expect(@lastRequest().url).toMatchUrl('/path?foo-key=foo-value&bar-key=bar-value')
 
         it 'uses a HTTP method given as { method } option', asyncSpec (next) ->
@@ -201,8 +201,8 @@ describe 'up.dom', ->
             next => @respond(responseHeaders: { 'X-Up-Location': '/other-path' })
             next => expect(location.href).toMatchUrl('/other-path')
 
-          it 'adds params from a { data } option to the URL of a GET request', asyncSpec (next) ->
-            up.replace('.middle', '/path', data: { 'foo-key': 'foo value', 'bar-key': 'bar value' })
+          it 'adds params from a { params } option to the URL of a GET request', asyncSpec (next) ->
+            up.replace('.middle', '/path', params: { 'foo-key': 'foo value', 'bar-key': 'bar value' })
             next => @respond()
             next => expect(location.href).toMatchUrl('/path?foo-key=foo%20value&bar-key=bar%20value')
 
@@ -1269,6 +1269,8 @@ describe 'up.dom', ->
         describe 'with { reveal } option', ->
 
           beforeEach ->
+            up.history.config.enabled = true
+
             @revealedHTML = []
             @revealedText = []
             @revealOptions = {}
@@ -1345,13 +1347,13 @@ describe 'up.dom', ->
               up.replace('.middle', '/path', failTarget: '.fail-target', reveal: false, failReveal: '&', origin: $origin)
 
               next =>
-              @respondWith
-                status: 500
-                responseText: """
-                  <div class="fail-target">
-                    new fail target text
-                  </div>
-                  """
+                @respondWith
+                  status: 500
+                  responseText: """
+                    <div class="fail-target">
+                      new fail target text
+                    </div>
+                    """
 
               next =>
                 expect(@revealedText).toEqual ['origin text']
@@ -1370,8 +1372,71 @@ describe 'up.dom', ->
 
           describe 'when there is an anchor #hash in the URL', ->
 
-            it 'scrolls to the top of a child with the ID of that #hash', asyncSpec (next) ->
+            it 'scrolls to the top of an element with the ID of that #hash', asyncSpec (next) ->
+              up.replace('.middle', '/path#hash', reveal: true)
+              @responseText =
+                """
+                <div class="middle">
+                  <div id="hash"></div>
+                </div>
+                """
+
+              next =>
+                @respond()
+
+              next =>
+                expect(@revealedHTML).toEqual ['<div id="hash"></div>']
+                expect(@revealOptions).toEqual jasmine.objectContaining(top: true)
+
+            it "scrolls to the top of an <a> element with the name of that hash", asyncSpec (next) ->
               up.replace('.middle', '/path#three', reveal: true)
+              @responseText =
+                """
+                <div class="middle">
+                  <a name="three"></a>
+                </div>
+                """
+
+              next =>
+                @respond()
+
+              next =>
+                expect(@revealedHTML).toEqual ['<a name="three"></a>']
+                expect(@revealOptions).toEqual jasmine.objectContaining(top: true)
+
+            it "scrolls to a hash that includes a dot character ('.') (bugfix)", asyncSpec (next) ->
+              up.replace('.middle', '/path#foo.bar', reveal: true)
+              @responseText =
+                """
+                <div class="middle">
+                  <a name="foo.bar"></a>
+                </div>
+                """
+
+              next =>
+                @respond()
+
+              next =>
+                expect(@revealedHTML).toEqual ['<a name="foo.bar"></a>']
+                expect(@revealOptions).toEqual jasmine.objectContaining(top: true)
+
+            it 'does not scroll if { reveal: false } is also set', asyncSpec (next) ->
+              up.replace('.middle', '/path#hash', reveal: false)
+              @responseText =
+                """
+                <div class="middle">
+                  <div id="hash"></div>
+                </div>
+                """
+
+              next =>
+                @respond()
+
+              next =>
+                expect(@revealMock).not.toHaveBeenCalled()
+
+            it 'reveals multiple consecutive #hash targets with the same URL (bugfix)', asyncSpec (next) ->
+              up.replace('.middle', '/path#two', reveal: true)
               @responseText =
                 """
                 <div class="middle">
@@ -1383,25 +1448,26 @@ describe 'up.dom', ->
 
               next =>
                 @respond()
+                up.replace('.middle', '/path#three', reveal: true)
+                # response is already cached
 
               next =>
-                expect(@revealedHTML).toEqual ['<div id="three">three</div>']
-                expect(@revealOptions).toEqual jasmine.objectContaining(top: true)
+                expect(@revealedText).toEqual ['two', 'three']
 
-            it "reveals the entire element if it has no child with the ID of that #hash", asyncSpec (next) ->
-              up.replace('.middle', '/path#four', reveal: true)
+            it "does not scroll if there is no element with the ID of that #hash", asyncSpec (next) ->
+              up.replace('.middle', '/path#hash', reveal: true)
+              @responseText =
+                """
+                <div class="middle">
+                </div>
+                """
 
               next =>
-                @responseText =
-                  """
-                  <div class="middle">
-                    new-middle
-                  </div>
-                  """
                 @respond()
 
               next =>
-                expect(@revealedText).toEqual ['new-middle']
+                expect(@revealMock).not.toHaveBeenCalled()
+
 
           it 'reveals a new element that is being appended', (done) ->
             promise = up.replace('.middle:after', '/path', reveal: true)
@@ -1621,7 +1687,7 @@ describe 'up.dom', ->
 
         it 'calls destructors when the replaced element is a singleton element like <body> (bugfix)', asyncSpec (next) ->
           # shouldSwapElementsDirectly() is true for body, but can't have the example replace the Jasmine test runner UI
-          up.motion.knife.mock('isSingletonElement').and.callFake ($element) -> $element.is('.container')
+          up.util.knife.mock('isSingletonElement').and.callFake ($element) -> $element.is('.container')
           destructor = jasmine.createSpy('destructor')
           up.compiler '.container', -> destructor
           $container = affix('.container')
@@ -1696,7 +1762,7 @@ describe 'up.dom', ->
 
         it 'morphs between the old and new element', asyncSpec (next) ->
           affix('.element.v1').text('version 1')
-          up.extract('.element', '<div class="element v2">version 2</div>', transition: 'cross-fade', duration: 100, easing: 'linear')
+          up.extract('.element', '<div class="element v2">version 2</div>', transition: 'cross-fade', duration: 200, easing: 'linear')
 
           $old = undefined
           $new = undefined
@@ -1706,23 +1772,23 @@ describe 'up.dom', ->
             $new = $('.element.v2')
 
             expect($old).toHaveLength(1)
-            expect(u.opacity($old)).toBeAround(1.0, 0.2)
+            expect(u.opacity($old)).toBeAround(1.0, 0.15)
 
             expect($new).toHaveLength(1)
-            expect(u.opacity($new)).toBeAround(0.0, 0.2)
+            expect(u.opacity($new)).toBeAround(0.0, 0.15)
 
-          next.after 50, =>
-            expect(u.opacity($old)).toBeAround(0.5, 0.2)
-            expect(u.opacity($new)).toBeAround(0.5, 0.2)
+          next.after 100, =>
+            expect(u.opacity($old)).toBeAround(0.5, 0.3)
+            expect(u.opacity($new)).toBeAround(0.5, 0.3)
 
-          next.after (50 + 30), =>
+          next.after (100 + 70), =>
             expect(u.opacity($new)).toBeAround(1.0, 0.1)
             expect($old).toBeDetached()
 
 
           it 'ignores a { transition } option when replacing a singleton element like <body>', asyncSpec (next) ->
             # shouldSwapElementsDirectly() is true for body, but can't have the example replace the Jasmine test runner UI
-            up.motion.knife.mock('isSingletonElement').and.callFake ($element) -> $element.is('.container')
+            up.util.knife.mock('isSingletonElement').and.callFake ($element) -> $element.is('.container')
 
             affix('.container').text('old text')
 
@@ -1814,7 +1880,7 @@ describe 'up.dom', ->
           promise.then(resolution)
           expect(resolution).not.toHaveBeenCalled()
 
-          u.setTimer 40, ->
+          u.setTimer 20, ->
             expect(resolution).not.toHaveBeenCalled()
 
           u.setTimer 200, ->
@@ -1991,7 +2057,6 @@ describe 'up.dom', ->
 
           it "only emits an event up:fragment:kept, but not an event up:fragment:inserted", asyncSpec (next) ->
             insertedListener = jasmine.createSpy('subscriber to up:fragment:inserted')
-            up.on('up:fragment:inserted', insertedListener)
             keptListener = jasmine.createSpy('subscriber to up:fragment:kept')
             up.on('up:fragment:kept', keptListener)
             up.on 'up:fragment:inserted', insertedListener
@@ -2323,15 +2388,15 @@ describe 'up.dom', ->
 
       it 'runs an animation before removal with { animate } option', asyncSpec (next) ->
         $element = affix('.element')
-        up.destroy($element, animation: 'fade-out', duration: 150, easing: 'linear')
+        up.destroy($element, animation: 'fade-out', duration: 200, easing: 'linear')
 
         next ->
-          expect($element).toHaveOpacity(1.0, 0.2)
+          expect($element).toHaveOpacity(1.0, 0.15)
 
-        next.after 75, ->
-          expect($element).toHaveOpacity(0.5, 0.2)
+        next.after 100, ->
+          expect($element).toHaveOpacity(0.5, 0.3)
 
-        next.after (75 + 40), ->
+        next.after (100 + 75), ->
           expect($element).toBeDetached()
 
       it 'calls destructors for custom elements', (done) ->
@@ -2477,8 +2542,31 @@ describe 'up.dom', ->
           next =>
             expect(up.browser.navigate).toHaveBeenCalledWith('/source', jasmine.anything())
 
+    describe 'up.dom.layerOf', ->
+
+      it 'returns "popup" for an element in a popup over the page', ->
+        $popup = affix('.up-popup')
+        $element = $popup.affix('.element')
+        expect(up.dom.layerOf($element)).toEqual('popup')
+
+      it 'returns "popup" for an element in a popup over a modal', ->
+        $modal = affix('.up-modal')
+        $popupInModal = $modal.affix('.up-popup')
+        $element = $popupInModal.affix('.element')
+        expect(up.dom.layerOf($element)).toEqual('popup')
+
+      it 'returns "modal" for an element in a modal', ->
+        $modal = affix('.up-modal')
+        $element = $modal.affix('.element')
+        expect(up.dom.layerOf($element)).toEqual('modal')
+
+      it 'returns "page" for an element below a modal or popup', ->
+        $element = affix('.element')
+        expect(up.dom.layerOf($element)).toEqual('page')
 
-    describe 'up.reset', ->
+      it 'returns undefined for an empty jQuery collection', ->
+        expect(up.dom.layerOf($())).toBeUndefined()
 
-      it 'should have tests'
+      it 'returns undefined for undefined', ->
+        expect(up.dom.layerOf(undefined)).toBeUndefined()