rtomayko-sinatra 0.8.10 → 0.9.0

data/Rakefile

@@ -152,12 +152,7 @@ def source_version
   line.match(/.*VERSION = '(.*)'/)[1]
 end
 
-project_files =
-  FileList[
-    '{lib,test,compat,images}/**',
-    'Rakefile', 'CHANGES', 'README.rdoc'
-  ]
-file 'sinatra.gemspec' => project_files do |f|
+file 'sinatra.gemspec' => FileList['{lib,test,images}/**','Rakefile'] do |f|
   # read spec file and split out manifest section
   spec = File.read(f.name)
   head, manifest, tail = spec.split("  # = MANIFEST =\n")

data/compat/events_test.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + '/helper'
 
 context "Simple Events" do
+
   def simple_request_hash(method, path)
     Rack::Request.new({
       'REQUEST_METHOD' => method.to_s.upcase,
@@ -13,16 +14,16 @@ context "Simple Events" do
 
   def invoke_simple(path, request_path, &b)
     params = nil
-    get path do
-      params = self.params
-      b.call if b
-    end
+    mock_app {
+      get path do
+        params = self.params
+        b.call if b
+      end
+    }
     get_it request_path
     MockResult.new(b, params)
   end
 
-  setup { Sinatra.application = nil }
-
   specify "return last value" do
     block = Proc.new { 'Simple' }
     result = invoke_simple('/', '/', &block)
@@ -37,7 +38,6 @@ context "Simple Events" do
     result.params.should.equal "foo" => 'a', "bar" => 'b'
 
     # unscapes
-    Sinatra.application = nil
     result = invoke_simple('/:foo/:bar', '/a/blake%20mizerany')
     result.should.not.be.nil
     result.params.should.equal "foo" => 'a', "bar" => 'blake mizerany'
@@ -48,17 +48,14 @@ context "Simple Events" do
     result.should.not.be.nil
     result.params.should.equal "foo" => 'a', "bar" => 'b'
 
-    Sinatra.application = nil
     result = invoke_simple('/?:foo?/?:bar?', '/a/')
     result.should.not.be.nil
     result.params.should.equal "foo" => 'a', "bar" => nil
 
-    Sinatra.application = nil
     result = invoke_simple('/?:foo?/?:bar?', '/a')
     result.should.not.be.nil
     result.params.should.equal "foo" => 'a', "bar" => nil
 
-    Sinatra.application = nil
     result = invoke_simple('/:foo?/?:bar?', '/')
     result.should.not.be.nil
     result.params.should.equal "foo" => nil, "bar" => nil

data/compat/helper.rb

@@ -1,9 +1,6 @@
 require 'rubygems'
 require 'mocha'
 
-# disable warnings in compat specs.
-$VERBOSE = nil
-
 $:.unshift File.dirname(File.dirname(__FILE__)) + "/lib"
 
 ENV['RACK_ENV'] ||= 'test'
@@ -13,18 +10,9 @@ require 'sinatra/test'
 require 'sinatra/test/unit'
 require 'sinatra/test/spec'
 
-module Sinatra::Test
-  # we need to remove the new test helper methods since they conflict with
-  # the top-level methods of the same name.
-  %w(get head post put delete).each do |verb|
-    remove_method verb
-  end
-  include Sinatra::Delegator
-end
-
 class Test::Unit::TestCase
-  include Sinatra::Test
   def setup
     @app = lambda { |env| Sinatra::Application.call(env) }
   end
+  include Sinatra::Test
 end

data/lib/sinatra.rb

@@ -1,8 +1,3 @@
-libdir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
-
 require 'sinatra/base'
 require 'sinatra/main'
 require 'sinatra/compat'
-
-use_in_file_templates!

data/lib/sinatra/base.rb

@@ -4,23 +4,12 @@ require 'rack'
 require 'rack/builder'
 
 module Sinatra
-  VERSION = '0.8.10'
+  VERSION = '0.9.0'
 
   class Request < Rack::Request
     def user_agent
       @env['HTTP_USER_AGENT']
     end
-
-    def accept
-      @env['HTTP_ACCEPT'].split(',').map { |a| a.strip }
-    end
-
-    # Override Rack 0.9.x's #params implementation (see #72 in lighthouse)
-    def params
-      self.GET.update(self.POST)
-    rescue EOFError => boom
-      self.GET
-    end
   end
 
   class Response < Rack::Response
@@ -77,7 +66,7 @@ module Sinatra
     def redirect(uri, *args)
       status 302
       response['Location'] = uri
-      halt(*args)
+      halt *args
     end
 
     # Halt processing and return the error status provided.
@@ -99,7 +88,9 @@ module Sinatra
 
     # Look up a media type by file extension in Rack's mime registry.
     def media_type(type)
-      Base.media_type(type)
+      return type if type.nil? || type.to_s.include?('/')
+      type = ".#{type}" unless type.to_s[0] == ?.
+      Rack::Mime.mime_type(type, nil)
     end
 
     # Set the Content-Type of the response body given a media type or file
@@ -142,7 +133,7 @@ module Sinatra
     class StaticFile < ::File #:nodoc:
       alias_method :to_path, :path
       def each
-        while buf = read(8192)
+        while buf = read(8196)
           yield buf
         end
       end
@@ -217,7 +208,6 @@ module Sinatra
 
     def lookup_layout(engine, options)
       return if options[:layout] == false
-      options.delete(:layout) if options[:layout] == true
       template = options[:layout] || :layout
       data = lookup_template(engine, template, options)
       [template, data]
@@ -306,10 +296,10 @@ module Sinatra
     attr_accessor :env, :request, :response, :params
 
     def call!(env)
-      @env      = env
-      @request  = Request.new(env)
+      @env = env
+      @request = Request.new(env)
       @response = Response.new
-      @params   = nil
+      @params = nil
       error_detection { dispatch! }
       @response.finish
     end
@@ -331,9 +321,10 @@ module Sinatra
       self.class.filters.each {|block| instance_eval(&block)}
       if routes = self.class.routes[@request.request_method]
         path = @request.path_info
-        original_params = nested_params(@request.params)
+        original_params = Hash.new{ |hash,k| hash[k.to_s] if Symbol === k }
+        original_params.merge! @request.params
 
-        routes.each do |pattern, keys, conditions, method_name|
+        routes.each do |pattern, keys, conditions, block|
           if pattern =~ path
             values = $~.captures.map{|val| val && unescape(val) }
             params =
@@ -351,12 +342,13 @@ module Sinatra
               else
                 {}
               end
-            @params = original_params.merge(params)
+            @params = original_params.dup
+            @params.merge!(params)
 
             catch(:pass) {
               conditions.each { |cond|
                 throw :pass if instance_eval(&cond) == false }
-              return invoke(method_name)
+              return invoke(block)
             }
           end
         end
@@ -364,22 +356,6 @@ module Sinatra
       raise NotFound
     end
 
-    def nested_params(params)
-      return indifferent_hash.merge(params) if !params.keys.join.include?('[')
-      params.inject indifferent_hash do |res, (key,val)|
-        if key =~ /\[.*\]/
-          splat = key.scan(/(^[^\[]+)|\[([^\]]+)\]/).flatten.compact
-          head, last = splat[0..-2], splat[-1]
-          head.inject(res){ |s,v| s[v] ||= indifferent_hash }[last] = val
-        end
-        res
-      end
-    end
-
-    def indifferent_hash
-      Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
-    end
-
     def invoke(block)
       res = catch(:halt) { instance_eval(&block) }
       case
@@ -401,12 +377,16 @@ module Sinatra
         else
           @response.body = res
         end
+      when res.kind_of?(Symbol)  # TODO: deprecate this.
+        @response.body = __send__(res)
       when res.respond_to?(:each)
         @response.body = res
       when (100...599) === res
         @response.status = res
       when res.nil?
         @response.body = []
+      else
+        raise TypeError, "#{res.inspect} not supported"
       end
       res
     end
@@ -422,12 +402,6 @@ module Sinatra
       invoke handler unless handler.nil?
     rescue ::Exception => boom
       @env['sinatra.error'] = boom
-
-      if options.dump_errors?
-        msg = ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n ")
-        @env['rack.errors'] << msg
-      end
-
       raise boom if options.raise_errors?
       @response.status = 500
       invoke errmap[boom.class] || errmap[Exception]
@@ -480,10 +454,6 @@ module Sinatra
         end
       end
 
-      def not_found(&block)
-        error 404, &block
-      end
-
       def template(name, &block)
         templates[name] = block
       end
@@ -493,16 +463,11 @@ module Sinatra
       end
 
       def use_in_file_templates!
-        line = caller.detect do |s|
-          [
-           /lib\/sinatra.*\.rb/,
-           /\(.*\)/,
-           /rubygems\/custom_require\.rb/
-          ].all? { |x| s !~ x }
-        end
+        line = caller.detect { |s| s !~ /lib\/sinatra.*\.rb/ &&
+          s !~ /\(.*\)/ }
         file = line.sub(/:\d+.*$/, '')
         if data = ::IO.read(file).split('__END__')[1]
-          data.gsub!(/\r\n/, "\n")
+          data.gsub! /\r\n/, "\n"
           template = nil
           data.each_line do |line|
             if line =~ /^@@\s*(.*)/
@@ -514,13 +479,6 @@ module Sinatra
         end
       end
 
-      # Look up a media type by file extension in Rack's mime registry.
-      def media_type(type)
-        return type if type.nil? || type.to_s.include?('/')
-        type = ".#{type}" unless type.to_s[0] == ?.
-        Rack::Mime.mime_type(type, nil)
-      end
-
       def before(&block)
         @filters << block
       end
@@ -544,24 +502,9 @@ module Sinatra
         }
       end
 
-      def accept_mime_types(types)
-        types = [types] unless types.kind_of? Array
-        types.map!{|t| media_type(t)}
-
-        condition {
-          matching_types = (request.accept & types)
-          unless matching_types.empty?
-            response.headers['Content-Type'] = matching_types.first
-            true
-          else
-            false
-          end
-        }
-      end
-
       def get(path, opts={}, &block)
         conditions = @conditions.dup
-        route('GET', path, opts, &block)
+        route 'GET', path, opts, &block
 
         @conditions = conditions
         head(path, opts) { invoke(block) ; [] }
@@ -573,20 +516,14 @@ module Sinatra
       def head(path, opts={}, &bk); route 'HEAD', path, opts, &bk; end
 
     private
-      def route(verb, path, opts={}, &block)
+      def route(method, path, opts={}, &block)
         host_name  opts[:host]  if opts.key?(:host)
         user_agent opts[:agent] if opts.key?(:agent)
-        accept_mime_types opts[:provides] if opts.key?(:provides)
 
         pattern, keys = compile(path)
         conditions, @conditions = @conditions, []
-
-        define_method "#{verb} #{path}", &block
-        unbound_method = instance_method("#{verb} #{path}")
-        block = lambda { unbound_method.bind(self).call }
-
-        (routes[verb] ||= []).
-          push([pattern, keys, conditions, block]).last
+        (routes[method] ||= []).
+          push [pattern, keys, conditions, block]
       end
 
       def compile(path)
@@ -685,7 +622,6 @@ module Sinatra
     end
 
     set :raise_errors, true
-    set :dump_errors, false
     set :sessions, false
     set :logging, false
     set :methodoverride, false
@@ -779,7 +715,6 @@ module Sinatra
 
   class Default < Base
     set :raise_errors, false
-    set :dump_errors, true
     set :sessions, false
     set :logging, true
     set :methodoverride, true
@@ -787,27 +722,29 @@ module Sinatra
     set :run, false
     set :reload, Proc.new { app_file? && development? }
 
-    def self.reloading?
-      @reloading ||= false
-    end
+    @reloading = false
 
-    def self.configure(*envs)
-      super unless reloading?
-    end
+    class << self
+      def reloading?
+        @reloading
+      end
 
-    def self.call(env)
-      reload! if reload?
-      super
-    end
+      def configure(*envs)
+        super unless reloading?
+      end
 
-    def self.reload!
-      @reloading = true
-      superclass.send :inherited, self
-      $LOADED_FEATURES.delete("sinatra.rb")
-      ::Kernel.load app_file
-      @reloading = false
-    end
+      def call(env)
+        reload! if reload?
+        super
+      end
 
+      def reload!
+        @reloading = true
+        superclass.send :inherited, self
+        ::Kernel.load app_file
+        @reloading = false
+      end
+    end
   end
 
   class Application < Default

data/lib/sinatra/compat.rb

@@ -1,102 +1,58 @@
-# 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.
+# Deprecated. Do we still need this?
 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.
+# Deprecated. Make Rack 0.9.0 backward compatibile with 0.4.0
+# mime types
 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
+  unless defined? MIME_TYPES
+    MIME_TYPES = Hash.new {|hash,key|
+      Rack::Mime::MIME_TYPES[".#{key}"] }
   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
 
-  # The ServerError exception is deprecated. Any exception is considered an
-  # internal server error.
+  # Deprecated. Use: 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.
+    FORWARD_METHODS = Sinatra::Delegator::METHODS
 
     # 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
+    alias :stop :halt
 
     # Deprecated. Use: etag
-    def entity_tag(*args, &block)
-      sinatra_warn "The 'entity_tag' method is deprecated; use 'etag' instead."
-      etag(*args, &block)
-    end
+    alias :entity_tag :etag
 
     # 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]
@@ -104,89 +60,48 @@ module Sinatra
       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
+    def options ; self.class.options ; 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)
+      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
       end
 
       # Deprecated. Use: configure
-      def configures(*args, &block)
-        sinatra_warn "The 'configures' method is deprecated; use 'configure' instead."
-        configure(*args, &block)
-      end
+      alias :configures :configure
 
       # 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
+      alias :set_option :set
+      alias :set_options :set
 
       # 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
+      alias :env :environment
     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
@@ -197,43 +112,30 @@ 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
 
-    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
+    # Deprecated. Use: Sinatra::Application
+    alias :build_application :application
 
-    def env
-      sinatra_warn "Sinatra.env is deprecated; use Sinatra::Application.environment instead."
-      options.environment
-    end
+    # Deprecated.
+    def options ; Sinatra::Application.options ; end
+    def port ; options.port ; end
+    def host ; options.host ; end
+    def env ; options.environment  ; end
   end
 end