sinatra-sinatra 0.10.0 → 0.10.1

data/CHANGES

@@ -1,3 +1,12 @@
+= 1.0 / unreleased
+
+ * Route handlers, before filters, templates, error mappings, and
+   middleware are now resolved dynamically up the inheritance hierarchy
+   when needed instead of duplicating the superclass's version when
+   a new Sinatra::Base subclass is created. This should fix a variety
+   of issues with extensions that need to add any of these things
+   to the base class.
+
 = 0.9.2 / 2009-05-18
 
  * This version is compatible with Rack 1.0. [Rein Henrichs]

data/README.rdoc

@@ -470,6 +470,56 @@ recommended:
 NOTE: The built-in Sinatra::Test module and Sinatra::TestHarness class
 are deprecated as of the 0.9.2 release.
 
+== Sinatra::Base - Middleware, Libraries, and Modular Apps
+
+Defining your app at the top-level works well for micro-apps but has
+considerable drawbacks when building reuseable components such as Rack
+middleware, Rails metal, simple libraries with a server component, or
+even Sinatra extensions. The top-level DSL pollutes the Object namespace
+and assumes a micro-app style configuration (e.g., a single application
+file, ./public and ./views directories, logging, exception detail page,
+etc.). That's where Sinatra::Base comes into play:
+
+  require 'sinatra/base'
+
+  class MyApp < Sinatra::Base
+    set :sessions, true
+    set :foo, 'bar'
+
+    get '/' do
+      'Hello world!'
+    end
+  end
+
+The MyApp class is an independent Rack component that can act as
+Rack middleware, a Rack application, or Rails metal. You can +use+ or
++run+ this class from a rackup +config.ru+ file; or, control a server
+component shipped as a library:
+
+   MyApp.run! :host => 'localhost', :port => 9090
+
+The methods available to Sinatra::Base subclasses are exactly as those
+available via the top-level DSL. Most top-level apps can be converted to
+Sinatra::Base components with two modifications:
+
+* Your file should require +sinatra/base+  instead of +sinatra+;
+  otherwise, all of Sinatra's DSL methods are imported into the main
+  namespace.
+* Put your app's routes, error handlers, filters, and options in a subclass
+  of Sinatra::Base.
+
++Sinatra::Base+ is a blank slate. Most options are disabled by default,
+including the built-in server. See {Options and Configuration}[http://sinatra.github.com/configuration.html]
+for details on available options and their behavior.
+
+SIDEBAR: Sinatra's top-level DSL is implemented using a simple delegation
+system. The +Sinatra::Application+ class -- a special subclass of
+Sinatra::Base -- receives all :get, :put, :post, :delete, :before,
+:error, :not_found, :configure, and :set messages sent to the
+top-level. Have a look at the code for yourself: here's the
+{Sinatra::Delegator mixin}[http://github.com/sinatra/sinatra/blob/master/lib/sinatra/base.rb#L1064]
+being {included into the main namespace}[http://github.com/sinatra/sinatra/blob/master/lib/sinatra/main.rb#L25].
+
 == Command line
 
 Sinatra applications can be run directly:

data/lib/sinatra/base.rb

@@ -6,7 +6,7 @@ require 'rack/builder'
 require 'sinatra/showexceptions'
 
 module Sinatra
-  VERSION = '0.10.0'
+  VERSION = '0.10.1'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
@@ -270,23 +270,33 @@ module Sinatra
     def lookup_template(engine, template, views_dir, filename = nil, line = nil)
       case template
       when Symbol
-        if cached = self.class.templates[template]
-          lookup_template(engine, cached[:template], views_dir, cached[:filename], cached[:line])
-        else
-          path = ::File.join(views_dir, "#{template}.#{engine}")
-          [ ::File.read(path), path, 1 ]
-        end
+        load_template(engine, template, views_dir, options)
       when Proc
         filename, line = self.class.caller_locations.first if filename.nil?
-        [ template.call, filename, line.to_i ]
+        [template.call, filename, line.to_i]
       when String
         filename, line = self.class.caller_locations.first if filename.nil?
-        [ template, filename, line.to_i ]
+        [template, filename, line.to_i]
       else
         raise ArgumentError
       end
     end
 
+    def load_template(engine, template, views_dir, options={})
+      base = self.class
+      while base.respond_to?(:templates)
+        if cached = base.templates[template]
+          return lookup_template(engine, cached[:template], views_dir, cached[:filename], cached[:line])
+        else
+          base = base.superclass
+        end
+      end
+
+      # If no template exists in the cache, try loading from disk.
+      path = ::File.join(views_dir, "#{template}.#{engine}")
+      [ ::File.read(path), path, 1 ]
+    end
+
     def lookup_layout(engine, template, views_dir)
       lookup_template(engine, template, views_dir)
     rescue Errno::ENOENT
@@ -357,7 +367,7 @@ module Sinatra
       @env      = env
       @request  = Request.new(env)
       @response = Response.new
-      @params   = nil
+      @params   = indifferent_params(@request.params)
 
       invoke { dispatch! }
       invoke { error_block!(response.status) }
@@ -405,21 +415,15 @@ module Sinatra
     end
 
   private
-    # Run before filters and then locate and run a matching route.
-    def route!
-      # enable nested params in Rack < 1.0; allow indifferent access
-      @params =
-        if Rack::Utils.respond_to?(:parse_nested_query)
-          indifferent_params(@request.params)
-        else
-          nested_params(@request.params)
-        end
-
-      # before filters
-      self.class.filters.each { |block| instance_eval(&block) }
+    # Run before filters defined on the class and all superclasses.
+    def filter!(base=self.class)
+      filter!(base.superclass) if base.superclass.respond_to?(:filters)
+      base.filters.each { |block| instance_eval(&block) }
+    end
 
-      # routes
-      if routes = self.class.routes[@request.request_method]
+    # Run routes defined on the class and all superclasses.
+    def route!(base=self.class)
+      if routes = base.routes[@request.request_method]
         original_params = @params
         path            = unescape(@request.path_info)
 
@@ -451,6 +455,14 @@ module Sinatra
             end
           end
         end
+
+        @params = original_params
+      end
+
+      # Run routes defined in superclass.
+      if base.superclass.respond_to?(:routes)
+        route! base.superclass
+        return
       end
 
       route_missing
@@ -474,6 +486,19 @@ module Sinatra
       end
     end
 
+    # Attempt to serve static files from public directory. Throws :halt when
+    # a matching file is found, returns nil otherwise.
+    def static!
+      return if (public_dir = options.public).nil?
+      public_dir = File.expand_path(public_dir)
+
+      path = File.expand_path(public_dir + unescape(request.path_info))
+      return if path[0, public_dir.length] != public_dir
+      return unless File.file?(path)
+
+      send_file path, :disposition => nil
+    end
+
     # Enable string or symbol key access to the nested params hash.
     def indifferent_params(params)
       params = indifferent_hash.merge(params)
@@ -483,23 +508,6 @@ module Sinatra
       end
     end
 
-    # Recursively replace the params hash with a nested indifferent
-    # hash. Rack 1.0 has a built in implementation of this method - remove
-    # this once Rack 1.0 is required.
-    def nested_params(params)
-      return indifferent_hash.merge(params) if !params.keys.join.include?('[')
-      params.inject indifferent_hash do |res, (key,val)|
-        if key.include?('[')
-          head = key.split(/[\]\[]+/)
-          last = head.pop
-          head.inject(res){ |hash,k| hash[k] ||= indifferent_hash }[last] = val
-        else
-          res[key] = val
-        end
-        res
-      end
-    end
-
     def indifferent_hash
       Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
     end
@@ -539,6 +547,8 @@ module Sinatra
 
     # Dispatch a request with error handling.
     def dispatch!
+      filter!
+      static! if options.static? && (request.get? || request.head?)
       route!
     rescue NotFound => boom
       handle_not_found!(boom)
@@ -565,11 +575,16 @@ module Sinatra
 
     # Find an custom error block for the key(s) specified.
     def error_block!(*keys)
-      errmap = self.class.errors
       keys.each do |key|
-        if block = errmap[key]
-          res = instance_eval(&block)
-          return res
+        base = self.class
+        while base.respond_to?(:errors)
+          if block = base.errors[key]
+            # found a handler, eval and return result
+            res = instance_eval(&block)
+            return res
+          else
+            base = base.superclass
+          end
         end
       end
       nil
@@ -591,18 +606,37 @@ module Sinatra
       }.map! { |line| line.gsub(/^\.\//, '') }
     end
 
-    @routes     = {}
-    @filters    = []
-    @conditions = []
-    @templates  = {}
-    @middleware = []
-    @errors     = {}
-    @prototype  = nil
-    @extensions = []
-
     class << self
-      attr_accessor :routes, :filters, :conditions, :templates,
-        :middleware, :errors
+      attr_reader :routes, :filters, :templates, :errors
+
+      def reset!
+        @conditions = []
+        @routes     = {}
+        @filters    = []
+        @templates  = {}
+        @errors     = {}
+        @middleware = []
+        @prototype  = nil
+        @extensions = []
+      end
+
+      # Extension modules registered on this class and all superclasses.
+      def extensions
+        if superclass.respond_to?(:extensions)
+          (@extensions + superclass.extensions).uniq
+        else
+          @extensions
+        end
+      end
+
+      # Middleware used in this class and all superclasses.
+      def middleware
+        if superclass.respond_to?(:middleware)
+          superclass.middleware + @middleware
+        else
+          @middleware
+        end
+      end
 
       # Sets an option to the given value.  If the value is a proc,
       # the proc will be called every time the option is accessed.
@@ -770,7 +804,7 @@ module Sinatra
 
         invoke_hook(:route_added, verb, path, block)
 
-        (routes[verb] ||= []).
+        (@routes[verb] ||= []).
           push([pattern, keys, conditions, block]).last
       end
 
@@ -813,10 +847,6 @@ module Sinatra
         include(*extensions) if extensions.any?
       end
 
-      def extensions
-        (@extensions + (superclass.extensions rescue [])).uniq
-      end
-
       def register(*extensions, &block)
         extensions << Module.new(&block) if block_given?
         @extensions += extensions
@@ -875,8 +905,8 @@ module Sinatra
         builder.use Rack::CommonLogger    if logging?
         builder.use Rack::MethodOverride  if methodoverride?
         builder.use ShowExceptions        if show_exceptions?
+        middleware.each { |c,a,b| builder.use(c, *a, &b) }
 
-        @middleware.each { |c,a,b| builder.use(c, *a, &b) }
         builder.run super
         builder.to_app
       end
@@ -885,25 +915,6 @@ module Sinatra
         synchronize { prototype.call(env) }
       end
 
-      def reset!(base=superclass)
-        @routes     = base.dupe_routes
-        @templates  = base.templates.dup
-        @conditions = []
-        @filters    = base.filters.dup
-        @errors     = base.errors.dup
-        @middleware = base.middleware.dup
-        @prototype  = nil
-        @extensions = []
-      end
-
-    protected
-      def dupe_routes
-        routes.inject({}) do |hash,(request_method,routes)|
-          hash[request_method] = routes.dup
-          hash
-        end
-      end
-
     private
       def detect_rack_handler
         servers = Array(self.server)
@@ -918,7 +929,7 @@ module Sinatra
       end
 
       def inherited(subclass)
-        subclass.reset! self
+        subclass.reset!
         super
       end
 
@@ -942,7 +953,7 @@ module Sinatra
         /\(.*\)/,              # generated code
         /custom_require\.rb$/, # rubygems require hacks
         /active_support/,      # active_support require hacks
-      ] unless self.const_defined?('CALLERS_TO_IGNORE')
+      ]
 
       # add rubinius (and hopefully other VM impls) ignore patterns ...
       CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
@@ -961,10 +972,12 @@ module Sinatra
       end
     end
 
+    reset!
+
     set :raise_errors, true
     set :dump_errors, false
     set :clean_trace, true
-    set :show_exceptions, Proc.new { development? }
+    set :show_exceptions, false
     set :sessions, false
     set :logging, false
     set :methodoverride, false
@@ -982,16 +995,6 @@ module Sinatra
     set :public, Proc.new { root && File.join(root, 'public') }
     set :lock, false
 
-    # static files route
-    get(/.*[^\/]$/) do
-      pass unless options.static? && options.public?
-      public_dir = File.expand_path(options.public)
-      path = File.expand_path(public_dir + unescape(request.path_info))
-      pass if path[0, public_dir.length] != public_dir
-      pass unless File.file?(path)
-      send_file path, :disposition => nil
-    end
-
     error ::Exception do
       response.status = 500
       content_type 'text/html'
@@ -1035,6 +1038,7 @@ module Sinatra
   # Base class for classic style (top-level) applications.
   class Default < Base
     set :raise_errors, Proc.new { test? }
+    set :show_exceptions, Proc.new { development? }
     set :dump_errors, true
     set :sessions, false
     set :logging, Proc.new { ! test? }

data/sinatra.gemspec

@@ -3,13 +3,13 @@ Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'sinatra'
-  s.version = '0.10.0'
-  s.date = '2009-06-05'
+  s.version = '0.10.1'
+  s.date = '2009-06-07'
 
   s.description = "Classy web-development dressed in a DSL"
   s.summary     = "Classy web-development dressed in a DSL"
 
-  s.authors = ["Blake Mizerany"]
+  s.authors = ["Blake Mizerany", "Ryan Tomayko", "Simon Rozet"]
   s.email = "sinatrarb@googlegroups.com"
 
   # = MANIFEST =
@@ -71,7 +71,7 @@ Gem::Specification.new do |s|
 
   s.extra_rdoc_files = %w[README.rdoc LICENSE]
   s.add_dependency 'rack',    '>= 1.0'
-  s.add_development_dependency 'shotgun', '>= 0.2',   '< 1.0'
+  s.add_development_dependency 'shotgun', '>= 0.3',   '< 1.0'
   s.add_development_dependency 'rack-test', '>= 0.3.0'
 
   s.has_rdoc = true

data/test/filter_test.rb

@@ -96,4 +96,16 @@ class FilterTest < Test::Unit::TestCase
     assert ok?
     assert_equal 'cool', 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
 end

data/test/mapped_error_test.rb

@@ -101,6 +101,37 @@ class MappedErrorTest < Test::Unit::TestCase
       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) {
+        set :raise_errors, false
+        get '/' do
+          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) {
+        set :raise_errors, false
+        error(FooError) { 'subclass' }
+        get '/' do
+          raise FooError
+        end
+      }
+
+      get '/'
+      assert_equal 'subclass', body
+    end
   end
 
   describe 'Custom Error Pages' do

data/test/options_test.rb

@@ -183,10 +183,15 @@ class OptionsTest < Test::Unit::TestCase
   end
 
   describe 'show_exceptions' do
+    %w[development test production none].each do |environment|
+      it "is disabled on Base in #{environment} environments" do
+        @base.set(:environment, environment)
+        assert ! @base.show_exceptions?
+      end
+    end
+
     it 'is enabled on Default only in development' do
       @base.set(:environment, :development)
-      assert @base.show_exceptions?
-
       assert @default.development?
       assert @default.show_exceptions?
 

data/test/routing_test.rb

@@ -781,4 +781,39 @@ class RoutingTest < Test::Unit::TestCase
     end
 
   end
+
+  it "matches routes defined in superclasses" do
+    base = Class.new(Sinatra::Base)
+    base.get('/foo') { 'foo in baseclass' }
+
+    mock_app(base) {
+      get('/bar') { 'bar in subclass' }
+    }
+
+    get '/foo'
+    assert ok?
+    assert_equal 'foo in baseclass', body
+
+    get '/bar'
+    assert ok?
+    assert_equal 'bar in subclass', body
+  end
+
+  it "matches routes in subclasses before superclasses" do
+    base = Class.new(Sinatra::Base)
+    base.get('/foo') { 'foo in baseclass' }
+    base.get('/bar') { 'bar in baseclass' }
+
+    mock_app(base) {
+      get('/foo') { 'foo in subclass' }
+    }
+
+    get '/foo'
+    assert ok?
+    assert_equal 'foo in subclass', body
+
+    get '/bar'
+    assert ok?
+    assert_equal 'bar in baseclass', body
+  end
 end

data/test/static_test.rb

@@ -34,6 +34,13 @@ class StaticTest < Test::Unit::TestCase
     assert response.headers.include?('Last-Modified')
   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__)}"

data/test/templates_test.rb

@@ -1,8 +1,8 @@
 require File.dirname(__FILE__) + '/helper'
 
 class TemplatesTest < Test::Unit::TestCase
-  def render_app(&block)
-    mock_app {
+  def render_app(base=Sinatra::Base, &block)
+    mock_app(base) {
       def render_test(template, data, options, locals, &block)
         inner = block ? block.call : ''
         data + inner
@@ -107,6 +107,25 @@ class TemplatesTest < Test::Unit::TestCase
     assert ok?
     assert_equal 'Hello Mike!<p>content</p>', 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 'uses templates in superclasses before subclasses' do
+    base = Class.new(Sinatra::Base)
+    base.template(:foo) { 'template in superclass' }
+    render_app(base) { render :test, :foo }
+    @app.template(:foo) { 'template in subclass' }
+
+    get '/'
+    assert ok?
+    assert_equal 'template in subclass', body
+  end
 end
 
 # __END__ : this is not the real end of the script.

metadata

@@ -1,15 +1,17 @@
 --- !ruby/object:Gem::Specification 
 name: sinatra-sinatra
 version: !ruby/object:Gem::Version 
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors: 
 - Blake Mizerany
+- Ryan Tomayko
+- Simon Rozet
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2009-06-05 00:00:00 -07:00
+date: 2009-06-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +32,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: "0.2"
+        version: "0.3"
     - - <
       - !ruby/object:Gem::Version 
         version: "1.0"