@@ -7,9 +7,9 @@ configure do Castronaut.logger.debug "Sinatra Config - setting views path to #{views}" Castronaut.logger.debug "Sinatra Config - setting public path to #{pub_dir}" - set_options :root => root, - :views => views, - :public => pub_dir, - :logging => true, - :raise_errors => true + set :root => root, + :views => views, + :public => pub_dir, + :logging => true, + :raise_errors => true end app/config.rb @@ -5,7 +5,7 @@ describe 'Castronaut Application Controller' do describe "requesting / via GET" do it "redirects to /login" do - get_it '/' + get '/' @response.should be_redirection end end @@ -13,19 +13,19 @@ describe 'Castronaut Application Controller' do describe "requesting /login via GET" do it "responds with status 200" do - get_it '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + get '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } @response.should be_ok end it "sets the Pragma header to 'no-cache'" do - get_it '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + get '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } headers['Pragma'].should == 'no-cache' end it "sets the Cache-Control header to 'no-store'" do - get_it '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + get '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } headers['Cache-Control'].should == 'no-store' end @@ -35,7 +35,7 @@ describe 'Castronaut Application Controller' do jan_1st_2003 = Time.parse("01/01/2003 00:00:00") Time.stub!(:now).and_return(jan_1st_2008) - get_it '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + get '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } headers['Expires'].should include("Wed, 01 Jan 2003 00:00:00") end @@ -45,7 +45,7 @@ describe 'Castronaut Application Controller' do describe "requesting /login via POST" do it 'responds with status 200' do - post_it '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + post '/login', :env => { 'REMOTE_ADDR' => '10.0.0.1' } @response.should be_ok end @@ -55,7 +55,7 @@ describe 'Castronaut Application Controller' do describe "requesting /logout via GET" do it 'responds with status 200' do - get_it '/logout', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + get '/logout', :env => { 'REMOTE_ADDR' => '10.0.0.1' } @response.should be_ok end @@ -65,7 +65,7 @@ describe 'Castronaut Application Controller' do describe "requesting /serviceValidate via GET" do it 'responds with status 200' do - get_it '/serviceValidate', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + get '/serviceValidate', :env => { 'REMOTE_ADDR' => '10.0.0.1' } @response.should be_ok end @@ -75,7 +75,7 @@ describe 'Castronaut Application Controller' do describe "requesting /proxyValidate via GET" do it 'responds with status 200' do - get_it '/proxyValidate', :env => { 'REMOTE_ADDR' => '10.0.0.1' } + get '/proxyValidate', :env => { 'REMOTE_ADDR' => '10.0.0.1' } @response.should be_ok end spec/app/controllers/application_spec.rb @@ -6,8 +6,8 @@ require 'rack' require 'sinatra' require 'sinatra/test/unit' -Sinatra::Application.default_options.merge!( - :env => :test, +Sinatra::Application.set( + :environment => :test, :run => false, :raise_errors => true, :logging => false spec/spec_controller_helper.rb @@ -29,6 +29,8 @@ * chains apps by default * has implicit #to_app * supports blocks on use +* has explicit #to_app +* apps are initialized once == Rack::Adapter::Camping * works with GET @@ -55,12 +57,28 @@ * should log to rack.errors by default * should log to anything with << +== Rack::ConditionalGet +* should set a 304 status and truncate body when If-Modified-Since hits +* should set a 304 status and truncate body when If-None-Match hits +* should not affect non-GET/HEAD requests + +== Rack::ContentLength +* sets Content-Length on String bodies if none is set +* sets Content-Length on Array bodies if none is set +* does not set Content-Length on variable length bodies +* does not change Content-Length if it is already set +* does not set Content-Length on 304 responses +* does not set Content-Length when Transfer-Encoding is chunked + == Rack::Deflater * should be able to deflate bodies that respond to each * should be able to deflate String bodies * should be able to gzip bodies that respond to each * should be able to fallback to no deflation +* should be able to skip when there is no response entity body * should handle the lack of an acceptable encoding +* should handle gzip response with Last-Modified header +* should do nothing when no-transform Cache-Control directive present == Rack::Directory * serves directory indices @@ -85,13 +103,20 @@ * sets Last-Modified header * serves files with URL encoded filenames * does not allow directory traversal +* does not allow directory traversal with encoded periods * 404s if it can't find the file +* detects SystemCallErrors == Rack::Handler * has registered default handlers * should get unregistered handler by name * should register custom handler +== Rack::Head +* response (empty) +* passes GET, POST, PUT, DELETE, OPTIONS, TRACE requests +* removes body from HEAD requests + == Rack::Lint * passes valid request * notices fatal errors @@ -101,9 +126,15 @@ * notices status errors * notices header errors * notices content-type errors +* notices content-length errors * notices body errors * notices input handling errors * notices error handling errors +* notices HEAD errors + +== Rack::Lint::InputWrapper +* delegates :size to underlying IO object +* delegates :rewind to underlying IO object == Rack::Lobster::LambdaLobster * should be a single lambda @@ -115,6 +146,14 @@ * should be flippable * should provide crashing for testing purposes +== Rack::MethodOverride +* should not affect GET requests +* _method parameter should modify REQUEST_METHOD for POST requests +* X-HTTP-Method-Override header should modify REQUEST_METHOD for POST requests +* should not modify REQUEST_METHOD if the method is unknown +* should not modify REQUEST_METHOD when _method is nil +* should store the original REQUEST_METHOD prior to overriding + == Rack::MockRequest * should return a MockResponse * should be able to only return the environment @@ -143,6 +182,7 @@ * should provide a .run that maps a hash * should provide a .run that maps a urlmap * should provide a .run that maps a urlmap restricting by host +* should stream #each part of the response == Rack::Recursive * should allow for subrequests @@ -156,6 +196,8 @@ * can parse POST data * can parse POST data with explicit content type * does not parse POST data when media type is not form-data +* rewinds input after parsing POST data +* does not rewind unwindable CGI input * can get value by key from params with #[] * can set value to key on params with #[]= * values_at answers values by keys in order given @@ -175,6 +217,7 @@ * should work around buggy 1.8.* Tempfile equality * does conform to the Rack spec * should parse Accept-Encoding correctly +* should provide ip information == Rack::Response * has sensible default values @@ -182,6 +225,7 @@ * can set and read headers * can set cookies * formats the Cookie expiration date accordingly to RFC 2109 +* can set secure cookies * can delete cookies * has a useful constructor * has a constructor that can take a block @@ -195,6 +239,9 @@ * loads from a cookie * survives broken cookies * barks on too big cookies +* creates a new cookie with integrity hash +* loads from a cookie wih integrity hash +* ignores tampered with session cookies == Rack::Session::Memcache * startup (empty) @@ -228,6 +275,15 @@ * 404s if url root is known but it can't find the file * calls down the chain if url root is not known +== Rack::Handler::Thin +* should respond +* should be a Thin +* should have rack headers +* should have CGI headers on GET +* should have CGI headers on POST +* should support HTTP auth +* should set status + == Rack::URLMap * dispatches paths correctly * dispatches hosts correctly @@ -242,8 +298,10 @@ * should figure out which encodings are acceptable == Rack::Utils::HeaderHash -* should capitalize on all accesses -* should capitalize correctly +* should retain header case +* should check existence of keys case insensitively +* should merge case-insensitively +* should overwrite case insensitively and assume the new key's case * should be converted to real Hash == Rack::Utils::Context @@ -260,6 +318,7 @@ * should have CGI headers on POST * should support HTTP auth * should set status +* should correctly set cookies * should provide a .run -197 specifications, 3 empty (886 requirements), 0 failures +244 specifications, 4 empty (1004 requirements), 0 failures vendor/rack/RDOX @@ -9,38 +9,23 @@ middleware) into a single method call. The exact details of this are described in the Rack specification, which all Rack applications should conform to. -== Future specification changes - -PLEASE NOTE: In versions of Rack LATER than 0.4, the following -changes will be commited to the Rack specification: - -* 1xx, 204 and 304 status codes MUST not contain a Content-Type. -* A valid Content-Length header MUST be provided for non 1xx, 204 and 304 - responses with a Transfer-Encoding of "identity" (default). - The Content-Length MUST be the same as the sum of the byte-sizes of - the chunks. -* The REQUEST_METHOD may be any HTTP token. - -Internal Rack modules have been updated to follow this behavior, but -the Rack 0.4 Lint does NOT check it yet for compatibility reasons. -Please update your libraries accordingly. - == Supported web servers The included *handlers* connect all kinds of web servers to Rack: * Mongrel * EventedMongrel +* SwiftipliedMongrel * WEBrick * FCGI * CGI * SCGI * LiteSpeed +* Thin These web servers include Rack handlers in their distributions: * Ebb * Fuzed * Phusion Passenger (which is mod_rack for Apache) -* Thin Any valid Rack app will run the same on all these handlers, without changing anything. @@ -58,13 +43,12 @@ These frameworks include Rack adapters in their distributions: * Merb * Racktools::SimpleApplication * Ramaze +* Ruby on Rails * Sinatra +* Sin * Vintage * Waves -Ruby on Rails can be run with the adapter included with Thin, which -will be merged into a later Rack version. - Current links to these projects can be found at http://ramaze.net/#other-frameworks @@ -96,6 +80,14 @@ over: * Rack::MockRequest and Rack::MockResponse for efficient and quick testing of Rack application without real HTTP round-trips. +== rack-contrib + +The plethora of useful middleware created the need for a project that +collects fresh Rack middleware. rack-contrib includes a variety of +add-on components for Rack and it is easy to contribute new modules. + +* http://github.com/rack/rack-contrib + == rackup rackup is a useful tool for running Rack applications, which uses the @@ -129,7 +121,7 @@ A Gem of Rack is available. You can install it with: I also provide a local mirror of the gems (and development snapshots) at my site: - gem install rack --source http://chneukirchen.org/releases/gems + gem install rack --source http://chneukirchen.org/releases/gems/ == Running the tests @@ -204,7 +196,7 @@ run on port 11211) and memcache-client installed. * HTTP status 201 can contain a Content-Type and a body now. * Many bugfixes, especially related to Cookie handling. -* August 21th, 2008: Fourth public release 0.4. +* August 21st, 2008: Fourth public release 0.4. * New middleware, Rack::Deflater, by Christoffer Sawicki. * OpenID authentication now needs ruby-openid 2. * New Memcache sessions, by blink. @@ -216,37 +208,67 @@ run on port 11211) and memcache-client installed. * Improved tests. * Rack moved to Git. +* January 6th, 2009: Fifth public release 0.9. + * Rack is now managed by the Rack Core Team. + * Rack::Lint is stricter and follows the HTTP RFCs more closely. + * Added ConditionalGet middleware. + * Added ContentLength middleware. + * Added Deflater middleware. + * Added Head middleware. + * Added MethodOverride middleware. + * Rack::Mime now provides popular MIME-types and their extension. + * Mongrel Header now streams. + * Added Thin handler. + * Official support for swiftiplied Mongrel. + * Secure cookies. + * Made HeaderHash case-preserving. + * Many bugfixes and small improvements. + +* January 9th, 2009: Sixth public release 0.9.1. + * Fix directory traversal exploits in Rack::File and Rack::Directory. + == Contact Please mail bugs, suggestions and patches to <mailto:rack-devel@googlegroups.com>. Mailing list archives are available at -<http://groups.google.com/group/rack-devel> +<http://groups.google.com/group/rack-devel>. + +There is a bug tracker at <http://rack.lighthouseapp.com/>. -Git repository (branches rebased on master are most welcome): -* http://github.com/chneukirchen/rack +Git repository (patches rebased on master are most welcome): +* http://github.com/rack/rack * http://git.vuxu.org/cgi-bin/gitweb.cgi?p=rack.git You are also welcome to join the #rack channel on irc.freenode.net. -== Thanks to +== Thanks + +The Rack Core Team, consisting of + +* Christian Neukirchen (chneukirchen) +* James Tucker (raggi) +* Josh Peek (josh) +* Michael Fellinger (manveru) +* Ryan Tomayko (rtomayko) +* Scytrin dai Kinthra (scytrin) + +would like to thank: -* blink for the Pool sessions, Memcache sessions, OpenID support, many - tweaks, patches and bugreports. -* Michael Fellinger, for the helpful discussion, bugfixes and a better - Rack::Request interface. * Adrian Madrid, for the LiteSpeed handler. * Christoffer Sawicki, for the first Rails adapter and Rack::Deflater. * Tim Fletcher, for the HTTP authentication code. * Luc Heinrich for the Cookie sessions, the static file handler and bugfixes. * Armin Ronacher, for the logo and racktools. -* Aredridel, for bug fixing. +* Aredridel, Ben Alpert, Dan Kubb, Daniel Roethlisberger, Matt Todd, + Tom Robinson, and Phil Hagelberg for bug fixing and other + improvements. * Stephen Bannasch, for bug reports and documentation. * Gary Wright, for proposing a better Rack::Response interface. * Jonathan Buch, for improvements regarding Rack::Response. * Armin Röhrl, for tracking down bugs in the Cookie generator. -* Alexander Kellett for testing the Gem and reviewing the announce. +* Alexander Kellett for testing the Gem and reviewing the announcement. * Marcus Rückert, for help with configuring and debugging lighttpd. * The WSGI team for the well-done and documented work they've done and Rack builds up on. @@ -254,7 +276,7 @@ You are also welcome to join the #rack channel on irc.freenode.net. == Copyright -Copyright (C) 2007, 2008 Christian Neukirchen <http://purl.org/net/chneukirchen> +Copyright (C) 2007, 2008, 2009 Christian Neukirchen <http://purl.org/net/chneukirchen> Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to @@ -277,11 +299,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. Rack:: <http://rack.rubyforge.org/> Rack's Rubyforge project:: <http://rubyforge.org/projects/rack> +Official Rack repositories:: <http://github.com/rack> rack-devel mailing list:: <http://groups.google.com/group/rack-devel> -Camping:: <http://camping.rubyforge.org/> -Ramaze:: <http://ramaze.rubyforge.org/> -Maveric:: <http://maveric.rubyforge.org/> - Christian Neukirchen:: <http://chneukirchen.org/> vendor/rack/README @@ -133,6 +133,15 @@ Also see http://rack.rubyforge.org. s.email = 'chneukirchen@gmail.com' s.homepage = 'http://rack.rubyforge.org' s.rubyforge_project = 'rack' + + #s.add_development_dependency 'test-spec' + + #s.add_development_dependency 'camping' + #s.add_development_dependency 'fcgi' + #s.add_development_dependency 'memcache-client' + #s.add_development_dependency 'mongrel' + #s.add_development_dependency 'ruby-openid', '~> 2.0.0' + #s.add_development_dependency 'thin' end Rake::GemPackageTask.new(spec) do |p| vendor/rack/Rakefile @@ -71,8 +71,7 @@ There are the following restrictions: * <tt>rack.url_scheme</tt> must either be +http+ or +https+. * There must be a valid input stream in <tt>rack.input</tt>. * There must be a valid error stream in <tt>rack.errors</tt>. -* The <tt>REQUEST_METHOD</tt> must be one of +GET+, +POST+, +PUT+, - +DELETE+, +HEAD+, +OPTIONS+, +TRACE+. +* The <tt>REQUEST_METHOD</tt> must be a valid token. * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt> * The <tt>PATH_INFO</tt>, if non-empty, must start with <tt>/</tt> * The <tt>CONTENT_LENGTH</tt>, if given, must consist of digits only. @@ -111,7 +110,11 @@ The values passed on #each must be Strings and not contain characters below 037. === The Content-Type There must be a <tt>Content-Type</tt>, except when the -+Status+ is 204 or 304, in which case there must be none ++Status+ is 1xx, 204 or 304, in which case there must be none +given. +=== The Content-Length +There must be a <tt>Content-Length</tt>, except when the ++Status+ is 1xx, 204 or 304, in which case there must be none given. === The Body The Body must respond to #each vendor/rack/SPEC @@ -1,4 +1,4 @@ -# Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen> +# Copyright (C) 2007, 2008, 2009 Christian Neukirchen <purl.org/net/chneukirchen> # # Rack is freely distributable under the terms of an MIT-style license. # See COPYING or http://www.opensource.org/licenses/mit-license.php. @@ -23,18 +23,23 @@ module Rack # Return the Rack release as a dotted string. def self.release - "0.4" + "0.9" end autoload :Builder, "rack/builder" autoload :Cascade, "rack/cascade" autoload :CommonLogger, "rack/commonlogger" + autoload :ConditionalGet, "rack/conditionalget" + autoload :ContentLength, "rack/content_length" autoload :File, "rack/file" autoload :Deflater, "rack/deflater" autoload :Directory, "rack/directory" autoload :ForwardRequest, "rack/recursive" autoload :Handler, "rack/handler" + autoload :Head, "rack/head" autoload :Lint, "rack/lint" + autoload :MethodOverride, "rack/methodoverride" + autoload :Mime, "rack/mime" autoload :Recursive, "rack/recursive" autoload :Reloader, "rack/reloader" autoload :ShowExceptions, "rack/showexceptions" vendor/rack/lib/rack.rb @@ -15,7 +15,7 @@ module Rack h[k] = v.to_s end end - [controller.status, controller.headers, controller.body] + [controller.status, controller.headers, [controller.body.to_s]] end end end vendor/rack/lib/rack/adapter/camping.rb @@ -343,7 +343,7 @@ module Rack session['authenticated'] = false req.env['rack.errors'].puts oid.message - goto = @options[:login_fail] if @option.key? :login_fail + goto = @options[:login_fail] if @options.key? :login_fail body << "Authentication unsuccessful.\n" when ::OpenID::Consumer::SUCCESS session.clear @@ -367,7 +367,7 @@ module Rack session.clear session['authenticated'] = false - goto = @options[:login_fail] if @option.key? :login_fail + goto = @options[:login_fail] if @options.key? :login_fail body << "Authentication cancelled.\n" when ::OpenID::Consumer::SETUP_NEEDED session[:setup_needed] = true @@ -402,7 +402,8 @@ module Rack def add_extension ext, *args if not ext.is_a? Module raise TypeError, "#{ext.inspect} is not a module" - elsif not (m = %w'Request Response NS_URI' - ext.constants).empty? + elsif !(m = %w'Request Response NS_URI' - + ext.constants.map{ |c| c.to_s }).empty? raise ArgumentError, "#{ext.inspect} missing #{m*', '}" end vendor/rack/lib/rack/auth/openid.rb @@ -13,6 +13,13 @@ module Rack # end # } # + # Or + # + # app = Rack::Builder.app do + # use Rack::CommonLogger + # lambda { |env| [200, {'Content-Type' => 'text/plain'}, 'OK'] } + # end + # # +use+ adds a middleware to the stack, +run+ dispatches to an application. # You can use +map+ to construct a Rack::URLMap in a convenient way. @@ -22,6 +29,10 @@ module Rack instance_eval(&block) if block_given? end + def self.app(&block) + self.new(&block).to_app + end + def use(middleware, *args, &block) @ins << if block_given? lambda { |app| middleware.new(app, *args, &block) } @@ -36,7 +47,7 @@ module Rack def map(path, &block) if @ins.last.kind_of? Hash - @ins.last[path] = Rack::Builder.new(&block).to_app + @ins.last[path] = self.class.new(&block).to_app else @ins << {} map(path, &block) vendor/rack/lib/rack/builder.rb @@ -1,5 +1,6 @@ require "zlib" require "stringio" +require "time" # for Time.httpdate module Rack @@ -10,21 +11,44 @@ class Deflater def call(env) status, headers, body = @app.call(env) + headers = Utils::HeaderHash.new(headers) + + # Skip compressing empty entity body responses and responses with + # no-transform set. + if Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) || + headers['Cache-Control'].to_s =~ /\bno-transform\b/ + return [status, headers, body] + end request = Request.new(env) - encoding = Utils.select_best_encoding(%w(gzip deflate identity), request.accept_encoding) + encoding = Utils.select_best_encoding(%w(gzip deflate identity), + request.accept_encoding) + + # Set the Vary HTTP header. + vary = headers["Vary"].to_s.split(",").map { |v| v.strip } + unless vary.include?("*") || vary.include?("Accept-Encoding") + headers["Vary"] = vary.push("Accept-Encoding").join(",") + end case encoding when "gzip" - mtime = headers["Last-Modified"] || Time.now - [status, headers.merge("Content-Encoding" => "gzip"), self.class.gzip(body, mtime)] + mtime = if headers.key?("Last-Modified") + Time.httpdate(headers["Last-Modified"]) + else + Time.now + end + [status, + headers.merge("Content-Encoding" => "gzip"), + self.class.gzip(body, mtime)] when "deflate" - [status, headers.merge("Content-Encoding" => "deflate"), self.class.deflate(body)] + [status, + headers.merge("Content-Encoding" => "deflate"), + self.class.deflate(body)] when "identity" [status, headers, body] when nil - message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found." + message = ["An acceptable encoding for the requested resource #{request.fullpath} could not be found."] [406, {"Content-Type" => "text/plain"}, message] end end vendor/rack/lib/rack/deflater.rb @@ -1,4 +1,5 @@ require 'time' +require 'rack/mime' module Rack # Rack::Directory serves entries below the +root+ given, according to the @@ -13,10 +14,13 @@ module Rack DIR_PAGE = <<-PAGE <html><head> <title>%s</title> + <meta http-equiv="content-type" content="text/html; charset=utf-8" /> <style type='text/css'> table { width:100%%; } .name { text-align:left; } .size, .mtime { text-align:right; } +.type { width:11em; } +.mtime { width:15em; } </style> </head><body> <h1>%s</h1> @@ -38,11 +42,8 @@ table { width:100%%; } attr_accessor :root, :path def initialize(root, app=nil) - @root = root - @app = app - unless defined? @app - @app = Rack::File.new(@root) - end + @root = F.expand_path(root) + @app = app || Rack::File.new(@root) end def call(env) @@ -52,36 +53,72 @@ table { width:100%%; } F = ::File def _call(env) - if env["PATH_INFO"].include? ".." - body = "Forbidden\n" - size = body.respond_to?(:bytesize) ? body.bytesize : body.size - return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]] + @env = env + @script_name = env['SCRIPT_NAME'] + @path_info = Utils.unescape(env['PATH_INFO']) + + if forbidden = check_forbidden + forbidden + else + @path = F.join(@root, @path_info) + list_path + end + end + + def check_forbidden + return unless @path_info.include? ".." + + body = "Forbidden\n" + size = body.respond_to?(:bytesize) ? body.bytesize : body.size + return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]] + end + + def list_directory + @files = [['../','Parent Directory','','','']] + glob = F.join(@path, '*') + + Dir[glob].sort.each do |node| + stat = stat(node) + next unless stat + basename = F.basename(node) + ext = F.extname(node) + + url = F.join(@script_name, @path_info, basename) + size = stat.size + type = stat.directory? ? 'directory' : Mime.mime_type(ext) + size = stat.directory? ? '-' : filesize_format(size) + mtime = stat.mtime.httpdate + + @files << [ url, basename, size, type, mtime ] end - @path = F.join(@root, Utils.unescape(env['PATH_INFO'])) - - if F.exist?(@path) and F.readable?(@path) - if F.file?(@path) - return @app.call(env) - elsif F.directory?(@path) - @files = [['../','Parent Directory','','','']] - sName, pInfo = env.values_at('SCRIPT_NAME', 'PATH_INFO') - Dir.entries(@path).sort.each do |file| - next if file[0] == ?. - fl = F.join(@path, file) - sz = F.size(fl) - url = F.join(sName, pInfo, file) - type = F.directory?(fl) ? 'directory' : - MIME_TYPES.fetch(F.extname(file)[1..-1],'unknown') - size = (type!='directory' ? (sz<10240 ? "#{sz}B" : "#{sz/1024}KB") : '-') - mtime = F.mtime(fl).httpdate - @files << [ url, file, size, type, mtime ] - end - return [ 200, {'Content-Type'=>'text/html'}, self ] - end + return [ 200, {'Content-Type'=>'text/html; charset=utf-8'}, self ] + end + + def stat(node, max = 10) + F.stat(node) + rescue Errno::ENOENT, Errno::ELOOP + return nil + end + + # TODO: add correct response if not readable, not sure if 404 is the best + # option + def list_path + @stat = F.stat(@path) + + if @stat.readable? + return @app.call(@env) if @stat.file? + return list_directory if @stat.directory? + else + raise Errno::ENOENT, 'No such file or directory' end - body = "Entity not found: #{env["PATH_INFO"]}\n" + rescue Errno::ENOENT, Errno::ELOOP + return entity_not_found + end + + def entity_not_found + body = "Entity not found: #{@path_info}\n" size = body.respond_to?(:bytesize) ? body.bytesize : body.size return [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]] end @@ -93,66 +130,21 @@ table { width:100%%; } page.each_line{|l| yield l } end - def each_entry - @files.each{|e| yield e } - end + # Stolen from Ramaze + + FILESIZE_FORMAT = [ + ['%.1fT', 1 << 40], + ['%.1fG', 1 << 30], + ['%.1fM', 1 << 20], + ['%.1fK', 1 << 10], + ] - # From WEBrick. - MIME_TYPES = { - "ai" => "application/postscript", - "asc" => "text/plain", - "avi" => "video/x-msvideo", - "bin" => "application/octet-stream", - "bmp" => "image/bmp", - "class" => "application/octet-stream", - "cer" => "application/pkix-cert", - "crl" => "application/pkix-crl", - "crt" => "application/x-x509-ca-cert", - #"crl" => "application/x-pkcs7-crl", - "css" => "text/css", - "dms" => "application/octet-stream", - "doc" => "application/msword", - "dvi" => "application/x-dvi", - "eps" => "application/postscript", - "etx" => "text/x-setext", - "exe" => "application/octet-stream", - "gif" => "image/gif", - "htm" => "text/html", - "html" => "text/html", - "jpe" => "image/jpeg", - "jpeg" => "image/jpeg", - "jpg" => "image/jpeg", - "js" => "text/javascript", - "lha" => "application/octet-stream", - "lzh" => "application/octet-stream", - "mov" => "video/quicktime", - "mpe" => "video/mpeg", - "mpeg" => "video/mpeg", - "mpg" => "video/mpeg", - "pbm" => "image/x-portable-bitmap", - "pdf" => "application/pdf", - "pgm" => "image/x-portable-graymap", - "png" => "image/png", - "pnm" => "image/x-portable-anymap", - "ppm" => "image/x-portable-pixmap", - "ppt" => "application/vnd.ms-powerpoint", - "ps" => "application/postscript", - "qt" => "video/quicktime", - "ras" => "image/x-cmu-raster", - "rb" => "text/plain", - "rd" => "text/plain", - "rtf" => "application/rtf", - "sgm" => "text/sgml", - "sgml" => "text/sgml", - "tif" => "image/tiff", - "tiff" => "image/tiff", - "txt" => "text/plain", - "xbm" => "image/x-xbitmap", - "xls" => "application/vnd.ms-excel", - "xml" => "text/xml", - "xpm" => "image/x-xpixmap", - "xwd" => "image/x-xwindowdump", - "zip" => "application/zip", - } + def filesize_format(int) + FILESIZE_FORMAT.each do |format, size| + return format % (int.to_f / size) if int >= size + end + + int.to_s + 'B' + end end end vendor/rack/lib/rack/directory.rb @@ -1,4 +1,5 @@ require 'time' +require 'rack/mime' module Rack # Rack::File serves files below the +root+ given, according to the @@ -22,26 +23,55 @@ module Rack F = ::File def _call(env) - if env["PATH_INFO"].include? ".." - body = "Forbidden\n" - size = body.respond_to?(:bytesize) ? body.bytesize : body.size - return [403, {"Content-Type" => "text/plain","Content-Length" => size.to_s}, [body]] + @path_info = Utils.unescape(env["PATH_INFO"]) + return forbidden if @path_info.include? ".." + + @path = F.join(@root, @path_info) + + begin + if F.file?(@path) && F.readable?(@path) + serving + else + raise Errno::EPERM + end + rescue SystemCallError + not_found end + end + + def forbidden + body = "Forbidden\n" + [403, {"Content-Type" => "text/plain", + "Content-Length" => body.size.to_s}, + [body]] + end - @path = F.join(@root, Utils.unescape(env["PATH_INFO"])) - ext = F.extname(@path)[1..-1] + # NOTE: + # We check via File::size? whether this file provides size info + # via stat (e.g. /proc files often don't), otherwise we have to + # figure it out by reading the whole file into memory. And while + # we're at it we also use this as body then. - if F.file?(@path) && F.readable?(@path) - [200, { - "Last-Modified" => F.mtime(@path).httpdate, - "Content-Type" => MIME_TYPES[ext] || "text/plain", - "Content-Length" => F.size(@path).to_s - }, self] + def serving + if size = F.size?(@path) + body = self else - body = "File not found: #{env["PATH_INFO"]}\n" - size = body.respond_to?(:bytesize) ? body.bytesize : body.size - [404, {"Content-Type" => "text/plain", "Content-Length" => size.to_s}, [body]] + body = [F.read(@path)] + size = body.first.size end + + [200, { + "Last-Modified" => F.mtime(@path).httpdate, + "Content-Type" => Mime.mime_type(F.extname(@path), 'text/plain'), + "Content-Length" => size.to_s + }, body] + end + + def not_found + body = "File not found: #{@path_info}\n" + [404, {"Content-Type" => "text/plain", + "Content-Length" => body.size.to_s}, + [body]] end def each @@ -51,66 +81,5 @@ module Rack end } end - - # :stopdoc: - # From WEBrick with some additions. - MIME_TYPES = { - "ai" => "application/postscript", - "asc" => "text/plain", - "avi" => "video/x-msvideo", - "bin" => "application/octet-stream", - "bmp" => "image/bmp", - "class" => "application/octet-stream", - "cer" => "application/pkix-cert", - "crl" => "application/pkix-crl", - "crt" => "application/x-x509-ca-cert", - #"crl" => "application/x-pkcs7-crl", - "css" => "text/css", - "dms" => "application/octet-stream", - "doc" => "application/msword", - "dvi" => "application/x-dvi", - "eps" => "application/postscript", - "etx" => "text/x-setext", - "exe" => "application/octet-stream", - "gif" => "image/gif", - "htm" => "text/html", - "html" => "text/html", - "jpe" => "image/jpeg", - "jpeg" => "image/jpeg", - "jpg" => "image/jpeg", - "js" => "text/javascript", - "lha" => "application/octet-stream", - "lzh" => "application/octet-stream", - "mov" => "video/quicktime", - "mp3" => "audio/mpeg", - "mpe" => "video/mpeg", - "mpeg" => "video/mpeg", - "mpg" => "video/mpeg", - "pbm" => "image/x-portable-bitmap", - "pdf" => "application/pdf", - "pgm" => "image/x-portable-graymap", - "png" => "image/png", - "pnm" => "image/x-portable-anymap", - "ppm" => "image/x-portable-pixmap", - "ppt" => "application/vnd.ms-powerpoint", - "ps" => "application/postscript", - "qt" => "video/quicktime", - "ras" => "image/x-cmu-raster", - "rb" => "text/plain", - "rd" => "text/plain", - "rtf" => "application/rtf", - "sgm" => "text/sgml", - "sgml" => "text/sgml", - "tif" => "image/tiff", - "tiff" => "image/tiff", - "txt" => "text/plain", - "xbm" => "image/x-xbitmap", - "xls" => "application/vnd.ms-excel", - "xml" => "text/xml", - "xpm" => "image/x-xpixmap", - "xwd" => "image/x-xwindowdump", - "zip" => "application/zip", - } - # :startdoc: end end vendor/rack/lib/rack/file.rb @@ -29,16 +29,20 @@ module Rack autoload :FastCGI, "rack/handler/fastcgi" autoload :Mongrel, "rack/handler/mongrel" autoload :EventedMongrel, "rack/handler/evented_mongrel" + autoload :SwiftipliedMongrel, "rack/handler/swiftiplied_mongrel" autoload :WEBrick, "rack/handler/webrick" autoload :LSWS, "rack/handler/lsws" autoload :SCGI, "rack/handler/scgi" + autoload :Thin, "rack/handler/thin" register 'cgi', 'Rack::Handler::CGI' register 'fastcgi', 'Rack::Handler::FastCGI' register 'mongrel', 'Rack::Handler::Mongrel' register 'emongrel', 'Rack::Handler::EventedMongrel' + register 'smongrel', 'Rack::Handler::SwiftipliedMongrel' register 'webrick', 'Rack::Handler::WEBrick' register 'lsws', 'Rack::Handler::LSWS' register 'scgi', 'Rack::Handler::SCGI' + register 'thin', 'Rack::Handler::Thin' end end vendor/rack/lib/rack/handler.rb @@ -2,7 +2,7 @@ require 'swiftcore/evented_mongrel' module Rack module Handler - class EventedMongrel < Mongrel + class EventedMongrel < Handler::Mongrel end end end vendor/rack/lib/rack/handler/evented_mongrel.rb @@ -51,6 +51,8 @@ module Rack env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"] env["REQUEST_PATH"] ||= "/" env.delete "PATH_INFO" if env["PATH_INFO"] == "" + env.delete "CONTENT_TYPE" if env["CONTENT_TYPE"] == "" + env.delete "CONTENT_LENGTH" if env["CONTENT_LENGTH"] == "" status, headers, body = app.call(env) begin vendor/rack/lib/rack/handler/fastcgi.rb @@ -60,15 +60,19 @@ module Rack begin response.status = status.to_i + response.send_status(nil) + headers.each { |k, vs| vs.each { |v| response.header[k] = v } } + response.send_header + body.each { |part| - response.body << part + response.write part + response.socket.flush } - response.finished ensure body.close if body.respond_to? :close end vendor/rack/lib/rack/handler/mongrel.rb @@ -3,7 +3,7 @@ require 'stringio' module Rack module Handler - class WEBrick < WEBrick::HTTPServlet::AbstractServlet + class WEBrick < ::WEBrick::HTTPServlet::AbstractServlet def self.run(app, options={}) server = ::WEBrick::HTTPServer.new(options) server.mount "/", Rack::Handler::WEBrick, app @@ -41,9 +41,13 @@ module Rack begin res.status = status.to_i headers.each { |k, vs| - vs.each { |v| - res[k] = v - } + if k.downcase == "set-cookie" + res.cookies.concat vs.to_a + else + vs.each { |v| + res[k] = v + } + end } body.each { |part| res.body << part vendor/rack/lib/rack/handler/webrick.rb @@ -29,8 +29,8 @@ module Rack ## A Rack application is an Ruby object (not a class) that ## responds to +call+. - def call(env=nil) - dup._call(env) + def call(env=nil) + dup._call(env) end def _call(env) @@ -49,6 +49,7 @@ module Rack check_headers headers ## and the *body*. check_content_type status, headers + check_content_length status, headers, env [status, headers, self] end @@ -162,11 +163,9 @@ module Rack ## * There must be a valid error stream in <tt>rack.errors</tt>. check_error env["rack.errors"] - ## * The <tt>REQUEST_METHOD</tt> must be one of +GET+, +POST+, +PUT+, - ## +DELETE+, +HEAD+, +OPTIONS+, +TRACE+. + ## * The <tt>REQUEST_METHOD</tt> must be a valid token. assert("REQUEST_METHOD unknown: #{env["REQUEST_METHOD"]}") { - %w[GET POST PUT DELETE - HEAD OPTIONS TRACE].include?(env["REQUEST_METHOD"]) + env["REQUEST_METHOD"] =~ /\A[0-9A-Za-z!\#$%&'*+.^_`|~-]+\z/ } ## * The <tt>SCRIPT_NAME</tt>, if non-empty, must start with <tt>/</tt> @@ -215,6 +214,14 @@ module Rack @input = input end + def size + @input.size + end + + def rewind + @input.rewind + end + ## * +gets+ must be called without arguments and return a string, ## or +nil+ on EOF. def gets(*args) @@ -350,18 +357,75 @@ module Rack def check_content_type(status, headers) headers.each { |key, value| ## There must be a <tt>Content-Type</tt>, except when the - ## +Status+ is 204 or 304, in which case there must be none + ## +Status+ is 1xx, 204 or 304, in which case there must be none ## given. if key.downcase == "content-type" - assert("Content-Type header found in #{status} response, not allowed"){ - not [204, 304].include? status.to_i + assert("Content-Type header found in #{status} response, not allowed") { + not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i } return end } assert("No Content-Type header found") { - [204, 304].include? status.to_i + Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i + } + end + + ## === The Content-Length + def check_content_length(status, headers, env) + chunked_response = false + headers.each { |key, value| + if key.downcase == 'transfer-encoding' + chunked_response = value.downcase != 'identity' + end + } + + headers.each { |key, value| + if key.downcase == 'content-length' + ## There must be a <tt>Content-Length</tt>, except when the + ## +Status+ is 1xx, 204 or 304, in which case there must be none + ## given. + assert("Content-Length header found in #{status} response, not allowed") { + not Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i + } + + assert('Content-Length header should not be used if body is chunked') { + not chunked_response + } + + bytes = 0 + string_body = true + + @body.each { |part| + unless part.kind_of?(String) + string_body = false + break + end + + bytes += (part.respond_to?(:bytesize) ? part.bytesize : part.size) + } + + if env["REQUEST_METHOD"] == "HEAD" + assert("Response body was given for HEAD request, but should be empty") { + bytes == 0 + } + else + if string_body + assert("Content-Length header was #{value}, but should be #{bytes}") { + value == bytes.to_s + } + end + end + + return + end } + + if [ String, Array ].include?(@body.class) && !chunked_response + assert('No Content-Length header found') { + Rack::Utils::STATUS_WITH_NO_ENTITY_BODY.include? status.to_i + } + end end ## === The Body vendor/rack/lib/rack/lint.rb @@ -22,11 +22,11 @@ module Rack href = "?flip" end - [200, {"Content-Type" => "text/html"}, - ["<title>Lobstericious!</title>", - "<pre>", lobster, "</pre>", - "<a href='#{href}'>flip!</a>"] - ] + content = ["<title>Lobstericious!</title>", + "<pre>", lobster, "</pre>", + "<a href='#{href}'>flip!</a>"] + length = content.inject(0) { |a,e| a+e.size }.to_s + [200, {"Content-Type" => "text/html", "Content-Length" => length}, content] } def call(env) @@ -43,14 +43,14 @@ module Rack href = "?flip=left" end - Response.new.finish do |res| - res.write "<title>Lobstericious!</title>" - res.write "<pre>" - res.write lobster - res.write "</pre>" - res.write "<p><a href='#{href}'>flip!</a></p>" - res.write "<p><a href='?flip=crash'>crash!</a></p>" - end + res = Response.new + res.write "<title>Lobstericious!</title>" + res.write "<pre>" + res.write lobster + res.write "</pre>" + res.write "<p><a href='#{href}'>flip!</a></p>" + res.write "<p><a href='?flip=crash'>crash!</a></p>" + res.finish end end vendor/rack/lib/rack/lobster.rb @@ -123,7 +123,7 @@ module Rack } @body = "" - body.each { |part| @body << part.to_s } + body.each { |part| @body << part } @errors = errors.string end vendor/rack/lib/rack/mock.rb @@ -113,6 +113,7 @@ module Rack Utils::Multipart.parse_multipart(env) @env["rack.request.form_vars"] = @env["rack.input"].read @env["rack.request.form_hash"] = Utils.parse_query(@env["rack.request.form_vars"]) + @env["rack.input"].rewind if @env["rack.input"].respond_to?(:rewind) end @env["rack.request.form_hash"] else @@ -122,7 +123,7 @@ module Rack # The union of GET and POST data. def params - self.GET.update(self.POST) + self.put? ? self.GET : self.GET.update(self.POST) rescue EOFError => e self.GET end @@ -205,5 +206,13 @@ module Rack end end end + + def ip + if addr = @env['HTTP_X_FORWARDED_FOR'] + addr.split(',').last.strip + else + @env['REMOTE_ADDR'] + end + end end end vendor/rack/lib/rack/request.rb @@ -23,6 +23,7 @@ module Rack @writer = lambda { |x| @body << x } @block = nil + @length = 0 @body = [] @@ -59,12 +60,13 @@ module Rack # N.B.: cgi.rb uses spaces... expires = "; expires=" + value[:expires].clone.gmtime. strftime("%a, %d-%b-%Y %H:%M:%S GMT") if value[:expires] + secure = "; secure" if value[:secure] value = value[:value] end value = [value] unless Array === value cookie = Utils.escape(key) + "=" + value.map { |v| Utils.escape v }.join("&") + - "#{domain}#{path}#{expires}" + "#{domain}#{path}#{expires}#{secure}" case self["Set-Cookie"] when Array @@ -98,6 +100,7 @@ module Rack header.delete "Content-Type" [status.to_i, header.to_hash, []] else + header["Content-Length"] ||= @length.to_s [status.to_i, header.to_hash, self] end end @@ -110,7 +113,9 @@ module Rack end def write(str) - @writer.call str.to_s + s = str.to_s + @length += s.size + @writer.call s str end vendor/rack/lib/rack/response.rb @@ -26,7 +26,10 @@ module Rack :key => 'rack.session', :path => '/', :domain => nil, - :expire_after => nil + :expire_after => nil, + :secure => false, + :httponly => true, + :sidbits => 128 } def initialize(app, options={}) @@ -50,6 +53,14 @@ module Rack private + # Generate a new session id using Ruby #rand. The size of the + # session id is controlled by the :sidbits option. + # Monkey patch this to use custom methods for session id generation. + def generate_sid + "%0#{@default_options[:sidbits] / 4}x" % + rand(2**@default_options[:sidbits] - 1) + end + # Extracts the session id from provided cookies and passes it and the # environment to #get_session. It then sets the resulting session into # 'rack.session', and places options and session metadata into @@ -110,6 +121,8 @@ module Rack expiry = time + options[:expire_after] cookie<< "; expires=#{expiry.httpdate}" end + cookie<< "; Secure" if options[:secure] + cookie<< "; HttpOnly" if options[:httponly] case a = (h = response[1])['Set-Cookie'] when Array then a << cookie vendor/rack/lib/rack/session/abstract/id.rb @@ -1,3 +1,5 @@ +require 'openssl' + module Rack module Session @@ -5,13 +7,15 @@ module Rack # Rack::Session::Cookie provides simple cookie based session management. # The session is a Ruby Hash stored as base64 encoded marshalled data # set to :key (default: rack.session). + # When the secret key is set, cookie data is checked for data integrity. # # Example: # # use Rack::Session::Cookie, :key => 'rack.session', # :domain => 'foo.com', # :path => '/', - # :expire_after => 2592000 + # :expire_after => 2592000, + # :secret => 'change_me' # # All parameters are optional. @@ -20,6 +24,7 @@ module Rack def initialize(app, options={}) @app = app @key = options[:key] || "rack.session" + @secret = options[:secret] @default_options = {:domain => nil, :path => "/", :expire_after => nil}.merge(options) @@ -37,6 +42,11 @@ module Rack request = Rack::Request.new(env) session_data = request.cookies[@key] + if @secret && session_data + session_data, digest = session_data.split("--") + session_data = nil unless digest == generate_hmac(session_data) + end + begin session_data = session_data.unpack("m*").first session_data = Marshal.load(session_data) @@ -52,6 +62,10 @@ module Rack session_data = Marshal.dump(env["rack.session"]) session_data = [session_data].pack("m*") + if @secret + session_data = "#{session_data}--#{generate_hmac(session_data)}" + end + if session_data.size > (4096 - @key.size) env["rack.errors"].puts("Warning! Rack::Session::Cookie data size exceeds 4K. Content dropped.") [status, headers, body] @@ -66,6 +80,10 @@ module Rack end end + def generate_hmac(data) + OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA1.new, @secret, data) + end + end end end vendor/rack/lib/rack/session/cookie.rb @@ -45,7 +45,7 @@ module Rack @mutex.synchronize do begin raise RuntimeError, 'Unique id finding looping excessively' if (lc+=1) > 1000 - sid = "%08x" % rand(0xffffffff) + sid = generate_sid ret = @pool.add(sid, session) end until /^STORED/ =~ ret end vendor/rack/lib/rack/session/memcache.rb @@ -40,7 +40,7 @@ module Rack unless sess = @pool[sid] and ((expires = sess[:expire_at]).nil? or expires > Time.now) @pool.delete_if{|k,v| expiry = v[:expire_at] and expiry < Time.now } begin - sid = "%08x" % rand(0xffffffff) + sid = generate_sid end while @pool.has_key?(sid) end @pool[sid] ||= {} vendor/rack/lib/rack/session/pool.rb @@ -22,7 +22,11 @@ module Rack def call(env) @app.call(env) rescue StandardError, LoadError, SyntaxError => e - [500, {"Content-Type" => "text/html"}, pretty(env, e)] + backtrace = pretty(env, e) + [500, + {"Content-Type" => "text/html", + "Content-Length" => backtrace.join.size.to_s}, + backtrace] end def pretty(env, exception) vendor/rack/lib/rack/showexceptions.rb @@ -18,10 +18,11 @@ module Rack def call(env) status, headers, body = @app.call(env) + headers = Utils::HeaderHash.new(headers) + empty = headers['Content-Length'].to_i <= 0 # client or server error, or explicit message - if status.to_i >= 400 && - (body.empty? rescue false) || env["rack.showstatus.detail"] + if (status.to_i >= 400 && empty) || env["rack.showstatus.detail"] req = Rack::Request.new(env) message = Rack::Utils::HTTP_STATUS_CODES[status.to_i] || status.to_s detail = env["rack.showstatus.detail"] || message vendor/rack/lib/rack/showstatus.rb @@ -26,7 +26,7 @@ module Rack location = location.chomp('/') [host, location, app] - }.sort_by { |(h, l, a)| -l.size } # Longest path first + }.sort_by { |(h, l, a)| [-l.size, h.to_s.size] } # Longest path first end def call(env) vendor/rack/lib/rack/urlmap.rb @@ -1,3 +1,4 @@ +require 'set' require 'tempfile' module Rack @@ -31,10 +32,10 @@ module Rack def parse_query(qs, d = '&;') params = {} - + (qs || '').split(/[#{d}] */n).each do |p| k, v = unescape(p).split('=', 2) - + if cur = params[k] if cur.class == Array params[k] << v @@ -45,11 +46,11 @@ module Rack params[k] = v end end - + return params end module_function :parse_query - + def build_query(params) params.map { |k, v| if v.class == Array @@ -155,9 +156,11 @@ module Rack end end - # A case-normalizing Hash, adjusting on [] and []=. + # A case-insensitive Hash that preserves the original case of a + # header when set. class HeaderHash < Hash def initialize(hash={}) + @names = {} hash.each { |k, v| self[k] = v } end @@ -166,15 +169,35 @@ module Rack end def [](k) - super capitalize(k) + super @names[k.downcase] end def []=(k, v) - super capitalize(k), v + delete k + @names[k.downcase] = k + super k, v + end + + def delete(k) + super @names.delete(k.downcase) end - def capitalize(k) - k.to_s.downcase.gsub(/^.|[-_\s]./) { |x| x.upcase } + def include?(k) + @names.has_key? k.downcase + end + + alias_method :has_key?, :include? + alias_method :member?, :include? + alias_method :key?, :include? + + def merge!(other) + other.each { |k, v| self[k] = v } + self + end + + def merge(other) + hash = dup + hash.merge! other end end @@ -192,10 +215,11 @@ module Rack 206 => 'Partial Content', 300 => 'Multiple Choices', 301 => 'Moved Permanently', - 302 => 'Moved Temporarily', + 302 => 'Found', 303 => 'See Other', 304 => 'Not Modified', 305 => 'Use Proxy', + 307 => 'Temporary Redirect', 400 => 'Bad Request', 401 => 'Unauthorized', 402 => 'Payment Required', @@ -204,7 +228,7 @@ module Rack 405 => 'Method Not Allowed', 406 => 'Not Acceptable', 407 => 'Proxy Authentication Required', - 408 => 'Request Time-out', + 408 => 'Request Timeout', 409 => 'Conflict', 410 => 'Gone', 411 => 'Length Required', @@ -212,14 +236,19 @@ module Rack 413 => 'Request Entity Too Large', 414 => 'Request-URI Too Large', 415 => 'Unsupported Media Type', + 416 => 'Requested Range Not Satisfiable', + 417 => 'Expectation Failed', 500 => 'Internal Server Error', 501 => 'Not Implemented', 502 => 'Bad Gateway', 503 => 'Service Unavailable', - 504 => 'Gateway Time-out', - 505 => 'HTTP Version not supported' + 504 => 'Gateway Timeout', + 505 => 'HTTP Version Not Supported' } + # Responses with HTTP status codes that should not have an entity body + STATUS_WITH_NO_ENTITY_BODY = Set.new((100..199).to_a << 204 << 304) + # A multipart form data parser, adapted from IOWA. # # Usually, Rack::Request#POST takes care of calling this. vendor/rack/lib/rack/utils.rb @@ -3,7 +3,7 @@ server.document-root = "." server.errorlog = "lighttpd.errors" server.port = 9203 -server.event-handler = "freebsd-kqueue" +server.event-handler = "select" cgi.assign = ("/test" => "", # ".ru" => "" vendor/rack/test/cgi/lighttpd.conf vendor/rack/test/cgi/test vendor/rack/test/cgi/test.fcgi vendor/rack/test/cgi/test.ru @@ -2,6 +2,8 @@ require 'test/spec' require 'rack/builder' require 'rack/mock' +require 'rack/showexceptions' +require 'rack/auth/basic' context "Rack::Builder" do specify "chains apps by default" do @@ -47,4 +49,36 @@ context "Rack::Builder" do response.body.to_s.should.equal 'Hi Boss' end + specify "has explicit #to_app" do + app = Rack::Builder.app do + use Rack::ShowExceptions + run lambda { |env| raise "bzzzt" } + end + + Rack::MockRequest.new(app).get("/").should.be.server_error + Rack::MockRequest.new(app).get("/").should.be.server_error + Rack::MockRequest.new(app).get("/").should.be.server_error + end + + specify "apps are initialized once" do + app = Rack::Builder.new do + class AppClass + def initialize + @called = 0 + end + def call(env) + raise "bzzzt" if @called > 0 + @called += 1 + [200, {'Content-Type' => 'text/plain'}, 'OK'] + end + end + + use Rack::ShowExceptions + run AppClass.new + end + + Rack::MockRequest.new(app).get("/").status.should.equal 200 + Rack::MockRequest.new(app).get("/").should.be.server_error + end + end vendor/rack/test/spec_rack_builder.rb @@ -3,10 +3,11 @@ require 'test/spec' require 'rack/mock' require 'rack/deflater' require 'stringio' +require 'time' # for Time#httpdate context "Rack::Deflater" do - def build_response(body, accept_encoding, headers = {}) - app = lambda { |env| [200, {}, body] } + def build_response(status, body, accept_encoding, headers = {}) + app = lambda { |env| [status, {}, body] } request = Rack::MockRequest.env_for("", headers.merge("HTTP_ACCEPT_ENCODING" => accept_encoding)) response = Rack::Deflater.new(app).call(request) @@ -17,19 +18,19 @@ context "Rack::Deflater" do body = Object.new class << body; def each; yield("foo"); yield("bar"); end; end - response = build_response(body, "deflate") + response = build_response(200, body, "deflate") response[0].should.equal(200) - response[1].should.equal({ "Content-Encoding" => "deflate" }) + response[1].should.equal({ "Content-Encoding" => "deflate", "Vary" => "Accept-Encoding" }) response[2].to_s.should.equal("K\313\317OJ,\002\000") end # TODO: This is really just a special case of the above... specify "should be able to deflate String bodies" do - response = build_response("Hello world!", "deflate") + response = build_response(200, "Hello world!", "deflate") response[0].should.equal(200) - response[1].should.equal({ "Content-Encoding" => "deflate" }) + response[1].should.equal({ "Content-Encoding" => "deflate", "Vary" => "Accept-Encoding" }) response[2].to_s.should.equal("\363H\315\311\311W(\317/\312IQ\004\000") end @@ -37,10 +38,10 @@ context "Rack::Deflater" do body = Object.new class << body; def each; yield("foo"); yield("bar"); end; end - response = build_response(body, "gzip") + response = build_response(200, body, "gzip") response[0].should.equal(200) - response[1].should.equal({ "Content-Encoding" => "gzip" }) + response[1].should.equal({ "Content-Encoding" => "gzip", "Vary" => "Accept-Encoding" }) io = StringIO.new(response[2].to_s) gz = Zlib::GzipReader.new(io) @@ -49,22 +50,56 @@ context "Rack::Deflater" do end specify "should be able to fallback to no deflation" do - response = build_response("Hello world!", "superzip") + response = build_response(200, "Hello world!", "superzip") response[0].should.equal(200) - response[1].should.equal({}) + response[1].should.equal({ "Vary" => "Accept-Encoding" }) response[2].should.equal("Hello world!") end + specify "should be able to skip when there is no response entity body" do + response = build_response(304, [], "gzip") + + response[0].should.equal(304) + response[1].should.equal({}) + response[2].should.equal([]) + end + specify "should handle the lack of an acceptable encoding" do - response1 = build_response("Hello world!", "identity;q=0", "PATH_INFO" => "/") + response1 = build_response(200, "Hello world!", "identity;q=0", "PATH_INFO" => "/") response1[0].should.equal(406) response1[1].should.equal({"Content-Type" => "text/plain"}) - response1[2].should.equal("An acceptable encoding for the requested resource / could not be found.") + response1[2].should.equal(["An acceptable encoding for the requested resource / could not be found."]) - response2 = build_response("Hello world!", "identity;q=0", "SCRIPT_NAME" => "/foo", "PATH_INFO" => "/bar") + response2 = build_response(200, "Hello world!", "identity;q=0", "SCRIPT_NAME" => "/foo", "PATH_INFO" => "/bar") response2[0].should.equal(406) response2[1].should.equal({"Content-Type" => "text/plain"}) - response2[2].should.equal("An acceptable encoding for the requested resource /foo/bar could not be found.") + response2[2].should.equal(["An acceptable encoding for the requested resource /foo/bar could not be found."]) + end + + specify "should handle gzip response with Last-Modified header" do + last_modified = Time.now.httpdate + + app = lambda { |env| [200, { "Last-Modified" => last_modified }, "Hello World!"] } + request = Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => "gzip") + response = Rack::Deflater.new(app).call(request) + + response[0].should.equal(200) + response[1].should.equal({ "Content-Encoding" => "gzip", "Vary" => "Accept-Encoding", "Last-Modified" => last_modified }) + + io = StringIO.new(response[2].to_s) + gz = Zlib::GzipReader.new(io) + gz.read.should.equal("Hello World!") + gz.close + end + + specify "should do nothing when no-transform Cache-Control directive present" do + app = lambda { |env| [200, {'Cache-Control' => 'no-transform'}, ['Hello World!']] } + request = Rack::MockRequest.env_for("", "HTTP_ACCEPT_ENCODING" => "gzip") + response = Rack::Deflater.new(app).call(request) + + response[0].should.equal(200) + response[1].should.not.include "Content-Encoding" + response[2].join.should.equal("Hello World!") end end vendor/rack/test/spec_rack_deflater.rb @@ -45,6 +45,11 @@ context "Rack::Directory" do get("/cgi/../test") res.should.be.forbidden + + res = Rack::MockRequest.new(Rack::Lint.new(app)). + get("/cgi/%2E%2E/test") + + res.should.be.forbidden end specify "404s if it can't find the file" do vendor/rack/test/spec_rack_directory.rb @@ -41,10 +41,24 @@ context "Rack::File" do res.should.be.forbidden end + specify "does not allow directory traversal with encoded periods" do + res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). + get("/%2E%2E/README") + + res.should.be.forbidden + end + specify "404s if it can't find the file" do res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). get("/cgi/blubb") res.should.be.not_found end + + specify "detects SystemCallErrors" do + res = Rack::MockRequest.new(Rack::Lint.new(Rack::File.new(DOCROOT))). + get("/cgi") + + res.should.be.not_found + end end vendor/rack/test/spec_rack_file.rb @@ -2,10 +2,10 @@ require 'test/spec' require 'rack/handler' -context "Rack::Handler" do - class Rack::Handler::Lobster; end - class RockLobster; end +class Rack::Handler::Lobster; end +class RockLobster; end +context "Rack::Handler" do specify "has registered default handlers" do Rack::Handler.get('cgi').should.equal Rack::Handler::CGI Rack::Handler.get('fastcgi').should.equal Rack::Handler::FastCGI vendor/rack/test/spec_rack_handler.rb @@ -67,9 +67,9 @@ context "Rack::Lint" do message.should.match(/url_scheme unknown/) lambda { - Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP")) + Rack::Lint.new(nil).call(env("REQUEST_METHOD" => "FUCKUP?")) }.should.raise(Rack::Lint::LintError). - message.should.match(/REQUEST_METHOD unknown/) + message.should.match(/REQUEST_METHOD/) lambda { Rack::Lint.new(nil).call(env("SCRIPT_NAME" => "howdy")) @@ -203,6 +203,47 @@ context "Rack::Lint" do }).call(env({})) }.should.raise(Rack::Lint::LintError). message.should.match(/No Content-Type/) + + [100, 101, 204, 304].each do |status| + lambda { + Rack::Lint.new(lambda { |env| + [status, {"Content-type" => "text/plain", "Content-length" => "0"}, ""] + }).call(env({})) + }.should.raise(Rack::Lint::LintError). + message.should.match(/Content-Type header found/) + end + end + + specify "notices content-length errors" do + lambda { + Rack::Lint.new(lambda { |env| + [200, {"Content-type" => "text/plain"}, ""] + }).call(env({})) + }.should.raise(Rack::Lint::LintError). + message.should.match(/No Content-Length/) + + [100, 101, 204, 304].each do |status| + lambda { + Rack::Lint.new(lambda { |env| + [status, {"Content-length" => "0"}, ""] + }).call(env({})) + }.should.raise(Rack::Lint::LintError). + message.should.match(/Content-Length header found/) + end + + lambda { + Rack::Lint.new(lambda { |env| + [200, {"Content-type" => "text/plain", "Content-Length" => "0", "Transfer-Encoding" => "chunked"}, ""] + }).call(env({})) + }.should.raise(Rack::Lint::LintError). + message.should.match(/Content-Length header should not be used/) + + lambda { + Rack::Lint.new(lambda { |env| + [200, {"Content-type" => "text/plain", "Content-Length" => "1"}, ""] + }).call(env({})) + }.should.raise(Rack::Lint::LintError). + message.should.match(/Content-Length header was 1, but should be 0/) end specify "notices body errors" do @@ -300,4 +341,40 @@ context "Rack::Lint" do message.should.match(/close must not be called/) end + specify "notices HEAD errors" do + lambda { + Rack::Lint.new(lambda { |env| + [200, {"Content-type" => "test/plain", "Content-length" => "3"}, []] + }).call(env({"REQUEST_METHOD" => "HEAD"})) + }.should.not.raise + + lambda { + Rack::Lint.new(lambda { |env| + [200, {"Content-type" => "test/plain", "Content-length" => "3"}, "foo"] + }).call(env({"REQUEST_METHOD" => "HEAD"})) + }.should.raise(Rack::Lint::LintError). + message.should.match(/body was given for HEAD/) + end +end + +context "Rack::Lint::InputWrapper" do + specify "delegates :size to underlying IO object" do + class IOMock + def size + 101 + end + end + + wrapper = Rack::Lint::InputWrapper.new(IOMock.new) + wrapper.size.should == 101 + end + + specify "delegates :rewind to underlying IO object" do + io = StringIO.new("123") + wrapper = Rack::Lint::InputWrapper.new(io) + wrapper.read.should == "123" + wrapper.read.should == "" + wrapper.rewind + wrapper.read.should == "123" + end end vendor/rack/test/spec_rack_lint.rb @@ -125,7 +125,7 @@ context "Rack::MockResponse" do res.original_headers["Content-Type"].should.equal "text/yaml" res["Content-Type"].should.equal "text/yaml" res.content_type.should.equal "text/yaml" - res.content_length.should.be.nil + res.content_length.should.be 381 # needs change often. res.location.should.be.nil end vendor/rack/test/spec_rack_mock.rb @@ -5,7 +5,8 @@ require 'rack/handler/mongrel' require 'rack/urlmap' require 'rack/lint' require 'testrequest' - +require 'timeout' + Thread.abort_on_exception = true $tcp_defer_accept_opts = nil $tcp_cork_opts = nil @@ -17,6 +18,8 @@ context "Rack::Handler::Mongrel" do server = Mongrel::HttpServer.new(@host='0.0.0.0', @port=9201) server.register('/test', Rack::Handler::Mongrel.new(Rack::Lint.new(TestRequest.new))) + server.register('/stream', + Rack::Handler::Mongrel.new(Rack::Lint.new(StreamingRequest))) @acc = server.run end @@ -160,6 +163,22 @@ context "Rack::Handler::Mongrel" do block_ran.should.be true end + specify "should stream #each part of the response" do + body = '' + begin + Timeout.timeout(1) do + Net::HTTP.start(@host, @port) do |http| + get = Net::HTTP::Get.new('/stream') + http.request(get) do |response| + response.read_body { |part| body << part } + end + end + end + rescue Timeout::Error + end + body.should.not.be.empty + end + teardown do @acc.raise Mongrel::StopServer end vendor/rack/test/spec_rack_mongrel.rb @@ -83,6 +83,26 @@ context "Rack::Request" do req.body.read.should.equal "foo=bar&quux=bla" end + specify "rewinds input after parsing POST data" do + input = StringIO.new("foo=bar&quux=bla") + req = Rack::Request.new \ + Rack::MockRequest.env_for("/", + "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar', + :input => input) + req.params.should.equal "foo" => "bar", "quux" => "bla" + input.read.should.equal "foo=bar&quux=bla" + end + + specify "does not rewind unwindable CGI input" do + input = StringIO.new("foo=bar&quux=bla") + input.instance_eval "undef :rewind" + req = Rack::Request.new \ + Rack::MockRequest.env_for("/", + "CONTENT_TYPE" => 'application/x-www-form-urlencoded;foo=bar', + :input => input) + req.params.should.equal "foo" => "bar", "quux" => "bla" + end + specify "can get value by key from params with #[]" do req = Rack::Request.new \ Rack::MockRequest.env_for("?foo=quux") @@ -289,7 +309,7 @@ EOF "CONTENT_TYPE" => "multipart/form-data, boundary=AaB03x", "CONTENT_LENGTH" => input.size, :input => input) - + req.POST["huge"][:tempfile].size.should.equal 32768 req.POST["mean"][:tempfile].size.should.equal 10 req.POST["mean"][:tempfile].read.should.equal "--AaB03xha" @@ -398,4 +418,29 @@ EOF lambda { parser.call("gzip ; q=1.0") }.should.raise(RuntimeError) end + + specify 'should provide ip information' do + app = lambda { |env| + request = Rack::Request.new(env) + response = Rack::Response.new + response.write request.ip + response.finish + } + + mock = Rack::MockRequest.new(Rack::Lint.new(app)) + res = mock.get '/', 'REMOTE_ADDR' => '123.123.123.123' + res.body.should == '123.123.123.123' + + res = mock.get '/', + 'REMOTE_ADDR' => '123.123.123.123', + 'HTTP_X_FORWARDED_FOR' => '234.234.234.234' + + res.body.should == '234.234.234.234' + + res = mock.get '/', + 'REMOTE_ADDR' => '123.123.123.123', + 'HTTP_X_FORWARDED_FOR' => '234.234.234.234,212.212.212.212' + + res.body.should == '212.212.212.212' + end end vendor/rack/test/spec_rack_request.rb @@ -1,4 +1,5 @@ require 'test/spec' +require 'set' require 'rack/response' @@ -7,7 +8,7 @@ context "Rack::Response" do response = Rack::Response.new status, header, body = response.finish status.should.equal 200 - header.should.equal "Content-Type" => "text/html" + header.should.equal "Content-Type" => "text/html", "Content-Length" => "0" body.each { |part| part.should.equal "" } @@ -15,7 +16,7 @@ context "Rack::Response" do response = Rack::Response.new status, header, body = *response status.should.equal 200 - header.should.equal "Content-Type" => "text/html" + header.should.equal "Content-Type" => "text/html", "Content-Length" => "0" body.each { |part| part.should.equal "" } @@ -62,6 +63,12 @@ context "Rack::Response" do /expires=..., \d\d-...-\d\d\d\d \d\d:\d\d:\d\d .../) end + specify "can set secure cookies" do + response = Rack::Response.new + response.set_cookie "foo", {:value => "bar", :secure => true} + response["Set-Cookie"].should.equal "foo=bar; secure" + end + specify "can delete cookies" do response = Rack::Response.new response.set_cookie "foo", "bar" @@ -82,7 +89,7 @@ context "Rack::Response" do str = ""; body.each { |part| str << part } str.should.equal "foobar" - r = Rack::Response.new({"foo", "bar"}) + r = Rack::Response.new(["foo", "bar"].to_set) r.write "foo" status, header, body = r.finish str = ""; body.each { |part| str << part } vendor/rack/test/spec_rack_response.rb @@ -46,4 +46,37 @@ context "Rack::Session::Cookie" do get("/", :fatal => true) }.should.raise(Rack::MockRequest::FatalWarning) end + + specify "creates a new cookie with integrity hash" do + res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/") + if RUBY_VERSION < "1.9" + res["Set-Cookie"].should.match("rack.session=BAh7BiIMY291bnRlcmkG%0A--1439b4d37b9d4b04c603848382f712d6fcd31088") + else + res["Set-Cookie"].should.match("rack.session=BAh7BkkiDGNvdW50ZXIGOg1lbmNvZGluZyINVVMtQVNDSUlpBg%3D%3D%0A--d7a6637b94d2728194a96c18484e1f7ed9074a83") + end + end + + specify "loads from a cookie wih integrity hash" do + res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')).get("/") + cookie = res["Set-Cookie"] + res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')). + get("/", "HTTP_COOKIE" => cookie) + res.body.should.equal '{"counter"=>2}' + cookie = res["Set-Cookie"] + res = Rack::MockRequest.new(Rack::Session::Cookie.new(incrementor, :secret => 'test')). + get("/", "HTTP_COOKIE" => cookie) + res.body.should.equal '{"counter"=>3}' + end + + specify "ignores tampered with session cookies" do + app = Rack::Session::Cookie.new(incrementor, :secret => 'test') + response1 = Rack::MockRequest.new(app).get("/") + _, digest = response1["Set-Cookie"].split("--") + tampered_with_cookie = "hackerman-was-here" + "--" + digest + response2 = Rack::MockRequest.new(app).get("/", "HTTP_COOKIE" => + tampered_with_cookie) + + # The tampered-with cookie is ignored, so we get back an identical Set-Cookie + response2["Set-Cookie"].should.equal(response1["Set-Cookie"]) + end end vendor/rack/test/spec_rack_session_cookie.rb @@ -65,28 +65,30 @@ context "Rack::Utils" do end context "Rack::Utils::HeaderHash" do - specify "should capitalize on all accesses" do - h = Rack::Utils::HeaderHash.new("foo" => "bar") - h["foo"].should.equal "bar" - h["Foo"].should.equal "bar" - h["FOO"].should.equal "bar" - - h.to_hash.should.equal "Foo" => "bar" - - h["bar-zzle"] = "quux" + specify "should retain header case" do + h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...") + h['ETag'] = 'Boo!' + h.to_hash.should.equal "Content-MD5" => "d5ff4e2a0 ...", "ETag" => 'Boo!' + end - h.to_hash.should.equal "Foo" => "bar", "Bar-Zzle" => "quux" + specify "should check existence of keys case insensitively" do + h = Rack::Utils::HeaderHash.new("Content-MD5" => "d5ff4e2a0 ...") + h.should.include 'content-md5' + h.should.not.include 'ETag' end - specify "should capitalize correctly" do - h = Rack::Utils::HeaderHash.new + specify "should merge case-insensitively" do + h = Rack::Utils::HeaderHash.new("ETag" => 'HELLO', "content-length" => '123') + merged = h.merge("Etag" => 'WORLD', 'Content-Length' => '321', "Foo" => 'BAR') + merged.should.equal "Etag"=>'WORLD', "Content-Length"=>'321', "Foo"=>'BAR' + end - h.capitalize("foo").should.equal "Foo" - h.capitalize("foo-bar").should.equal "Foo-Bar" - h.capitalize("foo_bar").should.equal "Foo_Bar" - h.capitalize("foo bar").should.equal "Foo Bar" - h.capitalize("foo-bar-quux").should.equal "Foo-Bar-Quux" - h.capitalize("foo-bar-2quux").should.equal "Foo-Bar-2quux" + specify "should overwrite case insensitively and assume the new key's case" do + h = Rack::Utils::HeaderHash.new("Foo-Bar" => "baz") + h["foo-bar"] = "bizzle" + h["FOO-BAR"].should.equal "bizzle" + h.length.should.equal 1 + h.to_hash.should.equal "foo-bar" => "bizzle" end specify "should be converted to real Hash" do vendor/rack/test/spec_rack_utils.rb @@ -2,6 +2,7 @@ require 'test/spec' require 'rack/handler/webrick' require 'rack/lint' +require 'rack/response' require 'testrequest' Thread.abort_on_exception = true @@ -83,6 +84,22 @@ context "Rack::Handler::WEBrick" do response["rack.url_scheme"].should.equal "http" end + specify "should correctly set cookies" do + @server.mount "/cookie-test", Rack::Handler::WEBrick, + Rack::Lint.new(lambda { |req| + res = Rack::Response.new + res.set_cookie "one", "1" + res.set_cookie "two", "2" + res.finish + }) + + Net::HTTP.start(@host, @port) { |http| + res = http.get("/cookie-test") + res.code.to_i.should.equal 200 + res.get_fields("set-cookie").should.equal ["one=1", "two=2"] + } + end + specify "should provide a .run" do block_ran = false catch(:done) { vendor/rack/test/spec_rack_webrick.rb @@ -43,3 +43,15 @@ class TestRequest end end end + +class StreamingRequest + def self.call(env) + [200, {"Content-Type" => "text/plain"}, new] + end + + def each + yield "hello there!\n" + sleep 5 + yield "that is all.\n" + end +end vendor/rack/test/testrequest.rb @@ -1,9 +1,7 @@ = Sinatra Sinatra is a DSL for quickly creating web-applications in Ruby with minimal -effort. - -== Sample App +effort: # myapp.rb require 'rubygems' @@ -32,78 +30,80 @@ Run with <tt>ruby myapp.rb</tt> and view at <tt>http://localhost:4567</tt> .. annihilate something .. end - head '/' do - - end - -NOTE: <tt>put</tt> and <tt>delete</tt> are also triggered when a -<tt>_method</tt> parameter is set to PUT or DELETE and the HTTP request method -is POST - == Routes Routes are matched based on the order of declaration. The first route that matches the request is invoked. -Simple: +Basic routes: get '/hi' do ... end -Named parameters: +Route patterns may include named parameters, accessible via the +<tt>params</tt> hash: get '/:name' do - # matches /sinatra and the like and sets params[:name] + # matches "GET /foo" and "GET /bar" + # params[:name] is 'foo' or 'bar' + "Hello #{params[:name]}!" end -Splat parameters: +Route patterns may also include splat (or wildcard) parameters, accessible +via the <tt>params[:splat]</tt> array. get '/say/*/to/*' do # matches /say/hello/to/world - params["splat"] # => ["hello", "world"] + params[:splat] # => ["hello", "world"] end get '/download/*.*' do # matches /download/path/to/file.xml - params["splat"] # => ["path/to/file", "xml"] + params[:splat] # => ["path/to/file", "xml"] end -User agent matching: +Route matching with Regular Expressions: + + get %r{/hello/([\w]+)} do + "Hello, #{params[:captures].first}!" + end + +Routes may include a variety of matching conditions, such as the user agent: get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do "You're using Songbird version #{params[:agent][0]}" end get '/foo' do - # matches non-songbird browsers + # Matches non-songbird browsers end -= Static files +== Static Files -Put all of your static content in the ./public directory +Static files are served from the <tt>./public</tt> directory. You can specify +a different location by setting the <tt>:public</tt> option: - root - \ public + set :public, File.dirname(__FILE__) + '/static' -If a file exists that maps to the REQUEST_PATH then it is served and the -request ends. Otherwise, Sinatra will look for an event that matches the -path. +== Views / Templates -== Views +Templates are assumed to be located directly under a <tt>./views</tt> +directory. To use a different views directory: -Views are searched for in a "views" directory in the same location as -your main application. + set :views, File.dirname(__FILE__) + '/templates' === Haml Templates +The haml gem/library is required to render HAML templates: + get '/' do haml :index end Renders <tt>./views/index.haml</tt>. -=== Erb +=== Erb Templates get '/' do erb :index @@ -111,11 +111,20 @@ Renders <tt>./views/index.haml</tt>. Renders <tt>./views/index.erb</tt> -=== Builder +=== Builder Templates + +The builder gem/library is required to render builder templates: + + get '/' do + content_type 'application/xml', :charset => 'utf-8' + builder :index + end + +Renders <tt>./views/index.builder</tt>. -See Sinatra::Builder +=== Sass Templates -=== Sass +The sass gem/library is required to render Sass templates: get '/stylesheet.css' do content_type 'text/css', :charset => 'utf-8' @@ -134,20 +143,19 @@ Renders the inlined template string. === Accessing Variables -Templates are evaluated within the Sinatra::EventContext instance -used to evaluate event blocks. Instance variables set in event -blocks can be accessed direcly in views: +Templates are evaluated within the same context as the route blocks. Instance +variables set in route blocks are available in templates: get '/:id' do @foo = Foo.find(params[:id]) - haml '%h1== @foo.name' + haml '%h1= @foo.name' end Or, specify an explicit Hash of local variables: get '/:id' do foo = Foo.find(params[:id]) - haml '%h1== foo.name', :locals => { :foo => foo } + haml '%h1= foo.name', :locals => { :foo => foo } end This is typically used when rendering templates as partials from within @@ -157,27 +165,32 @@ other templates. Templates may be defined at the end of the source file: + require 'rubygems' + require 'sinatra' + get '/' do haml :index end - use_in_file_templates! - __END__ @@ layout - X - = yield - X + %html + = yield @@ index %div.title Hello world!!!!! +NOTE: Sinatra will automaticly load any in-file-templates in the +source file that first required sinatra. If you have in-file-templates +in another source file you will need to explicitly call ++use_in_file_templates! on main in that file. + It's also possible to define named templates using the top-level template method: template :layout do - "X\n=yield\nX" + "%html\n =yield\n" end template :index do @@ -188,10 +201,17 @@ method: haml :index end +If a template named "layout" exists, it will be used each time a template +is rendered. You can disable layouts by passing <tt>:layout => false</tt>. + + get '/' do + haml :index, :layout => !request.xhr? + end + == Helpers -The top-level <tt>helpers</tt> method takes a block and extends all -EventContext instances with the methods defined: +Use the top-level <tt>helpers</tt> method to define helper methods for use in +route blocks and templates: helpers do def bar(name) @@ -205,151 +225,127 @@ EventContext instances with the methods defined: == Filters -These are run in Sinatra::EventContext before every event. +Before filters are evaluated before each request within the context of the +request and can modify the request and response. Instance variables set in +filters are accessible by routes and templates. before do - .. this code will run before each event .. + @note = 'Hi!' + request.path_info = '/foo/bar/baz' end -== Halt! - -To immediately stop a request during a before filter or event use: - - throw :halt - -Set the body to the result of a helper method - - throw :halt, :helper_method - -Set the body to the result of a helper method after sending it parameters from -the local scope - - throw :halt, [:helper_method, foo, bar] + get '/foo/*' do + @note #=> 'Hi!' + params[:splat] #=> 'bar/baz' + end -Set the body to a simple string +== Halting - throw :halt, 'this will be the body' +To immediately stop a request during a before filter or route use: -Set status then the body + halt - throw :halt, [401, 'go away!'] +You can also specify a body when halting ... -Set the status then call a helper method with params from local scope + halt 'this will be the body' - throw :halt, [401, [:helper_method, foo, bar]] +Set the status and body ... -Run a proc inside the Sinatra::EventContext instance and set the body to the -result + halt 401, 'go away!' - throw :halt, lambda { puts 'In a proc!'; 'I just wrote to $stdout!' } +== Passing -Create you own to_result +A route can punt processing to the next matching route using the <tt>pass</tt> +statement: - class MyResultObject - def to_result(event_context, *args) - event_context.body = 'This will be the body! - end + get '/guess/:who' do + pass unless params[:who] == 'Frank' + "You got me!" end - get '/' do - throw :halt, MyResultObject.new + get '/guess/*' do + "You missed!" end -Get the gist? If you want more fun with this then checkout <tt>to_result</tt> -on Array, Symbol, Fixnum, NilClass. +The route block is immediately exited and control continues with the next +matching route. If no matching route is found, a 404 is returned. == Configuration and Reloading -Sinatra supports multiple environments and re-loading. Re-loading happens on -every request when in :development. Wrap your configurations in -<tt>configure</tt> (i.e. Database connections, Constants, etc.) to protect -them from re-loading and to only work in certain environments. +Sinatra supports multiple environments and reloading. Reloading happens +before each request when running under the <tt>:development</tt> +environment. Wrap your configurations (e.g., database connections, constants, +etc.) in <tt>configure</tt> blocks to protect them from reloading or to +target specific environments. -All environments: +Run once, at startup, in any environment: configure do - + ... end -Production +Run only when the environment (RACK_ENV environment variable) is set to +<tt>:production</tt>. configure :production do - + ... end -Two at a time: +Run when the environment (RACK_ENV environment variable) is set to +either <tt>:production</tt> or <tt>:test</tt>. configure :production, :test do - + ... end -This is also really nifty for error handling. +== Error handling -= Error handling +Error handlers run within the same context as routes and before filters, which +means you get all the goodies it has to offer, like <tt>haml</tt>, <tt>erb</tt>, +<tt>halt</tt>, etc. -== Not Found +=== Not Found -Remember: These are run inside the Sinatra::EventContext which means you get -all the goodies is has to offer (i.e. haml, erb, :halt, etc.) - -Whenever NotFound is raised this will be called +When a <tt>Sinatra::NotFound</tt> exception is raised, or the response's status +code is 404, the <tt>not_found</tt> handler is invoked: not_found do 'This is nowhere to be found' end -== Error - -By default +error+ will catch Sinatra::ServerError +=== Error -Sinatra will pass you the error via the 'sinatra.error' in request.env +The +error+ handler is invoked any time an exception is raised from a route +block or before filter. The exception object can be obtained from the +'sinatra.error' Rack variable: error do - 'Sorry there was a nasty error - ' + request.env['sinatra.error'].name + 'Sorry there was a nasty error - ' + env['sinatra.error'].name end -Custom error mapping: +Custom errors: error MyCustomError do 'So what happened was...' + request.env['sinatra.error'].message end -then if this happens: +Then, if this happens: get '/' do raise MyCustomError, 'something bad' end -you gets this: +You get this: So what happened was... something bad -one guess what this does ;) - - not_found do - 'I have no clue what you're looking for' - end - -Because Sinatra gives you a default <tt>not_found</tt> and <tt>error</tt> do -:production that are secure. If you want to customize only for :production -but want to keep the friendly helper screens for :development then do this: - - configure :production do - - not_found do - "We're so sorry, but we don't what this is" - end - - error do - "Something really nasty happened. We're on it!" - end - - end +Sinatra installs special not_found and error handlers when running under +the development environment. == Mime types -When using send_file or static files you may have mime types Sinatra doesn't -understand. Use +mime+ in those cases. +When using <tt>send_file</tt> or static files you may have mime types Sinatra +doesn't understand. Use +mime+ to register them by file extension: mime :foo, 'text/foo' @@ -360,12 +356,9 @@ interface for Ruby web frameworks. One of Rack's most interesting capabilities for application developers is support for "middleware" -- components that sit between the server and your application monitoring and/or manipulating the HTTP request/response to provide various types of common functionality. -What's more, middleware is portable between web frameworks, so middleware -components developed under, e.g., Merb, can be used with Sinatra and vice -versa. -Sinatra makes building Rack middleware pipelines a cinch via a top-level +use+ -method: +Sinatra makes building Rack middleware pipelines a cinch via a top-level ++use+ method: require 'sinatra' require 'my_custom_middleware' @@ -393,72 +386,98 @@ typically don't have to +use+ them explicitly. == Testing -=== Methods - - get_it path, params - get_it path, params.merge(:env => { 'HTTP_HOST' => 'www.sinatrarb.com' }) or - get_it path, params.merge(:env => { :host => 'www.sinatrarb.com' }) +The Sinatra::Test module includes a variety of helper methods for testing +your Sinatra app. Sinatra includes support for Test::Unit, test-spec, RSpec, +and Bacon through separate source files. -RESTful: +=== Test::Unit - post_it '/foo', '<myxml></myxml>', 'HTTP_ACCEPT' => 'application/xml' - -also works with: - - get_it, post_it, put_it, delete_it, head_it - -=== Test/Unit - - require 'my_sinatra_app' + require 'sinatra' require 'sinatra/test/unit' + require 'my_sinatra_app' class MyAppTest < Test::Unit::TestCase - def test_my_default - get_it '/' + get '/' assert_equal 'My Default Page!', @response.body end def test_with_agent - get_it '/', :agent => 'Songbird' + get '/', :agent => 'Songbird' assert_equal 'You're in Songbird!', @response.body end ... - end -=== Specs +=== Test::Spec - require 'my_sinatra_app' - require 'sinatra/test/spec' +Install the test-spec gem and require <tt>'sinatra/test/spec'</tt> before +your app: - context 'My app' + require 'sinatra' + require 'sinatra/test/spec' + require 'my_sinatra_app' - should "show a default page" do - get_it '/' + describe 'My app' do + it "should show a default page" do + get '/' should.be.ok body.should.equal 'My Default Page!' end + + ... + end + +=== RSpec + +Install the rspec gem and require <tt>'sinatra/test/rspec'</tt> before +your app: + + require 'sinatra' + require 'sinatra/test/rspec' + require 'my_sinatra_app' + + describe 'My app' do + it 'should show a default page' do + get '/' + @response.should be_ok + @response.body.should == 'My Default Page!' + end + ... end -=== Test Helpers +=== Bacon + + require 'sinatra' + require 'sinatra/test/bacon' + require 'my_sinatra_app' + + describe 'My app' do + it 'should be ok' do + get '/' + should.be.ok + body.should == 'Im OK' + end + end -See Sinatra::Test::Methods +See Sinatra::Test for more information on +get+, +post+, +put+, and +friends. == Command line -Run your sinatra file like: +Sinatra applications can be run directly: - ruby myapp.rb [options] + ruby myapp.rb [-h] [-x] [-e ENVIRONMENT] [-p PORT] [-s HANDLER] Options are: -h # help -p # set the port (default is 4567) -e # set the environment (default is development) + -s # specify rack server/handler (default is thin) -x # turn on the mutex lock (default is off) == Contributing @@ -491,7 +510,7 @@ screencasts about Git, which you can find here: http://www.gitcasts.com/ at the top of your sinatra_app.rb file: - $:.unshift File.dirname(__FILE__) + '/sinatra/lib' + $LOAD_PATH.unshift File.dirname(__FILE__) + '/sinatra/lib' require 'sinatra' get '/about' do vendor/sinatra/README.rdoc @@ -1,4 +1,6 @@ +require 'rubygems' require 'rake/clean' +require 'fileutils' task :default => :test @@ -6,13 +8,19 @@ task :default => :test desc 'Run specs with story style output' task :spec do - sh 'specrb --specdox -Ilib:test test/*_test.rb' + pattern = ENV['TEST'] || '.*' + sh "specrb --testcase '#{pattern}' --specdox -Ilib:test test/*_test.rb" end desc 'Run specs with unit test style output' -task :test => FileList['test/*_test.rb'] do |t| - suite = t.prerequisites.map{|f| "-r#{f.chomp('.rb')}"}.join(' ') - sh "ruby -Ilib:test #{suite} -e ''", :verbose => false +task :test do |t| + sh "specrb -Ilib:test test/*_test.rb" +end + +desc 'Run compatibility specs' +task :compat do |t| + pattern = ENV['TEST'] || '.*' + sh "specrb --testcase '#{pattern}' -Ilib:test compat/*_test.rb" end # PACKAGING ============================================================ @@ -49,16 +57,22 @@ file package('.gem') => %w[dist/ sinatra.gemspec] + spec.files do |f| end file package('.tar.gz') => %w[dist/] + spec.files do |f| - sh "git archive --format=tar HEAD | gzip > #{f.name}" + sh <<-SH + git archive \ + --prefix=sinatra-#{source_version}/ \ + --format=tar \ + HEAD | gzip > #{f.name} + SH end # Rubyforge Release / Publish Tasks ================================== -desc 'Publish API docs to rubyforge' +desc 'Publish website to rubyforge' task 'publish:doc' => 'doc/api/index.html' do sh 'scp -rp doc/* rubyforge.org:/var/www/gforge-projects/sinatra/' end +desc 'Publish gem and tarball to rubyforge' task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t| sh <<-end rubyforge add_release sinatra sinatra #{spec.version} #{package('.gem')} && @@ -66,34 +80,14 @@ task 'publish:gem' => [package('.gem'), package('.tar.gz')] do |t| end end -# Gemspec Helpers ==================================================== - -file 'sinatra.gemspec' => FileList['{lib,test,images}/**','Rakefile'] do |f| - # read spec file and split out manifest section - spec = File.read(f.name) - parts = spec.split(" # = MANIFEST =\n") - fail 'bad spec' if parts.length != 3 - # determine file list from git ls-files - files = `git ls-files`. - split("\n"). - sort. - reject{ |file| file =~ /^\./ }. - map{ |file| " #{file}" }. - join("\n") - # piece file back together and write... - parts[1] = " s.files = %w[\n#{files}\n ]\n" - spec = parts.join(" # = MANIFEST =\n") - File.open(f.name, 'w') { |io| io.write(spec) } - puts "updated #{f.name}" -end - -# Hanna RDoc ========================================================= -# -# Building docs requires the hanna gem: +# Website ============================================================ +# Building docs requires HAML and the hanna gem: # gem install mislav-hanna --source=http://gems.github.com +task 'doc' => ['doc:api','doc:site'] + desc 'Generate Hanna RDoc under doc/api' -task :doc => ['doc/api/index.html'] +task 'doc:api' => ['doc/api/index.html'] file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f| rb_files = f.prerequisites @@ -109,3 +103,84 @@ file 'doc/api/index.html' => FileList['lib/**/*.rb','README.rdoc'] do |f| end end CLEAN.include 'doc/api' + +def rdoc_to_html(file_name) + require 'rdoc/markup/to_html' + rdoc = RDoc::Markup::ToHtml.new + rdoc.convert(File.read(file_name)) +end + +def haml(locals={}) + require 'haml' + template = File.read('doc/template.haml') + haml = Haml::Engine.new(template, :format => :html4, :attr_wrapper => '"') + haml.render(Object.new, locals) +end + +desc 'Build website HTML and stuff' +task 'doc:site' => ['doc/index.html', 'doc/book.html'] + +file 'doc/index.html' => %w[README.rdoc doc/template.haml] do |file| + File.open(file.name, 'w') do |file| + file << haml(:title => 'Sinatra', :content => rdoc_to_html('README.rdoc')) + end +end +CLEAN.include 'doc/index.html' + +file 'doc/book.html' => ['book/output/sinatra-book.html'] do |file| + File.open(file.name, 'w') do |file| + book_content = File.read('book/output/sinatra-book.html') + file << haml(:title => 'Sinatra Book', :content => book_content) + end +end +CLEAN.include 'doc/book.html' + +file 'book/output/sinatra-book.html' => FileList['book/**'] do |f| + unless File.directory?('book') + sh 'git clone git://github.com/cschneid/sinatra-book.git book' + end + sh((<<-SH).strip.gsub(/\s+/, ' ')) + cd book && + git fetch origin && + git rebase origin/master && + thor book:build + SH +end +CLEAN.include 'book/output/sinatra-book.html' + +desc 'Build the Sinatra book' +task 'doc:book' => ['book/output/sinatra-book.html'] + +# Gemspec Helpers ==================================================== + +def source_version + line = File.read('lib/sinatra/base.rb')[/^\s*VERSION = .*/] + line.match(/.*VERSION = '(.*)'/)[1] +end + +project_files = + FileList[ + '{lib,test,compat,images}/**', + 'Rakefile', 'CHANGES', 'README.rdoc' + ] +file 'sinatra.gemspec' => project_files do |f| + # read spec file and split out manifest section + spec = File.read(f.name) + head, manifest, tail = spec.split(" # = MANIFEST =\n") + # replace version and date + head.sub!(/\.version = '.*'/, ".version = '#{source_version}'") + head.sub!(/\.date = '.*'/, ".date = '#{Date.today.to_s}'") + # determine file list from git ls-files + files = `git ls-files`. + split("\n"). + sort. + reject{ |file| file =~ /^\./ }. + reject { |file| file =~ /^doc/ }. + map{ |file| " #{file}" }. + join("\n") + # piece file back together and write... + manifest = " s.files = %w[\n#{files}\n ]\n" + spec = [head,manifest,tail].join(" # = MANIFEST =\n") + File.open(f.name, 'w') { |io| io.write(spec) } + puts "updated #{f.name}" +end vendor/sinatra/Rakefile @@ -1,1477 +1,8 @@ -require 'time' -require 'ostruct' -require 'uri' -require 'rack' +libdir = File.dirname(__FILE__) +$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir) -if ENV['SWIFT'] - require 'swiftcore/swiftiplied_mongrel' - puts "Using Swiftiplied Mongrel" -elsif ENV['EVENT'] - require 'swiftcore/evented_mongrel' - puts "Using Evented Mongrel" -end +require 'sinatra/base' +require 'sinatra/main' +require 'sinatra/compat' -module Rack #:nodoc: - - class Request #:nodoc: - - # Set of request method names allowed via the _method parameter hack. By - # default, all request methods defined in RFC2616 are included, with the - # exception of TRACE and CONNECT. - POST_TUNNEL_METHODS_ALLOWED = %w( PUT DELETE OPTIONS HEAD ) - - # Return the HTTP request method with support for method tunneling using - # the POST _method parameter hack. If the real request method is POST and - # a _method param is given and the value is one defined in - # +POST_TUNNEL_METHODS_ALLOWED+, return the value of the _method param - # instead. - def request_method - if post_tunnel_method_hack? - params['_method'].upcase - else - @env['REQUEST_METHOD'] - end - end - - def user_agent - @env['HTTP_USER_AGENT'] - end - - private - - # Return truthfully if the request is a valid verb-over-post hack. - def post_tunnel_method_hack? - @env['REQUEST_METHOD'] == 'POST' && - POST_TUNNEL_METHODS_ALLOWED.include?(self.POST.fetch('_method', '').upcase) - end - end - - module Utils - extend self - end - - module Handler - autoload :Mongrel, ::File.dirname(__FILE__) + "/sinatra/rack/handler/mongrel" - end - -end - - -module Sinatra - extend self - - VERSION = '0.3.0' - - class NotFound < RuntimeError - def self.code ; 404 ; end - end - class ServerError < RuntimeError - def self.code ; 500 ; end - end - - Result = Struct.new(:block, :params, :status) unless defined?(Result) - - def options - application.options - end - - def application - @app ||= Application.new - end - - def application=(app) - @app = app - end - - def port - application.options.port - end - - def host - application.options.host - end - - def env - application.options.env - end - - # Deprecated: use application instead of build_application. - alias :build_application :application - - def server - options.server ||= defined?(Rack::Handler::Thin) ? "thin" : "mongrel" - - # Convert the server into the actual handler name - handler = options.server.capitalize - - # If the convenience conversion didn't get us anything, - # fall back to what the user actually set. - handler = options.server unless Rack::Handler.const_defined?(handler) - - @server ||= eval("Rack::Handler::#{handler}") - end - - def run - begin - puts "== Sinatra/#{Sinatra::VERSION} has taken the stage on port #{port} for #{env} with backup by #{server.name}" - server.run(application, {:Port => port, :Host => host}) do |server| - trap(:INT) do - server.stop - puts "\n== Sinatra has ended his set (crowd applauds)" - end - end - rescue Errno::EADDRINUSE => e - puts "== Someone is already performing on port #{port}!" - end - end - - class Event - include Rack::Utils - - URI_CHAR = '[^/?:,&#\.]'.freeze unless defined?(URI_CHAR) - PARAM = /(:(#{URI_CHAR}+)|\*)/.freeze unless defined?(PARAM) - SPLAT = /(.*?)/ - attr_reader :path, :block, :param_keys, :pattern, :options - - def initialize(path, options = {}, &b) - @path = URI.encode(path) - @block = b - @param_keys = [] - @options = options - splats = 0 - regex = @path.to_s.gsub(PARAM) do |match| - if match == "*" - @param_keys << "_splat_#{splats}" - splats += 1 - SPLAT.to_s - else - @param_keys << $2 - "(#{URI_CHAR}+)" - end - end - - @pattern = /^#{regex}$/ - end - - def invoke(request) - params = {} - if agent = options[:agent] - return unless request.user_agent =~ agent - params[:agent] = $~[1..-1] - end - if host = options[:host] - return unless host === request.host - end - return unless pattern =~ request.path_info.squeeze('/') - path_params = param_keys.zip($~.captures.map{|s| unescape(s)}).to_hash - params.merge!(path_params) - splats = params.select { |k, v| k =~ /^_splat_\d+$/ }.sort.map(&:last) - unless splats.empty? - params.delete_if { |k, v| k =~ /^_splat_\d+$/ } - params["splat"] = splats - end - Result.new(block, params, 200) - end - - end - - class Error - - attr_reader :type, :block, :options - - def initialize(type, options={}, &block) - @type = type - @block = block - @options = options - end - - def invoke(request) - Result.new(block, options, code) - end - - def code - if type.respond_to?(:code) - type.code - else - 500 - end - end - - end - - class Static - include Rack::Utils - - def invoke(request) - return unless File.file?( - Sinatra.application.options.public + unescape(request.path_info) - ) - Result.new(block, {}, 200) - end - - def block - Proc.new do - send_file Sinatra.application.options.public + - unescape(request.path_info), :disposition => nil - end - end - - end - - # Methods for sending files and streams to the browser instead of rendering. - module Streaming - DEFAULT_SEND_FILE_OPTIONS = { - :type => 'application/octet-stream'.freeze, - :disposition => 'attachment'.freeze, - :stream => true, - :buffer_size => 4096 - }.freeze - - class MissingFile < RuntimeError; end - - class FileStreamer - - attr_reader :path, :options - - def initialize(path, options) - @path, @options = path, options - end - - def to_result(cx, *args) - self - end - - def each - File.open(path, 'rb') do |file| - while buf = file.read(options[:buffer_size]) - yield buf - end - end - end - - end - - protected - - # Sends the file by streaming it 4096 bytes at a time. This way the - # whole file doesn't need to be read into memory at once. This makes - # it feasible to send even large files. - # - # Be careful to sanitize the path parameter if it coming from a web - # page. send_file(params[:path]) allows a malicious user to - # download any file on your server. - # - # Options: - # * <tt>:filename</tt> - suggests a filename for the browser to use. - # Defaults to File.basename(path). - # * <tt>:type</tt> - specifies an HTTP content type. - # Defaults to 'application/octet-stream'. - # * <tt>:disposition</tt> - specifies whether the file will be shown - # inline or downloaded. Valid values are 'inline' and 'attachment' - # (default). When set to nil, the Content-Disposition and - # Content-Transfer-Encoding headers are omitted entirely. - # * <tt>:stream</tt> - whether to send the file to the user agent as it - # is read (true) or to read the entire file before sending (false). - # Defaults to true. - # * <tt>:buffer_size</tt> - specifies size (in bytes) of the buffer used - # to stream the file. Defaults to 4096. - # * <tt>:status</tt> - specifies the status code to send with the - # response. Defaults to '200 OK'. - # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value - # (See Time#httpdate) indicating the last modified time of the file. - # If the request includes an If-Modified-Since header that matches this - # value exactly, a 304 Not Modified response is sent instead of the file. - # Defaults to the file's last modified time. - # - # The default Content-Type and Content-Disposition headers are - # set to download arbitrary binary files in as many browsers as - # possible. IE versions 4, 5, 5.5, and 6 are all known to have - # a variety of quirks (especially when downloading over SSL). - # - # Simple download: - # send_file '/path/to.zip' - # - # Show a JPEG in the browser: - # send_file '/path/to.jpeg', - # :type => 'image/jpeg', - # :disposition => 'inline' - # - # Show a 404 page in the browser: - # send_file '/path/to/404.html, - # :type => 'text/html; charset=utf-8', - # :status => 404 - # - # Read about the other Content-* HTTP headers if you'd like to - # provide the user with more information (such as Content-Description). - # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11 - # - # Also be aware that the document may be cached by proxies and browsers. - # The Pragma and Cache-Control headers declare how the file may be cached - # by intermediaries. They default to require clients to validate with - # the server before releasing cached responses. See - # http://www.mnot.net/cache_docs/ for an overview of web caching and - # http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9 - # for the Cache-Control header spec. - def send_file(path, options = {}) #:doc: - raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path) - - options[:length] ||= File.size(path) - options[:filename] ||= File.basename(path) - options[:type] ||= Rack::File::MIME_TYPES[File.extname(options[:filename])[1..-1]] || 'text/plain' - options[:last_modified] ||= File.mtime(path).httpdate - send_file_headers! options - - if options[:stream] - throw :halt, [options[:status] || 200, FileStreamer.new(path, options)] - else - File.open(path, 'rb') { |file| throw :halt, [options[:status] || 200, file.read] } - end - end - - # Send binary data to the user as a file download. May set content type, - # apparent file name, and specify whether to show data inline or download - # as an attachment. - # - # Options: - # * <tt>:filename</tt> - Suggests a filename for the browser to use. - # * <tt>:type</tt> - specifies an HTTP content type. - # Defaults to 'application/octet-stream'. - # * <tt>:disposition</tt> - specifies whether the file will be shown inline - # or downloaded. Valid values are 'inline' and 'attachment' (default). - # * <tt>:status</tt> - specifies the status code to send with the response. - # Defaults to '200 OK'. - # * <tt>:last_modified</tt> - an optional RFC 2616 formatted date value (See - # Time#httpdate) indicating the last modified time of the response entity. - # If the request includes an If-Modified-Since header that matches this - # value exactly, a 304 Not Modified response is sent instead of the data. - # - # Generic data download: - # send_data buffer - # - # Download a dynamically-generated tarball: - # send_data generate_tgz('dir'), :filename => 'dir.tgz' - # - # Display an image Active Record in the browser: - # send_data image.data, - # :type => image.content_type, - # :disposition => 'inline' - # - # See +send_file+ for more information on HTTP Content-* headers and caching. - def send_data(data, options = {}) #:doc: - send_file_headers! options.merge(:length => data.size) - throw :halt, [options[:status] || 200, data] - end - - private - - def send_file_headers!(options) - options = DEFAULT_SEND_FILE_OPTIONS.merge(options) - [:length, :type, :disposition].each do |arg| - raise ArgumentError, ":#{arg} option required" unless options.key?(arg) - end - - # Send a "304 Not Modified" if the last_modified option is provided and - # matches the If-Modified-Since request header value. - if last_modified = options[:last_modified] - header 'Last-Modified' => last_modified - throw :halt, [ 304, '' ] if last_modified == request.env['HTTP_IF_MODIFIED_SINCE'] - end - - headers( - 'Content-Length' => options[:length].to_s, - 'Content-Type' => options[:type].strip # fixes a problem with extra '\r' with some browsers - ) - - # Omit Content-Disposition and Content-Transfer-Encoding headers if - # the :disposition option set to nil. - if !options[:disposition].nil? - disposition = options[:disposition].dup || 'attachment' - disposition <<= %(; filename="#{options[:filename]}") if options[:filename] - headers 'Content-Disposition' => disposition, 'Content-Transfer-Encoding' => 'binary' - end - - # Fix a problem with IE 6.0 on opening downloaded files: - # If Cache-Control: no-cache is set (which Rails does by default), - # IE removes the file it just downloaded from its cache immediately - # after it displays the "open/save" dialog, which means that if you - # hit "open" the file isn't there anymore when the application that - # is called for handling the download is run, so let's workaround that - header('Cache-Control' => 'private') if headers['Cache-Control'] == 'no-cache' - end - end - - - # Helper methods for building various aspects of the HTTP response. - module ResponseHelpers - - # Immediately halt response execution by redirecting to the resource - # specified. The +path+ argument may be an absolute URL or a path - # relative to the site root. Additional arguments are passed to the - # halt. - # - # With no integer status code, a '302 Temporary Redirect' response is - # sent. To send a permanent redirect, pass an explicit status code of - # 301: - # - # redirect '/somewhere/else', 301 - # - # NOTE: No attempt is made to rewrite the path based on application - # context. The 'Location' response header is set verbatim to the value - # provided. - def redirect(path, *args) - status(302) - header 'Location' => path - throw :halt, *args - end - - # Access or modify response headers. With no argument, return the - # underlying headers Hash. With a Hash argument, add or overwrite - # existing response headers with the values provided: - # - # headers 'Content-Type' => "text/html;charset=utf-8", - # 'Last-Modified' => Time.now.httpdate, - # 'X-UA-Compatible' => 'IE=edge' - # - # This method also available in singular form (#header). - def headers(header = nil) - @response.headers.merge!(header) if header - @response.headers - end - alias :header :headers - - # Set the content type of the response body (HTTP 'Content-Type' header). - # - # The +type+ argument may be an internet media type (e.g., 'text/html', - # 'application/xml+atom', 'image/png') or a Symbol key into the - # Rack::File::MIME_TYPES table. - # - # Media type parameters, such as "charset", may also be specified using the - # optional hash argument: - # - # get '/foo.html' do - # content_type 'text/html', :charset => 'utf-8' - # "<h1>Hello World</h1>" - # end - # - def content_type(type, params={}) - type = Rack::File::MIME_TYPES[type.to_s] if type.kind_of?(Symbol) - fail "Invalid or undefined media_type: #{type}" if type.nil? - if params.any? - params = params.collect { |kv| "%s=%s" % kv }.join(', ') - type = [ type, params ].join(";") - end - response.header['Content-Type'] = type - end - - # Set the last modified time of the resource (HTTP 'Last-Modified' header) - # and halt if conditional GET matches. The +time+ argument is a Time, - # DateTime, or other object that responds to +to_time+. - # - # When the current request includes an 'If-Modified-Since' header that - # matches the time specified, execution is immediately halted with a - # '304 Not Modified' response. - # - # Calling this method before perfoming heavy processing (e.g., lengthy - # database queries, template rendering, complex logic) can dramatically - # increase overall throughput with caching clients. - def last_modified(time) - time = time.to_time if time.respond_to?(:to_time) - time = time.httpdate if time.respond_to?(:httpdate) - response.header['Last-Modified'] = time - throw :halt, 304 if time == request.env['HTTP_IF_MODIFIED_SINCE'] - time - end - - # Set the response entity tag (HTTP 'ETag' header) and halt if conditional - # GET matches. The +value+ argument is an identifier that uniquely - # identifies the current version of the resource. The +strength+ argument - # indicates whether the etag should be used as a :strong (default) or :weak - # cache validator. - # - # When the current request includes an 'If-None-Match' header with a - # matching etag, execution is immediately halted. If the request method is - # GET or HEAD, a '304 Not Modified' response is sent. For all other request - # methods, a '412 Precondition Failed' response is sent. - # - # Calling this method before perfoming heavy processing (e.g., lengthy - # database queries, template rendering, complex logic) can dramatically - # increase overall throughput with caching clients. - # - # ==== See Also - # {RFC2616: ETag}[http://w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.19], - # ResponseHelpers#last_modified - def entity_tag(value, strength=:strong) - value = - case strength - when :strong then '"%s"' % value - when :weak then 'W/"%s"' % value - else raise TypeError, "strength must be one of :strong or :weak" - end - response.header['ETag'] = value - - # Check for If-None-Match request header and halt if match is found. - etags = (request.env['HTTP_IF_NONE_MATCH'] || '').split(/\s*,\s*/) - if etags.include?(value) || etags.include?('*') - # GET/HEAD requests: send Not Modified response - throw :halt, 304 if request.get? || request.head? - # Other requests: send Precondition Failed response - throw :halt, 412 - end - end - - alias :etag :entity_tag - - end - - module RenderingHelpers - - def render(renderer, template, options={}) - m = method("render_#{renderer}") - result = m.call(resolve_template(renderer, template, options), options) - if layout = determine_layout(renderer, template, options) - result = m.call(resolve_template(renderer, layout, options), options) { result } - end - result - end - - def determine_layout(renderer, template, options) - return if options[:layout] == false - layout_from_options = options[:layout] || :layout - resolve_template(renderer, layout_from_options, options, false) - end - - private - - def resolve_template(renderer, template, options, scream = true) - case template - when String - template - when Proc - template.call - when Symbol - if proc = templates[template] - resolve_template(renderer, proc, options, scream) - else - read_template_file(renderer, template, options, scream) - end - else - nil - end - end - - def read_template_file(renderer, template, options, scream = true) - path = File.join( - options[:views_directory] || Sinatra.application.options.views, - "#{template}.#{renderer}" - ) - unless File.exists?(path) - raise Errno::ENOENT.new(path) if scream - nil - else - File.read(path) - end - end - - def templates - Sinatra.application.templates - end - - end - - module Erb - - def erb(content, options={}) - require 'erb' - render(:erb, content, options) - end - - private - - def render_erb(content, options = {}) - locals_opt = options.delete(:locals) || {} - - locals_code = "" - locals_hash = {} - locals_opt.each do |key, value| - locals_code << "#{key} = locals_hash[:#{key}]\n" - locals_hash[:"#{key}"] = value - end - - body = ::ERB.new(content).src - eval("#{locals_code}#{body}", binding) - end - - end - - module Haml - - def haml(content, options={}) - require 'haml' - render(:haml, content, options) - end - - private - - def render_haml(content, options = {}, &b) - haml_options = (options[:options] || {}). - merge(Sinatra.options.haml || {}) - ::Haml::Engine.new(content, haml_options). - render(options[:scope] || self, options[:locals] || {}, &b) - end - - end - - # Generate valid CSS using Sass (part of Haml) - # - # Sass templates can be in external files with <tt>.sass</tt> extension - # or can use Sinatra's in_file_templates. In either case, the file can - # be rendered by passing the name of the template to the +sass+ method - # as a symbol. - # - # Unlike Haml, Sass does not support a layout file, so the +sass+ method - # will ignore both the default <tt>layout.sass</tt> file and any parameters - # passed in as <tt>:layout</tt> in the options hash. - # - # === Sass Template Files - # - # Sass templates can be stored in separate files with a <tt>.sass</tt> - # extension under the view path. - # - # Example: - # get '/stylesheet.css' do - # header 'Content-Type' => 'text/css; charset=utf-8' - # sass :stylesheet - # end - # - # The "views/stylesheet.sass" file might contain the following: - # - # body - # #admin - # :background-color #CCC - # #main - # :background-color #000 - # #form - # :border-color #AAA - # :border-width 10px - # - # And yields the following output: - # - # body #admin { - # background-color: #CCC; } - # body #main { - # background-color: #000; } - # - # #form { - # border-color: #AAA; - # border-width: 10px; } - # - # - # NOTE: Haml must be installed or a LoadError will be raised the first time an - # attempt is made to render a Sass template. - # - # See http://haml.hamptoncatlin.com/docs/rdoc/classes/Sass.html for comprehensive documentation on Sass. - module Sass - - def sass(content, options = {}) - require 'sass' - - # Sass doesn't support a layout, so we override any possible layout here - options[:layout] = false - - render(:sass, content, options) - end - - private - - def render_sass(content, options = {}) - ::Sass::Engine.new(content).render - end - - end - - # Generating conservative XML content using Builder templates. - # - # Builder templates can be inline by passing a block to the builder method, - # or in external files with +.builder+ extension by passing the name of the - # template to the +builder+ method as a Symbol. - # - # === Inline Rendering - # - # If the builder method is given a block, the block is called directly with - # an +XmlMarkup+ instance and the result is returned as String: - # get '/who.xml' do - # builder do |xml| - # xml.instruct! - # xml.person do - # xml.name "Francis Albert Sinatra", - # :aka => "Frank Sinatra" - # xml.email 'frank@capitolrecords.com' - # end - # end - # end - # - # Yields the following XML: - # <?xml version='1.0' encoding='UTF-8'?> - # <person> - # <name aka='Frank Sinatra'>Francis Albert Sinatra</name> - # <email>Frank Sinatra</email> - # </person> - # - # === Builder Template Files - # - # Builder templates can be stored in separate files with a +.builder+ - # extension under the view path. An +XmlMarkup+ object named +xml+ is - # automatically made available to template. - # - # Example: - # get '/bio.xml' do - # builder :bio - # end - # - # The "views/bio.builder" file might contain the following: - # xml.instruct! :xml, :version => '1.1' - # xml.person do - # xml.name "Francis Albert Sinatra" - # xml.aka "Frank Sinatra" - # xml.aka "Ol' Blue Eyes" - # xml.aka "The Chairman of the Board" - # xml.born 'date' => '1915-12-12' do - # xml.text! "Hoboken, New Jersey, U.S.A." - # end - # xml.died 'age' => 82 - # end - # - # And yields the following output: - # <?xml version='1.1' encoding='UTF-8'?> - # <person> - # <name>Francis Albert Sinatra</name> - # <aka>Frank Sinatra</aka> - # <aka>Ol&apos; Blue Eyes</aka> - # <aka>The Chairman of the Board</aka> - # <born date='1915-12-12'>Hoboken, New Jersey, U.S.A.</born> - # <died age='82' /> - # </person> - # - # NOTE: Builder must be installed or a LoadError will be raised the first - # time an attempt is made to render a builder template. - # - # See http://builder.rubyforge.org/ for comprehensive documentation on - # Builder. - module Builder - - def builder(content=nil, options={}, &block) - options, content = content, nil if content.is_a?(Hash) - content = Proc.new { block } if content.nil? - render(:builder, content, options) - end - - private - - def render_builder(content, options = {}, &b) - require 'builder' - xml = ::Builder::XmlMarkup.new(:indent => 2) - case content - when String - eval(content, binding, '<BUILDER>', 1) - when Proc - content.call(xml) - end - xml.target! - end - - end - - class EventContext - include Rack::Utils - include ResponseHelpers - include Streaming - include RenderingHelpers - include Erb - include Haml - include Builder - include Sass - - attr_accessor :request, :response - - attr_accessor :route_params - - def initialize(request, response, route_params) - @params = nil - @data = nil - @request = request - @response = response - @route_params = route_params - @response.body = nil - end - - def status(value=nil) - response.status = value if value - response.status - end - - def body(value=nil) - response.body = value if value - response.body - end - - def params - @params ||= - begin - hash = Hash.new {|h,k| h[k.to_s] if Symbol === k} - hash.merge! @request.params - hash.merge! @route_params - hash - end - end - - def data - @data ||= params.keys.first - end - - def stop(*args) - throw :halt, args - end - - def complete(returned) - @response.body || returned - end - - def session - request.env['rack.session'] ||= {} - end - - def reset! - @params = nil - @data = nil - end - - private - - def method_missing(name, *args, &b) - if @response.respond_to?(name) - @response.send(name, *args, &b) - else - super - end - end - - end - - - # The Application class represents the top-level working area of a - # Sinatra app. It provides the DSL for defining various aspects of the - # application and implements a Rack compatible interface for dispatching - # requests. - # - # Many of the instance methods defined in this class (#get, #post, - # #put, #delete, #layout, #before, #error, #not_found, etc.) are - # available at top-level scope. When invoked from top-level, the - # messages are forwarded to the "default application" (accessible - # at Sinatra::application). - class Application - - # Hash of event handlers with request method keys and - # arrays of potential handlers as values. - attr_reader :events - - # Hash of error handlers with error status codes as keys and - # handlers as values. - attr_reader :errors - - # Hash of template name mappings. - attr_reader :templates - - # Hash of filters with event name keys (:before) and arrays of - # handlers as values. - attr_reader :filters - - # Array of objects to clear during reload. The objects in this array - # must respond to :clear. - attr_reader :clearables - - # Object including open attribute methods for modifying Application - # configuration. - attr_reader :options - - # List of methods available from top-level scope. When invoked from - # top-level the method is forwarded to the default application - # (Sinatra::application). - FORWARD_METHODS = %w[ - get put post delete head template layout before error not_found - configures configure set set_options set_option enable disable use - development? test? production? - ] - - # Create a new Application with a default configuration taken - # from the default_options Hash. - # - # NOTE: A default Application is automatically created the first - # time any of Sinatra's DSL related methods is invoked so there - # is typically no need to create an instance explicitly. See - # Sinatra::application for more information. - def initialize - @reloading = false - @clearables = [ - @events = Hash.new { |hash, key| hash[key] = [] }, - @errors = Hash.new, - @filters = Hash.new { |hash, key| hash[key] = [] }, - @templates = Hash.new, - @middleware = [] - ] - @options = OpenStruct.new(self.class.default_options) - load_default_configuration! - end - - # Hash of default application configuration options. When a new - # Application is created, the #options object takes its initial values - # from here. - # - # Changes to the default_options Hash effect only Application objects - # created after the changes are made. For this reason, modifications to - # the default_options Hash typically occur at the very beginning of a - # file, before any DSL related functions are invoked. - def self.default_options - return @default_options unless @default_options.nil? - root = File.expand_path(File.dirname($0)) - @default_options = { - :run => true, - :port => 4567, - :host => '0.0.0.0', - :env => :development, - :root => root, - :views => root + '/views', - :public => root + '/public', - :sessions => false, - :logging => true, - :app_file => $0, - :raise_errors => false - } - load_default_options_from_command_line! - @default_options - end - - # Search ARGV for command line arguments and update the - # Sinatra::default_options Hash accordingly. This method is - # invoked the first time the default_options Hash is accessed. - # NOTE: Ignores --name so unit/spec tests can run individually - def self.load_default_options_from_command_line! #:nodoc: - # fixes issue with: gem install --test sinatra - return if ARGV.empty? || File.basename($0) =~ /gem/ - require 'optparse' - OptionParser.new do |op| - op.on('-p port') { |port| default_options[:port] = port } - op.on('-e env') { |env| default_options[:env] = env.to_sym } - op.on('-x') { default_options[:mutex] = true } - op.on('-s server') { |server| default_options[:server] = server } - end.parse!(ARGV.dup.select { |o| o !~ /--name/ }) - end - - # Determine whether the application is in the process of being - # reloaded. - def reloading? - @reloading == true - end - - # Yield to the block for configuration if the current environment - # matches any included in the +envs+ list. Always yield to the block - # when no environment is specified. - # - # NOTE: configuration blocks are not executed during reloads. - def configures(*envs, &b) - return if reloading? - yield self if envs.empty? || envs.include?(options.env) - end - - alias :configure :configures - - # When both +option+ and +value+ arguments are provided, set the option - # specified. With a single Hash argument, set all options specified in - # Hash. Options are available via the Application#options object. - # - # Setting individual options: - # set :port, 80 - # set :env, :production - # set :views, '/path/to/views' - # - # Setting multiple options: - # set :port => 80, - # :env => :production, - # :views => '/path/to/views' - # - def set(option, value=self) - if value == self && option.kind_of?(Hash) - option.each { |key,val| set(key, val) } - else - options.send("#{option}=", value) - end - end - - alias :set_option :set - alias :set_options :set - - # Enable the options specified by setting their values to true. For - # example, to enable sessions and logging: - # enable :sessions, :logging - def enable(*opts) - opts.each { |key| set(key, true) } - end - - # Disable the options specified by setting their values to false. For - # example, to disable logging and automatic run: - # disable :logging, :run - def disable(*opts) - opts.each { |key| set(key, false) } - end - - # Define an event handler for the given request method and path - # spec. The block is executed when a request matches the method - # and spec. - # - # NOTE: The #get, #post, #put, and #delete helper methods should - # be used to define events when possible. - def event(method, path, options = {}, &b) - events[method].push(Event.new(path, options, &b)).last - end - - # Define an event handler for GET requests. - def get(path, options={}, &b) - event(:get, path, options, &b) - end - - # Define an event handler for POST requests. - def post(path, options={}, &b) - event(:post, path, options, &b) - end - - # Define an event handler for HEAD requests. - def head(path, options={}, &b) - event(:head, path, options, &b) - end - - # Define an event handler for PUT requests. - # - # NOTE: PUT events are triggered when the HTTP request method is - # PUT and also when the request method is POST and the body includes a - # "_method" parameter set to "PUT". - def put(path, options={}, &b) - event(:put, path, options, &b) - end - - # Define an event handler for DELETE requests. - # - # NOTE: DELETE events are triggered when the HTTP request method is - # DELETE and also when the request method is POST and the body includes a - # "_method" parameter set to "DELETE". - def delete(path, options={}, &b) - event(:delete, path, options, &b) - end - - # Visits and invokes each handler registered for the +request_method+ in - # definition order until a Result response is produced. If no handler - # responds with a Result, the NotFound error handler is invoked. - # - # When the request_method is "HEAD" and no valid Result is produced by - # the set of handlers registered for HEAD requests, an attempt is made to - # invoke the GET handlers to generate the response before resorting to the - # default error handler. - def lookup(request) - method = request.request_method.downcase.to_sym - events[method].eject(&[:invoke, request]) || - (events[:get].eject(&[:invoke, request]) if method == :head) || - errors[NotFound].invoke(request) - end - - # Define a named template. The template may be referenced from - # event handlers by passing the name as a Symbol to rendering - # methods. The block is executed each time the template is rendered - # and the resulting object is passed to the template handler. - # - # The following example defines a HAML template named hello and - # invokes it from an event handler: - # - # template :hello do - # "h1 Hello World!" - # end - # - # get '/' do - # haml :hello - # end - # - def template(name, &b) - templates[name] = b - end - - # Define a layout template. - def layout(name=:layout, &b) - template(name, &b) - end - - # Define a custom error handler for the exception class +type+. The block - # is invoked when the specified exception type is raised from an error - # handler and can manipulate the response as needed: - # - # error MyCustomError do - # status 500 - # 'So what happened was...' + request.env['sinatra.error'].message - # end - # - # The Sinatra::ServerError handler is used by default when an exception - # occurs and no matching error handler is found. - def error(type=ServerError, options = {}, &b) - errors[type] = Error.new(type, options, &b) - end - - # Define a custom error handler for '404 Not Found' responses. This is a - # shorthand for: - # error NotFound do - # .. - # end - def not_found(options={}, &b) - error NotFound, options, &b - end - - # Define a request filter. When <tt>type</tt> is <tt>:before</tt>, execute the - # block in the context of each request before matching event handlers. - def filter(type, &b) - filters[type] << b - end - - # Invoke the block in the context of each request before invoking - # matching event handlers. - def before(&b) - filter :before, &b - end - - # True when environment is :development. - def development? ; options.env == :development ; end - - # True when environment is :test. - def test? ; options.env == :test ; end - - # True when environment is :production. - def production? ; options.env == :production ; end - - # Clear all events, templates, filters, and error handlers - # and then reload the application source file. This occurs - # automatically before each request is processed in development. - def reload! - clearables.each(&:clear) - load_default_configuration! - load_development_configuration! if development? - @pipeline = nil - @reloading = true - Kernel.load options.app_file - @reloading = false - end - - # Determine whether the application is in the process of being - # reloaded. - def reloading? - @reloading == true - end - - # Mutex instance used for thread synchronization. - def mutex - @@mutex ||= Mutex.new - end - - # Yield to the block with thread synchronization - def run_safely - if development? || options.mutex - mutex.synchronize { yield } - else - yield - end - end - - # Add a piece of Rack middleware to the pipeline leading to the - # application. - def use(klass, *args, &block) - fail "#{klass} must respond to 'new'" unless klass.respond_to?(:new) - @pipeline = nil - @middleware.push([ klass, args, block ]).last - end - - private - - # Rack middleware derived from current state of application options. - # These components are plumbed in at the very beginning of the - # pipeline. - def optional_middleware - [ - ([ Rack::CommonLogger, [], nil ] if options.logging), - ([ Rack::Session::Cookie, [], nil ] if options.sessions) - ].compact - end - - # Rack middleware explicitly added to the application with #use. These - # components are plumbed into the pipeline downstream from - # #optional_middle. - def explicit_middleware - @middleware - end - - # All Rack middleware used to construct the pipeline. - def middleware - optional_middleware + explicit_middleware - end - - public - - # An assembled pipeline of Rack middleware that leads eventually to - # the Application#invoke method. The pipeline is built upon first - # access. Defining new middleware with Application#use or manipulating - # application options may cause the pipeline to be rebuilt. - def pipeline - @pipeline ||= - middleware.inject(method(:dispatch)) do |app,(klass,args,block)| - klass.new(app, *args, &block) - end - end - - # Rack compatible request invocation interface. - def call(env) - run_safely do - reload! if development? && (options.reload != false) - pipeline.call(env) - end - end - - # Request invocation handler - called at the end of the Rack pipeline - # for each request. - # - # 1. Create Rack::Request, Rack::Response helper objects. - # 2. Lookup event handler based on request method and path. - # 3. Create new EventContext to house event handler evaluation. - # 4. Invoke each #before filter in context of EventContext object. - # 5. Invoke event handler in context of EventContext object. - # 6. Return response to Rack. - # - # See the Rack specification for detailed information on the - # +env+ argument and return value. - def dispatch(env) - request = Rack::Request.new(env) - context = EventContext.new(request, Rack::Response.new([], 200), {}) - begin - returned = - catch(:halt) do - filters[:before].each { |f| context.instance_eval(&f) } - result = lookup(context.request) - context.route_params = result.params - context.response.status = result.status - context.reset! - [:complete, context.instance_eval(&result.block)] - end - body = returned.to_result(context) - rescue => e - request.env['sinatra.error'] = e - context.status(500) - raise if options.raise_errors && e.class != NotFound - result = (errors[e.class] || errors[ServerError]).invoke(request) - returned = - catch(:halt) do - [:complete, context.instance_eval(&result.block)] - end - body = returned.to_result(context) - end - body = '' unless body.respond_to?(:each) - body = '' if request.env["REQUEST_METHOD"].upcase == 'HEAD' - context.body = body.kind_of?(String) ? [*body] : body - context.finish - end - - private - - # Called immediately after the application is initialized or reloaded to - # register default events, templates, and error handlers. - def load_default_configuration! - events[:get] << Static.new - configure do - error do - '<h1>Internal Server Error</h1>' - end - not_found { '<h1>Not Found</h1>'} - end - end - - # Called before reloading to perform development specific configuration. - def load_development_configuration! - get '/sinatra_custom_images/:image.png' do - content_type :png - File.read(File.dirname(__FILE__) + "/../images/#{params[:image]}.png") - end - - not_found do - (<<-HTML).gsub(/^ {8}/, '') - <!DOCTYPE html> - <html> - <head> - <style type="text/css"> - body {text-align:center;color:#888;font-family:arial;font-size:22px;margin:20px;} - #content {margin:0 auto;width:500px;text-align:left} - </style> - </head> - <body> - <h2>Sinatra doesn't know this diddy.</h2> - <img src='/sinatra_custom_images/404.png'> - <div id="content"> - Try this: - <pre>#{request.request_method.downcase} "#{request.path_info}" do\n .. do something ..\nend<pre> - </div> - </body> - </html> - HTML - end - - error do - @error = request.env['sinatra.error'] - (<<-HTML).gsub(/^ {8}/, '') - <!DOCTYPE html> - <html> - <head> - <style type="text/css" media="screen"> - body {font-family:verdana;color:#333} - #content {width:700px;margin-left:20px} - #content h1 {width:99%;color:#1D6B8D;font-weight:bold} - #stacktrace {margin-top:-20px} - #stacktrace pre {font-size:12px;border-left:2px solid #ddd;padding-left:10px} - #stacktrace img {margin-top:10px} - </style> - </head> - <body> - <div id="content"> - <img src="/sinatra_custom_images/500.png"> - <div class="info"> - Params: <pre>#{params.inspect}</pre> - </div> - <div id="stacktrace"> - <h1>#{escape_html(@error.class.name + ' - ' + @error.message.to_s)}</h1> - <pre><code>#{escape_html(@error.backtrace.join("\n"))}</code></pre> - </div> - </div> - </body> - </html> - HTML - end - end - - end - -end - -# Delegate DSLish methods to the currently active Sinatra::Application -# instance. -Sinatra::Application::FORWARD_METHODS.each do |method| - eval(<<-EOS, binding, '(__DSL__)', 1) - def #{method}(*args, &b) - Sinatra.application.#{method}(*args, &b) - end - EOS -end - -def helpers(&b) - Sinatra::EventContext.class_eval(&b) -end - -def use_in_file_templates! - require 'stringio' - templates = IO.read(caller.first.split(':').first).split('__FILE__').last - data = StringIO.new(templates) - current_template = nil - data.each do |line| - if line =~ /^@@\s?(.*)/ - current_template = $1.to_sym - Sinatra.application.templates[current_template] = '' - elsif current_template - Sinatra.application.templates[current_template] << line - end - end -end - -def mime(ext, type) - Rack::File::MIME_TYPES[ext.to_s] = type -end - -### Misc Core Extensions - -module Kernel - def silence_warnings - old_verbose, $VERBOSE = $VERBOSE, nil - yield - ensure - $VERBOSE = old_verbose - end -end - -class Symbol - def to_proc - Proc.new { |*args| args.shift.__send__(self, *args) } - end -end - -class Array - def to_hash - self.inject({}) { |h, (k, v)| h[k] = v; h } - end - def to_proc - Proc.new { |*args| args.shift.__send__(self[0], *(args + self[1..-1])) } - end -end - -module Enumerable - def eject(&block) - find { |e| result = block[e] and break result } - end -end - -### Core Extension results for throw :halt - -class Proc - def to_result(cx, *args) - cx.instance_eval(&self) - args.shift.to_result(cx, *args) - end -end - -class String - def to_result(cx, *args) - args.shift.to_result(cx, *args) - self - end -end - -class Array - def to_result(cx, *args) - self.shift.to_result(cx, *self) - end -end - -class Symbol - def to_result(cx, *args) - cx.send(self, *args) - end -end - -class Fixnum - def to_result(cx, *args) - cx.status self - args.shift.to_result(cx, *args) - end -end - -class NilClass - def to_result(cx, *args) - '' - end -end - -at_exit do - raise $! if $! - if Sinatra.application.options.run - Sinatra.run - end -end - -mime :xml, 'application/xml' -mime :js, 'application/javascript' -mime :png, 'image/png' +use_in_file_templates! vendor/sinatra/lib/sinatra.rb @@ -1,10 +1,9 @@ -require File.dirname(__FILE__) + '/unit' +require 'sinatra/test' require 'spec/interop/test' -class Test::Unit::TestCase - - def should - @response.should - end - -end +Sinatra::Default.set( + :env => :test, + :run => false, + :raise_errors => true, + :logging => false +) vendor/sinatra/lib/sinatra/test/rspec.rb @@ -1,10 +1,9 @@ -require File.dirname(__FILE__) + '/unit' require 'test/spec' +require 'sinatra/test' +require 'sinatra/test/unit' -class Test::Unit::TestCase - +module Sinatra::Test def should @response.should end - end vendor/sinatra/lib/sinatra/test/spec.rb @@ -1,13 +1,11 @@ +require 'sinatra/test' require 'test/unit' -require File.dirname(__FILE__) + '/methods' -Test::Unit::TestCase.send(:include, Sinatra::Test::Methods) +Test::Unit::TestCase.send :include, Sinatra::Test -Sinatra::Application.default_options.merge!( +Sinatra::Default.set( :env => :test, :run => false, :raise_errors => true, :logging => false ) - -Sinatra.application = nil vendor/sinatra/lib/sinatra/test/unit.rb @@ -3,74 +3,106 @@ 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.3.0' - s.date = "2008-08-31" + s.version = '0.9.0.2' + s.date = '2009-01-18' s.description = "Classy web-development dressed in a DSL" s.summary = "Classy web-development dressed in a DSL" s.authors = ["Blake Mizerany"] + s.email = "sinatrarb@googlegroups.com" # = MANIFEST = s.files = %w[ - ChangeLog + AUTHORS + CHANGES LICENSE README.rdoc Rakefile - images/404.png - images/500.png + compat/app_test.rb + compat/application_test.rb + compat/builder_test.rb + compat/custom_error_test.rb + compat/erb_test.rb + compat/events_test.rb + compat/filter_test.rb + compat/haml_test.rb + compat/helper.rb + compat/mapped_error_test.rb + compat/pipeline_test.rb + compat/public/foo.xml + compat/sass_test.rb + compat/sessions_test.rb + compat/streaming_test.rb + compat/sym_params_test.rb + compat/template_test.rb + compat/use_in_file_templates_test.rb + compat/views/foo.builder + compat/views/foo.erb + compat/views/foo.haml + compat/views/foo.sass + compat/views/foo_layout.erb + compat/views/foo_layout.haml + compat/views/layout_test/foo.builder + compat/views/layout_test/foo.erb + compat/views/layout_test/foo.haml + compat/views/layout_test/foo.sass + compat/views/layout_test/layout.builder + compat/views/layout_test/layout.erb + compat/views/layout_test/layout.haml + compat/views/layout_test/layout.sass + compat/views/no_layout/no_layout.builder + compat/views/no_layout/no_layout.haml lib/sinatra.rb - lib/sinatra/rack/handler/mongrel.rb - lib/sinatra/test/methods.rb + lib/sinatra/base.rb + lib/sinatra/compat.rb + lib/sinatra/images/404.png + lib/sinatra/images/500.png + lib/sinatra/main.rb + lib/sinatra/test.rb + lib/sinatra/test/bacon.rb lib/sinatra/test/rspec.rb lib/sinatra/test/spec.rb lib/sinatra/test/unit.rb sinatra.gemspec - test/app_test.rb - test/application_test.rb + test/base_test.rb test/builder_test.rb - test/custom_error_test.rb + test/data/reload_app_file.rb test/erb_test.rb - test/event_context_test.rb - test/events_test.rb test/filter_test.rb test/haml_test.rb test/helper.rb + test/helpers_test.rb test/mapped_error_test.rb - test/pipeline_test.rb - test/public/foo.xml + test/middleware_test.rb + test/options_test.rb + test/reload_test.rb + test/request_test.rb + test/result_test.rb + test/routing_test.rb test/sass_test.rb - test/sessions_test.rb - test/streaming_test.rb - test/sym_params_test.rb - test/template_test.rb - test/use_in_file_templates_test.rb - test/views/foo.builder - test/views/foo.erb - test/views/foo.haml - test/views/foo.sass - test/views/foo_layout.erb - test/views/foo_layout.haml - test/views/layout_test/foo.builder - test/views/layout_test/foo.erb - test/views/layout_test/foo.haml - test/views/layout_test/foo.sass - test/views/layout_test/layout.builder - test/views/layout_test/layout.erb - test/views/layout_test/layout.haml - test/views/layout_test/layout.sass - test/views/no_layout/no_layout.builder - test/views/no_layout/no_layout.haml + test/sinatra_test.rb + test/static_test.rb + test/templates_test.rb + test/views/hello.builder + test/views/hello.erb + test/views/hello.haml + test/views/hello.sass + test/views/hello.test + test/views/layout2.builder + test/views/layout2.erb + test/views/layout2.haml + test/views/layout2.test ] # = MANIFEST = s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/} s.extra_rdoc_files = %w[README.rdoc LICENSE] - s.add_dependency 'rack', '>= 0.4.0' + s.add_dependency 'rack', '>= 0.9.1' s.has_rdoc = true - s.homepage = "http://sinatrarb.com" + s.homepage = "http://sinatra.rubyforge.org" s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sinatra", "--main", "README.rdoc"] s.require_paths = %w[lib] s.rubyforge_project = 'sinatra' vendor/sinatra/sinatra.gemspec @@ -1,101 +1,64 @@ require File.dirname(__FILE__) + '/helper' -context "Builder" do - - setup do - Sinatra.application = nil +describe "Builder Templates" do + def builder_app(&block) + mock_app { + set :views, File.dirname(__FILE__) + '/views' + get '/', &block + } + get '/' end - context "without layouts" do - - setup do - Sinatra.application = nil - end - - specify "should render" do - - get '/no_layout' do - builder 'xml.instruct!' - end - - get_it '/no_layout' - should.be.ok - body.should == %(<?xml version="1.0" encoding="UTF-8"?>\n) - - end - - specify "should render inline block" do - - get '/no_layout_and_inlined' do - @name = "Frank & Mary" - builder do |xml| - xml.couple @name - end - end - - get_it '/no_layout_and_inlined' - should.be.ok - body.should == %(<couple>Frank &amp; Mary</couple>\n) - - end - + it 'renders inline Builder strings' do + builder_app { builder 'xml.instruct!' } + assert ok? + assert_equal %{<?xml version="1.0" encoding="UTF-8"?>\n}, body end - - - context "Templates (in general)" do - - setup do - Sinatra.application = nil - end - - specify "are read from files if Symbols" do - - get '/from_file' do - @name = 'Blue' - builder :foo, :views_directory => File.dirname(__FILE__) + "/views" + it 'renders inline blocks' do + builder_app { + @name = "Frank & Mary" + builder do |xml| + xml.couple @name end + } + assert ok? + assert_equal "<couple>Frank &amp; Mary</couple>\n", body + end - get_it '/from_file' - should.be.ok - body.should.equal %(<exclaim>You rock Blue!</exclaim>\n) - - end - - specify "use layout.ext by default if available" do - - get '/' do - builder :foo, :views_directory => File.dirname(__FILE__) + "/views/layout_test" - end - - get_it '/' - should.be.ok - body.should.equal "<layout>\n<this>is foo!</this>\n</layout>\n" - - end - - specify "renders without layout" do - - get '/' do - builder :no_layout, :views_directory => File.dirname(__FILE__) + "/views/no_layout" - end - - get_it '/' - should.be.ok - body.should.equal "<foo>No Layout!</foo>\n" - - end - - specify "raises error if template not found" do + it 'renders .builder files in views path' do + builder_app { + @name = "Blue" + builder :hello + } + assert ok? + assert_equal %(<exclaim>You're my boy, Blue!</exclaim>\n), body + end - get '/' do - builder :not_found + it "renders with inline layouts" do + mock_app { + layout do + %(xml.layout { xml << yield }) end + get('/') { builder %(xml.em 'Hello World') } + } + get '/' + assert ok? + assert_equal "<layout>\n<em>Hello World</em>\n</layout>\n", body + end - lambda { get_it '/' }.should.raise(Errno::ENOENT) - - end - + it "renders with file layouts" do + builder_app { + builder %(xml.em 'Hello World'), :layout => :layout2 + } + assert ok? + assert_equal "<layout>\n<em>Hello World</em>\n</layout>\n", body end + it "raises error if template not found" do + mock_app { + get('/') { builder :no_such_template } + } + assert_raise(Errno::ENOENT) { get('/') } + end end vendor/sinatra/test/builder_test.rb @@ -1,136 +1,50 @@ require File.dirname(__FILE__) + '/helper' -context "Erb" do - - setup do - Sinatra.application = nil +describe "ERB Templates" do + def erb_app(&block) + mock_app { + set :views, File.dirname(__FILE__) + '/views' + get '/', &block + } + get '/' end - context "without layouts" do - - setup do - Sinatra.application = nil - end - - specify "should render" do - - get '/no_layout' do - erb '<%= 1 + 1 %>' - end - - get_it '/no_layout' - should.be.ok - body.should == '2' - - end - - specify "should take an options hash with :locals set with a string" do - get '/locals' do - erb '<%= foo %>', :locals => {:foo => "Bar"} - end - - get_it '/locals' - should.be.ok - body.should == 'Bar' - end - - specify "should take an options hash with :locals set with a complex object" do - get '/locals-complex' do - erb '<%= foo[0] %>', :locals => {:foo => ["foo", "bar", "baz"]} - end - - get_it '/locals-complex' - should.be.ok - body.should == 'foo' - end + it 'renders inline ERB strings' do + erb_app { erb '<%= 1 + 1 %>' } + assert ok? + assert_equal '2', body end - context "with layouts" do - - setup do - Sinatra.application = nil - end - - specify "can be inline" do - - layout do - %Q{This is <%= yield %>!} - end - - get '/lay' do - erb 'Blake' - end - - get_it '/lay' - should.be.ok - body.should.equal 'This is Blake!' - - end - - specify "can use named layouts" do - - layout :pretty do - %Q{<h1><%= yield %></h1>} - end - - get '/pretty' do - erb 'Foo', :layout => :pretty - end - - get '/not_pretty' do - erb 'Bar' - end - - get_it '/pretty' - body.should.equal '<h1>Foo</h1>' - - get_it '/not_pretty' - body.should.equal 'Bar' - - end - - specify "can be read from a file if they're not inlined" do - - get '/foo' do - @title = 'Welcome to the Hello Program' - erb 'Blake', :layout => :foo_layout, - :views_directory => File.dirname(__FILE__) + "/views" - end - - get_it '/foo' - body.should.equal "Welcome to the Hello Program\nHi Blake\n" - - end - + it 'renders .erb files in views path' do + erb_app { erb :hello } + assert ok? + assert_equal "Hello World\n", body end - context "Templates (in general)" do - - specify "are read from files if Symbols" do - - get '/from_file' do - @name = 'Alena' - erb :foo, :views_directory => File.dirname(__FILE__) + "/views" - end - - get_it '/from_file' - - body.should.equal 'You rock Alena!' - - end - - specify "use layout.ext by default if available" do - - get '/layout_from_file' do - erb :foo, :views_directory => File.dirname(__FILE__) + "/views/layout_test" - end - - get_it '/layout_from_file' - should.be.ok - body.should.equal "x This is foo! x \n" - - end + it 'takes a :locals option' do + erb_app { + locals = {:foo => 'Bar'} + erb '<%= foo %>', :locals => locals + } + assert ok? + assert_equal 'Bar', body + end + it "renders with inline layouts" do + mock_app { + layout { 'THIS. IS. <%= yield.upcase %>!' } + get('/') { erb 'Sparta' } + } + get '/' + assert ok? + assert_equal 'THIS. IS. SPARTA!', body end + it "renders with file layouts" do + erb_app { + erb 'Hello World', :layout => :layout2 + } + assert ok? + assert_equal "ERB Layout!\nHello World\n", body + end end vendor/sinatra/test/erb_test.rb @@ -1,30 +1,75 @@ require File.dirname(__FILE__) + '/helper' -context "before filters" do +describe "Filters" do + it "executes filters in the order defined" do + count = 0 + mock_app do + get('/') { 'Hello World' } + before { + assert_equal 0, count + count = 1 + } + before { + assert_equal 1, count + count = 2 + } + end - setup do - Sinatra.application = nil - @app = Sinatra.application + get '/' + assert ok? + assert_equal 2, count + assert_equal 'Hello World', body end - specify "should be executed in the order defined" do - invoked = 0x0 - @app.before { invoked = 0x01 } - @app.before { invoked |= 0x02 } - @app.get('/') { 'Hello World' } - get_it '/' - should.be.ok - body.should.be == 'Hello World' - invoked.should.be == 0x03 + it "allows filters to modify the request" do + mock_app { + get('/foo') { 'foo' } + get('/bar') { 'bar' } + before { request.path_info = '/bar' } + } + + get '/foo' + assert ok? + assert_equal 'bar', body end - specify "should be capable of modifying the request" do - @app.get('/foo') { 'foo' } - @app.get('/bar') { 'bar' } - @app.before { request.path_info = '/bar' } - get_it '/foo' - should.be.ok - body.should.be == 'bar' + it "can modify instance variables available to routes" do + mock_app { + before { @foo = 'bar' } + get('/foo') { @foo } + } + + get '/foo' + assert ok? + assert_equal 'bar', body end + it "allows redirects in filters" do + mock_app { + before { redirect '/bar' } + get('/foo') do + fail 'before block should have halted processing' + 'ORLY?!' + end + } + + get '/foo' + assert redirect? + assert_equal '/bar', response['Location'] + assert_equal '', body + end + + it "does not modify the response with its return value" do + mock_app { + before { 'Hello World!' } + get '/foo' do + assert_equal [], response.body + 'cool' + end + } + + get '/foo' + assert ok? + assert_equal 'cool', body + end end vendor/sinatra/test/filter_test.rb @@ -1,233 +1,68 @@ require File.dirname(__FILE__) + '/helper' -context "Haml" do - - setup do - Sinatra.application = nil +describe "HAML Templates" do + def haml_app(&block) + mock_app { + set :views, File.dirname(__FILE__) + '/views' + get '/', &block + } + get '/' end - context "without layouts" do - - setup do - Sinatra.application = nil - end - - specify "should render" do - - get '/no_layout' do - haml '== #{1+1}' - end - - get_it '/no_layout' - should.be.ok - body.should == "2\n" - - end + it 'renders inline HAML strings' do + haml_app { haml '%h1 Hiya' } + assert ok? + assert_equal "<h1>Hiya</h1>\n", body end - context "with layouts" do - - setup do - Sinatra.application = nil - end - - specify "can be inline" do - - layout do - '== This is #{yield}!' - end - - get '/lay' do - haml 'Blake' - end - - get_it '/lay' - should.be.ok - body.should.equal "This is Blake\n!\n" - - end - - specify "can use named layouts" do - - layout :pretty do - '%h1== #{yield}' - end - - get '/pretty' do - haml 'Foo', :layout => :pretty - end - - get '/not_pretty' do - haml 'Bar' - end - - get_it '/pretty' - body.should.equal "<h1>Foo</h1>\n" - - get_it '/not_pretty' - body.should.equal "Bar\n" - - end - - specify "can be read from a file if they're not inlined" do - - get '/foo' do - @title = 'Welcome to the Hello Program' - haml 'Blake', :layout => :foo_layout, - :views_directory => File.dirname(__FILE__) + "/views" - end - - get_it '/foo' - body.should.equal "Welcome to the Hello Program\nHi Blake\n" - - end - - specify "can be read from file and layout from text" do - get '/foo' do - haml 'Test', :layout => '== Foo #{yield}' - end - - get_it '/foo' - - body.should.equal "Foo Test\n" - end - + it 'renders .haml files in views path' do + haml_app { haml :hello } + assert ok? + assert_equal "<h1>Hello From Haml</h1>\n", body end - context "Templates (in general)" do - - setup do - Sinatra.application = nil - end - - specify "are read from files if Symbols" do - - get '/from_file' do - @name = 'Alena' - haml :foo, :views_directory => File.dirname(__FILE__) + "/views" - end - - get_it '/from_file' - - body.should.equal "You rock Alena!\n" - - end - - specify "use layout.ext by default if available" do - - get '/' do - haml :foo, :views_directory => File.dirname(__FILE__) + "/views/layout_test" - end - - get_it '/' - should.be.ok - body.should.equal "x This is foo!\n x\n" - - end - - specify "renders without layout" do - - get '/' do - haml :no_layout, :views_directory => File.dirname(__FILE__) + "/views/no_layout" - end - - get_it '/' - should.be.ok - body.should.equal "<h1>No Layout!</h1>\n" - - end - - specify "can render with no layout" do - layout do - "X\n= yield\nX" - end - - get '/' do - haml 'blake', :layout => false - end - - get_it '/' - - body.should.equal "blake\n" - end - - specify "raises error if template not found" do - get '/' do - haml :not_found - end - - lambda { get_it '/' }.should.raise(Errno::ENOENT) - end - - specify "use layout.ext by default if available" do - - template :foo do - 'asdf' - end - - get '/' do - haml :foo, :layout => false, - :views_directory => File.dirname(__FILE__) + "/views/layout_test" - end - - get_it '/' - should.be.ok - body.should.equal "asdf\n" - - end - + it "renders with inline layouts" do + mock_app { + layout { %q(%h1= 'THIS. IS. ' + yield.upcase) } + get('/') { haml '%em Sparta' } + } + get '/' + assert ok? + assert_equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>\n", body end - describe 'Options passed to the HAML interpreter' do - setup do - Sinatra.application = nil - end - - specify 'are empty be default' do - - get '/' do - haml 'foo' - end - - Haml::Engine.expects(:new).with('foo', {}).returns(stub(:render => 'foo')) - - get_it '/' - should.be.ok - - end - - specify 'can be configured by passing :options to haml' do - - get '/' do - haml 'foo', :options => {:format => :html4} - end - - Haml::Engine.expects(:new).with('foo', {:format => :html4}).returns(stub(:render => 'foo')) - - get_it '/' - should.be.ok - - end + it "renders with file layouts" do + haml_app { + haml 'Hello World', :layout => :layout2 + } + assert ok? + assert_equal "<h1>HAML Layout!</h1>\n<p>Hello World</p>\n", body + end - specify 'can be configured using set_option :haml' do + it "raises error if template not found" do + mock_app { + get('/') { haml :no_such_template } + } + assert_raise(Errno::ENOENT) { get('/') } + end - configure do - set_option :haml, :format => :html4, - :escape_html => true - end + it "passes HAML options to the Haml engine" do + haml_app { + haml "!!!\n%h1 Hello World", :options => {:format => :html5} + } + assert ok? + assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body + end + it "passes default HAML options to the Haml engine" do + mock_app { + set :haml, {:format => :html5} get '/' do - haml 'foo' + haml "!!!\n%h1 Hello World" end - - Haml::Engine.expects(:new).with('foo', {:format => :html4, - :escape_html => true}).returns(stub(:render => 'foo')) - - get_it '/' - should.be.ok - - end - + } + get '/' + assert ok? + assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body end - end vendor/sinatra/test/haml_test.rb @@ -1,7 +1,25 @@ -require 'rubygems' -require 'mocha' +begin + require 'test/spec' +rescue LoadError + require 'rubygems' + require 'test/spec' +end -$:.unshift File.dirname(File.dirname(__FILE__)) + "/lib" - -require 'sinatra' +$:.unshift File.dirname(File.dirname(__FILE__)) + '/lib' +require 'sinatra/base' +require 'sinatra/test' require 'sinatra/test/spec' + +module Sinatra::Test + # Sets up a Sinatra::Base subclass defined with the block + # given. Used in setup or individual spec methods to establish + # the application. + def mock_app(base=Sinatra::Base, &block) + @app = Sinatra.new(base, &block) + end +end + +class Sinatra::Base + # Allow assertions in request context + include Test::Unit::Assertions +end vendor/sinatra/test/helper.rb @@ -1,72 +1,160 @@ require File.dirname(__FILE__) + '/helper' -class FooError < RuntimeError; end - -context "Mapped errors" do - - setup do - Sinatra.application = nil - Sinatra.application.options.raise_errors = false +describe 'Exception Mappings' do + class FooError < RuntimeError end - specify "are rescued and run in context" do - - error FooError do - 'MAPPED ERROR!' - end - - get '/' do - raise FooError - end - - get_it '/' - - should.be.server_error - body.should.equal 'MAPPED ERROR!' - + it 'invokes handlers registered with ::error when raised' do + mock_app { + set :raise_errors, false + error(FooError) { 'Foo!' } + get '/' do + raise FooError + end + } + get '/' + assert_equal 500, status + assert_equal 'Foo!', body end - specify "renders empty if no each method on result" do + it 'uses the Exception handler if no matching handler found' do + mock_app { + set :raise_errors, false + error(Exception) { 'Exception!' } + get '/' do + raise FooError + end + } + get '/' + assert_equal 500, status + assert_equal 'Exception!', body + end - error FooError do - nil - end + it "sets env['sinatra.error'] to the rescued exception" do + mock_app { + set :raise_errors, false + error(FooError) { + assert env.include?('sinatra.error') + assert env['sinatra.error'].kind_of?(FooError) + 'looks good' + } + get '/' do + raise FooError + end + } + get '/' + assert_equal 'looks good', body + end - get '/' do - raise FooError - end + it 'dumps errors to rack.errors when dump_errors is enabled' do + mock_app { + set :raise_errors, false + set :dump_errors, true + get('/') { raise FooError, 'BOOM!' } + } - get_it '/' + get '/' + assert_equal 500, status + assert @response.errors =~ /FooError - BOOM!:/ + end - should.be.server_error - body.should.be.empty + it "raises without calling the handler when the raise_errors options is set" do + mock_app { + set :raise_errors, true + error(FooError) { "she's not there." } + get '/' do + raise FooError + end + } + assert_raise(FooError) { get '/' } + end + it "never raises Sinatra::NotFound beyond the application" do + mock_app { + set :raise_errors, true + get '/' do + raise Sinatra::NotFound + end + } + assert_nothing_raised { get '/' } + assert_equal 404, status end - specify "doesn't override status if set" do + class FooNotFound < Sinatra::NotFound + end - error FooError do - status(200) - end + it "cascades for subclasses of Sinatra::NotFound" do + mock_app { + set :raise_errors, true + error(FooNotFound) { "foo! not found." } + get '/' do + raise FooNotFound + end + } + assert_nothing_raised { get '/' } + assert_equal 404, status + assert_equal 'foo! not found.', body + end - get '/' do - raise FooError - end + it 'has a not_found method for backwards compatibility' do + mock_app { + not_found do + "Lost, are we?" + end + } - get_it '/' + get '/test' + assert_equal 404, status + assert_equal "Lost, are we?", body + end +end - should.be.ok +describe 'Custom Error Pages' do + it 'allows numeric status code mappings to be registered with ::error' do + mock_app { + set :raise_errors, false + error(500) { 'Foo!' } + get '/' do + [500, {}, 'Internal Foo Error'] + end + } + get '/' + assert_equal 500, status + assert_equal 'Foo!', body + end + it 'allows ranges of status code mappings to be registered with :error' do + mock_app { + set :raise_errors, false + error(500..550) { "Error: #{response.status}" } + get '/' do + [507, {}, 'A very special error'] + end + } + get '/' + assert_equal 507, status + assert_equal 'Error: 507', body end - specify "raises errors when the raise_errors option is set" do - Sinatra.application.options.raise_errors = true - error FooError do - end - get '/' do - raise FooError - end - assert_raises(FooError) { get_it('/') } + class FooError < RuntimeError end + it 'runs after exception mappings and overwrites body' do + mock_app { + set :raise_errors, false + error FooError do + response.status = 502 + 'from exception mapping' + end + error(500) { 'from 500 handler' } + error(502) { 'from custom error page' } + + get '/' do + raise FooError + end + } + get '/' + assert_equal 502, status + assert_equal 'from custom error page', body + end end vendor/sinatra/test/mapped_error_test.rb @@ -1,57 +1,36 @@ require File.dirname(__FILE__) + '/helper' -context "Sass" do - - setup do - Sinatra.application = nil +describe "Sass Templates" do + def sass_app(&block) + mock_app { + set :views, File.dirname(__FILE__) + '/views' + get '/', &block + } + get '/' end - context "Templates (in general)" do - - setup do - Sinatra.application = nil - end - - specify "are read from files if Symbols" do - - get '/from_file' do - sass :foo, :views_directory => File.dirname(__FILE__) + "/views" - end - - get_it '/from_file' - should.be.ok - body.should.equal "#sass {\n background_color: #FFF; }\n" - - end - - specify "raise an error if template not found" do - get '/' do - sass :not_found - end - - lambda { get_it '/' }.should.raise(Errno::ENOENT) - end - - specify "ignore default layout file with .sass extension" do - get '/' do - sass :foo, :views_directory => File.dirname(__FILE__) + "/views/layout_test" - end - - get_it '/' - should.be.ok - body.should.equal "#sass {\n background_color: #FFF; }\n" - end - - specify "ignore explicitly specified layout file" do - get '/' do - sass :foo, :layout => :layout, :views_directory => File.dirname(__FILE__) + "/views/layout_test" - end + it 'renders inline Sass strings' do + sass_app { sass "#sass\n :background-color #FFF\n" } + assert ok? + assert_equal "#sass {\n background-color: #FFF; }\n", body + end - get_it '/' - should.be.ok - body.should.equal "#sass {\n background_color: #FFF; }\n" - end + it 'renders .sass files in views path' do + sass_app { sass :hello } + assert ok? + assert_equal "#sass {\n background-color: #FFF; }\n", body + end + it 'ignores the layout option' do + sass_app { sass :hello, :layout => :layout2 } + assert ok? + assert_equal "#sass {\n background-color: #FFF; }\n", body end + it "raises error if template not found" do + mock_app { + get('/') { sass :no_such_template } + } + assert_raise(Errno::ENOENT) { get('/') } + end end vendor/sinatra/test/sass_test.rb vendor/sinatra/.gitignore vendor/sinatra/.gitmodules vendor/sinatra/CHANGELOG vendor/sinatra/images/404.png vendor/sinatra/images/500.png vendor/sinatra/lib/sinatra/rack/handler/mongrel.rb vendor/sinatra/lib/sinatra/test/methods.rb vendor/sinatra/test/app_test.rb vendor/sinatra/test/application_test.rb vendor/sinatra/test/custom_error_test.rb vendor/sinatra/test/event_context_test.rb vendor/sinatra/test/events_test.rb vendor/sinatra/test/pipeline_test.rb vendor/sinatra/test/public/foo.xml vendor/sinatra/test/sessions_test.rb vendor/sinatra/test/streaming_test.rb vendor/sinatra/test/sym_params_test.rb vendor/sinatra/test/template_test.rb vendor/sinatra/test/use_in_file_templates_test.rb vendor/sinatra/test/views/foo.builder vendor/sinatra/test/views/foo.erb vendor/sinatra/test/views/foo.haml vendor/sinatra/test/views/foo.sass vendor/sinatra/test/views/foo_layout.erb vendor/sinatra/test/views/foo_layout.haml vendor/sinatra/test/views/layout_test/foo.builder vendor/sinatra/test/views/layout_test/foo.erb vendor/sinatra/test/views/layout_test/foo.haml vendor/sinatra/test/views/layout_test/foo.sass vendor/sinatra/test/views/layout_test/layout.builder vendor/sinatra/test/views/layout_test/layout.erb vendor/sinatra/test/views/layout_test/layout.haml vendor/sinatra/test/views/layout_test/layout.sass vendor/sinatra/test/views/no_layout/no_layout.builder vendor/sinatra/test/views/no_layout/no_layout.haml ab968d0de2057940dbc08351b8dfaec564e9322a Aaron Bedra aaron@thinkrelevance.com http://github.com/relevance/castronaut/commit/bcbef1f0c6c94e26a29dd36491623a3d679c3d8c bcbef1f0c6c94e26a29dd36491623a3d679c3d8c 2009-01-24T10:46:05-08:00 2009-01-24T10:46:05-08:00 upgraded sinatra and rack to latest versions 167ba6c990cb23604690ed95f851ef0dabfc6913 Aaron Bedra aaron@thinkrelevance.com