sinatra 1.3.2 → 1.3.3

data/README.ru.rdoc

@@ -315,7 +315,7 @@ Thin - это более производительный и функциона
 
 === Haml шаблоны
 
-Зависимости::         {haml}[http://haml-lang.com/]
+Зависимости::         {haml}[http://haml.info/]
 Расширения файлов::   <tt>.haml</tt>
 Пример::              <tt>haml :index, :format => :html5</tt>
 

data/README.zh.rdoc

@@ -229,7 +229,7 @@ Rack body对象或者HTTP状态码：
 
 渲染 <tt>./views/index.haml</tt>。
 
-{Haml的选项}[http://haml-lang.com/docs/yardoc/file.HAML_REFERENCE.html#options]
+{Haml的选项}[http://haml.info/docs/yardoc/file.HAML_REFERENCE.html#options]
 可以通过Sinatra的配置全局设定，
 参见 {选项和配置}[http://www.sinatrarb.com/configuration.html]，
 也可以个别的被覆盖。

data/Rakefile

@@ -56,7 +56,7 @@ end
 # Rcov ================================================================
 
 namespace :test do
-  desc 'Mesures test coverage'
+  desc 'Measures test coverage'
   task :coverage do
     rm_f "coverage"
     sh "rcov -Ilib test/*_test.rb"
@@ -117,6 +117,7 @@ task :authors, [:commit_range, :format, :sep] do |t, a|
     "a_user@mac.com" => blake, "ichverstehe" => "Harry Vangberg",
     "Wu Jiang (nouse)" => "Wu Jiang" }
   `git shortlog -s #{a.commit_range}`.lines.map do |line|
+    line = line.force_encoding 'binary' if line.respond_to? :force_encoding
     num, name = line.split("\t", 2).map(&:strip)
     authors[mapping[name] || name] += num.to_i
     overall += num.to_i

data/lib/sinatra.rb

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

data/lib/sinatra/base.rb

@@ -1,7 +1,7 @@
 # external dependencies
 require 'rack'
 require 'tilt'
-require "rack/protection"
+require 'rack/protection'
 
 # stdlib dependencies
 require 'thread'
@@ -77,7 +77,9 @@ module Sinatra
         headers.delete "Content-Length"
         headers.delete "Content-Type"
       elsif Array === body and not [204, 304].include?(status.to_i)
-        headers["Content-Length"] = body.inject(0) { |l, p| l + Rack::Utils.bytesize(p) }.to_s
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers["Content-Length"] ||= body.inject(0) { |l, p| l + Rack::Utils.bytesize(p) }.to_s
       end
 
       # Rack::Response#finish sometimes returns self as response body. We don't want that.
@@ -87,6 +89,55 @@ module Sinatra
     end
   end
 
+  # Some Rack handlers (Thin, Rainbows!) implement an extended body object protocol, however,
+  # some middleware (namely Rack::Lint) will break it by not mirroring the methods in question.
+  # This middleware will detect an extended body object and will make sure it reaches the
+  # handler directly. We do this here, so our middleware and middleware set up by the app will
+  # still be able to run.
+  class ExtendedRack < Struct.new(:app)
+    def call(env)
+      result, callback = app.call(env), env['async.callback']
+      return result unless callback and async?(*result)
+      after_response { callback.call result }
+      setup_close(env, *result)
+      throw :async
+    end
+
+    private
+
+    def setup_close(env, status, header, body)
+      return unless body.respond_to? :close and env.include? 'async.close'
+      env['async.close'].callback { body.close }
+      env['async.close'].errback { body.close }
+    end
+
+    def after_response(&block)
+      raise NotImplementedError, "only supports EventMachine at the moment" unless defined? EventMachine
+      EventMachine.next_tick(&block)
+    end
+
+    def async?(status, headers, body)
+      return true if status == -1
+      body.respond_to? :callback and body.respond_to? :errback
+    end
+  end
+
+  # Behaves exactly like Rack::CommonLogger with the notable exception that it does nothing,
+  # if another CommonLogger is already in the middleware chain.
+  class CommonLogger < Rack::CommonLogger
+    def call(env)
+      env['sinatra.commonlogger'] ? @app.call(env) : super
+    end
+
+    superclass.class_eval do
+      alias call_without_check call unless method_defined? :call_without_check
+      def call(env)
+        env['sinatra.commonlogger'] = true
+        call_without_check(env)
+      end
+    end
+  end
+
   class NotFound < NameError #:nodoc:
     def code ; 404 ; end
   end
@@ -275,6 +326,7 @@ module Sinatra
       end
 
       def callback(&block)
+        return yield if @closed
         @callbacks << block
       end
 
@@ -290,16 +342,7 @@ module Sinatra
     def stream(keep_open = false)
       scheduler = env['async.callback'] ? EventMachine : Stream
       current   = @params.dup
-      block     = proc do |out|
-        begin
-          original, @params = @params, current
-          yield(out)
-        ensure
-          @params = original if original
-        end
-      end
-
-      body Stream.new(scheduler, keep_open, &block)
+      body Stream.new(scheduler, keep_open) { |out| with_params(current) { yield(out) } }
     end
 
     # Specify response freshness policy for HTTP caches (Cache-Control header).
@@ -486,6 +529,13 @@ module Sinatra
       return !new_resource if list == '*'
       list.to_s.split(/\s*,\s*/).include? response['ETag']
     end
+
+    def with_params(temp_params)
+      original, @params = @params, temp_params
+      yield
+    ensure
+      @params = original if original
+    end
   end
 
   private
@@ -814,7 +864,7 @@ module Sinatra
 
       if values.any?
         original, @params = params, params.merge('splat' => [], 'captures' => values)
-        keys.zip(values) { |k,v| (@params[k] ||= '') << v if v }
+        keys.zip(values) { |k,v| Array === @params[k] ? @params[k] << v : @params[k] = v if v }
       end
 
       catch(:pass) do
@@ -990,9 +1040,7 @@ module Sinatra
         when Proc
           getter = value
         when Symbol, Fixnum, FalseClass, TrueClass, NilClass
-          # we have a lot of enable and disable calls, let's optimize those
-          class_eval "def self.#{option}() #{value.inspect} end"
-          getter = nil
+          getter = value.inspect
         when Hash
           setter = proc do |val|
             val = value.merge val if Hash === val
@@ -1000,13 +1048,9 @@ module Sinatra
           end
         end
 
-        (class << self; self; end).class_eval do
-          define_method("#{option}=", &setter) if setter
-          define_method(option,       &getter) if getter
-          unless method_defined? "#{option}?"
-            class_eval "def #{option}?() !!#{option} end"
-          end
-        end
+        define_singleton_method("#{option}=", setter) if setter
+        define_singleton_method(option, getter) if getter
+        define_singleton_method("#{option}?", "!!#{option}") unless method_defined? "#{option}?"
         self
       end
 
@@ -1126,7 +1170,16 @@ module Sinatra
         set(:public_folder, value)
       end
 
-   private
+    private
+      # Dynamically defines a method on settings.
+      def define_singleton_method(name, content = Proc.new)
+        # replace with call to singleton_class once we're 1.9 only
+        (class << self; self; end).class_eval do
+          undef_method(name) if method_defined? name
+          String === content ? class_eval("def #{name}() #{content}; end") : define_method(name, &content)
+        end
+      end
+
       # Condition for matching host name. Parameter might be String or Regexp.
       def host_name(pattern)
         condition { pattern === request.host }
@@ -1237,9 +1290,11 @@ module Sinatra
         end
       end
 
+      URI = ::URI.const_defined?(:Parser) ? ::URI::Parser.new : ::URI
+
       def encoded(char)
-        enc = URI.encode(char)
-        enc = "(?:#{Regexp.escape enc}|#{URI.encode char, /./})" if enc == char
+        enc = URI.escape(char)
+        enc = "(?:#{Regexp.escape enc}|#{URI.escape char, /./})" if enc == char
         enc = "(?:#{enc}|#{encoded('+')})" if char == " "
         enc
       end
@@ -1302,7 +1357,7 @@ module Sinatra
           set :running, true
           yield server if block_given?
         end
-      rescue Errno::EADDRINUSE => e
+      rescue Errno::EADDRINUSE
         $stderr.puts "== Someone is already performing on port #{port}!"
       end
 
@@ -1336,6 +1391,7 @@ module Sinatra
 
     private
       def setup_default_middleware(builder)
+        builder.use ExtendedRack
         builder.use ShowExceptions       if show_exceptions?
         builder.use Rack::MethodOverride if method_override?
         builder.use Rack::Head
@@ -1362,8 +1418,7 @@ module Sinatra
       end
 
       def setup_common_logger(builder)
-        return if ["development", "deployment", nil].include? ENV["RACK_ENV"]
-        builder.use Rack::CommonLogger
+        builder.use Sinatra::CommonLogger
       end
 
       def setup_custom_logger(builder)
@@ -1379,6 +1434,7 @@ module Sinatra
         options = Hash === protection ? protection.dup : {}
         options[:except] = Array options[:except]
         options[:except] += [:session_hijacking, :remote_token] unless sessions?
+        options[:reaction] ||= :drop_session
         builder.use Rack::Protection, options
       end
 
@@ -1395,8 +1451,7 @@ module Sinatra
         servers.each do |server_name|
           begin
             return Rack::Handler.get(server_name.to_s)
-          rescue LoadError
-          rescue NameError
+          rescue LoadError, NameError
           end
         end
         fail "Server handler (#{servers.join(',')}) not found."
@@ -1429,8 +1484,11 @@ module Sinatra
         /src\/kernel\/bootstrap\/[A-Z]/                  # maglev kernel files
       ]
 
-      # add rubinius (and hopefully other VM impls) ignore patterns ...
-      CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
+      # contrary to what the comment said previously, rubinius never supported this
+      if defined?(RUBY_IGNORE_CALLERS)
+        warn "RUBY_IGNORE_CALLERS is deprecated and will no longer be supported by Sinatra 2.0"
+        CALLERS_TO_IGNORE.concat(RUBY_IGNORE_CALLERS)
+      end
 
       # Like Kernel#caller but excluding certain magic entries and without
       # line / method information; the resulting array contains filenames only.

data/lib/sinatra/version.rb

@@ -1,3 +1,3 @@
 module Sinatra
-  VERSION = '1.3.2'
+  VERSION = '1.3.3'
 end

data/sinatra.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new 'sinatra', Sinatra::VERSION do |s|
   s.files             = `git ls-files`.split("\n") - %w[.gitignore .travis.yml]
   s.test_files        = s.files.select { |p| p =~ /^test\/.*_test.rb/ }
   s.extra_rdoc_files  = s.files.select { |p| p =~ /^README/ } << 'LICENSE'
-  s.rdoc_options      = %w[--line-numbers --inline-source --title Sinatra --main README.rdoc]
+  s.rdoc_options      = %w[--line-numbers --inline-source --title Sinatra --main README.rdoc --encoding=UTF-8]
 
   s.add_dependency 'rack',            '~> 1.3', '>= 1.3.6'
   s.add_dependency 'rack-protection', '~> 1.2'

data/test/delegator_test.rb

@@ -102,7 +102,7 @@ class DelegatorTest < Test::Unit::TestCase
     assert_equal ["helpers", mixin.to_s], app.last_call
   end
 
-  it "registers helpers with the delegation target" do
+  it "registers middleware with the delegation target" do
     app, mixin = mirror, Module.new
     Sinatra.use mixin
     assert_equal ["use", mixin.to_s], app.last_call

data/test/filter_test.rb

@@ -158,11 +158,11 @@ class BeforeFilterTest < Test::Unit::TestCase
 end
 
 class AfterFilterTest < Test::Unit::TestCase
-  it "executes filters in the order defined" do
+  it "executes before and after filters in correct order" do
     invoked = 0
     mock_app do
       before   { invoked = 2 }
-      get('/') { invoked += 2 }
+      get('/') { invoked += 2; 'hello' }
       after    { invoked *= 2 }
     end
 
@@ -412,7 +412,7 @@ class AfterFilterTest < Test::Unit::TestCase
     assert ran
   end
 
-  it 'is possible to apply user_agent conditions to before filters with a path' do
+  it 'is possible to apply user_agent conditions to after filters with a path' do
     ran = false
     mock_app do
       after('/foo', :user_agent => /foo/) { ran = true }

data/test/helpers_test.rb

@@ -31,12 +31,12 @@ class HelpersTest < Test::Unit::TestCase
       assert_body 'true'
     end
 
-    it 'is false for status > 404' do
+    it 'is false for status gt 404' do
       status_app(405) { not_found? }
       assert_body 'false'
     end
 
-    it 'is false for status < 404' do
+    it 'is false for status lt 404' do
       status_app(403) { not_found? }
       assert_body 'false'
     end
@@ -616,7 +616,7 @@ class HelpersTest < Test::Unit::TestCase
       assert_equal '<sinatra></sinatra>', body   
     end
     
-    it 'sets the Content-Type response header without extname' do
+    it 'sets the Content-Type response header with extname' do
       mock_app do
         get '/attachment' do
           content_type :atom
@@ -828,12 +828,12 @@ class HelpersTest < Test::Unit::TestCase
       assert_not_nil response['Expires']
     end
 
-    it 'allows passing time objects' do
+    it 'allows passing Time.now objects' do
       get '/bar'
       assert_not_nil response['Expires']
     end
 
-    it 'allows passing time objects' do
+    it 'allows passing Time.at objects' do
       get '/baz'
       assert_equal 'Thu, 01 Jan 1970 00:00:00 GMT', response['Expires']
     end

data/test/integration/app.rb

@@ -1,6 +1,62 @@
+$stderr.puts "loading"
 require 'sinatra'
 
+configure do
+  set :foo, :bar
+end
+
 get '/app_file' do
   content_type :txt
   settings.app_file
-end
+end
+
+get '/ping' do
+  'pong'
+end
+
+get '/stream' do
+  stream do |out|
+    sleep 0.1
+    out << "a"
+    sleep 1.2
+    out << "b"
+  end
+end
+
+get '/mainonly' do
+  object = Object.new
+  begin
+    object.send(:get, '/foo') { }
+    'false'
+  rescue NameError
+    'true'
+  end
+end
+
+set :out, nil
+get '/async' do
+  stream(:keep_open) { |o| (settings.out = o) << "hi!" }
+end
+
+get '/send' do
+  settings.out << params[:msg] if params[:msg]
+  settings.out.close if params[:close]
+  "ok"
+end
+
+class Subclass < Sinatra::Base
+  set :out, nil
+  get '/subclass/async' do
+    stream(:keep_open) { |o| (settings.out = o) << "hi!" }
+  end
+
+  get '/subclass/send' do
+    settings.out << params[:msg] if params[:msg]
+    settings.out.close if params[:close]
+    "ok"
+  end
+end
+
+use Subclass
+
+$stderr.puts "starting"

data/test/integration_helper.rb

@@ -0,0 +1,214 @@
+require 'sinatra/base'
+require 'rbconfig'
+require 'open-uri'
+require 'net/http'
+require 'timeout'
+
+module IntegrationHelper
+  class BaseServer
+    extend Enumerable
+    attr_accessor :server, :port, :pipe
+    alias name server
+
+    def self.all
+      @all ||= []
+    end
+
+    def self.each(&block)
+      all.each(&block)
+    end
+
+    def self.run(server, port)
+      new(server, port).run
+    end
+
+    def app_file
+      File.expand_path('../integration/app.rb', __FILE__)
+    end
+
+    def environment
+      "development"
+    end
+
+    def initialize(server, port)
+      @installed, @pipe, @server, @port = nil, nil, server, port
+      Server.all << self
+    end
+
+    def run
+      return unless installed?
+      kill
+      @log     = ""
+      @pipe    = IO.popen(command)
+      @started = Time.now
+      warn "#{server} up and running on port #{port}" if ping
+      at_exit { kill }
+    end
+
+    def ping(timeout = 30)
+      loop do
+        return if alive?
+        if Time.now - @started > timeout
+          $stderr.puts command, log
+          fail "timeout"
+        else
+          sleep 0.1
+        end
+      end
+    end
+
+    def alive?
+      3.times { get('/ping') }
+      true
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, SystemCallError, OpenURI::HTTPError, Timeout::Error => error
+      false
+    end
+
+    def get_stream(url = "/stream", &block)
+      Net::HTTP.start '127.0.0.1', port do |http|
+        request = Net::HTTP::Get.new url
+        http.request request do |response|
+          response.read_body(&block)
+        end
+      end
+    end
+
+    def get(url)
+      Timeout.timeout(1) { open("http://127.0.0.1:#{port}#{url}").read }
+    end
+
+    def log
+      @log ||= ""
+      loop { @log <<  @pipe.read_nonblock(1) }
+    rescue Exception
+      @log
+    end
+
+    def installed?
+      return @installed unless @installed.nil?
+      require server
+      @installed = true
+    rescue LoadError
+      warn "#{server} is not installed, skipping integration tests"
+      @installed = false
+    end
+
+    def command
+      @command ||= begin
+        cmd = ["RACK_ENV=#{environment}", "exec"]
+        if RbConfig.respond_to? :ruby
+          cmd << RbConfig.ruby.inspect
+        else
+          file, dir = RbConfig::CONFIG.values_at('ruby_install_name', 'bindir')
+          cmd << File.expand_path(file, dir).inspect
+        end
+        cmd << "-w" unless thin?
+        cmd << "-I" << File.expand_path('../../lib', __FILE__).inspect
+        cmd << app_file.inspect << '-s' << server << '-o' << '127.0.0.1' << '-p' << port
+        cmd << "-e" << environment.to_s << '2>&1'
+        cmd.join " "
+      end
+    end
+
+    def kill
+      return unless pipe
+      Process.kill("KILL", pipe.pid)
+    rescue NotImplementedError
+      system "kill -9 #{pipe.pid}"
+    rescue Errno::ESRCH
+    end
+
+    def webrick?
+      name.to_s == "webrick"
+    end
+
+    def thin?
+      name.to_s == "thin"
+    end
+
+    def warnings
+      log.scan(%r[(?:\(eval|lib/sinatra).*warning:.*$])
+    end
+
+    def run_test(target, &block)
+      retries ||= 3
+      target.server = self
+      run unless alive?
+      target.instance_eval(&block)
+    rescue Exception => error
+      retries -= 1
+      kill
+      retries < 0 ? retry : raise(error)
+    end
+  end
+
+  if RUBY_ENGINE == "jruby"
+    class JRubyServer < BaseServer
+      def start_vm
+        require 'java'
+        # Create a new container, set load paths and env
+        # SINGLETHREAD means create a new runtime
+        vm = org.jruby.embed.ScriptingContainer.new(org.jruby.embed.LocalContextScope::SINGLETHREAD)
+        vm.load_paths = [File.expand_path('../../lib', __FILE__)]
+        vm.environment = ENV.merge('RACK_ENV' => environment.to_s)
+
+        # This ensures processing of RUBYOPT which activates Bundler
+        vm.provider.ruby_instance_config.process_arguments []
+        vm.argv = ['-s', server.to_s, '-o', '127.0.0.1', '-p', port.to_s, '-e', environment.to_s]
+
+        # Set stdout/stderr so we can retrieve log
+        @pipe = java.io.ByteArrayOutputStream.new
+        vm.output = java.io.PrintStream.new(@pipe)
+        vm.error  = java.io.PrintStream.new(@pipe)
+
+        Thread.new do
+          # Hack to ensure that Kernel#caller has the same info as
+          # when run from command-line, for Sintra::Application.app_file.
+          # Also, line numbers are zero-based in JRuby's parser
+          vm.provider.runtime.current_context.set_file_and_line(app_file, 0)
+          # Run the app
+          vm.run_scriptlet org.jruby.embed.PathType::ABSOLUTE, app_file
+          # terminate launches at_exit hooks which start server
+          vm.terminate
+        end
+      end
+
+      def run
+        return unless installed?
+        kill
+        @thread  = start_vm
+        @started = Time.now
+        warn "#{server} up and running on port #{port}" if ping
+        at_exit { kill }
+      end
+
+      def log
+        String.from_java_bytes @pipe.to_byte_array
+      end
+
+      def kill
+        @thread.kill if @thread
+        @thread = nil
+      end
+    end
+    Server = JRubyServer
+  else
+    Server = BaseServer
+  end
+
+  def it(message, &block)
+    Server.each do |server|
+      next unless server.installed?
+      super("with #{server.name}: #{message}") { server.run_test(self, &block) }
+    end
+  end
+
+  def self.extend_object(obj)
+    super
+
+    base_port = 5000 + Process.pid % 100
+    Sinatra::Base.server.each_with_index do |server, index|
+      Server.run(server, 5000+index)
+    end
+  end
+end