sinatra 1.1.4 → 1.2.0.a

data/README.ru.rdoc

@@ -39,6 +39,10 @@ Sinatra — это предметно-ориентированный язык (D
     .. что-то удалить ..
   end
 
+  options '/' do
+    .. что-то ответить ..
+  end
+
 Маршруты сверяются с запросом по очередности определения. Первый же совпавший с запросом маршрут и будет вызван.
 
 Шаблоны маршрутов могут включать в себя параметры доступные в
@@ -90,7 +94,7 @@ Sinatra — это предметно-ориентированный язык (D
   end
 
   get '/foo' do
-    # соответствует non-songbird браузерам
+    # соответствует с non-songbird браузерам
   end
 
 Другими доступными условиями являются +host_name+ и +provides+:
@@ -122,7 +126,7 @@ Sinatra — это предметно-ориентированный язык (D
 === Возвращаемые значения
 
 Возвращаемое значение блока маршрута ограничивается телом ответа, которое будет передано HTTP клиенту,
-или следующей "прослойкой" (middleware, промежуточная программа) в Rack стеке. Чаще всего это строка, как в вышеизложенных примерах.
+или следующей подпрограммой (middleware) в Rack стеке. Чаще всего это строка, как в вышеизложенных примерах.
 Но и другие значения также приемлемы.
 
 Вы можете вернуть любой объект, который будет либо корректным Rack ответом, Rack
@@ -334,31 +338,16 @@ rdiscount gem/библиотека необходима для рендерин
 Отрисует <tt>./views/index.markdown</tt> (+md+ и +mkd+ также являются допустимыми файловыми
 расширениями).
 
-В Markdown невозможно вызывать методы или передавать локальные переменные.
-Следовательно, вам скорее всего придется использовать этот шаблон совместно с другим
-движком рендеринга:
+В markdown невозможно вызывать методы или передавать локальные переменные. Следовательно, вам скорее всего придется 
+использовать этот шаблон совместно с другим движком рендеринга:
 
   erb :overview, :locals => { :text => markdown(:introduction) }
 
-Заметьте, что вы можете вызывать метод +markdown+ из других шаблонов:
+Заметьте, что вы можете вызывать метод markdown из других шаблонов:
 
   %h1 Hello From Haml!
   %p= markdown(:greetings)
 
-Также возможно обрабатывать Markdown с помощью BlueCloth, а не RDiscount:
-
-  require 'bluecloth'
-
-  Tilt.register 'markdown', BlueClothTemplate
-  Tilt.register 'mkd',      BlueClothTemplate
-  Tilt.register 'md',       BlueClothTemplate
-
-  get '/' do
-    markdown :index
-  end
-
-Отрисует <tt>./views/index.md</tt> с помощью BlueCloth.
-
 === Textile шаблоны
 
 RedCloth gem/библиотека необходима для рендеринга Textile шаблонов:
@@ -436,6 +425,26 @@ markaby gem/библиотека необходима для рендеринг
 
 Отрисует <tt>./views/index.mab</tt>.
 
+Если у вас установлен Tilt версии 1.2 или выше, то вы также можете использовать внутристроковые
+markaby шаблоны:
+
+  get '/' do
+    markaby { h1 "Welcome!" }
+  end
+
+=== Slim шаблоны
+
+slim gem/библиотека необходима для рендеринга slim шаблонов:
+
+  ## Вам нужно будет подключить slim в приложении
+  require 'slim'
+
+  get '/' do
+    slim :index
+  end
+
+Отрисует <tt>./views/index.slim</tt>.
+
 === CoffeeScript шаблоны
 
 coffee-script gem/библиотека и `coffee` бинарный файл необходимы для рендеринга CoffeeScript шаблонов:
@@ -449,13 +458,13 @@ coffee-script gem/библиотека и `coffee` бинарный файл н
 
 Отрисует <tt>./views/application.coffee</tt>.
 
-=== Встроенные шаблоны
+=== Внутристроковые шаблоны
 
   get '/' do
     haml '%div.title Hello World'
   end
 
-Отрисует встроенный (строчный) шаблон.
+Отрисует внутристроковый шаблон.
 
 === Доступ к переменным в шаблонах
 
@@ -516,8 +525,7 @@ coffee-script gem/библиотека и `coffee` бинарный файл н
   end
 
 Если шаблон с именем "layout" существует, то он будет использован каждый раз,
-когда шаблоны будут отрисовываться. Вы можете отключать layout-шаблон в каждом конкретном случае с помощью
-<tt>:layout => false</tt> или отключить его для всего приложения, например, так: <tt>set :haml, :layout => false</tt>.
+когда шаблоны будут отрисовываться. Вы можете отключить layout-шаблон с помощью <tt>:layout => false</tt>.
 
   get '/' do
     haml :index, :layout => !request.xhr?
@@ -570,6 +578,16 @@ After-фильтры выполняются после каждого запро
     session[:last_slug] = slug
   end
 
+Как и маршруты, фильтры могут использовать условия:
+
+  before :agent => /Songbird/ do
+    # ...
+  end
+
+  after '/blog/*', :host_name => 'example.com' do
+    # ...
+  end
+
 == Прерывание
 
 Чтобы незамедлительно прервать обработку запроса внутри фильтра или маршрута, используйте:
@@ -745,15 +763,15 @@ Sinatra устанавливает специальные <tt>not_found</tt> и
 
   content_type :foo
 
-== Rack "прослойки"
+== Rack подпрограммы
 
 Sinatra использует Rack[http://rack.rubyforge.org/], минимальный стандартный 
 интерфейс для веб-фреймворков на Ruby. Одной из самых интересных для разработчиков возможностей Rack
-является поддержка "прослоек" ("middleware") — компонентов,
+является поддержка подпрограмм ("middleware") -- компонентов,
 "сидящих" между сервером и вашим приложением, которые отслеживают и/или манипулируют
 HTTP запросами/ответами для предоставления различной функциональности.
 
-В Sinatra очень просто использовать такие "прослойки" с помощью метода +use+:
+В Sinatra очень просто использовать такие Rack подпрограммы с помощью метода +use+:
 
   require 'sinatra'
   require 'my_custom_middleware'
@@ -774,7 +792,7 @@ Rack::Builder[http://rack.rubyforge.org/doc/classes/Rack/Builder.html] DSL
     username == 'admin' && password == 'secret'
   end
 
-Rack распространяется с различными стандартными "прослойками"
+Rack распространяется с различными стандартными подпрограммами
 для логирования, отладки, маршрутизации URL, аутентификации, обработки сессий. Sinatra использует
 многие из этих компонентов автоматически, основываясь на конфигурации, чтобы вам не приходилось
 регистрировать/использовать (+use+) их вручную.
@@ -814,12 +832,13 @@ Rack распространяется с различными стандартн
 Заметьте: Встроенные модули Sinatra::Test и Sinatra::TestHarness являются
 устаревшими, начиная с 0.9.2 релиза.
 
-== Sinatra::Base — "прослойки", библиотеки и модульные приложения
+== Sinatra::Base - Подпрограммы, библиотеки и модульные приложения
 
 Описание своего приложения самым простейшим способом (с помощью DSL верхнего уровня, как в примерах выше)
-работает отлично для крохотных приложений, но имеет множество недостатков, когда надо создать компоненты, такие как
-Rack middleware ("прослойки"), Rails metal, простые библиотеки с серверными компонентами,
-расширения Sinatra.
+работает отлично для крохотных приложений, но имеет множество недостатков, когда надо
+создать компоненты, такие как Rack
+middleware, Rails metal, простые библиотеки с серверными компонентами,
+Sinatra расширения.
 DSL верхнего уровня загрязняет пространство имен <tt>Object</tt> и подразумевает стиль конфигурации
 микро-приложения (например, единый файл приложения, ./public и
 ./views директории, создание логов, страницу деталей об исключениях 
@@ -836,6 +855,13 @@ DSL верхнего уровня загрязняет пространство
     end
   end
 
+MyApp класс является независимым Rack компонентом, который может исполнять роли
+Rack подпрограммы, Rack приложения, Rails metal. Вы можете +use+ (использовать) или
++run+ (запустить) этот класс из rackup файла +config.ru+; или контролировать серверную
+часть из библиотеки:
+
+   MyApp.run! :host => 'localhost', :port => 9090
+
 Методы, доступные Sinatra::Base сабклассам идентичны тем, что доступны
 в DSL верхнего уровня. Большинство приложений верхнего уровня могут быть
 конвертированы в Sinatra::Base компоненты с помощью двух модификаций:
@@ -848,68 +874,10 @@ DSL верхнего уровня загрязняет пространство
 Смотрите {Опции и Конфигурация}[http://www.sinatrarb.com/configuration.html] для детальной информации
 об опциях и их поведении.
 
-=== Запуск модульных приложений
-
-Есть два общепринятых способа запускать модульные приложения: запуск напрямую с помощью <tt>run!</tt>:
-
-  # my_app.rb
-  require 'sinatra/base'
-
-  class MyApp < Sinatra::Base
-    # ... здесь код приложения ...
-
-    # запускаем сервер, если исполняется текущий файл
-    run! if app_file == $0
-  end
-
-И запускаем с помощью:
-
-  ruby my_app.rb
-
-Или с помощью конфигурационного файла <tt>config.ru</tt>, который позволяет использовать любой
-Rack-совместимый сервер приложений.
-
-  # config.ru
-  require 'my_app'
-  run MyApp
-
-Запускаем:
-
-  rackup -p 4567
-
-=== Запуск "классических" приложений с config.ru
-
-Файл приложения:
-
-  # app.rb
-  require 'sinatra'
-
-  get '/' do
-    'Hello world!'
-  end
-
-И соответствующий <tt>config.ru</tt>:
-
-  require 'app'
-  run Sinatra::Application
-
-=== Когда использовать config.ru?
-
-Вот несколько причин, по которым вы, возможно, захотите использовать <tt>config.ru</tt>:
-
-* вы хотите разворачивать свое приложение на различных Rack-совместимых серверах (Passenger, Unicorn,
-  Heroku, ...).
-* вы хотите использовать более одного сабкласса <tt>Sinatra::Base</tt>.
-* вы хотите использовать Sinatra только в качестве "прослойки" Rack.
-
-<b>Совсем необязательно переходить на использование <tt>config.ru</tt> лишь потому, что вы стали
-использовать модульный стиль приложения. И необязательно использовать модульный стиль, чтобы
-запускать приложение с помощью <tt>config.ru</tt>.</b>
-
-=== Использование Sinatra в качестве "прослойки"
+=== Использование Sinatra как подпрограммы
 
-Не только сама Sinatra может использовать "прослойки" Rack, но и любое Sinatra приложение
-само может быть добавлено к любому Rack эндпоинту в качестве "прослойки". Этим эндпоинтом
+Не только сама Sinatra может использовать подпрограммы Rack, любое Sinatra приложение
+само может быть добавлено к любому Rack эндпоинту в качестве подпрограммы. Этим эндпоинтом
 может быть другое Sinatra приложение, или приложение, основанное на Rack (Rails/Ramaze/Camping/...).
 
   require 'sinatra/base'
@@ -929,7 +897,7 @@ Rack-совместимый сервер приложений.
   end
   
   class MyApp < Sinatra::Base
-    # "прослойка" будет запущена перед фильтрами
+    # подпрограмма будет запущена перед фильтрами
     use LoginScreen
     
     before do
@@ -1005,7 +973,7 @@ Sinatra::Application, иначе это будет сабкласс, котор
 
 У вас будет область видимости запроса внутри:
 
-* get/head/post/put/delete блоков
+* get/head/post/put/delete/options блоков
 * before/after фильтрах
 * методах помощниках 
 * шаблонах/видах

data/README.zh.rdoc

@@ -420,6 +420,19 @@ Rack body对象或者HTTP状态码：
 
 渲染 <tt>./views/index.mab</tt>。
 
+=== Slim 模板 
+
+需要引入 slim gem/library 来渲染 Slim 模板：
+
+  ## 需要在你的应用中引入 slim
+  require 'slim'
+
+  get '/' do
+    slim :index
+  end
+
+渲染 <tt>./views/index.slim</tt>。
+
 === CoffeeScript 模板
 
 需要引入 coffee-script gem/library 并在路径中存在 `coffee` 二进制文件以渲染

data/Rakefile

@@ -6,48 +6,45 @@ require 'date'
 task :default => :test
 task :spec => :test
 
-CLEAN.include "**/*.rbc"
-
 def source_version
-  @source_version ||= begin
-    line = File.read('lib/sinatra/base.rb')[/^\s*VERSION = .*/]
-    line.match(/.*VERSION = '(.*)'/)[1]
-  end
-end
-
-def prev_feature
-  source_version.gsub(/^(\d\.)(\d+)\..*$/) { $1 + ($2.to_i - 1).to_s }
-end
-
-def prev_version
-  return prev_feature + '.0' if source_version.end_with? '.0'
-  source_version.gsub(/\d+$/) { |s| s.to_i - 1 }
+  line = File.read('lib/sinatra/base.rb')[/^\s*VERSION = .*/]
+  line.match(/.*VERSION = '(.*)'/)[1]
 end
 
 # SPECS ===============================================================
-
 task :test do
   ENV['LANG'] = 'C'
   ENV.delete 'LC_CTYPE'
 end
 
-Rake::TestTask.new(:test) do |t|
-  t.test_files = FileList['test/*_test.rb']
-  t.ruby_opts = ['-rubygems'] if defined? Gem
-  t.ruby_opts << '-I.'
+if !ENV['NO_TEST_FIX'] and RUBY_VERSION == '1.9.2' and RUBY_PATCHLEVEL == 0
+  # Avoids seg fault
+  task(:test) do
+    second_run  = %w[settings rdoc markaby templates static textile].map { |l| "test/#{l}_test.rb" }
+    first_run   = Dir.glob('test/*_test.rb') - second_run
+    [first_run, second_run].each { |f| sh "testrb #{f.join ' '}" }
+  end
+else
+  Rake::TestTask.new(:test) do |t|
+    t.test_files = FileList['test/*_test.rb']
+    t.ruby_opts = ['-rubygems'] if defined? Gem
+    t.ruby_opts << '-I.'
+  end
 end
 
 # Rcov ================================================================
-
 namespace :test do
   desc 'Mesures test coverage'
   task :coverage do
     rm_f "coverage"
-    sh "rcov -Ilib test/*_test.rb"
+    rcov = "rcov --text-summary -Ilib"
+    system("#{rcov} --no-html --no-color test/*_test.rb")
   end
 end
 
 # Website =============================================================
+# Building docs requires HAML and the hanna gem:
+#   gem install mislav-hanna --source=http://gems.github.com
 
 desc 'Generate RDoc under doc/api'
 task 'doc'     => ['doc:api']
@@ -55,7 +52,6 @@ task('doc:api') { sh "yardoc -o doc/api" }
 CLEAN.include 'doc/api'
 
 # README ===============================================================
-
 task :add_template, [:name] do |t, args|
   Dir.glob('README.*') do |file|
     code = File.read(file)
@@ -75,36 +71,6 @@ task :add_template, [:name] do |t, args|
   end
 end
 
-# Thanks in announcement ===============================================
-
-team = ["Ryan Tomayko", "Blake Mizerany", "Simon Rozet", "Konstantin Haase"]
-desc "list of contributors"
-task :thanks, [:release,:backports] do |t, a|
-  a.with_defaults :release => "#{prev_version}..HEAD",
-    :backports => "#{prev_feature}.0..#{prev_feature}.x"
-  included = `git log --format=format:"%aN\t%s" #{a.release}`.lines.to_a
-  excluded = `git log --format=format:"%aN\t%s" #{a.backports}`.lines.to_a
-  commits  = (included - excluded).group_by { |c| c[/^[^\t]+/] }
-  authors  = commits.keys.sort_by { |n| - commits[n].size } - team
-  puts authors[0..-2].join(', ') << " and " << authors.last,
-    "(based on commits included in #{a.release}, but not in #{a.backports})"
-end
-
-task :authors, [:format, :sep] do |t, a|
-  a.with_defaults :format => "%s (%d)", :sep => ', '
-  authors = Hash.new { |h,k| h[k] = 0 }
-  blake   = "Blake Mizerany"
-  mapping = {
-    "blake.mizerany@gmail.com" => blake, "bmizerany" => blake,
-    "a_user@mac.com" => blake, "ichverstehe" => "Harry Vangberg",
-    "Wu Jiang (nouse)" => "Wu Jiang" }
-  `git shortlog -s`.lines.map do |line|
-    num, name = line.split("\t", 2).map(&:strip)
-    authors[mapping[name] || name] += num.to_i
-  end
-  puts authors.sort_by { |n,c| -c }.map { |e| a.format % e }.join(a.sep)
-end
-
 # PACKAGING ============================================================
 
 if defined?(Gem)
@@ -169,8 +135,8 @@ if defined?(Gem)
     sh <<-SH
       gem install #{package('.gem')} --local &&
       gem push #{package('.gem')}  &&
-      git commit --allow-empty -a -m '#{source_version} release'  &&
-      git tag -s v#{source_version} -m '#{source_version} release'  &&
+      git add sinatra.gemspec &&
+      git commit --allow-empty -m '#{source_version} release'  &&
       git tag -s #{source_version} -m '#{source_version} release'  &&
       git push && (git push sinatra || true) &&
       git push --tags && (git push sinatra --tags || true)

data/lib/sinatra/base.rb

@@ -7,7 +7,7 @@ require 'sinatra/showexceptions'
 require 'tilt'
 
 module Sinatra
-  VERSION = '1.1.4'
+  VERSION = '1.2.0.a'
 
   # The request object. See Rack::Request for more info:
   # http://rack.rubyforge.org/doc/classes/Rack/Request.html
@@ -164,7 +164,7 @@ module Sinatra
     # Use the contents of the file at +path+ as the response body.
     def send_file(path, opts={})
       stat = File.stat(path)
-      last_modified stat.mtime
+      last_modified(opts[:last_modified] || stat.mtime)
 
       if opts[:type] or not response['Content-Type']
         content_type opts[:type] || File.extname(path), :default => 'application/octet-stream'
@@ -324,17 +324,10 @@ module Sinatra
     # with a '304 Not Modified' response.
     def last_modified(time)
       return unless time
-      if time.respond_to?(:to_time)
-          time = time.to_time
-      else
-          ## make a best effort to convert something else to a time object
-          ## if this fails, this should throw an ArgumentError, then the
-          # rescue will result in an http 200, which should be safe
-          time = Time.parse(time.to_s)
-      end
-      response['Last-Modified'] = time.httpdate
-      # compare based on seconds since epoch
-      halt 304 if Time.httpdate(request.env['HTTP_IF_MODIFIED_SINCE']).to_i >= time.to_i
+      time = time.to_time if time.respond_to?(:to_time)
+      time = Time.parse time.strftime('%FT%T%:z') if time.respond_to?(:strftime)
+      response['Last-Modified'] = time.respond_to?(:httpdate) ? time.httpdate : time.to_s
+      halt 304 if Time.httpdate(request.env['HTTP_IF_MODIFIED_SINCE']) >= time
     rescue ArgumentError
     end
 
@@ -383,8 +376,6 @@ module Sinatra
       attr_accessor :content_type
     end
 
-    include Tilt::CompileSite
-
     def erb(template, options={}, locals={})
       render :erb, template, options, locals
     end
@@ -413,7 +404,8 @@ module Sinatra
     end
 
     def builder(template=nil, options={}, locals={}, &block)
-      render_xml(:builder, template, options, locals, &block)
+      options[:default_content_type] = :xml
+      render_ruby(:builder, template, options, locals, &block)
     end
 
     def liquid(template, options={}, locals={})
@@ -436,8 +428,8 @@ module Sinatra
       render :radius, template, options, locals
     end
 
-    def markaby(template, options={}, locals={})
-      render :mab, template, options, locals
+    def markaby(template=nil, options={}, locals={}, &block)
+      render_ruby(:mab, template, options, locals, &block)
     end
 
     def coffee(template, options={}, locals={})
@@ -446,14 +438,17 @@ module Sinatra
     end
 
     def nokogiri(template=nil, options={}, locals={}, &block)
-      options[:layout] = false if Tilt::VERSION <= "1.1"
-      render_xml(:nokogiri, template, options, locals, &block)
+      options[:default_content_type] = :xml
+      render_ruby(:nokogiri, template, options, locals, &block)
+    end
+
+    def slim(template, options={}, locals={})
+      render :slim, template, options, locals
     end
 
   private
     # logic shared between builder and nokogiri
-    def render_xml(engine, template, options={}, locals={}, &block)
-      options[:default_content_type] = :xml
+    def render_ruby(engine, template, options={}, locals={}, &block)
       options, template = template, nil if template.is_a?(Hash)
       template = Proc.new { block } if template.nil?
       render engine, template, options, locals
@@ -472,7 +467,8 @@ module Sinatra
       layout          = options.delete(:layout)
       eat_errors      = layout.nil?
       layout          = @default_layout if layout.nil? or layout == true
-      content_type    = options.delete(:content_type) || options.delete(:default_content_type)
+      content_type    = options.delete(:content_type)  || options.delete(:default_content_type)
+      layout_engine   = options.delete(:layout_engine) || engine
 
       # compile and render template
       layout_was      = @default_layout
@@ -484,7 +480,7 @@ module Sinatra
       # render layout
       if layout
         options = options.merge(:views => views, :layout => false, :eat_errors => eat_errors)
-        catch(:layout_missing) { output = render(engine, layout, options, locals) { output }}
+        catch(:layout_missing) { output = render(layout_engine, layout, options, locals) { output }}
       end
 
       output.extend(ContentTyped).content_type = content_type if content_type
@@ -505,12 +501,13 @@ module Sinatra
             template.new(path, line.to_i, options) { body }
           else
             found = false
+            path = ::File.join(views, "#{data}.#{engine}")
             Tilt.mappings.each do |ext, klass|
-              next unless Array(klass).include? template
-              path = ::File.join(views, "#{data}.#{ext}")
               break if found = File.exists?(path)
+              next unless klass == template
+              path = ::File.join(views, "#{data}.#{ext}")
             end
-            throw :layout_missing if eat_errors and not found
+            throw :layout_missing if eat_errors and !found
             template.new(path, 1, options)
           end
         when data.is_a?(Proc) || data.is_a?(String)
@@ -956,21 +953,22 @@ module Sinatra
       # Define a before filter; runs before all requests within the same
       # context as route handlers and may access/modify the request and
       # response.
-      def before(path = nil, &block)
-        add_filter(:before, path, &block)
+      def before(path = nil, options = {}, &block)
+        add_filter(:before, path, options, &block)
       end
 
       # Define an after filter; runs after all requests within the same
       # context as route handlers and may access/modify the request and
       # response.
-      def after(path = nil, &block)
-        add_filter(:after, path, &block)
+      def after(path = nil, options = {}, &block)
+        add_filter(:after, path, options, &block)
       end
 
       # add a filter
-      def add_filter(type, path = nil, &block)
+      def add_filter(type, path = nil, options = {}, &block)
         return filters[type] << block unless path
-        block, *arguments = compile!(type, path, block)
+        path, options = //, path if path.respond_to?(:each_pair)
+        block, *arguments = compile!(type, path, block, options)
         add_filter(type) do
           process_route(*arguments) { instance_eval(&block) }
         end
@@ -992,7 +990,7 @@ module Sinatra
       # Will set params[:agent].
       def user_agent(pattern)
         condition do
-          if request.user_agent.to_s =~ pattern
+          if request.user_agent =~ pattern
             @params[:agent] = $~[1..-1]
             true
           else
@@ -1009,7 +1007,7 @@ module Sinatra
         condition do
           matching_types = (request.accept & types)
           unless matching_types.empty?
-            content_type matching_types.first
+            response.headers['Content-Type'] = matching_types.first
             true
           else
             false
@@ -1028,18 +1026,18 @@ module Sinatra
         route('HEAD', path, opts, &block)
       end
 
-      def put(path, opts={}, &bk);    route 'PUT',    path, opts, &bk end
-      def post(path, opts={}, &bk);   route 'POST',   path, opts, &bk end
-      def delete(path, opts={}, &bk); route 'DELETE', path, opts, &bk end
-      def head(path, opts={}, &bk);   route 'HEAD',   path, opts, &bk end
+      def put(path, opts={}, &bk)     route 'PUT',     path, opts, &bk end
+      def post(path, opts={}, &bk)    route 'POST',    path, opts, &bk end
+      def delete(path, opts={}, &bk)  route 'DELETE',  path, opts, &bk end
+      def head(path, opts={}, &bk)    route 'HEAD',    path, opts, &bk end
+      def options(path, opts={}, &bk) route 'OPTIONS', path, opts, &bk end
 
     private
       def route(verb, path, options={}, &block)
         # Because of self.options.host
         host_name(options.delete(:host)) if options.key?(:host)
-        options.each { |option, args| send(option, *args) }
 
-        block, pattern, keys, conditions = compile! verb, path, block
+        block, pattern, keys, conditions = compile! verb, path, block, options
         invoke_hook(:route_added, verb, path, block)
 
         (@routes[verb] ||= []).
@@ -1050,7 +1048,8 @@ module Sinatra
         extensions.each { |e| e.send(name, *args) if e.respond_to?(name) }
       end
 
-      def compile!(verb, path, block)
+      def compile!(verb, path, block, options = {})
+        options.each_pair { |option, args| send(option, *args) }
         method_name = "#{verb} #{path}"
 
         define_method(method_name, &block)
@@ -1068,7 +1067,7 @@ module Sinatra
       def compile(path)
         keys = []
         if path.respond_to? :to_str
-          special_chars = %w{. + ( ) $}
+          special_chars = %w{. + ( )}
           pattern =
             path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
               case match
@@ -1364,7 +1363,7 @@ module Sinatra
       end
     end
 
-    delegate :get, :put, :post, :delete, :head, :template, :layout,
+    delegate :get, :put, :post, :delete, :head, :options, :template, :layout,
              :before, :after, :error, :not_found, :configure, :set, :mime_type,
              :enable, :disable, :use, :development?, :test?, :production?,
              :helpers, :settings