upjs-rails 0.18.1 → 0.19.0

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

@@ -209,7 +209,7 @@ describe 'up.modal', ->
         $outside = affix('.foo').text('old outside')
         up.modal.visit('/path', target: '.foo')
         @respondWith("<div class='foo'>old inside</div>")
-        up.flow.implant('.foo', "<div class='foo'>new text</div>")
+        up.extract('.foo', "<div class='foo'>new text</div>")
         expect($outside).toBeInDOM()
         expect($outside).toHaveText('old outside')
         expect($('.up-modal-content')).toHaveText('new text')
@@ -218,7 +218,7 @@ describe 'up.modal', ->
         affix('.outside').text('old outside')
         up.modal.visit('/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.outside', "<div class='outside'>new outside</div>", origin: $('.inside'))
+        up.extract('.outside', "<div class='outside'>new outside</div>", origin: $('.inside'))
         expect($('.outside')).toHaveText('new outside')
         expect($('.up-modal')).not.toExist()
 
@@ -226,7 +226,7 @@ describe 'up.modal', ->
         affix('.outside').text('old outside')
         up.modal.visit('/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.inside', "<div class='inside'>new inside</div>", origin: $('.inside'))
+        up.extract('.inside', "<div class='inside'>new inside</div>", origin: $('.inside'))
         expect($('.inside')).toHaveText('new inside')
         expect($('.up-modal')).toExist()
 
@@ -234,7 +234,7 @@ describe 'up.modal', ->
         affix('.outside').text('old outside')
         up.modal.visit('/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.outside', "<div class='outside'>new outside</div>", origin: $('.outside'))
+        up.extract('.outside', "<div class='outside'>new outside</div>", origin: $('.outside'))
         expect($('.outside')).toHaveText('new outside')
         expect($('.up-modal')).toExist()
 
@@ -242,7 +242,7 @@ describe 'up.modal', ->
         affix('.outside').text('old outside')
         up.modal.visit('/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.inside', "<div class='inside'>new inside</div>", origin: $('.outside'))
+        up.extract('.inside', "<div class='inside'>new inside</div>", origin: $('.outside'))
         expect($('.inside')).toHaveText('new inside')
         expect($('.up-modal')).toExist()
 

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

@@ -178,7 +178,7 @@ describe 'up.popup', ->
         $link = affix('.link')
         up.popup.attach($link, href: '/path', target: '.foo')
         @respondWith("<div class='foo'>old inside</div>")
-        up.flow.implant('.foo', "<div class='foo'>new text</div>")
+        up.extract('.foo', "<div class='foo'>new text</div>")
         expect($outside).toBeInDOM()
         expect($outside).toHaveText('old outside')
         expect($('.up-popup')).toHaveText('new text')
@@ -188,7 +188,7 @@ describe 'up.popup', ->
         $link = affix('.link')
         up.popup.attach($link, href: '/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.outside', "<div class='outside'>new outside</div>", origin: $('.inside'))
+        up.extract('.outside', "<div class='outside'>new outside</div>", origin: $('.inside'))
         expect($('.outside')).toHaveText('new outside')
         expect($('.up-popup')).not.toExist()
 
@@ -197,7 +197,7 @@ describe 'up.popup', ->
         $link = affix('.link')
         up.popup.attach($link, href: '/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.inside', "<div class='inside'>new inside</div>", origin: $('.inside'))
+        up.extract('.inside', "<div class='inside'>new inside</div>", origin: $('.inside'))
         expect($('.inside')).toHaveText('new inside')
         expect($('.up-popup')).toExist()
 
@@ -206,7 +206,7 @@ describe 'up.popup', ->
         $link = affix('.link')
         up.popup.attach($link, href: '/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.outside', "<div class='outside'>new outside</div>", origin: $('.outside'))
+        up.extract('.outside', "<div class='outside'>new outside</div>", origin: $('.outside'))
         expect($('.outside')).toHaveText('new outside')
         expect($('.up-popup')).toExist()
 
@@ -215,6 +215,6 @@ describe 'up.popup', ->
         $link = affix('.link')
         up.popup.attach($link, href: '/path', target: '.inside')
         @respondWith("<div class='inside'>old inside</div>")
-        up.flow.implant('.inside', "<div class='inside'>new inside</div>", origin: $('.outside'))
+        up.extract('.inside', "<div class='inside'>new inside</div>", origin: $('.outside'))
         expect($('.inside')).toHaveText('new inside')
         expect($('.up-popup')).toExist()

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

@@ -8,15 +8,15 @@ describe 'up.proxy', ->
       jasmine.clock().install()
       jasmine.clock().mockDate()
 
-    describe 'up.proxy.ajax', ->
+    describe 'up.ajax', ->
 
       it 'caches server responses for 5 minutes', ->
         responses = []
 
         # Send the same request for the same path, 3 minutes apart
-        up.proxy.ajax(url: '/foo').then (data) -> responses.push(data)
+        up.ajax(url: '/foo').then (data) -> responses.push(data)
         jasmine.clock().tick(3 * 60 * 1000)
-        up.proxy.ajax(url: '/foo').then (data) -> responses.push(data)
+        up.ajax(url: '/foo').then (data) -> responses.push(data)
 
         # See that only a single network request was triggered
         expect(jasmine.Ajax.requests.count()).toEqual(1)
@@ -31,7 +31,7 @@ describe 'up.proxy', ->
         # The clock is now a total of 6 minutes after the first request,
         # exceeding the cache's retention time of 5 minutes.
         jasmine.clock().tick(3 * 60 * 1000)
-        up.proxy.ajax(url: '/foo').then (data) -> responses.push(data)
+        up.ajax(url: '/foo').then (data) -> responses.push(data)
 
         # See that we have triggered a second request
         expect(jasmine.Ajax.requests.count()).toEqual(2)
@@ -41,63 +41,63 @@ describe 'up.proxy', ->
         expect(responses).toEqual(['foo', 'foo', 'bar'])
 
       it "doesn't reuse responses when asked for the same path, but different selectors", ->
-        up.proxy.ajax(url: '/path', target: '.a')
-        up.proxy.ajax(url: '/path', target: '.b')
+        up.ajax(url: '/path', target: '.a')
+        up.ajax(url: '/path', target: '.b')
         expect(jasmine.Ajax.requests.count()).toEqual(2)
 
       it "reuses a response for an 'html' selector when asked for the same path and any other selector", ->
-        up.proxy.ajax(url: '/path', target: 'html')
-        up.proxy.ajax(url: '/path', target: 'body')
-        up.proxy.ajax(url: '/path', target: 'p')
-        up.proxy.ajax(url: '/path', target: '.klass')
+        up.ajax(url: '/path', target: 'html')
+        up.ajax(url: '/path', target: 'body')
+        up.ajax(url: '/path', target: 'p')
+        up.ajax(url: '/path', target: '.klass')
         expect(jasmine.Ajax.requests.count()).toEqual(1)
 
       it "reuses a response for a 'body' selector when asked for the same path and any other selector other than 'html'", ->
-        up.proxy.ajax(url: '/path', target: 'body')
-        up.proxy.ajax(url: '/path', target: 'p')
-        up.proxy.ajax(url: '/path', target: '.klass')
+        up.ajax(url: '/path', target: 'body')
+        up.ajax(url: '/path', target: 'p')
+        up.ajax(url: '/path', target: '.klass')
         expect(jasmine.Ajax.requests.count()).toEqual(1)
 
       it "doesn't reuse a response for a 'body' selector when asked for the same path but an 'html' selector", ->
-        up.proxy.ajax(url: '/path', target: 'body')
-        up.proxy.ajax(url: '/path', target: 'html')
+        up.ajax(url: '/path', target: 'body')
+        up.ajax(url: '/path', target: 'html')
         expect(jasmine.Ajax.requests.count()).toEqual(2)
 
       it "doesn't reuse responses for different paths", ->
-        up.proxy.ajax(url: '/foo')
-        up.proxy.ajax(url: '/bar')
+        up.ajax(url: '/foo')
+        up.ajax(url: '/bar')
         expect(jasmine.Ajax.requests.count()).toEqual(2)
 
       u.each ['GET', 'HEAD', 'OPTIONS'], (method) ->
 
         it "caches #{method} requests", ->
-          u.times 2, -> up.proxy.ajax(url: '/foo', method: method)
+          u.times 2, -> up.ajax(url: '/foo', method: method)
           expect(jasmine.Ajax.requests.count()).toEqual(1)
 
         it "does not cache #{method} requests with cache: false option", ->
-          u.times 2, -> up.proxy.ajax(url: '/foo', method: method, cache: false)
+          u.times 2, -> up.ajax(url: '/foo', method: method, cache: false)
           expect(jasmine.Ajax.requests.count()).toEqual(2)
 
       u.each ['POST', 'PUT', 'DELETE'], (method) ->
 
         it "does not cache #{method} requests", ->
-          u.times 2, -> up.proxy.ajax(url: '/foo', method: method)
+          u.times 2, -> up.ajax(url: '/foo', method: method)
           expect(jasmine.Ajax.requests.count()).toEqual(2)
 
         it "caches #{method} requests with cache: true option", ->
-          u.times 2, -> up.proxy.ajax(url: '/foo', method: method, cache: true)
+          u.times 2, -> up.ajax(url: '/foo', method: method, cache: true)
           expect(jasmine.Ajax.requests.count()).toEqual(1)
 
       it 'does not cache responses with a non-200 status code', ->
         # Send the same request for the same path, 3 minutes apart
-        up.proxy.ajax(url: '/foo')
+        up.ajax(url: '/foo')
 
         @respondWith
           status: 500
           contentType: 'text/html'
           responseText: 'foo'
 
-        up.proxy.ajax(url: '/foo')
+        up.ajax(url: '/foo')
 
         expect(jasmine.Ajax.requests.count()).toEqual(2)
 
@@ -116,7 +116,7 @@ describe 'up.proxy', ->
         u.each ['GET', 'POST', 'HEAD', 'OPTIONS'], (method) ->
 
           it "does not change the method of a #{method} request", ->
-            up.proxy.ajax(url: '/foo', method: method)
+            up.ajax(url: '/foo', method: method)
             request = @lastRequest()
             expect(request.method).toEqual(method)
             expect(request.data()['_method']).toBeUndefined()
@@ -124,7 +124,7 @@ describe 'up.proxy', ->
         u.each ['PUT', 'PATCH', 'DELETE'], (method) ->
 
           it "turns a #{method} request into a POST request and sends the actual method as a { _method } param", ->
-            up.proxy.ajax(url: '/foo', method: method)
+            up.ajax(url: '/foo', method: method)
             request = @lastRequest()
             expect(request.method).toEqual('POST')
             expect(request.data()['_method']).toEqual([method])
@@ -140,8 +140,8 @@ describe 'up.proxy', ->
 
         it 'limits the number of concurrent requests', ->
           responses = []
-          up.proxy.ajax(url: '/foo').then (html) -> responses.push(html)
-          up.proxy.ajax(url: '/bar').then (html) -> responses.push(html)
+          up.ajax(url: '/foo').then (html) -> responses.push(html)
+          up.ajax(url: '/bar').then (html) -> responses.push(html)
           expect(jasmine.Ajax.requests.count()).toEqual(1) # only one request was made
           @respondWith('first response', request: jasmine.Ajax.requests.at(0))
           expect(responses).toEqual ['first response']
@@ -150,8 +150,8 @@ describe 'up.proxy', ->
           expect(responses).toEqual ['first response', 'second response']
 
 #        it 'considers preloading links for the request limit', ->
-#          up.proxy.ajax(url: '/foo', preload: true)
-#          up.proxy.ajax(url: '/bar')
+#          up.ajax(url: '/foo', preload: true)
+#          up.ajax(url: '/bar')
 #          expect(jasmine.Ajax.requests.count()).toEqual(1)
 
       describe 'events', ->
@@ -165,14 +165,14 @@ describe 'up.proxy', ->
 
         it 'emits an up:proxy:busy event once the proxy started loading, and up:proxy:idle if it is done loading', ->
   
-          up.proxy.ajax(url: '/foo')
+          up.ajax(url: '/foo')
   
           expect(@events).toEqual([
             'up:proxy:load',
             'up:proxy:busy'
           ])
   
-          up.proxy.ajax(url: '/bar')
+          up.ajax(url: '/bar')
   
           expect(@events).toEqual([
             'up:proxy:load',
@@ -210,14 +210,14 @@ describe 'up.proxy', ->
 
           # A request for preloading preloading purposes
           # doesn't make us busy.
-          up.proxy.ajax(url: '/foo', preload: true)
+          up.ajax(url: '/foo', preload: true)
           expect(@events).toEqual([
             'up:proxy:load'
           ])
           expect(up.proxy.busy()).toBe(false)
 
           # The same request with preloading does make us busy.
-          up.proxy.ajax(url: '/foo')
+          up.ajax(url: '/foo')
           expect(@events).toEqual([
             'up:proxy:load',
             'up:proxy:busy'
@@ -241,7 +241,7 @@ describe 'up.proxy', ->
         it 'can delay the up:proxy:busy event to prevent flickering of spinners', ->
           up.proxy.config.busyDelay = 100
 
-          up.proxy.ajax(url: '/foo')
+          up.ajax(url: '/foo')
           expect(@events).toEqual([
             'up:proxy:load'
           ])
@@ -272,7 +272,7 @@ describe 'up.proxy', ->
         it 'does not emit up:proxy:idle if a delayed up:proxy:busy was never emitted due to a fast response', ->
           up.proxy.config.busyDelay = 100
 
-          up.proxy.ajax(url: '/foo')
+          up.ajax(url: '/foo')
           expect(@events).toEqual([
             'up:proxy:load'
           ])
@@ -293,7 +293,7 @@ describe 'up.proxy', ->
 
         it 'emits up:proxy:idle if a request returned but failed', ->
 
-          up.proxy.ajax(url: '/foo')
+          up.ajax(url: '/foo')
 
           expect(@events).toEqual([
             'up:proxy:load',

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

@@ -15,8 +15,7 @@ describe 'up.syntax', ->
         expect(observeClass).not.toHaveBeenCalledWith('container')
         expect(observeClass).toHaveBeenCalledWith('child')           
   
-      it 'lets allows initializers return a destructor function, which is called when a compiled fragment gets destroyed', ->
-  
+
         destructor = jasmine.createSpy()
         up.compiler '.child', ($element) ->
           destructor
@@ -50,6 +49,48 @@ describe 'up.syntax', ->
 
         expect(observeArgs).toHaveBeenCalledWith('child', {})
 
+      it 'compiles matching elements one-by-one', ->
+        compiler = jasmine.createSpy('compiler')
+        up.compiler '.foo', ($element) -> compiler($element)
+        $container = affix('.container')
+        $first = $container.affix('.foo.first')
+        $second = $container.affix('.foo.second')
+        up.hello($container)
+        expect(compiler.calls.count()).toEqual(2)
+        expect(compiler).toHaveBeenCalledWith($first)
+        expect(compiler).toHaveBeenCalledWith($second)
+
+      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.hello($container)
+          expect(compiler.calls.count()).toEqual(1)
+          expect(compiler).toHaveBeenCalledWith($both)
+
+      describe 'with { keep } option', ->
+
+        it 'adds an up-keep attribute to the fragment during compilation', ->
+
+          up.compiler '.foo', { keep: true }, ->
+          up.compiler '.bar', { }, ->
+          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'))
+
+          expect($foo.attr('up-keep')).toEqual('')
+          expect($bar.attr('up-keep')).toBeMissing()
+          expect($baz.attr('up-keep')).toBeMissing()
+          expect($bam.attr('up-keep')).toEqual('.partner')
 
     describe 'up.hello', ->
 

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

@@ -87,6 +87,40 @@ describe 'up.util', ->
         $element = affix('div').attr('foo', 'some text')
         expect(up.util.castedAttr($element, 'foo')).toBe('some text')
 
+    describe 'up.util.any', ->
+
+      it 'returns true if an element in the array returns true for the given function', ->
+        result = up.util.any [null, undefined, 'foo', ''], up.util.isPresent
+        expect(result).toBe(true)
+
+      it 'returns false if no element in the array returns true for the given function', ->
+        result = up.util.any [null, undefined, ''], up.util.isPresent
+        expect(result).toBe(false)
+
+      it 'short-circuits once an element returns true', ->
+        count = 0
+        up.util.any [null, undefined, 'foo', ''], (element) ->
+          count += 1
+          up.util.isPresent(element)
+        expect(count).toBe(3)
+
+    describe 'up.util.all', ->
+
+      it 'returns true if all element in the array returns true for the given function', ->
+        result = up.util.all ['foo', 'bar', 'baz'], up.util.isPresent
+        expect(result).toBe(true)
+
+      it 'returns false if an element in the array returns false for the given function', ->
+        result = up.util.all ['foo', 'bar', null, 'baz'], up.util.isPresent
+        expect(result).toBe(false)
+
+      it 'short-circuits once an element returns false', ->
+        count = 0
+        up.util.all ['foo', 'bar', '', 'baz'], (element) ->
+          count += 1
+          up.util.isPresent(element)
+        expect(count).toBe(3)
+
     describe 'up.util.isBlank', ->
   
       it 'returns false for false', ->
@@ -170,12 +204,122 @@ describe 'up.util', ->
           object.reset()
           expect(object.reset).toBeDefined()
 
-    describe 'up.util.requestDataAsQueryString', ->
+    describe 'up.util.requestDataAsQuery', ->
 
-      it 'returns the query section for the given object, including the question mark', ->
-        string = up.util.requestDataAsQueryString('foo-key': 'foo value', 'bar-key': 'bar value')
-        expect(string).toEqual('?foo-key=foo%20value&bar-key=bar%20value')
+      encodedOpeningBracket = '%5B'
+      encodedClosingBracket = '%5D'
+      encodedSpace = '%20'
 
-      it 'returns an empty string', ->
-        string = up.util.requestDataAsQueryString({})
+      it 'returns the query section for the given object', ->
+        string = up.util.requestDataAsQuery('foo-key': 'foo value', 'bar-key': 'bar value')
+        expect(string).toEqual("foo-key=foo#{encodedSpace}value&bar-key=bar#{encodedSpace}value")
+
+      it 'returns the query section for the given nested object', ->
+        string = up.util.requestDataAsQuery('foo-key': { 'bar-key': 'bar-value' }, 'bam-key': 'bam-value')
+        expect(string).toEqual("foo-key#{encodedOpeningBracket}bar-key#{encodedClosingBracket}=bar-value&bam-key=bam-value")
+
+      it 'returns the query section for the given array with { name } and { value } keys', ->
+        string = up.util.requestDataAsQuery([
+          { name: 'foo-key', value: 'foo value' },
+          { name: 'bar-key', value: 'bar value' }
+        ])
+        expect(string).toEqual("foo-key=foo#{encodedSpace}value&bar-key=bar#{encodedSpace}value")
+
+      it 'returns an empty string for an empty object', ->
+        string = up.util.requestDataAsQuery({})
+        expect(string).toEqual('')
+
+      it 'returns an empty string for an empty string', ->
+        string = up.util.requestDataAsQuery('')
+        expect(string).toEqual('')
+
+      it 'returns an empty string for undefined', ->
+        string = up.util.requestDataAsQuery(undefined)
         expect(string).toEqual('')
+
+      it 'URL-encodes characters in the key and value', ->
+        string = up.util.requestDataAsQuery({ 'äpfel': 'bäume' })
+        expect(string).toEqual('%C3%A4pfel=b%C3%A4ume')
+
+      it 'URL-encodes plus characters', ->
+        string = up.util.requestDataAsQuery({ 'my+key': 'my+value' })
+        expect(string).toEqual('my%2Bkey=my%2Bvalue')
+
+
+    describe 'up.util.requestDataAsArray', ->
+
+      it 'normalized null to an empty array', ->
+        array = up.util.requestDataAsArray(null)
+        expect(array).toEqual([])
+
+      it 'normalized undefined to an empty array', ->
+        array = up.util.requestDataAsArray(undefined)
+        expect(array).toEqual([])
+
+      it 'normalizes an object hash to an array of objects with { name } and { value } keys', ->
+        array = up.util.requestDataAsArray(
+          'foo-key': 'foo-value'
+          'bar-key': 'bar-value'
+        )
+        expect(array).toEqual([
+          { name: 'foo-key', value: 'foo-value' },
+          { name: 'bar-key', value: 'bar-value' },
+        ])
+
+      it 'normalizes a nested object hash to a flat array using param naming conventions', ->
+        array = up.util.requestDataAsArray(
+          'foo-key': 'foo-value'
+          'bar-key': {
+            'bam-key': 'bam-value'
+            'baz-key': {
+              'qux-key': 'qux-value'
+            }
+          }
+        )
+        expect(array).toEqual([
+          { name: 'foo-key', value: 'foo-value' },
+          { name: 'bar-key[bam-key]', value: 'bam-value' },
+          { name: 'bar-key[baz-key][qux-key]', value: 'qux-value' },
+        ])
+
+      it 'returns a given array without modification', ->
+        array = up.util.requestDataAsArray([
+          { name: 'foo-key', value: 'foo-value' },
+          { name: 'bar-key', value: 'bar-value' },
+        ])
+        expect(array).toEqual([
+          { name: 'foo-key', value: 'foo-value' },
+          { name: 'bar-key', value: 'bar-value' },
+        ])
+
+      it 'does not URL-encode special characters keys or values', ->
+        array = up.util.requestDataAsArray(
+          'äpfel': { 'bäume': 'börse' }
+        )
+        expect(array).toEqual([
+          { name: 'äpfel[bäume]', value: 'börse' },
+        ])
+
+      it 'does not URL-encode spaces in keys or values', ->
+        array = up.util.requestDataAsArray(
+          'my key': 'my value'
+        )
+        expect(array).toEqual([
+          { name: 'my key', value: 'my value' },
+        ])
+
+      it 'does not URL-encode ampersands in keys or values', ->
+        array = up.util.requestDataAsArray(
+          'my&key': 'my&value'
+        )
+        expect(array).toEqual([
+          { name: 'my&key', value: 'my&value' },
+        ])
+
+      it 'does not URL-encode equal signs in keys or values', ->
+        array = up.util.requestDataAsArray(
+          'my=key': 'my=value'
+        )
+        expect(array).toEqual([
+          { name: 'my=key', value: 'my=value' },
+        ])