sinatra-sinatra 0.9.1.3 → 0.9.2

data/CHANGES

@@ -1,10 +1,83 @@
 = 0.9.2 / unreleased
 
+ * This version is compatible with Rack 1.0. [Rein Henrichs]
+
+ * The development-mode unhandled exception / error page has been
+   greatly enhanced, functionally and aesthetically. The error
+   page is used when the :show_exceptions option is enabled and an
+   exception propagates outside of a route handler or before filter.
+   [Simon Rozet / Matte Noble / Ryan Tomayko]
+
+ * Backtraces that move through templates now include filenames and
+   line numbers where possible. [#51 / S. Brent Faulkner]
+
+ * All templates now have an app-level option for setting default
+   template options (:haml, :sass, :erb, :builder). The app-level
+   option value must be a Hash if set and is merged with the
+   template options specified to the render method (Base#haml,
+   Base#erb, Base#builder). [S. Brent Faulkner, Ryan Tomayko]
+
+ * The method signature for all template rendering methods has
+   been unified: "def engine(template, options={}, locals={})".
+   The options Hash now takes the generic :views, :layout, and
+   :locals options but also any template-specific options. The
+   generic options are removed before calling the template specific
+   render method. Locals may be specified using either the
+   :locals key in the options hash or a second Hash option to the
+   rendering method. [#191 / Ryan Tomayko]
+
+ * The receiver is now passed to "configure" blocks. This
+   allows for the following idiom in top-level apps:
+   configure { |app| set :foo, app.root + '/foo' }
+   [TJ Holowaychuck / Ryan Tomayko]
+
+ * The "sinatra/test" lib is deprecated and will be removed in
+   Sinatra 1.0. This includes the Sinatra::Test module and
+   Sinatra::TestHarness class in addition to all the framework
+   test helpers that were deprecated in 0.9.1. The Rack::Test
+   lib should be used instead: http://gitrdoc.com/brynary/rack-test
+   [#176 / Simon Rozet]
+
  * Development mode source file reloading has been removed. The
    "shotgun" (http://rtomayko.github.com/shotgun/) program can be
    used to achieve the same basic functionality in most situations.
    Passenger users should use the "tmp/always_restart.txt"
-   file (http://tinyurl.com/c67o4h). [#166]
+   file (http://tinyurl.com/c67o4h). [#166 / Ryan Tomayko]
+
+ * Auto-requiring template libs in the erb, builder, haml, and
+   sass methods is deprecated due to thread-safety issues. You must
+   require the template libs explicitly in your app file. [Simon Rozet]
+
+ * A new Sinatra::Base#route_missing method was added. route_missing
+   is sent when no route matches the request or all route handlers
+   pass.  The default implementation forwards the request to the
+   downstream app when running as middleware (i.e., "@app" is
+   non-nil), or raises a NotFound exception when no downstream app
+   is defined. Subclasses can override this method to perform custom
+   route miss logic. [Jon Crosby]
+
+ * A new Sinatra::Base#route_eval method was added. The method
+   yields to the block and throws :halt with the result. Subclasses
+   can override this method to tap into the route execution logic.
+   [TJ Holowaychuck]
+
+ * Fix the "-x" (enable request mutex / locking) command line
+   argument. Passing -x now properly sets the :lock option.
+   [S. Brent Faulkner, Ryan Tomayko]
+
+ * Fix writer ("foo=") and predicate ("foo?") methods in extension
+   modules not being added to the registering class.
+   [#172 / Pat Nakajima]
+
+ * Fix in-file templates when running alongside activesupport and
+   fatal errors when requiring activesupport before sinatra
+   [#178 / Brian Candler]
+
+ * Fix various issues running on Google AppEngine.
+   [Samuel Goebert, Simon Rozet]
+
+ * Fix in-file templates __END__ detection when __END__ exists with
+   other stuff on a line [Yoji Shidara]
 
 = 0.9.1.1 / 2009-03-09
 

data/README.rdoc

@@ -437,34 +437,38 @@ typically don't have to +use+ them explicitly.
 
 == Testing
 
-The Sinatra::Test mixin and Sinatra::TestHarness class include a variety of
-helper methods for testing your Sinatra app:
+Sinatra tests can be written using any Rack-based testing library
+or framework. {Rack::Test}[http://gitrdoc.com/brynary/rack-test] is
+recommended:
 
   require 'my_sinatra_app'
-  require 'test/unit'
-  require 'sinatra/test'
+  require 'rack/test'
 
   class MyAppTest < Test::Unit::TestCase
-    include Sinatra::Test
+    include Rack::Test::Methods
+
+    def app
+      Sinatra::Application
+    end
 
     def test_my_default
       get '/'
-      assert_equal 'Hello World!', @response.body
+      assert_equal 'Hello World!', last_response.body
     end
 
     def test_with_params
-      get '/meet', {:name => 'Frank'}
-      assert_equal 'Hello Frank!', @response.body
+      get '/meet', :name => 'Frank'
+      assert_equal 'Hello Frank!', last_response.body
     end
 
     def test_with_rack_env
-      get '/', {}, :agent => 'Songbird'
-      assert_equal "You're using Songbird!", @response.body
+      get '/', {}, 'HTTP_USER_AGENT' => 'Songbird'
+      assert_equal "You're using Songbird!", last_response.body
     end
   end
 
-See http://www.sinatrarb.com/testing.html for more on Sinatra::Test and using it
-with other test frameworks such as RSpec, Bacon, and test/spec.
+NOTE: The built-in Sinatra::Test module and Sinatra::TestHarness class
+are deprecated as of the 0.9.2 release.
 
 == Command line
 
@@ -490,7 +494,7 @@ clone and run your app with the <tt>sinatra/lib</tt> directory on the
   git clone git://github.com/sinatra/sinatra.git
   ruby -Isinatra/lib myapp.rb
 
-Alternatively, you can add the <tt>sinatra/lib<tt> directory to the
+Alternatively, you can add the <tt>sinatra/lib</tt> directory to the
 <tt>LOAD_PATH</tt> in your application:
 
   $LOAD_PATH.unshift File.dirname(__FILE__) + '/sinatra/lib'

data/Rakefile

@@ -7,6 +7,8 @@ task :spec => :test
 
 # SPECS ===============================================================
 
+task(:test) { puts "==> Running main test suite" }
+
 Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/*_test.rb']
   t.ruby_opts = ['-rubygems'] if defined? Gem
@@ -16,18 +18,17 @@ desc "Run < 0.9.x compatibility specs"
 task :compat do
   begin
     require 'mocha'
-  rescue LoadError
-    puts 'WARN: skipping compat tests. mocha gem required.'
-    next
-  end
+    require 'test/spec'
+    at_exit { exit 0 } # disable test-spec at_exit runner
 
-  if ! system('specrb --help &>/dev/null')
-    puts 'WARN: skipping compat tests. test-spec gem required.'
-    next
+    puts "==> Running compat test suite"
+    Rake::TestTask.new(:compat) do |t|
+      t.test_files = FileList['compat/*_test.rb']
+      t.ruby_opts = ['-rubygems'] if defined? Gem
+    end
+  rescue LoadError
+    warn 'Skipping compat tests. mocha and/or test-spec gems not installed.'
   end
-
-  pattern = ENV['TEST'] || '.*'
-  sh "specrb --testcase '#{pattern}' -Ilib:test compat/*_test.rb"
 end
 
 # PACKAGING ============================================================

data/compat/helper.rb

@@ -1,10 +1,6 @@
 require 'rubygems'
 require 'mocha'
 
-require 'haml'
-require 'sass'
-require 'builder'
-
 # disable warnings in compat specs.
 $VERBOSE = nil
 
@@ -28,6 +24,9 @@ end
 
 class Test::Unit::TestCase
   include Sinatra::Test
+
+  PASSTHROUGH_EXCEPTIONS = [] unless const_defined?(:PASSTHROUGH_EXCEPTIONS)
+
   def setup
     @app = lambda { |env| Sinatra::Application.call(env) }
   end

data/lib/sinatra/base.rb

@@ -6,7 +6,7 @@ require 'rack/builder'
 require 'sinatra/showexceptions'
 
 module Sinatra
-  VERSION = '0.9.1.3'
+  VERSION = '0.9.2'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
@@ -223,19 +223,27 @@ module Sinatra
   #                 in the template
   module Templates
     def erb(template, options={}, locals={})
+      require_warn('ERB') unless defined?(::ERB)
+
       render :erb, template, options, locals
     end
 
     def haml(template, options={}, locals={})
+      require_warn('Haml') unless defined?(::Haml::Engine)
+
       render :haml, template, options, locals
     end
 
     def sass(template, options={}, locals={})
+      require_warn('Sass') unless defined?(::Sass::Engine)
+
       options[:layout] = false
       render :sass, template, options, locals
     end
 
     def builder(template=nil, options={}, locals={}, &block)
+      require_warn('Builder') unless defined?(::Builder)
+
       options, template = template, nil if template.is_a?(Hash)
       template = lambda { block } if template.nil?
       render :builder, template, options, locals
@@ -294,7 +302,7 @@ module Sinatra
     end
 
     def render_erb(template, data, options, locals, &block)
-      original_out_buf = @_out_buf
+      original_out_buf = defined?(@_out_buf) && @_out_buf
       data = data.call if data.kind_of? Proc
 
       instance = ::ERB.new(data, nil, nil, '@_out_buf')
@@ -331,6 +339,11 @@ module Sinatra
       end
       xml.target!
     end
+
+    def require_warn(engine)
+      warn "Auto-require of #{engine} is deprecated; add require '#{engine}' to your app."
+      require engine.downcase
+    end
   end
 
   # Base class for all Sinatra applications and middleware.
@@ -716,8 +729,9 @@ module Sinatra
           end
         }
       end
+      alias_method :agent, :user_agent
 
-      def accept_mime_types(types)
+      def provides(*types)
         types = [types] unless types.kind_of? Array
         types.map!{|t| media_type(t)}
 
@@ -749,10 +763,11 @@ module Sinatra
       def head(path, opts={}, &bk);   route 'HEAD',   path, opts, &bk end
 
     private
-      def route(verb, path, opts={}, &block)
-        host_name  opts[:host]  if opts.key?(:host)
-        user_agent opts[:agent] if opts.key?(:agent)
-        accept_mime_types opts[:provides] if opts.key?(:provides)
+      def route(verb, path, options={}, &block)
+        # Because of self.options.host
+        host_name(options.delete(:host)) if options.key?(:host)
+
+        options.each {|option, args| send(option, *args)}
 
         pattern, keys = compile(path)
         conditions, @conditions = @conditions, []
@@ -781,7 +796,7 @@ module Sinatra
         if path.respond_to? :to_str
           special_chars = %w{. + ( )}
           pattern =
-            path.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+            path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
               case match
               when "*"
                 keys << 'splat'
@@ -794,6 +809,8 @@ module Sinatra
               end
             end
           [/^#{pattern}$/, keys]
+        elsif path.respond_to?(:keys) && path.respond_to?(:match)
+          [path, path.keys]
         elsif path.respond_to? :match
           [path, keys]
         else
@@ -806,7 +823,7 @@ module Sinatra
       # in `extensions` available to the handlers and templates
       def helpers(*extensions, &block)
         class_eval(&block)  if block_given?
-        include *extensions if extensions.any?
+        include(*extensions) if extensions.any?
       end
 
       def extensions
@@ -940,6 +957,9 @@ module Sinatra
         /active_support/,      # active_support require hacks
       ] unless self.const_defined?('CALLERS_TO_IGNORE')
 
+      # add rubinius (and hopefully other VM impls) ignore patterns ...
+      CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
+
       # Like Kernel#caller but excluding certain magic entries and without
       # line / method information; the resulting array contains filenames only.
       def caller_files
@@ -1037,7 +1057,7 @@ module Sinatra
 
     def self.register(*extensions, &block) #:nodoc:
       added_methods = extensions.map {|m| m.public_instance_methods }.flatten
-      Delegator.delegate *added_methods
+      Delegator.delegate(*added_methods)
       super(*extensions, &block)
     end
   end

data/lib/sinatra/test.rb

@@ -1,5 +1,7 @@
 require 'sinatra/base'
 
+warn 'Sinatra::Test is deprecated; use Rack::Test instead.'
+
 module Sinatra
   module Test
     include Rack::Utils

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.1.3'
-  s.date = '2009-04-25'
+  s.version = '0.9.2'
+  s.date = '2009-05-18'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"
@@ -113,6 +113,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = %w[README.rdoc LICENSE]
   s.add_dependency 'rack',    '>= 0.9.1'
   s.add_development_dependency 'shotgun', '>= 0.2',   '< 1.0'
+  s.add_development_dependency 'rack-test', '>= 0.3.0'
 
   s.has_rdoc = true
   s.homepage = "http://sinatra.rubyforge.org"

data/test/base_test.rb

@@ -1,6 +1,10 @@
 require File.dirname(__FILE__) + '/helper'
 
 class BaseTest < Test::Unit::TestCase
+  def test_default
+    assert true
+  end
+
   describe 'Sinatra::Base subclasses' do
     class TestApp < Sinatra::Base
       get '/' do
@@ -23,6 +27,7 @@ class BaseTest < Test::Unit::TestCase
 
     class TestApp < Sinatra::Base
       get '/state' do
+        @foo ||= "new"
         body = "Foo: #{@foo}"
         @foo = 'discard'
         body
@@ -34,7 +39,7 @@ class BaseTest < Test::Unit::TestCase
       2.times do
         response = request.get('/state')
         assert response.ok?
-        assert_equal 'Foo: ', response.body
+        assert_equal 'Foo: new', response.body
       end
     end
 

data/test/builder_test.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/helper'
+require 'builder'
 
 class BuilderTest < Test::Unit::TestCase
   def builder_app(&block)

data/test/contest.rb

@@ -6,8 +6,10 @@ require "test/unit"
 # allow them. Having a failure when no tests have been defined seems
 # counter-intuitive.
 class Test::Unit::TestSuite
-  def empty?
-    false
+  unless method_defined?(:empty?)
+    def empty?
+      false
+    end
   end
 end
 

data/test/helper.rb

@@ -1,3 +1,5 @@
+ENV['RACK_ENV'] = 'test'
+
 begin
   require 'rack'
 rescue LoadError
@@ -12,11 +14,8 @@ libdir = File.dirname(File.dirname(__FILE__)) + '/lib'
 $LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
 
 require 'contest'
-require 'sinatra/test'
-
-require 'haml'
-require 'sass'
-require 'builder'
+require 'rack/test'
+require 'sinatra/base'
 
 class Sinatra::Base
   # Allow assertions in request context
@@ -26,24 +25,52 @@ end
 Sinatra::Base.set :environment, :test
 
 class Test::Unit::TestCase
-  include Sinatra::Test
+  include Rack::Test::Methods
 
   class << self
     alias_method :it, :test
   end
 
+  alias_method :response, :last_response
+
+  setup do
+    Sinatra::Base.set :environment, :test
+  end
+
   # Sets up a Sinatra::Base subclass defined with the block
   # given. Used in setup or individual spec methods to establish
   # the application.
   def mock_app(base=Sinatra::Base, &block)
     @app = Sinatra.new(base, &block)
   end
-end
 
-# Do not output warnings for the duration of the block.
-def silence_warnings
-  $VERBOSE, v = nil, $VERBOSE
-  yield
-ensure
-  $VERBOSE = v
+  def app
+    Rack::Lint.new(@app)
+  end
+
+  def body
+    response.body.to_s
+  end
+
+  # Delegate other missing methods to response.
+  def method_missing(name, *args, &block)
+    if response && response.respond_to?(name)
+      response.send(name, *args, &block)
+    else
+      super
+    end
+  end
+
+  # Also check response since we delegate there.
+  def respond_to?(symbol, include_private=false)
+    super || (response && response.respond_to?(symbol, include_private))
+  end
+
+  # Do not output warnings for the duration of the block.
+  def silence_warnings
+    $VERBOSE, v = nil, $VERBOSE
+    yield
+  ensure
+    $VERBOSE = v
+  end
 end

data/test/helpers_test.rb

@@ -1,6 +1,10 @@
 require File.dirname(__FILE__) + '/helper'
 
 class HelpersTest < Test::Unit::TestCase
+  def test_default
+    assert true
+  end
+
   describe 'status' do
     setup do
       mock_app {
@@ -178,7 +182,7 @@ class HelpersTest < Test::Unit::TestCase
         end
       }
 
-      get '/', :env => { 'rack.session' => { :foo => 'bar' } }
+      get '/', {}, { 'rack.session' => { :foo => 'bar' } }
       assert_equal 'bar', body
     end
 
@@ -373,7 +377,7 @@ class HelpersTest < Test::Unit::TestCase
     end
 
     it 'halts when a conditional GET matches' do
-      get '/', :env => { 'HTTP_IF_MODIFIED_SINCE' => @now.httpdate }
+      get '/', {}, { 'HTTP_IF_MODIFIED_SINCE' => @now.httpdate }
       assert_equal 304, status
       assert_equal '', body
     end
@@ -402,13 +406,13 @@ class HelpersTest < Test::Unit::TestCase
     end
 
     it 'halts when a conditional GET matches' do
-      get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
       assert_equal 304, status
       assert_equal '', body
     end
 
     it 'should handle multiple ETag values in If-None-Match header' do
-      get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
+      get '/', {}, { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
       assert_equal 304, status
       assert_equal '', body
     end

data/test/mapped_error_test.rb

@@ -7,6 +7,10 @@ class FooNotFound < Sinatra::NotFound
 end
 
 class MappedErrorTest < Test::Unit::TestCase
+  def test_default
+    assert true
+  end
+
   describe 'Exception Mappings' do
     it 'invokes handlers registered with ::error when raised' do
       mock_app {
@@ -51,18 +55,6 @@ class MappedErrorTest < Test::Unit::TestCase
       assert_equal 'looks good', body
     end
 
-    it 'dumps errors to rack.errors when dump_errors is enabled' do
-      mock_app {
-        set :raise_errors, false
-        set :dump_errors, true
-        get('/') { raise FooError, 'BOOM!' }
-      }
-
-      get '/'
-      assert_equal 500, status
-      assert @response.errors =~ /FooError - BOOM!:/
-    end
-
     it "raises without calling the handler when the raise_errors options is set" do
       mock_app {
         set :raise_errors, true

data/test/routing_test.rb

@@ -5,6 +5,22 @@ def route_def(pattern)
   mock_app { get(pattern) { } }
 end
 
+class RegexpLookAlike
+  class MatchData
+    def captures
+      ["this", "is", "a", "test"]
+    end
+  end
+
+  def match(string)
+    ::RegexpLookAlike::MatchData.new if string == "/this/is/a/test/"
+  end
+
+  def keys
+    ["one", "two", "three", "four"]
+  end
+end
+
 class RoutingTest < Test::Unit::TestCase
   %w[get put post delete].each do |verb|
     it "defines #{verb.upcase} request handlers with #{verb}" do
@@ -44,15 +60,19 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 404, status
   end
 
-  it "sets the content-type to text/html in the default 404 handler" do
+  it "overrides the content-type in error handlers" do
     mock_app {
       before { content_type 'text/plain' }
+      error Sinatra::NotFound do
+        content_type "text/html"
+        "<h1>Not Found</h1>"
+      end
     }
 
     get '/foo'
     assert_equal 404, status
     assert_equal 'text/html', response["Content-Type"]
-    assert body.include?("Sinatra doesn't know this ditty")
+    assert_equal "<h1>Not Found</h1>", response.body
   end
 
   it 'takes multiple definitions of a route' do
@@ -254,17 +274,7 @@ class RoutingTest < Test::Unit::TestCase
   end
 
   it "supports deeply nested params" do
-    input = {
-      'browser[chrome][engine][name]' => 'V8',
-      'browser[chrome][engine][version]' => '1.0',
-      'browser[firefox][engine][name]' => 'spidermonkey',
-      'browser[firefox][engine][version]' => '1.7.0',
-      'emacs[map][goto-line]' => 'M-g g',
-      'emacs[version]' => '22.3.1',
-      'paste[name]' => 'hello world',
-      'paste[syntax]' => 'ruby'
-    }
-    expected = {
+    expected_params = {
       "emacs" => {
         "map"     => { "goto-line" => "M-g g" },
         "version" => "22.3.1"
@@ -277,11 +287,11 @@ class RoutingTest < Test::Unit::TestCase
     }
     mock_app {
       get '/foo' do
-        assert_equal expected, params
+        assert_equal expected_params, params
         'looks good'
       end
     }
-    get "/foo?#{build_query(input)}"
+    get '/foo', expected_params
     assert ok?
     assert_equal 'looks good', body
   end
@@ -363,9 +373,26 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 'right on', body
   end
 
+  it 'supports regular expression look-alike routes' do
+    mock_app {
+      get(RegexpLookAlike.new) do
+        assert_equal 'this', params[:one]
+        assert_equal 'is', params[:two]
+        assert_equal 'a', params[:three]
+        assert_equal 'test', params[:four]
+        'right on'
+      end
+    }
+
+    get '/this/is/a/test/'
+    assert ok?
+    assert_equal 'right on', body
+  end
+
   it 'raises a TypeError when pattern is not a String or Regexp' do
-    @app = mock_app
-    assert_raise(TypeError) { @app.get(42){} }
+    assert_raise(TypeError) {
+      mock_app { get(42){} }
+    }
   end
 
   it "returns response immediately on halt" do
@@ -490,7 +517,7 @@ class RoutingTest < Test::Unit::TestCase
     get '/foo'
     assert not_found?
 
-    get '/foo', :env => { 'HTTP_HOST' => 'example.com' }
+    get '/foo', {}, { 'HTTP_HOST' => 'example.com' }
     assert_equal 200, status
     assert_equal 'Hello World', body
   end
@@ -505,7 +532,7 @@ class RoutingTest < Test::Unit::TestCase
     get '/foo'
     assert not_found?
 
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
     assert_equal 200, status
     assert_equal 'Hello World', body
   end
@@ -517,7 +544,7 @@ class RoutingTest < Test::Unit::TestCase
         'Hello ' + params[:agent].first
       end
     }
-    get '/foo', :env => { 'HTTP_USER_AGENT' => 'Foo Bar' }
+    get '/foo', {}, { 'HTTP_USER_AGENT' => 'Foo Bar' }
     assert_equal 200, status
     assert_equal 'Hello Bar', body
   end
@@ -529,12 +556,12 @@ class RoutingTest < Test::Unit::TestCase
       end
     }
 
-    get '/', :env => { :accept => 'application/xml' }
+    get '/', {}, { 'HTTP_ACCEPT' => 'application/xml' }
     assert ok?
     assert_equal 'application/xml', body
     assert_equal 'application/xml', response.headers['Content-Type']
 
-    get '/', :env => { :accept => 'text/html' }
+    get '/', {}, { :accept => 'text/html' }
     assert !ok?
   end
 
@@ -548,7 +575,7 @@ class RoutingTest < Test::Unit::TestCase
     }
 
     types.each do |type|
-      get '/', :env => { :accept => type }
+      get '/', {}, { 'HTTP_ACCEPT' => type }
       assert ok?
       assert_equal type, body
       assert_equal type, response.headers['Content-Type']
@@ -666,6 +693,40 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 'ab', body
   end
 
+  it 'allows custom route-conditions to be set via route options' do
+    protector = Module.new {
+      def protect(*args)
+        condition {
+          unless authorize(params["user"], params["password"])
+            halt 403, "go away"
+          end
+        }
+      end
+    }
+
+    mock_app {
+      register protector
+
+      helpers do
+        def authorize(username, password)
+          username == "foo" && password == "bar"
+        end
+      end
+
+      get "/", :protect => true do
+        "hey"
+      end
+    }
+
+    get "/"
+    assert forbidden?
+    assert_equal "go away", body
+
+    get "/", :user => "foo", :password => "bar"
+    assert ok?
+    assert_equal "hey", body
+  end
+
   # NOTE Block params behaves differently under 1.8 and 1.9. Under 1.8, block
   # param arity is lax: declaring a mismatched number of block params results
   # in a warning. Under 1.9, block param arity is strict: mismatched block

data/test/sass_test.rb

@@ -1,4 +1,5 @@
 require File.dirname(__FILE__) + '/helper'
+require 'sass'
 
 class SassTest < Test::Unit::TestCase
   def sass_app(&block)

data/test/test_test.rb

@@ -1,7 +1,15 @@
-require 'yaml'
 require File.dirname(__FILE__) + '/helper'
 
+require 'yaml'
+
+# silence deprecation warning when requiring sinatra/test
+$VERBOSE, v = nil, $VERBOSE
+require 'sinatra/test'
+$VERBOSE = v
+
 class TestTest < Test::Unit::TestCase
+  include Sinatra::Test
+
   def request
     YAML.load(body)
   end
@@ -45,8 +53,8 @@ class TestTest < Test::Unit::TestCase
     assert_equal('DELETE', request['REQUEST_METHOD'])
 
     head '/'
-    assert_equal('', response.body)
     assert response.headers['Content-Length'].to_i > 0
+    assert_equal('', body)
   end
 
   it 'allows to specify a body' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sinatra-sinatra
 version: !ruby/object:Gem::Version 
-  version: 0.9.1.3
+  version: 0.9.2
 platform: ruby
 authors: 
 - Blake Mizerany
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-25 00:00:00 -07:00
+date: 2009-05-18 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -35,6 +35,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "1.0"
     version: 
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+    version: 
 description: Classy web-development dressed in a DSL
 email: sinatrarb@googlegroups.com
 executables: []