bmizerany-sinatra 0.9.0.4 → 0.9.0.5

data/AUTHORS

@@ -1,7 +1,7 @@
 Sinatra was designed and developed by Blake Mizerany (bmizerany) in
 California. Continued development would not be possible without the ongoing
 financial support provided by [Heroku](http://heroku.com) and the emotional
-support provided by Adam Wiggins (adamwiggins), Chris Wanstrath (defunkt),
+support provided by Adam Wiggins (adamwiggins) of Heroku, Chris Wanstrath (defunkt),
 PJ Hyett (pjhyett), and the rest of the GitHub crew.
 
 Special thanks to the following extraordinary individuals, who-out which

data/CHANGES

@@ -1,3 +1,47 @@
+= 0.9.1 / unreleased
+
+ * Sinatra now runs under Ruby 1.9.1 [#61]
+ * Route patterns (splats, :named, or Regexp captures) are now
+   passed as arguments to the block. [#140]
+ * The "helpers" method now takes a variable number of modules
+   along with the normal block syntax. [#133]
+ * New simple API for extensions/plugins to add DSL-level and
+   request-level methods. Use Sinatra.register(mixin) to extend
+   the DSL with all public methods defined in the mixin module;
+   use Sinatra.helpers(mixin) to make all public methods defined
+   in the mixin module available at the request level. [#138]
+ * Added "redirect back" to redirect to the referring URL.
+ * Added a new "clean_trace" option that causes backtraces dumped
+   to rack.errors and displayed on the development error page to
+   omit framework and core library backtrace lines. The option is
+   enabled by default. [#77]
+ * Fix :provides causing crash on any request when request has no
+   Accept header [#139]
+ * Fix that ERB templates were evaluated twice per "erb" call.
+
+= 0.9.0.4 / 2009-01-25
+
+ * Using halt with more than 1 args causes ArgumentError [#131]
+ * using halt in a before filter doesn't modify response [#127]
+ * Add deprecated Sinatra::EventContext to unbreak plugins [#130]
+ * Give access to GET/POST params in filters [#129]
+ * Preserve non-nested params in nested params hash [#117]
+ * Fix backtrace dump with Rack::Lint [#116]
+
+= 0.9.0.3 / 2009-01-21
+
+ * Fall back on mongrel then webrick when thin not found. [#75]
+ * Use :environment instead of :env in test helpers to
+   fix deprecation warnings coming from framework.
+ * Make sinatra/test/rspec work again [#113]
+ * Fix app_file detection on windows [#118]
+ * Fix static files with Rack::Lint in pipeline [#121]
+
+= 0.9.0.2 / 2009-01-18
+
+ * Halting a before block should stop processing of routes [#85]
+ * Fix redirect/halt in before filters [#85]
+
 = 0.9.0 / 2009-01-18
 
  * Works with and requires Rack >= 0.9.1

data/README.rdoc

@@ -50,6 +50,12 @@ Route patterns may include named parameters, accessible via the
     "Hello #{params[:name]}!"
   end
 
+You can also access named parameters via block parameters:
+
+  get '/hello/:name' do |n|
+    "Hello #{n}!"
+  end
+
 Route patterns may also include splat (or wildcard) parameters, accessible
 via the <tt>params[:splat]</tt> array.
 
@@ -69,6 +75,12 @@ Route matching with Regular Expressions:
     "Hello, #{params[:captures].first}!"
   end
 
+Or with a block parameter:
+
+  get %r{/hello/([\w]+)} do |c|
+    "Hello, #{c}!"
+  end
+
 Routes may include a variety of matching conditions, such as the user agent:
 
   get '/foo', :agent => /Songbird (\d\.\d)[\d\/]*?/ do

data/Rakefile

@@ -2,7 +2,7 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'fileutils'
 
-task :default => :test
+task :default => [:test]
 task :spec => :test
 
 # SPECS ===============================================================
@@ -45,6 +45,7 @@ task :install => package('.gem') do
 end
 
 directory 'dist/'
+CLOBBER.include('dist')
 
 file package('.gem') => %w[dist/ sinatra.gemspec] + spec.files do |f|
   sh "gem build sinatra.gemspec"

data/compat/app_test.rb

@@ -8,8 +8,9 @@ context "Sinatra" do
 
   specify "should put all DSL methods on (main)" do
     object = Object.new
-    Sinatra::Application::FORWARD_METHODS.each do |method|
-      object.private_methods.should.include(method)
+    methods = %w[get put post head delete configure template helpers set]
+    methods.each do |method|
+      object.private_methods.map { |m| m.to_sym }.should.include(method.to_sym)
     end
   end
 

data/compat/compat_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/helper'
+
+context "Compat" do
+  setup do
+    Sinatra.application = nil
+    @app = Sinatra.application
+  end
+
+  specify "makes EventContext available" do
+    assert_same Sinatra::Default, Sinatra::EventContext
+  end
+end

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|
@@ -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,47 @@ 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) do
+      expanded = File.expand_path(file)
+      self.class_eval { set :app_file, expanded }
+      self.class_eval(File.read(expanded), expanded)
+    end
+  end
 end