bmizerany-sinatra 0.9.0.5 → 0.9.1

data/CHANGES

@@ -1,24 +1,62 @@
-= 0.9.1 / unreleased
+= 0.9.1 / 2009-03-01
 
  * Sinatra now runs under Ruby 1.9.1 [#61]
+
  * Route patterns (splats, :named, or Regexp captures) are now
    passed as arguments to the block. [#140]
+
  * The "helpers" method now takes a variable number of modules
    along with the normal block syntax. [#133]
+
+ * New request-level #forward method for middleware components: passes
+   the env to the downstream app and merges the response status, headers,
+   and body into the current context.
+
+ * Requests are now automatically forwarded to the downstream app when
+   running as middleware and no matching route is found or all routes
+   pass.
+
  * New simple API for extensions/plugins to add DSL-level and
    request-level methods. Use Sinatra.register(mixin) to extend
    the DSL with all public methods defined in the mixin module;
    use Sinatra.helpers(mixin) to make all public methods defined
    in the mixin module available at the request level. [#138]
- * Added "redirect back" to redirect to the referring URL.
+   See http://www.sinatrarb.com/extensions.html for details.
+
+ * Named parameters in routes now capture the "." character. This makes
+   routes like "/:path/:filename" match against requests like
+   "/foo/bar.txt"; in this case, "params[:filename]" is "bar.txt".
+   Previously, the route would not match at all.
+
+ * Added request-level "redirect back" to redirect to the referring
+   URL.
+
  * Added a new "clean_trace" option that causes backtraces dumped
    to rack.errors and displayed on the development error page to
    omit framework and core library backtrace lines. The option is
    enabled by default. [#77]
+
+ * The ERB output buffer is now available to helpers via the @_out_buf
+   instance variable.
+
+ * It's now much easier to test sessions in unit tests by passing a
+   ":session" option to any of the mock request methods. e.g.,
+       get '/', {}, :session => { 'foo' => 'bar' }
+
+ * The request-level #send_data method from Sinatra 0.3.3 has been added
+   for compatibility but is deprecated.
+
  * Fix :provides causing crash on any request when request has no
    Accept header [#139]
+
  * Fix that ERB templates were evaluated twice per "erb" call.
 
+ * Fix app-level middleware not being run when the Sinatra application is
+   run as middleware.
+
+ * Fixed some issues with running under Rack's CGI handler caused by
+   writing informational stuff to stdout.
+
 = 0.9.0.4 / 2009-01-25
 
  * Using halt with more than 1 args causes ArgumentError [#131]

data/README.rdoc

@@ -420,8 +420,8 @@ and Bacon through separate source files.
     end
 
     def test_with_agent
-      get '/', :agent => 'Songbird'
-      assert_equal 'You're in Songbird!', @response.body
+      get '/', :env => { :agent => 'Songbird' }
+      assert_equal "You're in Songbird!", @response.body
     end
 
     ...
@@ -527,7 +527,7 @@ To update the Sinatra sources in the future:
 
 * {Project Website}[http://sinatra.github.com/] - Additional documentation,
   news, and links to other resources.
-* {Contributing}[http://sinatra.github.com/contribute.html] - Find a bug? Need
+* {Contributing}[http://sinatra.github.com/contributing.html] - Find a bug? Need
   help? Have a patch?
 * {Lighthouse}[http://sinatra.lighthouseapp.com] - Issue tracking and release
   planning.

data/compat/app_test.rb

@@ -146,25 +146,6 @@ context "Sinatra" do
 
   end
 
-  # Deprecated. WTF was going on here? What's the 1 in [:foo, 1] do?
-  xspecify "should set status then call helper with a var" do
-    helpers do
-      def foo
-        'bah!'
-      end
-    end
-
-    get '/set_body' do
-      stop [404, [:foo, 1]]
-    end
-
-    get_it '/set_body'
-
-    should.be.not_found
-    body.should.equal 'bah!'
-
-  end
-
   specify "should easily set response Content-Type" do
     get '/foo.html' do
       content_type 'text/html', :charset => 'utf-8'

data/compat/application_test.rb

@@ -10,47 +10,6 @@ class TesterWithEach
   end
 end
 
-context "Looking up a request" do
-
-  setup do
-    Sinatra.application = nil
-  end
-
-  # Deprecated. The lookup method is no longer used.
-  xspecify "returns what's at the end" do
-    block = Proc.new { 'Hello' }
-    get '/', &block
-
-    result = Sinatra.application.lookup(
-      Rack::Request.new(
-        'REQUEST_METHOD' => 'GET',
-        'PATH_INFO' => '/'
-      )
-    )
-
-    result.should.not.be.nil
-    result.block.should.be block
-  end
-
-  # Deprecated. The lookup method is no longer used.
-  xspecify "takes params in path" do
-    block = Proc.new { 'Hello' }
-    get '/:foo', &block
-
-    result = Sinatra.application.lookup(
-      Rack::Request.new(
-        'REQUEST_METHOD' => 'GET',
-        'PATH_INFO' => '/bar'
-      )
-    )
-
-    result.should.not.be.nil
-    result.block.should.be block
-    result.params.should.equal "foo" => 'bar'
-  end
-
-end
-
 context "An app returns" do
 
   setup do
@@ -85,20 +44,6 @@ context "An app returns" do
 
   end
 
-  # Deprecated. The body method no longer halts.
-  xspecify "the body set if set before the last" do
-
-    get '/' do
-      body 'Blake'
-      'Mizerany'
-    end
-
-    get_it '/'
-    should.be.ok
-    body.should.equal 'Blake'
-
-  end
-
   specify "404 if NotFound is raised" do
 
     get '/' do
@@ -143,23 +88,6 @@ context "Application#configure blocks" do
 
 end
 
-context "Default Application Configuration" do
-
-  # Sinatra::ServerError is no longer used
-  xspecify "includes 404 and 500 error handlers" do
-    Sinatra.application.errors.should.include(Sinatra::ServerError)
-    Sinatra.application.errors[Sinatra::ServerError].should.not.be.nil
-    Sinatra.application.errors.should.include(Sinatra::NotFound)
-    Sinatra.application.errors[Sinatra::NotFound].should.not.be.nil
-  end
-
-  # Deprecated. No such thing as a Static event anymore.
-  xspecify "includes Static event" do
-    assert Sinatra.application.events[:get].any? { |e| Sinatra::Static === e }
-  end
-
-end
-
 context "Events in an app" do
 
   setup do

data/compat/pipeline_test.rb

@@ -23,32 +23,6 @@ context "Middleware Pipelines" do
     Sinatra.application = nil
   end
 
-  # Sessions and logging are tested elsewhere. This is a bad test because it
-  # asserts things about the implementation and not the effect.
-  xspecify "includes default middleware with options set" do
-    @app.set_options :sessions => true, :logging => true
-    @app.send(:optional_middleware).should.include([Rack::Session::Cookie, [], nil])
-    @app.send(:optional_middleware).should.include([Rack::CommonLogger, [], nil])
-  end
-
-  # Bad test.
-  xspecify "does not include default middleware with options unset" do
-    @app.set_options :sessions => false, :logging => false
-    @app.send(:optional_middleware).should.not.include([Rack::Session::Cookie, [], nil])
-    @app.send(:optional_middleware).should.not.include([Rack::CommonLogger, [], nil])
-  end
-
-  # Bad test.
-  xspecify "includes only optional middleware when no explicit middleware added" do
-    @app.set_options :sessions => true, :logging => true
-    @app.send(:middleware).should.equal @app.send(:optional_middleware)
-  end
-
-  # Bad test.
-  xspecify "should clear middleware before reload" do
-    @app.clearables.should.include(@app.send(:explicit_middleware))
-  end
-
   specify "should add middleware with use" do
     block = Proc.new { |env| }
     @app.use UpcaseMiddleware

data/compat/sessions_test.rb

@@ -21,6 +21,7 @@ context "Sessions" do
 
   specify "should be able to store data accross requests" do
     set_option :sessions, true
+    set_option :environment, :not_test # necessary because sessions are disabled
 
     get '/foo' do
       session[:test] = true
@@ -34,6 +35,8 @@ context "Sessions" do
     get_it '/foo', :env => { :host => 'foo.sinatrarb.com' }
     assert ok?
     assert include?('Set-Cookie')
+
+    set_option :environment, :test
   end
 
 end

data/compat/streaming_test.rb

@@ -93,7 +93,7 @@ context "SendData" do
   end
 
   # Deprecated. send_data is going away.
-  xspecify "should send the data with options" do
+  specify "should send the data with options" do
     get '/' do
       send_data 'asdf', :status => 500
     end
@@ -105,9 +105,10 @@ context "SendData" do
   end
 
   # Deprecated. The Content-Disposition is no longer handled by sendfile.
-  xspecify "should include a Content-Disposition header" do
+  specify "should include a Content-Disposition header" do
     get '/' do
-      send_file File.dirname(__FILE__) + '/public/foo.xml'
+      send_file File.dirname(__FILE__) + '/public/foo.xml',
+        :disposition => 'attachment'
     end
 
     get_it '/'
@@ -115,7 +116,6 @@ context "SendData" do
     should.be.ok
     headers['Content-Disposition'].should.not.be.nil
     headers['Content-Disposition'].should.equal 'attachment; filename="foo.xml"'
-    headers['Content-Transfer-Encoding'].should.equal 'binary'
   end
 
   specify "should include a Content-Disposition header when :disposition set to attachment" do

data/lib/sinatra/base.rb

@@ -5,7 +5,7 @@ require 'rack'
 require 'rack/builder'
 
 module Sinatra
-  VERSION = '0.9.0.5'
+  VERSION = '0.9.1'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
@@ -49,7 +49,7 @@ module Sinatra
       else
         body = @body || []
         body = [body] if body.respond_to? :to_str
-        if header["Content-Length"].nil? && body.respond_to?(:to_ary)
+        if body.respond_to?(:to_ary)
           header["Content-Length"] = body.to_ary.
             inject(0) { |len, part| len + part.bytesize }.to_s
         end
@@ -281,12 +281,17 @@ module Sinatra
     end
 
     def render_erb(template, data, options, &block)
+      original_out_buf = @_out_buf
       data = data.call if data.kind_of? Proc
-      instance = ::ERB.new(data)
+
+      instance = ::ERB.new(data, nil, nil, '@_out_buf')
       locals = options[:locals] || {}
       locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
+
       src = "#{locals_assigns.join("\n")}\n#{instance.src}"
       eval src, binding, '(__ERB__)', locals_assigns.length + 1
+      @_out_buf, result = original_out_buf, @_out_buf
+      result
     end
 
     def render_haml(template, data, options, &block)
@@ -339,10 +344,17 @@ module Sinatra
       invoke { dispatch! }
       invoke { error_block!(response.status) }
 
-      # never respond with a body on HEAD requests
-      @response.body = [] if @env['REQUEST_METHOD'] == 'HEAD'
+      status, header, body = @response.finish
+
+      # Never produce a body on HEAD requests. Do retain the Content-Length
+      # unless it's "0", in which case we assume it was calculated erroneously
+      # for a manual HEAD response and remove it entirely.
+      if @env['REQUEST_METHOD'] == 'HEAD'
+        body = []
+        header.delete('Content-Length') if header['Content-Length'] == '0'
+      end
 
-      @response.finish
+      [status, header, body]
     end
 
     # Access options defined with Base.set.
@@ -361,6 +373,16 @@ module Sinatra
       throw :pass
     end
 
+    # Forward the request to the downstream app -- middleware only.
+    def forward
+      fail "downstream app not set" unless @app.respond_to? :call
+      status, headers, body = @app.call(@request.env)
+      @response.status = status
+      @response.body = body
+      headers.each { |k, v| @response[k] = v }
+      nil
+    end
+
   private
     # Run before filters and then locate and run a matching route.
     def route!
@@ -372,11 +394,11 @@ module Sinatra
       # routes
       if routes = self.class.routes[@request.request_method]
         original_params = @params
-        path            = @request.path_info
+        path            = unescape(@request.path_info)
 
         routes.each do |pattern, keys, conditions, block|
           if match = pattern.match(path)
-            values = match.captures.map{|val| val && unescape(val) }
+            values = match.captures.to_a
             params =
               if keys.any?
                 keys.zip(values).inject({}) do |hash,(k,v)|
@@ -404,7 +426,13 @@ module Sinatra
         end
       end
 
-      raise NotFound
+      # No matching route found or all routes passed -- forward downstream
+      # when running as middleware; 404 when running as normal app.
+      if @app
+        forward
+      else
+        raise NotFound
+      end
     end
 
     def nested_params(params)
@@ -517,8 +545,8 @@ module Sinatra
     @conditions = []
     @templates  = {}
     @middleware = []
-    @callsite   = nil
     @errors     = {}
+    @prototype  = nil
 
     class << self
       attr_accessor :routes, :filters, :conditions, :templates,
@@ -673,7 +701,7 @@ module Sinatra
         if path.respond_to? :to_str
           special_chars = %w{. + ( )}
           pattern =
-            URI.encode(path).gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+            path.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
               case match
               when "*"
                 keys << 'splat'
@@ -682,7 +710,7 @@ module Sinatra
                 Regexp.escape(match)
               else
                 keys << $2[1..-1]
-                "([^/?&#\.]+)"
+                "([^/?&#]+)"
               end
             end
           [/^#{pattern}$/, keys]
@@ -695,13 +723,16 @@ module Sinatra
 
     public
       def helpers(*extensions, &block)
-        class_eval(&block) if block_given?
-        include *extensions
+        class_eval(&block)  if block_given?
+        include *extensions if extensions.any?
       end
 
       def register(*extensions, &block)
-        extensions << Module.new(&block) if block
-        extend *extensions
+        extensions << Module.new(&block) if block_given?
+        extensions.each do |extension|
+          extend extension
+          extension.registered(self) if extension.respond_to?(:registered)
+        end
       end
 
       def development? ; environment == :development ; end
@@ -714,7 +745,7 @@ module Sinatra
       end
 
       def use(middleware, *args, &block)
-        reset_middleware
+        @prototype = nil
         @middleware << [middleware, args, block]
       end
 
@@ -723,34 +754,73 @@ module Sinatra
         handler      = detect_rack_handler
         handler_name = handler.name.gsub(/.*::/, '')
         puts "== Sinatra/#{Sinatra::VERSION} has taken the stage " +
-          "on #{port} for #{environment} with backup from #{handler_name}"
+          "on #{port} for #{environment} with backup from #{handler_name}" unless handler_name =~/cgi/i
         handler.run self, :Host => host, :Port => port do |server|
           trap(:INT) do
             ## Use thins' hard #stop! if available, otherwise just #stop
             server.respond_to?(:stop!) ? server.stop! : server.stop
-            puts "\n== Sinatra has ended his set (crowd applauds)"
+            puts "\n== Sinatra has ended his set (crowd applauds)" unless handler_name =~/cgi/i
           end
         end
       rescue Errno::EADDRINUSE => e
         puts "== Someone is already performing on port #{port}!"
       end
 
+      # The prototype instance used to process requests.
+      def prototype
+        @prototype ||= new
+      end
+
+      # Create a new instance of the class fronted by its middleware
+      # pipeline. The object is guaranteed to respond to #call but may not be
+      # an instance of the class new was called on.
+      def new(*args, &bk)
+        builder = Rack::Builder.new
+        builder.use Rack::Session::Cookie if sessions? && !test?
+        builder.use Rack::CommonLogger if logging?
+        builder.use Rack::MethodOverride if methodoverride?
+        @middleware.each { |c, args, bk| builder.use(c, *args, &bk) }
+        builder.run super
+        builder.to_app
+      end
+
       def call(env)
         synchronize do
           reload! if reload?
-          construct_middleware if @callsite.nil?
-          @callsite.call(env)
+          prototype.call(env)
         end
       end
 
+      def reloading?
+        @reloading
+      end
+
       def reload!
         @reloading = true
-        superclass.send :reset!, self
+        reset!
         $LOADED_FEATURES.delete("sinatra.rb")
         ::Kernel.load app_file
         @reloading = false
       end
 
+      def reset!(base=superclass)
+        @routes     = base.dupe_routes
+        @templates  = base.templates.dup
+        @conditions = []
+        @filters    = base.filters.dup
+        @errors     = base.errors.dup
+        @middleware = base.middleware.dup
+        @prototype  = nil
+      end
+
+    protected
+      def dupe_routes
+        routes.inject({}) do |hash,(request_method,routes)|
+          hash[request_method] = routes.dup
+          hash
+        end
+      end
+
     private
       def detect_rack_handler
         servers = Array(self.server)
@@ -764,38 +834,11 @@ module Sinatra
         fail "Server handler (#{servers.join(',')}) not found."
       end
 
-      def construct_middleware(builder=Rack::Builder.new)
-        builder.use Rack::Session::Cookie if sessions?
-        builder.use Rack::CommonLogger if logging?
-        builder.use Rack::MethodOverride if methodoverride?
-        @middleware.each { |c, args, bk| builder.use(c, *args, &bk) }
-        builder.run new
-        @callsite = builder.to_app
-      end
-
-      def reset_middleware
-        @callsite = nil
-      end
-
-      def reset!(subclass = self)
-        subclass.routes     = dupe_routes
-        subclass.templates  = templates.dup
-        subclass.conditions = []
-        subclass.filters    = filters.dup
-        subclass.errors     = errors.dup
-        subclass.middleware = middleware.dup
-        subclass.send :reset_middleware
-      end
-
       def inherited(subclass)
-        reset!(subclass)
+        subclass.reset! self
         super
       end
 
-      def reloading?
-        @reloading ||= false
-      end
-
       @@mutex = Mutex.new
       def synchronize(&block)
         if lock?
@@ -805,13 +848,6 @@ module Sinatra
         end
       end
 
-      def dupe_routes
-        routes.inject({}) do |hash,(request_method,routes)|
-          hash[request_method] = routes.dup
-          hash
-        end
-      end
-
       def metadef(message, &block)
         (class << self; self; end).
           send :define_method, message, &block
@@ -916,13 +952,13 @@ module Sinatra
 
   # Base class for classic style (top-level) applications.
   class Default < Base
-    set :raise_errors, false
+    set :raise_errors, Proc.new { test? }
     set :dump_errors, true
     set :sessions, false
-    set :logging, true
+    set :logging, Proc.new { ! test? }
     set :methodoverride, true
     set :static, true
-    set :run, false
+    set :run, Proc.new { ! test? }
 
     def self.register(*extensions, &block) #:nodoc:
       added_methods = extensions.map {|m| m.public_instance_methods }.flatten
@@ -980,26 +1016,3 @@ class String #:nodoc:
   # earlier.
   alias_method :bytesize, :length unless ''.respond_to? :bytesize
 end
-
-class Rack::Builder
-  ## Sugar to include a classic style app in a rackup.
-  ##
-  ## This will eval the source into a Sinatra::Default class
-  ## Example:
-  ##
-  ## require 'sinatra/base'
-  ##
-  ## map '/foo' do
-  ##    run Sinatra("foo.rb")
-  ## end
-  ##
-  ## run Sinatra("bar.rb")
-  ##
-  def Sinatra(file, base=Sinatra::Default)
-    Sinatra.new(base) do
-      expanded = File.expand_path(file)
-      self.class_eval { set :app_file, expanded }
-      self.class_eval(File.read(expanded), expanded)
-    end
-  end
-end