sinatra 1.2.1 → 1.2.2

data/README.rdoc

@@ -1584,6 +1584,45 @@ application (Rails/Ramaze/Camping/...):
     get('/') { "Hello #{session['user_name']}." }
   end
 
+=== Dynamic Application Creation
+
+Sometimes you want to create new applications at runtime without having to
+assign them to a constant, you can do this with `Sinatra.new`:
+
+  require 'sinatra/base'
+  my_app = Sinatra.new { get('/') { "hi" } }
+  my_app.run!
+
+It takes the application to inherit from as optional argument:
+
+  require 'sinatra/base'
+
+  controller = Sinatra.new do
+    enable :logging
+    helpers MyHelpers
+  end
+
+  map('/a') do
+    run Sinatra.new(controller) { get('/') { 'a' } }
+  end
+
+  map('/b') do
+    run Sinatra.new(controller) { get('/') { 'b' } }
+  end
+
+This is especially useful for testing Sinatra extensions or using Sinatra in
+your own library.
+
+This also makes using Sinatra as middleware extremely easy:
+
+  require 'sinatra/base'
+
+  use Sinatra do
+    get('/') { ... }
+  end
+
+  run RailsProject::Application
+
 == Scopes and Binding
 
 The scope you are currently in determines what methods and variables are
@@ -1616,6 +1655,7 @@ You have the application scope binding inside:
 * Methods defined by extensions
 * The block passed to +helpers+
 * Procs/blocks used as value for +set+
+* The block passed to <tt>Sinatra.new</tt>
 
 You can reach the scope object (the class) like this:
 

data/Rakefile

@@ -15,6 +15,15 @@ def source_version
   end
 end
 
+def prev_feature
+  source_version.gsub(/^(\d\.)(\d+)\..*$/) { $1 + ($2.to_i - 1).to_s }
+end
+
+def prev_version
+  return prev_feature + '.0' if source_version.end_with? '.0'
+  source_version.gsub(/\d+$/) { |s| s.to_i - 1 }
+end
+
 # SPECS ===============================================================
 
 task :test do
@@ -69,13 +78,14 @@ end
 # Thanks in announcement ===============================================
 
 team = ["Ryan Tomayko", "Blake Mizerany", "Simon Rozet", "Konstantin Haase"]
-desc "list of contributors: rake thanks[1.1.0..master,1.1.0..1.1.x]"
+desc "list of contributors"
 task :thanks, [:release,:backports] do |t, a|
-  a.with_defaults :release => "1.1.0..master", :backports => "1.1.0..1.1.x"
+  a.with_defaults :release => "#{prev_version}..HEAD",
+    :backports => "#{prev_feature}.0..#{prev_feature}.x"
   included = `git log --format=format:"%aN\t%s" #{a.release}`.lines.to_a
   excluded = `git log --format=format:"%aN\t%s" #{a.backports}`.lines.to_a
-  commits = (included - excluded).group_by { |c| c[/^[^\t]+/] }
-  authors = commits.keys.sort_by { |n| - commits[n].size } - team
+  commits  = (included - excluded).group_by { |c| c[/^[^\t]+/] }
+  authors  = commits.keys.sort_by { |n| - commits[n].size } - team
   puts authors[0..-2].join(', ') << " and " << authors.last,
     "(based on commits included in #{a.release}, but not in #{a.backports})"
 end

data/lib/sinatra/base.rb

@@ -7,14 +7,30 @@ require 'sinatra/showexceptions'
 require 'tilt'
 
 module Sinatra
-  VERSION = '1.2.1'
+  VERSION = '1.2.2'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
   class Request < Rack::Request
+    def self.new(env)
+      env['sinatra.request'] ||= super
+    end
+
     # Returns an array of acceptable media types for the response
     def accept
-      @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.split(';')[0].strip }
+      @env['sinatra.accept'] ||= begin
+        entries = @env['HTTP_ACCEPT'].to_s.split(',')
+        entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first)
+      end
+    end
+
+    def preferred_type(*types)
+      return accept.first if types.empty?
+      types.flatten!
+      accept.detect do |pattern|
+        type = types.detect { |t| File.fnmatch(pattern, t) }
+        return type if type
+      end
     end
 
     if Rack.release <= "1.2"
@@ -34,16 +50,22 @@ module Sinatra
     end
 
     def route
-      @route ||= begin
-        path = Rack::Utils.unescape(path_info)
-        path.empty? ? "/" : path
-      end
+      @route ||= Rack::Utils.unescape(path_info)
     end
 
     def path_info=(value)
       @route = nil
       super
     end
+
+    private
+
+    def accept_entry(entry)
+      type, *options = entry.gsub(/\s/, '').split(';')
+      quality = 0 # we sort smalles first
+      options.delete_if { |e| quality = 1 - e[2..-1].to_f if e.start_with? 'q=' }
+      [type, [quality, type.count('*'), 1 - options.size]]
+    end
   end
 
   # The response object. See Rack::Response and Rack::ResponseHelpers for
@@ -99,14 +121,14 @@ module Sinatra
 
       # According to RFC 2616 section 14.30, "the field value consists of a
       # single absolute URI"
-      response['Location'] = url(uri, settings.absolute_redirects?, settings.prefixed_redirects?)
+      response['Location'] = uri(uri, settings.absolute_redirects?, settings.prefixed_redirects?)
       halt(*args)
     end
 
     # Generates the absolute URI for a given path in the app.
     # Takes Rack routers and reverse proxies into account.
     def uri(addr = nil, absolute = true, add_script_name = true)
-      return addr if addr =~ /^https?:\/\//
+      return addr if addr =~ /\A[A-z][A-z0-9\+\.\-]*:/
       uri = [host = ""]
       if absolute
         host << 'http'
@@ -156,7 +178,8 @@ module Sinatra
 
     # Set the Content-Type of the response body given a media type or file
     # extension.
-    def content_type(type, params={})
+    def content_type(type = nil, params={})
+      return response['Content-Type'] unless type
       default = params.delete :default
       mime_type = mime_type(type) || default
       fail "Unknown media type: %p" % type if mime_type.nil?
@@ -164,7 +187,11 @@ module Sinatra
       unless params.include? :charset or settings.add_charset.all? { |p| not p === mime_type }
         params[:charset] = params.delete('charset') || settings.default_encoding
       end
-      mime_type << ";#{params.map { |kv| kv.join('=') }.join(', ')}" unless params.empty?
+      params.delete :charset if mime_type.include? 'charset'
+      unless params.empty?
+        mime_type << (mime_type.include?(';') ? ', ' : ';')
+        mime_type << params.map { |kv| kv.join('=') }.join(', ')
+      end
       response['Content-Type'] = mime_type
     end
 
@@ -557,7 +584,7 @@ module Sinatra
 
         case
         when data.is_a?(Symbol)
-          body, path, line = self.class.templates[data]
+          body, path, line = settings.templates[data]
           if body
             body = body.call if body.respond_to?(:call)
             template.new(path, line.to_i, options) { body }
@@ -575,7 +602,7 @@ module Sinatra
           end
         when data.is_a?(Proc) || data.is_a?(String)
           body = data.is_a?(String) ? Proc.new { data } : data
-          path, line = self.class.caller_locations.first
+          path, line = settings.caller_locations.first
           template.new(path, line.to_i, options, &body)
         else
           raise ArgumentError
@@ -680,13 +707,13 @@ module Sinatra
 
   private
     # Run filters defined on the class and all superclasses.
-    def filter!(type, base = self.class)
+    def filter!(type, base = settings)
       filter! type, base.superclass if base.superclass.respond_to?(:filters)
       base.filters[type].each { |block| instance_eval(&block) }
     end
 
     # Run routes defined on the class and all superclasses.
-    def route!(base=self.class, pass_block=nil)
+    def route!(base = settings, pass_block=nil)
       if routes = base.routes[@request.request_method]
         routes.each do |pattern, keys, conditions, block|
           pass_block = process_route(pattern, keys, conditions) do
@@ -716,7 +743,9 @@ module Sinatra
     # Returns pass block.
     def process_route(pattern, keys, conditions)
       @original_params ||= @params
-      if match = pattern.match(@request.route)
+      route = @request.route
+      route = '/' if route.empty? and not settings.empty_path_info?
+      if match = pattern.match(route)
         values = match.captures.to_a
         params =
           if keys.any?
@@ -861,7 +890,7 @@ module Sinatra
     # Find an custom error block for the key(s) specified.
     def error_block!(*keys)
       keys.each do |key|
-        base = self.class
+        base = settings
         while base.respond_to?(:errors)
           if block = base.errors[key]
             # found a handler, eval and return result
@@ -1013,6 +1042,14 @@ module Sinatra
         Rack::Mime::MIME_TYPES[type] = value
       end
 
+      # provides all mime types matching type, including deprecated types:
+      #   mime_types :html # => ['text/html']
+      #   mime_types :js   # => ['application/javascript', 'text/javascript']
+      def mime_types(type)
+        type = mime_type type
+        type =~ /^application\/(xml|javascript)$/ ? [type, "text/#$1"] : [type]
+      end
+
       # Define a before filter; runs before all requests within the same
       # context as route handlers and may access/modify the request and
       # response.
@@ -1065,12 +1102,11 @@ module Sinatra
 
       # Condition for matching mimetypes. Accepts file extensions.
       def provides(*types)
-        types.map! { |t| mime_type(t) }
-
+        types.map! { |t| mime_types(t) }
+        types.flatten!
         condition do
-          matching_types = (request.accept & types)
-          unless matching_types.empty?
-            content_type matching_types.first
+          if type = request.preferred_type(types)
+            content_type(type)
             true
           else
             false
@@ -1099,6 +1135,7 @@ module Sinatra
       def route(verb, path, options={}, &block)
         # Because of self.options.host
         host_name(options.delete(:host)) if options.key?(:host)
+        enable :empty_path_info if path == "" and empty_path_info.nil?
 
         block, pattern, keys, conditions = compile! verb, path, block, options
         invoke_hook(:route_added, verb, path, block)
@@ -1232,10 +1269,10 @@ module Sinatra
       # an instance of this class as end point.
       def build(*args, &bk)
         builder = Rack::Builder.new
+        builder.use Rack::MethodOverride if method_override?
+        builder.use ShowExceptions       if show_exceptions?
+        builder.use Rack::CommonLogger   if logging?
         setup_sessions builder
-        builder.use Rack::CommonLogger    if logging?
-        builder.use Rack::MethodOverride  if method_override?
-        builder.use ShowExceptions        if show_exceptions?
         middleware.each { |c,a,b| builder.use(c, *a, &b) }
         builder.run new!(*args, &bk)
         builder
@@ -1363,6 +1400,7 @@ module Sinatra
 
     set :absolute_redirects, true
     set :prefixed_redirects, false
+    set :empty_path_info, nil
 
     set :app_file, nil
     set :root, Proc.new { app_file && File.expand_path(File.dirname(app_file)) }
@@ -1401,7 +1439,7 @@ module Sinatra
         </head>
         <body>
           <h2>Sinatra doesn't know this ditty.</h2>
-          <img src='/__sinatra__/404.png'>
+          <img src='#{uri "/__sinatra__/404.png"}'>
           <div id="c">
             Try this:
             <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  "Hello World"\nend</pre>

data/lib/sinatra/showexceptions.rb

@@ -174,7 +174,7 @@ TEMPLATE = <<-HTML # :nodoc:
 <body>
   <div id="wrap">
     <div id="header">
-      <img src="/__sinatra__/500.png" alt="application error" height="161" width="313" />
+      <img src="<%= env['SCRIPT_NAME'] %>/__sinatra__/500.png" alt="application error" height="161" width="313" />
       <div id="summary">
         <h1><strong><%=h exception.class %></strong> at <strong><%=h path %>
           </strong></h1>

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 = '1.2.1'
-  s.date = '2011-03-17'
+  s.version = '1.2.2'
+  s.date = '2011-04-08'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
     README.hu.rdoc
     README.jp.rdoc
     README.pt-br.rdoc
+    README.pt-pt.rdoc
     README.rdoc
     README.ru.rdoc
     README.zh.rdoc

data/test/encoding_test.rb

@@ -10,11 +10,11 @@ class BaseTest < Test::Unit::TestCase
 
   it 'allows unicode strings in ascii templates per default (1.9)' do
     next unless defined? Encoding
-    @base.new.erb(File.read(@base.views + "/ascii.erb").encode("ASCII"), {}, :value => "åkej")
+    @base.new!.erb(File.read(@base.views + "/ascii.erb").encode("ASCII"), {}, :value => "åkej")
   end
 
   it 'allows ascii strings in unicode templates per default (1.9)' do
     next unless defined? Encoding
-    @base.new.erb(:utf8, {}, :value => "Some Lyrics".encode("ASCII"))
+    @base.new!.erb(:utf8, {}, :value => "Some Lyrics".encode("ASCII"))
   end
 end

data/test/helpers_test.rb

@@ -123,6 +123,34 @@ class HelpersTest < Test::Unit::TestCase
       response = request.get('/', 'HTTP_X_FORWARDED_HOST' => 'example.com', 'SERVER_PORT' => '8080')
       assert_equal 'http://example.com/foo', response['Location']
     end
+
+    it 'accepts absolute URIs' do
+      mock_app do
+        get '/' do
+          redirect 'http://google.com'
+          fail 'redirect should halt'
+        end
+      end
+
+      get '/'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal 'http://google.com', response['Location']
+    end
+
+    it 'accepts absolute URIs with a different schema' do
+      mock_app do
+        get '/' do
+          redirect 'mailto:jsmith@example.com'
+          fail 'redirect should halt'
+        end
+      end
+
+      get '/'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal 'mailto:jsmith@example.com', response['Location']
+    end
   end
 
   describe 'error' do
@@ -401,6 +429,28 @@ class HelpersTest < Test::Unit::TestCase
       get '/'
       assert tests_ran
     end
+
+    it 'handles already present params' do
+      mock_app do
+        get '/' do
+          content_type 'foo/bar;level=1', :charset => 'utf-8'
+          'ok'
+        end
+      end
+      get '/'
+      assert_equal 'foo/bar;level=1, charset=utf-8', response['Content-Type']
+    end
+
+    it 'does not add charset if present' do
+      mock_app do
+        get '/' do
+          content_type 'text/plain;charset=utf-16'
+          'ok'
+        end
+      end
+      get '/'
+      assert_equal 'text/plain;charset=utf-16', response['Content-Type']
+    end
   end
 
   describe 'send_file' do
@@ -795,6 +845,18 @@ class HelpersTest < Test::Unit::TestCase
       assert_equal 'http://example.org/foo/bar', body
     end
 
+    it 'handles absolute URIs' do
+      mock_app { get('/') { uri 'http://google.com' }}
+      get '/'
+      assert_equal 'http://google.com', body
+    end
+
+    it 'handles different protocols' do
+      mock_app { get('/') { uri 'mailto:jsmith@example.com' }}
+      get '/'
+      assert_equal 'mailto:jsmith@example.com', body
+    end
+
     it 'is aliased to #url' do
       mock_app { get('/') { url }}
       get '/'

data/test/routing_test.rb

@@ -93,12 +93,28 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal "<h1>Not Found</h1>", response.body
   end
 
-  it 'matches empty PATH_INFO to "/"' do
-    mock_app {
+  it 'matches empty PATH_INFO to "/" if no route is defined for ""' do
+    mock_app do
       get '/' do
         'worked'
       end
-    }
+    end
+
+    get '/', {}, "PATH_INFO" => ""
+    assert ok?
+    assert_equal 'worked', body
+  end
+
+  it 'matches empty PATH_INFO to "" if a route is defined for ""' do
+    mock_app do
+      get '/' do
+        'did not work'
+      end
+
+      get '' do
+        'worked'
+      end
+    end
 
     get '/', {}, "PATH_INFO" => ""
     assert ok?
@@ -724,6 +740,77 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 'default', body
   end
 
+  it 'respects user agent prefferences for the content type' do
+    mock_app { get('/', :provides => [:png, :html]) { content_type }}
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/png;q=0.5,text/html;q=0.8' }
+    assert_body 'text/html;charset=utf-8'
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/png;q=0.8,text/html;q=0.5' }
+    assert_body 'image/png'
+  end
+
+  it 'accepts generic types' do
+    mock_app do
+      get('/', :provides => :xml) { content_type }
+      get('/') { 'no match' }
+    end
+    get '/'
+    assert_body 'no match'
+    get '/', {}, { 'HTTP_ACCEPT' => 'foo/*' }
+    assert_body 'no match'
+    get '/', {}, { 'HTTP_ACCEPT' => 'application/*' }
+    assert_body 'application/xml;charset=utf-8'
+    get '/', {}, { 'HTTP_ACCEPT' => '*/*' }
+    assert_body 'application/xml;charset=utf-8'
+  end
+
+  it 'prefers concrete over partly generic types' do
+    mock_app { get('/', :provides => [:png, :html]) { content_type }}
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/*, text/html' }
+    assert_body 'text/html;charset=utf-8'
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/png, text/*' }
+    assert_body 'image/png'
+  end
+
+  it 'prefers concrete over fully generic types' do
+    mock_app { get('/', :provides => [:png, :html]) { content_type }}
+    get '/', {}, { 'HTTP_ACCEPT' => '*/*, text/html' }
+    assert_body 'text/html;charset=utf-8'
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/png, */*' }
+    assert_body 'image/png'
+  end
+
+  it 'prefers partly generic over fully generic types' do
+    mock_app { get('/', :provides => [:png, :html]) { content_type }}
+    get '/', {}, { 'HTTP_ACCEPT' => '*/*, text/*' }
+    assert_body 'text/html;charset=utf-8'
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/*, */*' }
+    assert_body 'image/png'
+  end
+
+  it 'respects quality with generic types' do
+    mock_app { get('/', :provides => [:png, :html]) { content_type }}
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/*;q=1, text/html;q=0' }
+    assert_body 'image/png'
+    get '/', {}, { 'HTTP_ACCEPT' => 'image/png;q=0.5, text/*;q=0.7' }
+    assert_body 'text/html;charset=utf-8'
+  end
+
+  it 'accepts both text/javascript and application/javascript for js' do
+    mock_app { get('/', :provides => :js) { content_type }}
+    get '/', {}, { 'HTTP_ACCEPT' => 'application/javascript' }
+    assert_body 'application/javascript;charset=utf-8'
+    get '/', {}, { 'HTTP_ACCEPT' => 'text/javascript' }
+    assert_body 'text/javascript;charset=utf-8'
+  end
+
+  it 'accepts both text/xml and application/xml for xml' do
+    mock_app { get('/', :provides => :xml) { content_type }}
+    get '/', {}, { 'HTTP_ACCEPT' => 'application/xml' }
+    assert_body 'application/xml;charset=utf-8'
+    get '/', {}, { 'HTTP_ACCEPT' => 'text/xml' }
+    assert_body 'text/xml;charset=utf-8'
+  end
+
   it 'passes a single url param as block parameters when one param is specified' do
     mock_app {
       get '/:foo' do |foo|