async-rack 0.4.0.c → 0.4.0.d

data/README.md

@@ -1,5 +1,9 @@
 # AsyncRack
 
+## Note upfront
+Still experimental. Feel free to play around.
+
+## Introduction
 So, have you been amazed by thin's `async.callback`? If not, [go](http://macournoyer.com/blog/2009/06/04/pusher-and-async-with-thin/) [check](http://github.com/raggi/async_sinatra) [it](http://github.com/raggi/thin/blob/async_for_rack/example/async_app.ru) [out](http://m.onkey.org/2010/1/7/introducing-cramp). Come back here when you start missing your middleware.
 
 So what is the issue with Rack and `async.callback`? Currently there are two ways of triggering a async responds. The first is to `throw :async`, the latter to return a status code of -1 (even though thin and ebb do disagree on that). Opposed to what others say, I would recommend using `throw`, as it simply skips middleware not able to handle `:async`. Also, it works on all servers supporting `async.callback` – thin, ebb, rainbows! and zbatery – about the same and copes better with middleware that is unable to handle an async respond.
@@ -30,6 +34,45 @@ How does that work? Simple, whenever necessary, `async-rack` will replace `async
 
 Note: This library only 'fixes' the middleware that ships with rack, not other rack middleware. However, you can use the included helper classes to easily make other libraries handle `async.callback`.
 
+## What's in this package?
+
+### Rack middleware made async-proof
+This middleware now works well with `throw :async`:
+
+* Rack::Chunked
+* Rack::CommonLogger
+* Rack::ConditionalGet
+* Rack::ContentLength
+* Rack::ContentType
+* Rack::Deflater
+* Rack::ETag
+* Rack::Head
+* Rack::Logger
+* Rack::Runtime
+* Rack::Sendfile
+* Rack::ShowStatus
+
+### Middleware that is async-proof out of the box
+No changes where necessary for:
+
+* Rack::Cascade
+* Rack::Config
+* Rack::Directory
+* Rack::File
+* Rack::MethodOverride
+* Rack::Mime
+* Rack::NullLogger
+* Rack::Recursive
+* Rack::Reloader
+* Rack::Static
+* Rack::URLMap
+
+### Middleware not (yet) made async-proof
+
+* Rack::Lint (might not check async responses)
+* Rack::ShowExceptions (might not show exceptions for async responses)
+* Rack::Lock (might raise an exception)
+
 ## How to make a middleware async-proof?
 There are three types of middleware:
 

data/lib/async_rack.rb

@@ -13,13 +13,19 @@ module AsyncRack
   module ExtensionMixin
     ::AsyncRack.extend self
     def autoload(class_name, path)
-      super
-      if Rack.autoload? class_name then Rack.autoload(class_name, path)
-      elsif Rack.const_defined? class_name then require path
+      if Rack.const_defined? class_name
+        require path
+      else
+        Rack.autoload class_name, path
+        super
       end
     end
   end
 
+  # New middleware
+  autoload :CatchAsync,     "async_rack/catch_async"
+  autoload :ThrowAsync,     "async_rack/throw_async"
+
   # Wrapped rack middleware
   autoload :Chunked,        "async_rack/chunked"
   autoload :CommonLogger,   "async_rack/commonlogger"
@@ -31,7 +37,6 @@ module AsyncRack
   autoload :Head,           "async_rack/head"
   autoload :Lock,           "async_rack/lock"
   autoload :Logger,         "async_rack/logger"
-  # autoload :Recursive, "async_rack/recursive"
   autoload :Runtime,        "async_rack/runtime"
   autoload :Sendfile,       "async_rack/sendfile"
   autoload :ShowStatus,     "async_rack/showstatus"

data/lib/async_rack/async_callback.rb

@@ -27,6 +27,10 @@ module AsyncRack
   #   Rack::FancyMiddleware # => AsyncRack::FancyMiddleware
   #   AsyncRack::FancyMiddleware.ancestors # => [AsyncRack::AsyncCallback::Mixin, Rack::FancyMiddleware, ...]
   module AsyncCallback
+    def self.included(mod)
+      mod.send :include, Mixin
+      super
+    end
 
     ##
     # Aliases a subclass on subclassing, but only once.
@@ -82,9 +86,9 @@ module AsyncRack
       private
       def setup_late_initialize(klass)
         class << klass
-          alias create new
           def new(*args, &block)
-            proc { |env| create(*args, &block).call(env) }
+            return super if File.expand_path(caller.first[/^[^:]+/]) == File.expand_path(__FILE__)
+            proc { |env| new(*args, &block).call(env) }
           end
         end
       end
@@ -92,6 +96,7 @@ module AsyncRack
 
     module Mixin
       extend LateInitializer
+      attr_accessor :env
 
       def async_callback(result)
         @async_callback.call result

data/lib/async_rack/catch_async.rb

@@ -0,0 +1,16 @@
+require 'rack'
+module AsyncRack
+  class CatchAsync
+    Rack::CatchAsync = self unless defined? Rack::CatchAsync
+
+    def initialize(app, async_response = [-1, {}, []])
+      @app, @async_response = app, async_response
+    end
+
+    def call(env)
+      response = @async_response
+      catch(:async) { response = @app.call env }
+      response
+    end
+  end
+end

data/lib/async_rack/session/cookie.rb

@@ -4,7 +4,7 @@ module AsyncRack
   module Session
     class Cookie < AsyncCallback(:Cookie, Rack::Session)
       def async_callback(result)
-        super commit_session(@env, *result)
+        super commit_session(env, *result)
       end
     end
   end

data/lib/async_rack/session/memcache.rb

@@ -4,7 +4,7 @@ module AsyncRack
   module Session
     class Memcache < AsyncCallback(:Memcache, Rack::Session)
       def async_callback(result)
-        super commit_session(@env, *result)
+        super commit_session(env, *result)
       end
     end
   end

data/lib/async_rack/session/pool.rb

@@ -4,7 +4,7 @@ module AsyncRack
   module Session
     class Pool < AsyncCallback(:Pool, Rack::Session)
       def async_callback(result)
-        super commit_session(@env, *result)
+        super commit_session(env, *result)
       end
     end
   end

data/lib/async_rack/throw_async.rb

@@ -0,0 +1,17 @@
+require 'rack'
+
+module AsyncRack
+  class ThrowAsync
+    Rack::ThrowAsync = self unless defined? Rack::ThrowAsync
+
+    def initialize(app, throw_on = [-1, 0])
+      @app, @throw_on = app, throw_on
+    end
+
+    def call(env)
+      response = @app.call env
+      throw :async if @throw_on.include? response.first
+      response
+    end
+  end
+end

data/spec/async_rack/async_callback_spec.rb

@@ -28,7 +28,6 @@ describe AsyncRack::AsyncCallback do
     before do
       @class = Class.new do
         include AsyncRack::AsyncCallback::SimpleWrapper
-        attr_accessor :app, :env
         class << self
           attr_accessor :instance
         end
@@ -44,8 +43,7 @@ describe AsyncRack::AsyncCallback do
     end
 
     it "runs #call again on async callback, replacing app" do
-      middleware = @class.create
-      middleware.app = proc { throw :async }
+      middleware = @class.create proc { throw :async }
       catch(:async) do
         middleware.call "async.callback" => proc { |x| x + 10 }
         raise "should not get here"

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 4
   - 0
-  - c
-  version: 0.4.0.c
+  - d
+  version: 0.4.0.d
 platform: ruby
 authors: 
 - Konstantin Haase
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-12 00:00:00 +01:00
+date: 2010-03-14 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,6 +57,7 @@ extra_rdoc_files: []
 files: 
 - lib/async-rack.rb
 - lib/async_rack/async_callback.rb
+- lib/async_rack/catch_async.rb
 - lib/async_rack/chunked.rb
 - lib/async_rack/commonlogger.rb
 - lib/async_rack/conditionalget.rb
@@ -73,6 +74,7 @@ files:
 - lib/async_rack/session/memcache.rb
 - lib/async_rack/session/pool.rb
 - lib/async_rack/showstatus.rb
+- lib/async_rack/throw_async.rb
 - lib/async_rack.rb
 - spec/async_rack/async_callback_spec.rb
 - spec/spec_helper.rb