sinatra-sinatra 0.9.1.2 → 0.9.1.3

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Blake Mizerany
+Copyright (c) 2007, 2008, 2009 Blake Mizerany
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.rdoc

@@ -109,18 +109,41 @@ directory. To use a different views directory:
 
   set :views, File.dirname(__FILE__) + '/templates'
 
+One important thing to remember is that you always have to reference
+templates with symbols, even if they're in a subdirectory (in this
+case use <tt>:'subdir/template'</tt>). Rendering methods will render
+any strings passed to them directly.
+
 === Haml Templates
 
 The haml gem/library is required to render HAML templates:
 
+  ## You'll need to require haml in your app
+  require 'haml'
+
   get '/' do
     haml :index
   end
 
 Renders <tt>./views/index.haml</tt>.
 
+{Haml's options}[http://haml.hamptoncatlin.com/docs/rdoc/classes/Haml.html]
+can be set globally through Sinatra's configurations,
+see {Options and Configurations}[http://www.sinatrarb.com/configuration.html],
+and overridden on an individual basis.
+
+  set :haml, {:format => :html5 } # default Haml format is :xhtml
+
+  get '/' do
+    haml :index, :haml_options => {:format => :html4 } # overridden
+  end
+
+
 === Erb Templates
 
+  ## You'll need to require erb in your app
+  require 'erb'
+
   get '/' do
     erb :index
   end
@@ -131,6 +154,9 @@ Renders <tt>./views/index.erb</tt>
 
 The builder gem/library is required to render builder templates:
 
+  ## You'll need to require builder in your app
+  require 'builder'
+
   get '/' do
     content_type 'application/xml', :charset => 'utf-8'
     builder :index
@@ -142,6 +168,9 @@ Renders <tt>./views/index.builder</tt>.
 
 The sass gem/library is required to render Sass templates:
 
+  ## You'll need to require haml or sass in your app
+  require 'sass'
+
   get '/stylesheet.css' do
     content_type 'text/css', :charset => 'utf-8'
     sass :stylesheet
@@ -149,6 +178,19 @@ The sass gem/library is required to render Sass templates:
 
 Renders <tt>./views/stylesheet.sass</tt>.
 
+{Sass' options}[http://haml.hamptoncatlin.com/docs/rdoc/classes/Sass.html]
+can be set globally through Sinatra's configurations,
+see {Options and Configurations}[http://www.sinatrarb.com/configuration.html],
+and overridden on an individual basis.
+
+  set :sass, {:style => :compact } # default Sass style is :nested
+
+  get '/stylesheet.css' do
+    content_type 'text/css', :charset => 'utf-8'
+    sass :stylesheet, :sass_options => {:style => :expanded } # overridden
+  end
+
+
 === Inline Templates
 
   get '/' do

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'fileutils'
 
-task :default => [:test]
+task :default => [:test, :compat]
 task :spec => :test
 
 # SPECS ===============================================================
@@ -12,8 +12,20 @@ Rake::TestTask.new(:test) do |t|
   t.ruby_opts = ['-rubygems'] if defined? Gem
 end
 
-desc 'Run compatibility specs (requires test/spec)'
-task :compat do |t|
+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
+
+  if ! system('specrb --help &>/dev/null')
+    puts 'WARN: skipping compat tests. test-spec gem required.'
+    next
+  end
+
   pattern = ENV['TEST'] || '.*'
   sh "specrb --testcase '#{pattern}' -Ilib:test compat/*_test.rb"
 end

data/compat/haml_test.rb

@@ -183,13 +183,14 @@ context "Haml" do
       Sinatra.application = nil
     end
 
-    specify 'are empty be default' do
+    specify 'default to filename and line of caller' do
 
       get '/' do
         haml 'foo'
       end
 
-      Haml::Engine.expects(:new).with('foo', {}).returns(stub(:render => 'foo'))
+      Haml::Engine.expects(:new).with('foo', {:filename => __FILE__,
+        :line => (__LINE__-4)}).returns(stub(:render => 'foo'))
 
       get_it '/'
       should.be.ok
@@ -202,7 +203,8 @@ context "Haml" do
         haml 'foo', :options => {:format => :html4}
       end
 
-      Haml::Engine.expects(:new).with('foo', {:format => :html4}).returns(stub(:render => 'foo'))
+      Haml::Engine.expects(:new).with('foo', {:filename => __FILE__,
+        :line => (__LINE__-4), :format => :html4}).returns(stub(:render => 'foo'))
 
       get_it '/'
       should.be.ok
@@ -220,7 +222,8 @@ context "Haml" do
         haml 'foo'
       end
 
-      Haml::Engine.expects(:new).with('foo', {:format => :html4,
+      Haml::Engine.expects(:new).with('foo', {:filename => __FILE__,
+        :line => (__LINE__-4), :format => :html4,
         :escape_html => true}).returns(stub(:render => 'foo'))
 
       get_it '/'

data/compat/helper.rb

@@ -1,6 +1,10 @@
 require 'rubygems'
 require 'mocha'
 
+require 'haml'
+require 'sass'
+require 'builder'
+
 # disable warnings in compat specs.
 $VERBOSE = nil
 

data/compat/sass_test.rb

@@ -52,6 +52,16 @@ context "Sass" do
       body.should.equal "#sass {\n  background_color: #FFF; }\n"
     end
 
+    it "passes :sass option to the Sass engine" do
+      get '/' do
+        sass "#sass\n  :background-color #FFF\n  :color #000\n", :sass => {:style => :compact}
+      end
+
+      get_it '/'
+      should.be.ok
+      body.should.equal "#sass { background-color: #FFF; color: #000; }\n"
+    end
+
   end
 
 end

data/lib/sinatra/base.rb

@@ -3,9 +3,10 @@ require 'time'
 require 'uri'
 require 'rack'
 require 'rack/builder'
+require 'sinatra/showexceptions'
 
 module Sinatra
-  VERSION = '0.9.1.1'
+  VERSION = '0.9.1.3'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
@@ -32,16 +33,6 @@ module Sinatra
   # http://rack.rubyforge.org/doc/classes/Rack/Response.html
   # http://rack.rubyforge.org/doc/classes/Rack/Response/Helpers.html
   class Response < Rack::Response
-    def initialize
-      @status, @body = 200, []
-      @header = Rack::Utils::HeaderHash.new({'Content-Type' => 'text/html'})
-    end
-
-    def write(str)
-      @body << str.to_s
-      str
-    end
-
     def finish
       @body = block if block_given?
       if [204, 304].include?(status.to_i)
@@ -231,103 +222,110 @@ module Sinatra
   #   :locals       A hash with local variables that should be available
   #                 in the template
   module Templates
-    def erb(template, options={})
-      require 'erb' unless defined? ::ERB
-      render :erb, template, options
+    def erb(template, options={}, locals={})
+      render :erb, template, options, locals
     end
 
-    def haml(template, options={})
-      require 'haml' unless defined? ::Haml::Engine
-      options[:options] ||= self.class.haml if self.class.respond_to? :haml
-      render :haml, template, options
+    def haml(template, options={}, locals={})
+      render :haml, template, options, locals
     end
 
-    def sass(template, options={}, &block)
-      require 'sass' unless defined? ::Sass::Engine
+    def sass(template, options={}, locals={})
       options[:layout] = false
-      render :sass, template, options
+      render :sass, template, options, locals
     end
 
-    def builder(template=nil, options={}, &block)
-      require 'builder' unless defined? ::Builder
+    def builder(template=nil, options={}, locals={}, &block)
       options, template = template, nil if template.is_a?(Hash)
       template = lambda { block } if template.nil?
-      render :builder, template, options
+      render :builder, template, options, locals
     end
 
   private
-    def render(engine, template, options={}) #:nodoc:
-      data   = lookup_template(engine, template, options)
-      output = __send__("render_#{engine}", template, data, options)
-      layout, data = lookup_layout(engine, options)
+    def render(engine, template, options={}, locals={})
+      # merge app-level options
+      options = self.class.send(engine).merge(options) if self.class.respond_to?(engine)
+
+      # extract generic options
+      layout = options.delete(:layout)
+      layout = :layout if layout.nil? || layout == true
+      views = options.delete(:views) || self.class.views || "./views"
+      locals = options.delete(:locals) || locals || {}
+
+      # render template
+      data, options[:filename], options[:line] = lookup_template(engine, template, views)
+      output = __send__("render_#{engine}", template, data, options, locals)
+
+      # render layout
       if layout
-        __send__("render_#{engine}", layout, data, options) { output }
-      else
-        output
+        data, options[:filename], options[:line] = lookup_layout(engine, layout, views)
+        if data
+          output = __send__("render_#{engine}", layout, data, options, {}) { output }
+        end
       end
+
+      output
     end
 
-    def lookup_template(engine, template, options={})
+    def lookup_template(engine, template, views_dir, filename = nil, line = nil)
       case template
       when Symbol
         if cached = self.class.templates[template]
-          lookup_template(engine, cached, options)
+          lookup_template(engine, cached[:template], views_dir, cached[:filename], cached[:line])
         else
-          ::File.read(template_path(engine, template, options))
+          path = ::File.join(views_dir, "#{template}.#{engine}")
+          [ ::File.read(path), path, 1 ]
         end
       when Proc
-        template.call
+        filename, line = self.class.caller_locations.first if filename.nil?
+        [ template.call, filename, line.to_i ]
       when String
-        template
+        filename, line = self.class.caller_locations.first if filename.nil?
+        [ template, filename, line.to_i ]
       else
         raise ArgumentError
       end
     end
 
-    def lookup_layout(engine, options)
-      return if options[:layout] == false
-      options.delete(:layout) if options[:layout] == true
-      template = options[:layout] || :layout
-      data     = lookup_template(engine, template, options)
-      [template, data]
+    def lookup_layout(engine, template, views_dir)
+      lookup_template(engine, template, views_dir)
     rescue Errno::ENOENT
       nil
     end
 
-    def template_path(engine, template, options={})
-      views_dir =
-        options[:views_directory] || self.options.views || "./views"
-      "#{views_dir}/#{template}.#{engine}"
-    end
-
-    def render_erb(template, data, options, &block)
+    def render_erb(template, data, options, locals, &block)
       original_out_buf = @_out_buf
       data = data.call if data.kind_of? Proc
 
       instance = ::ERB.new(data, nil, nil, '@_out_buf')
-      locals = options[:locals] || {}
       locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
 
-      src = "#{locals_assigns.join("\n")}\n#{instance.src}"
-      eval src, binding, '(__ERB__)', locals_assigns.length + 1
+      filename = options.delete(:filename) || '(__ERB__)'
+      line = options.delete(:line) || 1
+      line -= 1 if instance.src =~ /^#coding:/
+
+      render_binding = binding
+      eval locals_assigns.join("\n"), render_binding
+      eval instance.src, render_binding, filename, line
       @_out_buf, result = original_out_buf, @_out_buf
       result
     end
 
-    def render_haml(template, data, options, &block)
-      engine = ::Haml::Engine.new(data, options[:options] || {})
-      engine.render(self, options[:locals] || {}, &block)
+    def render_haml(template, data, options, locals, &block)
+      ::Haml::Engine.new(data, options).render(self, locals, &block)
     end
 
-    def render_sass(template, data, options, &block)
-      engine = ::Sass::Engine.new(data, options[:sass] || {})
-      engine.render
+    def render_sass(template, data, options, locals, &block)
+      ::Sass::Engine.new(data, options).render
     end
 
-    def render_builder(template, data, options, &block)
-      xml = ::Builder::XmlMarkup.new(:indent => 2)
+    def render_builder(template, data, options, locals, &block)
+      options = { :indent => 2 }.merge(options)
+      filename = options.delete(:filename) || '<BUILDER>'
+      line = options.delete(:line) || 1
+      xml = ::Builder::XmlMarkup.new(options)
       if data.respond_to?(:to_str)
-        eval data.to_str, binding, '<BUILDER>', 1
+        eval data.to_str, binding, filename, line
       elsif data.kind_of?(Proc)
         data.call(xml)
       end
@@ -409,7 +407,13 @@ module Sinatra
   private
     # Run before filters and then locate and run a matching route.
     def route!
-      @params = nested_params(@request.params)
+      # enable nested params in Rack < 1.0; allow indifferent access
+      @params =
+        if Rack::Utils.respond_to?(:parse_nested_query)
+          indifferent_params(@request.params)
+        else
+          nested_params(@request.params)
+        end
 
       # before filters
       self.class.filters.each { |block| instance_eval(&block) }
@@ -443,24 +447,45 @@ module Sinatra
             catch(:pass) do
               conditions.each { |cond|
                 throw :pass if instance_eval(&cond) == false }
-              throw :halt, instance_eval(&block)
+              route_eval(&block)
             end
           end
         end
       end
 
-      # No matching route found or all routes passed -- forward downstream
-      # when running as middleware; 404 when running as normal app.
+      route_missing
+    end
+
+    # Run a route block and throw :halt with the result.
+    def route_eval(&block)
+      throw :halt, instance_eval(&block)
+    end
+
+    # No matching route was found or all routes passed. The default
+    # implementation is to forward the request downstream when running
+    # as middleware (@app is non-nil); when no downstream app is set, raise
+    # a NotFound exception. Subclasses can override this method to perform
+    # custom route miss logic.
+    def route_missing
       if @app
-        # Call bypassed method before forward to catch behavior that should
-        # happen even if no routes are hit.
-        bypassed if respond_to?(:bypassed)
         forward
       else
         raise NotFound
       end
     end
 
+    # Enable string or symbol key access to the nested params hash.
+    def indifferent_params(params)
+      params = indifferent_hash.merge(params)
+      params.each do |key, value|
+        next unless value.is_a?(Hash)
+        params[key] = indifferent_params(value)
+      end
+    end
+
+    # Recursively replace the params hash with a nested indifferent
+    # hash. Rack 1.0 has a built in implementation of this method - remove
+    # this once Rack 1.0 is required.
     def nested_params(params)
       return indifferent_hash.merge(params) if !params.keys.join.include?('[')
       params.inject indifferent_hash do |res, (key,val)|
@@ -532,7 +557,7 @@ module Sinatra
       @env['sinatra.error'] = boom
 
       dump_errors!(boom) if options.dump_errors?
-      raise boom         if options.raise_errors?
+      raise boom         if options.raise_errors? || options.show_exceptions?
 
       @response.status = 500
       error_block! boom.class, Exception
@@ -624,7 +649,8 @@ module Sinatra
 
       # Define a named template. The block must return the template source.
       def template(name, &block)
-        templates[name] = block
+        filename, line = caller_locations.first
+        templates[name] = { :filename => filename, :line => line, :template => block }
       end
 
       # Define the layout template. The block must return the template source.
@@ -636,12 +662,18 @@ module Sinatra
       # when no file is specified.
       def use_in_file_templates!(file=nil)
         file ||= caller_files.first
-        if data = ::IO.read(file).split('__END__')[1]
+        app, data =
+          ::IO.read(file).split(/^__END__$/, 2) rescue nil
+
+        if data
           data.gsub!(/\r\n/, "\n")
+          lines = app.count("\n") + 1
           template = nil
           data.each_line do |line|
+            lines += 1
             if line =~ /^@@\s*(.*)/
-              template = templates[$1.to_sym] = ''
+              template = ''
+              templates[$1.to_sym] = { :filename => file, :line => lines, :template => template }
             elsif template
               template << line
             end
@@ -711,10 +743,10 @@ 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
 
     private
       def route(verb, path, opts={}, &block)
@@ -734,7 +766,7 @@ module Sinatra
             lambda { unbound_method.bind(self).call }
           end
 
-        invoke_hook(:route_added, verb, path)
+        invoke_hook(:route_added, verb, path, block)
 
         (routes[verb] ||= []).
           push([pattern, keys, conditions, block]).last
@@ -790,14 +822,14 @@ module Sinatra
         end
       end
 
-      def development? ; environment == :development ; end
-      def test? ; environment == :test ; end
-      def production? ; environment == :production ; end
+      def development?; environment == :development end
+      def production?;  environment == :production  end
+      def test?;        environment == :test        end
 
       # Set configuration options for Sinatra and/or the app.
       # Allows scoping of settings for certain environments.
       def configure(*envs, &block)
-        yield if envs.empty? || envs.include?(environment.to_sym)
+        yield self if envs.empty? || envs.include?(environment.to_sym)
       end
 
       # Use the specified Rack middleware
@@ -836,8 +868,10 @@ module Sinatra
       def new(*args, &bk)
         builder = Rack::Builder.new
         builder.use Rack::Session::Cookie if sessions? && !test?
-        builder.use Rack::CommonLogger if logging?
-        builder.use Rack::MethodOverride if methodoverride?
+        builder.use Rack::CommonLogger    if logging?
+        builder.use Rack::MethodOverride  if methodoverride?
+        builder.use ShowExceptions        if show_exceptions?
+
         @middleware.each { |c,a,b| builder.use(c, *a, &b) }
         builder.run super
         builder.to_app
@@ -871,7 +905,7 @@ module Sinatra
         servers = Array(self.server)
         servers.each do |server_name|
           begin
-            return Rack::Handler.get(server_name)
+            return Rack::Handler.get(server_name.capitalize)
           rescue LoadError
           rescue NameError
           end
@@ -898,24 +932,32 @@ module Sinatra
           send :define_method, message, &block
       end
 
+    public
+      CALLERS_TO_IGNORE = [
+        /lib\/sinatra.*\.rb$/, # all sinatra code
+        /\(.*\)/,              # generated code
+        /custom_require\.rb$/, # rubygems require hacks
+        /active_support/,      # active_support require hacks
+      ] unless self.const_defined?('CALLERS_TO_IGNORE')
+
       # Like Kernel#caller but excluding certain magic entries and without
       # line / method information; the resulting array contains filenames only.
       def caller_files
-        ignore = [
-          /lib\/sinatra.*\.rb$/, # all sinatra code
-          /\(.*\)/,              # generated code
-          /custom_require\.rb$/, # rubygems require hacks
-          /active_support/,      # active_support require hacks
-        ]
+        caller_locations.
+          map { |file,line| file }
+      end
+
+      def caller_locations
         caller(1).
-          map    { |line| line.split(/:\d/, 2).first }.
-          reject { |file| ignore.any? { |pattern| file =~ pattern } }
+          map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
+          reject { |file,line| CALLERS_TO_IGNORE.any? { |pattern| file =~ pattern } }
       end
     end
 
     set :raise_errors, true
     set :dump_errors, false
     set :clean_trace, true
+    set :show_exceptions, Proc.new { development? }
     set :sessions, false
     set :logging, false
     set :methodoverride, false
@@ -957,6 +999,8 @@ module Sinatra
       end
 
       error NotFound do
+        content_type 'text/html'
+
         (<<-HTML).gsub(/^ {8}/, '')
         <!DOCTYPE html>
         <html>
@@ -978,35 +1022,6 @@ module Sinatra
         </html>
         HTML
       end
-
-      error do
-        next unless err = request.env['sinatra.error']
-        heading = err.class.name + ' - ' + err.message.to_s
-        (<<-HTML).gsub(/^ {8}/, '')
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <style type="text/css">
-            body {font-family:verdana;color:#333}
-            #c {margin-left:20px}
-            h1 {color:#1D6B8D;margin:0;margin-top:-30px}
-            h2 {color:#1D6B8D;font-size:18px}
-            pre {border-left:2px solid #ddd;padding-left:10px;color:#000}
-            img {margin-top:10px}
-          </style>
-        </head>
-        <body>
-          <div id="c">
-            <img src="/__sinatra__/500.png">
-            <h1>#{escape_html(heading)}</h1>
-            <pre>#{escape_html(clean_backtrace(err.backtrace) * "\n")}</pre>
-            <h2>Params</h2>
-            <pre>#{escape_html(params.inspect)}</pre>
-          </div>
-        </body>
-        </html>
-        HTML
-      end
     end
   end