async-rack 0.5.0 → 0.5.1

data/lib/async_rack.rb

@@ -13,10 +13,17 @@ module AsyncRack
   module ExtensionMixin
     ::AsyncRack.extend self
     def autoload(class_name, path)
-      if Rack.const_defined? class_name
+      mod = Rack
+      mod_path = self.name.split("::")
+      mod_path.shift
+      while (mod_ = mod_path.shift)
+        mod = mod.const_get(mod_.to_sym)
+      end
+      # already loaded ? override.
+      if mod.autoload?(class_name) == nil
         require path
       else
-        Rack.autoload class_name, path
+        mod.autoload class_name, path
         super
       end
     end

data/lib/async_rack/runtime.rb

@@ -4,9 +4,9 @@ module AsyncRack
   class Runtime < AsyncCallback(:Runtime)
     def async_callback(result)
       status, headers, body =result
-      request_time = Time.now - start_time
+      request_time = Time.now - @start_time
       headers[@header_name] = "%0.6f" % request_time if !headers.has_key?(@header_name)
-      [status, headers, body]
+      super [status, headers, body]
     end
 
     def call(env)

data/lib/async_rack/session/cookie.rb

@@ -1,8 +1,8 @@
-require "rack/cookie"
+require "rack/session/cookie"
 
 module AsyncRack
   module Session
-    class Cookie < AsyncCallback(:Cookie, Rack::Session)
+    class Cookie < AsyncRack::AsyncCallback(:Cookie, Rack::Session)
       def async_callback(result)
         super commit_session(env, *result)
       end

data/lib/async_rack/session/memcache.rb

@@ -1,8 +1,8 @@
-require "rack/memcache"
+require "rack/session/memcache"
 
 module AsyncRack
   module Session
-    class Memcache < AsyncCallback(:Memcache, Rack::Session)
+    class Memcache < AsyncRack::AsyncCallback(:Memcache, Rack::Session)
       def async_callback(result)
         super commit_session(env, *result)
       end

data/lib/async_rack/session/pool.rb

@@ -1,8 +1,8 @@
-require "rack/pool"
+require "rack/session/pool"
 
 module AsyncRack
   module Session
-    class Pool < AsyncCallback(:Pool, Rack::Session)
+    class Pool < AsyncRack::AsyncCallback(:Pool, Rack::Session)
       def async_callback(result)
         super commit_session(env, *result)
       end

data/lib/rack/async.rb

@@ -0,0 +1,26 @@
+require 'rack'
+
+module Rack
+  fail 'Rack version mismatch' if release != '1.2'
+  ASYNC_RESPONSE = [-1, {}, []].freeze
+
+  module Async
+    # Tools used to wrap sync middleware
+    autoload :AutoloadHook, 'rack/async/autoload_hook'
+    autoload :Original,     'rack/async/original'
+    autoload :Wrapper,      'rack/async/wrapper'
+  end
+
+  extend Async::AutoloadHook
+
+  # Wrapped middleware
+  autoload :ConditionalGet, 'rack/async/conditional_get'
+  autoload :Lint,           'rack/async/lint'
+
+  # New middleware
+  autoload :ReplaceableResponse,  'rack/replaceable_response'
+
+  module Session
+    extend Async::AutoloadHook
+  end
+end

data/lib/rack/async/autoload_hook.rb

@@ -0,0 +1,33 @@
+module Rack
+  module Async
+    module AutoloadHook
+      ##
+      # Hooks into Rack.autoload to allow replacing already defined autoload
+      # paths with the paths to the async counterparts but avoids accidentally
+      # overwriting them with the old paths, for instance if Rack::Reloader is
+      # used.
+      #
+      # If the middleware is already loaded, +require+ the counterpart.
+      def autoload(const_name, path)
+        if const_defined?(const_name) and not autoload?(const_name)
+          require path
+        elsif autoload?(const_name) !~ /^rack\/async/
+          @autoloaded = false
+          super
+        end
+      end
+
+      ##
+      # Module#autoload is not thread-safe.
+      # Use Rack.autoload! to preload all middleware in order to avoid race conditions.
+      def autoload!
+        return if @autoloaded
+        @autoloaded = true
+        constants.each do |const_name|
+          const = const_get(const_name)
+          const.autoload! if const.respond_to? :autoload!
+        end
+      end
+    end
+  end
+end

data/lib/rack/async/conditional_get.rb

@@ -0,0 +1,12 @@
+require 'rack/conditionalget'
+
+module Rack
+  module Async
+    module ConditionalGet < Original::ConditionalGet
+      include Wrapper
+    end
+  end
+
+  const_remove :ConditionalGet
+  ConditionalGet = Async::ConditionalGet
+end

data/lib/rack/async/lint.rb

@@ -0,0 +1,22 @@
+require 'rack/lint'
+
+module Rack
+  module Async
+    class Lint < Original::Lint
+      def check_status(status)                  super unless status.to_i < 0  end
+      def check_content_type(status, headers)   super unless status.to_i < 0  end
+      def check_content_length(status, headers) super unless status.to_i < 0  end
+
+      def _call(env)
+        status, *rest = catch(:async) { super } || ASYNC_RESPONSE
+        assert "async response detected without the handler supporting async.callback" do
+          status.to_i < 0 and not env.include?('async.callback')
+        end
+        [status, *rest]
+      end
+    end
+  end
+
+  const_remove :Lint
+  Lint = Async::Lint
+end

data/lib/rack/async/original.rb

@@ -0,0 +1,28 @@
+module Rack
+  module Session; end
+  module Async
+    ##
+    # This module is used as a bucket to keep a reference
+    # to old middleware in case it was replaced by a new implementation.
+    #
+    # Rack::Foo might get replaced by Rack::Async::Foo. The old Rack::Foo
+    # is still accessable as Rack::Original::Foo, if Rack::Async::Foo is
+    # subclassing it (recommended).
+    module Original
+      module Store
+        attr_accessor :base
+        def const_missing(name)
+          const_set name, base.const_get(name)
+        end
+      end
+
+      extend Store
+      self.base = ::Rack
+
+      module Session
+        extend Store
+        self.base = ::Rack::Session
+      end
+    end
+  end
+end

data/lib/rack/async/wrapper.rb

@@ -0,0 +1,22 @@
+module Rack
+  module Async
+    module Wrapper
+      def initialize(app, *args, &block)
+        super(CachedResponse.new(app), *args, &block)
+      end
+
+      def call(env)
+        return super unless callback = env['async.callback']
+        env['async.callback'] = proc do |result|
+          app.set_response_for(env, result)
+          async_call(env)
+        end
+        catch(:async) { super } || ASYNC_RESPONSE
+      end
+
+      def async_call(env)
+        call(env)
+      end
+    end
+  end
+end

data/lib/rack/replaceable_response.rb

@@ -0,0 +1,25 @@
+module Rack
+  ##
+  # Middleware that allows setting a predefined response for a request.
+  # If response is set, it will be returned instead of handing env on to
+  # the next middleware/endpoint. Response is stored in env, so it will be
+  # eaten by the GC as soon as possible.
+  #
+  # @example
+  #   class Wrapper < Wrapped
+  #     def call(env)
+  #       @app.response_for(env, some_response) if some_condition
+  #       super
+  #     end
+  #   end
+  #
+  #   use Wrapper
+  #   use ReplaceableResponse
+  #   run SomeApp
+  class ReplaceableResponse
+    def initialize(app)                 @app = app                                      end
+    def response_for(env, result = nil) (env['cached.responses'] ||= {})[self] = result end
+    def call(env)                       response_for(env) or @app.call(env)             end
+    alias set_response_for response_for
+  end
+end

data/spec/spec_conditional_get_sync.rb

@@ -0,0 +1,39 @@
+require 'time'
+require 'rack/async'
+require 'rack/mock'
+
+describe Rack::ConditionalGet do
+  should "set a 304 status and truncate body when If-Modified-Since hits" do
+    timestamp = Time.now.httpdate
+    app = Rack::ConditionalGet.new(lambda { |env|
+      [200, {'Last-Modified'=>timestamp}, ['TEST']] })
+
+    response = Rack::MockRequest.new(app).
+      get("/", 'HTTP_IF_MODIFIED_SINCE' => timestamp)
+
+    response.status.should.equal 304
+    response.body.should.be.empty
+  end
+
+  should "set a 304 status and truncate body when If-None-Match hits" do
+    app = Rack::ConditionalGet.new(lambda { |env|
+      [200, {'Etag'=>'1234'}, ['TEST']] })
+
+    response = Rack::MockRequest.new(app).
+      get("/", 'HTTP_IF_NONE_MATCH' => '1234')
+
+    response.status.should.equal 304
+    response.body.should.be.empty
+  end
+
+  should "not affect non-GET/HEAD requests" do
+    app = Rack::ConditionalGet.new(lambda { |env|
+      [200, {'Etag'=>'1234'}, ['TEST']] })
+
+    response = Rack::MockRequest.new(app).
+      post("/", 'HTTP_IF_NONE_MATCH' => '1234')
+
+    response.status.should.equal 200
+    response.body.should.equal 'TEST'
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: async-rack
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 0
   - 5
-  - 0
-  version: 0.5.0
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Konstantin Haase
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-09 00:00:00 +02:00
+date: 2011-02-07 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -79,7 +79,15 @@ files:
 - lib/async_rack/showstatus.rb
 - lib/async_rack/throw_async.rb
 - lib/async_rack.rb
+- lib/rack/async/autoload_hook.rb
+- lib/rack/async/conditional_get.rb
+- lib/rack/async/lint.rb
+- lib/rack/async/original.rb
+- lib/rack/async/wrapper.rb
+- lib/rack/async.rb
+- lib/rack/replaceable_response.rb
 - spec/async_rack/async_callback_spec.rb
+- spec/spec_conditional_get_sync.rb
 - spec/spec_helper.rb
 - README.md
 - LICENSE