sinatra 1.1.4 → 1.2.0

data/Rakefile

@@ -15,15 +15,6 @@ 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
@@ -78,33 +69,17 @@ end
 # Thanks in announcement ===============================================
 
 team = ["Ryan Tomayko", "Blake Mizerany", "Simon Rozet", "Konstantin Haase"]
-desc "list of contributors"
+desc "list of contributors: rake thanks[1.1.0..master,1.1.0..1.1.x]"
 task :thanks, [:release,:backports] do |t, a|
-  a.with_defaults :release => "#{prev_version}..HEAD",
-    :backports => "#{prev_feature}.0..#{prev_feature}.x"
+  a.with_defaults :release => "1.1.0..master", :backports => "1.1.0..1.1.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
 
-task :authors, [:format, :sep] do |t, a|
-  a.with_defaults :format => "%s (%d)", :sep => ', '
-  authors = Hash.new { |h,k| h[k] = 0 }
-  blake   = "Blake Mizerany"
-  mapping = {
-    "blake.mizerany@gmail.com" => blake, "bmizerany" => blake,
-    "a_user@mac.com" => blake, "ichverstehe" => "Harry Vangberg",
-    "Wu Jiang (nouse)" => "Wu Jiang" }
-  `git shortlog -s`.lines.map do |line|
-    num, name = line.split("\t", 2).map(&:strip)
-    authors[mapping[name] || name] += num.to_i
-  end
-  puts authors.sort_by { |n,c| -c }.map { |e| a.format % e }.join(a.sep)
-end
-
 # PACKAGING ============================================================
 
 if defined?(Gem)
@@ -165,12 +140,12 @@ if defined?(Gem)
     puts "updated #{f.name}"
   end
 
-  task 'release' => package('.gem') do
+  task 'release' => ['test', package('.gem')] do
     sh <<-SH
       gem install #{package('.gem')} --local &&
       gem push #{package('.gem')}  &&
-      git commit --allow-empty -a -m '#{source_version} release'  &&
-      git tag -s v#{source_version} -m '#{source_version} release'  &&
+      git add sinatra.gemspec &&
+      git commit --allow-empty -m '#{source_version} release'  &&
       git tag -s #{source_version} -m '#{source_version} release'  &&
       git push && (git push sinatra || true) &&
       git push --tags && (git push sinatra --tags || true)

data/lib/sinatra/base.rb

@@ -7,7 +7,7 @@ require 'sinatra/showexceptions'
 require 'tilt'
 
 module Sinatra
-  VERSION = '1.1.4'
+  VERSION = '1.2.0'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
@@ -29,6 +29,10 @@ module Sinatra
       alias secure? ssl?
     end
 
+    def forwarded?
+      @env.include? "HTTP_X_FORWARDED_HOST"
+    end
+
     def route
       @route ||= begin
         path = Rack::Utils.unescape(path_info)
@@ -91,24 +95,37 @@ module Sinatra
 
     # Halt processing and redirect to the URI provided.
     def redirect(uri, *args)
-      if not uri =~ /^https?:\/\//
-        # According to RFC 2616 section 14.30, "the field value consists of a
-        # single absolute URI"
-        abs_uri = "#{request.scheme}://#{request.host}"
-
-        if request.scheme == 'https' && request.port != 443 ||
-              request.scheme == 'http' && request.port != 80
-          abs_uri << ":#{request.port}"
-        end
-
-        uri = (abs_uri << uri)
-      end
-
       status 302
-      response['Location'] = uri
+
+      # 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?)
       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?:\/\//
+      uri = [host = ""]
+      if absolute
+        host << 'http'
+        host << 's' if request.secure?
+        host << "://"
+        if request.forwarded? or request.port != (request.secure? ? 443 : 80)
+          host << request.host_with_port
+        else
+          host << request.host
+        end
+      end
+      uri << request.script_name.to_s if add_script_name
+      uri << (addr ? addr : request.path_info).to_s
+      File.join uri
+    end
+
+    alias url uri
+    alias to uri
+
     # Halt processing and return the error status provided.
     def error(code, body=nil)
       code, body    = 500, code.to_str if code.respond_to? :to_str
@@ -164,7 +181,7 @@ module Sinatra
     # Use the contents of the file at +path+ as the response body.
     def send_file(path, opts={})
       stat = File.stat(path)
-      last_modified stat.mtime
+      last_modified(opts[:last_modified] || stat.mtime)
 
       if opts[:type] or not response['Content-Type']
         content_type opts[:type] || File.extname(path), :default => 'application/octet-stream'
@@ -301,12 +318,12 @@ module Sinatra
     def expires(amount, *values)
       values << {} unless values.last.kind_of?(Hash)
 
-      if amount.respond_to?(:to_time)
-        max_age = amount.to_time - Time.now
-        time = amount.to_time
-      else
+      if Integer === amount
+        time    = Time.now + amount
         max_age = amount
-        time = Time.now + amount
+      else
+        time    = time_for amount
+        max_age = time - Time.now
       end
 
       values.last.merge!(:max_age => max_age)
@@ -324,14 +341,7 @@ module Sinatra
     # with a '304 Not Modified' response.
     def last_modified(time)
       return unless time
-      if time.respond_to?(:to_time)
-          time = time.to_time
-      else
-          ## make a best effort to convert something else to a time object
-          ## if this fails, this should throw an ArgumentError, then the
-          # rescue will result in an http 200, which should be safe
-          time = Time.parse(time.to_s)
-      end
+      time = time_for time
       response['Last-Modified'] = time.httpdate
       # compare based on seconds since epoch
       halt 304 if Time.httpdate(request.env['HTTP_IF_MODIFIED_SINCE']).to_i >= time.to_i
@@ -360,9 +370,39 @@ module Sinatra
       end
     end
 
-    ## Sugar for redirect (example:  redirect back)
-    def back ; request.referer ; end
+    # Sugar for redirect (example:  redirect back)
+    def back
+      request.referer
+    end
+
+    private
 
+    # Ruby 1.8 has no #to_time method.
+    # This can be removed and calls to it replaced with to_time,
+    # if 1.8 support is dropped.
+    def time_for(value)
+      if value.respond_to? :to_time
+        value.to_time
+      elsif Time === value
+        value
+      elsif value.respond_to? :new_offset
+        # DateTime#to_time does the same on 1.9
+        d = value.new_offset 0
+        t = Time.utc d.year, d.mon, d.mday, d.hour, d.min, d.sec + d.sec_fraction
+        t.getlocal
+      elsif value.respond_to? :mday
+        # Date#to_time does the same on 1.9
+        Time.local(value.year, value.mon, value.mday)
+      elsif Numeric === value
+        Time.at value
+      else
+        Time.parse value.to_s
+      end
+    rescue ArgumentError => boom
+      raise boom.to_s
+    rescue Exception
+      raise ArgumentError, "unable to convert #{value.inspect} to a Time object"
+    end
   end
 
   # Template rendering methods. Each method takes the name of a template
@@ -374,17 +414,20 @@ module Sinatra
   # that will be rendered.
   #
   # Possible options are:
-  #   :layout       If set to false, no layout is rendered, otherwise
-  #                 the specified layout is used (Ignored for `sass` and `less`)
-  #   :locals       A hash with local variables that should be available
-  #                 in the template
+  #   :content_type   The content type to use, same arguments as content_type.
+  #   :layout         If set to false, no layout is rendered, otherwise
+  #                   the specified layout is used (Ignored for `sass` and `less`)
+  #   :layout_engine  Engine to use for rendering the layout.
+  #   :locals         A hash with local variables that should be available
+  #                   in the template
+  #   :scope          If set, template is evaluate with the binding of the given
+  #                   object rather than the application instance.
+  #   :views          Views directory to use.
   module Templates
     module ContentTyped
       attr_accessor :content_type
     end
 
-    include Tilt::CompileSite
-
     def erb(template, options={}, locals={})
       render :erb, template, options, locals
     end
@@ -413,7 +456,8 @@ module Sinatra
     end
 
     def builder(template=nil, options={}, locals={}, &block)
-      render_xml(:builder, template, options, locals, &block)
+      options[:default_content_type] = :xml
+      render_ruby(:builder, template, options, locals, &block)
     end
 
     def liquid(template, options={}, locals={})
@@ -436,8 +480,8 @@ module Sinatra
       render :radius, template, options, locals
     end
 
-    def markaby(template, options={}, locals={})
-      render :mab, template, options, locals
+    def markaby(template=nil, options={}, locals={}, &block)
+      render_ruby(:mab, template, options, locals, &block)
     end
 
     def coffee(template, options={}, locals={})
@@ -446,14 +490,26 @@ module Sinatra
     end
 
     def nokogiri(template=nil, options={}, locals={}, &block)
-      options[:layout] = false if Tilt::VERSION <= "1.1"
-      render_xml(:nokogiri, template, options, locals, &block)
+      options[:default_content_type] = :xml
+      render_ruby(:nokogiri, template, options, locals, &block)
+    end
+
+    def slim(template, options={}, locals={})
+      render :slim, template, options, locals
+    end
+
+    # Calls the given block for every possible template file in views,
+    # named name.ext, where ext is registered on engine.
+    def find_template(views, name, engine)
+      Tilt.mappings.each do |ext, klass|
+        next unless klass == engine
+        yield ::File.join(views, "#{name}.#{ext}")
+      end
     end
 
   private
     # logic shared between builder and nokogiri
-    def render_xml(engine, template, options={}, locals={}, &block)
-      options[:default_content_type] = :xml
+    def render_ruby(engine, template, options={}, locals={}, &block)
       options, template = template, nil if template.is_a?(Hash)
       template = Proc.new { block } if template.nil?
       render engine, template, options, locals
@@ -472,19 +528,21 @@ module Sinatra
       layout          = options.delete(:layout)
       eat_errors      = layout.nil?
       layout          = @default_layout if layout.nil? or layout == true
-      content_type    = options.delete(:content_type) || options.delete(:default_content_type)
+      content_type    = options.delete(:content_type)  || options.delete(:default_content_type)
+      layout_engine   = options.delete(:layout_engine) || engine
+      scope           = options.delete(:scope)         || self
 
       # compile and render template
       layout_was      = @default_layout
       @default_layout = false
       template        = compile_template(engine, data, options, views)
-      output          = template.render(self, locals, &block)
+      output          = template.render(scope, locals, &block)
       @default_layout = layout_was
 
       # render layout
       if layout
-        options = options.merge(:views => views, :layout => false, :eat_errors => eat_errors)
-        catch(:layout_missing) { output = render(engine, layout, options, locals) { output }}
+        options = options.merge(:views => views, :layout => false, :eat_errors => eat_errors, :scope => scope)
+        catch(:layout_missing) { output = render(layout_engine, layout, options, locals) { output }}
       end
 
       output.extend(ContentTyped).content_type = content_type if content_type
@@ -505,10 +563,12 @@ module Sinatra
             template.new(path, line.to_i, options) { body }
           else
             found = false
-            Tilt.mappings.each do |ext, klass|
-              next unless Array(klass).include? template
-              path = ::File.join(views, "#{data}.#{ext}")
-              break if found = File.exists?(path)
+            find_template(views, data, template) do |file|
+              path ||= file # keep the initial path rather than the last one
+              if found = File.exists?(file)
+                path = file
+                break
+              end
             end
             throw :layout_missing if eat_errors and not found
             template.new(path, 1, options)
@@ -956,21 +1016,22 @@ module Sinatra
       # Define a before filter; runs before all requests within the same
       # context as route handlers and may access/modify the request and
       # response.
-      def before(path = nil, &block)
-        add_filter(:before, path, &block)
+      def before(path = nil, options = {}, &block)
+        add_filter(:before, path, options, &block)
       end
 
       # Define an after filter; runs after all requests within the same
       # context as route handlers and may access/modify the request and
       # response.
-      def after(path = nil, &block)
-        add_filter(:after, path, &block)
+      def after(path = nil, options = {}, &block)
+        add_filter(:after, path, options, &block)
       end
 
       # add a filter
-      def add_filter(type, path = nil, &block)
+      def add_filter(type, path = nil, options = {}, &block)
         return filters[type] << block unless path
-        block, *arguments = compile!(type, path, block)
+        path, options = //, path if path.respond_to?(:each_pair)
+        block, *arguments = compile!(type, path, block, options)
         add_filter(type) do
           process_route(*arguments) { instance_eval(&block) }
         end
@@ -1028,18 +1089,18 @@ module Sinatra
         route('HEAD', path, opts, &block)
       end
 
-      def put(path, opts={}, &bk);    route 'PUT',    path, opts, &bk end
-      def post(path, opts={}, &bk);   route 'POST',   path, opts, &bk end
-      def delete(path, opts={}, &bk); route 'DELETE', path, opts, &bk end
-      def head(path, opts={}, &bk);   route 'HEAD',   path, opts, &bk end
+      def put(path, opts={}, &bk)     route 'PUT',     path, opts, &bk end
+      def post(path, opts={}, &bk)    route 'POST',    path, opts, &bk end
+      def delete(path, opts={}, &bk)  route 'DELETE',  path, opts, &bk end
+      def head(path, opts={}, &bk)    route 'HEAD',    path, opts, &bk end
+      def options(path, opts={}, &bk) route 'OPTIONS', path, opts, &bk end
 
     private
       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) }
 
-        block, pattern, keys, conditions = compile! verb, path, block
+        block, pattern, keys, conditions = compile! verb, path, block, options
         invoke_hook(:route_added, verb, path, block)
 
         (@routes[verb] ||= []).
@@ -1050,7 +1111,8 @@ module Sinatra
         extensions.each { |e| e.send(name, *args) if e.respond_to?(name) }
       end
 
-      def compile!(verb, path, block)
+      def compile!(verb, path, block, options = {})
+        options.each_pair { |option, args| send(option, *args) }
         method_name = "#{verb} #{path}"
 
         define_method(method_name, &block)
@@ -1085,6 +1147,8 @@ module Sinatra
           [/^#{pattern}$/, keys]
         elsif path.respond_to?(:keys) && path.respond_to?(:match)
           [path, path.keys]
+        elsif path.respond_to?(:names) && path.respond_to?(:match)
+          [path, path.names]
         elsif path.respond_to? :match
           [path, keys]
         else
@@ -1281,6 +1345,9 @@ module Sinatra
     set :bind, '0.0.0.0'
     set :port, 4567
 
+    set :absolute_redirects, true
+    set :prefixed_redirects, false
+
     set :app_file, nil
     set :root, Proc.new { app_file && File.expand_path(File.dirname(app_file)) }
     set :views, Proc.new { root && File.join(root, 'views') }
@@ -1364,7 +1431,7 @@ module Sinatra
       end
     end
 
-    delegate :get, :put, :post, :delete, :head, :template, :layout,
+    delegate :get, :put, :post, :delete, :head, :options, :template, :layout,
              :before, :after, :error, :not_found, :configure, :set, :mime_type,
              :enable, :disable, :use, :development?, :test?, :production?,
              :helpers, :settings

data/lib/sinatra/showexceptions.rb

@@ -8,11 +8,36 @@ module Sinatra
   # Be careful when you use this on public-facing sites as it could reveal
   # information helpful to attackers.
   class ShowExceptions < Rack::ShowExceptions
+    @@eats_errors = Object.new
+    def @@eats_errors.flush(*) end
+    def @@eats_errors.puts(*) end
+
     def initialize(app)
       @app      = app
       @template = ERB.new(TEMPLATE)
     end
 
+    def call(env)
+      @app.call(env)
+    rescue Exception => e
+      errors, env["rack.errors"] = env["rack.errors"], @@eats_errors
+
+      if respond_to?(:prefers_plain_text?) and prefers_plain_text?(env)
+        content_type = "text/plain"
+        body = [dump_exception(e)]
+      else
+        content_type = "text/html"
+        body = pretty(env, e)
+      end
+
+      env["rack.errors"] = errors
+
+      [500,
+       {"Content-Type" => content_type,
+        "Content-Length" => Rack::Utils.bytesize(body.join).to_s},
+       body]
+    end
+
     private
 
     def frame_class(frame)

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.1.4'
-  s.date = '2011-04-13'
+  s.version = '1.2.0'
+  s.date = '2011-03-03'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"
@@ -16,6 +16,7 @@ Gem::Specification.new do |s|
   s.files = %w[
     AUTHORS
     CHANGES
+    Gemfile
     LICENSE
     README.de.rdoc
     README.es.rdoc
@@ -67,10 +68,13 @@ Gem::Specification.new do |s|
     test/server_test.rb
     test/settings_test.rb
     test/sinatra_test.rb
+    test/slim_test.rb
     test/static_test.rb
     test/templates_test.rb
     test/textile_test.rb
-    test/views/ascii.haml
+    test/views/a/in_a.str
+    test/views/ascii.erb
+    test/views/b/in_b.str
     test/views/calc.html.erb
     test/views/error.builder
     test/views/error.erb
@@ -93,6 +97,7 @@ Gem::Specification.new do |s|
     test/views/hello.rdoc
     test/views/hello.sass
     test/views/hello.scss
+    test/views/hello.slim
     test/views/hello.str
     test/views/hello.test
     test/views/hello.textile
@@ -104,10 +109,11 @@ Gem::Specification.new do |s|
     test/views/layout2.mab
     test/views/layout2.nokogiri
     test/views/layout2.radius
+    test/views/layout2.slim
     test/views/layout2.str
     test/views/layout2.test
     test/views/nested.str
-    test/views/utf8.haml
+    test/views/utf8.erb
   ]
   # = MANIFEST =
 
@@ -116,21 +122,7 @@ Gem::Specification.new do |s|
   s.extra_rdoc_files = %w[README.rdoc README.de.rdoc README.jp.rdoc README.fr.rdoc README.es.rdoc README.hu.rdoc README.zh.rdoc LICENSE]
   s.add_dependency 'rack', '~> 1.1'
   s.add_dependency 'tilt', '>= 1.2.2', '< 2.0'
-  s.add_development_dependency 'rake'
   s.add_development_dependency 'shotgun', '~> 0.6'
-  s.add_development_dependency 'rack-test', '>= 0.5.6'
-  s.add_development_dependency 'haml', '>= 3.0'
-  s.add_development_dependency 'builder'
-  s.add_development_dependency 'erubis'
-  s.add_development_dependency 'less'
-  s.add_development_dependency 'liquid'
-  s.add_development_dependency 'rdiscount'
-  s.add_development_dependency 'RedCloth'
-  s.add_development_dependency 'radius'
-  s.add_development_dependency 'markaby'
-  s.add_development_dependency 'coffee-script', '>= 2.0'
-  s.add_development_dependency 'rdoc'
-  s.add_development_dependency 'nokogiri'
 
   s.has_rdoc = true
   s.homepage = "http://sinatra.rubyforge.org"

data/test/builder_test.rb

@@ -1,4 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
+
+begin
 require 'builder'
 
 class BuilderTest < Test::Unit::TestCase
@@ -87,3 +89,7 @@ class BuilderTest < Test::Unit::TestCase
     assert_raise(Errno::ENOENT) { get('/') }
   end
 end
+
+rescue LoadError
+  warn "#{$!.to_s}: skipping builder tests"
+end

data/test/coffee_test.rb

@@ -83,6 +83,6 @@ class CoffeeTest < Test::Unit::TestCase
   end
 end
 
-rescue
+rescue LoadError
   warn "#{$!.to_s}: skipping coffee tests"
 end

data/test/encoding_test.rb

@@ -1,5 +1,6 @@
 # encoding: UTF-8
 require File.dirname(__FILE__) + '/helper'
+require 'erb'
 
 class BaseTest < Test::Unit::TestCase
   setup do
@@ -9,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.haml(File.read(@base.views + "/ascii.haml").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.haml(:utf8, {}, :value => "Some Lyrics".encode("ASCII"))
+    @base.new.erb(:utf8, {}, :value => "Some Lyrics".encode("ASCII"))
   end
-end
+end

data/test/erubis_test.rb

@@ -1,4 +1,6 @@
 require File.dirname(__FILE__) + '/helper'
+
+begin
 require 'erubis'
 
 class ERubisTest < Test::Unit::TestCase
@@ -80,3 +82,7 @@ class ERubisTest < Test::Unit::TestCase
     assert_equal '<outer><inner>hi</inner></outer>', body
   end
 end
+
+rescue LoadError
+  warn "#{$!.to_s}: skipping erubis tests"
+end