adamwiggins-sinatra 0.8.9

data/lib/sinatra/compat.rb

@@ -0,0 +1,239 @@
+# Sinatra 0.3.x compatibility module.
+#
+# The following code makes Sinatra 0.9.x compatible with Sinatra 0.3.x to
+# ease the transition to the final 1.0 release. Everything defined in this
+# file will be removed for the 1.0 release.
+
+require 'ostruct'
+require 'sinatra/base'
+require 'sinatra/main'
+
+# Like Kernel#warn but outputs the location that triggered the warning.
+def sinatra_warn(*message)
+  line = caller.
+    detect { |line| line !~ /(?:lib\/sinatra\/|__DELEGATE__)/ }.
+    sub(/:in .*/, '')
+  warn "#{line}: warning: #{message.join(' ')}"
+end
+
+# Rack now supports evented and swiftiplied mongrels through separate
+# handler.
+if ENV['SWIFT']
+  sinatra_warn 'the SWIFT environment variable is deprecated;',
+    'use Rack::Handler::SwiftipliedMongrel instead.'
+  require 'swiftcore/swiftiplied_mongrel'
+  puts "Using Swiftiplied Mongrel"
+elsif ENV['EVENT']
+  sinatra_warn 'the EVENT environment variable is deprecated;',
+    'use Rack::Handler::EventedMongrel instead.'
+  require 'swiftcore/evented_mongrel'
+  puts "Using Evented Mongrel"
+end
+
+# Make Rack 0.9.0 backward compatibile with 0.4.0 mime types. This isn't
+# technically a Sinatra issue but many Sinatra apps access the old
+# MIME_TYPES constants due to Sinatra example code.
+require 'rack/file'
+class Rack::File
+  def self.const_missing(const_name)
+    if const_name == :MIME_TYPES
+      hash = Hash.new { |hash,key| Rack::Mime::MIME_TYPES[".#{key}"] }
+      const_set :MIME_TYPES, hash
+      sinatra_warn 'Rack::File::MIME_TYPES is deprecated; use Rack::Mime instead.'
+      hash
+    else
+      super
+    end
+  end
+end
+
+module Sinatra
+  module Compat
+  end
+
+  # The ServerError exception is deprecated. Any exception is considered an
+  # internal server error.
+  class ServerError < RuntimeError
+    def initialize(*args, &block)
+      sinatra_warn 'Sinatra::ServerError is deprecated;',
+        'use another exception, error, or Kernel#fail instead.'
+    end
+    def code ; 500 ; end
+  end
+
+  class Default < Base
+    def self.const_missing(const_name)
+      if const_name == :FORWARD_METHODS
+        sinatra_warn 'Sinatra::Application::FORWARD_METHODS is deprecated;',
+          'use Sinatra::Delegator::METHODS instead.'
+        const_set :FORWARD_METHODS, Sinatra::Delegator::METHODS
+        Sinatra::Delegator::METHODS
+      else
+        super
+      end
+    end
+
+    # Deprecated. Use: response['Header-Name']
+    def headers(header=nil)
+      sinatra_warn "The 'headers' method is deprecated; use 'response' instead."
+      response.headers.merge!(header) if header
+      response.headers
+    end
+    alias :header :headers
+
+    # Deprecated. Use: halt
+    def stop(*args, &block)
+      sinatra_warn "The 'stop' method is deprecated; use 'halt' instead."
+      halt(*args, &block)
+    end
+
+    # Deprecated. Use: etag
+    def entity_tag(*args, &block)
+      sinatra_warn "The 'entity_tag' method is deprecated; use 'etag' instead."
+      etag(*args, &block)
+    end
+
+    # The :disposition option is deprecated; use: #attachment. This method
+    # setting the Content-Transfer-Encoding header is deprecated.
+    #--
+    # TODO deprecation warning for :disposition argument.
+    def send_file(path, opts={})
+      opts[:disposition] = 'attachment' if !opts.key?(:disposition)
+      attachment opts[:filename] || path if opts[:filename] || opts[:disposition]
+      response['Content-Transfer-Encoding'] = 'binary' if opts[:disposition]
+      super(path, opts)
+    end
+
+    # Throwing halt with a Symbol and the to_result convention are
+    # deprecated. Override the invoke method to detect those types of return
+    # values.
+    def invoke(handler)
+      res = super
+      case
+      when res.kind_of?(Symbol)
+        sinatra_warn "Invoking the :#{res} helper by returning a Symbol is deprecated;",
+          "call the helper directly instead."
+        @response.body = __send__(res)
+      when res.respond_to?(:to_result)
+        sinatra_warn "The to_result convention is deprecated."
+        @response.body = res.to_result(self)
+      end
+      res
+    end
+
+    def options
+      Options.new(self.class)
+    end
+
+    class Options < Struct.new(:target) #:nodoc:
+      def method_missing(name, *args, &block)
+        if target.respond_to?(name)
+          target.__send__(name, *args, &block)
+        elsif args.empty? && name.to_s !~ /=$/
+          sinatra_warn 'accessing undefined options will raise a NameError in Sinatra 1.0'
+          nil
+        else
+          super
+        end
+      end
+    end
+
+    class << self
+      # Deprecated. Options are stored directly on the class object.
+      def options
+        sinatra_warn "The 'options' class method is deprecated; use 'self' instead."
+        Options.new(self)
+      end
+
+      # Deprecated. Use: configure
+      def configures(*args, &block)
+        sinatra_warn "The 'configures' method is deprecated; use 'configure' instead."
+        configure(*args, &block)
+      end
+
+      # Deprecated. Use: set
+      def default_options
+        sinatra_warn "Sinatra::Application.default_options is deprecated; use 'set' instead."
+        fake = lambda { |options| set(options) }
+        def fake.merge!(options) ; call(options) ; end
+        fake
+      end
+
+      # Deprecated. Use: set
+      def set_option(*args, &block)
+        sinatra_warn "The 'set_option' method is deprecated; use 'set' instead."
+        set(*args, &block)
+      end
+
+      def set_options(*args, &block)
+        sinatra_warn "The 'set_options' method is deprecated; use 'set' instead."
+        set(*args, &block)
+      end
+
+      # Deprecated. Use: set :environment, ENV
+      def env=(value)
+        sinatra_warn "The :env option is deprecated; use :environment instead."
+        set :environment, value
+      end
+
+      # Deprecated. Use: options.environment
+      def env
+        sinatra_warn "The :env option is deprecated; use :environment instead."
+        environment
+      end
+    end
+
+    # Deprecated. Missing messages are no longer delegated to @response.
+    def method_missing(name, *args, &b)
+      if @response.respond_to?(name)
+        sinatra_warn "The '#{name}' method is deprecated; use 'response.#{name}' instead."
+        @response.send(name, *args, &b)
+      else
+        super
+      end
+    end
+  end
+
+  class << self
+    # Deprecated. Use: Sinatra::Application
+    def application
+      sinatra_warn "Sinatra.application is deprecated; use Sinatra::Application instead."
+      Sinatra::Application
+    end
+
+    # Deprecated. Use: Sinatra::Application.reset!
+    def application=(value)
+      raise ArgumentError unless value.nil?
+      sinatra_warn "Setting Sinatra.application to nil is deprecated; create a new instance instead."
+      Sinatra.class_eval do
+        remove_const :Application
+        const_set :Application, Class.new(Sinatra::Default)
+      end
+    end
+
+    def build_application
+      sinatra_warn "Sinatra.build_application is deprecated; use Sinatra::Application instead."
+      Sinatra::Application
+    end
+
+    def options
+      sinatra_warn "Sinatra.options is deprecated; use Sinatra::Application.option_name instead."
+      Sinatra::Application.options
+    end
+
+    def port
+      sinatra_warn "Sinatra.port is deprecated; use Sinatra::Application.port instead."
+      options.port
+    end
+
+    def host
+      sinatra_warn "Sinatra.host is deprecated; use Sinatra::Application.host instead."
+      options.host
+    end
+
+    def env
+      sinatra_warn "Sinatra.env is deprecated; use Sinatra::Application.environment instead."
+      options.environment
+    end
+  end
+end

data/lib/sinatra/main.rb

@@ -0,0 +1,48 @@
+require 'sinatra/base'
+
+module Sinatra
+  class Default < Base
+    set :app_file, lambda {
+      ignore = [
+        /lib\/sinatra.*\.rb$/, # all sinatra code
+        /\(.*\)/,              # generated code
+        /custom_require\.rb$/  # rubygems require hacks
+      ]
+      path =
+        caller.map{ |line| line.split(':', 2).first }.find do |file|
+          next if ignore.any? { |pattern| file =~ pattern }
+          file
+        end
+      path || $0
+    }.call
+
+    set :run, Proc.new { $0 == app_file }
+    set :reload, Proc.new{ app_file? && development? }
+
+    if run? && ARGV.any?
+      require 'optparse'
+      OptionParser.new { |op|
+        op.on('-x')        {       set :mutex, true }
+        op.on('-e env')    { |val| set :environment, val.to_sym }
+        op.on('-s server') { |val| set :server, val }
+        op.on('-p port')   { |val| set :port, val.to_i }
+      }.parse!(ARGV.dup)
+    end
+  end
+end
+
+include Sinatra::Delegator
+
+def helpers(&block)
+  Sinatra::Application.send :class_eval, &block
+end
+
+def mime(ext, type)
+  ext = ".#{ext}" unless ext.to_s[0] == ?.
+  Rack::Mime::MIME_TYPES[ext.to_s] = type
+end
+
+at_exit do
+  raise $! if $!
+  Sinatra::Application.run! if Sinatra::Application.run?
+end

data/lib/sinatra/test/rspec.rb

@@ -0,0 +1,2 @@
+require 'sinatra/test'
+require 'spec/interop/test'

data/lib/sinatra/test/spec.rb

@@ -0,0 +1,2 @@
+require 'test/spec'
+require 'sinatra/test'

data/lib/sinatra/test/unit.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'sinatra/test'
+
+Test::Unit::TestCase.send :include, Sinatra::Test
+
+Sinatra::Default.set(
+  :env => :test,
+  :run => false,
+  :raise_errors => true,
+  :logging => false
+)

data/lib/sinatra/test.rb

@@ -0,0 +1,112 @@
+require 'sinatra/base'
+require 'test/unit'
+
+module Sinatra::Test
+  include Rack::Utils
+
+  attr_reader :app, :request, :response
+
+  def mock_app(base=Sinatra::Base, &block)
+    @app = Sinatra.new(base, &block)
+  end
+
+  undef request if method_defined?(:request)
+
+  def request(verb, path, *args)
+    fail "@app not set - cannot make request" if @app.nil?
+    @request = Rack::MockRequest.new(@app)
+    opts, input =
+      case args.size
+      when 2 # input, env
+        input, env = args
+        if input.kind_of?(Hash) # params, env
+          [env, param_string(input)]
+        else
+          [env, input]
+        end
+      when 1 # params
+        if (data = args.first).kind_of?(Hash)
+          env = (data.delete(:env) || {})
+          [env, param_string(data)]
+        else
+          [{}, data]
+        end
+      when 0
+        [{}, '']
+      else
+        raise ArgumentError, "zero, one, or two arguments expected"
+      end
+    opts = rack_opts(opts)
+    opts[:input] ||= input
+    yield @request if block_given?
+    @response = @request.request(verb, path, opts)
+  end
+
+  def get(path, *args, &b)  ; request('GET', path, *args, &b) ; end
+  def head(path, *args, &b) ; request('HEAD', path, *args, &b) ; end
+  def post(path, *args, &b) ; request('POST', path, *args, &b) ; end
+  def put(path, *args, &b)  ; request('PUT', path, *args, &b) ; end
+  def delete(path, *args, &b) ; request('DELETE', path, *args, &b) ; end
+
+  def follow!
+    request 'GET', @response.location
+  end
+
+  def should
+    @response.should
+  end
+
+  def body
+    @response.body
+  end
+
+  def status
+    @response.status
+  end
+
+  RACK_OPT_NAMES = {
+    :accept => "HTTP_ACCEPT",
+    :agent => "HTTP_USER_AGENT",
+    :host => "HTTP_HOST",
+    :session => "HTTP_COOKIE",
+    :cookies => "HTTP_COOKIE",
+    :content_type => "CONTENT_TYPE"
+  }
+
+  def rack_opts(opts)
+    opts.inject({}) do |hash,(key,val)|
+      key = RACK_OPT_NAMES[key] || key
+      hash[key] = val
+      hash
+    end
+  end
+
+  def env_for(opts={})
+    opts = rack_opts(opts)
+    Rack::MockRequest.env_for(opts)
+  end
+
+  def param_string(hash)
+    hash.map { |pair| pair.map{|v|escape(v)}.join('=') }.join('&')
+  end
+
+  if defined? Sinatra::Compat
+    # Deprecated. Use: "get" instead of "get_it".
+    %w(get head post put delete).each do |verb|
+      alias_method "#{verb}_it", verb
+      remove_method verb
+    end
+
+    include Sinatra::Delegator
+
+    # Deprecated. Tests no longer delegate missing methods to the
+    # mock response. Use: @response
+    def method_missing(name, *args, &block)
+      if @response && @response.respond_to?(name)
+        @response.send(name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/sinatra.rb

@@ -0,0 +1,3 @@
+require 'sinatra/base'
+require 'sinatra/main'
+require 'sinatra/compat'

data/sinatra.gemspec

@@ -0,0 +1,107 @@
+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.8.9'
+  s.date = '2009-01-13'
+
+  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[
+    AUTHORS
+    CHANGES
+    LICENSE
+    README.rdoc
+    Rakefile
+    compat/app_test.rb
+    compat/application_test.rb
+    compat/builder_test.rb
+    compat/custom_error_test.rb
+    compat/erb_test.rb
+    compat/events_test.rb
+    compat/filter_test.rb
+    compat/haml_test.rb
+    compat/helper.rb
+    compat/mapped_error_test.rb
+    compat/pipeline_test.rb
+    compat/public/foo.xml
+    compat/sass_test.rb
+    compat/sessions_test.rb
+    compat/streaming_test.rb
+    compat/sym_params_test.rb
+    compat/template_test.rb
+    compat/use_in_file_templates_test.rb
+    compat/views/foo.builder
+    compat/views/foo.erb
+    compat/views/foo.haml
+    compat/views/foo.sass
+    compat/views/foo_layout.erb
+    compat/views/foo_layout.haml
+    compat/views/layout_test/foo.builder
+    compat/views/layout_test/foo.erb
+    compat/views/layout_test/foo.haml
+    compat/views/layout_test/foo.sass
+    compat/views/layout_test/layout.builder
+    compat/views/layout_test/layout.erb
+    compat/views/layout_test/layout.haml
+    compat/views/layout_test/layout.sass
+    compat/views/no_layout/no_layout.builder
+    compat/views/no_layout/no_layout.haml
+    lib/sinatra.rb
+    lib/sinatra/base.rb
+    lib/sinatra/compat.rb
+    lib/sinatra/images/404.png
+    lib/sinatra/images/500.png
+    lib/sinatra/main.rb
+    lib/sinatra/test.rb
+    lib/sinatra/test/rspec.rb
+    lib/sinatra/test/spec.rb
+    lib/sinatra/test/unit.rb
+    sinatra.gemspec
+    test/base_test.rb
+    test/builder_test.rb
+    test/data/reload_app_file.rb
+    test/erb_test.rb
+    test/filter_test.rb
+    test/haml_test.rb
+    test/helpers_test.rb
+    test/mapped_error_test.rb
+    test/middleware_test.rb
+    test/options_test.rb
+    test/reload_test.rb
+    test/request_test.rb
+    test/result_test.rb
+    test/routing_test.rb
+    test/sass_test.rb
+    test/sinatra_test.rb
+    test/static_test.rb
+    test/templates_test.rb
+    test/views/hello.builder
+    test/views/hello.erb
+    test/views/hello.haml
+    test/views/hello.sass
+    test/views/hello.test
+    test/views/layout2.builder
+    test/views/layout2.erb
+    test/views/layout2.haml
+    test/views/layout2.test
+  ]
+  # = MANIFEST =
+
+  s.test_files = s.files.select {|path| path =~ /^test\/.*_test.rb/}
+
+  s.extra_rdoc_files = %w[README.rdoc LICENSE]
+  s.add_dependency 'rack', '>= 0.9.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/base_test.rb

@@ -0,0 +1,72 @@
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
+
+describe 'Sinatra::Base' do
+  include Sinatra::Test
+
+  it 'includes Rack::Utils' do
+    Sinatra::Base.should.include Rack::Utils
+  end
+
+  it 'can be used as a Rack application' do
+    mock_app {
+      get '/' do
+        'Hello World'
+      end
+    }
+    @app.should.respond_to :call
+
+    request = Rack::MockRequest.new(@app)
+    response = request.get('/')
+    response.should.be.ok
+    response.body.should.equal 'Hello World'
+  end
+
+  it 'can be used as Rack middleware' do
+    app = lambda { |env| [200, {}, ['Goodbye World']] }
+    mock_middleware =
+      mock_app {
+        get '/' do
+          'Hello World'
+        end
+        get '/goodbye' do
+          @app.call(request.env)
+        end
+      }
+    middleware = mock_middleware.new(app)
+    middleware.app.should.be app
+
+    request = Rack::MockRequest.new(middleware)
+    response = request.get('/')
+    response.should.be.ok
+    response.body.should.equal 'Hello World'
+
+    response = request.get('/goodbye')
+    response.should.be.ok
+    response.body.should.equal 'Goodbye World'
+  end
+
+  it 'can take multiple definitions of a route' do
+    app = mock_app {
+      user_agent(/Foo/)
+      get '/foo' do
+        'foo'
+      end
+
+      get '/foo' do
+        'not foo'
+      end
+    }
+
+    request = Rack::MockRequest.new(app)
+    response = request.get('/foo', 'HTTP_USER_AGENT' => 'Foo')
+    response.should.be.ok
+    response.body.should.equal 'foo'
+
+    request = Rack::MockRequest.new(app)
+    response = request.get('/foo')
+    response.should.be.ok
+    response.body.should.equal 'not foo'
+  end
+end

data/test/builder_test.rb

@@ -0,0 +1,68 @@
+require 'test/spec'
+require 'sinatra/base'
+require 'sinatra/test'
+
+describe "Builder Templates" do
+  include Sinatra::Test
+
+  def builder_app(&block)
+    mock_app {
+      set :views, File.dirname(__FILE__) + '/views'
+      get '/', &block
+    }
+    get '/'
+  end
+
+  it 'renders inline Builder strings' do
+    builder_app { builder 'xml.instruct!' }
+    should.be.ok
+    body.should.equal %{<?xml version="1.0" encoding="UTF-8"?>\n}
+  end
+
+  it 'renders inline blocks' do
+    builder_app {
+      @name = "Frank & Mary"
+      builder do |xml|
+        xml.couple @name
+      end
+    }
+    should.be.ok
+    body.should.equal "<couple>Frank &amp; Mary</couple>\n"
+  end
+
+  it 'renders .builder files in views path' do
+    builder_app {
+      @name = "Blue"
+      builder :hello
+    }
+    should.be.ok
+    body.should.equal %(<exclaim>You're my boy, Blue!</exclaim>\n)
+  end
+
+  it "renders with inline layouts" do
+    mock_app {
+      layout do
+        %(xml.layout { xml << yield })
+      end
+      get('/') { builder %(xml.em 'Hello World') }
+    }
+    get '/'
+    should.be.ok
+    body.should.equal "<layout>\n<em>Hello World</em>\n</layout>\n"
+  end
+
+  it "renders with file layouts" do
+    builder_app {
+      builder %(xml.em 'Hello World'), :layout => :layout2
+    }
+    should.be.ok
+    body.should.equal "<layout>\n<em>Hello World</em>\n</layout>\n"
+  end
+
+  it "raises error if template not found" do
+    mock_app {
+      get('/') { builder :no_such_template }
+    }
+    lambda { get('/') }.should.raise(Errno::ENOENT)
+  end
+end

data/test/data/reload_app_file.rb

@@ -0,0 +1,3 @@
+$reload_count += 1
+
+$reload_app.get('/') { 'Hello from reload file' }