darkhelmet-sinatra 0.9.0.5 → 0.9.1

data/CHANGES

@@ -1,34 +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]
- * Fix :provides causing crash on any request when request has no
-   Accept header [#139]
- * Fix that ERB templates were evaluated twice per "erb" call.
+
  * 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/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

@@ -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

@@ -6,7 +6,7 @@ require 'rack/builder'
 require 'colored'
 
 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
@@ -50,7 +50,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
@@ -345,10 +345,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
 
-      @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
+
+      [status, header, body]
     end
 
     # Access options defined with Base.set.
@@ -542,8 +549,8 @@ module Sinatra
     @conditions = []
     @templates  = {}
     @middleware = []
-    @callsite   = nil
     @errors     = {}
+    @prototype  = nil
 
     class << self
       attr_accessor :routes, :filters, :conditions, :templates,
@@ -720,13 +727,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
@@ -739,7 +749,7 @@ module Sinatra
       end
 
       def use(middleware, *args, &block)
-        reset_middleware
+        @prototype = nil
         @middleware << [middleware, args, block]
       end
 
@@ -760,22 +770,61 @@ module Sinatra
         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)
@@ -789,38 +838,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?
@@ -830,13 +852,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

data/lib/sinatra/test.rb

@@ -14,27 +14,27 @@ for more information.
       EOF
     end
 
-    def make_request(verb, path, data=nil, h=nil)
+    def make_request(verb, path, body=nil, options={})
       @app = Sinatra::Application if @app.nil? && defined?(Sinatra::Application)
       fail "@app not set - cannot make request" if @app.nil?
 
       @request = Rack::MockRequest.new(@app)
-      options  = { :lint => true }
-
-      case data
-      when Hash
-        if env = data.delete(:env)
-          options = rack_options(env)
-        end
-        options.merge!(h) if h.is_a?(Hash)
-        options[:input] = param_string(data)
-      when String
-        options = rack_options(h) if h.is_a?(Hash)
-        options[:input] = data
+      options = { :lint => true }.merge(options || {})
+
+      case
+      when body.respond_to?(:to_hash)
+        options.merge! body.delete(:env) if body.key?(:env)
+        options[:input] = param_string(body)
+      when body.respond_to?(:to_str)
+        options[:input] = body
+      when body.nil?
+        options[:input] = ''
+      else
+        raise ArgumentError, "body must be a Hash, String, or nil"
       end
 
-      # TODO: yield @request if block_given?
-      @response = @request.request(verb, path, options)
+      yield @request if block_given?
+      @response = @request.request(verb, path, rack_options(options))
     end
 
     def get(path, *args, &b)  ; make_request('GET', path, *args, &b) ; end
@@ -67,12 +67,12 @@ for more information.
   private
 
     RACK_OPTIONS = {
-      :accept => "HTTP_ACCEPT",
-      :agent => "HTTP_USER_AGENT",
-      :host => "HTTP_HOST",
-      :session => "HTTP_COOKIE",
-      :cookies => "HTTP_COOKIE",
-      :content_type => "CONTENT_TYPE"
+      :accept       => 'HTTP_ACCEPT',
+      :agent        => 'HTTP_USER_AGENT',
+      :host         => 'HTTP_HOST',
+      :session      => 'rack.session',
+      :cookies      => 'HTTP_COOKIE',
+      :content_type => 'CONTENT_TYPE'
     }
 
     def rack_options(opts)

data/sinatra.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'sinatra'
-  s.version = '0.9.0.5'
-  s.date = '2009-02-10'
+  s.version = '0.9.1'
+  s.date = '2009-03-01'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"

data/test/base_test.rb

@@ -108,5 +108,23 @@ describe "Sinatra::Base as Rack middleware" do
     assert_equal 210, response.status
     assert_equal 'true', response['X-Downstream']
     assert_equal 'Hello after explicit forward', response.body
+    assert_equal '28', response['Content-Length']
+  end
+
+  app_content_length = lambda {|env|
+    [200, {'Content-Length' => '16'}, 'From downstream!']}
+  class TestMiddlewareContentLength < Sinatra::Base
+    get '/forward' do
+      res = forward
+      'From after explicit forward!'
+    end
+  end
+
+  middleware_content_length = TestMiddlewareContentLength.new(app_content_length)
+  request_content_length = Rack::MockRequest.new(middleware_content_length)
+
+  it "sets content length for last response" do
+    response = request_content_length.get('/forward')
+    assert_equal '28', response['Content-Length']
   end
 end

data/test/extensions_test.rb

@@ -60,4 +60,25 @@ describe 'Registering extensions' do
     assert !Sinatra::Base.respond_to?(:baz)
     assert Sinatra::Default.respond_to?(:baz)
   end
+
+  module BizzleExtension
+    def bizzle
+      bizzle_option
+    end
+
+    def self.registered(base)
+      fail "base should be BizzleApp" unless base == BizzleApp
+      fail "base should have already extended BizzleExtension" unless base.respond_to?(:bizzle)
+      base.set :bizzle_option, 'bizzle!'
+    end
+  end
+
+  class BizzleApp < Sinatra::Base
+  end
+
+  it 'sends .registered to the extension module after extending the class' do
+    BizzleApp.register BizzleExtension
+    assert_equal 'bizzle!', BizzleApp.bizzle_option
+    assert_equal 'bizzle!', BizzleApp.bizzle
+  end
 end

data/test/middleware_test.rb

@@ -57,4 +57,12 @@ describe "Middleware" do
     assert_equal '/foo', body
     assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests']
   end
+
+  it "works when app is used as middleware" do
+    @app.use UpcaseMiddleware
+    @app = @app.new
+    get '/Foo'
+    assert_equal "/FOO", body
+    assert_equal "UpcaseMiddleware", response['X-Tests']
+  end
 end

data/test/test_test.rb

@@ -45,7 +45,8 @@ describe 'Sinatra::Test' do
     assert_equal('DELETE', request['REQUEST_METHOD'])
 
     head '/'
-    assert_equal('0', headers['Content-Length'])
+    assert_equal('596', response.headers['Content-Length'])
+    assert_equal('', response.body)
   end
 
   it 'allows to specify a body' do
@@ -92,7 +93,7 @@ describe 'Sinatra::Test' do
     assert_equal '1.2.3.4', request['HTTP_HOST']
 
     get '/', :env => { :session => 'foo' }
-    assert_equal 'foo', request['HTTP_COOKIE']
+    assert_equal 'foo', request['rack.session']
 
     get '/', :env => { :cookies => 'foo' }
     assert_equal 'foo', request['HTTP_COOKIE']
@@ -101,6 +102,34 @@ describe 'Sinatra::Test' do
     assert_equal 'text/plain', request['CONTENT_TYPE']
   end
 
+  it 'allow to test session easily' do
+    app = mock_app(Sinatra::Default) {
+      get '/' do
+        session['foo'] = 'bar'
+        200
+      end
+
+      post '/' do
+        assert_equal 'bar', session['foo']
+        session['foo'] || "blah"
+      end
+    }
+
+    browser = Sinatra::TestHarness.new(app)
+    browser.get '/'
+    browser.post '/', {}, :session => { 'foo' => 'bar' }
+    assert_equal 'bar', browser.response.body
+  end
+
+  it 'yields the request object to the block before invoking the application' do
+    called = false
+    get '/' do |req|
+      called = true
+      assert req.kind_of?(Rack::MockRequest)
+    end
+    assert called
+  end
+
   def test_TestHarness
     session  = Sinatra::TestHarness.new(@app)
     response = session.get('/')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: darkhelmet-sinatra
 version: !ruby/object:Gem::Version 
-  version: 0.9.0.5
+  version: 0.9.1
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-10 00:00:00 -08:00
+date: 2009-03-01 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency