async_sinatra 0.1.5 → 0.2.0

data/README.rdoc

@@ -7,11 +7,17 @@
 == DESCRIPTION:
 
 A Sinatra plugin to provide convenience whilst performing asynchronous
-responses inside of the Sinatra framework running under the Thin webserver.
+responses inside of the Sinatra framework running under async webservers.
 
 To properly utilise this package, some knowledge of EventMachine and/or
 asynchronous patterns is recommended.
 
+Currently, supporting servers include:
+
+* Thin
+* Rainbows
+* Zbatery
+
 == SYNOPSIS:
 
 A quick example:
@@ -36,7 +42,7 @@ See Sinatra::Async for more details.
 == REQUIREMENTS:
 
 * Sinatra (>= 0.9)
-* Thin    (>= 1.2)
+* An async webserver
 
 == INSTALL:
 

data/Rakefile

@@ -1,7 +1,7 @@
 #!/usr/bin/env rake
 require 'rake/clean'
 
-task :default => :spec
+task :default => :test
 
 def spec(file = Dir['*.gemspec'].first)
   @spec ||=
@@ -19,27 +19,25 @@ end
 
 def manifest; @manifest ||= `git ls-files`.split("\n").reject{|s|s=~/\.gemspec$|\.gitignore$/}; end
 
-require 'rake/gempackagetask'
-def gem_task; @gem_task ||= Rake::GemPackageTask.new(spec); end
+require 'rubygems/package_task'
+def gem_task; @gem_task ||= Gem::PackageTask.new(spec); end
 gem_task.define
 Rake::Task[:clobber].enhance [:clobber_package]
 
 require 'rake/testtask'
-Rake::TestTask.new(:spec) do |t|
+Rake::TestTask.new do |t|
   t.test_files = spec.test_files
-  t.ruby_opts = ['-rubygems'] if defined? Gem
+  t.ruby_opts = ['-rubygems']
   t.warning = true
 end unless spec.test_files.empty?
 
-require 'rake/rdoctask'
-df = begin; require 'rdoc/generator/darkfish'; true; rescue LoadError; end
-rdtask = Rake::RDocTask.new do |rd|
+require 'rdoc/task'
+rdtask = RDoc::Task.new do |rd|
   rd.title = spec.name
   rd.main = spec.extra_rdoc_files.first
   lib_rexp = spec.require_paths.map { |p| Regexp.escape p }.join('|')
   rd.rdoc_files.include(*manifest.grep(/^(?:#{lib_rexp})/))
   rd.rdoc_files.include(*spec.extra_rdoc_files)
-  rd.template = 'darkfish' if df
 end
 
 Rake::Task[:clobber].enhance [:clobber_rdoc]
@@ -70,7 +68,7 @@ task :gemspec => spec.filename
 
 task spec.filename do
   spec.files = manifest
-  spec.test_files = manifest.grep(/(?:spec|test)\/*.rb/)
+  spec.test_files = manifest.grep(%r{test/test_.*\.rb})
   open(spec.filename, 'w') { |w| w.write spec.to_ruby }
 end
 
@@ -90,7 +88,8 @@ task :tag do
   end
 end
 
-desc "Release #{gem_task.gem_file} to rubyforge"
+desc "Release #{gem_task.gem_spec.file_name}"
 task :release => [:tag, :gem, :publish] do |t|
-  sh "rubyforge add_release #{spec.rubyforge_project} #{spec.name} #{spec.version} #{gem_task.package_dir}/#{gem_task.gem_file}"
+  sh "rubyforge add_release #{spec.rubyforge_project} #{spec.name} #{spec.version} #{gem_task.package_dir}/#{gem_task.gem_spec.file_name}"
+  sh "gem push #{gem_task.package_dir}/#{gem_task.gem_spec.file_name}"
 end

data/examples/basic.ru

@@ -18,6 +18,15 @@ class AsyncTest < Sinatra::Base
     raise 'boom'
   end
 
+  aget '/araise' do
+    EM.add_timer(1) { body { raise "boom" } }
+  end
+
+  # This will blow up in thin currently
+  aget '/raise/die' do
+    EM.add_timer(1) { raise 'die' }
+  end
+
 end
 
 run AsyncTest.new

data/lib/sinatra/async.rb

@@ -35,6 +35,7 @@ module Sinatra #:nodoc:
   #  
   #  end
   module Async
+
     # Similar to Sinatra::Base#get, but the block will be scheduled to run
     # during the next tick of the EventMachine reactor. In the meantime,
     # Thin will hold onto the client connection, awaiting a call to 
@@ -58,43 +59,79 @@ module Sinatra #:nodoc:
 
     private
     def aroute(verb, path, opts = {}, &block) #:nodoc:
+      method = "A#{verb} #{path}".to_sym
+      define_method method, &block
+
       route(verb, path, opts) do |*bargs|
-        method = "A#{verb} #{path}".to_sym
+        async_runner(method, *bargs)
+        async_response
+      end
+    end
 
-        mc = class << self; self; end
-        mc.send :define_method, method, &block
-        mc.send :alias_method, :__async_callback, method
+    module Helpers
+      # Send the given body or block as the final response to the asynchronous 
+      # request.
+      def body(*args)
+        if @async_running
+          block_given? ? async_handle_exception { super yield } : super
+          request.env['async.callback'][
+            [response.status, response.headers, response.body]
+          ]
+        else
+          super
+        end
+      end
 
-        EM.next_tick {
-          begin
-            send(:__async_callback, *bargs)
-          rescue ::Exception => boom
-            if options.show_exceptions?
-              # HACK: handle_exception! re-raises the exception if show_exceptions?,
-              # so we ignore any errors and instead create a ShowExceptions page manually
-              handle_exception!(boom) rescue nil
-              s, h, b = Sinatra::ShowExceptions.new(proc{ raise boom }).call(request.env)
-              response.status = s
-              response.headers.replace(h)
-              body(b)
-            else
-              body(handle_exception!(boom))
+      # By default async_schedule calls EventMachine#next_tick, if you're using
+      # threads or some other scheduling mechanism, it must take the block
+      # passed here.
+      def async_schedule(&b)
+        if options.environment == :test
+          options.set :async_schedules, [] unless options.respond_to? :async_schedules
+          options.async_schedules << b
+        else
+          EM.next_tick(&b)
+        end
+      end
+
+      # Defaults to throw async as that is most commonly used by servers.
+      def async_response
+        throw :async
+      end
+
+      def async_runner(method, *bargs)
+        async_schedule do
+          @async_running = true
+          async_handle_exception do
+            if h = catch(:halt) { __send__(method, *bargs); nil }
+              invoke { halt h }
+              invoke { error_block! response.status }
+              body(response.body)
             end
           end
-        }
+        end
+      end
 
-        throw :async      
+      def async_handle_exception
+        yield
+      rescue ::Exception => boom
+        if options.show_exceptions?
+          printer = Sinatra::ShowExceptions.new(proc{ raise boom })
+          s, h, b = printer.call(request.env)
+          response.status = s
+          response.headers.replace(h)
+          response.body = b
+        else
+          body(handle_exception!(boom))
+        end
       end
-    end
 
-    module Helpers
-      # Send the given body or block as the final response to the asynchronous 
-      # request.
-      def body(*args, &blk)
-        super
-        request.env['async.callback'][
-          [response.status, response.headers, response.body]
-        ] if respond_to?(:__async_callback)
+      # Asynchronous halt must be used when the halt is occuring outside of
+      # the original call stack.
+      def ahalt(*args)
+        invoke { halt(*args) }
+        invoke { error_block! response.status }
+        body response.body
       end
     end
 

data/lib/sinatra/async/test.rb

@@ -0,0 +1,67 @@
+require 'sinatra/async'
+require 'rack/test'
+
+class Rack::MockResponse
+  def async?
+    self.status == -1
+  end
+end
+
+class Sinatra::Async::Test
+  class AsyncSession < Rack::MockSession
+    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
+      catch(:async) { super }
+      @last_response ||= Rack::MockResponse.new(-1, {}, [], env["rack.errors"].flush)
+    end
+
+    def handle_last_response(uri, env, status, headers, body)
+      @last_response = Rack::MockResponse.new(status, headers, body, env["rack.errors"].flush)
+      body.close if body.respond_to?(:close)
+
+      cookie_jar.merge(last_response.headers["Set-Cookie"], uri)
+
+      @after_request.each { |hook| hook.call }
+      @last_response
+    end
+  end
+
+  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
+      RUBY
+    end
+
+    def build_rack_mock_session # XXX move me
+      Sinatra::Async::Test::AsyncSession.new(app)
+    end
+
+    def assert_async
+      assert last_response.async?
+    end
+
+    def async_continue
+      while b = app.options.async_schedules.shift
+        b.call
+      end
+    end
+
+    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 }
+      end
+      assert !timed, "asynchronous timeout after #{timeout} seconds"
+    end
+  end
+end

data/test/borked_test_crohr.rb

@@ -0,0 +1,161 @@
+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

data/test/test_async.rb

@@ -0,0 +1,116 @@
+gem 'test-unit'
+require "test/unit"
+
+require 'eventmachine'
+
+require "sinatra/async/test"
+
+class TestSinatraAsync < Test::Unit::TestCase
+  include Sinatra::Async::Test::Methods
+
+  class TestApp < Sinatra::Base
+    set :environment, :test
+    register Sinatra::Async
+
+    error 401 do
+      '401'
+    end
+
+    aget '/hello' do
+      body { 'hello async' }
+    end
+
+    aget '/em' do
+      EM.add_timer(0.001) { body { 'em' }; EM.stop }
+    end
+
+    aget '/em_timeout' do
+      # never send a response
+    end
+
+    aget '/404' do
+      not_found
+    end
+
+    aget '/302' do
+      ahalt 302
+    end
+
+    aget '/em_halt' do
+      EM.next_tick { ahalt 404 }
+    end
+
+    aget '/s401' do
+      halt 401
+    end
+
+    aget '/a401' do
+      ahalt 401
+    end
+  end
+
+  def app
+    TestApp.new
+  end
+
+  def test_basic_async_get
+    get '/hello'
+    assert_async
+    async_continue
+    assert last_response.ok?
+    assert_equal 'hello async', last_response.body
+  end
+
+  def test_em_get
+    get '/em'
+    assert_async
+    em_async_continue
+    assert last_response.ok?
+    assert_equal 'em', last_response.body
+  end
+
+  def test_em_async_continue_timeout
+    get '/em_timeout'
+    assert_async
+    assert_raises(Test::Unit::AssertionFailedError) do
+      em_async_continue(0.001)
+    end
+  end
+
+  def test_404
+    get '/404'
+    assert_async
+    async_continue
+    assert_equal 404, last_response.status
+  end
+
+  def test_302
+    get '/302'
+    assert_async
+    async_continue
+    assert_equal 302, last_response.status
+  end
+
+  def test_em_halt
+    get '/em_halt'
+    assert_async
+    em_async_continue
+    assert_equal 404, last_response.status
+  end
+
+  def test_error_blocks_sync
+    get '/s401'
+    assert_async
+    async_continue
+    assert_equal 401, last_response.status
+    assert_equal '401', last_response.body
+  end
+
+  def test_error_blocks_async
+    get '/a401'
+    assert_async
+    async_continue
+    assert_equal 401, last_response.status
+    assert_equal '401', last_response.body
+  end
+end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: async_sinatra
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
+  hash: 23
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - James Tucker
@@ -9,50 +15,58 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-24 00:00:00 +00:00
+date: 2009-03-24 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sinatra
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 9
+        - 1
         version: 0.9.1
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: thin
   type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.2.0
-    version: 
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rdoc
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 29
+        segments: 
+        - 2
+        - 4
+        - 1
         version: 2.4.1
-    version: 
+  type: :development
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: rake
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 0
+        - 8
+        - 3
         version: 0.8.3
-    version: 
-description: Asynchronous response API for Sinatra and Thin
+  type: :development
+  version_requirements: *id003
+description: Asynchronous response API for Sinatra
 email: raggi@rubyforge.org
 executables: []
 
@@ -65,6 +79,9 @@ files:
 - Rakefile
 - 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
 licenses: []
@@ -80,23 +97,29 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: libraggi
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 2
-summary: Asynchronous response API for Sinatra and Thin
-test_files: []
-
+summary: Asynchronous response API for Sinatra
+test_files: 
+- test/test_async.rb