unpoly-rails 0.37.0 → 0.50.0

data/spec_app/spec/javascripts/helpers/async_sequence.js.coffee

@@ -0,0 +1,102 @@
+u = up.util
+
+LOG_ENABLED = false
+
+unstubbedSetTimeout = window.setTimeout
+
+window.asyncSpec = (args...) ->
+  (originalDone) ->
+
+    done = ->
+      # For some reason Jasmine ignores done() calls if its own clock is stubbed
+      jasmine.clock().uninstall()
+      originalDone()
+
+    fail = (args...) ->
+      # For some reason Jasmine ignores done() calls if its own clock is stubbed
+      jasmine.clock().uninstall()
+      originalDone.fail(args...)
+
+    plan = args.pop()
+
+    queue = []
+
+    insertCursor = 0
+
+    log = (args...) ->
+      if LOG_ENABLED
+        args[0] = "[asyncSpec] #{args[0]}"
+        up.log.debug(args...)
+
+    insertAtCursor = (task) ->
+      log('Inserting task at index %d: %o', insertCursor, task)
+      # We insert at pointer instead of pushing to the end.
+      # This way tasks can insert additional tasks at runtime.
+      queue.splice(insertCursor, 0, task)
+      insertCursor++
+
+    next = (block) ->
+      insertAtCursor [0, block, 'sync']
+
+    next.next = next # alternative API
+
+    next.after = (delay, block) ->
+      insertAtCursor [delay, block, 'sync']
+
+    next.await = (block) ->
+      insertAtCursor  [0, block, 'async']
+
+    next.fail = fail
+
+    # Call example body
+    plan.call(this, next)
+
+    runBlockSyncAndPoke = (block) ->
+      try
+        log('runBlockSync')
+        block()
+        pokeQueue()
+      catch e
+        fail(e)
+        throw e
+
+    runBlockAsyncThenPoke = (blockOrPromise) ->
+      log('runBlockAsync')
+      # On plan-level people will usually pass a function returning a promise.
+      # During runtime people will usually pass a promise to delay the next step.
+      promise = if u.isPromise(blockOrPromise) then blockOrPromise else blockOrPromise()
+      promise.then -> pokeQueue()
+      promise.catch (e) -> fail(e)
+
+    pokeQueue = ->
+      if entry = queue[runtimeCursor]
+        log('Playing task at index %d', runtimeCursor)
+        runtimeCursor++
+        insertCursor++
+
+        timing = entry[0]
+        block = entry[1]
+        callStyle = entry[2]
+
+        log('Task is %s after %d ms: %o', callStyle, timing, block)
+
+        switch timing
+          when 'now'
+            runBlockSyncAndPoke(block)
+          else
+            fun = ->
+              # Move the block behind the microtask queue of that frame
+              Promise.resolve().then ->
+                if callStyle == 'sync'
+                  runBlockSyncAndPoke(block)
+                else # async
+                  runBlockAsyncThenPoke(block)
+
+            # Also move to the next frame
+            unstubbedSetTimeout(fun, timing)
+      else
+        log('calling done()')
+        done()
+
+    runtimeCursor = insertCursor = 0
+    pokeQueue()

data/spec_app/spec/javascripts/helpers/last_request.js.coffee

@@ -13,7 +13,7 @@ beforeEach ->
       options = args[0] || {}
     else
       options = firstArg
-      responseText = options.responseText
+      responseText = options.responseText || 'response-text'
     request = options.request || @lastRequest()
     request.respondWith
       status: options.status || 200

data/spec_app/spec/javascripts/helpers/mock_ajax.js.coffee

@@ -1,5 +1,8 @@
 beforeEach ->
   jasmine.Ajax.install()
 
-afterEach ->
-  jasmine.Ajax.uninstall()
+afterEach (done) ->
+  up.util.nextFrame ->
+    jasmine.Ajax.uninstall()
+    done()
+

data/spec_app/spec/javascripts/helpers/promise_state.js

@@ -0,0 +1,18 @@
+function promiseState(promise) {
+  var uniqueValue = window['Symbol'] ? Symbol('unique') : Math.random().toString(36)
+
+  function notifyPendingOrResolved(value) {
+    if (value === uniqueValue) {
+      return Promise.resolve({ state: 'pending' })
+    } else {
+      return Promise.resolve({ state: 'fulfilled', value: value })
+    }
+  }
+
+  function notifyRejected(reason) {
+    return Promise.resolve({ state: 'rejected', value: reason })
+  }
+
+  var race = [promise, Promise.resolve(uniqueValue)]
+  return Promise.race(race).then(notifyPendingOrResolved, notifyRejected)
+}

data/spec_app/spec/javascripts/helpers/protect_jasmine_runner.coffee

@@ -0,0 +1,9 @@
+beforeEach ->
+  up.dom.config.fallbacks = ['.default-fallback']
+  up.history.config.popTargets = ['.default-fallback']
+  $element = $('<div class="default-fallback"></div>')
+  $element.appendTo(document.body)
+
+afterEach ->
+  up.destroy('.default-fallback', log: false)
+

data/spec_app/spec/javascripts/helpers/reset_history.js.coffee

@@ -0,0 +1,22 @@
+u = up.util
+
+replaceStateHelperCount = 0
+
+beforeAll ->
+  @hrefBeforeSuite = location.href
+  @titleBeforeSuite = document.title
+
+afterAll (done) ->
+  up.util.nextFrame =>
+    history.replaceState?({ fromResetPathHelper: true }, '', @hrefBeforeSuite)
+    document.title = @titleBeforeSuite
+    done()
+
+beforeEach ->
+  # Webkit ignores replaceState() calls after 100 calls / 30 sec.
+  # So specs need to explicitely activate history handling.
+  up.history.config.enabled = false
+
+  # Store original URL and title so we can restore it in afterEach.
+  @hrefBeforeExample = location.href
+  @titleBeforeExample = document.title

data/spec_app/spec/javascripts/helpers/reset_up.js.coffee

@@ -1,5 +1,13 @@
-afterEach ->
-  up.reset()
-  $('.up-error').remove()
+afterEach (done) ->
+  # Wait one more frame so pending callbacks have a chance to run.
+  # Pending callbacks might change the URL or cause errors that bleed into
+  # the next example.
 
+  up.util.nextFrame =>
+    up.reset()
 
+    # Give async reset behavior another frame to play out,
+    # then start the next example.
+    up.util.nextFrame ->
+      $('.up-toast').remove()
+      done()

data/spec_app/spec/javascripts/helpers/show_lib_versions.coffee

@@ -0,0 +1,10 @@
+showVersions = ->
+  $('.jasmine-version').text """
+  jQuery #{$.fn.jquery}
+  Unpoly #{up.version}
+  Jasmine #{jasmine.version}
+  """
+
+$ ->
+  # Give Jasmine time to initialize
+  setTimeout(showVersions, 0)

data/spec_app/spec/javascripts/helpers/to_be_error.coffee

@@ -0,0 +1,5 @@
+beforeEach ->
+  jasmine.addMatchers
+    toBeError: (util, customEqualityTesters) ->
+      compare: (actual, message) ->
+        pass: (actual instanceof Error) && (!message || (message instanceof RegExp && actual.message =~ message) || actual.message == message)

data/spec_app/spec/javascripts/helpers/to_match_url.coffee

@@ -0,0 +1,13 @@
+u = up.util
+
+beforeEach ->
+  jasmine.addMatchers
+    toMatchUrl: (util, customEqualityTesters) ->
+      compare: (actual, expected, normalizeOptions = {}) ->
+        pass = true
+        pass &&= u.isString(actual)
+        pass &&= u.isString(expected)
+        pass &&= u.normalizeUrl(actual, normalizeOptions) == u.normalizeUrl(expected, normalizeOptions)
+        { pass }
+
+

data/spec_app/spec/javascripts/helpers/trigger.js.coffee

@@ -2,26 +2,33 @@
   
   u = up.util
   
-  mouseover = ($element, options) ->
+  mouseover = (element, options) ->
+    $element = $(element)
     event = createMouseEvent('mouseover', options)
     dispatch($element, event)
 
-  mousedown = ($element, options) ->
+  mousedown = (element, options) ->
+    $element = $(element)
     event = createMouseEvent('mousedown', options)
     dispatch($element, event)
 
-  mouseup = ($element, options) ->
+  mouseup = (element, options) ->
+    $element = $(element)
     event = createMouseEvent('mouseup', options)
     dispatch($element, event)
 
-  click = ($element, options) ->
+  click = (element, options) ->
+    $element = $(element)
     event = createMouseEvent('click', options)
     dispatch($element, event)
 
-  focus = ($element, options) ->
+  focus = (element, options) ->
+    $element = $(element)
     $element.focus()
 
-  clickSequence = ($element, options) ->
+  clickSequence = (element, options) ->
+    $element = $(element)
+    mouseover($element, options)
     mousedown($element, options)
     focus($element, options)
     mouseup($element, options)

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

@@ -4,62 +4,87 @@ describe 'up.browser', ->
 
   describe 'JavaScript functions', ->
 
-    describe 'up.browser.loadPage', ->
+    describe 'up.browser.navigate', ->
 
       afterEach ->
         # We're preventing the form to be submitted during tests,
         # so we need to remove it manually after each example.
         $('form.up-page-loader').remove()
 
-      describe 'for GET requests', ->
+      describe "for GET requests", ->
 
-        it 'sets location.href to the given URL', ->
-          hrefSetter = up.browser.knife.mock('setLocationHref')
-          up.browser.loadPage('/foo')
-          expect(hrefSetter).toHaveBeenCalledWith('/foo')
-
-        it 'encodes { data } params into the URL', ->
-          hrefSetter = up.browser.knife.mock('setLocationHref')
-          up.browser.loadPage('/foo', data: { param1: 'param1 value', param2: 'param2 value' })
-          expect(hrefSetter).toHaveBeenCalledWith('/foo?param1=param1%20value&param2=param2%20value')
+        it "creates a GET form, adds all { data } params to the form action and submits the form", ->
+          submitForm = spyOn(up.browser, 'submitForm')
+          up.browser.navigate('/foo', method: 'GET', data: { param1: 'param1 value', param2: 'param2 value' })
+          expect(submitForm).toHaveBeenCalled()
+          $form = $('form.up-page-loader')
+          expect($form).toExist()
+          expect($form.attr('action')).toMatchUrl('/foo?param1=param1%20value&param2=param2%20value')
+          # No params should be left in the form
+          expect($form.find('input')).not.toExist()
 
-      describe 'for POST requests', ->
+      describe "for POST requests", ->
 
-        it 'creates a form, adds all { data } params a hidden fields and submits the form', ->
-          submitForm = up.browser.knife.mock('submitForm')
-          up.browser.loadPage('/foo', method: 'post', data: { param1: 'param1 value', param2: 'param2 value' })
+        it "creates a POST form, adds all { data } params a hidden fields and submits the form", ->
+          submitForm = spyOn(up.browser, 'submitForm')
+          up.browser.navigate('/foo', method: 'POST', data: { param1: 'param1 value', param2: 'param2 value' })
           expect(submitForm).toHaveBeenCalled()
           $form = $('form.up-page-loader')
           expect($form).toExist()
-          expect($form.attr('action')).toEqual('/foo')
-          expect($form.attr('method')).toEqual('post')
+          expect($form.attr('action')).toMatchUrl('/foo')
+          expect($form.attr('method')).toEqual('POST')
           expect($form.find('input[name="param1"][value="param1 value"]')).toExist()
           expect($form.find('input[name="param2"][value="param2 value"]')).toExist()
 
-        it 'submits the Rails CSRF token as another hidden field', ->
-          submitForm = up.browser.knife.mock('submitForm')
-          spyOn(up.rails, 'csrfField').and.returnValue
-            name: 'authenticity-param-name',
-            value: 'authenticity-token'
-          up.browser.loadPage('/foo', method: 'post')
-          expect(submitForm).toHaveBeenCalled()
-          $form = $('form.up-page-loader')
-          $tokenInput = $form.find('input[name="authenticity-param-name"]')
-          expect($tokenInput).toExist()
-          expect($tokenInput.val()).toEqual('authenticity-token')
-
       u.each ['PUT', 'PATCH', 'DELETE'], (method) ->
 
         describe "for #{method} requests", ->
 
           it "uses a POST form and sends the actual method as a { _method } param", ->
-            submitForm = up.browser.knife.mock('submitForm')
-            up.browser.loadPage('/foo', method: method)
+            submitForm = spyOn(up.browser, 'submitForm')
+            up.browser.navigate('/foo', method: method)
             expect(submitForm).toHaveBeenCalled()
             $form = $('form.up-page-loader')
             expect($form).toExist()
-            expect($form.attr('method')).toEqual('post')
-            expect($form.find('input[name="_method"]').val()).toEqual(method.toLowerCase())
+            expect($form.attr('method')).toEqual('POST')
+            expect($form.find('input[name="_method"]').val()).toEqual(method)
+
+      describe 'CSRF', ->
+
+        beforeEach ->
+          up.protocol.config.csrfToken = -> 'csrf-token'
+          up.protocol.config.csrfParam = -> 'csrf-param'
+          @submitForm = spyOn(up.browser, 'submitForm')
+
+        it 'submits an CSRF token as another hidden field', ->
+          up.browser.navigate('/foo', method: 'post')
+          expect(@submitForm).toHaveBeenCalled()
+          $form = $('form.up-page-loader')
+          $tokenInput = $form.find('input[name="csrf-param"]')
+          expect($tokenInput).toExist()
+          expect($tokenInput.val()).toEqual('csrf-token')
+
+        it 'does not add a CSRF token if there is none', ->
+          up.protocol.config.csrfToken = -> ''
+          up.browser.navigate('/foo', method: 'post')
+          expect(@submitForm).toHaveBeenCalled()
+          $form = $('form.up-page-loader')
+          $tokenInput = $form.find('input[name="csrf-param"]')
+          expect($tokenInput).not.toExist()
+
+        it 'does not add a CSRF token for GET requests', ->
+          up.browser.navigate('/foo', method: 'get')
+          expect(@submitForm).toHaveBeenCalled()
+          $form = $('form.up-page-loader')
+          $tokenInput = $form.find('input[name="csrf-param"]')
+          expect($tokenInput).not.toExist()
+
+        it 'does not add a CSRF token when loading content from another domain', ->
+          up.browser.navigate('http://other-domain.tld/foo', method: 'get')
+          expect(@submitForm).toHaveBeenCalled()
+          $form = $('form.up-page-loader')
+          $tokenInput = $form.find('input[name="csrf-param"]')
+          expect($tokenInput).not.toExist()
 
     describe 'up.browser.sprintf', ->
 
@@ -131,3 +156,37 @@ describe 'up.browser', ->
           object.bar = 'bar'
           formatted = up.browser.sprintf('before %o after', object)
           expect(formatted).toEqual('before {"bar":"bar"} after')
+
+    describe 'up.browser.whenConfirmed', ->
+
+      it 'shows a confirmation dialog with the given message and fulfills when the user presses OK', (done) ->
+        spyOn(window, 'confirm').and.returnValue(true)
+        promise = up.browser.whenConfirmed(confirm: 'Do action?')
+        promiseState(promise).then (result) ->
+          expect(window.confirm).toHaveBeenCalledWith('Do action?')
+          expect(result.state).toEqual('fulfilled')
+          done()
+
+      it 'emits the event and rejects the returned promise when any listener calls event.preventDefault()', (done) ->
+        spyOn(window, 'confirm').and.returnValue(false)
+        promise = up.browser.whenConfirmed(confirm: 'Do action?')
+        promiseState(promise).then (result) ->
+          expect(window.confirm).toHaveBeenCalledWith('Do action?')
+          expect(result.state).toEqual('rejected')
+          done()
+
+      it 'does now show a conformation dialog and fulfills if no { confirm } option is given', (done) ->
+        spyOn(window, 'confirm')
+        promise = up.browser.whenConfirmed({})
+        promiseState(promise).then (result) ->
+          expect(window.confirm).not.toHaveBeenCalled()
+          expect(result.state).toEqual('fulfilled')
+          done()
+
+      it "does now show a conformation dialog and fulfills if a { confirm } option is given but we're also preloading", (done) ->
+        spyOn(window, 'confirm')
+        promise = up.browser.whenConfirmed(confirm: 'Do action?', preload: true)
+        promiseState(promise).then (result) ->
+          expect(window.confirm).not.toHaveBeenCalled()
+          expect(result.state).toEqual('fulfilled')
+          done()

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

@@ -4,8 +4,7 @@ describe 'up.bus', ->
 
     describe 'up.on', ->
 
-      it 'registers a delagating event listener to the document body, which passes the $element as a second argument to the listener', ->
-
+      it 'registers a delagating event listener to the document body, which passes the $element as a second argument to the listener', asyncSpec (next) ->
         affix('.container .child')
         observeClass = jasmine.createSpy()
         up.on 'click', '.child', (event, $element) ->
@@ -14,20 +13,25 @@ describe 'up.bus', ->
         Trigger.click($('.container'))
         Trigger.click($('.child'))
 
-        expect(observeClass).not.toHaveBeenCalledWith('container')
-        expect(observeClass).toHaveBeenCalledWith('child')
+        next =>
+          expect(observeClass).not.toHaveBeenCalledWith('container')
+          expect(observeClass).toHaveBeenCalledWith('child')
 
-      it 'returns a method that unregisters the event listener when called', ->
+      it 'returns a method that unregisters the event listener when called', asyncSpec (next) ->
         $child = affix('.child')
         clickSpy = jasmine.createSpy()
         unsubscribe = up.on 'click', '.child', clickSpy
         Trigger.click($('.child'))
-        expect(clickSpy.calls.count()).toEqual(1)
-        unsubscribe()
-        Trigger.click($('.child'))
-        expect(clickSpy.calls.count()).toEqual(1)
 
-      it 'parses an up-data attribute as JSON and passes the parsed object as a third argument to the initializer', ->
+        next =>
+          expect(clickSpy.calls.count()).toEqual(1)
+          unsubscribe()
+          Trigger.click($('.child'))
+
+        next =>
+          expect(clickSpy.calls.count()).toEqual(1)
+
+      it 'parses an up-data attribute as JSON and passes the parsed object as a third argument to the initializer', asyncSpec (next) ->
         $child = affix('.child')
         observeArgs = jasmine.createSpy()
         up.on 'click', '.child', (event, $element, data) ->
@@ -37,27 +41,33 @@ describe 'up.bus', ->
         $tag = affix(".child").attr('up-data', JSON.stringify(data))
 
         Trigger.click($('.child'))
-        expect(observeArgs).toHaveBeenCalledWith('child', data)
 
-      it 'passes an empty object as a second argument to the listener if there is no up-data attribute', ->
+        next =>
+          expect(observeArgs).toHaveBeenCalledWith('child', data)
+
+      it 'passes an empty object as a second argument to the listener if there is no up-data attribute', asyncSpec (next) ->
         $child = affix('.child')
         observeArgs = jasmine.createSpy()
         up.on 'click', '.child', (event, $element, data) ->
           observeArgs($element.attr('class'), data)
 
         Trigger.click($('.child'))
-        expect(observeArgs).toHaveBeenCalledWith('child', {})
+
+        next =>
+          expect(observeArgs).toHaveBeenCalledWith('child', {})
 
     describe 'up.off', ->
 
-      it 'unregisters an event listener previously registered through up.on', ->
+      it 'unregisters an event listener previously registered through up.on', asyncSpec (next) ->
         $child = affix('.child')
         clickSpy = jasmine.createSpy()
         up.on 'click', '.child', clickSpy
         Trigger.click($('.child'))
         up.off 'click', '.child', clickSpy
         Trigger.click($('.child'))
-        expect(clickSpy.calls.count()).toEqual(1)
+
+        next =>
+          expect(clickSpy.calls.count()).toEqual(1)
 
       it 'throws an error if the given event listener was not registered through up.on', ->
         someFunction = ->
@@ -121,3 +131,42 @@ describe 'up.bus', ->
           expect($emittedTarget).toEqual($element)
 
           expect(emittedEvent.$element).toEqual($element)
+
+    describe 'up.bus.renamedEvent', ->
+
+      it 'prints a warning and registers the event listener for the new event name', ->
+        warnSpy = spyOn(up.log, 'warn')
+        listener = jasmine.createSpy('listener')
+
+        # Reister listener for the old event name
+        up.on('up:proxy:received', listener)
+        expect(warnSpy).toHaveBeenCalled()
+
+        # Emit event with new name and see that it invokes the legacy listener
+        up.emit('up:proxy:loaded')
+        expect(listener.calls.count()).toBe(1)
+
+        # Check that up.off works with the old event name
+        up.off('up:proxy:received', listener)
+
+        up.emit('up:proxy:loaded')
+        expect(listener.calls.count()).toBe(1)
+
+    describe 'up.bus.whenEmitted', ->
+
+      it 'emits the event and fulfills the returned promise when no listener calls event.preventDefault()', (done) ->
+        eventListener = jasmine.createSpy('event listener')
+        up.on('my:event', eventListener)
+        promise = up.bus.whenEmitted('my:event', key: 'value')
+        promiseState(promise).then (result) ->
+          expect(eventListener).toHaveBeenCalledWith(jasmine.objectContaining(key: 'value'), jasmine.anything(), jasmine.anything())
+          expect(result.state).toEqual('fulfilled')
+          done()
+
+      it 'emits the event and rejects the returned promise when any listener calls event.preventDefault()', (done) ->
+        eventListener = (event) -> event.preventDefault()
+        up.on('my:event', eventListener)
+        promise = up.bus.whenEmitted('my:event', key: 'value')
+        promiseState(promise).then (result) ->
+          expect(result.state).toEqual('rejected')
+          done()

data/spec_app/spec/javascripts/up/classes/cache_spec.js.coffee

@@ -0,0 +1 @@
+describe 'up.Cache', ->