unpoly-rails 0.37.0 → 0.50.0

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

@@ -21,21 +21,37 @@ describe 'up.rails', ->
         describe "on an [#{upAttribute}] element", ->
 
           it "is transformed to an up-method attribute so the element isn't handled a second time by Rails UJS", ->
-            $element = affix("span[#{upAttribute}][data-method=\"put\"]")
+            $element = affix("a[href=\"/foo\"][#{upAttribute}][data-method=\"put\"]")
             up.hello($element)
             expect($element.attr('data-method')).toBeUndefined()
             expect($element.attr('up-method')).toEqual('put')
 
           it "does not overwrite an existing up-method attribute, but gets deleted", ->
-            $element = affix("span[#{upAttribute}][up-method=\"patch\"][data-method=\"put\"]")
+            $element = affix("a[href=\"/foo\"][#{upAttribute}][up-method=\"patch\"][data-method=\"put\"]")
             up.hello($element)
             expect($element.attr('data-method')).toBeUndefined()
             expect($element.attr('up-method')).toEqual('patch')
 
+          it 'transforms an element that becomes followable through [up-expand]', ->
+            $element = affix('a[up-expand][data-method="put"]')
+            $child = $element.affix('span[up-href="/foo"][up-follow]')
+            up.hello($element)
+            expect($element.attr('up-href')).toEqual('/foo')
+            expect($element.attr('up-follow')).toEqual('')
+            expect($element.attr('data-method')).toBeUndefined()
+            expect($element.attr('up-method')).toEqual('put')
+
+          it 'transforms an element that becomes followable through a user macro like [content-link]', ->
+            up.macro '[user-make-followable]', ($element) -> $element.attr('up-follow', '')
+            $element = affix('a[user-make-followable][data-method="put"]')
+            up.hello($element)
+            expect($element.attr('data-method')).toBeUndefined()
+            expect($element.attr('up-method')).toEqual('put')
+
       describe 'on an element without Unpoly attributes', ->
 
         it "is not changed", ->
-          $element = affix("span[data-method=\"put\"]")
+          $element = affix("a[href=\"/foo\"][data-method=\"put\"]")
           up.hello($element)
           expect($element.attr('data-method')).toEqual('put')
 
@@ -48,7 +64,7 @@ describe 'up.rails', ->
         describe "on an [#{upAttribute}] element", ->
 
           it "is not changed", ->
-            $element = affix("span[#{upAttribute}][data-method=\"put\"]")
+            $element = affix("a[href=\"/foo\"][#{upAttribute}][data-method=\"put\"]")
             up.hello($element)
             expect($element.attr('data-method')).toEqual('put')
 
@@ -69,13 +85,13 @@ describe 'up.rails', ->
         describe "on an [#{upAttribute}] element", ->
 
           it "is transformed to an up-confirm attribute so the element isn't handled a second time by Rails UJS", ->
-            $element = affix("span[#{upAttribute}][data-confirm=\"Really?\"]")
+            $element = affix("a[href=\"/foo\"][#{upAttribute}][data-confirm=\"Really?\"]")
             up.hello($element)
             expect($element.attr('data-confirm')).toBeUndefined()
             expect($element.attr('up-confirm')).toEqual('Really?')
 
           it "does not overwrite an existing up-confirm attribute, but gets deleted", ->
-            $element = affix("span[#{upAttribute}][up-confirm=\"Seriously?\"][data-confirm=\"Really?\"]")
+            $element = affix("a[href=\"/foo\"][#{upAttribute}][up-confirm=\"Seriously?\"][data-confirm=\"Really?\"]")
             up.hello($element)
             expect($element.attr('data-confirm')).toBeUndefined()
             expect($element.attr('up-confirm')).toEqual('Seriously?')
@@ -83,7 +99,7 @@ describe 'up.rails', ->
       describe 'on an element without Unpoly attributes', ->
 
         it "is not changed", ->
-          $element = affix("span[data-confirm=\"Really?\"]")
+          $element = affix("a[href=\"/foo\"][data-confirm=\"Really?\"]")
           up.hello($element)
           expect($element.attr('data-confirm')).toEqual('Really?')
 
@@ -96,6 +112,6 @@ describe 'up.rails', ->
         describe "on an [#{upAttribute}] element", ->
 
           it "is not changed", ->
-            $element = affix("span[#{upAttribute}][data-confirm=\"Really?\"]")
+            $element = affix("a[href=\"/foo\"][#{upAttribute}][data-confirm=\"Really?\"]")
             up.hello($element)
             expect($element.attr('data-confirm')).toEqual('Really?')

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

@@ -17,44 +17,55 @@ describe 'up.syntax', ->
 
       describe 'destructors', ->
 
-        it 'allows compilers to return a function to call when the compiled element is destroyed', ->
+        it 'allows compilers to return a function to call when the compiled element is destroyed', asyncSpec (next) ->
           destructor = jasmine.createSpy('destructor')
           up.compiler '.child', ($element) ->
             destructor
 
           up.hello(affix('.container .child'))
-          expect(destructor).not.toHaveBeenCalled()
 
-          up.destroy('.container')
-          expect(destructor).toHaveBeenCalled()
+          next =>
+            expect(destructor).not.toHaveBeenCalled()
+            up.destroy('.container')
 
-        it 'allows compilers to return an array of functions to all when the compiled element is destroyed', ->
+          next =>
+            expect(destructor).toHaveBeenCalled()
+
+        it 'allows compilers to return an array of functions to call when the compiled element is destroyed', asyncSpec (next) ->
           destructor1 = jasmine.createSpy('destructor1')
           destructor2 = jasmine.createSpy('destructor2')
           up.compiler '.child', ($element) ->
             [ destructor1, destructor2 ]
 
           up.hello(affix('.container .child'))
-          expect(destructor1).not.toHaveBeenCalled()
-          expect(destructor2).not.toHaveBeenCalled()
 
-          up.destroy('.container')
-          expect(destructor1).toHaveBeenCalled()
-          expect(destructor2).toHaveBeenCalled()
+          next =>
+            expect(destructor1).not.toHaveBeenCalled()
+            expect(destructor2).not.toHaveBeenCalled()
+
+            up.destroy('.container')
 
-        it "does not consider a returned array to be a destructor unless it's comprised entirely of functions", ->
+          next =>
+            expect(destructor1).toHaveBeenCalled()
+            expect(destructor2).toHaveBeenCalled()
+
+        it "does not consider a returned array to be a destructor unless it's comprised entirely of functions", asyncSpec (next) ->
           value1 = jasmine.createSpy('non-destructor')
           value2 = 'two'
           up.compiler '.child', ($element) ->
             [ value1, value2 ]
 
           up.hello(affix('.container .child'))
-          expect(value1).not.toHaveBeenCalled()
 
-          up.destroy('.container')
-          expect(value1).not.toHaveBeenCalled()
+          next =>
+            expect(value1).not.toHaveBeenCalled()
+
+            up.destroy('.container')
 
-        it 'runs all destructors if multiple compilers are applied to the same element', ->
+          next =>
+            expect(value1).not.toHaveBeenCalled()
+
+        it 'runs all destructors if multiple compilers are applied to the same element', asyncSpec (next) ->
           destructor1 = jasmine.createSpy('destructor1')
           up.compiler '.one', ($element) -> destructor1
           destructor2 = jasmine.createSpy('destructor2')
@@ -62,22 +73,28 @@ describe 'up.syntax', ->
 
           $element = affix('.one.two')
           up.hello($element)
-          expect(destructor1).not.toHaveBeenCalled()
-          expect(destructor2).not.toHaveBeenCalled()
 
-          up.destroy($element)
-          expect(destructor1).toHaveBeenCalled()
-          expect(destructor2).toHaveBeenCalled()
+          next =>
+            expect(destructor1).not.toHaveBeenCalled()
+            expect(destructor2).not.toHaveBeenCalled()
+
+            up.destroy($element)
 
-        it 'does not throw an error if both container and child have a destructor, and the container gets destroyed', ->
+          next =>
+            expect(destructor1).toHaveBeenCalled()
+            expect(destructor2).toHaveBeenCalled()
+
+        it 'does not throw an error if both container and child have a destructor, and the container gets destroyed', asyncSpec (next) ->
           up.compiler '.container', ($element) ->
             return (->)
 
           up.compiler '.child', ($element) ->
             return (->)
 
-          destruction = -> up.destroy('.container')
-          expect(destruction).not.toThrowError()
+          promise = up.destroy('.container')
+
+          promiseState(promise).then (result) ->
+            expect(result.state).toEqual('fulfilled')
 
       it 'parses an up-data attribute as JSON and passes the parsed object as a second argument to the initializer', ->
 

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

@@ -6,23 +6,26 @@ describe 'up.tooltip', ->
     
     describe 'up.tooltip.attach', ->
       
-      it 'opens a tooltip with the given text', ->
+      it 'opens a tooltip with the given text', (done) ->
         $link = affix('span')
-        up.tooltip.attach($link, html: 'tooltip text')
-        $tooltip = $('.up-tooltip')
-        expect($tooltip).toHaveText('tooltip text')
+        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', ->
+      it 'allows HTML for the tooltip text when contents are given as { html } option', (done) ->
         $link = affix('span')
-        up.tooltip.attach($link, html: '<b>text</b>')
-        $tooltip = $('.up-tooltip')
-        expect($tooltip.html()).toEqual('<b>text</b>')
+        up.tooltip.attach($link, html: '<b>text</b>').then ->
+          $tooltip = $('.up-tooltip')
+          expect($tooltip.html()).toEqual('<b>text</b>')
+          done()
 
-      it 'escapes HTML for the tooltip text when contents given as { text } option', ->
+      it 'escapes HTML for the tooltip text when contents given as { text } option', (done) ->
         $link = affix('span')
-        up.tooltip.attach($link, text: '<b>text</b>')
-        $tooltip = $('.up-tooltip')
-        expect($tooltip.html()).toEqual('&lt;b&gt;text&lt;/b&gt;')
+        up.tooltip.attach($link, text: '<b>text</b>').then ->
+          $tooltip = $('.up-tooltip')
+          expect($tooltip.html()).toEqual('&lt;b&gt;text&lt;/b&gt;')
+          done()
 
       describe 'positioning', ->
 
@@ -44,58 +47,61 @@ describe 'up.tooltip', ->
 
         describe 'with { position: "top" }', ->
 
-          it 'centers the tooltip above the given element', ->
+          it 'centers the tooltip above the given element', (done) ->
             @linkBox = @$link.get(0).getBoundingClientRect()
-            up.tooltip.attach(@$link, html: 'tooltip text', position: 'top')
-            $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)
+            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)
+              done()
 
         describe 'with { position: "right" }', ->
 
-          it 'centers the tooltip at the right side of the given element', ->
+          it 'centers the tooltip at the right side of the given element', (done) ->
             @linkBox = @$link.get(0).getBoundingClientRect()
-            up.tooltip.attach(@$link, html: 'tooltip text', position: 'right')
-            $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)
+            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)
+              done()
 
         describe 'with { position: "bottom" }', ->
 
-          it 'centers the tooltip below the given element', ->
+          it 'centers the tooltip below the given element', (done) ->
             @linkBox = @$link.get(0).getBoundingClientRect()
-            up.tooltip.attach(@$link, html: 'tooltip text', position: 'bottom')
-            $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)
+            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)
+              done()
 
         describe 'with { position: "left" }', ->
 
-          it 'centers the tooltip at the left side of the given element', ->
+          it 'centers the tooltip at the left side of the given element', (done) ->
             @linkBox = @$link.get(0).getBoundingClientRect()
-            up.tooltip.attach(@$link, html: 'tooltip text', position: 'left')
-            $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)
-
-        it 'gives the tooltip { position: "fixed" } if the given link is fixed', ->
+            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)
+              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')
-          $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)
-
+          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'
       
@@ -122,44 +128,52 @@ describe 'up.tooltip', ->
       beforeEach ->
         up.motion.config.enabled = false
 
-      it 'closes the tooltip', (done) ->
+      it 'closes the tooltip', asyncSpec (next) ->
         $link = affix('.link')
         up.tooltip.attach($link, text: 'Tooltip text')
-        expect(up.tooltip.isOpen()).toBe(true)
-        Trigger.clickSequence($('body'))
-        u.nextFrame ->
+
+        next =>
+          expect(up.tooltip.isOpen()).toBe(true)
+          Trigger.clickSequence($('body'))
+
+        next =>
           expect(up.tooltip.isOpen()).toBe(false)
-          done()
 
-      it 'closes the tooltip when a an [up-instant] link removes its parent (and thus a click event never bubbles up to the document)', (done) ->
+      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')
         $parentReplacingLink = $parent.affix('a[href="/foo"][up-target=".parent"][up-instant]')
         $tooltipOpener = affix('.link')
         up.tooltip.attach($tooltipOpener, text: 'Tooltip text')
-        expect(up.tooltip.isOpen()).toBe(true)
-        Trigger.clickSequence($parentReplacingLink)
-        u.nextFrame ->
+
+        next =>
+          expect(up.tooltip.isOpen()).toBe(true)
+          Trigger.clickSequence($parentReplacingLink)
+
+        next =>
           expect(up.tooltip.isOpen()).toBe(false)
-          done()
 
-      it 'closes a tooltip when the user clicks on an [up-target] link outside the tooltip', (done) ->
+      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')
         up.tooltip.attach($tooltipOpener, text: 'Tooltip text')
-        expect(up.tooltip.isOpen()).toBe(true)
-        Trigger.clickSequence($outsideLink)
-        u.nextFrame ->
+
+        next =>
+          expect(up.tooltip.isOpen()).toBe(true)
+          Trigger.clickSequence($outsideLink)
+
+        next =>
           expect(up.tooltip.isOpen()).toBe(false)
-          done()
 
-      it 'closes a tooltip when the user clicks on an [up-instant] link outside the tooltip', (done) ->
+      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')
         up.tooltip.attach($tooltipOpener, text: 'Tooltip text')
-        expect(up.tooltip.isOpen()).toBe(true)
-        Trigger.clickSequence($outsideLink)
-        u.nextFrame ->
+
+        next =>
+          expect(up.tooltip.isOpen()).toBe(true)
+          Trigger.clickSequence($outsideLink)
+
+        next =>
           expect(up.tooltip.isOpen()).toBe(false)
-          done()