sinatra 1.4.0.d → 1.4.0

data/lib/sinatra/base.rb

@@ -17,7 +17,7 @@ module Sinatra
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
   class Request < Rack::Request
     HEADER_PARAM = /\s*[\w.]+=(?:[\w.]+|"(?:[^"\\]|\\.)*")?\s*/
-    HEADER_VALUE_WITH_PARAMS = /(?:(?:\w+|\*)\/(?:\w+|\*))\s*(?:;#{HEADER_PARAM})*/
+    HEADER_VALUE_WITH_PARAMS = /(?:(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*)\s*(?:;#{HEADER_PARAM})*/
 
     # Returns an array of acceptable media types for the response
     def accept
@@ -71,9 +71,10 @@ module Sinatra
           [key, value]
         end
 
-        @type = entry[/[^;]+/].delete(' ')
+        @entry  = entry
+        @type   = entry[/[^;]+/].delete(' ')
         @params = Hash[params]
-        @q = @params.delete('q') { "1.0" }.to_f
+        @q      = @params.delete('q') { "1.0" }.to_f
       end
 
       def <=>(other)
@@ -85,13 +86,21 @@ module Sinatra
         [ @q, -@type.count('*'), @params.size ]
       end
 
-      def [](param)
-        @params[param]
-      end
-
       def to_str
         @type
       end
+
+      def to_s(full = false)
+        full ? entry : to_str
+      end
+
+      def respond_to?(*args)
+        super or to_str.respond_to?(*args)
+      end
+
+      def method_missing(*args, &block)
+        to_str.send(*args, &block)
+      end
     end
   end
 
@@ -1044,7 +1053,11 @@ module Sinatra
   rescue ::Exception => boom
     invoke { handle_exception!(boom) }
   ensure
-    filter! :after unless env['sinatra.static_file']
+    begin
+      filter! :after unless env['sinatra.static_file']
+    rescue ::Exception => boom
+      invoke { handle_exception!(boom) } unless @env['sinatra.error']
+    end
   end
 
   # Error handling during requests.
@@ -1211,7 +1224,7 @@ module Sinatra
         template name, &block
       end
 
-      # Load embeded templates from the file; uses the caller's __FILE__
+      # Load embedded templates from the file; uses the caller's __FILE__
       # when no file is specified.
       def inline_templates=(file = nil)
         file = (file.nil? || file == true) ? (caller_files.first || File.expand_path($0)) : file
@@ -1246,7 +1259,8 @@ module Sinatra
 
       # Lookup or register a mime type in Rack's mime registry.
       def mime_type(type, value = nil)
-        return type if type.nil? || type.to_s.include?('/')
+        return type      if type.nil?
+        return type.to_s if type.to_s.include?('/')
         type = ".#{type}" unless type.to_s[0] == ?.
         return Rack::Mime.mime_type(type, nil) unless value
         Rack::Mime::MIME_TYPES[type] = value
@@ -1745,7 +1759,7 @@ module Sinatra
 
     set :run, false                       # start server via at-exit hook?
     set :running, false                   # is the built-in server running now?
-    set :server, %w[http webrick]
+    set :server, %w[HTTP webrick]
     set :bind, Proc.new { development? ? 'localhost' : '0.0.0.0' }
     set :port, Integer(ENV['PORT'] || 4567)
 

data/lib/sinatra/version.rb

@@ -1,3 +1,3 @@
 module Sinatra
-  VERSION = '1.4.0.d'
+  VERSION = '1.4.0'
 end

data/test/base_test.rb

@@ -67,7 +67,7 @@ class BaseTest < Test::Unit::TestCase
       assert_equal Sinatra::Base.settings, Sinatra::Base.new.settings
     end
 
-    it 'expses helpers' do
+    it 'exposes helpers' do
       assert_equal 'image/jpeg', Sinatra::Base.new.helpers.mime_type(:jpg)
     end
   end

data/test/contest.rb

@@ -82,7 +82,9 @@ private
   end
 
   def self.test_name(name)
-    "test_#{sanitize_name(name).gsub(/\s+/,'_')}".to_sym
+    name = "test_#{sanitize_name(name).gsub(/\s+/,'_')}_0"
+    name = name.succ while method_defined? name
+    name.to_sym
   end
 
   def self.sanitize_name(name)

data/test/erb_test.rb

@@ -86,7 +86,7 @@ class ERBTest < Test::Unit::TestCase
     assert_equal '<outer><inner>hi</inner></outer>', body
   end
 
-  it "can rendere truly nested layouts by accepting a layout and a block with the contents" do
+  it "can render truly nested layouts by accepting a layout and a block with the contents" do
     mock_app do
       template(:main_outer_layout) { "<h1>Title</h1>\n<%= yield %>" }
       template(:an_inner_layout) { "<h2>Subtitle</h2>\n<%= yield %>" }

data/test/filter_test.rb

@@ -153,6 +153,27 @@ class BeforeFilterTest < Test::Unit::TestCase
     get '/foo/bar'
     assert_equal subpath, 'bar'
   end
+
+  it 'can catch exceptions in before filters and handle them properly' do
+    doodle = ''
+    mock_app do
+      before do
+        doodle += 'This begins'
+        raise StandardError, "before"
+      end
+      get "/" do
+        doodle = 'and runs'
+      end
+      error 500 do
+        "Error handled #{env['sinatra.error'].message}"
+      end
+    end
+
+    doodle = ''
+    get '/'
+    assert_equal 'Error handled before', body
+    assert_equal 'This begins', doodle
+  end
 end
 
 class AfterFilterTest < Test::Unit::TestCase
@@ -267,7 +288,7 @@ class AfterFilterTest < Test::Unit::TestCase
     assert ran_filter
   end
 
-  it 'changes to path_info from a pattern matching before filter are respoected when routing' do
+  it 'changes to path_info from a pattern matching before filter are respected when routing' do
     mock_app do
       before('/foo') { request.path_info = '/bar' }
       get('/bar') { 'blah' }
@@ -434,4 +455,33 @@ class AfterFilterTest < Test::Unit::TestCase
     get('/', {}, { 'HTTP_ACCEPT' => '*/*' })
     assert_body 'txt'
   end
+
+  it 'can catch exceptions in after filters and handle them properly' do
+    doodle = ''
+    mock_app do
+      after do
+        doodle += ' and after'
+        raise StandardError, "after"
+      end
+      get "/foo" do
+        doodle = 'Been now'
+        raise StandardError, "now"
+      end
+      get "/" do
+        doodle = 'Been now'
+      end
+      error 500 do
+        "Error handled #{env['sinatra.error'].message}"
+      end
+    end
+
+    get '/foo'
+    assert_equal 'Error handled now', body
+    assert_equal 'Been now and after', doodle
+
+    doodle = ''
+    get '/'
+    assert_equal 'Error handled after', body
+    assert_equal 'Been now and after', doodle
+  end
 end

data/test/haml_test.rb

@@ -85,7 +85,7 @@ class HAMLTest < Test::Unit::TestCase
     assert_equal "bar\n", body
   end
 
-  it "can rendere truly nested layouts by accepting a layout and a block with the contents" do
+  it "can render truly nested layouts by accepting a layout and a block with the contents" do
     mock_app do
       template(:main_outer_layout) { "%h1 Title\n= yield" }
       template(:an_inner_layout) { "%h2 Subtitle\n= yield" }

data/test/helpers_test.rb

@@ -118,7 +118,7 @@ class HelpersTest < Test::Unit::TestCase
   end
 
   describe 'body' do
-    it 'takes a block for defered body generation' do
+    it 'takes a block for deferred body generation' do
       mock_app do
         get('/') { body { 'Hello World' } }
       end
@@ -574,6 +574,12 @@ class HelpersTest < Test::Unit::TestCase
     it 'returns the argument when given a media type string' do
       assert_equal 'text/plain', mime_type('text/plain')
     end
+
+    it 'turns AcceptEntry into String' do
+      type = mime_type(Sinatra::Request::AcceptEntry.new('text/plain'))
+      assert_equal String, type.class
+      assert_equal 'text/plain', type
+    end
   end
 
   test 'Base.mime_type registers mime type' do
@@ -792,7 +798,7 @@ class HelpersTest < Test::Unit::TestCase
       assert_equal 'text/plain;charset=utf-8', response['Content-Type']
     end
 
-    it 'sets the Content-Type response header if type option is set to a file extesion' do
+    it 'sets the Content-Type response header if type option is set to a file extension' do
       send_file_app :type => 'html'
       get '/file.txt'
       assert_equal 'text/html;charset=utf-8', response['Content-Type']
@@ -816,7 +822,7 @@ class HelpersTest < Test::Unit::TestCase
       assert_equal File.mtime(@file).httpdate, response['Last-Modified']
     end
 
-    it 'allows passing in a differen Last-Modified response header with :last_modified' do
+    it 'allows passing in a different Last-Modified response header with :last_modified' do
       time = Time.now
       send_file_app :last_modified => time
       get '/file.txt'
@@ -867,7 +873,7 @@ class HelpersTest < Test::Unit::TestCase
       assert_status 201
     end
 
-    it "is able to send files with unkown mime type" do
+    it "is able to send files with unknown mime type" do
       @file = File.dirname(__FILE__) + '/file.foobar'
       File.open(@file, 'wb') { |io| io.write('Hello World') }
       send_file_app

data/test/integration_helper.rb

@@ -60,7 +60,7 @@ module IntegrationHelper
     def alive?
       3.times { get('/ping') }
       true
-    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, SystemCallError, OpenURI::HTTPError, Timeout::Error => error
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, SystemCallError, OpenURI::HTTPError, Timeout::Error
       false
     end
 
@@ -86,7 +86,8 @@ module IntegrationHelper
 
     def installed?
       return @installed unless @installed.nil?
-      require server
+      s = server == 'HTTP' ? 'net/http/server' : server
+      require s
       @installed = true
     rescue LoadError
       warn "#{server} is not installed, skipping integration tests"
@@ -102,7 +103,7 @@ module IntegrationHelper
           file, dir = RbConfig::CONFIG.values_at('ruby_install_name', 'bindir')
           cmd << File.expand_path(file, dir).inspect
         end
-        cmd << "-w" unless thin?
+        cmd << "-w" unless thin? || net_http_server?
         cmd << "-I" << File.expand_path('../../lib', __FILE__).inspect
         cmd << app_file.inspect << '-s' << server << '-o' << '127.0.0.1' << '-p' << port
         cmd << "-e" << environment.to_s << '2>&1'
@@ -134,6 +135,10 @@ module IntegrationHelper
       name.to_s == "trinidad"
     end
 
+    def net_http_server?
+      name.to_s == 'HTTP'
+    end
+
     def warnings
       log.scan(%r[(?:\(eval|lib/sinatra).*warning:.*$])
     end
@@ -171,7 +176,7 @@ module IntegrationHelper
 
         Thread.new do
           # Hack to ensure that Kernel#caller has the same info as
-          # when run from command-line, for Sintra::Application.app_file.
+          # when run from command-line, for Sinatra::Application.app_file.
           # Also, line numbers are zero-based in JRuby's parser
           vm.provider.runtime.current_context.set_file_and_line(app_file, 0)
           # Run the app

data/test/integration_test.rb

@@ -17,7 +17,13 @@ class IntegrationTest < Test::Unit::TestCase
     random = "%064x" % Kernel.rand(2**256-1)
     server.get "/ping?x=#{random}"
     count = server.log.scan("GET /ping?x=#{random}").count
-    server.webrick? ? assert(count > 0) : assert_equal(1, count)
+    if server.net_http_server?
+      assert_equal 0, count
+    elsif server.webrick?
+      assert(count > 0)
+    else
+      assert_equal(1, count)
+    end
   end
 
   it 'streams' do
@@ -76,7 +82,8 @@ class IntegrationTest < Test::Unit::TestCase
       with\sbackup\sfrom\s#{server}
     }ix
 
-    assert_match exp, server.log
+    # because Net HTTP Server logs to $stderr by default
+    assert_match exp, server.log unless server.net_http_server?
   end
 
   it 'does not generate warnings' do

data/test/request_test.rb

@@ -38,7 +38,7 @@ class RequestTest < Test::Unit::TestCase
       'CONTENT_TYPE' => 'application/x-www-form-urlencoded',
       'rack.input' => StringIO.new('foo=bar')
     )
-    params = Sinatra::Base.new!.send(:indifferent_hash).replace(request.params)
+    Sinatra::Base.new!.send(:indifferent_hash).replace(request.params)
     dumped = Marshal.dump(request.params)
     assert_equal 'bar', Marshal.load(dumped)['foo']
   end
@@ -50,6 +50,18 @@ class RequestTest < Test::Unit::TestCase
     assert_equal({ 'compress' => '0.25' }, request.preferred_type.params)
   end
 
+  it "makes accept types behave like strings" do
+    request = Sinatra::Request.new('HTTP_ACCEPT' => 'image/jpeg; compress=0.25')
+    assert_equal 'image/jpeg', request.preferred_type.to_s
+    assert_equal 'image/jpeg', request.preferred_type.to_str
+    assert_equal 'image',      request.preferred_type.split('/').first
+
+    String.instance_methods.each do |method|
+      next unless "".respond_to? method
+      assert request.preferred_type.respond_to?(method), "responds to #{method}"
+    end
+  end
+
   it "properly decodes MIME type parameters" do
     request = Sinatra::Request.new(
       'HTTP_ACCEPT' => 'image/jpeg;unquoted=0.25;quoted="0.25";chartest="\";,\x"'

data/test/response_test.rb

@@ -6,8 +6,7 @@ class ResponseTest < Test::Unit::TestCase
   setup { @response = Sinatra::Response.new }
 
   def assert_same_body(a, b)
-    enum = Enumerable.const_get(:Enumerator)
-    assert_equal enum.new(a).to_a, enum.new(b).to_a
+    assert_equal a.to_enum(:each).to_a, b.to_enum(:each).to_a
   end
 
   it "initializes with 200, text/html, and empty body" do

data/test/routing_test.rb

@@ -768,6 +768,119 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 'Hello Bar', body
   end
 
+  it 'matches mime_types with dots, hyphens and plus signs' do
+    mime_types = %w(
+      application/atom+xml
+      application/ecmascript
+      application/EDI-X12
+      application/EDIFACT
+      application/json
+      application/javascript
+      application/octet-stream
+      application/ogg
+      application/pdf
+      application/postscript
+      application/rdf+xml
+      application/rss+xml
+      application/soap+xml
+      application/font-woff
+      application/xhtml+xml
+      application/xml
+      application/xml-dtd
+      application/xop+xml
+      application/zip
+      application/gzip
+      audio/basic
+      audio/L24
+      audio/mp4
+      audio/mpeg
+      audio/ogg
+      audio/vorbis
+      audio/vnd.rn-realaudio
+      audio/vnd.wave
+      audio/webm
+      image/gif
+      image/jpeg
+      image/pjpeg
+      image/png
+      image/svg+xml
+      image/tiff
+      image/vnd.microsoft.icon
+      message/http
+      message/imdn+xml
+      message/partial
+      message/rfc822
+      model/example
+      model/iges
+      model/mesh
+      model/vrml
+      model/x3d+binary
+      model/x3d+vrml
+      model/x3d+xml
+      multipart/mixed
+      multipart/alternative
+      multipart/related
+      multipart/form-data
+      multipart/signed
+      multipart/encrypted
+      text/cmd
+      text/css
+      text/csv
+      text/html
+      text/javascript
+      application/javascript
+      text/plain
+      text/vcard
+      text/xml
+      video/mpeg
+      video/mp4
+      video/ogg
+      video/quicktime
+      video/webm
+      video/x-matroska
+      video/x-ms-wmv
+      video/x-flv
+      application/vnd.oasis.opendocument.text
+      application/vnd.oasis.opendocument.spreadsheet
+      application/vnd.oasis.opendocument.presentation
+      application/vnd.oasis.opendocument.graphics
+      application/vnd.ms-excel
+      application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+      application/vnd.ms-powerpoint
+      application/vnd.openxmlformats-officedocument.presentationml.presentation
+      application/vnd.openxmlformats-officedocument.wordprocessingml.document
+      application/vnd.mozilla.xul+xml
+      application/vnd.google-earth.kml+xml
+      application/x-deb
+      application/x-dvi
+      application/x-font-ttf
+      application/x-javascript
+      application/x-latex
+      application/x-mpegURL
+      application/x-rar-compressed
+      application/x-shockwave-flash
+      application/x-stuffit
+      application/x-tar
+      application/x-www-form-urlencoded
+      application/x-xpinstall
+      audio/x-aac
+      audio/x-caf
+      image/x-xcf
+      text/x-gwt-rpc
+      text/x-jquery-tmpl
+      application/x-pkcs12
+      application/x-pkcs12
+      application/x-pkcs7-certificates
+      application/x-pkcs7-certificates
+      application/x-pkcs7-certreqresp
+      application/x-pkcs7-mime
+      application/x-pkcs7-mime
+      application/x-pkcs7-signature
+    )
+    
+    mime_types.each { |mime_type| assert mime_type.match(Sinatra::Request::HEADER_VALUE_WITH_PARAMS) }
+  end
+
   it "filters by accept header" do
     mock_app {
       get '/', :provides => :xml do
@@ -776,6 +889,9 @@ class RoutingTest < Test::Unit::TestCase
       get '/foo', :provides => :html do
         env['HTTP_ACCEPT']
       end
+      get '/stream', :provides => 'text/event-stream' do
+        env['HTTP_ACCEPT']
+      end
     }
 
     get '/', {}, { 'HTTP_ACCEPT' => 'application/xml' }
@@ -792,6 +908,13 @@ class RoutingTest < Test::Unit::TestCase
 
     get '/foo', {}, { 'HTTP_ACCEPT' => '' }
     assert !ok?
+
+    get '/stream', {}, { 'HTTP_ACCEPT' => 'text/event-stream' }
+    assert ok?
+    assert_equal 'text/event-stream', body
+
+    get '/stream', {}, { 'HTTP_ACCEPT' => '' }
+    assert !ok?
   end
 
   it "filters by current Content-Type" do