unpoly-rails 0.24.1 → 0.25.0

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

@@ -47,50 +47,230 @@ describe 'up.modal', ->
 
     describe 'up.modal.visit', ->
 
-      it "brings its own scrollbar, padding the body on the right in order to prevent jumping", (done) ->
-        promise = up.modal.visit('/foo', target: '.container')
+      describe 'preventing elements from jumping as scrollbars change', ->
 
-        @respondWith('<div class="container">text</div>')
+        it "brings its own scrollbar, padding the body on the right", (done) ->
+          promise = up.modal.visit('/foo', target: '.container')
 
-        promise.then ->
+          @respondWith('<div class="container">text</div>')
+
+          promise.then ->
+            $modal = $('.up-modal')
+            $viewport = $modal.find('.up-modal-viewport')
+            $body = $('body')
+            expect($modal).toExist()
+            expect($viewport.css('overflow-y')).toEqual('scroll')
+            expect($body.css('overflow-y')).toEqual('hidden')
+            expect(parseInt($body.css('padding-right'))).toBeAround(assumedScrollbarWidth, 5)
+
+            up.modal.close().then ->
+              expect($body.css('overflow-y')).toEqual('scroll')
+              expect(parseInt($body.css('padding-right'))).toBe(0)
+              done()
+
+        it "gives the scrollbar to .up-modal instead of .up-modal-viewport while animating, so we don't see scaled scrollbars in a zoom-in animation", (done) ->
+          openPromise = up.modal.extract('.container', '<div class="container">text</div>', animation: 'fade-in', duration: 100)
           $modal = $('.up-modal')
           $viewport = $modal.find('.up-modal-viewport')
-          $body = $('body')
-          expect($modal).toExist()
-          expect($viewport.css('overflow-y')).toEqual('scroll')
-          expect($body.css('overflow-y')).toEqual('hidden')
-          expect(parseInt($body.css('padding-right'))).toBeAround(assumedScrollbarWidth, 10)
-
-          up.modal.close().then ->
-            expect($body.css('overflow-y')).toEqual('scroll')
+          expect($modal.css('overflow-y')).toEqual('scroll')
+          expect($viewport.css('overflow-y')).toEqual('hidden')
+          openPromise.then ->
+            expect($modal.css('overflow-y')).toEqual('auto')
+            expect($viewport.css('overflow-y')).toEqual('scroll')
+            closePromise = up.modal.close(animation: 'fade-out', duration: 100)
+            expect($modal.css('overflow-y')).toEqual('scroll')
+            expect($viewport.css('overflow-y')).toEqual('hidden')
+            done()
+
+
+        it 'does not add right padding to the body if the body has overflow-y: hidden', (done) ->
+          restoreBody = u.temporaryCss($('body'), 'overflow-y': 'hidden')
+
+          up.modal.extract('.container', '<div class="container">text</div>').then ->
+            $body = $('body')
+            expect($('.up-modal')).toExist()
             expect(parseInt($body.css('padding-right'))).toBe(0)
 
-            done()
+            up.modal.close().then ->
+              expect(parseInt($body.css('padding-right'))).toBe(0)
+              restoreBody()
+              done()
 
-      it 'pushes right-anchored elements away from the edge of the screen in order to prevent jumping', (done) ->
+        it 'does not add right padding to the body if the body has overflow-y: auto, but does not currently have scrollbars', (done) ->
+          restoreBody = u.temporaryCss($('body'), 'overflow-y': 'auto')
+          restoreReporter = u.temporaryCss($('.jasmine_html-reporter'), 'height': '100px', 'overflow-y': 'hidden')
 
-        $anchoredElement = affix('div[up-anchored=right]').css
-          position: 'absolute'
-          top: '0'
-          right: '30px'
+          up.modal.extract('.container', '<div class="container">text</div>').then ->
+            $body = $('body')
+            expect($('.up-modal')).toExist()
+            expect(parseInt($body.css('padding-right'))).toBe(0)
 
-        promise = up.modal.visit('/foo', target: '.container')
+            up.modal.close().then ->
+              expect(parseInt($body.css('padding-right'))).toBe(0)
+              restoreReporter()
+              restoreBody()
+              done()
 
-        @respondWith('<div class="container">text</div>')
+        it 'pushes right-anchored elements away from the edge of the screen', (done) ->
 
-        promise.then ->
-          expect(parseInt($anchoredElement.css('right'))).toBeAround(30 + assumedScrollbarWidth, 10)
+          $anchoredElement = affix('div[up-anchored=right]').css
+            position: 'absolute'
+            top: '0'
+            right: '30px'
+
+          promise = up.modal.visit('/foo', target: '.container')
+
+          @respondWith('<div class="container">text</div>')
+
+          promise.then ->
+            expect(parseInt($anchoredElement.css('right'))).toBeAround(30 + assumedScrollbarWidth, 10)
+
+            up.modal.close().then ->
+              expect(parseInt($anchoredElement.css('right'))).toBeAround(30 , 10)
+              done()
+
+      describe 'opening a modal while another modal is open', ->
+
+        it 'does not open multiple modals or pad the body twice if the user starts loading a second modal before the first was done loading', (done) ->
+          up.modal.config.closeDuration = 10
+          promise1 = up.modal.visit('/path1', target: '.container', animation: 'fade-in', duration: 100)
+          promise2 = up.modal.visit('/path2', target: '.container', animation: 'fade-in', duration: 100)
+          expect(jasmine.Ajax.requests.count()).toBe(2)
+          request1 = jasmine.Ajax.requests.at(0)
+          request2 = jasmine.Ajax.requests.at(1)
+
+          u.setTimer 10, =>
+            @respondWith('<div class="container">response1</div>', request: request1)
+            u.setTimer 10, =>
+              @respondWith('<div class="container">response2</div>', request: request2)
+              u.setTimer 50, =>
+                expect($('.up-modal').length).toBe(1)
+                expect($('.up-modal-dialog').length).toBe(1)
+                expect($('.container')).toHaveText('response2')
+                bodyPadding = parseInt($('body').css('padding-right'))
+                expect(bodyPadding).toBeAround(assumedScrollbarWidth, 10)
+                expect(bodyPadding).not.toBeAround(2 * assumedScrollbarWidth, 2 * 5)
+                done()
+
+        it 'closes the current modal and wait for its close animation to finish before starting the open animation of a second modal', (done) ->
+          up.modal.config.openAnimation = 'fade-in'
+          up.modal.config.openDuration = 5
+          up.modal.config.closeAnimation = 'fade-out'
+          up.modal.config.closeDuration = 50
+
+          events = []
+          u.each ['up:modal:open', 'up:modal:opened', 'up:modal:close', 'up:modal:closed'], (event) ->
+            up.on event, ->
+              events.push(event)
+
+          up.modal.extract('.target', '<div class="target">response1</div>')
+
+          # First modal is starting opening animation
+          expect(events).toEqual ['up:modal:open']
+          expect($('.target')).toHaveText('response1')
+
+          u.setTimer 40, ->
+            # First modal has completed opening animation
+            expect(events).toEqual ['up:modal:open', 'up:modal:opened']
+            expect($('.target')).toHaveText('response1')
+
+            up.modal.extract('.target', '<div class="target">response2</div>')
+
+            # First modal is starting close animation. Second modal waits for that.
+            expect(events).toEqual ['up:modal:open', 'up:modal:opened', 'up:modal:open', 'up:modal:close']
+            expect($('.target')).toHaveText('response1')
+
+            u.setTimer 40, ->
+
+              # Second modal is still waiting for first modal's closing animaton to finish.
+              expect(events).toEqual ['up:modal:open', 'up:modal:opened', 'up:modal:open', 'up:modal:close']
+              expect($('.target')).toHaveText('response1')
+
+              u.setTimer 100, ->
+
+                # First modal has finished closing, second modal has finished opening.
+                expect(events).toEqual ['up:modal:open', 'up:modal:opened', 'up:modal:open', 'up:modal:close', 'up:modal:closed', 'up:modal:opened']
+                expect($('.target')).toHaveText('response2')
+
+                done()
+
+        it 'closes an opening modal if a second modal starts opening before the first modal has finished its open animation', (done) ->
+          up.modal.config.openAnimation = 'fade-in'
+          up.modal.config.openDuration = 50
+          up.modal.config.closeAnimation = 'fade-out'
+          up.modal.config.closeDuration = 50
+
+          up.modal.extract('.target', '<div class="target">response1</div>')
+
+          u.setTimer 10, ->
+            # First modal is still in its opening animation
+            expect($('.target')).toHaveText('response1')
+
+            up.modal.extract('.target', '<div class="target">response2</div>')
+
+            # First modal is starting close animation. Second modal waits for that.
+            expect($('.target')).toHaveText('response1')
+
+            u.setTimer 10, ->
+              # Second modal is still waiting for first modal's closing animaton to finish.
+              expect($('.target')).toHaveText('response1')
+
+              u.setTimer 90, ->
+                # First modal has finished closing, second modal has finished opening.
+                expect($('.target')).toHaveText('response2')
+
+                done()
+
+        it 'uses the correct flavor config for the first and second modal', (done) ->
+          up.modal.config.openAnimation = 'fade-in'
+          up.modal.config.openDuration = 10
+          up.modal.config.closeAnimation = 'fade-out'
+          up.modal.config.closeDuration = 10
+          up.modal.flavor 'drawer',
+            openAnimation: 'move-from-right'
+            closeAnimation: 'move-to-right'
+
+          animations = []
+          spyOn(up, 'animate').and.callFake ($element, animation, options) ->
+            if $element.is('.up-modal-viewport')
+              animations.push
+                text: u.trim($element.find('.target').text())
+                animation: animation
+            deferred = $.Deferred()
+            u.setTimer options.duration, -> deferred.resolve()
+            deferred.promise()
+
+          up.modal.extract('.target', '<div class="target">response1</div>')
+          expect(animations).toEqual [
+            { animation: 'fade-in', text: 'response1' }
+          ]
+
+          up.modal.extract('.target', '<div class="target">response2</div>', flavor: 'drawer')
+
+          expect(animations).toEqual [
+            { animation: 'fade-in', text: 'response1' },
+            { animation: 'fade-out', text: 'response1' }
+          ]
+
+          u.setTimer 20, ->
+
+            expect(animations).toEqual [
+              { animation: 'fade-in', text: 'response1' },
+              { animation: 'fade-out', text: 'response1' },
+              { animation: 'move-from-right', text: 'response2' }
+            ]
+
+            expect($('.up-modal').attr('up-flavor')).toEqual('drawer')
 
-          up.modal.close().then ->
-            expect(parseInt($anchoredElement.css('right'))).toBeAround(30 , 10)
             done()
 
-      it 'does not explode if the modal was closed before the response was received', ->
-        up.modal.visit('/foo', target: '.container')
-        up.modal.close()
-        respond = => @respondWith('<div class="container">text</div>')
-        expect(respond).not.toThrowError()
-        expect($('.up-error')).not.toExist()
+
+        it 'does not explode if up.modal.close() was called before the response was received', ->
+          up.modal.visit('/foo', target: '.container')
+          up.modal.close()
+          respond = => @respondWith('<div class="container">text</div>')
+          expect(respond).not.toThrowError()
+          expect($('.up-error')).not.toExist()
 
     describe 'up.modal.coveredUrl', ->
 
@@ -107,6 +287,28 @@ describe 'up.modal', ->
               expect(up.modal.coveredUrl()).toBeUndefined()
               done()
 
+    describe 'up.modal.flavor', ->
+
+      it 'registers a new modal variant with its own default configuration', ->
+        up.modal.flavor('variant', { maxWidth: 200 })
+        $link = affix('a[href="/path"][up-modal=".target"][up-flavor="variant"]')
+        Trigger.click($link)
+        @respondWith('<div class="target">new text</div>')
+        $modal = $('.up-modal')
+        $dialog = $modal.find('.up-modal-dialog')
+        expect($modal).toBeInDOM()
+        expect($modal.attr('up-flavor')).toEqual('variant')
+        expect($dialog.attr('style')).toContain('max-width: 200px')
+
+      it 'does not change the configuration of non-flavored modals', ->
+        up.modal.flavor('variant', { maxWidth: 200 })
+        $link = affix('a[href="/path"][up-modal=".target"]')
+        Trigger.click($link)
+        @respondWith('<div class="target">new text</div>')
+        $modal = $('.up-modal')
+        $dialog = $modal.find('.up-modal-dialog')
+        expect($modal).toBeInDOM()
+        expect($dialog.attr('style')).toBeBlank()
 
     describe 'up.modal.close', ->
 

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

@@ -10,17 +10,29 @@ describe 'up.motion', ->
 
         it 'animates the given element', (done) ->
           $element = affix('.element').text('content')
-          opacity = -> Number($element.css('opacity'))
           up.animate($element, 'fade-in', duration: 200, easing: 'linear')
 
           u.setTimer 0, ->
-            expect(opacity()).toBeAround(0.0, 0.25)
+            expect(u.opacity($element)).toBeAround(0.0, 0.25)
           u.setTimer 100, ->
-            expect(opacity()).toBeAround(0.5, 0.25)
+            expect(u.opacity($element)).toBeAround(0.5, 0.25)
           u.setTimer 200, ->
-            expect(opacity()).toBeAround(1.0, 0.25)
+            expect(u.opacity($element)).toBeAround(1.0, 0.25)
             done()
 
+        it 'returns a promise that is resolved when the animation completed', (done) ->
+          $element = affix('.element').text('content')
+          resolveSpy = jasmine.createSpy('resolve')
+
+          promise = up.animate($element, 'fade-in', duration: 100, easing: 'linear')
+          promise.then(resolveSpy)
+
+          u.setTimer 50, ->
+            expect(resolveSpy).not.toHaveBeenCalled()
+            u.setTimer 70, ->
+              expect(resolveSpy).toHaveBeenCalled()
+              done()
+
         it 'cancels an existing animation on the element by instantly jumping to the last frame', ->
           $element = affix('.element').text('content')
           up.animate($element, { 'font-size': '40px' }, duration: 10000, easing: 'linear')
@@ -74,17 +86,15 @@ describe 'up.motion', ->
         it 'restores existing transitions on the element', ->
           $element = affix('.element').text('content')
           $element.css('transition': 'font-size 3s ease')
-          oldTransition = $element.css('transition')
-          expect(oldTransition).toContain('font-size') # be paranoid
+          oldTransitionProperty = $element.css('transition-property')
+          expect(oldTransitionProperty).toContain('font-size') # be paranoid
           up.animate($element, 'fade-in', duration: 10000)
           up.motion.finish($element)
-          expect(Number($element.css('opacity'))).toEqual(1)
-          currentTransition = $element.css('transition')
-          expect(currentTransition).toEqual(oldTransition)
-          expect(currentTransition).toContain('font-size')
-          expect(currentTransition).not.toContain('opacity')
-          expect(currentTransition).not.toContain('none')
-          expect(currentTransition).not.toContain('all')
+          expect(u.opacity($element)).toEqual(1)
+          currentTransitionProperty = $element.css('transition-property')
+          expect(currentTransitionProperty).toEqual(oldTransitionProperty)
+          expect(currentTransitionProperty).toContain('font-size')
+          expect(currentTransitionProperty).not.toContain('opacity')
 
         it 'cancels an existing transition on the element by instantly jumping to the last frame', ->
           $old = affix('.old').text('old content')
@@ -136,17 +146,15 @@ describe 'up.motion', ->
           up.animate($element1, 'fade-in', duration: 3000)
           up.animate($element2, 'fade-in', duration: 3000)
 
-          opacity = ($element) -> Number($element.css('opacity'))
-
-          expect(opacity($element1)).toBeAround(0.0, 0.1)
-          expect(opacity($element2)).toBeAround(0.0, 0.1)
+          expect(u.opacity($element1)).toBeAround(0.0, 0.1)
+          expect(u.opacity($element2)).toBeAround(0.0, 0.1)
 
           up.motion.finish()
 
           $element1 = $('.element1')
           $element2 = $('.element2')
-          expect(opacity($element1)).toBe(1.0)
-          expect(opacity($element2)).toBe(1.0)
+          expect(u.opacity($element1)).toBe(1.0)
+          expect(u.opacity($element2)).toBe(1.0)
 
     describe 'up.morph', ->
 
@@ -222,19 +230,17 @@ describe 'up.motion', ->
             height:   '23px'
           )
 
-          opacity = ($element) -> Number($element.css('opacity'))
-
           u.setTimer 0, ->
-            expect(opacity($newGhost)).toBeAround(0.0, 0.25)
-            expect(opacity($oldGhost)).toBeAround(1.0, 0.25)
+            expect(u.opacity($newGhost)).toBeAround(0.0, 0.25)
+            expect(u.opacity($oldGhost)).toBeAround(1.0, 0.25)
 
           u.setTimer 80, ->
-            expect(opacity($newGhost)).toBeAround(0.4, 0.25)
-            expect(opacity($oldGhost)).toBeAround(0.6, 0.25)
+            expect(u.opacity($newGhost)).toBeAround(0.4, 0.25)
+            expect(u.opacity($oldGhost)).toBeAround(0.6, 0.25)
 
           u.setTimer 140, ->
-            expect(opacity($newGhost)).toBeAround(0.7, 0.25)
-            expect(opacity($oldGhost)).toBeAround(0.3, 0.25)
+            expect(u.opacity($newGhost)).toBeAround(0.7, 0.25)
+            expect(u.opacity($oldGhost)).toBeAround(0.3, 0.25)
 
           u.setTimer 250, ->
             # Once our two ghosts have rendered their visual effect,

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

@@ -43,6 +43,78 @@ describe 'up.popup', ->
         expect(respond).not.toThrowError()
         expect($('.up-error')).not.toExist()
 
+      describe 'with { html } option', ->
+
+        it 'extracts the selector from the given HTML string', ->
+          $span = affix('span')
+          up.popup.attach($span, target: '.container', html: "<div class='container'>container contents</div>")
+          expect($('.up-popup')).toHaveText('container contents')
+
+      describe 'opening a popup while another modal is open', ->
+
+        it 'does not open multiple popups or pad the body twice if the user starts loading a second popup before the first was done loading', (done) ->
+          $span = affix('span')
+          up.popup.config.closeDuration = 10
+          promise1 = up.popup.attach($span, url: '/path1', target: '.container', animation: 'fade-in', duration: 100)
+          promise2 = up.popup.attach($span, url: '/path2', target: '.container', animation: 'fade-in', duration: 100)
+          expect(jasmine.Ajax.requests.count()).toBe(2)
+          request1 = jasmine.Ajax.requests.at(0)
+          request2 = jasmine.Ajax.requests.at(1)
+
+          u.setTimer 10, =>
+            @respondWith('<div class="container">response1</div>', request: request1)
+            u.setTimer 10, =>
+              @respondWith('<div class="container">response2</div>', request: request2)
+              u.setTimer 30, =>
+                expect($('.up-popup').length).toBe(1)
+                expect($('.container')).toHaveText('response2')
+                done()
+
+        it 'closes the current popup and wait for its close animation to finish before starting the open animation of a second popup', (done) ->
+          $span = affix('span')
+          up.popup.config.openAnimation = 'fade-in'
+          up.popup.config.openDuration = 5
+          up.popup.config.closeAnimation = 'fade-out'
+          up.popup.config.closeDuration = 50
+
+          events = []
+          u.each ['up:popup:open', 'up:popup:opened', 'up:popup:close', 'up:popup:closed'], (event) ->
+            up.on event, ->
+              events.push(event)
+
+          up.popup.attach($span, { target: '.target', html: '<div class="target">response1</div>' })
+
+          # First popup is starting opening animation
+          expect(events).toEqual ['up:popup:open']
+          expect($('.target')).toHaveText('response1')
+
+          u.setTimer 30, ->
+            # First popup has completed opening animation
+            expect(events).toEqual ['up:popup:open', 'up:popup:opened']
+            expect($('.target')).toHaveText('response1')
+
+            up.popup.attach($span, { target: '.target', html: '<div class="target">response2</div>' })
+
+            # First popup is starting close animation. Second popup waits for that.
+            expect(events).toEqual ['up:popup:open', 'up:popup:opened', 'up:popup:open', 'up:popup:close']
+            expect($('.target')).toHaveText('response1')
+
+            u.setTimer 15, ->
+
+              # Second popup is still waiting for first popup's closing animaton to finish.
+              expect(events).toEqual ['up:popup:open', 'up:popup:opened', 'up:popup:open', 'up:popup:close']
+              expect($('.target')).toHaveText('response1')
+
+              u.setTimer 100, ->
+
+                # First popup has finished closing, second popup has finished opening.
+                expect(events).toEqual ['up:popup:open', 'up:popup:opened', 'up:popup:open', 'up:popup:close', 'up:popup:closed', 'up:popup:opened']
+                expect($('.target')).toHaveText('response2')
+
+                done()
+
+
+
     describe 'up.popup.coveredUrl', ->
 
       describeCapability 'canPushState', ->

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

@@ -15,15 +15,28 @@ describe 'up.syntax', ->
         expect(observeClass).not.toHaveBeenCalledWith('container')
         expect(observeClass).toHaveBeenCalledWith('child')           
 
-        destructor = jasmine.createSpy('destructor')
-        up.compiler '.child', ($element) ->
-          destructor
-  
-        up.hello(affix('.container .child'))
-        expect(destructor).not.toHaveBeenCalled()
-        
-        up.destroy('.container')
-        expect(destructor).toHaveBeenCalled()
+      describe 'destructors', ->
+
+        it 'allows initializers to return a function that is called when the compiled element is removed', ->
+          destructor = jasmine.createSpy('destructor')
+          up.compiler '.child', ($element) ->
+            destructor
+
+          up.hello(affix('.container .child'))
+          expect(destructor).not.toHaveBeenCalled()
+
+          up.destroy('.container')
+          expect(destructor).toHaveBeenCalled()
+
+        it 'does not throw an error if both container and child have a destructor, and the container gets destroyed', ->
+          up.compiler '.container', ($element) ->
+            return (->)
+
+          up.compiler '.child', ($element) ->
+            return (->)
+
+          destruction = -> up.destroy('.container')
+          expect(destruction).not.toThrowError()
 
       it 'parses an up-data attribute as JSON and passes the parsed object as a second argument to the initializer', ->
 
@@ -101,7 +114,7 @@ describe 'up.syntax', ->
           up.compiler '.element', { priority: 3 }, -> traces.push('bam')
           up.compiler '.element', { priority: -1 }, -> traces.push('qux')
           up.hello(affix('.element'))
-          expect(traces).toEqual ['qux', 'baz', 'foo', 'bar', 'bam']
+          expect(traces).toEqual ['bam', 'bar', 'foo', 'baz', 'qux']
 
         it 'considers priority-less compilers to be priority zero', ->
           traces = []
@@ -109,7 +122,7 @@ describe 'up.syntax', ->
           up.compiler '.element', -> traces.push('bar')
           up.compiler '.element', { priority: -1 }, -> traces.push('baz')
           up.hello(affix('.element'))
-          expect(traces).toEqual ['baz', 'bar', 'foo']
+          expect(traces).toEqual ['foo', 'bar', 'baz']
 
         it 'runs two compilers with the same priority in the order in which they were registered', ->
           traces = []
@@ -126,7 +139,7 @@ describe 'up.syntax', ->
         up.compiler '.element', { priority: -1000 }, -> traces.push('bar')
         up.macro '.element', -> traces.push('baz')
         up.hello(affix('.element'))
-        expect(traces).toEqual ['baz', 'bar' , 'foo']
+        expect(traces).toEqual ['baz', 'foo' , 'bar']
 
       it 'allows to macros to have priorities of their own', ->
         traces = []
@@ -135,8 +148,33 @@ describe 'up.syntax', ->
         up.macro '.element', { priority: 0 }, -> traces.push('baz')
         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'))
+        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'))
-        expect(traces).toEqual ['qux', 'baz', 'foo', 'bar', 'bam']
+        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.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.hello($element)
+        expect($element.attr('up-target')).toEqual('.target')
+        expect($element.attr('up-preload')).toEqual('')
+        expect($element.attr('up-instant')).toEqual('')
 
     describe 'up.hello', ->
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unpoly-rails
 version: !ruby/object:Gem::Version
-  version: 0.24.1
+  version: 0.25.0
 platform: ruby
 authors:
 - Henning Koch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-07 00:00:00.000000000 Z
+date: 2016-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails