sinatra 0.9.0.5 → 0.9.1

data/lib/sinatra/compat.rb

@@ -9,7 +9,7 @@ require 'sinatra/base'
 require 'sinatra/main'
 
 # Like Kernel#warn but outputs the location that triggered the warning.
-def sinatra_warn(*message)
+def sinatra_warn(*message) #:nodoc:
   line = caller.
     detect { |line| line !~ /(?:lib\/sinatra\/|__DELEGATE__)/ }.
     sub(/:in .*/, '')
@@ -34,25 +34,27 @@ end
 # technically a Sinatra issue but many Sinatra apps access the old
 # MIME_TYPES constants due to Sinatra example code.
 require 'rack/file'
-class Rack::File
-  def self.const_missing(const_name)
-    if const_name == :MIME_TYPES
-      hash = Hash.new { |hash,key| Rack::Mime::MIME_TYPES[".#{key}"] }
-      const_set :MIME_TYPES, hash
-      sinatra_warn 'Rack::File::MIME_TYPES is deprecated; use Rack::Mime instead.'
-      hash
-    else
-      super
+module Rack #:nodoc:
+  class File #:nodoc:
+    def self.const_missing(const_name)
+      if const_name == :MIME_TYPES
+        hash = Hash.new { |hash,key| Rack::Mime::MIME_TYPES[".#{key}"] }
+        const_set :MIME_TYPES, hash
+        sinatra_warn 'Rack::File::MIME_TYPES is deprecated; use Rack::Mime instead.'
+        hash
+      else
+        super
+      end
     end
   end
 end
 
 module Sinatra
-  module Compat
+  module Compat #:nodoc:
   end
 
   # Make Sinatra::EventContext an alias for Sinatra::Default to unbreak plugins.
-  def self.const_missing(const_name)
+  def self.const_missing(const_name) #:nodoc:
     if const_name == :EventContext
       const_set :EventContext, Sinatra::Default
       sinatra_warn 'Sinatra::EventContext is deprecated; use Sinatra::Default instead.'
@@ -73,7 +75,7 @@ module Sinatra
   end
 
   class Default < Base
-    def self.const_missing(const_name)
+    def self.const_missing(const_name) #:nodoc:
       if const_name == :FORWARD_METHODS
         sinatra_warn 'Sinatra::Application::FORWARD_METHODS is deprecated;',
           'use Sinatra::Delegator::METHODS instead.'
@@ -85,12 +87,10 @@ module Sinatra
     end
 
     # Deprecated. Use: response['Header-Name']
-    def headers(header=nil)
-      sinatra_warn "The 'headers' method is deprecated; use 'response' instead."
-      response.headers.merge!(header) if header
-      response.headers
+    def header(header=nil)
+      sinatra_warn "The 'header' method is deprecated; use 'headers' instead."
+      headers(header)
     end
-    alias :header :headers
 
     # Deprecated. Use: halt
     def stop(*args, &block)
@@ -104,21 +104,21 @@ module Sinatra
       etag(*args, &block)
     end
 
-    # The :disposition option is deprecated; use: #attachment. This method
-    # setting the Content-Transfer-Encoding header is deprecated.
-    #--
-    # TODO deprecation warning for :disposition argument.
-    def send_file(path, opts={})
-      opts[:disposition] = 'attachment' if !opts.key?(:disposition)
-      attachment opts[:filename] || path if opts[:filename] || opts[:disposition]
-      response['Content-Transfer-Encoding'] = 'binary' if opts[:disposition]
-      super(path, opts)
+    # Deprecated. Use the #attachment helper and return the data as a String or
+    # Array.
+    def send_data(data, options={})
+      sinatra_warn "The 'send_data' method is deprecated. use attachment, status, content_type, etc. helpers instead."
+
+      status       options[:status]   if options[:status]
+      attachment   options[:filename] if options[:disposition] == 'attachment'
+      content_type options[:type]     if options[:type]
+      halt data
     end
 
     # Throwing halt with a Symbol and the to_result convention are
     # deprecated. Override the invoke method to detect those types of return
     # values.
-    def invoke(&block)
+    def invoke(&block) #:nodoc:
       res = super
       case
       when res.kind_of?(Symbol)
@@ -132,7 +132,7 @@ module Sinatra
       res
     end
 
-    def options
+    def options #:nodoc:
       Options.new(self.class)
     end
 
@@ -195,7 +195,7 @@ module Sinatra
     end
 
     # Deprecated. Missing messages are no longer delegated to @response.
-    def method_missing(name, *args, &b)
+    def method_missing(name, *args, &b) #:nodoc:
       if @response.respond_to?(name)
         sinatra_warn "The '#{name}' method is deprecated; use 'response.#{name}' instead."
         @response.send(name, *args, &b)

data/lib/sinatra/main.rb

@@ -2,6 +2,10 @@ require 'sinatra/base'
 
 module Sinatra
   class Default < Base
+
+    # we assume that the first file that requires 'sinatra' is the
+    # app_file. all other path related options are calculated based
+    # on this path by default.
     set :app_file, lambda {
       ignore = [
         /lib\/sinatra.*\.rb$/, # all sinatra code
@@ -17,7 +21,6 @@ module Sinatra
     }.call
 
     set :run, Proc.new { $0 == app_file }
-    set :reload, Proc.new{ app_file? && development? }
 
     if run? && ARGV.any?
       require 'optparse'
@@ -33,10 +36,6 @@ end
 
 include Sinatra::Delegator
 
-def helpers(&block)
-  Sinatra::Application.send :class_eval, &block
-end
-
 def mime(ext, type)
   ext = ".#{ext}" unless ext.to_s[0] == ?.
   Rack::Mime::MIME_TYPES[ext.to_s] = type

data/lib/sinatra/test/bacon.rb

@@ -1,6 +1,8 @@
 require 'bacon'
 require 'sinatra/test'
 
+Sinatra::Test.deprecate('Bacon')
+
 Sinatra::Default.set(
   :environment => :test,
   :run => false,

data/lib/sinatra/test/rspec.rb

@@ -3,6 +3,8 @@ require 'sinatra/test/unit'
 require 'spec'
 require 'spec/interop/test'
 
+Sinatra::Test.deprecate('RSpec')
+
 Sinatra::Default.set(
   :environment => :test,
   :run => false,

data/lib/sinatra/test/spec.rb

@@ -2,6 +2,8 @@ require 'test/spec'
 require 'sinatra/test'
 require 'sinatra/test/unit'
 
+Sinatra::Test.deprecate('test/spec')
+
 module Sinatra::Test
   def should
     @response.should

data/lib/sinatra/test/unit.rb

@@ -1,6 +1,8 @@
 require 'sinatra/test'
 require 'test/unit'
 
+Sinatra::Test.deprecate('test/unit')
+
 Test::Unit::TestCase.send :include, Sinatra::Test
 
 Sinatra::Default.set(

data/lib/sinatra/test.rb

@@ -1,51 +1,54 @@
 require 'sinatra/base'
 
 module Sinatra
-
   module Test
     include Rack::Utils
 
+    def self.included(base)
+      Sinatra::Default.set(:environment, :test)
+    end
+
     attr_reader :app, :request, :response
 
-    def test_request(verb, path, *args)
+    def self.deprecate(framework)
+      warn <<-EOF
+Warning: support for the #{framework} testing framework is deprecated and
+will be dropped in Sinatra 1.0. See <http://sinatra.github.com/testing.html>
+for more information.
+      EOF
+    end
+
+    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)
-      opts, input =
-        case args.size
-        when 2 # input, env
-          input, env = args
-          if input.kind_of?(Hash) # params, env
-            [env, param_string(input)]
-          else
-            [env, input]
-          end
-        when 1 # params
-          if (data = args.first).kind_of?(Hash)
-            env = (data.delete(:env) || {})
-            [env, param_string(data)]
-          else
-            [{}, data]
-          end
-        when 0
-          [{}, '']
-        else
-          raise ArgumentError, "zero, one, or two arguments expected"
-        end
-      opts = rack_opts(opts)
-      opts[:input] ||= input
+      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
+
       yield @request if block_given?
-      @response = @request.request(verb, path, opts)
+      @response = @request.request(verb, path, rack_options(options))
     end
 
-    def get(path, *args, &b)  ; test_request('GET', path, *args, &b) ; end
-    def head(path, *args, &b) ; test_request('HEAD', path, *args, &b) ; end
-    def post(path, *args, &b) ; test_request('POST', path, *args, &b) ; end
-    def put(path, *args, &b)  ; test_request('PUT', path, *args, &b) ; end
-    def delete(path, *args, &b) ; test_request('DELETE', path, *args, &b) ; end
+    def get(path, *args, &b)  ; make_request('GET', path, *args, &b) ; end
+    def head(path, *args, &b) ; make_request('HEAD', path, *args, &b) ; end
+    def post(path, *args, &b) ; make_request('POST', path, *args, &b) ; end
+    def put(path, *args, &b)  ; make_request('PUT', path, *args, &b) ; end
+    def delete(path, *args, &b) ; make_request('DELETE', path, *args, &b) ; end
 
     def follow!
-      test_request 'GET', @response.location
+      make_request 'GET', @response.location
     end
 
     def body ; @response.body ; end
@@ -65,30 +68,38 @@ module Sinatra
       super || (@response && @response.respond_to?(symbol, include_private))
     end
 
-    RACK_OPT_NAMES = {
-      :accept => "HTTP_ACCEPT",
-      :agent => "HTTP_USER_AGENT",
-      :host => "HTTP_HOST",
-      :session => "HTTP_COOKIE",
-      :cookies => "HTTP_COOKIE",
-      :content_type => "CONTENT_TYPE"
+  private
+
+    RACK_OPTIONS = {
+      :accept       => 'HTTP_ACCEPT',
+      :agent        => 'HTTP_USER_AGENT',
+      :host         => 'HTTP_HOST',
+      :session      => 'rack.session',
+      :cookies      => 'HTTP_COOKIE',
+      :content_type => 'CONTENT_TYPE'
     }
 
-    def rack_opts(opts)
-      opts.inject({}) do |hash,(key,val)|
-        key = RACK_OPT_NAMES[key] || key
+    def rack_options(opts)
+      opts.merge(:lint => true).inject({}) do |hash,(key,val)|
+        key = RACK_OPTIONS[key] || key
         hash[key] = val
         hash
       end
     end
 
-    def env_for(opts={})
-      opts = rack_opts(opts)
-      Rack::MockRequest.env_for(opts)
-    end
-
-    def param_string(hash)
-      hash.map { |pair| pair.map{|v|escape(v)}.join('=') }.join('&')
+    def param_string(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v|
+          param_string(v, "#{prefix}[]")
+        } * "&"
+      when Hash
+        value.map { |k, v|
+          param_string(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
+        } * "&"
+      else
+        "#{prefix}=#{escape(value)}"
+      end
     end
 
     if defined? Sinatra::Compat
@@ -97,7 +108,7 @@ module Sinatra
         eval <<-RUBY, binding, __FILE__, __LINE__
         def #{verb}_it(*args, &block)
           sinatra_warn "The #{verb}_it method is deprecated; use #{verb} instead."
-          test_request('#{verb.upcase}', *args, &block)
+          make_request('#{verb.upcase}', *args, &block)
         end
         RUBY
       end
@@ -109,6 +120,7 @@ module Sinatra
 
     def initialize(app=nil)
       @app = app || Sinatra::Application
+      @app.set(:environment, :test)
     end
   end
 end

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-03-09'
+  s.version = '0.9.1'
+  s.date = '2009-03-02'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"
@@ -70,6 +70,7 @@ Gem::Specification.new do |s|
     test/builder_test.rb
     test/data/reload_app_file.rb
     test/erb_test.rb
+    test/extensions_test.rb
     test/filter_test.rb
     test/haml_test.rb
     test/helper.rb
@@ -79,12 +80,15 @@ Gem::Specification.new do |s|
     test/options_test.rb
     test/reload_test.rb
     test/request_test.rb
+    test/response_test.rb
     test/result_test.rb
     test/routing_test.rb
     test/sass_test.rb
+    test/server_test.rb
     test/sinatra_test.rb
     test/static_test.rb
     test/templates_test.rb
+    test/test_test.rb
     test/views/hello.builder
     test/views/hello.erb
     test/views/hello.haml
@@ -100,7 +104,7 @@ Gem::Specification.new do |s|
   s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/}
 
   s.extra_rdoc_files = %w[README.rdoc LICENSE]
-  s.add_dependency 'rack', '>= 0.9.1'
+  s.add_dependency 'rack', '>= 0.9.1', '< 1.0'
 
   s.has_rdoc = true
   s.homepage = "http://sinatra.rubyforge.org"

data/test/base_test.rb

@@ -1,68 +1,130 @@
 require File.dirname(__FILE__) + '/helper'
 
-describe 'Sinatra::Base' do
-  it 'includes Rack::Utils' do
-    assert Sinatra::Base.included_modules.include?(Rack::Utils)
+describe 'Sinatra::Base subclasses' do
+
+  class TestApp < Sinatra::Base
+    get '/' do
+      'Hello World'
+    end
+  end
+
+  it 'include Rack::Utils' do
+    assert TestApp.included_modules.include?(Rack::Utils)
   end
 
-  it 'can be used as a Rack application' do
-    mock_app {
-      get '/' do
-        'Hello World'
-      end
-    }
-    assert @app.respond_to?(:call)
+  it 'processes requests with #call' do
+    assert TestApp.respond_to?(:call)
 
-    request = Rack::MockRequest.new(@app)
+    request = Rack::MockRequest.new(TestApp)
     response = request.get('/')
     assert response.ok?
     assert_equal 'Hello World', response.body
   end
 
-  it 'can be used as Rack middleware' do
-    app = lambda { |env| [200, {}, ['Goodbye World']] }
-    mock_middleware =
-      mock_app {
-        get '/' do
-          'Hello World'
-        end
-        get '/goodbye' do
-          @app.call(request.env)
-        end
-      }
-    middleware = mock_middleware.new(app)
+  class TestApp < Sinatra::Base
+    get '/state' do
+      body = "Foo: #{@foo}"
+      @foo = 'discard'
+      body
+    end
+  end
+
+  it 'does not maintain state between requests' do
+    request = Rack::MockRequest.new(TestApp)
+    2.times do
+      response = request.get('/state')
+      assert response.ok?
+      assert_equal 'Foo: ', response.body
+    end
+  end
+end
+
+describe "Sinatra::Base as Rack middleware" do
+
+  app = lambda { |env|
+    [210, {'X-Downstream' => 'true'}, ['Hello from downstream']] }
+
+  class TestMiddleware < Sinatra::Base
+  end
+
+  it 'creates a middleware that responds to #call with .new' do
+    middleware = TestMiddleware.new(app)
+    assert middleware.respond_to?(:call)
+  end
+
+  it 'exposes the downstream app' do
+    middleware = TestMiddleware.new(app)
     assert_same app, middleware.app
+  end
 
-    request = Rack::MockRequest.new(middleware)
+  class TestMiddleware < Sinatra::Base
+    get '/' do
+      'Hello from middleware'
+    end
+  end
+
+  middleware = TestMiddleware.new(app)
+  request = Rack::MockRequest.new(middleware)
+
+  it 'intercepts requests' do
     response = request.get('/')
     assert response.ok?
-    assert_equal 'Hello World', response.body
+    assert_equal 'Hello from middleware', response.body
+  end
 
-    response = request.get('/goodbye')
-    assert response.ok?
-    assert_equal 'Goodbye World', response.body
+  it 'automatically forwards requests downstream when no matching route found' do
+    response = request.get('/missing')
+    assert_equal 210, response.status
+    assert_equal 'Hello from downstream', response.body
   end
 
-  it 'can take multiple definitions of a route' do
-    app = mock_app {
-      user_agent(/Foo/)
-      get '/foo' do
-        'foo'
-      end
+  class TestMiddleware < Sinatra::Base
+    get '/low-level-forward' do
+      app.call(env)
+    end
+  end
 
-      get '/foo' do
-        'not foo'
-      end
-    }
+  it 'can call the downstream app directly and return result' do
+    response = request.get('/low-level-forward')
+    assert_equal 210, response.status
+    assert_equal 'true', response['X-Downstream']
+    assert_equal 'Hello from downstream', response.body
+  end
 
-    request = Rack::MockRequest.new(app)
-    response = request.get('/foo', 'HTTP_USER_AGENT' => 'Foo')
-    assert response.ok?
-    assert_equal 'foo', response.body
+  class TestMiddleware < Sinatra::Base
+    get '/explicit-forward' do
+      response['X-Middleware'] = 'true'
+      res = forward
+      assert_nil res
+      assert_equal 210, response.status
+      assert_equal 'true', response['X-Downstream']
+      assert_equal ['Hello from downstream'], response.body
+      'Hello after explicit forward'
+    end
+  end
 
-    request = Rack::MockRequest.new(app)
-    response = request.get('/foo')
-    assert response.ok?
-    assert_equal 'not foo', response.body
+  it 'forwards the request downstream and integrates the response into the current context' do
+    response = request.get('/explicit-forward')
+    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/erb_test.rb

@@ -47,4 +47,35 @@ describe "ERB Templates" do
     assert ok?
     assert_equal "ERB Layout!\nHello World\n", body
   end
+
+  it "renders erb with blocks" do
+    mock_app {
+      def container
+        @_out_buf << "THIS."
+        yield
+        @_out_buf << "SPARTA!"
+      end
+      def is; "IS." end
+      get '/' do
+        erb '<% container do %> <%= is %> <% end %>'
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal 'THIS. IS. SPARTA!', body
+  end
+
+  it "can be used in a nested fashion for partials and whatnot" do
+    mock_app {
+      template(:inner) { "<inner><%= 'hi' %></inner>" }
+      template(:outer) { "<outer><%= erb :inner %></outer>" }
+      get '/' do
+        erb :outer
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal '<outer><inner>hi</inner></outer>', body
+  end
 end