rtomayko-sinatra 0.9.0 → 0.9.0.2

data/lib/sinatra/compat.rb

@@ -1,58 +1,102 @@
+# 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'
 
-# Deprecated. Do we still need this?
+# 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
 
-# Deprecated. Make Rack 0.9.0 backward compatibile with 0.4.0
-# mime types
+# 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
-  unless defined? MIME_TYPES
-    MIME_TYPES = Hash.new {|hash,key|
-      Rack::Mime::MIME_TYPES[".#{key}"] }
+  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
 
-# Deprecated. Rack::Utils will not extend itself in the future. Sinatra::Base
-# includes Rack::Utils, however.
-module Rack::Utils ; extend self ; end
-
 module Sinatra
   module Compat
   end
 
-  # Deprecated. Use: error
+  # 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
-    # Deprecated.
-    FORWARD_METHODS = Sinatra::Delegator::METHODS
+    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
-    alias :stop :halt
+    def stop(*args, &block)
+      sinatra_warn "The 'stop' method is deprecated; use 'halt' instead."
+      halt(*args, &block)
+    end
 
     # Deprecated. Use: etag
-    alias :entity_tag :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]
@@ -60,48 +104,89 @@ module Sinatra
       super(path, opts)
     end
 
-    def options ; self.class.options ; 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 ; Options.new(self) ; 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 !~ /=$/
-            nil
-          else
-            super
-          end
-        end
+      def options
+        sinatra_warn "The 'options' class method is deprecated; use 'self' instead."
+        Options.new(self)
       end
 
       # Deprecated. Use: configure
-      alias :configures :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
-      alias :set_option :set
-      alias :set_options :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
-      alias :env :environment
+
+      # 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
@@ -112,30 +197,43 @@ module Sinatra
   class << self
     # Deprecated. Use: Sinatra::Application
     def application
+      sinatra_warn "Sinatra.application is deprecated; use Sinatra::Application instead."
       Sinatra::Application
     end
 
-    # Deprecated. Use: error 404
-    def not_found(&block)
-      error 404, &block
-    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
 
-    # Deprecated. Use: Sinatra::Application
-    alias :build_application :application
+    def build_application
+      sinatra_warn "Sinatra.build_application is deprecated; use Sinatra::Application instead."
+      Sinatra::Application
+    end
 
-    # Deprecated.
-    def options ; Sinatra::Application.options ; end
-    def port ; options.port ; end
-    def host ; options.host ; end
-    def env ; options.environment  ; 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/test.rb

@@ -1,104 +1,57 @@
 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
-
-  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)]
+module Sinatra
+
+  module Test
+    include Rack::Utils
+
+    attr_reader :app, :request, :response
+
+    def test_request(verb, path, *args)
+      @app = Sinatra::Application if @app.nil? && defined?(Sinatra::Application)
+      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, build_query(input)]
+          else
+            [env, input]
+          end
+        when 1 # params
+          if (data = args.first).kind_of?(Hash)
+            env = (data.delete(:env) || {})
+            [env, build_query(data)]
+          else
+            [{}, data]
+          end
+        when 0
+          [{}, '']
         else
-          [{}, data]
+          raise ArgumentError, "zero, one, or two arguments expected"
         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
+      opts = rack_opts(opts)
+      opts[:input] ||= input
+      yield @request if block_given?
+      @response = @request.request(verb, path, opts)
     end
-  end
 
-  def env_for(opts={})
-    opts = rack_opts(opts)
-    Rack::MockRequest.env_for(opts)
-  end
+    def get(path, *args, &b)  ; test_request('GET', path, *args, &b) ; end
+    def head(path, *args, &b) ; test_request('HEAD', path, *args, &b) ; end
+    def post(path, *args, &b) ; test_request('POST', path, *args, &b) ; end
+    def put(path, *args, &b)  ; test_request('PUT', path, *args, &b) ; end
+    def delete(path, *args, &b) ; test_request('DELETE', path, *args, &b) ; 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
+    def follow!
+      test_request 'GET', @response.location
     end
 
-    include Sinatra::Delegator
+    def body ; @response.body ; end
+    def status ; @response.status ; end
 
-    # Deprecated. Tests no longer delegate missing methods to the
-    # mock response. Use: @response
+    # Delegate other missing methods to @response.
     def method_missing(name, *args, &block)
       if @response && @response.respond_to?(name)
         @response.send(name, *args, &block)
@@ -106,5 +59,53 @@ module Sinatra::Test
         super
       end
     end
+
+    # Also check @response since we delegate there.
+    def respond_to?(symbol, include_private=false)
+      super || (@response && @response.respond_to?(symbol, include_private))
+    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
+
+    if defined? Sinatra::Compat
+      # Deprecated. Use: "get" instead of "get_it".
+      %w(get head post put delete).each do |verb|
+        eval <<-RUBY, binding, __FILE__, __LINE__
+        def #{verb}_it(*args, &block)
+          sinatra_warn "The #{verb}_it method is deprecated; use #{verb} instead."
+          test_request('#{verb.upcase}', *args, &block)
+        end
+        RUBY
+      end
+
+      # Deprecated. Use: build_query instead.
+      def param_string(hash)
+        sinatra_warn "The param_string method is deprecated; use build_query instead."
+        build_query(hash)
+      end
+    end
+  end
+
+  class TestHarness
+    include Test
+
+    def initialize(app=nil)
+      @app = app || Sinatra::Application
+    end
   end
 end