unpoly-rails 0.57.0 → 0.60.0

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

@@ -1,6 +1,7 @@
-describe 'up.radio', ->
+u = up.util
+$ = jQuery
 
-  u = up.util
+describe 'up.radio', ->
 
   describe 'JavaScript functions', ->
 
@@ -9,8 +10,8 @@ describe 'up.radio', ->
     describe '[up-hungry]', ->
 
       it "replaces the element when it is found in a response, even when the element wasn't targeted", asyncSpec (next) ->
-        affix('.hungry[up-hungry]').text('old hungry')
-        affix('.target').text('old target')
+        $fixture('.hungry[up-hungry]').text('old hungry')
+        $fixture('.target').text('old target')
 
         up.replace('.target', '/path')
 
@@ -32,8 +33,8 @@ describe 'up.radio', ->
           expect('.hungry').toHaveText('new hungry')
 
       it "does not impede replacements when the element is not part of a response", asyncSpec (next) ->
-        affix('.hungry[up-hungry]').text('old hungry')
-        affix('.target').text('old target')
+        $fixture('.hungry[up-hungry]').text('old hungry')
+        $fixture('.target').text('old target')
 
         promise = up.replace('.target', '/path')
 
@@ -52,10 +53,10 @@ describe 'up.radio', ->
             expect(result.state).toEqual('fulfilled')
 
       it 'still reveals the element that was originally targeted', asyncSpec (next) ->
-        affix('.hungry[up-hungry]').text('old hungry')
-        affix('.target').text('old target')
+        $fixture('.hungry[up-hungry]').text('old hungry')
+        $fixture('.target').text('old target')
 
-        revealStub = up.layout.knife.mock('reveal')
+        revealStub = up.viewport.knife.mock('reveal')
 
         up.replace('.target', '/path', reveal: true)
 
@@ -69,14 +70,14 @@ describe 'up.radio', ->
         next =>
           expect(revealStub).toHaveBeenCalled()
           revealArg = revealStub.calls.mostRecent().args[0]
-          expect(revealArg).not.toBeMatchedBy('.hungry')
-          expect(revealArg).toBeMatchedBy('.target')
+          expect(revealArg).not.toMatchSelector('.hungry')
+          expect(revealArg).toMatchSelector('.target')
 
 
       it 'does not change the X-Up-Target header for the request', asyncSpec (next) ->
-        affix('.hungry[up-hungry]').text('old hungry')
-        affix('.target').text('old target')
-        affix('.fail-target').text('old fail target')
+        $fixture('.hungry[up-hungry]').text('old hungry')
+        $fixture('.target').text('old target')
+        $fixture('.fail-target').text('old fail target')
 
         up.replace('.target', '/path', failTarget: '.fail-target')
 
@@ -85,9 +86,9 @@ describe 'up.radio', ->
           expect(@lastRequest().requestHeaders['X-Up-Fail-Target']).toEqual('.fail-target')
 
       it 'does replace the element when the server responds with an error (e.g. for error flashes)', asyncSpec (next) ->
-        affix('.hungry[up-hungry]').text('old hungry')
-        affix('.target').text('old target')
-        affix('.fail-target').text('old fail target')
+        $fixture('.hungry[up-hungry]').text('old hungry')
+        $fixture('.target').text('old target')
+        $fixture('.fail-target').text('old fail target')
 
         up.replace('.target', '/path', failTarget: '.fail-target')
 
@@ -109,9 +110,15 @@ describe 'up.radio', ->
               </div>
               """
 
+        next =>
+          expect('.target').toHaveText('old target')
+          expect('.fail-target').toHaveText('new fail target')
+          expect('.hungry').toHaveText('new hungry')
+
+
       it 'does not update [up-hungry] elements with { hungry: false } option', asyncSpec (next) ->
-        affix('.hungry[up-hungry]').text('old hungry')
-        affix('.target').text('old target')
+        $fixture('.hungry[up-hungry]').text('old hungry')
+        $fixture('.target').text('old target')
 
         up.replace('.target', '/path', hungry: false)
 
@@ -134,7 +141,7 @@ describe 'up.radio', ->
         up.modal.config.openDuration = 0
         up.modal.config.closeDuration = 0
 
-        affix('.outside').text('old outside').attr('up-hungry', true)
+        $fixture('.outside').text('old outside').attr('up-hungry', true)
 
         closeEventHandler = jasmine.createSpy('close event handler')
         up.on('up:modal:close', closeEventHandler)
@@ -169,8 +176,8 @@ describe 'up.radio', ->
         up.popup.config.openDuration = 0
         up.popup.config.closeDuration = 0
 
-        affix('.outside').text('old outside').attr('up-hungry', true)
-        $popupAnchor = affix('span.link').text('link')
+        $fixture('.outside').text('old outside').attr('up-hungry', true)
+        $popupAnchor = $fixture('span.link').text('link')
 
         closeEventHandler = jasmine.createSpy('close event handler')
         up.on('up:popup:close', closeEventHandler)

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

@@ -1,6 +1,7 @@
-describe 'up.rails', ->
+u = up.util
+$ = jQuery
 
-  u = up.util
+describe 'up.rails', ->
 
   upAttributes = ['up-follow', 'up-target', 'up-modal', 'up-popup']
 
@@ -21,19 +22,19 @@ 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("a[href=\"/foo\"][#{upAttribute}][data-method=\"put\"]")
+            $element = $fixture("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("a[href=\"/foo\"][#{upAttribute}][up-method=\"patch\"][data-method=\"put\"]")
+            $element = $fixture("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"]')
+            $element = $fixture('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')
@@ -42,8 +43,8 @@ describe 'up.rails', ->
             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.$macro '[user-make-followable]', ($element) -> $element.attr('up-follow', '')
+            $element = $fixture('a[user-make-followable][data-method="put"]')
             up.hello($element)
             expect($element.attr('data-method')).toBeUndefined()
             expect($element.attr('up-method')).toEqual('put')
@@ -51,7 +52,7 @@ describe 'up.rails', ->
       describe 'on an element without Unpoly attributes', ->
 
         it "is not changed", ->
-          $element = affix("a[href=\"/foo\"][data-method=\"put\"]")
+          $element = $fixture("a[href=\"/foo\"][data-method=\"put\"]")
           up.hello($element)
           expect($element.attr('data-method')).toEqual('put')
 
@@ -64,7 +65,7 @@ describe 'up.rails', ->
         describe "on an [#{upAttribute}] element", ->
 
           it "is not changed", ->
-            $element = affix("a[href=\"/foo\"][#{upAttribute}][data-method=\"put\"]")
+            $element = $fixture("a[href=\"/foo\"][#{upAttribute}][data-method=\"put\"]")
             up.hello($element)
             expect($element.attr('data-method')).toEqual('put')
 
@@ -85,13 +86,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("a[href=\"/foo\"][#{upAttribute}][data-confirm=\"Really?\"]")
+            $element = $fixture("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("a[href=\"/foo\"][#{upAttribute}][up-confirm=\"Seriously?\"][data-confirm=\"Really?\"]")
+            $element = $fixture("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?')
@@ -99,7 +100,7 @@ describe 'up.rails', ->
       describe 'on an element without Unpoly attributes', ->
 
         it "is not changed", ->
-          $element = affix("a[href=\"/foo\"][data-confirm=\"Really?\"]")
+          $element = $fixture("a[href=\"/foo\"][data-confirm=\"Really?\"]")
           up.hello($element)
           expect($element.attr('data-confirm')).toEqual('Really?')
 
@@ -112,6 +113,6 @@ describe 'up.rails', ->
         describe "on an [#{upAttribute}] element", ->
 
           it "is not changed", ->
-            $element = affix("a[href=\"/foo\"][#{upAttribute}][data-confirm=\"Really?\"]")
+            $element = $fixture("a[href=\"/foo\"][#{upAttribute}][data-confirm=\"Really?\"]")
             up.hello($element)
             expect($element.attr('data-confirm')).toEqual('Really?')

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

@@ -0,0 +1,9 @@
+u = up.util
+$ = jQuery
+
+describe 'Jasmine setup', ->
+
+  it 'does not consider a jQuery collection to be equal to its contained element (which is what jasmine-jquery does and which makes out expectations too soft)', ->
+    element = document.createElement('div')
+    $element = $(element)
+    expect($element).not.toEqual(element)

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

@@ -1,30 +1,34 @@
+u = up.util
+$ = jQuery
+
 describe 'up.syntax', ->
 
-  u = up.util
-  
   describe 'JavaScript functions', ->
   
     describe 'up.compiler', ->
       
       it 'applies an event initializer whenever a matching fragment is inserted', ->
-  
-        observeClass = jasmine.createSpy()
-        up.compiler '.child', ($element) ->
-          observeClass($element.attr('class'))
-  
-        up.hello(affix('.container .child'))
+        observeElement = jasmine.createSpy()
+        up.compiler '.child', (element) -> observeElement(element)
+
+        $container = $fixture('.container')
+        $child = $container.affix('.child')
+        $otherChild = $container.affix('.other-child')
+
+        up.hello($container[0])
    
-        expect(observeClass).not.toHaveBeenCalledWith('container')
-        expect(observeClass).toHaveBeenCalledWith('child')
+        expect(observeElement).not.toHaveBeenCalledWith($container[0])
+        expect(observeElement).not.toHaveBeenCalledWith($otherChild[0])
+        expect(observeElement).toHaveBeenCalledWith($child[0])
 
       describe 'destructors', ->
 
         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) ->
+          up.compiler '.child', (element) ->
             destructor
 
-          up.hello(affix('.container .child'))
+          up.hello(fixture('.container .child'))
 
           next =>
             expect(destructor).not.toHaveBeenCalled()
@@ -36,10 +40,10 @@ describe 'up.syntax', ->
         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) ->
+          up.compiler '.child', (element) ->
             [ destructor1, destructor2 ]
 
-          up.hello(affix('.container .child'))
+          up.hello(fixture('.container .child'))
 
           next =>
             expect(destructor1).not.toHaveBeenCalled()
@@ -54,10 +58,10 @@ describe 'up.syntax', ->
         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) ->
+          up.compiler '.child', (element) ->
             [ value1, value2 ]
 
-          up.hello(affix('.container .child'))
+          up.hello(fixture('.container .child'))
 
           next =>
             expect(value1).not.toHaveBeenCalled()
@@ -69,28 +73,28 @@ describe 'up.syntax', ->
 
         it 'runs all destructors if multiple compilers are applied to the same element', asyncSpec (next) ->
           destructor1 = jasmine.createSpy('destructor1')
-          up.compiler '.one', ($element) -> destructor1
+          up.compiler '.one', (element) -> destructor1
           destructor2 = jasmine.createSpy('destructor2')
-          up.compiler '.two', ($element) -> destructor2
+          up.compiler '.two', (element) -> destructor2
 
-          $element = affix('.one.two')
+          $element = $fixture('.one.two')
           up.hello($element)
 
           next =>
             expect(destructor1).not.toHaveBeenCalled()
             expect(destructor2).not.toHaveBeenCalled()
 
-            up.destroy($element)
+            up.destroy($element[0])
 
           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) ->
+          up.compiler '.container', (element) ->
             return (->)
 
-          up.compiler '.child', ($element) ->
+          up.compiler '.child', (element) ->
             return (->)
 
           promise = up.destroy('.container')
@@ -102,63 +106,62 @@ describe 'up.syntax', ->
 
         it 'parses an [up-data] attribute as JSON and passes the parsed object as a second argument to the compiler', ->
           observeArgs = jasmine.createSpy()
-          up.compiler '.child', ($element, data) ->
-            observeArgs($element.attr('class'), data)
+          up.compiler '.child', (element, data) ->
+            observeArgs(element.className, data)
 
           data = { key1: 'value1', key2: 'value2' }
 
-          $tag = affix(".child").attr('up-data', JSON.stringify(data))
-          up.hello($tag)
+          $tag = $fixture(".child").attr('up-data', JSON.stringify(data))
+          up.hello($tag[0])
 
           expect(observeArgs).toHaveBeenCalledWith('child', data)
 
         it 'passes an empty object as a second argument to the compiler if there is no [up-data] attribute', ->
           observeArgs = jasmine.createSpy()
-          up.compiler '.child', ($element, data) ->
-            observeArgs($element.attr('class'), data)
+          up.compiler '.child', (element, data) ->
+            observeArgs(element.className, data)
 
-          up.hello(affix(".child"))
+          up.hello(fixture(".child"))
 
           expect(observeArgs).toHaveBeenCalledWith('child', {})
 
         it 'does not parse an [up-data] attribute if the compiler function only takes a single argument', ->
           parseDataSpy = spyOn(up.syntax, 'data').and.returnValue({})
 
-          $child = affix(".child")
+          $child = $fixture(".child")
 
-          up.compiler '.child', ($element) -> # no-op
+          up.compiler '.child', (element) -> # no-op
           up.hello($child)
 
           expect(parseDataSpy).not.toHaveBeenCalled()
 
-      it 'compiles matching elements one-by-one', ->
+      it 'compiles multiple matching elements one-by-one', ->
         compiler = jasmine.createSpy('compiler')
-        up.compiler '.foo', ($element) -> compiler($element)
-        $container = affix('.container')
+        up.compiler '.foo', (element) -> compiler(element)
+        $container = $fixture('.container')
         $first = $container.affix('.foo.first')
         $second = $container.affix('.foo.second')
-        up.hello($container)
+        up.hello($container[0])
         expect(compiler.calls.count()).toEqual(2)
-        expect(compiler).toHaveBeenCalledWith($first)
-        expect(compiler).toHaveBeenCalledWith($second)
+        expect(compiler).toHaveBeenCalledWith($first[0])
+        expect(compiler).toHaveBeenCalledWith($second[0])
 
       describe 'with { batch } option', ->
 
         it 'compiles all matching elements at once', ->
           compiler = jasmine.createSpy('compiler')
-          up.compiler '.foo', { batch: true }, ($element) -> compiler($element)
-          $container = affix('.container')
-          $first = $container.affix('.foo.first')
-          $second = $container.affix('.foo.second')
-          $both = $first.add($second)
+          up.compiler '.foo', { batch: true }, (elements) -> compiler(elements)
+          $container = $fixture('.container')
+          first = $container.affix('.foo.first')[0]
+          second = $container.affix('.foo.second')[0]
           up.hello($container)
           expect(compiler.calls.count()).toEqual(1)
-          expect(compiler).toHaveBeenCalledWith($both)
+          expect(compiler).toHaveBeenCalledWith([first, second])
 
         it 'throws an error if the batch compiler returns a destructor', ->
           destructor = ->
-          up.compiler '.element', { batch: true }, ($element) -> destructor
-          $container = affix('.element')
+          up.compiler '.element', { batch: true }, (element) -> destructor
+          $container = $fixture('.element')
           compile = -> up.hello($container)
           expect(compile).toThrowError(/cannot return destructor/i)
 
@@ -171,10 +174,10 @@ describe 'up.syntax', ->
           up.compiler '.bar', { keep: false }, ->
           up.compiler '.bam', { keep: '.partner' }, ->
 
-          $foo = up.hello(affix('.foo'))
-          $bar = up.hello(affix('.bar'))
-          $baz = up.hello(affix('.baz'))
-          $bam = up.hello(affix('.bam'))
+          $foo = $ up.hello(fixture('.foo'))
+          $bar = $ up.hello(fixture('.bar'))
+          $baz = $ up.hello(fixture('.baz'))
+          $bam = $ up.hello(fixture('.bam'))
 
           expect($foo.attr('up-keep')).toEqual('')
           expect($bar.attr('up-keep')).toBeMissing()
@@ -190,7 +193,7 @@ describe 'up.syntax', ->
           up.compiler '.element', { priority: 0 }, -> traces.push('baz')
           up.compiler '.element', { priority: 3 }, -> traces.push('bam')
           up.compiler '.element', { priority: -1 }, -> traces.push('qux')
-          up.hello(affix('.element'))
+          up.hello(fixture('.element'))
           expect(traces).toEqual ['bam', 'bar', 'foo', 'baz', 'qux']
 
         it 'considers priority-less compilers to be priority zero', ->
@@ -198,16 +201,30 @@ describe 'up.syntax', ->
           up.compiler '.element', { priority: 1 }, -> traces.push('foo')
           up.compiler '.element', -> traces.push('bar')
           up.compiler '.element', { priority: -1 }, -> traces.push('baz')
-          up.hello(affix('.element'))
+          up.hello(fixture('.element'))
           expect(traces).toEqual ['foo', 'bar', 'baz']
 
         it 'runs two compilers with the same priority in the order in which they were registered', ->
           traces = []
           up.compiler '.element', { priority: 1 }, -> traces.push('foo')
           up.compiler '.element', { priority: 1 }, -> traces.push('bar')
-          up.hello(affix('.element'))
+          up.hello(fixture('.element'))
           expect(traces).toEqual ['foo', 'bar']
 
+    describe 'up.$compiler', ->
+
+      it 'registers a compiler that receives the element as a jQuery collection', ->
+        observeElement = jasmine.createSpy()
+        up.$compiler '.element', ($element) -> observeElement($element)
+
+        $element = $fixture('.element')
+        up.hello($element)
+
+        expect(observeElement).toHaveBeenCalled()
+        arg = observeElement.calls.argsFor(0)[0]
+        expect(arg).toBeJQuery()
+        expect(arg).toEqual($element)
+
     describe 'up.macro', ->
 
       it 'registers compilers that are run before other compilers', ->
@@ -215,7 +232,7 @@ describe 'up.syntax', ->
         up.compiler '.element', { priority: 10 }, -> traces.push('foo')
         up.compiler '.element', { priority: -1000 }, -> traces.push('bar')
         up.macro '.element', -> traces.push('baz')
-        up.hello(affix('.element'))
+        up.hello(fixture('.element'))
         expect(traces).toEqual ['baz', 'foo' , 'bar']
 
       it 'allows to macros to have priorities of their own', ->
@@ -226,33 +243,49 @@ describe 'up.syntax', ->
         up.macro '.element', { priority: 3 }, -> traces.push('bam')
         up.macro '.element', { priority: -1 }, -> traces.push('qux')
         up.compiler '.element', { priority: 999 }, -> traces.push('ccc')
-        up.hello(affix('.element'))
+        up.hello(fixture('.element'))
         expect(traces).toEqual ['bam', 'bar', 'foo', 'baz', 'qux', 'ccc']
 
       it 'runs two macros with the same priority in the order in which they were registered', ->
         traces = []
         up.macro '.element', { priority: 1 }, -> traces.push('foo')
         up.macro '.element', { priority: 1 }, -> traces.push('bar')
-        up.hello(affix('.element'))
+        up.hello(fixture('.element'))
         expect(traces).toEqual ['foo', 'bar']
 
       it 'allows users to use the built-in [up-expand] from their own macros', ->
-        up.macro '.element', ($element) ->
-          $element.attr('up-expand', '')
-        $element = affix('.element a[href="/foo"][up-target=".target"]')
+        up.macro '.element', (element) ->
+          element.setAttribute('up-expand', '')
+        $element = $fixture('.element a[href="/foo"][up-target=".target"]')
         up.hello($element)
         expect($element.attr('up-target')).toEqual('.target')
         expect($element.attr('up-href')).toEqual('/foo')
 
       it 'allows users to use the built-in [up-dash] from their own macros', ->
-        up.macro '.element', ($element) ->
-          $element.attr('up-dash', '.target')
-        $element = affix('a.element[href="/foo"]')
+        up.macro '.element', (element) ->
+          element.setAttribute('up-dash', '.target')
+        $element = $fixture('a.element[href="/foo"]')
         up.hello($element)
         expect($element.attr('up-target')).toEqual('.target')
         expect($element.attr('up-preload')).toEqual('')
         expect($element.attr('up-instant')).toEqual('')
 
+    describe 'up.$macro', ->
+
+      it 'registers a macro that receives the element as a jQuery collection', ->
+        observeElement = jasmine.createSpy()
+        up.$macro '.element', ($element) -> observeElement('macro', $element)
+        up.$compiler '.element', ($element) -> observeElement('compiler', $element)
+
+        $element = $fixture('.element')
+        up.hello($element)
+
+        expect(observeElement).toHaveBeenCalled()
+        args = observeElement.calls.argsFor(0)
+        expect(args[0]).toEqual('macro')
+        expect(args[1]).toBeJQuery()
+        expect(args[1]).toEqual($element)
+
     describe 'up.hello', ->
 
       it 'should have tests'
@@ -260,15 +293,12 @@ describe 'up.syntax', ->
     describe 'up.syntax.data', ->
 
       it 'returns the [up-data] attribute of the given element, parsed as JSON', ->
-        $element = affix('.element').attr('up-data', '{ "foo": 1, "bar": 2 }')
+        $element = $fixture('.element').attr('up-data', '{ "foo": 1, "bar": 2 }')
         data = up.syntax.data($element)
         expect(data).toEqual(foo: 1, bar: 2)
 
       it 'returns en empty object if the given element has no [up-data] attribute', ->
-        $element = affix('.element')
+        $element = $fixture('.element')
         data = up.syntax.data($element)
         expect(data).toEqual({})
 
-      it 'returns undefined if undefined is passed instead of an element', ->
-        data = up.syntax.data(undefined)
-        expect(data).toBeUndefined()