bmizerany-sinatra 0.3.2

data/sinatra.gemspec

@@ -0,0 +1,77 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  s.name = 'sinatra'
+  s.version = '0.3.2'
+  s.date = "2008-11-02"
+
+  s.description = "Classy web-development dressed in a DSL"
+  s.summary     = "Classy web-development dressed in a DSL"
+
+  s.authors = ["Blake Mizerany"]
+
+  # = MANIFEST =
+  s.files = %w[
+    ChangeLog
+    LICENSE
+    README.rdoc
+    Rakefile
+    images/404.png
+    images/500.png
+    lib/sinatra.rb
+    lib/sinatra/test/methods.rb
+    lib/sinatra/test/rspec.rb
+    lib/sinatra/test/spec.rb
+    lib/sinatra/test/unit.rb
+    sinatra.gemspec
+    test/app_test.rb
+    test/application_test.rb
+    test/builder_test.rb
+    test/custom_error_test.rb
+    test/erb_test.rb
+    test/event_context_test.rb
+    test/events_test.rb
+    test/filter_test.rb
+    test/haml_test.rb
+    test/helper.rb
+    test/mapped_error_test.rb
+    test/pipeline_test.rb
+    test/public/foo.xml
+    test/sass_test.rb
+    test/sessions_test.rb
+    test/streaming_test.rb
+    test/sym_params_test.rb
+    test/template_test.rb
+    test/use_in_file_templates_test.rb
+    test/views/foo.builder
+    test/views/foo.erb
+    test/views/foo.haml
+    test/views/foo.sass
+    test/views/foo_layout.erb
+    test/views/foo_layout.haml
+    test/views/layout_test/foo.builder
+    test/views/layout_test/foo.erb
+    test/views/layout_test/foo.haml
+    test/views/layout_test/foo.sass
+    test/views/layout_test/layout.builder
+    test/views/layout_test/layout.erb
+    test/views/layout_test/layout.haml
+    test/views/layout_test/layout.sass
+    test/views/no_layout/no_layout.builder
+    test/views/no_layout/no_layout.haml
+  ]
+  # = MANIFEST =
+
+  s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/}
+
+  s.extra_rdoc_files = %w[README.rdoc LICENSE]
+  s.add_dependency 'rack', '>= 0.4.0'
+
+  s.has_rdoc = true
+  s.homepage = "http://sinatra.rubyforge.org"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sinatra", "--main", "README.rdoc"]
+  s.require_paths = %w[lib]
+  s.rubyforge_project = 'sinatra'
+  s.rubygems_version = '1.1.1'
+end

data/test/app_test.rb

@@ -0,0 +1,299 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Sinatra" do
+
+  setup do
+    Sinatra.application = nil
+  end
+
+  specify "should put all DSL methods on (main)" do
+    object = Object.new
+    Sinatra::Application::FORWARD_METHODS.each do |method|
+      object.private_methods.should.include(method)
+    end
+  end
+
+  specify "should handle result of nil" do
+    get '/' do
+      nil
+    end
+
+    get_it '/'
+    should.be.ok
+    body.should == ''
+  end
+
+  specify "handles events" do
+    get '/:name' do
+      'Hello ' + params["name"]
+    end
+
+    get_it '/Blake'
+
+    should.be.ok
+    body.should.equal 'Hello Blake'
+  end
+
+
+  specify "handles splats" do
+    get '/hi/*' do
+      params["splat"].kind_of?(Array).should.equal true
+      params["splat"].first
+    end
+
+    get_it '/hi/Blake'
+
+    should.be.ok
+    body.should.equal 'Blake'
+  end
+
+  specify "handles multiple splats" do
+    get '/say/*/to/*' do
+      params["splat"].join(' ')
+    end
+
+    get_it '/say/hello/to/world'
+
+    should.be.ok
+    body.should.equal 'hello world'
+  end
+
+  specify "allow empty splats" do
+    get '/say/*/to*/*' do
+      params["splat"].join(' ')
+    end
+
+    get_it '/say/hello/to/world'
+
+    should.be.ok
+    body.should.equal 'hello  world' # second splat is empty
+
+    get_it '/say/hello/tomy/world'
+
+    should.be.ok
+    body.should.equal 'hello my world'
+  end
+
+  specify "gives access to underlying response header Hash" do
+    get '/' do
+      header['X-Test'] = 'Is this thing on?'
+      headers 'X-Test2' => 'Foo', 'X-Test3' => 'Bar'
+      ''
+    end
+
+    get_it '/'
+    should.be.ok
+    headers.should.include 'X-Test'
+    headers['X-Test'].should.equal 'Is this thing on?'
+    headers.should.include 'X-Test3'
+    headers['X-Test3'].should.equal 'Bar'
+  end
+
+  specify "follows redirects" do
+    get '/' do
+      redirect '/blake'
+    end
+
+    get '/blake' do
+      'Mizerany'
+    end
+
+    get_it '/'
+    should.be.redirection
+    body.should.equal ''
+
+    follow!
+    should.be.ok
+    body.should.equal 'Mizerany'
+  end
+
+  specify "renders a body with a redirect" do
+    Sinatra::EventContext.any_instance.expects(:foo).returns('blah')
+    get "/" do
+      redirect 'foo', :foo
+    end
+    get_it '/'
+    should.be.redirection
+    headers['Location'].should.equal 'foo'
+    body.should.equal 'blah'
+  end
+
+  specify "redirects permanently with 301 status code" do
+    get "/" do
+      redirect 'foo', 301
+    end
+    get_it '/'
+    should.be.redirection
+    headers['Location'].should.equal 'foo'
+    status.should.equal 301
+    body.should.be.empty
+  end
+
+  specify "stop sets content and ends event" do
+
+    Sinatra::EventContext.any_instance.expects(:foo).never
+
+    get '/set_body' do
+      stop 'Hello!'
+      stop 'World!'
+      foo
+    end
+
+    get_it '/set_body'
+
+    should.be.ok
+    body.should.equal 'Hello!'
+
+  end
+
+  specify "should set status then call helper with a var" do
+    Sinatra::EventContext.any_instance.expects(:foo).once.with(1).returns('bah!')
+
+    get '/set_body' do
+      stop [404, [:foo, 1]]
+    end
+
+    get_it '/set_body'
+
+    should.be.not_found
+    body.should.equal 'bah!'
+
+  end
+
+  specify "should easily set response Content-Type" do
+    get '/foo.html' do
+      content_type 'text/html', :charset => 'utf-8'
+      "<h1>Hello, World</h1>"
+    end
+
+    get_it '/foo.html'
+    should.be.ok
+    headers['Content-Type'].should.equal 'text/html;charset=utf-8'
+    body.should.equal '<h1>Hello, World</h1>'
+
+    get '/foo_test.xml' do
+      content_type :xml
+      "<feed></feed>"
+    end
+
+    get_it '/foo_test.xml'
+    should.be.ok
+    headers['Content-Type'].should.equal 'application/xml'
+    body.should.equal '<feed></feed>'
+  end
+
+  specify "supports conditional GETs with last_modified" do
+    modified_at = Time.now
+    get '/maybe' do
+      last_modified modified_at
+      'response body, maybe'
+    end
+
+    get_it '/maybe'
+    should.be.ok
+    body.should.equal 'response body, maybe'
+
+    get_it '/maybe', :env => { 'HTTP_IF_MODIFIED_SINCE' => modified_at.httpdate }
+    status.should.equal 304
+    body.should.equal ''
+  end
+
+  specify "supports conditional GETs with entity_tag" do
+    get '/strong' do
+      entity_tag 'FOO'
+      'foo response'
+    end
+
+    get_it '/strong'
+    should.be.ok
+    body.should.equal 'foo response'
+
+    get_it '/strong', {},
+      'HTTP_IF_NONE_MATCH' => '"BAR"'
+    should.be.ok
+    body.should.equal 'foo response'
+
+    get_it '/strong', {},
+      'HTTP_IF_NONE_MATCH' => '"FOO"'
+    status.should.equal 304
+    body.should.equal ''
+
+    get_it '/strong', {},
+      'HTTP_IF_NONE_MATCH' => '"BAR", *'
+    status.should.equal 304
+    body.should.equal ''
+  end
+
+  specify "delegates HEAD requests to GET handlers" do
+    get '/invisible' do
+      "I am invisible to the world"
+    end
+
+    head_it '/invisible'
+    should.be.ok
+    body.should.not.equal "I am invisible to the world"
+    body.should.equal ''
+  end
+
+
+  specify "supports PUT" do
+    put '/' do
+      'puted'
+    end
+    put_it '/'
+    assert_equal 'puted', body
+  end
+
+  specify "rewrites POSTs with _method param to PUT" do
+    put '/' do
+      'puted'
+    end
+    post_it '/', :_method => 'PUT'
+    assert_equal 'puted', body
+  end
+
+  # Some Ajax libraries downcase the _method parameter value. Make
+  # sure we can handle that.
+  specify "rewrites POSTs with lowercase _method param to PUT" do
+    put '/' do
+      'puted'
+    end
+    post_it '/', :_method => 'put'
+    body.should.equal 'puted'
+  end
+
+  # Ignore any _method parameters specified in GET requests or on the query string in POST requests.
+  specify "does not rewrite GETs with _method param to PUT" do
+    get '/' do
+      'getted'
+    end
+    get_it '/', :_method => 'put'
+    should.be.ok
+    body.should.equal 'getted'
+  end
+
+  specify "ignores _method query string parameter on non-POST requests" do
+    post '/' do
+      'posted'
+    end
+    put '/' do
+      'booo'
+    end
+    post_it "/?_method=PUT"
+    should.be.ok
+    body.should.equal 'posted'
+  end
+
+  specify "does not read body if content type is not url encoded" do
+    post '/foo.xml' do
+      request.env['CONTENT_TYPE'].should.be == 'application/xml'
+      request.content_type.should.be == 'application/xml'
+      request.body.read
+    end
+
+    post_it '/foo.xml', '<foo></foo>', :content_type => 'application/xml'
+    @response.should.be.ok
+    @response.body.should.be == '<foo></foo>'
+  end
+
+end

data/test/application_test.rb

@@ -0,0 +1,318 @@
+require File.dirname(__FILE__) + '/helper'
+
+require 'uri'
+
+class TesterWithEach
+  def each
+    yield 'foo'
+    yield 'bar'
+    yield 'baz'
+  end
+end
+
+context "Looking up a request" do
+
+  setup do
+    Sinatra.application = nil
+  end
+
+  specify "returns what's at the end" do
+    block = Proc.new { 'Hello' }
+    get '/', &block
+
+    result = Sinatra.application.lookup(
+      Rack::Request.new(
+        'REQUEST_METHOD' => 'GET',
+        'PATH_INFO' => '/'
+      )
+    )
+
+    result.should.not.be.nil
+    result.block.should.be block
+  end
+
+  specify "takes params in path" do
+    block = Proc.new { 'Hello' }
+    get '/:foo', &block
+
+    result = Sinatra.application.lookup(
+      Rack::Request.new(
+        'REQUEST_METHOD' => 'GET',
+        'PATH_INFO' => '/bar'
+      )
+    )
+
+    result.should.not.be.nil
+    result.block.should.be block
+    result.params.should.equal "foo" => 'bar'
+  end
+
+end
+
+context "An app returns" do
+
+  setup do
+    Sinatra.application = nil
+  end
+
+  specify "404 if no events found" do
+    request = Rack::MockRequest.new(@app)
+    get_it '/'
+    should.be.not_found
+    body.should.equal '<h1>Not Found</h1>'
+  end
+
+  specify "200 if success" do
+    get '/' do
+      'Hello World'
+    end
+    get_it '/'
+    should.be.ok
+    body.should.equal 'Hello World'
+  end
+
+  specify "an objects result from each if it has it" do
+
+    get '/' do
+      TesterWithEach.new
+    end
+
+    get_it '/'
+    should.be.ok
+    body.should.equal 'foobarbaz'
+
+  end
+
+  specify "the body set if set before the last" do
+
+    get '/' do
+      body 'Blake'
+      'Mizerany'
+    end
+
+    get_it '/'
+    should.be.ok
+    body.should.equal 'Blake'
+
+  end
+
+end
+
+context "Application#configure blocks" do
+
+  setup do
+    Sinatra.application = nil
+  end
+
+  specify "run when no environment specified" do
+    ref = false
+    configure { ref = true }
+    ref.should.equal true
+  end
+
+  specify "run when matching environment specified" do
+    ref = false
+    configure(:test) { ref = true }
+    ref.should.equal true
+  end
+
+  specify "do not run when no matching environment specified" do
+    configure(:foo) { flunk "block should not have been executed" }
+    configure(:development, :production, :foo) { flunk "block should not have been executed" }
+  end
+
+  specify "accept multiple environments" do
+    ref = false
+    configure(:foo, :test, :bar) { ref = true }
+    ref.should.equal true
+  end
+
+end
+
+context "Default Application Configuration" do
+
+  specify "includes 404 and 500 error handlers" do
+    Sinatra.application.errors.should.include(Sinatra::ServerError)
+    Sinatra.application.errors[Sinatra::ServerError].should.not.be.nil
+    Sinatra.application.errors.should.include(Sinatra::NotFound)
+    Sinatra.application.errors[Sinatra::NotFound].should.not.be.nil
+  end
+
+  specify "includes Static event" do
+    assert Sinatra.application.events[:get].any? { |e| Sinatra::Static === e }
+  end
+
+end
+
+context "Events in an app" do
+
+  setup do
+    Sinatra.application = nil
+  end
+
+  specify "evaluate in a clean context" do
+    helpers do
+      def foo
+        'foo'
+      end
+    end
+
+    get '/foo' do
+      foo
+    end
+
+    get_it '/foo'
+    should.be.ok
+    body.should.equal 'foo'
+  end
+
+  specify "get access to request, response, and params" do
+    get '/:foo' do
+      params["foo"] + params["bar"]
+    end
+
+    get_it '/foo?bar=baz'
+    should.be.ok
+    body.should.equal 'foobaz'
+  end
+
+  specify "can filters by agent" do
+
+    get '/', :agent => /Windows/ do
+      request.env['HTTP_USER_AGENT']
+    end
+
+    get_it '/', :env => { :agent => 'Windows' }
+    should.be.ok
+    body.should.equal 'Windows'
+
+    get_it '/', :env => { :agent => 'Mac' }
+    should.not.be.ok
+
+  end
+
+  specify "can use regex to get parts of user-agent" do
+
+    get '/', :agent => /Windows (NT)/ do
+      params[:agent].first
+    end
+
+    get_it '/', :env => { :agent => 'Windows NT' }
+
+    body.should.equal 'NT'
+
+  end
+
+  specify "can deal with spaces in paths" do
+
+    path = '/path with spaces'
+
+    get path do
+      "Look ma, a path with spaces!"
+    end
+
+    get_it URI.encode(path)
+
+    body.should.equal "Look ma, a path with spaces!"
+  end
+
+  specify "route based on host" do
+
+    get '/' do
+      'asdf'
+    end
+
+    get_it '/'
+    assert ok?
+    assert_equal('asdf', body)
+
+    get '/foo', :host => 'foo.sinatrarb.com' do
+      'in foo!'
+    end
+
+    get '/foo', :host => 'bar.sinatrarb.com'  do
+      'in bar!'
+    end
+
+    get_it '/foo', {}, 'HTTP_HOST' => 'foo.sinatrarb.com'
+    assert ok?
+    assert_equal 'in foo!', body
+
+    get_it '/foo', {}, 'HTTP_HOST' => 'bar.sinatrarb.com'
+    assert ok?
+    assert_equal 'in bar!', body
+
+    get_it '/foo'
+    assert not_found?
+
+  end
+
+end
+
+
+context "Options in an app" do
+
+  setup do
+    Sinatra.application = nil
+    @app = Sinatra::application
+  end
+
+  specify "can be set singly on app" do
+    @app.set :foo, 1234
+    @app.options.foo.should.equal 1234
+  end
+
+  specify "can be set singly from top-level" do
+    set_option :foo, 1234
+    @app.options.foo.should.equal 1234
+  end
+
+  specify "can be set multiply on app" do
+    @app.options.foo.should.be.nil
+    @app.set :foo => 1234,
+      :bar => 'hello, world'
+    @app.options.foo.should.equal 1234
+    @app.options.bar.should.equal 'hello, world'
+  end
+
+  specify "can be set multiply from top-level" do
+    @app.options.foo.should.be.nil
+    set_options :foo => 1234,
+      :bar => 'hello, world'
+    @app.options.foo.should.equal 1234
+    @app.options.bar.should.equal 'hello, world'
+  end
+
+  specify "can be enabled on app" do
+    @app.options.foo.should.be.nil
+    @app.enable :sessions, :foo, :bar
+    @app.options.sessions.should.equal true
+    @app.options.foo.should.equal true
+    @app.options.bar.should.equal true
+  end
+
+  specify "can be enabled from top-level" do
+    @app.options.foo.should.be.nil
+    enable :sessions, :foo, :bar
+    @app.options.sessions.should.equal true
+    @app.options.foo.should.equal true
+    @app.options.bar.should.equal true
+  end
+
+  specify "can be disabled on app" do
+    @app.options.foo.should.be.nil
+    @app.disable :sessions, :foo, :bar
+    @app.options.sessions.should.equal false
+    @app.options.foo.should.equal false
+    @app.options.bar.should.equal false
+  end
+
+  specify "can be enabled from top-level" do
+    @app.options.foo.should.be.nil
+    disable :sessions, :foo, :bar
+    @app.options.sessions.should.equal false
+    @app.options.foo.should.equal false
+    @app.options.bar.should.equal false
+  end
+
+end