async_sinatra 0.2.1 → 0.2.2

data/README.rdoc

@@ -1,4 +1,4 @@
-= async_sinatra (for Thin)
+= async_sinatra
     by James Tucker
     http://ra66i.org
     http://github.com/raggi/async_sinatra

data/lib/sinatra/async.rb

@@ -73,7 +73,10 @@ module Sinatra #:nodoc:
       # request.
       def body(*args)
         if @async_running
-          block_given? ? async_handle_exception { super yield } : super
+          block_given? ? async_handle_exception { super(yield) } : super
+          if response.body.respond_to?(:call)
+            response.body = Array(async_handle_exception {response.body.call})
+          end
           request.env['async.callback'][
             [response.status, response.headers, response.body]
           ]
@@ -133,6 +136,14 @@ module Sinatra #:nodoc:
         invoke { error_block! response.status }
         body response.body
       end
+
+      # The given block will be executed if the user closes the connection
+      # prematurely (before we've sent a response). This is good for
+      # deregistering callbacks that would otherwise send the body (for
+      # example channel subscriptions).
+      def on_close(&blk)
+        env['async.close'].callback(&blk)
+      end
     end
 
     def self.registered(app) #:nodoc:

data/lib/sinatra/async/test.rb

@@ -8,10 +8,31 @@ class Rack::MockResponse
 end
 
 class Sinatra::Async::Test
+
   class AsyncSession < Rack::MockSession
+    class AsyncCloser
+      def initialize
+        @callbacks, @errbacks = [], []
+      end
+      def callback(&b)
+        @callbacks << b
+      end
+      def errback(&b)
+        @errbacks << b
+      end
+      def fail
+        @errbacks.each { |cb| cb.call }
+        @errbacks.clear
+      end
+      def succeed
+        @callbacks.each { |cb| cb.call }
+        @callbacks.clear
+      end
+    end
+
     def request(uri, env)
       env['async.callback'] = lambda { |r| s,h,b = *r; handle_last_response(uri, env, s,h,b) }
-      env['async.close'] = lambda { raise 'close connection' } # XXX deal with this
+      env['async.close'] = AsyncCloser.new
       catch(:async) { super }
       @last_response ||= Rack::MockResponse.new(-1, {}, [], env["rack.errors"].flush)
     end
@@ -29,14 +50,14 @@ class Sinatra::Async::Test
 
   module Methods
     include Rack::Test::Methods
-    
+
     %w(get put post delete head).each do |m|
       eval <<-RUBY, binding, __FILE__, __LINE__ + 1
-        def a#{m}(*args)
-          #{m}(*args)
-          assert_async
-          async_continue
-        end
+      def a#{m}(*args)
+        #{m}(*args)
+        assert_async
+        async_continue
+      end
       RUBY
     end
 
@@ -48,20 +69,40 @@ class Sinatra::Async::Test
       assert last_response.async?
     end
 
+    # Simulate a user closing the connection before a response is sent.
+    def async_close
+      raise ArgumentError, 'please make a request first' unless last_request
+      current_session.last_request.env['async.close'].succeed
+    end
+
+    # Executes the pending asynchronous blocks, required for the
+    # aget/apost/etc blocks to run.
     def async_continue
       while b = app.options.async_schedules.shift
         b.call
       end
     end
 
+    # Crank the eventmachine loop until a response is made, or timeout after a
+    # particular period, by default 10s. If the timeout is nil, no timeout
+    # will occur.
     def em_async_continue(timeout = 10)
       timed = false
       EM.run do
         async_continue
-        EM.tick_loop { EM.stop unless last_response.async? }
-        EM.add_timer(timeout) { timed = true; EM.stop }
+        em_hard_loop { EM.stop unless last_response.async? }
+        EM.add_timer(timeout) { timed = true; EM.stop } if timeout
       end
       assert !timed, "asynchronous timeout after #{timeout} seconds"
     end
+
+    # Uses EM.tick_loop or a periodic timer to check for changes
+    def em_hard_loop
+      if EM.respond_to?(:tick_loop)
+        EM.tick_loop { yield }
+      else
+        EM.periodic_timer(0.0001) { yield }
+      end
+    end
   end
 end

data/test/test_async.rb

@@ -12,6 +12,12 @@ class TestSinatraAsync < Test::Unit::TestCase
     set :environment, :test
     register Sinatra::Async
 
+    # Hack for storing some global data accessible in tests (normally you
+    # shouldn't need to do this!)
+    def self.singletons
+      @singletons ||= []
+    end
+
     error 401 do
       '401'
     end
@@ -47,6 +53,22 @@ class TestSinatraAsync < Test::Unit::TestCase
     aget '/a401' do
       ahalt 401
     end
+
+    aget '/async_close' do
+      # don't call body here, the 'user' is going to 'disconnect' before we do
+      env['async.close'].callback { self.class.singletons << 'async_closed' }
+    end
+
+    aget '/on_close' do
+      # sugared version of the above
+      on_close do
+        self.class.singletons << 'async_close_cleaned_up'
+      end
+    end
+
+    aget '/redirect' do
+      redirect '/'
+    end
   end
 
   def app
@@ -113,4 +135,23 @@ class TestSinatraAsync < Test::Unit::TestCase
     assert_equal 401, last_response.status
     assert_equal '401', last_response.body
   end
+
+  def test_async_close
+    aget '/async_close'
+    async_close
+    assert_equal 'async_closed', TestApp.singletons.shift
+  end
+
+  def test_on_close
+    aget '/on_close'
+    async_close
+    assert_equal 'async_close_cleaned_up', TestApp.singletons.shift
+  end
+
+  def test_redirect
+    aget '/redirect'
+    assert last_response.redirect?
+    assert_equal 302, last_response.status
+    assert_equal '/', last_response.location
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: async_sinatra
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: false
   segments: 
   - 0
   - 2
-  - 1
-  version: 0.2.1
+  - 2
+  version: 0.2.2
 platform: ruby
 authors: 
 - James Tucker
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-20 00:00:00 -03:00
+date: 2010-09-07 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +26,11 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 57
+        hash: 15
         segments: 
-        - 0
-        - 9
         - 1
-        version: 0.9.1
+        - 0
+        version: "1.0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -80,7 +79,6 @@ files:
 - examples/basic.ru
 - lib/sinatra/async.rb
 - lib/sinatra/async/test.rb
-- test/borked_test_crohr.rb
 - test/test_async.rb
 has_rdoc: true
 homepage: http://libraggi.rubyforge.org/async_sinatra

data/test/borked_test_crohr.rb

@@ -1,161 +0,0 @@
-require 'eventmachine'
-require "sinatra/async/test"
-
-require 'spec/autorun'
-require 'spec/interop/test'
-
-require 'em-http'
-
-Spec::Runner.configure { |c| }
-
-def server(base=Sinatra::Base, &block)
-  s = Sinatra.new(base, &block).new
-  s.options.set :environment, :test
-  s
-end
-
-def app
-  @app
-end
-
-include Sinatra::Async::Test::Methods
-
-describe "Asynchronous routes" do
-  it "should still work as usual" do
-    @app = server do
-      register Sinatra::Async
-      disable :raise_errors, :show_exceptions
-
-      aget '/' do
-        body "hello async"
-      end      
-    end
-    aget '/'
-    last_response.status.should_equal 200
-    last_response.body.should == "hello async"
-  end
-
-  it "should correctly deal with raised exceptions" do
-    @app = server do
-      register Sinatra::Async
-      disable :raise_errors, :show_exceptions
-      aget '/' do
-        raise "boom"
-        body "hello async"
-      end
-      error Exception do
-        e = request.env['sinatra.error']
-        "problem: #{e.class.name} #{e.message}"
-      end
-    end
-    aget '/'
-    last_response.status.should == 500
-    last_response.body.should == "problem: RuntimeError boom"
-  end
-
-  it "should correctly deal with halts" do
-    @app = server do
-      register Sinatra::Async
-      disable :raise_errors, :show_exceptions
-      aget '/' do
-        halt 406, "Format not supported"
-        body "never called"
-      end
-    end
-
-    aget '/'
-    last_response.status.should == 406
-    last_response.body.should == "Format not supported"
-  end
-
-  it "should correctly deal with halts and pass it to the defined error blocks if any" do
-    @app = server do
-      register Sinatra::Async
-      disable :raise_errors, :show_exceptions
-      aget '/' do
-        halt 406, "Format not supported"
-        body "never called"
-      end
-      error 406 do
-        response['Content-Type'] = "text/plain"
-        "problem: #{response.body.to_s}"
-      end
-    end
-    aget '/'
-    last_response.status.should == 406
-    last_response.headers['Content-Type'].should == "text/plain"
-    last_response.body.should == "problem: Format not supported"
-  end
-
-  describe "using EM libraries inside route block" do
-    it "should still work as usual" do
-      @app = server do
-        register Sinatra::Async
-        disable :raise_errors, :show_exceptions
-        aget '/' do
-          url = "http://ruby.activeventure.com/programmingruby/book/tut_exceptions.html"
-          http = EM::HttpRequest.new(url).get
-          http.callback {
-            status http.response_header.status
-            body "ok"
-          }
-          http.errback {
-            body "nok"
-          }
-        end
-      end
-      EM.run { EM.add_timer(1) { EM.stop }; aget '/' }
-      last_response.status.should == 200
-      last_response.body.should == "ok"
-    end
-
-    it "should correctly deal with exceptions raised from within EM callbacks" do
-      @app = server do
-        register Sinatra::Async
-        disable :raise_errors, :show_exceptions
-        aget '/' do
-          url = "http://doesnotexist.local/whatever"
-          http = EM::HttpRequest.new(url).get
-          http.callback {
-            status http.response_header.status
-            body "ok"
-          }
-          http.errback {
-            raise "boom"
-          }
-        end
-        error Exception do
-          e = request.env['sinatra.error']
-          "#{e.class.name}: #{e.message}"
-        end
-      end
-      EM.run { EM.add_timer(1) { EM.stop }; aget '/' }
-      last_response.status.should == 500
-      last_response.body.should == "RuntimeError: boom"
-    end
-
-    it "should correctly deal with halts thrown from within EM callbacks" do
-      @app = server do
-        register Sinatra::Async
-        disable :raise_errors, :show_exceptions
-        aget '/' do
-          url = "http://doesnotexist.local/whatever"
-          http = EM::HttpRequest.new(url).get
-          http.callback {
-            status http.response_header.status
-            body "ok"
-          }
-          http.errback {
-            halt 503, "error: #{http.errors.inspect}"
-          }
-        end
-        error 503 do
-          "503: #{response.body.to_s}"
-        end
-      end
-      EM.run { EM.add_timer(1) { EM.stop }; aget '/' }
-      last_response.status.should == 503
-      last_response.body.should == "503: error: \"unable to resolve server address\""
-    end
-  end
-end