unpoly-rails 0.30.0 → 0.30.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8c90c3524cc53bceb112f2a7fe498d4a7eda786
-  data.tar.gz: 979eaa1084743303e20c6ecd7f430e64751797bd
+  metadata.gz: 1e53ab2c1cbdfe09b80e31d76371d5382ad40f70
+  data.tar.gz: 7ba79eb21d2494bf69b3bc222a4b7e89778671a1
 SHA512:
-  metadata.gz: 42c4bd9af359d17e34a0741e0a06a1074ae90ee87143cd150679f47b2035a18f2b613e12df74c4ba313b5eddf5abdf84710f5c324bd030a80ca9e33802f71caa
-  data.tar.gz: 74539855e8eadf62b68ca6a88e09b2ef2b6f5227eedb616c0395579e1d48eda87e4b1ca998fe9bdf5c13b48114caee59db83377c96892d8cfd6578d65b445b43
+  metadata.gz: 5789b11f34c69787dbf6fdd9fe9ed03d6c25c5c76fbf32b7028fcba36a6ecad14072c10d1cf5b4945d7edd104d11e581a302f6ca45b1c15baf4b5aa868c90691
+  data.tar.gz: 3d07d31ce7a01814badad2a7e16fbe4bbf283dc574a6b27818ea9a2ba5a6cff9b9fdcf6a9acfd19b6d505d12f8c84486ea12b7322fae39fa7000cb9af3492c1d

data/CHANGELOG.md

@@ -14,6 +14,16 @@ Unreleased
 ### Breaking changes
 
 
+0.30.1
+------
+
+### Compatible changes
+
+- Fix [`up.observe`](/up.observe) not honoring `{ delay }` option
+- Fix [`[up-observe]`](/up-observe) not honoring `[up-delay]` modifier
+- Fix many issues with concurrency and slow server responses for [`up.observe`](/up.observe) and [`[up-observe]`](/up-observe)
+
+
 
 0.30.0
 ------

data/lib/assets/javascripts/unpoly/form.js.coffee

@@ -249,52 +249,35 @@ up.form = (($) ->
     delay = u.option($fields.attr('up-delay'), options.delay, config.observeDelay)
     delay = parseInt(delay)
 
+    console.debug("Observing with delay %o", delay)
+
     destructors = u.map $fields, (field) ->
-      observeField($(field), options, callback)
+      observeField($(field), delay, callback)
 
     u.sequence(destructors...)
 
   observeField = ($field, delay, callback) ->
-    knownValue = null
-    callbackTimer = null
-    callbackPromise = u.resolvedPromise()
-
-    # This holds the next callback function, curried with `value` and `$field`.
-    # Since we're waiting for callback promises to resolve before running
-    # another callback, this might be overwritten while we're waiting for a
-    # previous callback to finish.
-    nextCallback = null
-
-    runNextCallback = ->
-      if nextCallback
-        returnValue = nextCallback()
-        nextCallback = null
-        returnValue
+    processedValue = u.submittedValue($field)
+    timer = undefined
+    lastCallbackDone = u.resolvedPromise()
+
+    runCallback = (value) ->
+      processedValue = value
+      callbackReturnValue = callback.apply($field.get(0), [value, $field])
+      if u.isPromise(callbackReturnValue)
+        lastCallbackDone = callbackReturnValue
+      else
+        lastCallbackDone = callbackReturnValue
 
     check = ->
       value = u.submittedValue($field)
       # don't run the callback for the check during initialization
-      skipCallback = u.isNull(knownValue)
-      if knownValue != value
-        knownValue = value
-        unless skipCallback
-          clearTimer()
-          nextCallback = -> callback.apply($field.get(0), [value, $field])
-          runAndChain = ->
-            # Only run the callback once the previous callback's
-            # promise resolves.
-            callbackPromise.then ->
-              returnValue = runNextCallback()
-              # If the callback returns a promise, we will remember it
-              # and chain additional callback invocations to it.
-              if u.isPromise(returnValue)
-                callbackPromise = returnValue
-              else
-                callbackPromise = u.resolvedPromise()
-          u.setTimer(delay, runAndChain)
-
-    clearTimer = ->
-      clearTimeout(callbackTimer)
+      if processedValue != value
+        nextCallback = -> runCallback(value)
+        timer?.cancel()
+        timer = u.promiseTimer(delay)
+        # We wait until both the delay has passed and a previous callback is done executing
+        $.when(timer, lastCallbackDone).then(nextCallback)
 
     # Although (depending on the browser) we only need/receive either input or change,
     # we always bind to both events in case another script manually triggers it.
@@ -307,12 +290,10 @@ up.form = (($) ->
 
     $field.on(changeEvents, check)
 
-    check()
-
     # return destructor
     return ->
       $field.off(changeEvents, check)
-      clearTimer()
+      timer?.cancel()
 
   ###*
   [Observes](/up.observe) a field or form and submits the form when a value changes.
@@ -860,7 +841,7 @@ up.form = (($) ->
   but not if the checkbox was changed:
 
       <form method="GET" action="/search">
-        <input type="search" name="query" autosubmit>
+        <input type="search" name="query" up-autosubmit>
         <input type="checkbox"> Include archive
       </form>
 

data/lib/assets/javascripts/unpoly/util.js.coffee

@@ -778,6 +778,7 @@ up.util = (($) ->
       setTimeout(callback, millis)
     else
       callback()
+      undefined
 
 
   ###*
@@ -1777,14 +1778,21 @@ up.util = (($) ->
   The proxy's `.promise` attribute is available even before the function is called
   and will resolve when the inner function's returned promise resolves.
 
+  If the inner function does not return a promise, the proxy's `.promise` attribute
+  will resolve as soon as the inner function returns.
+
   @function up.util.previewable
   @internal
   ###
   previewable = (fun) ->
     deferred = $.Deferred()
     preview = (args...) ->
-      fun(args...).then ->
-        deferred.resolve()
+      funValue = fun(args...)
+      if isPromise(funValue)
+        funValue.then -> deferred.resolve(funValue)
+      else
+        deferred.resolve(funValue)
+      funValue
     preview.promise = deferred.promise()
     preview
 
@@ -1844,6 +1852,27 @@ up.util = (($) ->
     ->
       map functions, (f) -> f()
 
+#  ###*
+#  @function up.util.race
+#  @internal
+#  ###
+#  race = (promises...) ->
+#    raceDone = $.Deferred()
+#    each promises, (promise) ->
+#      promise.then -> raceDone.resolve()
+#    raceDone.promise()
+
+  ###*
+  @function up.util.promiseTimer
+  @internal
+  ###
+  promiseTimer = (ms) ->
+    deferred = $.Deferred()
+    timeout = setTimer ms, ->
+      deferred.resolve()
+    deferred.cancel = -> clearTimeout(timeout)
+    deferred
+
   isDetached: isDetached
   requestDataAsArray: requestDataAsArray
   requestDataAsQuery: requestDataAsQuery
@@ -1952,6 +1981,8 @@ up.util = (($) ->
   DivertibleChain: DivertibleChain
   submittedValue: submittedValue
   sequence: sequence
+  promiseTimer: promiseTimer
+  previewable: previewable
 
 )($)
 

data/lib/unpoly/rails/version.rb

@@ -4,6 +4,6 @@ module Unpoly
     # The current version of the unpoly-rails gem.
     # This version number is also used for releases of the Unpoly
     # frontend code.
-    VERSION = '0.30.0'
+    VERSION = '0.30.1'
   end
 end

data/spec_app/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ..
   specs:
-    unpoly-rails (0.28.1)
+    unpoly-rails (0.30.0)
       rails (>= 3)
 
 GEM
@@ -82,8 +82,8 @@ GEM
       hpricot (~> 0.8.6)
       ruby_parser (~> 3.1.1)
     i18n (0.7.0)
-    jasmine-core (2.4.1)
-    jasmine-rails (0.12.2)
+    jasmine-core (2.5.2)
+    jasmine-rails (0.14.1)
       jasmine-core (>= 1.3, < 3.0)
       phantomjs (>= 1.9)
       railties (>= 3.2.0)
@@ -99,12 +99,14 @@ GEM
     mail (2.6.3)
       mime-types (>= 1.16, < 3)
     mime-types (2.99)
-    mini_portile2 (2.0.0)
-    minitest (5.8.4)
-    multi_json (1.11.2)
-    nokogiri (1.6.7.2)
-      mini_portile2 (~> 2.0.0.rc2)
-    phantomjs (1.9.8.0)
+    mini_portile2 (2.1.0)
+    minitest (5.9.1)
+    multi_json (1.12.1)
+    nokogiri (1.6.8)
+      mini_portile2 (~> 2.1.0)
+      pkg-config (~> 1.1.7)
+    phantomjs (2.1.1.0)
+    pkg-config (1.1.7)
     rack (1.6.4)
     rack-test (0.6.3)
       rack (>= 1.0)
@@ -132,7 +134,7 @@ GEM
       activesupport (= 4.2.0)
       rake (>= 0.8.7)
       thor (>= 0.18.1, < 2.0)
-    rake (11.1.2)
+    rake (11.3.0)
     ref (1.0.5)
     rspec-core (3.4.1)
       rspec-support (~> 3.4.0)

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

@@ -1,3 +1,2 @@
 beforeAll (done) ->
   $(done)
-  

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

@@ -3,7 +3,7 @@ describe 'up.form', ->
   u = up.util
 
   describe 'Javascript functions', ->
-    
+
     describe 'up.observe', ->
 
       beforeEach ->
@@ -23,43 +23,100 @@ describe 'up.form', ->
 
         u.each changeEvents, (eventName) ->
 
-          it "runs the callback when the input receives a '#{eventName}' event and the value changed", (done) ->
-            $input = affix('input[value="old-value"]')
-            callback = jasmine.createSpy('change callback')
-            up.observe($input, callback)
-            $input.val('new-value')
-            u.times 2, -> $input.trigger(eventName)
-            u.nextFrame ->
-              expect(callback).toHaveBeenCalledWith('new-value', $input)
-              expect(callback.calls.count()).toEqual(1)
-              done()
+          describe "when the input receives a #{eventName} event", ->
 
-          it "does not run the callback when the input receives a '#{eventName}' event, but the value didn't change", (done) ->
-            $input = affix('input[value="old-value"]')
-            callback = jasmine.createSpy('change callback')
-            up.observe($input, callback)
-            $input.trigger(eventName)
-            u.nextFrame ->
-              expect(callback).not.toHaveBeenCalled()
-              done()
+            it "runs the callback if the value changed", (done) ->
+              $input = affix('input[value="old-value"]')
+              callback = jasmine.createSpy('change callback')
+              up.observe($input, callback)
+              $input.val('new-value')
+              u.times 2, -> $input.trigger(eventName)
+              u.nextFrame ->
+                expect(callback).toHaveBeenCalledWith('new-value', $input)
+                expect(callback.calls.count()).toEqual(1)
+                done()
 
-          it "runs a callback in the same frame if the delay is 0 and it receives a '#{eventName}' event", ->
-            $input = affix('input[value="old-value"]')
-            callback = jasmine.createSpy('change callback')
-            up.observe($input, { delay: 0 }, callback)
-            $input.val('new-value')
-            $input.trigger(eventName)
-            expect(callback.calls.count()).toEqual(1)
+            it "does not run the callback if the value didn't change", (done) ->
+              $input = affix('input[value="old-value"]')
+              callback = jasmine.createSpy('change callback')
+              up.observe($input, callback)
+              $input.trigger(eventName)
+              u.nextFrame ->
+                expect(callback).not.toHaveBeenCalled()
+                done()
 
-          it "runs multiple callbacks in the same frame if the delay is 0 and it receives a '#{eventName}' event", ->
-            $input = affix('input[value="old-value"]')
-            callback = jasmine.createSpy('change callback')
-            up.observe($input, { delay: 0 }, callback)
-            $input.val('new-value')
-            $input.trigger(eventName)
-            $input.val('yet-another-value')
-            $input.trigger(eventName)
-            expect(callback.calls.count()).toEqual(2)
+            it 'debounces the callback when the { delay } option is given', (done) ->
+              $input = affix('input[value="old-value"]')
+              callback = jasmine.createSpy('change callback')
+              up.observe($input, { delay: 100 }, callback)
+              $input.val('new-value-1')
+              $input.trigger(eventName)
+              u.setTimer 50, ->
+                # 50 ms after change 1: We're still waiting for the 100ms delay to expire
+                expect(callback.calls.count()).toEqual(0)
+                u.setTimer 100, ->
+                  # 150 ms after change 1: The 100ms delay has expired
+                  expect(callback.calls.count()).toEqual(1)
+                  expect(callback.calls.mostRecent().args[0]).toEqual('new-value-1')
+                  $input.val('new-value-2')
+                  $input.trigger(eventName)
+                  u.setTimer 40, ->
+                    # 40 ms after change 2: We change again, resetting the delay
+                    expect(callback.calls.count()).toEqual(1)
+                    $input.val('new-value-3')
+                    $input.trigger(eventName)
+                    u.setTimer 85, ->
+                      # 125 ms after change 2, which was superseded by change 3
+                      # 85 ms after change 3
+                      expect(callback.calls.count()).toEqual(1)
+                      u.setTimer 65, ->
+                        # 190 ms after change 2, which was superseded by change 3
+                        # 150 ms after change 3
+                        expect(callback.calls.count()).toEqual(2)
+                        expect(callback.calls.mostRecent().args[0]).toEqual('new-value-3')
+                        done()
+
+            it 'delays a callback if a previous async callback is taking long to execute', (done) ->
+              $input = affix('input[value="old-value"]')
+              callbackCount = 0
+              callback = ->
+                callbackCount += 1
+                u.promiseTimer(100)
+              up.observe($input, { delay: 1 }, callback)
+              $input.val('new-value-1')
+              $input.trigger(eventName)
+              u.setTimer 30, ->
+                # Callback has been called and takes 100 ms to complete
+                expect(callbackCount).toEqual(1)
+                $input.val('new-value-2')
+                $input.trigger(eventName)
+                u.setTimer 30, ->
+                  # Second callback is triggerd, but waits for first callback to complete
+                  expect(callbackCount).toEqual(1)
+                  u.setTimer 100, ->
+                    expect(callbackCount).toEqual(2)
+                    done()
+
+            it 'does not run multiple callbacks if a long-running callback has been blocking multiple subsequent callbacks'
+
+            it "runs a callback in the same frame if the delay is 0", ->
+              console.debug('*** next example')
+              $input = affix('input[value="old-value"]')
+              callback = jasmine.createSpy('change callback')
+              up.observe($input, { delay: 0 }, callback)
+              $input.val('new-value')
+              $input.trigger(eventName)
+              expect(callback.calls.count()).toEqual(1)
+
+            it "runs multiple callbacks in the same frame if the delay is 0", ->
+              $input = affix('input[value="old-value"]')
+              callback = jasmine.createSpy('change callback')
+              up.observe($input, { delay: 0 }, callback)
+              $input.val('new-value')
+              $input.trigger(eventName)
+              $input.val('yet-another-value')
+              $input.trigger(eventName)
+              expect(callback.calls.count()).toEqual(2)
 
         describe 'when the first argument is a checkbox', ->
 
@@ -163,42 +220,44 @@ describe 'up.form', ->
 
         u.each changeEvents, (eventName) ->
 
-          it "runs the callback when any of the form's inputs receives a '#{eventName}' event and the value changed", (done) ->
-            $form = affix('form')
-            $input = $form.affix('input[value="old-value"]')
-            callback = jasmine.createSpy('change callback')
-            up.observe($form, callback)
-            $input.val('new-value')
-            u.times 2, -> $input.trigger(eventName)
-            u.nextFrame ->
-              expect(callback).toHaveBeenCalledWith('new-value', $input)
-              expect(callback.calls.count()).toEqual(1)
-              done()
+          describe "when any of the form's inputs receives a #{eventName} event", ->
 
-          it "does not run the callback when any of the form's inputs receives a '#{eventName}' event, but the value didn't change", (done) ->
-            $form = affix('form')
-            $input = $form.affix('input[value="old-value"]')
-            callback = jasmine.createSpy('change callback')
-            up.observe($form, callback)
-            $input.trigger(eventName)
-            u.nextFrame ->
-              expect(callback).not.toHaveBeenCalled()
-              done()
+            it "runs the callback if the value changed", (done) ->
+              $form = affix('form')
+              $input = $form.affix('input[value="old-value"]')
+              callback = jasmine.createSpy('change callback')
+              up.observe($form, callback)
+              $input.val('new-value')
+              u.times 2, -> $input.trigger(eventName)
+              u.nextFrame ->
+                expect(callback).toHaveBeenCalledWith('new-value', $input)
+                expect(callback.calls.count()).toEqual(1)
+                done()
 
-#        it 'runs the callback only once when a radio button group changes its selection', ->
-#          $form = affix('form')
-#          $radio1 = $form.affix('input[type="radio"][name="group"][value="1"][checked="checked"]')
-#          $radio2 = $form.affix('input[type="radio"][name="group"][value="2"]')
-#          callback = jasmine.createSpy('change callback')
-#          up.observe($form, callback)
-#          $radio2.get(0).click()
-#          u.nextFrame ->
-#            expect(callback.calls.count()).toEqual(1)
+            it "does not run the callback if the value didn't change", (done) ->
+              $form = affix('form')
+              $input = $form.affix('input[value="old-value"]')
+              callback = jasmine.createSpy('change callback')
+              up.observe($form, callback)
+              $input.trigger(eventName)
+              u.nextFrame ->
+                expect(callback).not.toHaveBeenCalled()
+                done()
+
+  #        it 'runs the callback only once when a radio button group changes its selection', ->
+  #          $form = affix('form')
+  #          $radio1 = $form.affix('input[type="radio"][name="group"][value="1"][checked="checked"]')
+  #          $radio2 = $form.affix('input[type="radio"][name="group"][value="2"]')
+  #          callback = jasmine.createSpy('change callback')
+  #          up.observe($form, callback)
+  #          $radio2.get(0).click()
+  #          u.nextFrame ->
+  #            expect(callback.calls.count()).toEqual(1)
 
     describe 'up.submit', ->
 
       describeCapability 'canPushState', ->
-      
+
         beforeEach ->
           @$form = affix('form[action="/path/to"][method="put"][up-target=".response"]')
           @$form.append('<input name="field1" value="value1">')
@@ -232,11 +291,11 @@ describe 'up.form', ->
             responseText:
               """
               text-before
-    
+
               <form>
                 error-messages
               </form>
-    
+
               text-after
               """
           expect(up.browser.url()).toEqual(@hrefBeforeExample)
@@ -300,12 +359,12 @@ describe 'up.form', ->
               expect(form.submit).toHaveBeenCalled()
 
       describeFallback 'canPushState', ->
-        
+
         it 'falls back to a vanilla form submission', ->
           $form = affix('form[action="/path/to"][method="put"][up-target=".response"]')
           form = $form.get(0)
           spyOn(form, 'submit')
-          
+
           up.submit($form)
           expect(form.submit).toHaveBeenCalled()
 
@@ -358,7 +417,10 @@ describe 'up.form', ->
 
     describe '[up-observe]', ->
 
-      it 'runs the Javascript code in the attribute value when a change is observed in the field', ->
+      afterEach ->
+        window.observeCallbackSpy = undefined
+
+      it 'runs the Javascript code in the attribute value when a change is observed in the field', (done) ->
         $form = affix('form')
         window.observeCallbackSpy = jasmine.createSpy('observe callback')
         $field = $form.affix('input[val="old-value"][up-observe="window.observeCallbackSpy(value, $field.get(0))"]')
@@ -369,6 +431,20 @@ describe 'up.form', ->
           expect(window.observeCallbackSpy).toHaveBeenCalledWith('new-value', $field.get(0))
           done()
 
+      describe 'with [up-delay] modifier', ->
+
+        it 'debounces the callback', (done) ->
+          $form = affix('form')
+          window.observeCallbackSpy = jasmine.createSpy('observe callback')
+          $field = $form.affix('input[val="old-value"][up-observe="window.observeCallbackSpy()"][up-delay="50"]')
+          up.hello($form)
+          $field.val('new-value')
+          $field.trigger('change')
+          u.nextFrame ->
+            expect(window.observeCallbackSpy).not.toHaveBeenCalled()
+            u.setTimer 80, ->
+              expect(window.observeCallbackSpy).toHaveBeenCalled()
+              done()
 
     describe 'input[up-validate]', ->
 

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

@@ -1,7 +1,85 @@
 describe 'up.util', ->
-  
+
+  u = up.util
+
   describe 'Javascript functions', ->
 
+    describe 'up.util.previewable', ->
+
+      it 'wraps a function into a proxy function with an additional .promise attribute', ->
+        fun = -> 'return value'
+        proxy = up.util.previewable(fun)
+        expect(u.isFunction(proxy)).toBe(true)
+        expect(u.isPromise(proxy.promise)).toBe(true)
+        expect(proxy()).toEqual('return value')
+
+      it "resolves the proxy's .promise when the inner function returns", (done) ->
+        fun = -> 'return value'
+        proxy = up.util.previewable(fun)
+        callback = jasmine.createSpy('promise callback')
+        proxy.promise.then(callback)
+        u.nextFrame ->
+          expect(callback).not.toHaveBeenCalled()
+          proxy()
+          u.nextFrame ->
+            expect(callback).toHaveBeenCalledWith('return value')
+            done()
+
+      it "delays resolution of the proxy's .promise if the inner function returns a promise", (done) ->
+        funDeferred = $.Deferred()
+        fun = -> funDeferred
+        proxy = up.util.previewable(fun)
+        callback = jasmine.createSpy('promise callback')
+        proxy.promise.then(callback)
+        proxy()
+        u.nextFrame ->
+          expect(callback).not.toHaveBeenCalled()
+          funDeferred.resolve()
+          u.nextFrame ->
+            expect(callback).toHaveBeenCalled()
+            done()
+
+    describe 'up.util.DivertibleChain', ->
+
+      it "instantiates a task queue whose (2..n)th tasks can be changed by calling '.asap'", (done) ->
+        chain = new up.util.DivertibleChain()
+        
+        timer1Spy = jasmine.createSpy('timer1 has been called')
+        timer1 = ->
+          timer1Spy()
+          u.promiseTimer(50)
+        
+        timer2Spy = jasmine.createSpy('timer2 has been called')
+        timer2 = ->
+          timer2Spy()
+          u.promiseTimer(50)
+        
+        timer3Spy = jasmine.createSpy('timer3 has been called')
+        timer3 = ->
+          timer3Spy()
+          u.promiseTimer(50)
+        
+        timer4Spy = jasmine.createSpy('timer4 has been called')
+        timer4 = ->
+          timer4Spy()
+          u.promiseTimer(50)
+
+        chain.asap(timer1)
+        u.nextFrame ->
+          expect(timer1Spy).toHaveBeenCalled()
+          chain.asap(timer2)
+          u.nextFrame ->
+            # timer2 is still waiting for timer1 to finish
+            expect(timer2Spy).not.toHaveBeenCalled()
+            # Override the (2..n)th tasks. This unschedules timer2.
+            chain.asap(timer3, timer4)
+            u.setTimer 80, ->
+              expect(timer2Spy).not.toHaveBeenCalled()
+              expect(timer3Spy).toHaveBeenCalled()
+              u.setTimer 70, ->
+                expect(timer4Spy).toHaveBeenCalled()
+                done()
+
     describe 'up.util.sequence', ->
 
       it 'combines the given functions into a single function', ->
@@ -144,10 +222,17 @@ describe 'up.util', ->
         jasmine.clock().tick(1500)
         expect(callback).toHaveBeenCalled()
 
-      it 'calls the given function in the current execution frame if the delay is zero', ->
-        callback = jasmine.createSpy()
-        up.util.setTimer(0, callback)
-        expect(callback).toHaveBeenCalled()
+      describe 'if the delay is zero', ->
+
+        it 'calls the given function in the current execution frame', ->
+          callback = jasmine.createSpy()
+          up.util.setTimer(0, callback)
+          expect(callback).toHaveBeenCalled()
+
+        it "returns undefined so the return value won't be mistaken with a Javascript timer ID", ->
+          callback = -> 'function return value'
+          timerReturnValue = up.util.setTimer(0, callback)
+          expect(timerReturnValue).toBeUndefined()
 
 #    describe 'up.util.argNames', ->
 #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unpoly-rails
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.30.1
 platform: ruby
 authors:
 - Henning Koch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-20 00:00:00.000000000 Z
+date: 2016-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails