sinatra-sinatra 0.9.0.4 → 0.9.0.5

data/lib/sinatra/base.rb

@@ -1,18 +1,21 @@
+require 'thread'
 require 'time'
 require 'uri'
 require 'rack'
 require 'rack/builder'
 
 module Sinatra
-  VERSION = '0.9.0.2'
+  VERSION = '0.9.0.5'
 
+  # The request object. See Rack::Request for more info:
+  # http://rack.rubyforge.org/doc/classes/Rack/Request.html
   class Request < Rack::Request
     def user_agent
       @env['HTTP_USER_AGENT']
     end
 
     def accept
-      @env['HTTP_ACCEPT'].split(',').map { |a| a.strip }
+      @env['HTTP_ACCEPT'].to_s.split(',').map { |a| a.strip }
     end
 
     # Override Rack 0.9.x's #params implementation (see #72 in lighthouse)
@@ -23,6 +26,10 @@ module Sinatra
     end
   end
 
+  # The response object. See Rack::Response and Rack::ResponseHelpers for
+  # more info:
+  # http://rack.rubyforge.org/doc/classes/Rack/Response.html
+  # http://rack.rubyforge.org/doc/classes/Rack/Response/Helpers.html
   class Response < Rack::Response
     def initialize
       @status, @body = 200, []
@@ -44,17 +51,18 @@ module Sinatra
         body = [body] if body.respond_to? :to_str
         if header["Content-Length"].nil? && body.respond_to?(:to_ary)
           header["Content-Length"] = body.to_ary.
-            inject(0) { |len, part| len + part.length }.to_s
+            inject(0) { |len, part| len + part.bytesize }.to_s
         end
         [status.to_i, header.to_hash, body]
       end
     end
   end
 
-  class NotFound < NameError # :)
+  class NotFound < NameError #:nodoc:
     def code ; 404 ; end
   end
 
+  # Methods available to routes, before filters, and views.
   module Helpers
     # Set or retrieve the response status code.
     def status(value=nil)
@@ -82,7 +90,7 @@ module Sinatra
 
     # Halt processing and return the error status provided.
     def error(code, body=nil)
-      code, body = 500, code.to_str if code.respond_to? :to_str
+      code, body    = 500, code.to_str if code.respond_to? :to_str
       response.body = body unless body.nil?
       halt code
     end
@@ -194,11 +202,42 @@ module Sinatra
         halt 304 if etags.include?(value) || etags.include?('*')
       end
     end
+
+    ## Sugar for redirect (example:  redirect back)
+    def back ; request.referer ; end
+
   end
 
+  # Template rendering methods. Each method takes a the name of a template
+  # to render as a Symbol and returns a String with the rendered output.
   module Templates
-    def render(engine, template, options={})
-      data = lookup_template(engine, template, options)
+    def erb(template, options={})
+      require 'erb' unless defined? ::ERB
+      render :erb, template, options
+    end
+
+    def haml(template, options={})
+      require 'haml' unless defined? ::Haml
+      options[:options] ||= self.class.haml if self.class.respond_to? :haml
+      render :haml, template, options
+    end
+
+    def sass(template, options={}, &block)
+      require 'sass' unless defined? ::Sass
+      options[:layout] = false
+      render :sass, template, options
+    end
+
+    def builder(template=nil, options={}, &block)
+      require 'builder' unless defined? ::Builder
+      options, template = template, nil if template.is_a?(Hash)
+      template = lambda { block } if template.nil?
+      render :builder, template, options
+    end
+
+  private
+    def render(engine, template, options={}) #:nodoc:
+      data   = lookup_template(engine, template, options)
       output = __send__("render_#{engine}", template, data, options)
       layout, data = lookup_layout(engine, options)
       if layout
@@ -229,7 +268,7 @@ module Sinatra
       return if options[:layout] == false
       options.delete(:layout) if options[:layout] == true
       template = options[:layout] || :layout
-      data = lookup_template(engine, template, options)
+      data     = lookup_template(engine, template, options)
       [template, data]
     rescue Errno::ENOENT
       nil
@@ -241,11 +280,6 @@ module Sinatra
       "#{views_dir}/#{template}.#{engine}"
     end
 
-    def erb(template, options={})
-      require 'erb' unless defined? ::ERB
-      render :erb, template, options
-    end
-
     def render_erb(template, data, options, &block)
       data = data.call if data.kind_of? Proc
       instance = ::ERB.new(data)
@@ -253,13 +287,6 @@ module Sinatra
       locals_assigns = locals.to_a.collect { |k,v| "#{k} = locals[:#{k}]" }
       src = "#{locals_assigns.join("\n")}\n#{instance.src}"
       eval src, binding, '(__ERB__)', locals_assigns.length + 1
-      instance.result(binding)
-    end
-
-    def haml(template, options={})
-      require 'haml' unless defined? ::Haml
-      options[:options] ||= self.class.haml if self.class.respond_to? :haml
-      render :haml, template, options
     end
 
     def render_haml(template, data, options, &block)
@@ -267,24 +294,11 @@ module Sinatra
       engine.render(self, options[:locals] || {}, &block)
     end
 
-    def sass(template, options={}, &block)
-      require 'sass' unless defined? ::Sass
-      options[:layout] = false
-      render :sass, template, options
-    end
-
     def render_sass(template, data, options, &block)
       engine = ::Sass::Engine.new(data, options[:sass] || {})
       engine.render
     end
 
-    def builder(template=nil, options={}, &block)
-      require 'builder' unless defined? ::Builder
-      options, template = template, nil if template.is_a?(Hash)
-      template = lambda { block } if template.nil?
-      render :builder, template, options
-    end
-
     def render_builder(template, data, options, &block)
       xml = ::Builder::XmlMarkup.new(:indent => 2)
       if data.respond_to?(:to_str)
@@ -294,9 +308,9 @@ module Sinatra
       end
       xml.target!
     end
-
   end
 
+  # Base class for all Sinatra applications and middleware.
   class Base
     include Rack::Utils
     include Helpers
@@ -309,6 +323,7 @@ module Sinatra
       yield self if block_given?
     end
 
+    # Rack call interface.
     def call(env)
       dup.call!(env)
     end
@@ -324,19 +339,24 @@ module Sinatra
       invoke { dispatch! }
       invoke { error_block!(response.status) }
 
+      # never respond with a body on HEAD requests
       @response.body = [] if @env['REQUEST_METHOD'] == 'HEAD'
+
       @response.finish
     end
 
+    # Access options defined with Base.set.
     def options
       self.class
     end
 
+    # Exit the current block and halt the response.
     def halt(*response)
       response = response.first if response.length == 1
       throw :halt, response
     end
 
+    # Pass control to the next matching route.
     def pass
       throw :pass
     end
@@ -352,7 +372,7 @@ module Sinatra
       # routes
       if routes = self.class.routes[@request.request_method]
         original_params = @params
-        path = @request.path_info
+        path            = @request.path_info
 
         routes.each do |pattern, keys, conditions, block|
           if match = pattern.match(path)
@@ -373,6 +393,7 @@ module Sinatra
                 {}
               end
             @params = original_params.merge(params)
+            @block_params = values
 
             catch(:pass) do
               conditions.each { |cond|
@@ -389,10 +410,10 @@ module Sinatra
     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
+        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
@@ -421,7 +442,7 @@ module Sinatra
             headers.each { |k, v| @response.headers[k] = v } if headers
           elsif res.length == 2
             @response.status = res.first
-            @response.body = res.last
+            @response.body   = res.last
           else
             raise TypeError, "#{res.inspect} not supported"
           end
@@ -441,21 +462,24 @@ module Sinatra
     def dispatch!
       route!
     rescue NotFound => boom
+      handle_not_found!(boom)
+    rescue ::Exception => boom
+      handle_exception!(boom)
+    end
+
+    def handle_not_found!(boom)
       @env['sinatra.error'] = boom
-      @response.status = 404
-      @response.body = ['<h1>Not Found</h1>']
+      @response.status      = 404
+      @response.body        = ['<h1>Not Found</h1>']
       error_block! boom.class, NotFound
+    end
 
-    rescue ::Exception => boom
+    def handle_exception!(boom)
       @env['sinatra.error'] = boom
 
-      if options.dump_errors?
-        backtrace = clean_backtrace(boom.backtrace)
-        msg = ["#{boom.class} - #{boom.message}:", *backtrace].join("\n ")
-        @env['rack.errors'].write(msg)
-      end
+      dump_errors!(boom) if options.dump_errors?
+      raise boom         if options.raise_errors?
 
-      raise boom if options.raise_errors?
       @response.status = 500
       error_block! boom.class, Exception
     end
@@ -472,6 +496,13 @@ module Sinatra
       nil
     end
 
+    def dump_errors!(boom)
+      backtrace = clean_backtrace(boom.backtrace)
+      msg = ["#{boom.class} - #{boom.message}:",
+        *backtrace].join("\n ")
+      @env['rack.errors'].write(msg)
+    end
+
     def clean_backtrace(trace)
       return trace unless options.clean_trace?
 
@@ -493,13 +524,14 @@ module Sinatra
       attr_accessor :routes, :filters, :conditions, :templates,
         :middleware, :errors
 
+    public
       def set(option, value=self)
         if value.kind_of?(Proc)
           metadef(option, &value)
           metadef("#{option}?") { !!__send__(option) }
           metadef("#{option}=") { |val| set(option, Proc.new{val}) }
         elsif value == self && option.respond_to?(:to_hash)
-          option.to_hash.each(&method(:set))
+          option.to_hash.each { |k,v| set(k, v) }
         elsif respond_to?("#{option}=")
           __send__ "#{option}=", value
         else
@@ -537,14 +569,10 @@ 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
-        file = line.sub(/:\d+.*$/, '')
+        ignore = [/lib\/sinatra.*\.rb/, /\(.*\)/, /rubygems\/custom_require\.rb/]
+        file = caller.
+          map  { |line| line.sub(/:\d+.*$/, '') }.
+          find { |line| ignore.all? { |pattern| line !~ pattern } }
         if data = ::IO.read(file).split('__END__')[1]
           data.gsub!(/\r\n/, "\n")
           template = nil
@@ -573,6 +601,7 @@ module Sinatra
         @conditions << block
       end
 
+   private
       def host_name(pattern)
         condition { pattern === request.host }
       end
@@ -603,6 +632,7 @@ module Sinatra
         }
       end
 
+    public
       def get(path, opts={}, &block)
         conditions = @conditions.dup
         route('GET', path, opts, &block)
@@ -627,7 +657,12 @@ module Sinatra
 
         define_method "#{verb} #{path}", &block
         unbound_method = instance_method("#{verb} #{path}")
-        block = lambda { unbound_method.bind(self).call }
+        block =
+          if block.arity != 0
+            lambda { unbound_method.bind(self).call(*@block_params) }
+          else
+            lambda { unbound_method.bind(self).call }
+          end
 
         (routes[verb] ||= []).
           push([pattern, keys, conditions, block]).last
@@ -659,11 +694,22 @@ module Sinatra
       end
 
     public
+      def helpers(*extensions, &block)
+        class_eval(&block) if block_given?
+        include *extensions
+      end
+
+      def register(*extensions, &block)
+        extensions << Module.new(&block) if block
+        extend *extensions
+      end
+
       def development? ; environment == :development ; end
       def test? ; environment == :test ; end
       def production? ; environment == :production ; end
 
       def configure(*envs, &block)
+        return if reloading?
         yield if envs.empty? || envs.include?(environment.to_sym)
       end
 
@@ -674,7 +720,7 @@ module Sinatra
 
       def run!(options={})
         set options
-        handler = detect_rack_handler
+        handler      = detect_rack_handler
         handler_name = handler.name.gsub(/.*::/, '')
         puts "== Sinatra/#{Sinatra::VERSION} has taken the stage " +
           "on #{port} for #{environment} with backup from #{handler_name}"
@@ -690,8 +736,19 @@ module Sinatra
       end
 
       def call(env)
-        construct_middleware if @callsite.nil?
-        @callsite.call(env)
+        synchronize do
+          reload! if reload?
+          construct_middleware if @callsite.nil?
+          @callsite.call(env)
+        end
+      end
+
+      def reload!
+        @reloading = true
+        superclass.send :reset!, self
+        $LOADED_FEATURES.delete("sinatra.rb")
+        ::Kernel.load app_file
+        @reloading = false
       end
 
     private
@@ -720,17 +777,34 @@ module Sinatra
         @callsite = nil
       end
 
-      def inherited(subclass)
-        subclass.routes = dupe_routes
-        subclass.templates = templates.dup
+      def reset!(subclass = self)
+        subclass.routes     = dupe_routes
+        subclass.templates  = templates.dup
         subclass.conditions = []
-        subclass.filters = filters.dup
-        subclass.errors = errors.dup
+        subclass.filters    = filters.dup
+        subclass.errors     = errors.dup
         subclass.middleware = middleware.dup
         subclass.send :reset_middleware
+      end
+
+      def inherited(subclass)
+        reset!(subclass)
         super
       end
 
+      def reloading?
+        @reloading ||= false
+      end
+
+      @@mutex = Mutex.new
+      def synchronize(&block)
+        if lock?
+          @@mutex.synchronize(&block)
+        else
+          yield
+        end
+      end
+
       def dupe_routes
         routes.inject({}) do |hash,(request_method,routes)|
           hash[request_method] = routes.dup
@@ -762,6 +836,8 @@ module Sinatra
     set :root, Proc.new { app_file && File.expand_path(File.dirname(app_file)) }
     set :views, Proc.new { root && File.join(root, 'views') }
     set :public, Proc.new { root && File.join(root, 'public') }
+    set :reload, Proc.new { app_file? && app_file !~ /\.ru$/i && development? }
+    set :lock, Proc.new { reload? }
 
     # static files route
     get(/.*[^\/]$/) do
@@ -838,6 +914,7 @@ module Sinatra
     end
   end
 
+  # Base class for classic style (top-level) applications.
   class Default < Base
     set :raise_errors, false
     set :dump_errors, true
@@ -846,61 +923,35 @@ module Sinatra
     set :methodoverride, true
     set :static, true
     set :run, false
-    set :reload, Proc.new { app_file? && app_file !~ /\.ru$/i && development? }
-    set :lock, Proc.new { reload? }
-
-    def self.reloading?
-      @reloading ||= false
-    end
-
-    def self.configure(*envs)
-      super unless reloading?
-    end
-
-    def self.call(env)
-      synchronize do
-        reload! if reload?
-        super
-      end
-    end
-
-    def self.reload!
-      @reloading = true
-      superclass.send :inherited, self
-      $LOADED_FEATURES.delete("sinatra.rb")
-      ::Kernel.load app_file
-      @reloading = false
-    end
 
-  private
-    @@mutex = Mutex.new
-    def self.synchronize(&block)
-      if lock?
-        @@mutex.synchronize(&block)
-      else
-        yield
-      end
+    def self.register(*extensions, &block) #:nodoc:
+      added_methods = extensions.map {|m| m.public_instance_methods }.flatten
+      Delegator.delegate *added_methods
+      super(*extensions, &block)
     end
   end
 
+  # The top-level Application. All DSL methods executed on main are delegated
+  # to this class.
   class Application < Default
   end
 
-  module Delegator
-    METHODS = %w[
-      get put post delete head template layout before error not_found
-      configures configure set set_option set_options enable disable use
-      development? test? production? use_in_file_templates!
-    ]
-
-    METHODS.each do |method_name|
-      eval <<-RUBY, binding, '(__DELEGATE__)', 1
-        def #{method_name}(*args, &b)
-          ::Sinatra::Application.#{method_name}(*args, &b)
-        end
-        private :#{method_name}
-      RUBY
+  module Delegator #:nodoc:
+    def self.delegate(*methods)
+      methods.each do |method_name|
+        eval <<-RUBY, binding, '(__DELEGATE__)', 1
+          def #{method_name}(*args, &b)
+            ::Sinatra::Application.#{method_name}(*args, &b)
+          end
+          private :#{method_name}
+        RUBY
+      end
     end
+
+    delegate :get, :put, :post, :delete, :head, :template, :layout, :before,
+             :error, :not_found, :configures, :configure, :set, :set_option,
+             :set_options, :enable, :disable, :use, :development?, :test?,
+             :production?, :use_in_file_templates!, :helpers
   end
 
   def self.new(base=Base, options={}, &block)
@@ -908,4 +959,45 @@ module Sinatra
     base.send :class_eval, &block if block_given?
     base
   end
+
+  # Extend the top-level DSL with the modules provided.
+  def self.register(*extensions, &block)
+    Default.register(*extensions, &block)
+  end
+
+  # Include the helper modules provided in Sinatra's request context.
+  def self.helpers(*extensions, &block)
+    Default.helpers(*extensions, &block)
+  end
+end
+
+class String #:nodoc:
+  # Define String#each under 1.9 for Rack compatibility. This should be
+  # removed once Rack is fully 1.9 compatible.
+  alias_method :each, :each_line  unless ''.respond_to? :each
+
+  # Define String#bytesize as an alias to String#length for Ruby 1.8.6 and
+  # earlier.
+  alias_method :bytesize, :length unless ''.respond_to? :bytesize
+end
+
+class Rack::Builder
+  ## Sugar to include a classic style app in a rackup.
+  ##
+  ## This will eval the source into a Sinatra::Default class
+  ## Example:
+  ##
+  ## require 'sinatra/base'
+  ##
+  ## map '/foo' do
+  ##    run Sinatra("foo.rb")
+  ## end
+  ##
+  ## run Sinatra("bar.rb")
+  ##
+  def Sinatra(file, base=Sinatra::Default)
+    Sinatra.new(base) {
+      expanded = File.expand_path(file)
+      self.class_eval(File.read(expanded), expanded) }
+  end
 end

data/lib/sinatra/compat.rb

@@ -9,7 +9,7 @@ require 'sinatra/base'
 require 'sinatra/main'
 
 # Like Kernel#warn but outputs the location that triggered the warning.
-def sinatra_warn(*message)
+def sinatra_warn(*message) #:nodoc:
   line = caller.
     detect { |line| line !~ /(?:lib\/sinatra\/|__DELEGATE__)/ }.
     sub(/:in .*/, '')
@@ -34,25 +34,27 @@ end
 # 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
+module Rack #:nodoc:
+  class File #:nodoc:
+    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
 end
 
 module Sinatra
-  module Compat
+  module Compat #:nodoc:
   end
 
   # Make Sinatra::EventContext an alias for Sinatra::Default to unbreak plugins.
-  def self.const_missing(const_name)
+  def self.const_missing(const_name) #:nodoc:
     if const_name == :EventContext
       const_set :EventContext, Sinatra::Default
       sinatra_warn 'Sinatra::EventContext is deprecated; use Sinatra::Default instead.'
@@ -73,7 +75,7 @@ module Sinatra
   end
 
   class Default < Base
-    def self.const_missing(const_name)
+    def self.const_missing(const_name) #:nodoc:
       if const_name == :FORWARD_METHODS
         sinatra_warn 'Sinatra::Application::FORWARD_METHODS is deprecated;',
           'use Sinatra::Delegator::METHODS instead.'
@@ -107,7 +109,7 @@ module Sinatra
     # 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(&block)
+    def invoke(&block) #:nodoc:
       res = super
       case
       when res.kind_of?(Symbol)
@@ -121,7 +123,7 @@ module Sinatra
       res
     end
 
-    def options
+    def options #:nodoc:
       Options.new(self.class)
     end
 
@@ -184,7 +186,7 @@ module Sinatra
     end
 
     # Deprecated. Missing messages are no longer delegated to @response.
-    def method_missing(name, *args, &b)
+    def method_missing(name, *args, &b) #:nodoc:
       if @response.respond_to?(name)
         sinatra_warn "The '#{name}' method is deprecated; use 'response.#{name}' instead."
         @response.send(name, *args, &b)

data/lib/sinatra/main.rb

@@ -2,6 +2,10 @@ require 'sinatra/base'
 
 module Sinatra
   class Default < Base
+
+    # we assume that the first file that requires 'sinatra' is the
+    # app_file. all other path related options are calculated based
+    # on this path by default.
     set :app_file, lambda {
       ignore = [
         /lib\/sinatra.*\.rb$/, # all sinatra code
@@ -32,10 +36,6 @@ 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