Hello World
\n", body get '/html4' assert ok? assert_match(/^ { :foo => 'bar' }} assert_equal "bar\n", body end it "can render truly nested layouts by accepting a layout and a block with the contents" do mock_app do template(:main_outer_layout) { "%h1 Title\n= yield" } template(:an_inner_layout) { "%h2 Subtitle\n= yield" } template(:a_page) { "%p Contents." } get('/') do haml :main_outer_layout, :layout => false do haml :an_inner_layout do haml :a_page end end end end get '/' assert ok? assert_body "Title
\nSubtitle
\nContents.
\n" end end rescue LoadError warn "#{$!.to_s}: skipping haml tests" end sinatra-1.4.3/test/coffee_test.rb 0000644 0000041 0000041 00000004216 12161612727 017012 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) begin require 'coffee-script' require 'execjs' begin ExecJS.compile '1' rescue Exception raise LoadError, 'unable to execute JavaScript' end class CoffeeTest < Test::Unit::TestCase def coffee_app(options = {}, &block) mock_app do set :views, File.dirname(__FILE__) + '/views' set(options) get('/', &block) end get '/' end it 'renders inline Coffee strings' do coffee_app { coffee "alert 'Aye!'\n" } assert ok? assert body.include?("alert('Aye!');") end it 'defaults content type to javascript' do coffee_app { coffee "alert 'Aye!'\n" } assert ok? assert_equal "application/javascript;charset=utf-8", response['Content-Type'] end it 'defaults allows setting content type per route' do coffee_app do content_type :html coffee "alert 'Aye!'\n" end assert ok? assert_equal "text/html;charset=utf-8", response['Content-Type'] end it 'defaults allows setting content type globally' do coffee_app(:coffee => { :content_type => 'html' }) do coffee "alert 'Aye!'\n" end assert ok? assert_equal "text/html;charset=utf-8", response['Content-Type'] end it 'renders .coffee files in views path' do coffee_app { coffee :hello } assert ok? assert_include body, "alert(\"Aye!\");" end it 'ignores the layout option' do coffee_app { coffee :hello, :layout => :layout2 } assert ok? assert_include body, "alert(\"Aye!\");" end it "raises error if template not found" do mock_app { get('/') { coffee :no_such_template } } assert_raise(Errno::ENOENT) { get('/') } end it "passes coffee options to the coffee engine" do coffee_app { coffee "alert 'Aye!'\n", :no_wrap => true } assert ok? assert_body "alert('Aye!');" end it "passes default coffee options to the coffee engine" do mock_app do set :coffee, :no_wrap => true # default coffee style is :nested get('/') { coffee "alert 'Aye!'\n" } end get '/' assert ok? assert_body "alert('Aye!');" end end rescue LoadError warn "#{$!.to_s}: skipping coffee tests" end sinatra-1.4.3/test/radius_test.rb 0000644 0000041 0000041 00000002543 12161612727 017053 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) begin require 'radius' class RadiusTest < Test::Unit::TestCase def radius_app(&block) mock_app do set :views, File.dirname(__FILE__) + '/views' get('/', &block) end get '/' end it 'renders inline radius strings' do radius_app { radius 'Hiya
' } assert ok? assert_equal "Hiya
", body end it 'renders .radius files in views path' do radius_app { radius :hello } assert ok? assert_equal "Hello From Radius
\n", body end it "renders with inline layouts" do mock_app do layout { "THIS. IS.
" }
get('/') { radius 'SPARTA' }
end
get '/'
assert ok?
assert_equal "THIS. IS. SPARTA
", body end it "renders with file layouts" do radius_app { radius 'Hello World', :layout => :layout2 } assert ok? assert_equal "Radius Layout!
\nHello World
\n", body end it "raises error if template not found" do mock_app { get('/') { radius :no_such_template } } assert_raise(Errno::ENOENT) { get('/') } end it "allows passing locals" do radius_app { radius 'Title
\n>{ yield }" } template(:an_inner_layout) { "Subtitle
\n>{ yield }" } template(:a_page) { "Contents.
\n" } get('/') do wlang :main_outer_layout, :layout => false do wlang :an_inner_layout do wlang :a_page end end end end get '/' assert ok? assert_body "Title
\nSubtitle
\nContents.
\n" end end rescue LoadError warn "#{$!.to_s}: skipping wlang tests" end sinatra-1.4.3/test/server_test.rb 0000644 0000041 0000041 00000001645 12161612727 017074 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) require 'stringio' module Rack::Handler class Mock extend Test::Unit::Assertions def self.run(app, options={}) assert(app < Sinatra::Base) assert_equal 9001, options[:Port] assert_equal 'foo.local', options[:Host] yield new end def stop end end register 'mock', 'Rack::Handler::Mock' end class ServerTest < Test::Unit::TestCase setup do mock_app do set :server, 'mock' set :bind, 'foo.local' set :port, 9001 end $stderr = StringIO.new end def teardown $stderr = STDERR end it "locates the appropriate Rack handler and calls ::run" do @app.run! end it "sets options on the app before running" do @app.run! :sessions => true assert @app.sessions? end it "falls back on the next server handler when not found" do @app.run! :server => %w[foo bar mock] end end sinatra-1.4.3/test/filter_test.rb 0000644 0000041 0000041 00000025545 12161612727 017060 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class BeforeFilterTest < Test::Unit::TestCase it "executes filters in the order defined" do count = 0 mock_app do get('/') { 'Hello World' } before do assert_equal 0, count count = 1 end before do assert_equal 1, count count = 2 end end get '/' assert ok? assert_equal 2, count assert_equal 'Hello World', body end it "can modify the request" do mock_app do get('/foo') { 'foo' } get('/bar') { 'bar' } before { request.path_info = '/bar' } end get '/foo' assert ok? assert_equal 'bar', body end it "can modify instance variables available to routes" do mock_app do before { @foo = 'bar' } get('/foo') { @foo } end get '/foo' assert ok? assert_equal 'bar', body end it "allows redirects" do mock_app do before { redirect '/bar' } get('/foo') do fail 'before block should have halted processing' 'ORLY?!' end end get '/foo' assert redirect? assert_equal 'http://example.org/bar', response['Location'] assert_equal '', body end it "does not modify the response with its return value" do mock_app do before { 'Hello World!' } get('/foo') do assert_equal [], response.body 'cool' end end get '/foo' assert ok? assert_equal 'cool', body end it "does modify the response with halt" do mock_app do before { halt 302, 'Hi' } get '/foo' do "should not happen" end end get '/foo' assert_equal 302, response.status assert_equal 'Hi', body end it "gives you access to params" do mock_app do before { @foo = params['foo'] } get('/foo') { @foo } end get '/foo?foo=cool' assert ok? assert_equal 'cool', body end it "properly unescapes parameters" do mock_app do before { @foo = params['foo'] } get('/foo') { @foo } end get '/foo?foo=bar%3Abaz%2Fbend' assert ok? assert_equal 'bar:baz/bend', body end it "runs filters defined in superclasses" do base = Class.new(Sinatra::Base) base.before { @foo = 'hello from superclass' } mock_app(base) { get('/foo') { @foo } } get '/foo' assert_equal 'hello from superclass', body end it 'does not run before filter when serving static files' do ran_filter = false mock_app do before { ran_filter = true } set :static, true set :public_folder, File.dirname(__FILE__) end get "/#{File.basename(__FILE__)}" assert ok? assert_equal File.read(__FILE__), body assert !ran_filter end it 'takes an optional route pattern' do ran_filter = false mock_app do before("/b*") { ran_filter = true } get('/foo') { } get('/bar') { } end get '/foo' assert !ran_filter get '/bar' assert ran_filter end it 'generates block arguments from route pattern' do subpath = nil mock_app do before("/foo/:sub") { |s| subpath = s } get('/foo/*') { } end get '/foo/bar' assert_equal subpath, 'bar' end it 'can catch exceptions in before filters and handle them properly' do doodle = '' mock_app do before do doodle += 'This begins' raise StandardError, "before" end get "/" do doodle = 'and runs' end error 500 do "Error handled #{env['sinatra.error'].message}" end end doodle = '' get '/' assert_equal 'Error handled before', body assert_equal 'This begins', doodle end end class AfterFilterTest < Test::Unit::TestCase it "executes before and after filters in correct order" do invoked = 0 mock_app do before { invoked = 2 } get('/') { invoked += 2; 'hello' } after { invoked *= 2 } end get '/' assert ok? assert_equal 8, invoked end it "executes filters in the order defined" do count = 0 mock_app do get('/') { 'Hello World' } after do assert_equal 0, count count = 1 end after do assert_equal 1, count count = 2 end end get '/' assert ok? assert_equal 2, count assert_equal 'Hello World', body end it "allows redirects" do mock_app do get('/foo') { 'ORLY' } after { redirect '/bar' } end get '/foo' assert redirect? assert_equal 'http://example.org/bar', response['Location'] assert_equal '', body end it "does not modify the response with its return value" do mock_app do get('/foo') { 'cool' } after { 'Hello World!' } end get '/foo' assert ok? assert_equal 'cool', body end it "does modify the response with halt" do mock_app do get '/foo' do "should not be returned" end after { halt 302, 'Hi' } end get '/foo' assert_equal 302, response.status assert_equal 'Hi', body end it "runs filters defined in superclasses" do count = 2 base = Class.new(Sinatra::Base) base.after { count *= 2 } mock_app(base) do get('/foo') do count += 2 "ok" end end get '/foo' assert_equal 8, count end it 'does not run after filter when serving static files' do ran_filter = false mock_app do after { ran_filter = true } set :static, true set :public_folder, File.dirname(__FILE__) end get "/#{File.basename(__FILE__)}" assert ok? assert_equal File.read(__FILE__), body assert !ran_filter end it 'takes an optional route pattern' do ran_filter = false mock_app do after("/b*") { ran_filter = true } get('/foo') { } get('/bar') { } end get '/foo' assert !ran_filter get '/bar' assert ran_filter end it 'changes to path_info from a pattern matching before filter are respected when routing' do mock_app do before('/foo') { request.path_info = '/bar' } get('/bar') { 'blah' } end get '/foo' assert ok? assert_equal 'blah', body end it 'generates block arguments from route pattern' do subpath = nil mock_app do after("/foo/:sub") { |s| subpath = s } get('/foo/*') { } end get '/foo/bar' assert_equal subpath, 'bar' end it 'is possible to access url params from the route param' do ran = false mock_app do get('/foo/*') { } before('/foo/:sub') do assert_equal params[:sub], 'bar' ran = true end end get '/foo/bar' assert ran end it 'is possible to apply host_name conditions to before filters with no path' do ran = false mock_app do before(:host_name => 'example.com') { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_HOST' => 'example.org' }) assert !ran get('/', {}, { 'HTTP_HOST' => 'example.com' }) assert ran end it 'is possible to apply host_name conditions to before filters with a path' do ran = false mock_app do before('/foo', :host_name => 'example.com') { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_HOST' => 'example.com' }) assert !ran get('/foo', {}, { 'HTTP_HOST' => 'example.org' }) assert !ran get('/foo', {}, { 'HTTP_HOST' => 'example.com' }) assert ran end it 'is possible to apply host_name conditions to after filters with no path' do ran = false mock_app do after(:host_name => 'example.com') { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_HOST' => 'example.org' }) assert !ran get('/', {}, { 'HTTP_HOST' => 'example.com' }) assert ran end it 'is possible to apply host_name conditions to after filters with a path' do ran = false mock_app do after('/foo', :host_name => 'example.com') { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_HOST' => 'example.com' }) assert !ran get('/foo', {}, { 'HTTP_HOST' => 'example.org' }) assert !ran get('/foo', {}, { 'HTTP_HOST' => 'example.com' }) assert ran end it 'is possible to apply user_agent conditions to before filters with no path' do ran = false mock_app do before(:user_agent => /foo/) { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_USER_AGENT' => 'bar' }) assert !ran get('/', {}, { 'HTTP_USER_AGENT' => 'foo' }) assert ran end it 'is possible to apply user_agent conditions to before filters with a path' do ran = false mock_app do before('/foo', :user_agent => /foo/) { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_USER_AGENT' => 'foo' }) assert !ran get('/foo', {}, { 'HTTP_USER_AGENT' => 'bar' }) assert !ran get('/foo', {}, { 'HTTP_USER_AGENT' => 'foo' }) assert ran end it 'can add params' do mock_app do before { params['foo'] = 'bar' } get('/') { params['foo'] } end get '/' assert_body 'bar' end it 'can remove params' do mock_app do before { params.delete('foo') } get('/') { params['foo'].to_s } end get '/?foo=bar' assert_body '' end it 'is possible to apply user_agent conditions to after filters with no path' do ran = false mock_app do after(:user_agent => /foo/) { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_USER_AGENT' => 'bar' }) assert !ran get('/', {}, { 'HTTP_USER_AGENT' => 'foo' }) assert ran end it 'is possible to apply user_agent conditions to after filters with a path' do ran = false mock_app do after('/foo', :user_agent => /foo/) { ran = true } get('/') { 'welcome' } end get('/', {}, { 'HTTP_USER_AGENT' => 'foo' }) assert !ran get('/foo', {}, { 'HTTP_USER_AGENT' => 'bar' }) assert !ran get('/foo', {}, { 'HTTP_USER_AGENT' => 'foo' }) assert ran end it 'only triggeres provides condition if conforms with current Content-Type' do mock_app do before(:provides => :txt) { @type = 'txt' } before(:provides => :html) { @type = 'html' } get('/') { @type } end get('/', {}, { 'HTTP_ACCEPT' => '*/*' }) assert_body 'txt' end it 'can catch exceptions in after filters and handle them properly' do doodle = '' mock_app do after do doodle += ' and after' raise StandardError, "after" end get "/foo" do doodle = 'Been now' raise StandardError, "now" end get "/" do doodle = 'Been now' end error 500 do "Error handled #{env['sinatra.error'].message}" end end get '/foo' assert_equal 'Error handled now', body assert_equal 'Been now and after', doodle doodle = '' get '/' assert_equal 'Error handled after', body assert_equal 'Been now and after', doodle end end sinatra-1.4.3/test/scss_test.rb 0000644 0000041 0000041 00000004610 12161612727 016534 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) begin raise LoadError, 'sass not supported on Ruby 2.0' if RUBY_VERSION >= '2.0' require 'sass' class ScssTest < Test::Unit::TestCase def scss_app(options = {}, &block) mock_app do set :views, File.dirname(__FILE__) + '/views' set options get('/', &block) end get '/' end it 'renders inline Scss strings' do scss_app { scss "#scss {\n background-color: white; }\n" } assert ok? assert_equal "#scss {\n background-color: white; }\n", body end it 'defaults content type to css' do scss_app { scss "#scss {\n background-color: white; }\n" } assert ok? assert_equal "text/css;charset=utf-8", response['Content-Type'] end it 'defaults allows setting content type per route' do scss_app do content_type :html scss "#scss {\n background-color: white; }\n" end assert ok? assert_equal "text/html;charset=utf-8", response['Content-Type'] end it 'defaults allows setting content type globally' do scss_app(:scss => { :content_type => 'html' }) { scss "#scss {\n background-color: white; }\n" } assert ok? assert_equal "text/html;charset=utf-8", response['Content-Type'] end it 'renders .scss files in views path' do scss_app { scss :hello } assert ok? assert_equal "#scss {\n background-color: white; }\n", body end it 'ignores the layout option' do scss_app { scss :hello, :layout => :layout2 } assert ok? assert_equal "#scss {\n background-color: white; }\n", body end it "raises error if template not found" do mock_app { get('/') { scss(:no_such_template) } } assert_raise(Errno::ENOENT) { get('/') } end it "passes scss options to the scss engine" do scss_app do scss( "#scss {\n background-color: white;\n color: black\n}", :style => :compact ) end assert ok? assert_equal "#scss { background-color: white; color: black; }\n", body end it "passes default scss options to the scss engine" do mock_app do set :scss, {:style => :compact} # default scss style is :nested get('/') { scss("#scss {\n background-color: white;\n color: black;\n}") } end get '/' assert ok? assert_equal "#scss { background-color: white; color: black; }\n", body end end rescue LoadError warn "#{$!.to_s}: skipping scss tests" end sinatra-1.4.3/test/base_test.rb 0000644 0000041 0000041 00000011554 12161612727 016500 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class BaseTest < Test::Unit::TestCase def test_default assert true end describe 'Sinatra::Base subclasses' do class TestApp < Sinatra::Base get('/') { 'Hello World' } end it 'include Rack::Utils' do assert TestApp.included_modules.include?(Rack::Utils) end it 'processes requests with #call' do assert TestApp.respond_to?(:call) request = Rack::MockRequest.new(TestApp) response = request.get('/') assert response.ok? assert_equal 'Hello World', response.body end class TestApp < Sinatra::Base get '/state' do @foo ||= "new" body = "Foo: #{@foo}" @foo = 'discard' body end end it 'does not maintain state between requests' do request = Rack::MockRequest.new(TestApp) 2.times do response = request.get('/state') assert response.ok? assert_equal 'Foo: new', response.body end end it "passes the subclass to configure blocks" do ref = nil TestApp.configure { |app| ref = app } assert_equal TestApp, ref end it "allows the configure block arg to be omitted and does not change context" do context = nil TestApp.configure { context = self } assert_equal self, context end end describe "Sinatra::Base#new" do it 'returns a wrapper' do assert_equal Sinatra::Wrapper, Sinatra::Base.new.class end it 'implements a nice inspect' do assert_equal '#Title
\n<%= yield %>" } template(:an_inner_layout) { "Subtitle
\n<%= yield %>" } template(:a_page) { "Contents.
\n" } get('/') do erb :main_outer_layout, :layout => false do erb :an_inner_layout do erb :a_page end end end end get '/' assert ok? assert_body "Title
\nSubtitle
\nContents.
\n" end end begin require 'erubis' class ErubisTest < ERBTest def engine; Tilt::ErubisTemplate end end rescue LoadError warn "#{$!.to_s}: skipping erubis tests" end sinatra-1.4.3/test/helpers_test.rb 0000644 0000041 0000041 00000136343 12161612727 017234 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) require 'date' require 'json' class HelpersTest < Test::Unit::TestCase def test_default assert true end def status_app(code, &block) code += 2 if [204, 205, 304].include? code block ||= proc { } mock_app do get('/') do status code instance_eval(&block).inspect end end get '/' end describe 'status' do it 'sets the response status code' do status_app 207 assert_equal 207, response.status end end describe 'not_found?' do it 'is true for status == 404' do status_app(404) { not_found? } assert_body 'true' end it 'is false for status gt 404' do status_app(405) { not_found? } assert_body 'false' end it 'is false for status lt 404' do status_app(403) { not_found? } assert_body 'false' end end describe 'informational?' do it 'is true for 1xx status' do status_app(100 + rand(100)) { informational? } assert_body 'true' end it 'is false for status > 199' do status_app(200 + rand(400)) { informational? } assert_body 'false' end end describe 'success?' do it 'is true for 2xx status' do status_app(200 + rand(100)) { success? } assert_body 'true' end it 'is false for status < 200' do status_app(100 + rand(100)) { success? } assert_body 'false' end it 'is false for status > 299' do status_app(300 + rand(300)) { success? } assert_body 'false' end end describe 'redirect?' do it 'is true for 3xx status' do status_app(300 + rand(100)) { redirect? } assert_body 'true' end it 'is false for status < 300' do status_app(200 + rand(100)) { redirect? } assert_body 'false' end it 'is false for status > 399' do status_app(400 + rand(200)) { redirect? } assert_body 'false' end end describe 'client_error?' do it 'is true for 4xx status' do status_app(400 + rand(100)) { client_error? } assert_body 'true' end it 'is false for status < 400' do status_app(200 + rand(200)) { client_error? } assert_body 'false' end it 'is false for status > 499' do status_app(500 + rand(100)) { client_error? } assert_body 'false' end end describe 'server_error?' do it 'is true for 5xx status' do status_app(500 + rand(100)) { server_error? } assert_body 'true' end it 'is false for status < 500' do status_app(200 + rand(300)) { server_error? } assert_body 'false' end end describe 'body' do it 'takes a block for deferred body generation' do mock_app do get('/') { body { 'Hello World' } } end get '/' assert_equal 'Hello World', body end it 'takes a String, Array, or other object responding to #each' do mock_app { get('/') { body 'Hello World' } } get '/' assert_equal 'Hello World', body end it 'can be used with other objects' do mock_app do get '/' do body :hello => 'from json' end after do if Hash === response.body body response.body[:hello] end end end get '/' assert_body 'from json' end it 'can be set in after filter' do mock_app do get('/') { body 'route' } after { body 'filter' } end get '/' assert_body 'filter' end end describe 'redirect' do it 'uses a 302 when only a path is given' do mock_app do get('/') do redirect '/foo' fail 'redirect should halt' end end get '/' assert_equal 302, status assert_equal '', body assert_equal 'http://example.org/foo', response['Location'] end it 'uses the code given when specified' do mock_app do get('/') do redirect '/foo', 301 fail 'redirect should halt' end end get '/' assert_equal 301, status assert_equal '', body assert_equal 'http://example.org/foo', response['Location'] end it 'redirects back to request.referer when passed back' do mock_app { get('/try_redirect') { redirect back } } request = Rack::MockRequest.new(@app) response = request.get('/try_redirect', 'HTTP_REFERER' => '/foo') assert_equal 302, response.status assert_equal 'http://example.org/foo', response['Location'] end it 'redirects using a non-standard HTTP port' do mock_app { get('/') { redirect '/foo' } } request = Rack::MockRequest.new(@app) response = request.get('/', 'SERVER_PORT' => '81') assert_equal 'http://example.org:81/foo', response['Location'] end it 'redirects using a non-standard HTTPS port' do mock_app { get('/') { redirect '/foo' } } request = Rack::MockRequest.new(@app) response = request.get('/', 'SERVER_PORT' => '444') assert_equal 'http://example.org:444/foo', response['Location'] end it 'uses 303 for post requests if request is HTTP 1.1' do mock_app { post('/') { redirect '/'} } post('/', {}, 'HTTP_VERSION' => 'HTTP/1.1') assert_equal 303, status assert_equal '', body assert_equal 'http://example.org/', response['Location'] end it 'uses 302 for post requests if request is HTTP 1.0' do mock_app { post('/') { redirect '/'} } post('/', {}, 'HTTP_VERSION' => 'HTTP/1.0') assert_equal 302, status assert_equal '', body assert_equal 'http://example.org/', response['Location'] end it 'works behind a reverse proxy' do mock_app { get('/') { redirect '/foo' } } request = Rack::MockRequest.new(@app) response = request.get('/', 'HTTP_X_FORWARDED_HOST' => 'example.com', 'SERVER_PORT' => '8080') assert_equal 'http://example.com/foo', response['Location'] end it 'accepts absolute URIs' do mock_app do get('/') do redirect 'http://google.com' fail 'redirect should halt' end end get '/' assert_equal 302, status assert_equal '', body assert_equal 'http://google.com', response['Location'] end it 'accepts absolute URIs with a different schema' do mock_app do get('/') do redirect 'mailto:jsmith@example.com' fail 'redirect should halt' end end get '/' assert_equal 302, status assert_equal '', body assert_equal 'mailto:jsmith@example.com', response['Location'] end it 'accepts a URI object instead of a String' do mock_app do get('/') { redirect URI.parse('http://sinatrarb.com') } end get '/' assert_equal 302, status assert_equal '', body assert_equal 'http://sinatrarb.com', response['Location'] end end describe 'error' do it 'sets a status code and halts' do mock_app do get('/') do error 501 fail 'error should halt' end end get '/' assert_equal 501, status assert_equal '', body end it 'takes an optional body' do mock_app do get('/') do error 501, 'FAIL' fail 'error should halt' end end get '/' assert_equal 501, status assert_equal 'FAIL', body end it 'should not invoke error handler when setting status inside an error handler' do mock_app do disable :raise_errors not_found do body "not_found handler" status 404 end error do body "error handler" status 404 end get '/' do raise end end get '/' assert_equal 404, status assert_equal 'error handler', body end it 'should not reset the content-type to html for error handlers' do mock_app do disable :raise_errors before { content_type "application/json;charset=utf-8" } not_found { JSON.dump("error" => "Not Found") } end get '/' assert_equal 404, status assert_equal 'application/json;charset=utf-8', response.content_type end it 'should not invoke error handler when halting with 500 inside an error handler' do mock_app do disable :raise_errors not_found do body "not_found handler" halt 404 end error do body "error handler" halt 404 end get '/' do raise end end get '/' assert_equal 404, status assert_equal 'error handler', body end it 'should not invoke not_found handler when halting with 404 inside a not found handler' do mock_app do disable :raise_errors not_found do body "not_found handler" halt 500 end error do body "error handler" halt 500 end end get '/' assert_equal 500, status assert_equal 'not_found handler', body end it 'uses a 500 status code when first argument is a body' do mock_app do get('/') do error 'FAIL' fail 'error should halt' end end get '/' assert_equal 500, status assert_equal 'FAIL', body end end describe 'not_found' do it 'halts with a 404 status' do mock_app do get('/') do not_found fail 'not_found should halt' end end get '/' assert_equal 404, status assert_equal '', body end it 'does not set a X-Cascade header' do mock_app do get('/') do not_found fail 'not_found should halt' end end get '/' assert_equal 404, status assert_equal nil, response.headers['X-Cascade'] end end describe 'headers' do it 'sets headers on the response object when given a Hash' do mock_app do get('/') do headers 'X-Foo' => 'bar', 'X-Baz' => 'bling' 'kthx' end end get '/' assert ok? assert_equal 'bar', response['X-Foo'] assert_equal 'bling', response['X-Baz'] assert_equal 'kthx', body end it 'returns the response headers hash when no hash provided' do mock_app do get('/') do headers['X-Foo'] = 'bar' 'kthx' end end get '/' assert ok? assert_equal 'bar', response['X-Foo'] end end describe 'session' do it 'uses the existing rack.session' do mock_app do get('/') do session[:foo] end end get('/', {}, { 'rack.session' => { :foo => 'bar' } }) assert_equal 'bar', body end it 'creates a new session when none provided' do mock_app do enable :sessions get('/') do assert session[:foo].nil? session[:foo] = 'bar' redirect '/hi' end get('/hi') do "hi #{session[:foo]}" end end get '/' follow_redirect! assert_equal 'hi bar', body end it 'inserts session middleware' do mock_app do enable :sessions get('/') do assert env['rack.session'] assert env['rack.session.options'] 'ok' end end get '/' assert_body 'ok' end it 'sets a default session secret' do mock_app do enable :sessions get('/') do secret = env['rack.session.options'][:secret] assert secret assert_equal secret, settings.session_secret 'ok' end end get '/' assert_body 'ok' end it 'allows disabling session secret' do mock_app do enable :sessions disable :session_secret get('/') do assert !env['rack.session.options'].include?(:session_secret) 'ok' end end # Silence warnings since Rack::Session::Cookie complains about the non-present session secret silence_warnings do get '/' end assert_body 'ok' end it 'accepts an options hash' do mock_app do set :sessions, :foo => :bar get('/') do assert_equal env['rack.session.options'][:foo], :bar 'ok' end end get '/' assert_body 'ok' end end describe 'mime_type' do include Sinatra::Helpers it "looks up mime types in Rack's MIME registry" do Rack::Mime::MIME_TYPES['.foo'] = 'application/foo' assert_equal 'application/foo', mime_type('foo') assert_equal 'application/foo', mime_type('.foo') assert_equal 'application/foo', mime_type(:foo) end it 'returns nil when given nil' do assert mime_type(nil).nil? end it 'returns nil when media type not registered' do assert mime_type(:bizzle).nil? end it 'returns the argument when given a media type string' do assert_equal 'text/plain', mime_type('text/plain') end it 'turns AcceptEntry into String' do type = mime_type(Sinatra::Request::AcceptEntry.new('text/plain')) assert_equal String, type.class assert_equal 'text/plain', type end end test 'Base.mime_type registers mime type' do mock_app do mime_type :foo, 'application/foo' get('/') do "foo is #{mime_type(:foo)}" end end get '/' assert_equal 'foo is application/foo', body end describe 'content_type' do it 'sets the Content-Type header' do mock_app do get('/') do content_type 'text/plain' 'Hello World' end end get '/' assert_equal 'text/plain;charset=utf-8', response['Content-Type'] assert_equal 'Hello World', body end it 'takes media type parameters (like charset=)' do mock_app do get('/') do content_type 'text/html', :charset => 'latin1' "Hello, World
" end end get '/' assert ok? assert_equal 'text/html;charset=latin1', response['Content-Type'] assert_equal "Hello, World
", body end it "looks up symbols in Rack's mime types dictionary" do Rack::Mime::MIME_TYPES['.foo'] = 'application/foo' mock_app do get('/foo.xml') do content_type :foo "I AM FOO" end end get '/foo.xml' assert ok? assert_equal 'application/foo', response['Content-Type'] assert_equal 'I AM FOO', body end it 'fails when no mime type is registered for the argument provided' do mock_app do get('/foo.xml') do content_type :bizzle "I AM FOO" end end assert_raise(RuntimeError) { get '/foo.xml' } end it 'only sets default charset for specific mime types' do tests_ran = false mock_app do mime_type :foo, 'text/foo' mime_type :bar, 'application/bar' mime_type :baz, 'application/baz' add_charset << mime_type(:baz) get('/') do assert_equal content_type(:txt), 'text/plain;charset=utf-8' assert_equal content_type(:css), 'text/css;charset=utf-8' assert_equal content_type(:html), 'text/html;charset=utf-8' assert_equal content_type(:foo), 'text/foo;charset=utf-8' assert_equal content_type(:xml), 'application/xml;charset=utf-8' assert_equal content_type(:xhtml), 'application/xhtml+xml;charset=utf-8' assert_equal content_type(:js), 'application/javascript;charset=utf-8' assert_equal content_type(:json), 'application/json;charset=utf-8' assert_equal content_type(:bar), 'application/bar' assert_equal content_type(:png), 'image/png' assert_equal content_type(:baz), 'application/baz;charset=utf-8' tests_ran = true "done" end end get '/' assert tests_ran end it 'handles already present params' do mock_app do get('/') do content_type 'foo/bar;level=1', :charset => 'utf-8' 'ok' end end get '/' assert_equal 'foo/bar;level=1, charset=utf-8', response['Content-Type'] end it 'does not add charset if present' do mock_app do get('/') do content_type 'text/plain;charset=utf-16' 'ok' end end get '/' assert_equal 'text/plain;charset=utf-16', response['Content-Type'] end it 'properly encodes parameters with delimiter characters' do mock_app do before '/comma' do content_type 'image/png', :comment => 'Hello, world!' end before '/semicolon' do content_type 'image/png', :comment => 'semi;colon' end before '/quote' do content_type 'image/png', :comment => '"Whatever."' end get('*') { 'ok' } end get '/comma' assert_equal 'image/png;comment="Hello, world!"', response['Content-Type'] get '/semicolon' assert_equal 'image/png;comment="semi;colon"', response['Content-Type'] get '/quote' assert_equal 'image/png;comment="\"Whatever.\""', response['Content-Type'] end end describe 'attachment' do def attachment_app(filename=nil) mock_app do get('/attachment') do attachment filename response.write("Hiya
" end it 'renders .creole files in views path' do creole_app { creole :hello } assert ok? assert_body "Hello From Creole
" end it "raises error if template not found" do mock_app { get('/') { creole :no_such_template } } assert_raise(Errno::ENOENT) { get('/') } end it "renders with inline layouts" do mock_app do layout { 'THIS. IS. #{yield.upcase}!' } get('/') { creole 'Sparta', :layout_engine => :str } end get '/' assert ok? assert_like 'THIS. IS.SPARTA
!', body end it "renders with file layouts" do creole_app do creole 'Hello World', :layout => :layout2, :layout_engine => :erb end assert ok? assert_body "ERB Layout!\nHello World
" end it "can be used in a nested fashion for partials and whatnot" do mock_app do template(:inner) { "hi" } template(:outer) { "hi
Hiya
' } assert ok? assert_equal "Hiya
", body end it 'renders .liquid files in views path' do liquid_app { liquid :hello } assert ok? assert_equal "Hello From Liquid
\n", body end it "renders with inline layouts" do mock_app do layout { "THIS. IS. {{ yield }}
" } get('/') { liquid 'SPARTA' } end get '/' assert ok? assert_equal "THIS. IS. SPARTA
", body end it "renders with file layouts" do liquid_app { liquid 'Hello World', :layout => :layout2 } assert ok? assert_equal "Liquid Layout!
\nHello World
\n", body end it "raises error if template not found" do mock_app { get('/') { liquid :no_such_template } } assert_raise(Errno::ENOENT) { get('/') } end it "allows passing locals" do liquid_app { liquid '{{ value }}', :locals => { :value => 'foo' } } assert ok? assert_equal 'foo', body end it "can rendere truly nested layouts by accepting a layout and a block with the contents" do mock_app do template(:main_outer_layout) { "Title
\n{{ yield }}" } template(:an_inner_layout) { "Subtitle
\n{{ yield }}" } template(:a_page) { "Contents.
\n" } get('/') do liquid :main_outer_layout, :layout => false do liquid :an_inner_layout do liquid :a_page end end end end get '/' assert ok? assert_body "Title
\nSubtitle
\nContents.
\n" end end rescue LoadError warn "#{$!.to_s}: skipping liquid tests" end sinatra-1.4.3/test/middleware_test.rb 0000644 0000041 0000041 00000003172 12161612727 017700 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class MiddlewareTest < Test::Unit::TestCase setup do @app = mock_app(Sinatra::Application) do get('/*')do response.headers['X-Tests'] = env['test.ran']. map { |n| n.split('::').last }. join(', ') env['PATH_INFO'] end end end class MockMiddleware < Struct.new(:app) def call(env) (env['test.ran'] ||= []) << self.class.to_s app.call(env) end end class UpcaseMiddleware < MockMiddleware def call(env) env['PATH_INFO'] = env['PATH_INFO'].upcase super end end it "is added with Sinatra::Application.use" do @app.use UpcaseMiddleware get '/hello-world' assert ok? assert_equal '/HELLO-WORLD', body end class DowncaseMiddleware < MockMiddleware def call(env) env['PATH_INFO'] = env['PATH_INFO'].downcase super end end it "runs in the order defined" do @app.use UpcaseMiddleware @app.use DowncaseMiddleware get '/Foo' assert_equal "/foo", body assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests'] end it "resets the prebuilt pipeline when new middleware is added" do @app.use UpcaseMiddleware get '/Foo' assert_equal "/FOO", body @app.use DowncaseMiddleware get '/Foo' assert_equal '/foo', body assert_equal "UpcaseMiddleware, DowncaseMiddleware", response['X-Tests'] end it "works when app is used as middleware" do @app.use UpcaseMiddleware @app = @app.new get '/Foo' assert_equal "/FOO", body assert_equal "UpcaseMiddleware", response['X-Tests'] end end sinatra-1.4.3/test/yajl_test.rb 0000644 0000041 0000041 00000003504 12161612727 016521 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) begin require 'yajl' class YajlTest < Test::Unit::TestCase def yajl_app(&block) mock_app do set :views, File.dirname(__FILE__) + '/views' get('/', &block) end get '/' end it 'renders inline Yajl strings' do yajl_app { yajl('json = { :foo => "bar" }') } assert ok? assert_body '{"foo":"bar"}' end it 'renders .yajl files in views path' do yajl_app { yajl(:hello) } assert ok? assert_body '{"yajl":"hello"}' end it 'raises error if template not found' do mock_app { get('/') { yajl(:no_such_template) } } assert_raise(Errno::ENOENT) { get('/') } end it 'accepts a :locals option' do yajl_app do locals = { :object => { :foo => 'bar' } } yajl 'json = object', :locals => locals end assert ok? assert_body '{"foo":"bar"}' end it 'accepts a :scope option' do yajl_app do scope = { :object => { :foo => 'bar' } } yajl 'json = self[:object]', :scope => scope end assert ok? assert_body '{"foo":"bar"}' end it 'decorates the json with a callback' do yajl_app do yajl( 'json = { :foo => "bar" }', { :callback => 'baz' } ) end assert ok? assert_body 'baz({"foo":"bar"});' end it 'decorates the json with a variable' do yajl_app do yajl( 'json = { :foo => "bar" }', { :variable => 'qux' } ) end assert ok? assert_body 'var qux = {"foo":"bar"};' end it 'decorates the json with a callback and a variable' do yajl_app do yajl( 'json = { :foo => "bar" }', { :callback => 'baz', :variable => 'qux' } ) end assert ok? assert_body 'var qux = {"foo":"bar"}; baz(qux);' end end rescue LoadError warn "#{$!.to_s}: skipping yajl tests" end sinatra-1.4.3/test/sinatra_test.rb 0000644 0000041 0000041 00000000554 12161612727 017225 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class SinatraTest < Test::Unit::TestCase it 'creates a new Sinatra::Base subclass on new' do app = Sinatra.new { get('/') { 'Hello World' } } assert_same Sinatra::Base, app.superclass end it "responds to #template_cache" do assert_kind_of Tilt::Cache, Sinatra::Base.new!.template_cache end end sinatra-1.4.3/test/markaby_test.rb 0000644 0000041 0000041 00000003734 12161612727 017215 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) begin require 'markaby' class MarkabyTest < Test::Unit::TestCase def markaby_app(&block) mock_app do set :views, File.dirname(__FILE__) + '/views' get('/', &block) end get '/' end it 'renders inline markaby strings' do markaby_app { markaby 'h1 "Hiya"' } assert ok? assert_equal "Hiya
", body end it 'renders .markaby files in views path' do markaby_app { markaby :hello } assert ok? assert_equal "Hello From Markaby
", body end it "renders with inline layouts" do mock_app do layout { 'h1 { text "THIS. IS. "; yield }' } get('/') { markaby 'em "SPARTA"' } end get '/' assert ok? assert_equal "THIS. IS. SPARTA
", body end it "renders with file layouts" do markaby_app { markaby 'text "Hello World"', :layout => :layout2 } assert ok? assert_equal "Markaby Layout!
Hello World
", body end it 'renders inline markaby blocks' do markaby_app { markaby { h1 'Hiya' } } assert ok? assert_equal "Hiya
", body end it 'renders inline markaby blocks with inline layouts' do markaby_app do settings.layout { 'h1 { text "THIS. IS. "; yield }' } markaby { em 'SPARTA' } end assert ok? assert_equal "THIS. IS. SPARTA
", body end it 'renders inline markaby blocks with file layouts' do markaby_app { markaby(:layout => :layout2) { text "Hello World" } } assert ok? assert_equal "Markaby Layout!
Hello World
", body end it "raises error if template not found" do mock_app { get('/') { markaby :no_such_template } } assert_raise(Errno::ENOENT) { get('/') } end it "allows passing locals" do markaby_app { markaby 'text value', :locals => { :value => 'foo' } } assert ok? assert_equal 'foo', body end end rescue LoadError warn "#{$!.to_s}: skipping markaby tests" end sinatra-1.4.3/test/helper.rb 0000644 0000041 0000041 00000006125 12161612727 016004 0 ustar www-data www-data ENV['RACK_ENV'] = 'test' Encoding.default_external = "UTF-8" if defined? Encoding RUBY_ENGINE = 'ruby' unless defined? RUBY_ENGINE begin require 'rack' rescue LoadError require 'rubygems' require 'rack' end testdir = File.dirname(__FILE__) $LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir) libdir = File.dirname(File.dirname(__FILE__)) + '/lib' $LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir) require 'contest' require 'rack/test' require 'sinatra/base' class Sinatra::Base # Allow assertions in request context include Test::Unit::Assertions end class Rack::Builder def include?(middleware) @ins.any? { |m| p m ; middleware === m } end end Sinatra::Base.set :environment, :test class Test::Unit::TestCase include Rack::Test::Methods class << self alias_method :it, :test alias_method :section, :context end def self.example(desc = nil, &block) @example_count = 0 unless instance_variable_defined? :@example_count @example_count += 1 it(desc || "Example #{@example_count}", &block) end alias_method :response, :last_response setup do Sinatra::Base.set :environment, :test end # 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 def app Rack::Lint.new(@app) end def body response.body.to_s end def assert_body(value) if value.respond_to? :to_str assert_equal value.lstrip.gsub(/\s*\n\s*/, ""), body.lstrip.gsub(/\s*\n\s*/, "") else assert_match value, body end end def assert_status(expected) assert_equal Integer(expected), Integer(status) end def assert_like(a,b) pattern = /id=['"][^"']*["']|\s+/ assert_equal a.strip.gsub(pattern, ""), b.strip.gsub(pattern, "") end def assert_include(str, substr) assert str.include?(substr), "expected #{str.inspect} to include #{substr.inspect}" end def options(uri, params = {}, env = {}, &block) request(uri, env.merge(:method => "OPTIONS", :params => params), &block) end def patch(uri, params = {}, env = {}, &block) request(uri, env.merge(:method => "PATCH", :params => params), &block) end def link(uri, params = {}, env = {}, &block) request(uri, env.merge(:method => "LINK", :params => params), &block) end def unlink(uri, params = {}, env = {}, &block) request(uri, env.merge(:method => "UNLINK", :params => params), &block) end # Delegate other missing methods to response. def method_missing(name, *args, &block) if response && response.respond_to?(name) response.send(name, *args, &block) else super end rescue Rack::Test::Error super end # Also check response since we delegate there. def respond_to?(symbol, include_private=false) super || (response && response.respond_to?(symbol, include_private)) end # Do not output warnings for the duration of the block. def silence_warnings $VERBOSE, v = nil, $VERBOSE yield ensure $VERBOSE = v end end sinatra-1.4.3/test/mapped_error_test.rb 0000644 0000041 0000041 00000016303 12161612727 020242 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class FooError < RuntimeError end class FooNotFound < Sinatra::NotFound end class FooSpecialError < RuntimeError def http_status; 501 end end class FooStatusOutOfRangeError < RuntimeError def code; 4000 end end class FooWithCode < RuntimeError def code; 419 end end class FirstError < RuntimeError; end class SecondError < RuntimeError; end class MappedErrorTest < Test::Unit::TestCase def test_default assert true end describe 'Exception Mappings' do it 'invokes handlers registered with ::error when raised' do mock_app do set :raise_errors, false error(FooError) { 'Foo!' } get('/') { raise FooError } end get '/' assert_equal 500, status assert_equal 'Foo!', body end it 'passes the exception object to the error handler' do mock_app do set :raise_errors, false error(FooError) { |e| assert_equal(FooError, e.class) } get('/') { raise FooError } end get('/') end it 'uses the Exception handler if no matching handler found' do mock_app do set :raise_errors, false error(Exception) { 'Exception!' } get('/') { raise FooError } end get '/' assert_equal 500, status assert_equal 'Exception!', body end it 'walks down inheritance chain for errors' do mock_app do set :raise_errors, false error(RuntimeError) { 'Exception!' } get('/') { raise FooError } end get '/' assert_equal 500, status assert_equal 'Exception!', body end it 'favors subclass handler over superclass handler if available' do mock_app do set :raise_errors, false error(Exception) { 'Exception!' } error(FooError) { 'FooError!' } error(RuntimeError) { 'Exception!' } get('/') { raise FooError } end get '/' assert_equal 500, status assert_equal 'FooError!', body end it "sets env['sinatra.error'] to the rescued exception" do mock_app do set :raise_errors, false error(FooError) do assert env.include?('sinatra.error') assert env['sinatra.error'].kind_of?(FooError) 'looks good' end get('/') { raise FooError } end get '/' assert_equal 'looks good', body end it "raises errors from the app when raise_errors set and no handler defined" do mock_app do set :raise_errors, true get('/') { raise FooError } end assert_raise(FooError) { get '/' } end it "calls error handlers before raising errors even when raise_errors is set" do mock_app do set :raise_errors, true error(FooError) { "she's there." } get('/') { raise FooError } end assert_nothing_raised { get '/' } assert_equal 500, status end it "never raises Sinatra::NotFound beyond the application" do mock_app(Sinatra::Application) do get('/') { raise Sinatra::NotFound } end assert_nothing_raised { get '/' } assert_equal 404, status end it "cascades for subclasses of Sinatra::NotFound" do mock_app do set :raise_errors, true error(FooNotFound) { "foo! not found." } get('/') { raise FooNotFound } end assert_nothing_raised { get '/' } assert_equal 404, status assert_equal 'foo! not found.', body end it 'has a not_found method for backwards compatibility' do mock_app { not_found { "Lost, are we?" } } get '/test' assert_equal 404, status assert_equal "Lost, are we?", body end it 'inherits error mappings from base class' do base = Class.new(Sinatra::Base) base.error(FooError) { 'base class' } mock_app(base) do set :raise_errors, false get('/') { raise FooError } end get '/' assert_equal 'base class', body end it 'overrides error mappings in base class' do base = Class.new(Sinatra::Base) base.error(FooError) { 'base class' } mock_app(base) do set :raise_errors, false error(FooError) { 'subclass' } get('/') { raise FooError } end get '/' assert_equal 'subclass', body end it 'honors Exception#http_status if present' do mock_app do set :raise_errors, false error(501) { 'Foo!' } get('/') { raise FooSpecialError } end get '/' assert_equal 501, status assert_equal 'Foo!', body end it 'does not use Exception#code by default' do mock_app do set :raise_errors, false get('/') { raise FooWithCode } end get '/' assert_equal 500, status end it 'uses Exception#code if use_code is enabled' do mock_app do set :raise_errors, false set :use_code, true get('/') { raise FooWithCode } end get '/' assert_equal 419, status end it 'does not rely on Exception#code for invalid codes' do mock_app do set :raise_errors, false set :use_code, true get('/') { raise FooStatusOutOfRangeError } end get '/' assert_equal 500, status end it "allows a stack of exception_handlers" do mock_app do set :raise_errors, false error(FirstError) { 'First!' } error(SecondError) { 'Second!' } get('/'){ raise SecondError } end get '/' assert_equal 500, status assert_equal 'Second!', body end it "allows an exception handler to pass control to the next exception handler" do mock_app do set :raise_errors, false error(500, FirstError) { 'First!' } error(500, SecondError) { pass } get('/') { raise 500 } end get '/' assert_equal 500, status assert_equal 'First!', body end it "allows an exception handler to handle the exception" do mock_app do set :raise_errors, false error(500, FirstError) { 'First!' } error(500, SecondError) { 'Second!' } get('/') { raise 500 } end get '/' assert_equal 500, status assert_equal 'Second!', body end end describe 'Custom Error Pages' do it 'allows numeric status code mappings to be registered with ::error' do mock_app do set :raise_errors, false error(500) { 'Foo!' } get('/') { [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 do set :raise_errors, false error(500..550) { "Error: #{response.status}" } get('/') { [507, {}, 'A very special error'] } end get '/' assert_equal 507, status assert_equal 'Error: 507', body end it 'allows passing more than one range' do mock_app do set :raise_errors, false error(409..411, 503..509) { "Error: #{response.status}" } get('/') { [507, {}, 'A very special error'] } end get '/' assert_equal 507, status assert_equal 'Error: 507', body end end end sinatra-1.4.3/test/settings_test.rb 0000644 0000041 0000041 00000035572 12161612727 017434 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class SettingsTest < Test::Unit::TestCase setup do @base = Sinatra.new(Sinatra::Base) @base.set :environment => :foo, :app_file => nil @application = Sinatra.new(Sinatra::Application) @application.set :environment => :foo, :app_file => nil end it 'sets settings to literal values' do @base.set(:foo, 'bar') assert @base.respond_to?(:foo) assert_equal 'bar', @base.foo end it 'sets settings to Procs' do @base.set(:foo, Proc.new { 'baz' }) assert @base.respond_to?(:foo) assert_equal 'baz', @base.foo end it 'sets settings using a block' do @base.set(:foo){ 'baz' } assert @base.respond_to?(:foo) assert_equal 'baz', @base.foo end it 'raises an error with a value and a block' do assert_raise ArgumentError do @base.set(:fiz, 'boom!'){ 'baz' } end assert !@base.respond_to?(:fiz) end it 'raises an error without value and block' do assert_raise(ArgumentError) { @base.set(:fiz) } assert !@base.respond_to?(:fiz) end it 'allows setting a value to the app class' do @base.set :base, @base assert @base.respond_to?(:base) assert_equal @base, @base.base end it 'raises an error with the app class as value and a block' do assert_raise ArgumentError do @base.set(:fiz, @base) { 'baz' } end assert !@base.respond_to?(:fiz) end it "sets multiple settings with a Hash" do @base.set :foo => 1234, :bar => 'Hello World', :baz => Proc.new { 'bizzle' } assert_equal 1234, @base.foo assert_equal 'Hello World', @base.bar assert_equal 'bizzle', @base.baz end it 'sets multiple settings using #each' do @base.set [["foo", "bar"]] assert_equal "bar", @base.foo end it 'inherits settings methods when subclassed' do @base.set :foo, 'bar' @base.set :biz, Proc.new { 'baz' } sub = Class.new(@base) assert sub.respond_to?(:foo) assert_equal 'bar', sub.foo assert sub.respond_to?(:biz) assert_equal 'baz', sub.biz end it 'overrides settings in subclass' do @base.set :foo, 'bar' @base.set :biz, Proc.new { 'baz' } sub = Class.new(@base) sub.set :foo, 'bling' assert_equal 'bling', sub.foo assert_equal 'bar', @base.foo end it 'creates setter methods when first defined' do @base.set :foo, 'bar' assert @base.respond_to?('foo=') @base.foo = 'biz' assert_equal 'biz', @base.foo end it 'creates predicate methods when first defined' do @base.set :foo, 'hello world' assert @base.respond_to?(:foo?) assert @base.foo? @base.set :foo, nil assert !@base.foo? end it 'uses existing setter methods if detected' do class << @base def foo @foo end def foo=(value) @foo = 'oops' end end @base.set :foo, 'bam' assert_equal 'oops', @base.foo end it 'merges values of multiple set calls if those are hashes' do @base.set :foo, :a => 1 sub = Class.new(@base) sub.set :foo, :b => 2 assert_equal({:a => 1, :b => 2}, sub.foo) end it 'merging does not affect the superclass' do @base.set :foo, :a => 1 sub = Class.new(@base) sub.set :foo, :b => 2 assert_equal({:a => 1}, @base.foo) end it 'is possible to change a value from a hash to something else' do @base.set :foo, :a => 1 @base.set :foo, :bar assert_equal(:bar, @base.foo) end it 'merges values with values of the superclass if those are hashes' do @base.set :foo, :a => 1 @base.set :foo, :b => 2 assert_equal({:a => 1, :b => 2}, @base.foo) end it "sets multiple settings to true with #enable" do @base.enable :sessions, :foo, :bar assert @base.sessions assert @base.foo assert @base.bar end it "sets multiple settings to false with #disable" do @base.disable :sessions, :foo, :bar assert !@base.sessions assert !@base.foo assert !@base.bar end it 'is accessible from instances via #settings' do assert_equal :foo, @base.new!.settings.environment end it 'is accessible from class via #settings' do assert_equal :foo, @base.settings.environment end describe 'methodoverride' do it 'is disabled on Base' do assert ! @base.method_override? end it 'is enabled on Application' do assert @application.method_override? end it 'enables MethodOverride middleware' do @base.set :method_override, true @base.put('/') { 'okay' } @app = @base post '/', {'_method'=>'PUT'}, {} assert_equal 200, status assert_equal 'okay', body end it 'is backward compatible with methodoverride' do assert ! @base.methodoverride? @base.enable :methodoverride assert @base.methodoverride? end end describe 'run' do it 'is disabled on Base' do assert ! @base.run? end it 'is enabled on Application except in test environment' do assert @application.run? @application.set :environment, :test assert ! @application.run? end end describe 'raise_errors' do it 'is enabled on Base only in test' do assert ! @base.raise_errors? @base.set(:environment, :test) assert @base.raise_errors? end it 'is enabled on Application only in test' do assert ! @application.raise_errors? @application.set(:environment, :test) assert @application.raise_errors? end end describe 'show_exceptions' do it 'is disabled on Base except under development' do assert ! @base.show_exceptions? @base.environment = :development assert @base.show_exceptions? end it 'is disabled on Application except in development' do assert ! @application.show_exceptions? @application.set(:environment, :development) assert @application.show_exceptions? end it 'returns a friendly 500' do klass = Sinatra.new(Sinatra::Application) mock_app(klass) { enable :show_exceptions get '/' do raise StandardError end } get '/' assert_equal 500, status assert body.include?("StandardError") assert body.include?("show_exceptions setting")
end
it 'does not override app-specified error handling when set to :after_handler' do
ran = false
mock_app do
set :show_exceptions, :after_handler
error(RuntimeError) { ran = true }
get('/') { raise RuntimeError }
end
get '/'
assert_equal 500, status
assert ran
end
it 'does catch any other exceptions when set to :after_handler' do
ran = false
mock_app do
set :show_exceptions, :after_handler
error(RuntimeError) { ran = true }
get('/') { raise ArgumentError }
end
get '/'
assert_equal 500, status
assert !ran
end
end
describe 'dump_errors' do
it 'is disabled on Base in test' do
@base.environment = :test
assert ! @base.dump_errors?
@base.environment = :development
assert @base.dump_errors?
@base.environment = :production
assert @base.dump_errors?
end
it 'dumps exception with backtrace to rack.errors' do
klass = Sinatra.new(Sinatra::Application)
mock_app(klass) {
enable :dump_errors
disable :raise_errors
error do
error = @env['rack.errors'].instance_variable_get(:@error)
error.rewind
error.read
end
get '/' do
raise
end
}
get '/'
assert body.include?("RuntimeError") && body.include?("settings_test.rb")
end
it 'does not dump 404 errors' do
klass = Sinatra.new(Sinatra::Application)
mock_app(klass) {
enable :dump_errors
disable :raise_errors
error do
error = @env['rack.errors'].instance_variable_get(:@error)
error.rewind
error.read
end
get '/' do
raise Sinatra::NotFound
end
}
get '/'
assert !body.include?("NotFound") && !body.include?("settings_test.rb")
end
end
describe 'sessions' do
it 'is disabled on Base' do
assert ! @base.sessions?
end
it 'is disabled on Application' do
assert ! @application.sessions?
end
end
describe 'logging' do
it 'is disabled on Base' do
assert ! @base.logging?
end
it 'is enabled on Application except in test environment' do
assert @application.logging?
@application.set :environment, :test
assert ! @application.logging
end
end
describe 'static' do
it 'is disabled on Base by default' do
assert ! @base.static?
end
it 'is enabled on Base when public_folder is set and exists' do
@base.set :environment, :development
@base.set :public_folder, File.dirname(__FILE__)
assert @base.static?
end
it 'is enabled on Base when root is set and root/public_folder exists' do
@base.set :environment, :development
@base.set :root, File.dirname(__FILE__)
assert @base.static?
end
it 'is disabled on Application by default' do
assert ! @application.static?
end
it 'is enabled on Application when public_folder is set and exists' do
@application.set :environment, :development
@application.set :public_folder, File.dirname(__FILE__)
assert @application.static?
end
it 'is enabled on Application when root is set and root/public_folder exists' do
@application.set :environment, :development
@application.set :root, File.dirname(__FILE__)
assert @application.static?
end
it 'is possible to use Module#public' do
@base.send(:define_method, :foo) { }
@base.send(:private, :foo)
assert !@base.public_method_defined?(:foo)
@base.send(:public, :foo)
assert @base.public_method_defined?(:foo)
end
it 'is possible to use the keyword public in a sinatra app' do
app = Sinatra.new do
private
def priv; end
public
def pub; end
end
assert !app.public_method_defined?(:priv)
assert app.public_method_defined?(:pub)
end
end
describe 'bind' do
it 'defaults to 0.0.0.0' do
assert_equal '0.0.0.0', @base.bind
assert_equal '0.0.0.0', @application.bind
end
end
describe 'port' do
it 'defaults to 4567' do
assert_equal 4567, @base.port
assert_equal 4567, @application.port
end
end
describe 'server' do
it 'includes webrick' do
assert @base.server.include?('webrick')
assert @application.server.include?('webrick')
end
it 'includes puma' do
assert @base.server.include?('puma')
assert @application.server.include?('puma')
end
it 'includes thin' do
next if RUBY_ENGINE == 'jruby'
assert @base.server.include?('thin')
assert @application.server.include?('thin')
end
end
describe 'app_file' do
it 'is nil for base classes' do
assert_nil Sinatra::Base.app_file
assert_nil Sinatra::Application.app_file
end
it 'defaults to the file subclassing' do
assert_equal File.expand_path(__FILE__), Sinatra.new.app_file
end
end
describe 'root' do
it 'is nil if app_file is not set' do
assert @base.root.nil?
assert @application.root.nil?
end
it 'is equal to the expanded basename of app_file' do
@base.app_file = __FILE__
assert_equal File.expand_path(File.dirname(__FILE__)), @base.root
@application.app_file = __FILE__
assert_equal File.expand_path(File.dirname(__FILE__)), @application.root
end
end
describe 'views' do
it 'is nil if root is not set' do
assert @base.views.nil?
assert @application.views.nil?
end
it 'is set to root joined with views/' do
@base.root = File.dirname(__FILE__)
assert_equal File.dirname(__FILE__) + "/views", @base.views
@application.root = File.dirname(__FILE__)
assert_equal File.dirname(__FILE__) + "/views", @application.views
end
end
describe 'public_folder' do
it 'is nil if root is not set' do
assert @base.public_folder.nil?
assert @application.public_folder.nil?
end
it 'is set to root joined with public/' do
@base.root = File.dirname(__FILE__)
assert_equal File.dirname(__FILE__) + "/public", @base.public_folder
@application.root = File.dirname(__FILE__)
assert_equal File.dirname(__FILE__) + "/public", @application.public_folder
end
end
describe 'public_dir' do
it 'is an alias for public_folder' do
@base.public_dir = File.dirname(__FILE__)
assert_equal File.dirname(__FILE__), @base.public_dir
assert_equal @base.public_folder, @base.public_dir
@application.public_dir = File.dirname(__FILE__)
assert_equal File.dirname(__FILE__), @application.public_dir
assert_equal @application.public_folder, @application.public_dir
end
end
describe 'lock' do
it 'is disabled by default' do
assert ! @base.lock?
assert ! @application.lock?
end
end
describe 'protection' do
class MiddlewareTracker < Rack::Builder
def self.track
Rack.send :remove_const, :Builder
Rack.const_set :Builder, MiddlewareTracker
MiddlewareTracker.used.clear
yield
ensure
Rack.send :remove_const, :Builder
Rack.const_set :Builder, MiddlewareTracker.superclass
end
def self.used
@used ||= []
end
def use(middleware, *)
MiddlewareTracker.used << middleware
super
end
end
it 'sets up Rack::Protection' do
MiddlewareTracker.track do
Sinatra::Base.new
assert_include MiddlewareTracker.used, Rack::Protection
end
end
it 'sets up Rack::Protection::PathTraversal' do
MiddlewareTracker.track do
Sinatra::Base.new
assert_include MiddlewareTracker.used, Rack::Protection::PathTraversal
end
end
it 'does not set up Rack::Protection::PathTraversal when disabling it' do
MiddlewareTracker.track do
Sinatra.new { set :protection, :except => :path_traversal }.new
assert_include MiddlewareTracker.used, Rack::Protection
assert !MiddlewareTracker.used.include?(Rack::Protection::PathTraversal)
end
end
it 'sets up RemoteToken if sessions are enabled' do
MiddlewareTracker.track do
Sinatra.new { enable :sessions }.new
assert_include MiddlewareTracker.used, Rack::Protection::RemoteToken
end
end
it 'does not set up RemoteToken if sessions are disabled' do
MiddlewareTracker.track do
Sinatra.new.new
assert !MiddlewareTracker.used.include?(Rack::Protection::RemoteToken)
end
end
it 'sets up RemoteToken if it is configured to' do
MiddlewareTracker.track do
Sinatra.new { set :protection, :session => true }.new
assert_include MiddlewareTracker.used, Rack::Protection::RemoteToken
end
end
end
end
sinatra-1.4.3/test/less_test.rb 0000644 0000041 0000041 00000003475 12161612727 016537 0 ustar www-data www-data require File.expand_path('../helper', __FILE__)
begin
require 'less'
class LessTest < Test::Unit::TestCase
def less_app(options = {}, &block)
mock_app do
set :views, File.dirname(__FILE__) + '/views'
set options
get('/', &block)
end
get '/'
end
it 'renders inline Less strings' do
less_app {
less "@white_color: #fff; #main { background-color: @white_color }"
}
assert ok?
assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
end
it 'defaults content type to css' do
less_app {
less "@white_color: #fff; #main { background-color: @white_color }"
}
assert ok?
assert_equal "text/css;charset=utf-8", response['Content-Type']
end
it 'defaults allows setting content type per route' do
less_app do
content_type :html
less "@white_color: #fff; #main { background-color: @white_color }"
end
assert ok?
assert_equal "text/html;charset=utf-8", response['Content-Type']
end
it 'defaults allows setting content type globally' do
less_app(:less => { :content_type => 'html' }) do
less "@white_color: #fff; #main { background-color: @white_color }"
end
assert ok?
assert_equal "text/html;charset=utf-8", response['Content-Type']
end
it 'renders .less files in views path' do
less_app { less :hello }
assert ok?
assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
end
it 'ignores the layout option' do
less_app { less :hello, :layout => :layout2 }
assert ok?
assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
end
it "raises error if template not found" do
mock_app { get('/') { less :no_such_template } }
assert_raise(Errno::ENOENT) { get('/') }
end
end
rescue LoadError
warn "#{$!.to_s}: skipping less tests"
end
sinatra-1.4.3/test/markdown_test.rb 0000644 0000041 0000041 00000004032 12161612727 017401 0 ustar www-data www-data require File.expand_path('../helper', __FILE__)
MarkdownTest = proc do
def markdown_app(&block)
mock_app do
set :views, File.dirname(__FILE__) + '/views'
get('/', &block)
end
get '/'
end
def setup
Tilt.prefer engine, 'markdown', 'mkd', 'md'
super
end
it 'uses the correct engine' do
assert_equal engine, Tilt[:md]
assert_equal engine, Tilt[:mkd]
assert_equal engine, Tilt[:markdown]
end
it 'renders inline markdown strings' do
markdown_app { markdown '# Hiya' }
assert ok?
assert_like "Hiya
\n", body end it 'renders .markdown files in views path' do markdown_app { markdown :hello } assert ok? assert_like "Hello From Markdown
", body end it "raises error if template not found" do mock_app { get('/') { markdown :no_such_template } } assert_raise(Errno::ENOENT) { get('/') } end it "renders with inline layouts" do mock_app do layout { 'THIS. IS. #{yield.upcase}!' } get('/') { markdown 'Sparta', :layout_engine => :str } end get '/' assert ok? assert_like 'THIS. IS.SPARTA
!', body end it "renders with file layouts" do markdown_app { markdown 'Hello World', :layout => :layout2, :layout_engine => :erb } assert ok? assert_body "ERB Layout!\nHello World
" end it "can be used in a nested fashion for partials and whatnot" do mock_app do template(:inner) { "hi" } template(:outer) { "hi
Not Found
" end } get '/foo' assert_equal 404, status assert_equal 'text/html;charset=utf-8', response["Content-Type"] assert_equal "Not Found
", response.body end it "recalculates body length correctly for 404 response" do mock_app { get '/' do @response["Content-Length"] = "30" raise Sinatra::NotFound end } get "/" assert_equal "18", response["Content-Length"] assert_equal 404, status end it 'matches empty PATH_INFO to "/" if no route is defined for ""' do mock_app do get '/' do 'worked' end end get '/', {}, "PATH_INFO" => "" assert ok? assert_equal 'worked', body end it 'matches empty PATH_INFO to "" if a route is defined for ""' do mock_app do disable :protection get '/' do 'did not work' end get '' do 'worked' end end get '/', {}, "PATH_INFO" => "" assert ok? assert_equal 'worked', body end it 'takes multiple definitions of a route' do mock_app { user_agent(/Foo/) get '/foo' do 'foo' end get '/foo' do 'not foo' end } get '/foo', {}, 'HTTP_USER_AGENT' => 'Foo' assert ok? assert_equal 'foo', body get '/foo' assert ok? assert_equal 'not foo', body end it "exposes params with indifferent hash" do mock_app { get '/:foo' do assert_equal 'bar', params['foo'] assert_equal 'bar', params[:foo] 'well, alright' end } get '/bar' assert_equal 'well, alright', body end it "merges named params and query string params in params" do mock_app { get '/:foo' do assert_equal 'bar', params['foo'] assert_equal 'biz', params['baz'] end } get '/bar?baz=biz' assert ok? end it "supports named params like /hello/:person" do mock_app { get '/hello/:person' do "Hello #{params['person']}" end } get '/hello/Frank' assert_equal 'Hello Frank', body end it "supports optional named params like /?:foo?/?:bar?" do mock_app { get '/?:foo?/?:bar?' do "foo=#{params[:foo]};bar=#{params[:bar]}" end } get '/hello/world' assert ok? assert_equal "foo=hello;bar=world", body get '/hello' assert ok? assert_equal "foo=hello;bar=", body get '/' assert ok? assert_equal "foo=;bar=", body end it "supports named captures like %r{/hello/(?Hiya
", body end it 'renders .slim files in views path' do slim_app { slim :hello } assert ok? assert_equal "Hello From Slim
", body end it "renders with inline layouts" do mock_app do layout { %(h1\n | THIS. IS. \n == yield.upcase ) } get('/') { slim 'em Sparta' } end get '/' assert ok? assert_equal "THIS. IS. SPARTA
", body end it "renders with file layouts" do slim_app { slim('| Hello World', :layout => :layout2) } assert ok? assert_equal "Slim Layout!
Hello World
", body end it "raises error if template not found" do mock_app { get('/') { slim(:no_such_template) } } assert_raise(Errno::ENOENT) { get('/') } end HTML4_DOCTYPE = "" it "passes slim options to the slim engine" do mock_app { get('/') { slim("x foo='bar'", :attr_wrapper => "'") }} get '/' assert ok? assert_body "Title
\nSubtitle
\nContents.
\n" end end rescue LoadError warn "#{$!.to_s}: skipping slim tests" end sinatra-1.4.3/test/rabl_test.rb 0000644 0000041 0000041 00000003714 12161612727 016505 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) begin require 'rabl' require 'ostruct' require 'json' require 'active_support/core_ext/hash/conversions' class RablTest < Test::Unit::TestCase def rabl_app(&block) mock_app { set :views, File.dirname(__FILE__) + '/views' get '/', &block } get '/' end it 'renders inline rabl strings' do rabl_app do @foo = OpenStruct.new(:baz => 'w00t') rabl %q{ object @foo attributes :baz } end assert ok? assert_equal '{"openstruct":{"baz":"w00t"}}', body end it 'renders .rabl files in views path' do rabl_app do @foo = OpenStruct.new(:bar => 'baz') rabl :hello end assert ok? assert_equal '{"openstruct":{"bar":"baz"}}', body end it "renders with file layouts" do rabl_app { @foo = OpenStruct.new(:bar => 'baz') rabl :hello, :layout => :layout2 } assert ok? assert_equal '{"qux":{"openstruct":{"bar":"baz"}}}', body end it "raises error if template not found" do mock_app { get('/') { rabl :no_such_template } } assert_raise(Errno::ENOENT) { get('/') } end it "passes rabl options to the rabl engine" do mock_app do get('/') do @foo = OpenStruct.new(:bar => 'baz') rabl %q{ object @foo attributes :bar }, :format => 'xml' end end get '/' assert ok? assert_body 'Hello From String
sinatra-1.4.3/test/views/layout2.liquid 0000644 0000041 0000041 00000000053 12161612727 020137 0 ustar www-data www-dataLiquid Layout!
{{ yield }}
sinatra-1.4.3/test/views/layout2.str 0000644 0000041 0000041 00000000040 12161612727 017454 0 ustar www-data www-dataString Layout!
#{yield} sinatra-1.4.3/test/views/layout2.nokogiri 0000644 0000041 0000041 00000000041 12161612727 020466 0 ustar www-data www-data xml.layout do xml << yield end sinatra-1.4.3/test/views/hello.test 0000644 0000041 0000041 00000000015 12161612727 017331 0 ustar www-data www-data Hello World! sinatra-1.4.3/test/views/hello.coffee 0000644 0000041 0000041 00000000015 12161612727 017601 0 ustar www-data www-data alert "Aye!" sinatra-1.4.3/test/views/b/ 0000755 0000041 0000041 00000000000 12161612727 015552 5 ustar www-data www-data sinatra-1.4.3/test/views/b/in_b.str 0000644 0000041 0000041 00000000013 12161612727 017205 0 ustar www-data www-data Gimme a B! sinatra-1.4.3/test/views/hello.sass 0000644 0000041 0000041 00000000040 12161612727 017321 0 ustar www-data www-data #sass :background-color white sinatra-1.4.3/test/views/layout2.slim 0000644 0000041 0000041 00000000035 12161612727 017614 0 ustar www-data www-data h1 Slim Layout! p == yield sinatra-1.4.3/test/views/layout2.mab 0000644 0000041 0000041 00000000041 12161612727 017404 0 ustar www-data www-data h1 "Markaby Layout!" p { yield } sinatra-1.4.3/test/views/layout2.test 0000644 0000041 0000041 00000000012 12161612727 017622 0 ustar www-data www-data Layout 2! sinatra-1.4.3/test/views/utf8.erb 0000644 0000041 0000041 00000000077 12161612727 016715 0 ustar www-data www-data<%= value %>
Ingen vill veta var du köpt din tröja. sinatra-1.4.3/test/views/hello.textile 0000644 0000041 0000041 00000000027 12161612727 020033 0 ustar www-data www-data h1. Hello From Textile sinatra-1.4.3/test/views/hello.styl 0000644 0000041 0000041 00000000020 12161612727 017341 0 ustar www-data www-data a margin auto sinatra-1.4.3/test/views/hello.rabl 0000644 0000041 0000041 00000000034 12161612727 017273 0 ustar www-data www-data object @foo attributes :bar sinatra-1.4.3/test/views/hello.rdoc 0000644 0000041 0000041 00000000022 12161612727 017277 0 ustar www-data www-data = Hello From RDoc sinatra-1.4.3/test/views/calc.html.erb 0000644 0000041 0000041 00000000014 12161612727 017663 0 ustar www-data www-data <%= 1 + 1 %> sinatra-1.4.3/test/views/hello.creole 0000644 0000041 0000041 00000000024 12161612727 017623 0 ustar www-data www-data = Hello From Creole sinatra-1.4.3/test/views/a/ 0000755 0000041 0000041 00000000000 12161612727 015551 5 ustar www-data www-data sinatra-1.4.3/test/views/a/in_a.str 0000644 0000041 0000041 00000000014 12161612727 017204 0 ustar www-data www-data Gimme an A! sinatra-1.4.3/test/views/layout2.wlang 0000644 0000041 0000041 00000000027 12161612727 017761 0 ustar www-data www-data WLang Layout! +{yield} sinatra-1.4.3/test/views/error.sass 0000644 0000041 0000041 00000000026 12161612727 017353 0 ustar www-data www-data #sass +argle-bargle sinatra-1.4.3/test/views/hello.nokogiri 0000644 0000041 0000041 00000000047 12161612727 020200 0 ustar www-data www-data xml.exclaim "You're my boy, #{@name}!" sinatra-1.4.3/test/views/layout2.haml 0000644 0000041 0000041 00000000033 12161612727 017567 0 ustar www-data www-data %h1 HAML Layout! %p= yield sinatra-1.4.3/test/views/ascii.erb 0000644 0000041 0000041 00000000055 12161612727 017113 0 ustar www-data www-data This file has no unicode in it! <%= value %> sinatra-1.4.3/test/views/error.erb 0000644 0000041 0000041 00000000203 12161612727 017147 0 ustar www-data www-data Hello <%= 'World' %> <% raise 'Goodbye' unless defined?(french) && french %> <% raise 'Au revoir' if defined?(french) && french %> sinatra-1.4.3/test/views/hello.less 0000644 0000041 0000041 00000000101 12161612727 017314 0 ustar www-data www-data @white_colour: #fff; #main { background-color: @white_colour; } sinatra-1.4.3/test/views/hello.haml 0000644 0000041 0000041 00000000024 12161612727 017273 0 ustar www-data www-data %h1 Hello From Haml sinatra-1.4.3/test/views/hello.radius 0000644 0000041 0000041 00000000033 12161612727 017641 0 ustar www-data www-dataHello From Radius
sinatra-1.4.3/test/views/hello.scss 0000644 0000041 0000041 00000000043 12161612727 017326 0 ustar www-data www-data #scss { background-color: white } sinatra-1.4.3/test/views/hello.md 0000644 0000041 0000041 00000000025 12161612727 016753 0 ustar www-data www-data # Hello From Markdown sinatra-1.4.3/test/views/hello.mab 0000644 0000041 0000041 00000000030 12161612727 017106 0 ustar www-data www-data h1 "Hello From Markaby" sinatra-1.4.3/test/views/error.builder 0000644 0000041 0000041 00000000043 12161612727 020027 0 ustar www-data www-data xml.error do raise "goodbye" end sinatra-1.4.3/test/views/hello.wlang 0000644 0000041 0000041 00000000022 12161612727 017460 0 ustar www-data www-data Hello from wlang! sinatra-1.4.3/test/views/layout2.rabl 0000644 0000041 0000041 00000000050 12161612727 017565 0 ustar www-data www-data node(:qux) do ::JSON.parse(yield) end sinatra-1.4.3/test/views/foo/ 0000755 0000041 0000041 00000000000 12161612727 016114 5 ustar www-data www-data sinatra-1.4.3/test/views/foo/hello.test 0000644 0000041 0000041 00000000035 12161612727 020116 0 ustar www-data www-data from another views directory sinatra-1.4.3/test/views/layout2.erb 0000644 0000041 0000041 00000000031 12161612727 017414 0 ustar www-data www-data ERB Layout! <%= yield %> sinatra-1.4.3/test/views/hello.slim 0000644 0000041 0000041 00000000023 12161612727 017315 0 ustar www-data www-data h1 Hello From Slim sinatra-1.4.3/test/views/hello.liquid 0000644 0000041 0000041 00000000033 12161612727 017641 0 ustar www-data www-dataHello From Liquid
sinatra-1.4.3/test/views/nested.str 0000644 0000041 0000041 00000000051 12161612727 017341 0 ustar www-data www-dataRadius Layout!
Hiya
", body end it 'renders .textile files in views path' do textile_app { textile(:hello) } assert ok? assert_equal "Hello From Textile
", body end it "raises error if template not found" do mock_app { get('/') { textile(:no_such_template) } } assert_raise(Errno::ENOENT) { get('/') } end it "renders with inline layouts" do mock_app do layout { 'THIS. IS. #{yield.upcase}!' } get('/') { textile('Sparta', :layout_engine => :str) } end get '/' assert ok? assert_like 'THIS. IS.SPARTA
!', body end it "renders with file layouts" do textile_app { textile('Hello World', :layout => :layout2, :layout_engine => :erb) } assert ok? assert_body "ERB Layout!\nHello World
" end it "can be used in a nested fashion for partials and whatnot" do mock_app do template(:inner) { "hi" } template(:outer) { "hi
SPARTA
!', body end it "renders with file layouts" do rdoc_app { rdoc 'Hello World', :layout => :layout2, :layout_engine => :erb } assert ok? assert_body "ERB Layout!\nHello World
" end it "can be used in a nested fashion for partials and whatnot" do mock_app do template(:inner) { "hi" } template(:outer) { "hi
String Layout!
\nHello From String
String Layout!
\nString Layout!
\nHello From String
String Layout!
\nHello From String
content
', { :layout => :my_layout }, { :name => 'Mike'}) end end get '/' assert ok? assert_equal 'Hello Mike!content
', body end it 'sets layout-only options via layout_options' do render_app do render(:str, :in_a, :views => settings.views + '/a', :layout_options => { :views => settings.views }, :layout => :layout2) end assert ok? assert_equal "String Layout!
\nGimme an A!\n", body end it 'loads templates defined in subclasses' do base = Class.new(Sinatra::Base) base.template(:foo) { 'bar' } render_app(base) { render(:test, :foo) } assert ok? assert_equal 'bar', body end it 'allows setting default content type per template engine' do render_app(:str => { :content_type => :txt }) { render :str, 'foo' } assert_equal 'text/plain;charset=utf-8', response['Content-Type'] end it 'setting default content type does not affect other template engines' do render_app(:str => { :content_type => :txt }) { render :test, 'foo' } assert_equal 'text/html;charset=utf-8', response['Content-Type'] end it 'setting default content type per template engine does not override content_type' do render_app :str => { :content_type => :txt } do content_type :html render :str, 'foo' end assert_equal 'text/html;charset=utf-8', response['Content-Type'] end it 'uses templates in superclasses before subclasses' do base = Class.new(Sinatra::Base) base.template(:foo) { 'template in superclass' } assert_equal 'template in superclass', base.templates[:foo].first.call mock_app(base) do set :views, File.dirname(__FILE__) + '/views' template(:foo) { 'template in subclass' } get('/') { render :test, :foo } end assert_equal 'template in subclass', @app.templates[:foo].first.call get '/' assert ok? assert_equal 'template in subclass', body end it "is possible to use a different engine for the layout than for the template itself explicitly" do render_app do settings.template(:layout) { 'Hello <%= yield %>!' } render :str, "<%= 'World' %>", :layout_engine => :erb end assert_equal "Hello <%= 'World' %>!", body end it "is possible to use a different engine for the layout than for the template itself globally" do render_app :str => { :layout_engine => :erb } do settings.template(:layout) { 'Hello <%= yield %>!' } render :str, "<%= 'World' %>" end assert_equal "Hello <%= 'World' %>!", body end it "does not leak the content type to the template" do render_app :str => { :layout_engine => :erb } do settings.template(:layout) { 'Hello <%= yield %>!' } render :str, "<%= 'World' %>", :content_type => :txt end assert_equal "text/html;charset=utf-8", headers['Content-Type'] end it "is possible to register another template" do Tilt.register "html.erb", Tilt[:erb] render_app { render :erb, :calc } assert_equal '2', body end it "passes scope to the template" do mock_app do template(:scoped) { 'Hello <%= foo %>' } get('/') do some_scope = Object.new def some_scope.foo() 'World!' end erb :scoped, :scope => some_scope end end get '/' assert ok? assert_equal 'Hello World!', body end it "is possible to use custom logic for finding template files" do mock_app do set :views, ["a", "b"].map { |d| File.dirname(__FILE__) + '/views/' + d } def find_template(views, name, engine, &block) Array(views).each { |v| super(v, name, engine, &block) } end get('/:name') { render(:str, params[:name].to_sym) } end get '/in_a' assert_body 'Gimme an A!' get '/in_b' assert_body 'Gimme a B!' end end # __END__ : this is not the real end of the script. __END__ @@ foo this is foo @@ bar There's a space after 'bar'! @@ foo bar this is not foo @@ umlaut Den som tror at hemma det är där man bor har aldrig vart hos mig. @@ layout X = yield X sinatra-1.4.3/test/extensions_test.rb 0000644 0000041 0000041 00000005310 12161612727 017756 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class ExtensionsTest < Test::Unit::TestCase module FooExtensions def foo end private def im_hiding_in_ur_foos end end module BarExtensions def bar end end module BazExtensions def baz end end module QuuxExtensions def quux end end module PainExtensions def foo=(name); end def bar?(name); end def fizz!(name); end end it 'will add the methods to the DSL for the class in which you register them and its subclasses' do Sinatra::Base.register FooExtensions assert Sinatra::Base.respond_to?(:foo) Sinatra::Application.register BarExtensions assert Sinatra::Application.respond_to?(:bar) assert Sinatra::Application.respond_to?(:foo) assert !Sinatra::Base.respond_to?(:bar) end it 'allows extending by passing a block' do Sinatra::Base.register { def im_in_ur_anonymous_module; end } assert Sinatra::Base.respond_to?(:im_in_ur_anonymous_module) end it 'will make sure any public methods added via Application#register are delegated to Sinatra::Delegator' do Sinatra::Application.register FooExtensions assert Sinatra::Delegator.private_instance_methods. map { |m| m.to_sym }.include?(:foo) assert !Sinatra::Delegator.private_instance_methods. map { |m| m.to_sym }.include?(:im_hiding_in_ur_foos) end it 'will handle special method names' do Sinatra::Application.register PainExtensions assert Sinatra::Delegator.private_instance_methods. map { |m| m.to_sym }.include?(:foo=) assert Sinatra::Delegator.private_instance_methods. map { |m| m.to_sym }.include?(:bar?) assert Sinatra::Delegator.private_instance_methods. map { |m| m.to_sym }.include?(:fizz!) end it 'will not delegate methods on Base#register' do Sinatra::Base.register QuuxExtensions assert !Sinatra::Delegator.private_instance_methods.include?("quux") end it 'will extend the Sinatra::Application application by default' do Sinatra.register BazExtensions assert !Sinatra::Base.respond_to?(:baz) assert Sinatra::Application.respond_to?(:baz) end module BizzleExtension def bizzle bizzle_option end def self.registered(base) fail "base should be BizzleApp" unless base == BizzleApp fail "base should have already extended BizzleExtension" unless base.respond_to?(:bizzle) base.set :bizzle_option, 'bizzle!' end end class BizzleApp < Sinatra::Base end it 'sends .registered to the extension module after extending the class' do BizzleApp.register BizzleExtension assert_equal 'bizzle!', BizzleApp.bizzle_option assert_equal 'bizzle!', BizzleApp.bizzle end end sinatra-1.4.3/test/contest.rb 0000644 0000041 0000041 00000006745 12161612727 016214 0 ustar www-data www-data # Copyright (c) 2009 Damian Janowski and Michel Martens for Citrusbyte # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. require "test/unit" # Test::Unit loads a default test if the suite is empty, whose purpose is to # fail. Since having empty contexts is a common practice, we decided to # overwrite TestSuite#empty? in order to allow them. Having a failure when no # tests have been defined seems counter-intuitive. class Test::Unit::TestSuite def empty? false end end # Contest adds +teardown+, +test+ and +context+ as class methods, and the # instance methods +setup+ and +teardown+ now iterate on the corresponding # blocks. Note that all setup and teardown blocks must be defined with the # block syntax. Adding setup or teardown instance methods defeats the purpose # of this library. class Test::Unit::TestCase def self.setup(&block) setup_blocks << block end def self.teardown(&block) teardown_blocks << block end def self.setup_blocks() @setup_blocks ||= [] end def self.teardown_blocks() @teardown_blocks ||= [] end def setup_blocks(base = self.class) setup_blocks base.superclass if base.superclass.respond_to? :setup_blocks base.setup_blocks.each do |block| instance_eval(&block) end end def teardown_blocks(base = self.class) teardown_blocks base.superclass if base.superclass.respond_to? :teardown_blocks base.teardown_blocks.each do |block| instance_eval(&block) end end alias setup setup_blocks alias teardown teardown_blocks def self.context(*name, &block) subclass = Class.new(self) remove_tests(subclass) subclass.class_eval(&block) if block_given? const_set(context_name(name.join(" ")), subclass) end def self.test(name, &block) define_method(test_name(name), &block) end class << self alias_method :should, :test alias_method :describe, :context end private def self.context_name(name) # "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}".to_sym name = "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}" name.tr(" ", "_").to_sym end def self.test_name(name) name = "test_#{sanitize_name(name).gsub(/\s+/,'_')}_0" name = name.succ while method_defined? name name.to_sym end def self.sanitize_name(name) # name.gsub(/\W+/, ' ').strip name.gsub(/\W+/, ' ') end def self.remove_tests(subclass) subclass.public_instance_methods.grep(/^test_/).each do |meth| subclass.send(:undef_method, meth.to_sym) end end end sinatra-1.4.3/test/route_added_hook_test.rb 0000644 0000041 0000041 00000002522 12161612727 021060 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) module RouteAddedTest @routes, @procs = [], [] def self.routes ; @routes ; end def self.procs ; @procs ; end def self.route_added(verb, path, proc) @routes << [verb, path] @procs << proc end end class RouteAddedHookTest < Test::Unit::TestCase setup do RouteAddedTest.routes.clear RouteAddedTest.procs.clear end it "should be notified of an added route" do mock_app(Class.new(Sinatra::Base)) do register RouteAddedTest get('/') {} end assert_equal [["GET", "/"], ["HEAD", "/"]], RouteAddedTest.routes end it "should include hooks from superclass" do a = Class.new(Class.new(Sinatra::Base)) b = Class.new(a) a.register RouteAddedTest b.class_eval { post("/sub_app_route") {} } assert_equal [["POST", "/sub_app_route"]], RouteAddedTest.routes end it "should only run once per extension" do mock_app(Class.new(Sinatra::Base)) do register RouteAddedTest register RouteAddedTest get('/') {} end assert_equal [["GET", "/"], ["HEAD", "/"]], RouteAddedTest.routes end it "should pass route blocks as an argument" do mock_app(Class.new(Sinatra::Base)) do register RouteAddedTest get('/') {} end assert_kind_of Proc, RouteAddedTest.procs.first end end sinatra-1.4.3/test/static_test.rb 0000644 0000041 0000041 00000016022 12161612727 017050 0 ustar www-data www-data require File.expand_path('../helper', __FILE__) class StaticTest < Test::Unit::TestCase setup do mock_app do set :static, true set :public_folder, File.dirname(__FILE__) end end it 'serves GET requests for files in the public directory' do get "/#{File.basename(__FILE__)}" assert ok? assert_equal File.read(__FILE__), body assert_equal File.size(__FILE__).to_s, response['Content-Length'] assert response.headers.include?('Last-Modified') end it 'produces a body that can be iterated over multiple times' do env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}") status, headers, body = @app.call(env) buf1, buf2 = [], [] body.each { |part| buf1 << part } body.each { |part| buf2 << part } assert_equal buf1.join, buf2.join assert_equal File.read(__FILE__), buf1.join end it 'sets the sinatra.static_file env variable if served' do env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}") status, headers, body = @app.call(env) assert_equal File.expand_path(__FILE__), env['sinatra.static_file'] end it 'serves HEAD requests for files in the public directory' do head "/#{File.basename(__FILE__)}" assert ok? assert_equal '', body assert response.headers.include?('Last-Modified') assert_equal File.size(__FILE__).to_s, response['Content-Length'] end %w[POST PUT DELETE].each do |verb| it "does not serve #{verb} requests" do send verb.downcase, "/#{File.basename(__FILE__)}" assert_equal 404, status end end it 'serves files in preference to custom routes' do @app.get("/#{File.basename(__FILE__)}") { 'Hello World' } get "/#{File.basename(__FILE__)}" assert ok? assert body != 'Hello World' end it 'does not serve directories' do get "/" assert not_found? end it 'passes to the next handler when the static option is disabled' do @app.set :static, false get "/#{File.basename(__FILE__)}" assert not_found? end it 'passes to the next handler when the public option is nil' do @app.set :public_folder, nil get "/#{File.basename(__FILE__)}" assert not_found? end it '404s when a file is not found' do get "/foobarbaz.txt" assert not_found? end it 'serves files when .. path traverses within public directory' do get "/data/../#{File.basename(__FILE__)}" assert ok? assert_equal File.read(__FILE__), body end it '404s when .. path traverses outside of public directory' do mock_app do set :static, true set :public_folder, File.dirname(__FILE__) + '/data' end get "/../#{File.basename(__FILE__)}" assert not_found? end def assert_valid_range(http_range, range, path, file) request = Rack::MockRequest.new(@app) response = request.get("/#{File.basename(path)}", 'HTTP_RANGE' => http_range) should_be = file[range] expected_range = "bytes #{range.begin}-#{range.end}/#{file.length}" assert_equal( 206,response.status, "Should be HTTP/1.1 206 Partial content" ) assert_equal( should_be.length, response.body.length, "Unexpected response length for #{http_range}" ) assert_equal( should_be, response.body, "Unexpected response data for #{http_range}" ) assert_equal( should_be.length.to_s, response['Content-Length'], "Incorrect Content-Length for #{http_range}" ) assert_equal( expected_range, response['Content-Range'], "Incorrect Content-Range for #{http_range}" ) end it 'handles valid byte ranges correctly' do # Use the biggest file in this dir so we can test ranges > 8k bytes. (StaticFile sends in 8k chunks.) path = File.dirname(__FILE__) + '/helpers_test.rb' # currently 16k bytes file = File.read(path) length = file.length assert length > 9000, "The test file #{path} is too short (#{length} bytes) to run these tests" [0..0, 42..88, 1234..1234, 100..9000, 0..(length-1), (length-1)..(length-1)].each do |range| assert_valid_range("bytes=#{range.begin}-#{range.end}", range, path, file) end [0, 100, length-100, length-1].each do |start| assert_valid_range("bytes=#{start}-", (start..length-1), path, file) end [1, 100, length-100, length-1, length].each do |range_length| assert_valid_range("bytes=-#{range_length}", (length-range_length..length-1), path, file) end # Some valid ranges that exceed the length of the file: assert_valid_range("bytes=100-999999", (100..length-1), path, file) assert_valid_range("bytes=100-#{length}", (100..length-1), path, file) assert_valid_range("bytes=-#{length}", (0..length-1), path, file) assert_valid_range("bytes=-#{length+1}", (0..length-1), path, file) assert_valid_range("bytes=-999999", (0..length-1), path, file) end it 'correctly ignores syntactically invalid range requests' do # ...and also ignores multi-range requests, which aren't supported yet ["bytes=45-40", "bytes=IV-LXVI", "octets=10-20", "bytes=-", "bytes=1-2,3-4"].each do |http_range| request = Rack::MockRequest.new(@app) response = request.get("/#{File.basename(__FILE__)}", 'HTTP_RANGE' => http_range) assert_equal( 200, response.status, "Invalid range '#{http_range}' should be ignored" ) assert_equal( nil, response['Content-Range'], "Invalid range '#{http_range}' should be ignored" ) end end it 'returns error 416 for unsatisfiable range requests' do # An unsatisfiable request is one that specifies a start that's at or past the end of the file. length = File.read(__FILE__).length ["bytes=888888-", "bytes=888888-999999", "bytes=#{length}-#{length}"].each do |http_range| request = Rack::MockRequest.new(@app) response = request.get("/#{File.basename(__FILE__)}", 'HTTP_RANGE' => http_range) assert_equal( 416, response.status, "Unsatisfiable range '#{http_range}' should return 416" ) assert_equal( "bytes */#{length}", response['Content-Range'], "416 response should include actual length" ) end end it 'does not include static cache control headers by default' do env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}") status, headers, body = @app.call(env) assert !headers.has_key?('Cache-Control') end it 'sets cache control headers on static files if set' do @app.set :static_cache_control, :public env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}") status, headers, body = @app.call(env) assert headers.has_key?('Cache-Control') assert_equal headers['Cache-Control'], 'public' @app.set( :static_cache_control, [:public, :must_revalidate, {:max_age => 300}] ) env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}") status, headers, body = @app.call(env) assert headers.has_key?('Cache-Control') assert_equal( headers['Cache-Control'], 'public, must-revalidate, max-age=300' ) end end sinatra-1.4.3/README.ko.md 0000644 0000041 0000041 00000212535 12161612727 015114 0 ustar www-data www-data # Sinatra *주의: 이 문서는 영문판의 번역본이며 최신판 문서와 다를 수 있음.* Sinatra는 최소한의 노력으로 루비 기반 웹 애플리케이션을 신속하게 만들 수 있게 해 주는 [DSL](http://en.wikipedia.org/wiki/Domain-specific_language)이다: ```ruby # myapp.rb require 'sinatra' get '/' do 'Hello world!' end ``` 다음과 같이 젬을 설치하고 실행한다: ```ruby gem install sinatra ruby myapp.rb ``` 확인: http://localhost:4567 `gem install thin`도 함께 실행하기를 권장하며, 그럴 경우 Sinatra는 thin을 부른다. ## 라우터(Routes) Sinatra에서, 라우터(route)는 URL-매칭 패턴과 쌍을 이루는 HTTP 메서드다. 각각의 라우터는 블록과 연결된다: ```ruby get '/' do .. 무언가 보여주기(show) .. end post '/' do .. 무언가 만들기(create) .. end put '/' do .. 무언가 대체하기(replace) .. end patch '/' do .. 무언가 수정하기(modify) .. end delete '/' do .. 무언가 없애기(annihilate) .. end options '/' do .. 무언가 주기(appease) .. end ``` 라우터는 정의된 순서에 따라 매치되며 매칭된 첫 번째 라우터가 호출된다. 라우터 패턴에는 이름을 가진 매개변수가 포함될 수있으며, `params` 해시로 접근할 수 있다: ```ruby get '/hello/:name' do # "GET /hello/foo" 및 "GET /hello/bar"와 매치 # params[:name]은 'foo' 또는 'bar' "Hello #{params[:name]}!" end ``` 또한 블록 매개변수를 통하여도 이름을 가진 매개변수에 접근할 수 있다: ```ruby get '/hello/:name' do |n| "Hello #{n}!" end ``` 라우터 패턴에는 스플랫(splat, 또는 와일드카드)도 포함될 수 있으며, 이럴 경우 `params[:splat]` 배열로 접근할 수 있다: ```ruby get '/say/*/to/*' do # /say/hello/to/world와 매치 params[:splat] # => ["hello", "world"] end get '/download/*.*' do # /download/path/to/file.xml과 매치 params[:splat] # => ["path/to/file", "xml"] end ``` 또는 블록 매개변수도 가능하다: ```ruby get '/download/*.*' do |path, ext| [path, ext] # => ["path/to/file", "xml"] end ``` 정규표현식을 이용한 라우터 매칭: ```ruby get %r{/hello/([\w]+)} do "Hello, #{params[:captures].first}!" end ``` 또는 블록 매개변수로도 가능: ```ruby get %r{/hello/([\w]+)} do |c| "Hello, #{c}!" end ``` 라우터 패턴에는 선택적인(optional) 매개변수도 올 수 있다: ```ruby get '/posts.?:format?' do # "GET /posts" 및 "GET /posts.json", "GET /posts.xml" 와 같은 어떤 확장자와도 매칭 end ``` 한편, 경로 탐색 공격 방지(path traversal attack protection, 아래 참조)를 비활성화시키지 않았다면, 요청 경로는 라우터와 매칭되기 이전에 수정될 수 있다. ### 조건(Conditions) 라우터는 예를 들면 사용자 에이전트(user agent)와 같은 다양한 매칭 조건을 포함할 수 있다: ```ruby get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do "Songbird 버전 #{params[:agent][0]}을 사용하는군요!" end get '/foo' do # songbird 브라우저가 아닌 경우 매치 end ``` 그 밖에 다른 조건으로는 `host_name`과 `provides`가 있다: ```ruby get '/', :host_name => /^admin\./ do "Admin Area, Access denied!" end get '/', :provides => 'html' do haml :index end get '/', :provides => ['rss', 'atom', 'xml'] do builder :feed end ``` 여러분만의 조건도 쉽게 정의할 수 있다: ```ruby set(:probability) { |value| condition { rand <= value } } get '/win_a_car', :probability => 0.1 do "내가 졌소!" end get '/win_a_car' do "미안해서 어쩌나." end ``` 여러 값을 받는 조건에는 스플랫(splat)을 사용하자: ```ruby set(:auth) do |*roles| # <- 이게 스플랫 condition do unless logged_in? && roles.any? {|role| current_user.in_role? role } redirect "/login/", 303 end end end get "/my/account/", :auth => [:user, :admin] do "내 계정 정보" end get "/only/admin/", :auth => :admin do "관리자 외 접근불가!" end ``` ### 반환값(Return Values) 라우터 블록의 반환값은 HTTP 클라이언트로 전달되는 응답 본문을 결정하거나, 또는 Rack 스택에서 다음 번 미들웨어를 결정한다. 대부분의 경우, 이 반환값은 위의 예제에서 보듯 문자열이지만, 다른 값도 가능하다. 유효한 Rack 응답, Rack 본문 객체 또는 HTTP 상태 코드가 되는 어떠한 객체라도 반환할 수 있다: * 세 요소를 가진 배열: `[상태 (Fixnum), 헤더 (Hash), 응답 본문 (#each에 반응)]` * 두 요소를 가진 배열: `[상태 (Fixnum), 응답 본문 (#each에 반응)]` * `#each`에 반응하고 주어진 블록으로 문자열만을 전달하는 객체 * 상태 코드를 의미하는 Fixnum 이에 따라 우리는, 예를 들면, 스트리밍(streaming) 예제를 쉽게 구현할 수 있다: ```ruby class Stream def each 100.times { |i| yield "#{i}\n" } end end get('/') { Stream.new } ``` 이런 번거로움을 줄이기 위해 `stream` 헬퍼 메서드(아래 참조)를 사용하여 스트리밍 로직을 라우터 속에 둘 수도 있다. ### 커스텀 라우터 매처(Custom Route Matchers) 위에서 보듯, Sinatra에는 문자열 패턴 및 정규표현식을 이용한 라우터 매칭 지원이 내장되어 있다. 그렇지만, 그게 끝이 아니다. 여러분 만의 매처(matcher)도 쉽게 정의할 수 있다: ```ruby class AllButPattern Match = Struct.new(:captures) def initialize(except) @except = except @captures = Match.new([]) end def match(str) @captures unless @except === str end end def all_but(pattern) AllButPattern.new(pattern) end get all_but("/index") do # ... end ``` 사실 위의 예제는 조금 과하게 작성된 면이 있다. 다음과 같이 표현할 수도 있다: ```ruby get // do pass if request.path_info == "/index" # ... end ``` 또는 네거티브 룩어헤드(negative look ahead)를 사용할 수도 있다: ```ruby get %r{^(?!/index$)} do # ... end ``` ## 정적 파일(Static Files) 정적 파일들은 `./public`에서 제공된다. 위치를 다른 곳으로 변경하려면 `:public_folder` 옵션을 사용하면 된다: ```ruby set :public_folder, File.dirname(__FILE__) + '/static' ``` 이 때 public 디렉터리명은 URL에 포함되지 않는다는 점에 유의. `./public/css/style.css` 파일은 `http://example.com/css/style.css` 로 접근할 수 있다. `Cache-Control` 헤더 정보를 추가하려면 `:static_cache_control` 설정(아래 참조)을 사용하면 된다. ## 뷰 / 템플릿(Views / Templates) 각 템플릿 언어는 그들만의 고유한 렌더링 메서드를 통해 표출된다. 이들 메서드는 단순히 문자열을 반환한다. ```ruby get '/' do erb :index end ``` 이 메서드는 `views/index.erb`를 렌더한다. 템플릿 이름 대신 템플릿의 내용을 직접 전달할 수도 있다: ```ruby get '/' do code = "<%= Time.now %>" erb code end ``` 템플릿은 두 번째 인자로 옵션값의 해시를 받는다: ```ruby get '/' do erb :index, :layout => :post end ``` 이렇게 하면 `views/post.erb` 속에 내장된 `views/index.erb`를 렌더한다. (기본값은 `views/layout.erb`이며, 이 파일이 존재할 경우에만 먹는다). Sinatra가 이해하지 못하는 모든 옵션값들은 템플릿 엔진으로 전달될 것이다: ```ruby get '/' do haml :index, :format => :html5 end ``` 옵션값은 템플릿 언어별로 일반적으로 설정할 수도 있다: ```ruby set :haml, :format => :html5 get '/' do haml :index end ``` render 메서드에서 전달된 옵션값들은 `set`을 통해 설정한 옵션값을 덮어 쓴다. 가능한 옵션값들:- locals
- 문서로 전달되는 local 목록. 파셜과 함께 사용하기 좋음. 예제: erb "<%= foo %>", :locals => {:foo => "bar"}
- default_encoding
- 불확실한 경우에 사용할 문자열 인코딩. 기본값은 settings.default_encoding.
- views
- 템플릿을 로드할 뷰 폴더. 기본값은 settings.views.
- layout
- 레이아웃을 사용할지 여부 (true 또는 false), 만약 이 값이 심볼일 경우, 사용할 템플릿을 지정. 예제: erb :index, :layout => !request.xhr?
- content_type
- 템플릿이 생성하는 Content-Type, 기본값은 템플릿 언어에 의존.
- scope
- 템플릿을 렌더링하는 범위. 기본값은 어플리케이션 인스턴스. 만약 이 값을 변경하면, 인스턴스 변수와 헬퍼 메서드들을 사용할 수 없게 됨.
- layout_engine
- 레이아웃 렌더링에 사용할 템플릿 엔진. 레이아웃을 지원하지 않는 언어인 경우에 유용. 기본값은 템플릿에서 사용하는 엔진. 예제: set :rdoc, :layout_engine => :erb
| 의존 | haml |
| 파일 확장자 | .haml |
| 예 | haml :index, :format => :html5 |
| 의존 | erubis 또는 erb (루비 속에 포함) |
| 파일 확장자 | .erb, .rhtml 또는 .erubis (Erubis만 해당) |
| 예제 | erb :index |
| 의존 | builder |
| 파일 확장자 | .builder |
| Example | builder { |xml| xml.em "hi" } |
| 의존 | nokogiri |
| 파일 확장자 | .nokogiri |
| 예제 | nokogiri { |xml| xml.em "hi" } |
| 의존 | sass |
| 파일 확장자 | .sass |
| 예제 | sass :stylesheet, :style => :expanded |
| 의존 | sass |
| 파일 확장자 | .scss |
| 예제 | scss :stylesheet, :style => :expanded |
| 의존 | less |
| 파일 확장자 | .less |
| 예제 | less :stylesheet |
| 의존 | liquid |
| 파일 확장자 | .liquid |
| 예제 | liquid :index, :locals => { :key => 'value' } |
| 의존 | rdiscount, redcarpet, bluecloth, kramdown *또는* maruku |
| 파일 확장 | .markdown, .mkd, .md |
| 예제 | markdown :index, :layout_engine => :erb |
| 의존 | RedCloth |
| 파일 확장자 | .textile |
| 예제 | textile :index, :layout_engine => :erb |
| 의존 | rdoc |
| 파일 확장자 | .rdoc |
| 예제 | rdoc :README, :layout_engine => :erb |
| 의존 | radius |
| 파일 확장자 | .radius |
| 예제 | radius :index, :locals => { :key => 'value' } |
| 의존 | markaby |
| 파일확장 | .mab |
| 예제 | markaby { h1 "Welcome!" } |
| 의존 | rabl |
| 파일 확장자 | .rabl |
| 예제 | rabl :index |
| 의존 | slim |
| 파일 확장자 | .slim |
| 예제 | slim :index |
| 의존 | creole |
| 파일 확장자 | .creole |
| 예제 | creole :wiki, :layout_engine => :erb |
| 의존성 | coffee-script 와 자바스크립트 실행법 |
| 파일 확장자 | .coffee |
| 예제 | coffee :index |
| 의존 | yajl-ruby |
| 파일 확장자 | .yajl |
| 예제 | yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'resource' |
- filename
- 응답에서의 파일명. 기본값은 실제 파일명이다.
- last_modified
- Last-Modified 헤더값. 기본값은 파일의 mtime.
- type
- 사용할 컨텐츠 유형. 없으면 파일 확장자로부터 유추된다.
- disposition
- Content-Disposition에서 사용됨. 가능한 값들: nil (기본값), :attachment 및 :inline
- length
- Content-Length, 기본값은 파일 크기.
- status
- 전송할 상태 코드. 오류 페이지로 정적 파일을 전송할 경우에 유용.
- absolute_redirects
- 만약 비활성이면, Sinatra는 상대경로 리다이렉트를 허용할 것이지만, 이렇게 되면 Sinatra는 더 이상 오직 절대경로 리다이렉트만 허용하고 있는 RFC 2616(HTTP 1.1)에 위배될 것이다. 적정하게 설정되지 않은 리버스 프록시 하에서 앱을 실행 중이라면 활성화시킬 것. rul 헬퍼는, 만약 두 번째 매개변수로 false를 전달하지만 않는다면, 여전히 절대경로 URL을 생성할 것임에 유의하자. 기본값은 비활성.
- add_charsets
- content_type가 문자셋 정보에 자동으로 추가하게 될 마임(mime) 타입. 이 옵션은 오버라이딩하지 말고 추가해야 한다: settings.add_charsets << "application/foobar"
- app_file
- 메인 애플리케이션 파일의 경로. 프로젝트 루트와 뷰, 그리고 public 폴더, 인라인 템플릿을 파악할 때 사용됨.
- bind
- 바인드할 IP 주소(기본값: 0.0.0.0). 오직 빌트인(built-in) 서버에서만 사용됨.
- default_encoding
- 모를 때 가정할 인코딩 (기본값은 "utf-8").
- dump_errors
- 로그로 에러 출력.
- environment
- 현재 환경, 기본값은 ENV['RACK_ENV'] 또는 알 수 없을 경우 "development".
- logging
- 로거(logger) 사용.
- lock
- 매 요청에 걸쳐 잠금(lock)을 설정. Ruby 프로세스 당 요청을 동시에 할 경우. 앱이 스레드 안전(thread-safe)이 아니라면 활성화시킬 것. 기본값은 비활성.
- method_override
- put/delete를 지원하지 않는 브라우저에서 put/delete 폼을 허용하는 _method 꼼수 사용.
- port
- 접속 포트. 빌트인 서버에서만 사용됨.
- prefixed_redirects
- 절대경로가 주어지지 않은 리다이렉트에 request.script_name를 삽입할지 여부. 이렇게 하면 redirect '/foo'는 redirect to('/foo') 처럼 동작. 기본값은 비활성.
- protection
- 웹 공격 방어를 활성화시킬 건지 여부. 위의 보안 섹션 참조.
- public_folder
- public 파일이 제공될 폴더의 경로. static 파일 제공이 활성화된 경우만 사용됨(아래 static참조). 만약 설정이 없으면 app_file로부터 유추됨.
- reload_templates
- 요청 간에 템플릿을 리로드(reload)할 건지 여부. 개발 모드에서는 활성됨.
- root
- 프로젝트 루트 디렉터리 경로. 설정이 없으면 app_file 설정으로부터 유추됨.
- raise_errors
- 예외 발생(애플리케이션은 중단됨). 기본값은 environment가 "test"인 경우는 활성, 그렇지 않으면 비활성.
- run
- 활성화되면, Sinatra가 웹서버의 시작을 핸들링. rackup 또는 다른 도구를 사용하는 경우라면 활성화시키지 말 것.
- running
- 빌트인 서버가 실행 중인지? 이 설정은 변경하지 말 것!
- server
- 빌트인 서버로 사용할 서버 또는 서버 목록. 기본값은 ['thin', 'mongrel', 'webrick']이며 순서는 우선순위를 의미.
- sessions
- Rack::Session::Cookie를 사용한 쿠키 기반 세션 활성화. 보다 자세한 정보는 '세션 사용하기' 참조.
- show_exceptions
- 예외 발생 시에 브라우저에 스택 추적을 보임. 기본값은 environment가 "development"인 경우는 활성, 나머지는 비활성.
- static
- Sinatra가 정적(static) 파일을 핸들링할 지 여부. 이 기능을 수행하는 서버를 사용하는 경우라면 비활성시킬 것. 비활성시키면 성능이 올라감. 기본값은 전통적 방식에서는 활성, 모듈 앱에서는 비활성.
- static_cache_control
- Sinatra가 정적 파일을 제공하는 경우, 응답에 Cache-Control 헤더를 추가할 때 설정. cache_control 헬퍼를 사용. 기본값은 비활성. 여러 값을 설정할 경우는 명시적으로 배열을 사용할 것: set :static_cache_control, [:public, :max_age => 300]
- threaded
- true로 설정하면, Thin이 요청을 처리하는데 있어 EventMachine.defer를 사용하도록 함.
- views
- 뷰 폴더 경로. 설정하지 않은 경우 app_file로부터 유추됨.
| Setting | Classic | Modular |
|---|---|---|
| app_file | sinatra를 로딩하는 파일 | Sinatra::Base를 서브클래싱한 파일 |
| run | $0 == app_file | false |
| logging | true | false |
| method_override | true | false |
| inline_templates | true | false |
| static | true | false |
- Ruby 1.8.7
- 1.8.7은 완전하게 지원되지만, 꼭 그래야할 특별한 이유가 없다면, 1.9.2로 업그레이드하거나 또는 JRuby나 Rubinius로 전환할 것을 권장한다. 1.8.7에 대한 지원은 Sinatra 2.0과 Ruby 2.0 이전에는 중단되지 않을 것이다. 또한 그때도, 우리는 계속 지원할 것이다. Ruby 1.8.6은 더이상 지원되지 않는다. 만약 1.8.6으로 실행하려 한다면, Sinatra 1.2로 다운그레이드하라. Sinatra 1.4.0이 릴리스될 때 까지는 버그 픽스를 받을 수 있을 것이다.
- Ruby 1.9.2
- 1.9.2는 완전하게 지원되면 권장된다. Radius와 Maraby는 현재 1.9와 호환되지 않음에 유의하라. 1.9.2p0은, Sinatra를 실행했을 때 세그먼트 오류가 발생한다고 알려져 있으니 사용하지 말라. Ruby 1.9.4/2.0 릴리스까지는 적어도 지원을 계속할 것이며, 최신 1.9 릴리스에 대한 지원은 Ruby 코어팀이 지원하고 있는 한 계속 지원할 것이다.
- Ruby 1.9.3
- 1.9.3은 완전하게 지원된다. 그렇지만 프로덕션에서의 사용은 보다 상위의 패치 레벨이 릴리스될 때까지 기다리길 권장한다(현재는 p0). 이전 버전에서 1.9.3으로 전환할 경우 모든 세션이 무효화된다는 점을 유의하라.
- Rubinius
- Rubinius는 공식적으로 지원되며 (Rubinius >= 1.2.4), 모든 템플릿 언어를 포함한 모든 것들이 작동한다. 조만간 출시될 2.0 릴리스 역시 지원할 것이다.
- JRuby
- JRuby는 공식적으로 지원된다 (JRuby >= 1.6.5). 서드 파티 템플릿 라이브러리와의 문제는 알려진 바 없지만, 만약 JRuby를 사용하기로 했다면, JRuby rack 핸들러를 찾아보길 바란다. Thin 웹 서버는 JRuby에서 완전하게 지원되지 않는다. JRuby의 C 확장 지원은 아직 실험 단계이며, RDiscount, Redcarpet 및 RedCloth가 현재 이 영향을 받는다.
- locals
- List of locals passed to the document. Handy with partials. Example: erb "<%= foo %>", :locals => {:foo => "bar"}
- default_encoding
- String encoding to use if uncertain. Defaults to settings.default_encoding.
- views
- Views folder to load templates from. Defaults to settings.views.
- layout
- Whether to use a layout (true or false), if it's a Symbol, specifies what template to use. Example: erb :index, :layout => !request.xhr?
- content_type
- Content-Type the template produces, default depends on template language.
- scope
- Scope to render template under. Defaults to the application instance. If you change this, instance variables and helper methods will not be available.
- layout_engine
- Template engine to use for rendering the layout. Useful for languages that do not support layouts otherwise. Defaults to the engine used for the template. Example: set :rdoc, :layout_engine => :erb
- layout_options
- Special options only used for rendering the layout. Example: set :rdoc, :layout_options => { :views => 'views/layouts' }
| Dependency | haml |
| File Extension | .haml |
| Example | haml :index, :format => :html5 |
| Dependency | erubis or erb (included in Ruby) |
| File Extensions | .erb, .rhtml or .erubis (Erubis only) |
| Example | erb :index |
| Dependency | builder |
| File Extension | .builder |
| Example | builder { |xml| xml.em "hi" } |
| Dependency | nokogiri |
| File Extension | .nokogiri |
| Example | nokogiri { |xml| xml.em "hi" } |
| Dependency | sass |
| File Extension | .sass |
| Example | sass :stylesheet, :style => :expanded |
| Dependency | sass |
| File Extension | .scss |
| Example | scss :stylesheet, :style => :expanded |
| Dependency | less |
| File Extension | .less |
| Example | less :stylesheet |
| Dependency | liquid |
| File Extension | .liquid |
| Example | liquid :index, :locals => { :key => 'value' } |
| Dependency | Anyone of: RDiscount, RedCarpet, BlueCloth, kramdown, maruku |
| File Extensions | .markdown, .mkd and .md |
| Example | markdown :index, :layout_engine => :erb |
| Dependency | RedCloth |
| File Extension | .textile |
| Example | textile :index, :layout_engine => :erb |
| Dependency | RDoc |
| File Extension | .rdoc |
| Example | rdoc :README, :layout_engine => :erb |
| Dependency | Radius |
| File Extension | .radius |
| Example | radius :index, :locals => { :key => 'value' } |
| Dependency | Markaby |
| File Extension | .mab |
| Example | markaby { h1 "Welcome!" } |
| Dependency | Rabl |
| File Extension | .rabl |
| Example | rabl :index |
| Dependency | Slim Lang |
| File Extension | .slim |
| Example | slim :index |
| Dependency | Creole |
| File Extension | .creole |
| Example | creole :wiki, :layout_engine => :erb |
| Dependency | CoffeeScript and a way to execute javascript |
| File Extension | .coffee |
| Example | coffee :index |
| Dependency | Stylus and a way to execute javascript |
| File Extension | .styl |
| Example | stylus :index |
| Dependency | yajl-ruby |
| File Extension | .yajl |
| Example | yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'resource' |
| Dependency | wlang |
| File Extension | .wlang |
| Example | wlang :index, :locals => { :key => 'value' } |
- filename
- file name, in response, defaults to the real file name.
- last_modified
- value for Last-Modified header, defaults to the file's mtime.
- type
- content type to use, guessed from the file extension if missing. disposition
- used for Content-Disposition, possible value: nil (default), :attachment and :inline
- length
- Content-Length header, defaults to file size.
- status
- Status code to be send. Useful when sending a static file as an error page. If supported by the Rack handler, other means than streaming from the Ruby process will be used. If you use this helper method, Sinatra will automatically handle range requests.
- absolute_redirects
- If disabled, Sinatra will allow relative redirects, however, Sinatra will no longer conform with RFC 2616 (HTTP 1.1), which only allows absolute redirects.
- Enable if your app is running behind a reverse proxy that has not been set up properly. Note that the url helper will still produce absolute URLs, unless you pass in false as the second parameter.
- Disabled by default.
- add_charsets
- mime types the content_type helper will automatically add the charset info to. You should add to it rather than overriding this option: settings.add_charsets << "application/foobar"
- app_file
- Path to the main application file, used to detect project root, views and public folder and inline templates.
- bind
- IP address to bind to (default: 0.0.0.0 or localhost if your `environment` is set to development.). Only used for built-in server.
- default_encoding
- encoding to assume if unknown (defaults to "utf-8").
- dump_errors
- display errors in the log.
- environment
- current environment, defaults to ENV['RACK_ENV'], or "development" if not available.
- logging
- use the logger.
- lock
- Places a lock around every request, only running processing on request per Ruby process concurrently.
- Enabled if your app is not thread-safe. Disabled per default.
- method_override
- use _method magic to allow put/delete forms in browsers that don't support it.
- port
- Port to listen on. Only used for built-in server.
- prefixed_redirects
- Whether or not to insert request.script_name into redirects if no absolute path is given. That way redirect '/foo' would behave like redirect to('/foo'). Disabled per default.
- protection
- Whether or not to enable web attack protections. See protection section above.
- public_dir
- Alias for public_folder. See below.
- public_folder
- Path to the folder public files are served from. Only used if static file serving is enabled (see static setting below). Inferred from app_file setting if not set.
- reload_templates
- Whether or not to reload templates between requests. Enabled in development mode.
- root
- Path to project root folder. Inferred from app_file setting if not set.
- raise_errors
- raise exceptions (will stop application). Enabled by default when environment is set to "test", disabled otherwise.
- run
- if enabled, Sinatra will handle starting the web server, do not enable if using rackup or other means.
- running
- is the built-in server running now? Do not change this setting!
- server
- Server or list of servers to use for built-in server. Order indicates priority, default depends on Ruby implementation.
- sessions
- Enable cookie-based sessions support using Rack::Session::Cookie. See 'Using Sessions' section for more information.
- show_exceptions
- Show a stack trace in the browser when an exception happens. Enabled by default when environment is set to "development", disabled otherwise.
- Can also be set to :after_handler to trigger app-specified error handling before showing a stack trace in the browser.
- static
- Whether Sinatra should handle serving static files.
- Disable when using a server able to do this on its own.
- Disabling will boost performance.
- Enabled per default in classic style, disabled for modular apps.
- static_cache_control
- When Sinatra is serving static files, set this to add Cache-Control headers to the responses. Uses the cache_control helper. Disabled by default.
- Use an explicit array when setting multiple values: set :static_cache_control, [:public, :max_age => 300]
- threaded
- If set to true, will tell Thin to use EventMachine.defer for processing the request.
- views
- Path to the views folder. Inferred from app_file setting if not set.
- x_cascade
- Whether or not to set the X-Cascade header if no route matches. Defaults to true.
| Setting | Classic | Modular |
|---|---|---|
| app_file | file loading sinatra | file subclassing Sinatra::Base |
| run | $0 == app_file | false |
| logging | true | false |
| method_override | true | false |
| inline_templates | true | false |
| static | true | false |
- Ruby 1.8.7
- 1.8.7 is fully supported, however, if nothing is keeping you from it, we recommend upgrading or switching to JRuby or Rubinius. Support for 1.8.7 will not be dropped before Sinatra 2.0. Ruby 1.8.6 is no longer supported.
- Ruby 1.9.2
- 1.9.2 is fully supported. Do not use 1.9.2p0, as it is known to cause segmentation faults when running Sinatra. Official support will continue at least until the release of Sinatra 1.5.
- Ruby 1.9.3
- 1.9.3 is fully supported and recommended. Please note that switching to 1.9.3 from an earlier version will invalidate all sessions. 1.9.3 will be supported until the release of Sinatra 2.0.
- Ruby 2.0.0
- 2.0.0 is fully supported and recommended. There are currently no plans to drop official support for it.
- Rubinius
- Rubinius is officially supported (Rubinius >= 2.x). It is recommendended to gem install puma.
- JRuby
- The latest stable release of JRuby is officially supported. It is not recommended to use C extensions with JRuby. It is recommended to gem install trinidad.
- locals
- Lista de variables locales pasadas al documento. Resultan muy útiles cuando se combinan con parciales. Ejemplo: erb "<%= foo %>", :locals => {:foo => "bar"}
- default_encoding
- Encoding utilizado cuando el de un string es dudoso. Por defecto toma el valor de settings.default_encoding.
- views
- Directorio desde donde se cargan las vistas. Por defecto toma el valor de settings.views.
- layout
- Si es true o false indica que se debe usar, o no, un layout, respectivamente. También puede ser un símbolo que especifique qué plantilla usar. Ejemplo: erb :index, :layout => !request.xhr?
- content_type
- Content-Type que produce la plantilla. El valor por defecto depende de cada lenguaje de plantillas.
- scope
- Ámbito en el que se renderiza la plantilla. Por defecto utiliza la instancia de la aplicación. Tené en cuenta que si cambiás esta opción las variables de instancia y los helpers van a dejar de estar disponibles.
- layout_engine
- Motor de renderizado de plantillas que usa para el layout. Resulta conveniente para lenguajes que no soportan layouts. Por defecto toma el valor del motor usado para renderizar la plantilla. Ejemplo: set :rdoc, :layout_engine => :erb
- Se asume que las plantillas están ubicadas directamente bajo el directorio ./views. Para usar un directorio de vistas diferente: set :views, settings.root + '/plantillas'
- Es importante acordarse que siempre tenés que referenciar a las plantillas con símbolos, incluso cuando se encuentran en un subdirectorio (en este caso tenés que usar: `:'subdir/plantilla'` o `'subdir/plantilla'.to_sym`). Tenés que usar un símbolo porque los métodos de renderización van a renderizar directamente cualquier string que se les pase como argumento.
| Dependencias | haml |
| Expresiones de Archivo | .haml |
| Ejemplo | haml :index, :format => :html5 |
| Dependencias | erubis o erb (incluida en Ruby) |
| Extensiones de Archivo | .erb, .rhtml o .erubis (solamente con Erubis) |
| Ejemplo | erb :index |
| Dependencias | builder |
| Extensiones de Archivo | .builder |
| Ejemplo | builder { |xml| xml.em "hola" } |
| Dependencias | nokogiri |
| Extensiones de Archivo | .nokogiri |
| Ejemplo | nokogiri { |xml| xml.em "hola" } |
| Dependencias | sass |
| Extensiones de Archivo | .sass |
| Ejemplo | sass :stylesheet, :style => :expanded |
| Dependencias | sass |
| Extensiones de Archivo | .scss |
| Ejemplo | scss :stylesheet, :style => :expanded |
| Dependencias | less |
| Extensiones de Archivo | .less |
| Ejemplo | less :stylesheet |
| Dependencias | liquid |
| Extensiones de Archivo | .liquid |
| Ejemplo | liquid :index, :locals => { :clave => 'valor' } |
| Dependencias | RDiscount, RedCarpet, BlueCloth, kramdown o maruku |
| Extensiones de Archivo | .markdown, .mkd y .md |
| Ejemplo | markdown :index, :layout_engine => :erb |
| Dependencias | RedCloth |
| Extensiones de Archivo | .textile |
| Ejemplo | textile :index, :layout_engine => :erb |
| Dependencias | RDoc |
| Extensiones de Archivo | .rdoc |
| Ejemplo | rdoc :README, :layout_engine => :erb |
| Dependencias | Radius |
| Extensiones de Archivo | .radius |
| Ejemplo | radius :index, :locals => { :clave => 'valor' } |
| Dependencias | Markaby |
| Extensiones de Archivo | .mab |
| Ejemplo | markaby { h1 "Bienvenido!" } |
| Dependencias | Rabl |
| Extensiones de Archivo | .rabl |
| Ejemplo | rabl :index |
| Dependencias | Slim Lang |
| Extensiones de Archivo | .slim |
| Ejemplo | slim :index |
| Dependencias | Creole |
| Extensiones de Archivo | .creole |
| Ejemplo | creole :wiki, :layout_engine => :erb |
| Dependencias | CoffeeScript y un mecanismo para ejecutar javascript |
| Extensiones de Archivo | .coffee |
| Ejemplo | coffee :index |
| Dependencias | Stylus y un mecanismo para ejecutar javascript |
| Extensiones de Archivo | .styl |
| Ejemplo | stylus :index |
| Dependencias | yajl-ruby |
| Extensiones de Archivo | .yajl |
| Ejemplo | yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'resource' |
| Dependencias | wlang |
| Extensiones de Archivo | .wlang |
| Ejemplo | wlang :index, :locals => { :clave => 'valor' } |
- absolute_redirects
- Si está deshabilitada, Sinatra va a permitir redirecciones relativas, sin embargo, como consecuencia de esto, va a dejar de cumplir con el RFC 2616 (HTTP 1.1), que solamente permite redirecciones absolutas. Activalo si tu apliación está corriendo atrás de un proxy reverso que no se ha configurado adecuadamente. Notá que el helper url va a seguir produciendo URLs absolutas, a menos que le pasés false como segundo parámetro. Deshabilitada por defecto.
- add_charsets
- Tipos mime a los que el helper content_type les añade automáticamente el charset. En general, no deberías asignar directamente esta opción, sino añadirle los charsets que quieras: settings.add_charsets << "application/foobar"
- app_file
- Path del archivo principal de la aplicación, se utiliza para detectar la raíz del proyecto, el directorio de las vistas y el público, así como las plantillas inline.
- bind
- Dirección IP que utilizará el servidor integrado (por defecto: 0.0.0.0).
- default_encoding
- Encoding utilizado cuando el mismo se desconoce (por defecto "utf-8").
- dump_errors
- Mostrar errores en el log.
- environment
- Entorno actual, por defecto toma el valor de ENV['RACK_ENV'], o "development" si no está disponible.
- logging
- Define si se utiliza el logger.
- lock
- Coloca un lock alrededor de cada petición, procesando solamente una por proceso. Habilitá esta opción si tu aplicación no es thread-safe. Se encuentra deshabilitada por defecto.
- method_override
- Utiliza el parámetro _method para permtir formularios put/delete en navegadores que no los soportan.
- port
- Puerto en el que escuchará el servidor integrado.
- prefixed_redirects
- Define si inserta request.script_name en las redirecciones cuando no se proporciona un path absoluto. De esta manera, cuando está habilitada, redirect '/foo' se comporta de la misma manera que redirect to('/foo'). Se encuentra deshabilitada por defecto.
- protection
- Define si deben activarse las protecciones para los ataques web más comunes. Para más detalles mirá la sección sobre la configuración de protección de ataques más arriba.
- public_dir
- Alias para public_folder, que se encuentra a continuación.
- public_folder
- Path del directorio desde donde se sirven los archivos públicos. Solo se utiliza cuando se sirven archivos estáticos (ver la opción static). Si no está presente, se infiere del valor de la opción app_file.
- reload_templates
- Define si se recargan las plantillas entre peticiones. Se encuentra activado en el entorno de desarrollo.
- root
- Path del directorio raíz del proyecto. Si no está presente, se infiere del valor de la opción app_file.
- raise_errors
- Elevar excepciones (detiene la aplicación). Se encuentra activada por defecto cuando el valor de environment es "test". En caso contrario estará desactivada.
- run
- Cuando está habilitada, Sinatra se va a encargar de iniciar el servidor web, no la habilites cuando estés usando rackup o algún otro medio.
- running
- Indica si el servidor integrado está ejecutandose, ¡no cambiés esta configuración!.
- server
- Servidor, o lista de servidores, para usar como servidor integrado. Por defecto: ['thin', 'mongrel', 'webrick'], el orden establece la prioridad.
- sessions
- Habilita el soporte de sesiones basadas en cookies a través de Rack::Session::Cookie. Ver la sección 'Usando Sesiones' para más información.
- show_exceptions
- Muestra un stack trace en el navegador cuando ocurre una excepción. Se encuentra activada por defecto cuando el valor de environment es "development". En caso contrario estará desactivada.
- static
- Define si Sinatra debe encargarse de servir archivos estáticos. Deshabilitala cuando uses un servidor capaz de hacerlo por sí solo, porque mejorará el rendimiento. Se encuentra habilitada por defecto en el estilo clásico y desactivado en el el modular.
- static_cache_control
- Cuando Sinatra está sirviendo archivos estáticos, y está opción está habilitada, les va a agregar encabezados Cache-Control a las respuestas. Para esto utiliza el helper cache_control. Se encuentra deshabilitada por defecto. Notar que es necesario utilizar un array cuando se asignan múltiples valores: set :static_cache_control, [:public, :max_age => 300].
- views
- Path del directorio de las vistas. Si no está presente, se infiere del valor de la opción app_file.
| Configuración | Clásica | Modular |
| app_file | archivo que carga sinatra | archivo con la subclase de Sinatra::Base |
| run | $0 == app_file | false |
| logging | true | false |
| method_override | true | false |
| inline_templates | true | false |
| static | true | false |
- Ruby 1.8.7
- 1.8.7 es soportado completamente. Sin embargo, si no hay nada que te lo prohiba, te recomendamos que uses 1.9.2 o cambies a JRuby o Rubinius. No se dejará de dar soporte a 1.8.7 hasta Sinatra 2.0 y Ruby 2.0, aunque si se libera la versión 1.8.8 de Ruby las cosas podrían llegar a cambiar. Sin embargo, que eso ocurra es muy poco probable, e incluso el caso de que lo haga, puede que se siga dando soporte a 1.8.7. Hemos dejado de soportar Ruby 1.8.6. Si querés ejecutar Sinatra sobre 1.8.6, podés utilizar la versión 1.2, pero tené en cuenta que una vez que Sinatra 1.4.0 sea liberado, ya no se corregirán errores por más que se reciban reportes de los mismos.
- Ruby 1.9.2
- 1.9.2 es soportado y recomendado. No uses 1.9.2p0, porque se producen fallos de segmentación cuando se ejecuta Sinatra. El soporte se mantendrá al menos hasta que se libere la versión 1.9.4/2.0 de Ruby. El soporte para la última versión de la serie 1.9 se mantendrá mientras lo haga el core team de Ruby.
- Ruby 1.9.3
- 1.9.3 es soportado y recomendado. Tené en cuenta que el cambio a 1.9.3 desde una versión anterior va a invalidar todas las sesiones.
- Rubinius
- Rubinius es soportado oficialmente (Rubinius >= 1.2.4). Todo funciona correctamente, incluyendo los lenguajes de plantillas. La próxima versión, 2.0, también es soportada, incluyendo el modo 1.9.
- JRuby
- JRuby es soportado oficialmente (JRuby >= 1.6.7). No se conocen problemas con librerías de plantillas de terceras partes. Sin embargo, si elegís usar JRuby, deberías examinar sus Rack handlers porque el servidor web Thin no es soportado completamente. El soporte de JRuby para extensiones C se encuentra en una etapa experimental, sin embargo, de momento solamente RDiscount, Redcarpet, RedCloth y Yajl, así como Thin y Mongrel se ven afectadas.
- locals
- Liste von lokalen Variablen, die an das Dokument weitergegeben werden. Praktisch für Partials: erb "<%= foo %>", :locals => {:foo => "bar"}
- default_encoding
- Gibt die Stringkodierung an, die verwendet werden soll. Voreingestellt auf settings.default_encoding.
- views
- Ordner, aus dem die Templates geladen werden. Voreingestellt auf settings.views.
- layout
- Legt fest, ob ein Layouttemplate verwendet werden soll oder nicht (true oderfalse). Ist es ein Symbol, dann legt es fest, welches Template als Layout verwendet wird: erb :index, :layout => !request.xhr?
- content_type
- Content-Typ den das Template ausgibt. Voreinstellung hängt von der Templatesprache ab.
- scope
- Scope, in dem das Template gerendert wird. Liegt standardmäßig innerhalb der App-Instanz. Wird Scope geändert, sind Instanzvariablen und Helfermethoden nicht verfügbar.
- layout_engine
- Legt fest, welcher Renderer für das Layout verantwortlich ist. Hilfreich für Sprachen, die sonst keine Templates unterstützen. Voreingestellt auf den Renderer, der für das Template verwendet wird: set :rdoc, :layout_engine => :erb
- layout_options
- Besondere Einstellungen, die nur für das Rendering verwendet werden: set :rdoc, :layout_options => { :views => 'views/layouts' }
| Abhängigkeit | haml |
| Dateierweiterung | .haml |
| Beispiel | haml :index, :format => :html5 |
| Abhängigkeit | erubis oder erb (Standardbibliothek von Ruby) |
| Dateierweiterungen | .erb, .rhtml oder .erubis (nur Erubis) |
| Beispiel | erb :index |
| Abhängigkeit | builder |
| Dateierweiterung | .builder |
| Beispiel | builder { |xml| xml.em "Hallo" } |
| Abhängigkeit | nokogiri |
| Dateierweiterung | .nokogiri |
| Beispiel | nokogiri { |xml| xml.em "Hallo" } |
| Abhängigkeit | sass |
| Dateierweiterung | .sass |
| Beispiel | sass :stylesheet, :style => :expanded |
| Abhängigkeit | sass |
| Dateierweiterung | .scss |
| Beispiel | scss :stylesheet, :style => :expanded |
| Abhängigkeit | less |
| Dateierweiterung | .less |
| Beispiel | less :stylesheet |
| Abhängigkeit | liquid |
| Dateierweiterung | .liquid |
| Beispiel | liquid :index, :locals => { :key => 'Wert' } |
| Abhängigkeit | Eine der folgenden Bibliotheken: RDiscount, RedCarpet, BlueCloth, kramdown oder maruku |
| Dateierweiterungen | .markdown, .mkd und .md |
| Beispiel | markdown :index, :layout_engine => :erb |
| Abhängigkeit | RedCloth |
| Dateierweiterung | .textile |
| Beispiel | textile :index, :layout_engine => :erb |
| Abhängigkeit | rdoc |
| Dateierweiterung | .rdoc |
| Beispiel | textile :README, :layout_engine => :erb |
| Abhängigkeit | radius |
| Dateierweiterung | .radius |
| Beispiel | radius :index, :locals => { :key => 'Wert' } |
| Abhängigkeit | markaby |
| Dateierweiterung | .mab |
| Beispiel | markaby { h1 "Willkommen!" } |
| Abhängigkeit | rabl |
| Dateierweiterung | .rabl |
| Beispiel | rabl :index |
| Abhängigkeit | slim |
| Dateierweiterung | .slim |
| Beispiel | slim :index |
| Abhängigkeit | creole |
| Dateierweiterung | .creole |
| Beispiel | creole :wiki, :layout_engine => :erb |
| Abhängigkeit | coffee-script und eine Möglichkeit JavaScript auszuführen. | Dateierweiterung | .coffee |
| Beispiel | coffee :index |
| Abhängigkeit | Stylus und eine Möglichkeit JavaScript auszuführen . |
| Dateierweiterung | .styl |
| Beispiel | stylus :index |
| Abhängigkeit | yajl-ruby |
| Dateierweiterung | .yajl |
| Beispiel | yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'resource' |
| Abhängigkeit | wlang |
| Dateierweiterung | .wlang |
| Beispiel | wlang :index, :locals => { :key => 'value' } |
- filename
- Dateiname als Response. Standardwert ist der eigentliche Dateiname.
- last_modified
- Wert für den Last-Modified-Header, Standardwert ist mtime der Datei.
- type
- Content-Type, der verwendet werden soll. Wird, wenn nicht angegeben, von der Dateiendung abgeleitet.
- disposition
- Verwendet für Content-Disposition. Mögliche Werte sind: nil (Standard), :attachment und :inline.
- length
- Content-Length-Header. Standardwert ist die Dateigröße.
- absolute_redirects
- Wenn ausgeschaltet, wird Sinatra relative Redirects zulassen. Jedoch ist Sinatra dann nicht mehr mit RFC 2616 (HTTP 1.1) konform, das nur absolute Redirects zulässt. Sollte eingeschaltet werden, wenn die Applikation hinter einem Reverse-Proxy liegt, der nicht ordentlich eingerichtet ist. Beachte, dass die url-Helfer-Methode nach wie vor absolute URLs erstellen wird, es sei denn, es wird als zweiter Parameter false angegeben. Standardmäßig nicht aktiviert.
- add_charsets
- Mime-Types werden hier automatisch der Helfer-Methode content_type zugeordnet. Es empfielt sich, Werte hinzuzufügen statt sie zu überschreiben: settings.add_charsets << "application/foobar"
- app_file
- Pfad zur Hauptdatei der Applikation. Wird verwendet, um das Wurzel-, Inline-, View- und öffentliche Verzeichnis des Projekts festzustellen.
- bind
- IP-Address, an die gebunden wird (Standardwert: 0.0.0.0 oder localhost). Wird nur für den eingebauten Server verwendet.
- default_encoding
- Das Encoding, falls keines angegeben wurde. Standardwert ist "utf-8".
- dump_errors
- Fehler im Log anzeigen.
- environment
- Momentane Umgebung. Standardmäßig auf content_type oder "development" eingestellt, soweit ersteres nicht vorhanden.
- logging
- Den Logger verwenden.
- lock
- Jeder Request wird gelocked. Es kann nur ein Request pro Ruby-Prozess gleichzeitig verarbeitet werden. Eingeschaltet, wenn die Applikation threadsicher ist. Standardmäßig nicht aktiviert.
- method_override
- Verwende _method, um put/delete-Formulardaten in Browsern zu verwenden, die dies normalerweise nicht unterstützen.
- port
- Port für die Applikation. Wird nur im internen Server verwendet.
- prefixed_redirects
- Entscheidet, ob request.script_name in Redirects eingefügt wird oder nicht, wenn kein absoluter Pfad angegeben ist. Auf diese Weise verhält sich redirect '/foo' so, als wäre es ein redirect to('/foo'). Standardmäßig nicht aktiviert.
- protection
- Legt fest, ob der Schutzmechanismus für häufig Vorkommende Webangriffe auf Webapplikationen aktiviert wird oder nicht. Weitere Informationen im vorhergehenden Abschnitt.
- public_folder
- Das öffentliche Verzeichnis, aus dem Daten zur Verfügung gestellt werden können. Wird nur dann verwendet, wenn statische Daten zur Verfügung gestellt werden können (s.u. static Option). Leitet sich von der app_file Einstellung ab, wenn nicht gesetzt.
- public_dir
- Alias für public_folder, s.o.
- reload_templates
- Im development-Modus aktiviert.
- root
- Wurzelverzeichnis des Projekts. Leitet sich von der app_file Einstellung ab, wenn nicht gesetzt.
- raise_errors
- Einen Ausnahmezustand aufrufen. Beendet die Applikation. Ist automatisch aktiviert, wenn die Umgebung auf "test" eingestellt ist. Ansonsten ist diese Option deaktiviert.
- run
- Wenn aktiviert, wird Sinatra versuchen, den Webserver zu starten. Nicht verwenden, wenn Rackup oder anderes verwendet werden soll.
- running
- Läuft der eingebaute Server? Diese Einstellung nicht ändern!
- server
- Server oder Liste von Servern, die als eingebaute Server zur Verfügung stehen. Die Reihenfolge gibt die Priorität vor, die Voreinstellung hängt von der verwendenten Ruby Implementierung ab.
- sessions
- Sessions auf Cookiebasis mittels Rack::Session::Cookieaktivieren. Für weitere Infos bitte in der Sektion ‘Sessions verwenden’ nachschauen.
- show_exceptions
- Bei Fehlern einen Stacktrace im Browseranzeigen. Ist automatisch aktiviert, wenn die Umgebung auf "development" eingestellt ist. Ansonsten ist diese Option deaktiviert. Kann auch auf :after_handler gestellt werden, um eine anwendungsspezifische Fehlerbehandlung auszulösen, bevor der Fehlerverlauf im Browser angezeigt wird.
- static
- Entscheidet, ob Sinatra statische Dateien zur Verfügung stellen soll oder nicht. Sollte nicht aktiviert werden, wenn ein Server verwendet wird, der dies auch selbstständig erledigen kann. Deaktivieren wird die Performance erhöhen. Standardmäßig aktiviert.
- static_cache_control
- Wenn Sinatra statische Daten zur Verfügung stellt, können mit dieser Einstellung die Cache-Control Header zu den Responses hinzugefügt werden. Die Einstellung verwendet dazu die cache_control Helfer-Methode. Standardmäßig deaktiviert. Ein Array wird verwendet, um mehrere Werte gleichzeitig zu übergeben: set :static_cache_control, [:public, :max_age => 300]
- threaded
- Wird es auf true gesetzt, wird Thin aufgefordert EventMachine.defer zur Verarbeitung des Requests einzusetzen.
- views
- Verzeichnis der Views. Leitet sich von der app_file Einstellung ab, wenn nicht gesetzt.
- x_cascade
- Einstellung, ob der X-Cascade Header bei fehlender Route gesetzt wird oder nicht. Standardeinstellung ist true.
| Szenario | Classic | Modular |
|---|---|---|
| app_file | Sinatra ladende Datei | Sinatra::Base subklassierende Datei |
| run | $0 == app_file | false |
| logging | true | false |
| method_override | true | false |
| inline_templates | true | false |
| static | true | false |
- Ruby 1.8.7
- 1.8.7 wird vollständig unterstützt, ein Wechsel zu JRuby oder Rubinius wird aber empfohlen. Ruby 1.8.7 wird noch bis Sinatra 2.0 unterstützt werden. Frühere Versionen von Ruby sind nicht kompatibel mit Sinatra.
- Ruby 1.9.2
- 1.9.2 wird mindestens bis Sinatra 1.5 voll unterstützt. Version 1.9.2p0 sollte nicht verwendet werden, da unter Sinatra immer wieder Segfaults auftreten.
- Ruby 1.9.3
- 1.9.3 wird vollständig unterstützt und empfohlen. Achtung, bei einem Upgrade von einer früheren Version von Ruby zu Ruby 1.9.3 werden alle Sessions ungültig. Ruby 1.9.3 wird bis Sinatra 2.0 unterstützt werden.
- Rubinius
- Rubinius (Version >= 2.x) wird offiziell unterstützt. Es wird empfohlen, den Puma Server zu installieren (gem install puma )
- JRuby
- Aktuelle JRuby Versionen werden offiziell unterstützt. Es wird empfohlen, keine C-Erweiterungen zu verwenden und als Server Trinidad zu verwenden (gem install trinidad).
- filename
- 响应中的文件名，默认是真实文件的名字。
- last_modified
- Last-Modified 消息头的值，默认是文件的mtime（修改时间）。
- type
- 使用的内容类型，如果没有会从文件扩展名猜测。
- disposition
- 用于 Content-Disposition，可能的包括： nil (默认), :attachment 和 :inline
- length
- Content-Length 的值，默认是文件的大小。
- absolute_redirects
-
如果被禁用，Sinatra会允许使用相对路径重定向， 但是，Sinatra就不再遵守 RFC 2616标准 (HTTP 1.1), 该标准只允许绝对路径重定向。
如果你的应用运行在一个未恰当设置的反向代理之后， 你需要启用这个选项。注意 url 辅助方法 仍然会生成绝对 URL，除非你传入 false 作为第二参数。
默认禁用。
- add_charsets
-
设定 content_type 辅助方法会 自动加上字符集信息的多媒体类型。
你应该添加而不是覆盖这个选项: settings.add_charsets << "application/foobar"
- app_file
- 主应用文件，用来检测项目的根路径， views和public文件夹和内联模板。
- bind
- 绑定的IP 地址 (默认: 0.0.0.0)。 仅对于内置的服务器有用。
- default_encoding
- 默认编码 (默认为 "utf-8")。
- dump_errors
- 在log中显示错误。
- environment
- 当前环境，默认是 ENV['RACK_ENV']， 或者 "development" 如果不可用。
- logging
- 使用logger
- lock
-
对每一个请求放置一个锁， 只使用进程并发处理请求。
如果你的应用不是线程安全则需启动。 默认禁用。
- method_override
- 使用 _method 魔法以允许在旧的浏览器中在 表单中使用 put/delete 方法
- port
- 监听的端口号。只对内置服务器有用。
- prefixed_redirects
- 是否添加 request.script_name 到 重定向请求，如果没有设定绝对路径。那样的话 redirect '/foo' 会和 redirect to('/foo')起相同作用。默认禁用。
- public_folder
- public文件夹的位置。
- reload_templates
- 是否每个请求都重新载入模板。 在development mode和 Ruby 1.8.6 中被企业（用来 消除一个Ruby内存泄漏的bug）。
- root
- 项目的根目录。
- raise_errors
- 抛出异常（应用会停下）。
- run
- 如果启用，Sinatra会开启web服务器。 如果使用rackup或其他方式则不要启用。
- running
- 内置的服务器在运行吗？ 不要修改这个设置！
- server
- 服务器，或用于内置服务器的列表。 默认是 [‘thin’, ‘mongrel’, ‘webrick’], 顺序表明了 优先级。
- sessions
- 开启基于cookie的sesson。
- show_exceptions
- 在浏览器中显示一个stack trace。
- static
- Sinatra是否处理静态文件。 当服务器能够处理则禁用。 禁用会增强性能。 默认开启。
- views
- views 文件夹。
- Ruby 1.8.6
- 不推荐在1.8.6上安装Sinatra， 但是直到Sinatra 1.3.0发布才会放弃对它的支持。 RDoc 和 CoffeScript模板不被这个Ruby版本支持。 1.8.6在它的Hash实现中包含一个内存泄漏问题， 该问题会被1.1.1版本之前的Sinatra引发。 当前版本使用性能下降的代价排除了这个问题。你需要把Rack降级到1.1.x， 因为Rack \>= 1.2不再支持1.8.6。
- Ruby 1.8.7
- 1.8.7 被完全支持，但是，如果没有特别原因， 我们推荐你升级到 1.9.2 或者切换到 JRuby 或者 Rubinius.
- Ruby 1.9.2
- 1.9.2 被支持而且推荐。注意 Radius 和 Markaby 模板并不和1.9兼容。不要使用 1.9.2p0, 它被已知会产生 segmentation faults.
- Rubinius
- Rubinius 被官方支持 (Rubinius \>= 1.2.2)， 除了Textile模板。
- JRuby
- JRuby 被官方支持 (JRuby \>= 1.5.6)。 目前未知和第三方模板库有关的问题， 但是，如果你选择了JRuby，请查看一下JRuby rack 处理器， 因为 Thin web 服务器还没有在JRuby上获得支持。
- locals
- Список локальных переменных, передаваемых в документ. Например: erb "<%= foo %>", :locals => {:foo => "bar"}
- default_encoding
- Кодировка, которую следует использовать, если не удалось определить оригинальную. По умолчанию: settings.default_encoding.
- views
- Директория с шаблонами. По умолчанию: settings.views.
- layout
- Использовать или нет лэйаут (true или false). Если же значение Symbol, то указывает, какой шаблон использовать в качестве лэйаута. Например: erb :index, :layout => !request.xhr?
- content_type
- Content-Type отображенного шаблона. По умолчанию: задается шаблонизатором.
- scope
- Область видимости, в которой рендерятся шаблоны. По умолчанию: экземпляр приложения. Если вы измените эту опцию, то переменные экземпляра и методы-помощники станут недоступными в ваших шаблонах.
- layout_engine
- Шаблонизатор, который следует использовать для отображения лэйаута. Полезная опция для шаблонизаторов, в которых нет никакой поддержки лэйаутов. По умолчанию: тот же шаблонизатор, что используется и для самого шаблона. Пример: set :rdoc, :layout_engine => :erb
| Зависимости | haml |
| Расширения файлов | .haml |
| Пример | haml :index, :format => :html5 |
| Зависимости | erubis или erb (включен в Ruby) |
| Расширения файлов | .erb, .rhtml or .erubis (только Erubis) |
| Пример | erb :index |
| Зависимости | builder |
| Расширения файлов | .builder |
| Пример | builder { |xml| xml.em "hi" } |
| Зависимости | nokogiri |
| Расширения файлов | .nokogiri |
| Пример | nokogiri { |xml| xml.em "hi" } |
| Зависимости | sass |
| Расширения файлов | .sass |
| Пример | sass :stylesheet, :style => :expanded |
| Зависимости | sass |
| Расширения файлов | .scss |
| Пример | scss :stylesheet, :style => :expanded |
| Зависимости | less |
| Расширения файлов | .less |
| Пример | less :stylesheet |
| Зависимости | liquid |
| Расширения файлов | .liquid |
| Пример | liquid :index, :locals => { :key => 'value' } |
| Зависимости | Любая из библиотек: RDiscount, RedCarpet, BlueCloth, kramdown, maruku |
| Расширения файлов | .markdown, .mkd and .md |
| Пример | markdown :index, :layout_engine => :erb |
| Зависимости | RedCloth |
| Расширения файлов | .textile |
| Пример | textile :index, :layout_engine => :erb |
| Зависимости | RDoc |
| Расширения файлов | .rdoc |
| Пример | rdoc :README, :layout_engine => :erb |
| Зависимости | Radius |
| Расширения файлов | .radius |
| Пример | radius :index, :locals => { :key => 'value' } |
| Зависимости | Markaby |
| Расширения файлов | .mab |
| Пример | markaby { h1 "Welcome!" } |
| Зависимости | Rabl |
| Расширения файлов | .rabl |
| Пример | rabl :index |
| Зависимости | Slim Lang |
| Расширения файлов | .slim |
| Пример | slim :index |
| Зависимости | Creole |
| Расширения файлов | .creole |
| Пример | creole :wiki, :layout_engine => :erb |
| Зависимости | CoffeeScript и способ запускать JavaScript |
| Расширения файлов | .coffee |
| Пример | coffee :index |
| Зависимости | yajl-ruby |
| Расширения файлов | .yajl |
| Пример | yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'resource' |
| Зависимости | wlang |
| Расширения файлов | .wlang |
| Пример | wlang :index, :locals => { :key => 'value' } |
- filename
- имя файла, по умолчанию: реальное имя файла.
- last_modified
- значение для заголовка Last-Modified, по умолчанию: mtime (время изменения) файла.
- type
- тип файла, по умолчанию: определяется по расширению файла.
- disposition
- используется для заголовка Content-Disposition, возможные значения: nil (по умолчанию), :attachment и :inline.
- length
- значения для заголовка Content-Length, по умолчанию: размер файла.
- status
- Код ответа. Полезно, когда отдается статический файл в качестве страницы с сообщением об ошибке.
- absolute_redirects
- если отключено, то Sinatra будет позволять использование относительных перенаправлений, но при этом перестанет соответствовать RFC 2616 (HTTP 1.1), который разрешает только абсолютные перенаправления.
- Включайте эту опцию, если ваше приложение работает за обратным прокси, который настроен не совсем корректно. Обратите внимание, метод url все равно будет генерировать абсолютные URL, если вы не передадите false вторым аргументом.
- Отключено по умолчанию.
- add_charsets
- mime-типы, к которым метод content_type будет автоматически добавлять информацию о кодировке. Вам следует добавлять значения к этой опции вместо ее переопределения: settings.add_charsets << "application/foobar"
- app_file
- путь к главному файлу приложения, используется для нахождения корневой директории проекта, директорий с шаблонами и статическими файлами, вложенных шаблонов.
- bind
- используемый IP-адрес (по умолчанию: 0.0.0.0). Используется только встроенным сервером.
- default_encoding
- кодировка, если неизвестна (по умолчанию: "utf-8").
- dump_errors
- отображать ошибки в логе.
- environment
- текущее окружение, по умолчанию, значение ENV['RACK_ENV'] или "development", если ENV['RACK_ENV'] недоступна.
- logging
- использовать логер.
- lock
- создает блокировку для каждого запроса, которая гарантирует обработку только одного запроса в текущий момент времени в Ruby процессе.
- Включайте, если ваше приложение не потоко-безопасно (thread-safe). Отключено по умолчанию.
- method_override
- использовать "магический" параметр _method, для поддержки PUT/DELETE форм в браузерах, которые не поддерживают эти методы.
- port
- порт, на котором будет работать сервер. Используется только встроенным сервером.
- prefixed_redirects
- добавлять или нет параметр request.script_name к редиректам, если не задан абсолютный путь. Таким образом, redirect '/foo' будет вести себя как redirect to('/foo'). Отключено по умолчанию.
- protection
- включена или нет защита от атак. Смотрите секцию выше.
- public_dir
- Алиас для public_folder.
- public_folder
- путь к директории, откуда будут раздаваться статические файлы. Используется, только если включена раздача статических файлов (см. опцию static ниже).
- reload_templates
- перезагружать или нет шаблоны на каждый запрос. Включено в режиме разработки.
- root
- путь к корневой директории проекта.
- raise_errors
- выбрасывать исключения (будет останавливать приложение). По умолчанию включено только в окружении test.
- run
- если включено, Sinatra будет самостоятельно запускать веб-сервер. Не включайте, если используете rackup или аналогичные средства.
- running
- работает ли сейчас встроенный сервер? Не меняйте эту опцию!
- server
- сервер или список серверов, которые следует использовать в качестве встроенного сервера. По умолчанию: ['thin', 'mongrel', 'webrick'], порядок задает приоритет.
- sessions
- включить сессии на основе кук (cookie) на базе Rack::Session::Cookie. Смотрите секцию "Использование сессий" выше.
- show_exceptions
- показывать исключения/стек вызовов (stack trace) в браузере. По умолчанию включено только в окружении development.
- Может быть установлено в :after_handler для запуска специфичной для приложения обработки ошибок, перед показом трассировки стека в браузере.
- static
- должна ли Sinatra осуществлять раздачу статических файлов.
- Отключите, когда используете какой-либо веб-сервер для этой цели.
- Отключение значительно улучшит производительность приложения.
- По умолчанию включено в классических и отключено в модульных приложениях.
- static_cache_control
- когда Sinatra отдает статические файлы, используйте эту опцию, чтобы добавить им заголовок Cache-Control. Для этого используется метод-помощник cache_control. По умолчанию отключено.
- Используйте массив, когда надо задать несколько значений: set :static_cache_control, [:public, :max_age => 300]
- threaded
- если включено, то Thin будет использовать EventMachine.defer для обработки запросов.
- views
- путь к директории с шаблонами.
- Ruby 1.8.7
- 1.8.7 полностью поддерживается, тем не менее, если вас ничто не держит на этой версии, рекомендуем обновиться до 1.9.2 или перейти на JRuby или Rubinius. Поддержка 1.8.7 не будет прекращена до выхода Sinatra 2.0 и Ruby 2.0, разве что в случае релиза 1.8.8 (что маловероятно). Но даже тогда, возможно, поддержка не будет прекращена. Ruby 1.8.6 больше не поддерживается. Если вы хотите использовать 1.8.6, откатитесь до Sinatra 1.2, которая будет получать все исправления ошибок до тех пор, пока не будет выпущена Sinatra 1.4.0.
- Ruby 1.9.2
- 1.9.2 полностью поддерживается и рекомендована к использованию. Не используйте 1.9.2p0, известно, что эта версия очень нестабильна при использовании Sinatra. Эта версия будет поддерживаться по крайней мере до выхода Ruby 1.9.4/2.0, а поддержка последней версии 1.9 будет осуществляться до тех пор, пока она поддерживается командой разработчиков Ruby.
- Ruby 1.9.3
- 1.9.3 полностью поддерживается. Заметьте, что переход на 1.9.3 с ранних версий сделает недействительными все сессии.
- Rubinius
- Rubinius официально поддерживается (Rubinius >= 1.2.4), всё, включая все языки шаблонов, работает. Предстоящий релиз 2.0 также поддерживается.
- JRuby
- JRuby официально поддерживается (JRuby >= 1.6.5). Нет никаких проблем с использованием альтернативных шаблонов. Тем не менее, если вы выбираете JRuby, то, пожалуйста, посмотрите на JRuby Rack-серверы, так как Thin не поддерживается полностью на JRuby. Поддержка расширений на C в JRuby все еще экспериментальная, что на данный момент затрагивает только RDiscount, Redcarpet и RedCloth.
| Dépendances | haml |
| Extensions de fichier | .haml |
| Exemple | haml :index, :format => :html5 |
| Dépendances | erubis ou erb (inclus avec Ruby) |
| Extensions de fichier | .erb, .rhtml ou .erubis (Erubis seulement) |
| Exemple | erb :index |
| Dépendances | builder |
| Extensions de fichier | .builder |
| Exemple | builder { |xml| xml.em "salut" } |
| Dépendances | nokogiri |
| Extensions de fichier | .nokogiri |
| Exemple | nokogiri { |xml| xml.em "salut" } |
| Dépendances | sass |
| Extensions de fichier | .sass |
| Exemple | sass :stylesheet, :style => :expanded |
| Dépendances | sass |
| Extensions de fichier | .scss |
| Exemple | scss :stylesheet, :style => :expanded |
| Dépendances | less |
| Extensions de fichier | .less |
| Exemple | less :stylesheet |
| Dépendances | liquid |
| Extensions de fichier | .liquid |
| Exemple | liquid :index, :locals => { :key => 'value' } |
Dépendances |
rdiscount, redcarpet, bluecloth, kramdown *ou* maruku |
| Extensions de fichier | .markdown, .mkd et .md |
| Exemple | markdown :index, :layout_engine => :erb |
| Dépendances | RedCloth |
| Extensions de fichier | .textile |
| Exemple | textile :index, :layout_engine => :erb |
| Dépendances | rdoc |
| Extensions de fichier | .rdoc |
| Exemple | rdoc :README, :layout_engine => :erb |
| Dépendances | radius |
| Extensions de fichier | .radius |
| Exemple | radius :index, :locals => { :key => 'value' } |
| Dépendances | markaby |
| Extensions de fichier | .mab |
| Exemple | markaby { h1 "Bienvenue !" } |
| Dépendances | rabl |
| Extensions de fichier | .rabl |
| Exemple | rabl :index |
| Dépendances | slim |
| Extensions de fichier | .slim |
| Exemple | slim :index |
| Dépendances | creole |
| Extensions de fichier | .creole |
| Exemple | creole :wiki, :layout_engine => :erb |
| Dépendances | coffee-script et un [moyen d'exécuter javascript](https://github.com/sstephenson/execjs/blob/master/README.md#readme) |
| Extensions de fichier | .coffee |
| Exemple | coffee :index |
| Dépendances | yajl-ruby |
| Extensions de fichier | .yajl |
| Exemple | yajl :index, :locals => { :key => 'qux' }, :callback => 'present', :variable => 'resource' |
| Dependency | wlang |
| File Extensions | .wlang |
| Example | wlang :index, :locals => { :key => 'value' } |
- filename
- le nom du fichier dans la réponse, par défaut le nom du fichier envoyé.
- last_modified
- valeur pour l’entête Last-Modified, par défaut la date de modification du fichier
- type
- type de contenu à utiliser, deviné à partir de l’extension de fichier si absent
- disposition
- utilisé pour Content-Disposition, les valuers possibles étant : `nil` (par défaut), `:attachment` et `:inline`
- length
- entête Content-Length, par défaut la taille du fichier
- status
- code état à renvoyer. Utile quand un fichier statique sert de page d’erreur.
- absolute_redirects
- Si désactivé, Sinatra permettra les redirections relatives. Toutefois,
Sinatra ne sera plus conforme à la RFC 2616 (HTTP 1.1), qui n’autorise
que les redirections absolues.
Activez si votre application tourne derrière un proxy inverse qui n’a
pas été correctement configuré. Notez que la méthode url
continuera de produire des URLs absolues, sauf si vous lui passez
false comme second argument.
Désactivé par défaut.
- add_charsets
types mime pour lesquels la méthode content_type va automatiquement ajouter l’information du charset.
Vous devriez lui ajouter des valeurs plutôt que de l’écraser :
settings.add_charsets >> "application/foobar"
- app_file
chemin pour le fichier de l’application principale, utilisé pour détecter la racine du projet, les dossiers public et vues, et les templates en ligne.
- bind
- adresse IP sur laquelle se brancher (par défaut : 0.0.0.0). Utiliser seulement pour le serveur intégré.
- default_encoding
- encodage à utiliser si inconnu (par défaut "utf-8")
- dump_errors
- afficher les erreurs dans le log.
- environment
- environnement courant, par défaut ENV['RACK_ENV'], ou "development" si absent.
- logging
- utiliser le logger.
- lock
Place un lock autour de chaque requête, n’exécutant donc qu’une seule requête par processus Ruby.
Activé si votre application n’est pas thread-safe. Désactivé par défaut.
- method_override
- utilise la magie de _method afin de permettre des formulaires put/delete dans des navigateurs qui ne le permettent pas.
- port
- port à écouter. Utiliser seulement pour le serveur intégré.
- prefixed_redirects
- si oui ou non request.script_name doit être inséré dans les redirections si un chemin non absolu est utilisé. Ainsi, redirect '/foo' se comportera comme redirect to('/foo'). Désactivé par défaut.
- protection
- défini s’il faut activer ou non la protection contre les attaques web. Voir la section protection précédente.
- public_dir
- alias pour public_folder. Voir ci-dessous.
- public_folder
- chemin pour le dossier à partir duquel les fichiers publics sont servis. Utilisé seulement si les fichiers statiques doivent être servis (voir le paramètre static). Si non défini, il découle du paramètre app_file.
- reload_templates
- si oui ou non les templates doivent être rechargés entre les requêtes. Activé en mode développement.
- root
- chemin pour le dossier racine du projet. Si non défini, il découle du paramètre app_file.
- raise_errors
- soulever les erreurs (ce qui arrêtera l’application). Désactivé par défaut sauf lorsque environment est défini à "test".
- run
- si activé, Sinatra s’occupera de démarrer le serveur, ne pas activer si vous utiliser rackup ou autres.
- running
- est-ce que le serveur intégré est en marche ? ne changez pas ce paramètre !
- server
- serveur ou liste de serveurs à utiliser pour le serveur intégré. Par défaut [‘thin’, ‘mongrel’, ‘webrick’], l’ordre indiquant la priorité.
- sessions
- active le support des sessions basées sur les cookies, en utilisant Rack::Session::Cookie. Reportez-vous à la section ‘Utiliser les sessions’ pour plus d’informations.
- show_exceptions
- affiche la trace de l’erreur dans le navigateur lorsqu’une exception se produit. Désactivé par défaut sauf lorsque environment est défini à "development".
- static
- Si oui ou non Sinatra doit s’occuper de servir les fichiers statiques. Désactivez si vous utilisez un serveur capable de le gérer lui même. Le désactiver augmentera la performance. Activé par défaut pour le style classique, désactivé pour le style modulaire.
- static_cache_control
- A définir quand Sinatra rend des fichiers statiques pour ajouter les en-têtes Cache-Control. Utilise le helper cache_control. Désactivé par défaut. Utiliser un array explicite pour définir des plusieurs valeurs : set :static_cache_control, [:public, :max_age => 300]
- threaded
- à définir à true pour indiquer à Thin d’utiliser EventMachine.defer pour traiter la requête.
- views
- chemin pour le dossier des vues. Si non défini, il découle du paramètre app_file.
- Ruby 1.8.7
- 1.8.7 est complètement supporté, toutefois si rien ne vous en empêche, nous vous recommandons de passer à 1.9.2 ou bien de passer à JRuby ou Rubinius. Le support de Ruby 1.8.7 ne sera pas supprimé avant la sortie de Sinatra 2.0 et de Ruby 2.0, à moins qu’un improbable Ruby 1.8.8 apparaisse. Et même dans ce cas, nous pourrions continuer à le supporter. **Ruby 1.8.6 n’est plus supporté**. Si vous souhaitez utiliser la version 1.8.6, vous devez revenir à Sinatra 1.2 qui continuera à recevoir des corrections de bugs tant que Sinatra 1.4.0 ne sera pas livré.
- Ruby 1.9.2
- 1.9.2 est totalement supporté et recommandé. N’utilisez pas 1.9.2p0 car il provoque des erreurs de segmentation à l’exécution de Sinatra. Son support continuera au minimum jusqu’à la sortie de Ruby 1.9.4/2.0 et le support de la dernière version 1.9 se poursuivra aussi longtemps que la core team de Ruby la supportera.
- Ruby 1.9.3
- 1.9.3 est totalement supporté et recommandé. Nous vous rappelons que passer à 1.9.3 depuis une version précédente annulera toutes les sessions.
- Rubinius
- Rubinius est officiellement supporté (Rubinius <= 1.2.4), tout fonctionne, y compris tous les langages de template. La version 2.0 à venir est également supportée.
- JRuby
- JRuby est officiellement supporté (JRuby <= 1.6.5). Aucune anomalie avec des bibliothèques de templates tierces ne sont connues. Toutefois, si vous choisissez JRuby, alors tournez vous vers des gestionnaires Rack JRuby car le serveur Thin n’est pas complètement supporté par JRuby. Le support des extensions C dans JRuby est encore expérimental, ce qui n’affecte que RDiscount, Redcarpet and RedCloth pour l’instant.
Not Found
' end res = error_block!(boom.class, boom) || error_block!(status, boom) return res if res or not server_error? raise boom if settings.raise_errors? or settings.show_exceptions? error_block! Exception, boom end # Find an custom error block for the key(s) specified. def error_block!(key, *block_params) base = settings while base.respond_to?(:errors) next base = base.superclass unless args_array = base.errors[key] args_array.reverse_each do |args| first = args == args_array.first args += [block_params] resp = process_route(*args) return resp unless resp.nil? && !first end end return false unless key.respond_to? :superclass and key.superclass < Exception error_block!(key.superclass, *block_params) end def dump_errors!(boom) msg = ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n\t") @env['rack.errors'].puts(msg) end class << self CALLERS_TO_IGNORE = [ # :nodoc: /\/sinatra(\/(base|main|showexceptions))?\.rb$/, # all sinatra code /lib\/tilt.*\.rb$/, # all tilt code /^\(.*\)$/, # generated code /rubygems\/(custom|core_ext\/kernel)_require\.rb$/, # rubygems require hacks /active_support/, # active_support require hacks /bundler(\/runtime)?\.rb/, # bundler require hacks /Internal Server Error
' end configure :development do get '/__sinatra__/:image.png' do filename = File.dirname(__FILE__) + "/images/#{params[:image]}.png" content_type :png send_file filename end error NotFound do content_type 'text/html' if self.class == Sinatra::Application code = <<-RUBY.gsub(/^ {12}/, '') #{request.request_method.downcase} '#{request.path_info}' do "Hello World" end RUBY else code = <<-RUBY.gsub(/^ {12}/, '') class #{self.class} #{request.request_method.downcase} '#{request.path_info}' do "Hello World" end end RUBY file = settings.app_file.to_s.sub(settings.root.to_s, '').sub(/^\//, '') code = "# in #{file}\n#{code}" unless file.empty? end (<<-HTML).gsub(/^ {10}/, '')Sinatra doesn’t know this ditty.
![](#{uri "/__sinatra__/404.png"})
Try this:
HTML
end
end
end
# Execution context for classic style (top-level) applications. All
# DSL methods executed on main are delegated to this class.
#
# The Application class should not be subclassed, unless you want to
# inherit all settings, routes, handlers, and error pages from the
# top-level. Subclassing Sinatra::Base is highly recommended for
# modular applications.
class Application < Base
set :logging, Proc.new { ! test? }
set :method_override, true
set :run, Proc.new { ! test? }
set :session_secret, Proc.new { super() unless development? }
set :app_file, nil
def self.register(*extensions, &block) #:nodoc:
added_methods = extensions.map {|m| m.public_instance_methods }.flatten
Delegator.delegate(*added_methods)
super(*extensions, &block)
end
end
# Sinatra delegation mixin. Mixing this module into an object causes all
# methods to be delegated to the Sinatra::Application class. Used primarily
# at the top-level.
module Delegator #:nodoc:
def self.delegate(*methods)
methods.each do |method_name|
define_method(method_name) do |*args, &block|
return super(*args, &block) if respond_to? method_name
Delegator.target.send(method_name, *args, &block)
end
private method_name
end
end
delegate :get, :patch, :put, :post, :delete, :head, :options, :link, :unlink,
:template, :layout, :before, :after, :error, :not_found, :configure,
:set, :mime_type, :enable, :disable, :use, :development?, :test?,
:production?, :helpers, :settings, :register
class << self
attr_accessor :target
end
self.target = Application
end
class Wrapper
def initialize(stack, instance)
@stack, @instance = stack, instance
end
def settings
@instance.settings
end
def helpers
@instance
end
def call(env)
@stack.call(env)
end
def inspect
"#<#{@instance.class} app_file=#{settings.app_file.inspect}>"
end
end
# Create a new Sinatra application. The block is evaluated in the new app's
# class scope.
def self.new(base = Base, options = {}, &block)
base = Class.new(base)
base.class_eval(&block) if block_given?
base
end
# Extend the top-level DSL with the modules provided.
def self.register(*extensions, &block)
Delegator.target.register(*extensions, &block)
end
# Include the helper modules provided in Sinatra's request context.
def self.helpers(*extensions, &block)
Delegator.target.helpers(*extensions, &block)
end
# Use the middleware for classic applications.
def self.use(*args, &block)
Delegator.target.use(*args, &block)
end
end
sinatra-1.4.3/lib/sinatra/images/ 0000755 0000041 0000041 00000000000 12161612727 016671 5 ustar www-data www-data sinatra-1.4.3/lib/sinatra/images/500.png 0000644 0000041 0000041 00000074520 12161612727 017713 0 ustar www-data www-data PNG
IHDR 9 3_< tEXtSoftware Adobe ImageReadyqe< xIDATx]`Tn&^w{ ދ4) * S>| T UT PSHIvӳ73fSDdY;3g52}̰pAOcJ}mMO#;* P|{ڨ{KZZzZzFO;-[
fL:+"PkgzfZ)/
++zSPpwJY!
EE%=*uzf&Jhcld⌍suv666b.NFFZJLLv={
GB'Ne*-=Sظxm\ 6c4"5^l.MMMB nS侾 Vk팎Ψ "༝SJ(Plml{sxmozXzJ7`5:: y775c [>"%E!jM
1 D^.l&wX`^w{F67C]t
X. #{code}
<%=h exception.class %> at <%=h path %>
<%=h exception.message %>
- file:
<%=h frames.first.filename.split("/").last %> - location:
<%=h frames.first.function %> - line: <%=h frames.first.lineno %>
BACKTRACE
-
<% id = 1 %>
<% frames.each do |frame| %>
<% if frame.context_line && frame.context_line != "#" %>
-
<%=h frame.filename %>in<%=h frame.function %> -
<% if frame.pre_context %>
-
<% frame.pre_context.each do |line| %>
<%=h line %>
<% end %>
<%= h frame.context_line %>
-
<% frame.post_context.each do |line| %>
<%=h line %>
<% end %>
<% end %>
<% id += 1 %>
<% end %>
GET
<% if req.GET and not req.GET.empty? %>| Variable | Value |
|---|---|
| <%=h key %> | <%=h val.inspect %> |
No GET data.
<% end %>POST
<% if req.POST and not req.POST.empty? %>| Variable | Value |
|---|---|
| <%=h key %> | <%=h val.inspect %> |
No POST data.
<% end %>Rack ENV
| Variable | Value |
|---|---|
| <%=h key %> | <%=h val %> |
You're seeing this error because you have
enabled the show_exceptions setting.