sinatra 1.4.1 → 1.4.2

data/CHANGES

@@ -1,3 +1,12 @@
+= 1.4.2 / 2013-03-21
+
+ * Fix parsing error for case where both the pattern and the captured part
+   contain a dot. (Florian Hanke, Konstantin Haase)
+
+ * Missing Accept header is treated like */*. (Greg Denton)
+
+ * Improve documentation. (Patricio Mac Adden, Joe Bottigliero)
+
 = 1.4.1 / 2013-03-15
 
  * Make delegated methods available in config.ru (Konstantin Haase)

data/README.es.md

@@ -15,7 +15,7 @@ get '/' do
 end
 ```
 
-Instalá la gem y ejecutá la aplicación con:
+Instalá el gem y corré la aplicación con:
 
 ```  shell
 gem install sinatra
@@ -58,11 +58,11 @@ options '/' do
 end
 ```
 
-Las rutas son comparadas en el orden en el que son definidas. La primer ruta
+Las rutas son comparadas en el orden en el que son definidas. La primera ruta
 que coincide con la petición es invocada.
 
 Los patrones de las rutas pueden incluir parámetros nombrados, accesibles a
-través de el hash `params`:
+través del hash `params`:
 
 ``` ruby
 get '/hola/:nombre' do
@@ -76,6 +76,9 @@ También podés acceder a los parámetros nombrados usando parámetros de bloque
 
 ``` ruby
 get '/hola/:nombre' do |n|
+  # coincide con "GET /hola/foo" y "GET /hola/bar"
+  # params[:nombre] es 'foo' o 'bar'
+  # n almacena params[:nombre]
   "Hola #{n}!"
 end
 ```
@@ -128,7 +131,7 @@ get '/posts.?:formato?' do
 end
 ```
 
-A propósito, a menos que desactivés la protección para el ataque *path
+A propósito, a menos que desactives la protección para el ataque *path
 traversal* (ver más abajo), el path de la petición puede ser modificado
 antes de que se compare con los de tus rutas.
 
@@ -201,10 +204,10 @@ end
 
 ### Valores de Retorno
 
-El valor de retorno de un bloque de ruta determina al menos el cuerpo de la
+El valor de retorno de un bloque de ruta que determina al menos el cuerpo de la
 respuesta que se le pasa al cliente HTTP o al siguiente middleware en la pila
 de Rack. Lo más común es que sea un string, como en los ejemplos anteriores.
-Sin embargo, otros valor también son aceptados.
+Sin embargo, otros valores también son aceptados.
 
 Podés devolver cualquier objeto que sea una respuesta Rack válida, un objeto
 que represente el cuerpo de una respuesta Rack o un código de estado HTTP:
@@ -377,7 +380,7 @@ Opciones disponibles:
 
   <dt>layout</dt>
   <dd>
-    Si es <tt>true</tt> o <tt>false</tt> indica que se debe usar, o nó, un layout,
+    Si es <tt>true</tt> o <tt>false</tt> indica que se debe usar, o no, un layout,
     respectivamente. También puede ser un símbolo que especifique qué plantilla
     usar. Ejemplo: <tt>erb :index, :layout => !request.xhr?</tt>
   </dd>
@@ -412,9 +415,9 @@ Opciones disponibles:
   <dd>
     Es importante acordarse que siempre tenés que referenciar a las plantillas con
     símbolos, incluso cuando se encuentran en un subdirectorio (en este caso
-    tenés que usar: <tt>'subdir/plantilla'</tt>). Tenés que usar un símbolo porque los
-    métodos de renderización van a renderizar directamente cualquier string que se
-    les pase como argumento.
+    tenés que usar: `:'subdir/plantilla'` o `'subdir/plantilla'.to_sym`). Tenés que
+    usar un símbolo porque los métodos de renderización van a renderizar
+    directamente cualquier string que se les pase como argumento.
   </dd>
 </dl>
 
@@ -872,7 +875,6 @@ distinto al de la plantilla pasando la opción `:layout_engine`.
   </tr>
 </table>
 
-
 El contenido de La plantilla se evalúa como código Ruby, y la variable `json` es convertida a JSON mediante `#to_json`.
 
 ``` ruby
@@ -1057,7 +1059,7 @@ after do
 end
 ```
 
-Nota: A menos que usés el método `body` en lugar de simplemente devolver un
+Nota: A menos que uses el método `body` en lugar de simplemente devolver un
 string desde una ruta, el cuerpo de la respuesta no va a estar disponible en
 un filtro after, debido a que todavía no se ha generado.
 
@@ -1125,7 +1127,7 @@ incluir los módulos en la clase de la aplicación.
 ### Usando Sesiones
 
 Una sesión es usada para mantener el estado a través de distintas peticiones.
-Cuando están activadas, tenés un hash de sesión para cada sesión de usuario:
+Cuando están activadas, proporciona un hash de sesión para cada sesión de usuario:
 
 ``` ruby
 enable :sessions
@@ -1140,8 +1142,8 @@ end
 ```
 
 Tené en cuenta que `enable :sessions` guarda todos los datos en una
-cookie, lo que no es siempre deseable (guardar muchos datos va a incrementar
-tu tráfico, por citar un ejemplo). Podés usar cualquier middleware Rack para
+cookie, lo cual no es siempre deseable (guardar muchos datos va a incrementar
+el tráfico, por citar un ejemplo). Podés usar cualquier middleware Rack para
 manejar sesiones, de la misma manera que usarías cualquier otro middleware,
 pero con la salvedad de que *no* tenés que llamar a `enable :sessions`:
 
@@ -1230,7 +1232,7 @@ end
 ```
 
 Se sale inmediatamente del bloque de la ruta y se le pasa el control a la
-siguiente ruta que coincida. Si no coincide ninguna ruta, se devuelve un 404.
+siguiente ruta que coincida. Si no coincide ninguna ruta, se devuelve 404.
 
 ### Ejecutando Otra Ruta
 
@@ -1413,7 +1415,7 @@ Para generar URLs deberías usar el método `url`. Por ejemplo, en Haml:
 
 Tiene en cuenta proxies inversos y encaminadores de Rack, si están presentes.
 
-Este método también puede invocarse mediante su alias `to`  (mirá un ejemplo
+Este método también puede invocarse mediante su alias `to` (mirá un ejemplo
 a continuación).
 
 ### Redirección del Navegador
@@ -1524,7 +1526,7 @@ etag @articulo.sha1, :weak
 
 Estos helpers no van a cachear nada por vos, sino que van a facilitar la
 información necesaria para poder hacerlo. Si estás buscando soluciones rápidas
-de cacheo con proxys inversos, mirá
+de cacheo con proxys reversos, mirá
 [rack-cache](https://github.com/rtomayko/rack-cache):
 
 ``` ruby
@@ -1548,7 +1550,7 @@ De acuerdo con la RFC 2616 tu aplicación debería comportarse diferente si a la
 cabeceras If-Match o If-None-Match se le asigna el valor `*` cuando el
 recurso solicitado ya existe. Sinatra asume para peticiones seguras (como get)
 e idempotentes (como put) que el recurso existe, mientras que para el resto
-(como post), que no. Podes cambiar este comportamiento con la opción
+(como post) asume que no. Podes cambiar este comportamiento con la opción
 `:new_resource`:
 
 ``` ruby
@@ -1643,7 +1645,7 @@ get '/foo' do
   request.path                # "/ejemplo/foo"
   request.ip                  # dirección IP del cliente
   request.secure?             # false (sería true sobre ssl)
-  request.forwarded?          # true (si se está corriendo atrás de un proxy inverso)
+  request.forwarded?          # true (si se está corriendo atrás de un proxy reverso)
   requuest.env                # hash de entorno directamente entregado por Rack
 end
 ```
@@ -1766,7 +1768,7 @@ helpers do
 end
 ```
 
-¡Es muy fácil convertir estos ejemplos en una extensión y compartirla!.
+¡Es muy fácil convertir estos ejemplos en una extensión y compartirla!
 
 Notá que `find_template` no verifica si un archivo existe realmente, sino
 que llama al bloque que recibe para cada path posible. Esto no representa un
@@ -1864,7 +1866,7 @@ set :protection, :except => [:path_traversal, :session_hijacking]
     1.1), que solamente permite redirecciones absolutas.
 
     Activalo si tu apliación está corriendo atrás de un proxy
-    inverso que no se ha configurado adecuadamente. Notá que
+    reverso que no se ha configurado adecuadamente. Notá que
     el helper <tt>url</tt> va a seguir produciendo URLs absolutas, a
     menos que le pasés <tt>false</tt> como segundo parámetro.
 
@@ -1996,7 +1998,7 @@ set :protection, :except => [:path_traversal, :session_hijacking]
   <dt>run</dt>
   <dd>
     Cuando está habilitada, Sinatra se va a encargar de
-    iniciar el servidor web, no la habilités cuando estés
+    iniciar el servidor web, no la habilites cuando estés
     usando rackup o algún otro medio.
   </dd>
 
@@ -2033,7 +2035,7 @@ set :protection, :except => [:path_traversal, :session_hijacking]
     Define si Sinatra debe encargarse de servir archivos
     estáticos.
 
-    Deshabilitala cuando usés un servidor capaz de
+    Deshabilitala cuando uses un servidor capaz de
     hacerlo por sí solo, porque mejorará el
     rendimiento. Se encuentra habilitada por
     defecto en el estilo clásico y desactivado en el
@@ -2156,7 +2158,7 @@ cuando se ejecuta dentro del entorno de desarrollo "development".
 
 Sinatra corre sobre Rack[http://rack.rubyforge.org/], una interfaz minimalista
 que es un estándar para frameworks webs escritos en Ruby. Una de las
-capacidades más interesantes de Rack para los desarrolladores de aplicaciones
+características más interesantes de Rack para los desarrolladores de aplicaciones
 es el soporte de "middleware" -- componentes que se ubican entre el servidor y
 tu aplicación, supervisando y/o manipulando la petición/respuesta HTTP para
 proporcionar varios tipos de funcionalidades comunes.
@@ -2176,9 +2178,9 @@ get '/hola' do
 end
 ```
 
-Las semánticas de `use` son idénticas a las definidas para el DSL
+La semántica de `use` es idéntica a la definida para el DSL
 Rack::Builder[http://rack.rubyforge.org/doc/classes/Rack/Builder.html] (más
-frecuentemente usado desde archivos rackup). Por ejemplo, el método `use`
+frecuentemente usado en archivos rackup). Por ejemplo, el método `use`
 acepta argumentos múltiples/variables así como bloques:
 
 ``` ruby
@@ -2237,7 +2239,7 @@ end
 
 Definir tu aplicación en el top-level funciona bien para micro-aplicaciones
 pero trae inconvenientes considerables a la hora de construir componentes
-reutilizables como Rack middleware, Rails metal, simple librerías con un
+reutilizables como Rack middleware, Rails metal, librerías simples con un
 componente de servidor, o incluso extensiones de Sinatra. El DSL de top-level
 asume una configuración apropiada para micro-aplicaciones (por ejemplo, un
 único archivo de aplicación, los directorios `./public` y
@@ -2574,7 +2576,7 @@ Tenés la ligadura al ámbito de delegación dentro de:
 * La ligadura del top-level, si hiciste `require "sinatra"`
 * Un objeto extendido con el mixin `Sinatra::Delegator`
 
-Pegale una mirada al código: acá está el
+Hechale un vistazo al código: acá está el
 [Sinatra::Delegator mixin](https://github.com/sinatra/sinatra/blob/ca06364/lib/sinatra/base.rb#L1609-1633)
 que [extiende el objeto main](https://github.com/sinatra/sinatra/blob/ca06364/lib/sinatra/main.rb#L28-30).
 
@@ -2605,7 +2607,7 @@ Las siguientes versiones de Ruby son soportadas oficialmente:
   <dt>Ruby 1.8.7</dt>
   <dd>
     1.8.7 es soportado completamente. Sin embargo, si no hay nada que te lo
-    prohíba, te recomendamos que usés 1.9.2 o cambies a JRuby o Rubinius. No se
+    prohiba, te recomendamos que uses 1.9.2 o cambies a JRuby o Rubinius. No se
     dejará de dar soporte a 1.8.7 hasta Sinatra 2.0 y Ruby 2.0, aunque si se
     libera la versión 1.8.8 de Ruby las cosas podrían llegar a cambiar. Sin
     embargo, que eso ocurra es muy poco probable, e incluso el caso de que lo
@@ -2617,7 +2619,7 @@ Las siguientes versiones de Ruby son soportadas oficialmente:
 
   <dt>Ruby 1.9.2</dt>
   <dd>
-    1.9.2 es soportado y recomendado. No usés 1.9.2p0, porque se producen fallos
+    1.9.2 es soportado y recomendado. No uses 1.9.2p0, porque se producen fallos
     de segmentación cuando se ejecuta Sinatra. El soporte se mantendrá al menos
     hasta que se libere la versión 1.9.4/2.0 de Ruby. El soporte para la última
     versión de la serie 1.9 se mantendrá mientras lo haga el core team de Ruby.
@@ -2655,16 +2657,16 @@ oficialmente. De cualquier manera, pueden ejecutar Sinatra:
 * Versiones anteriores de JRuby y Rubinius
 * Ruby Enterprise Edition
 * MacRuby, Maglev e IronRuby
-* Ruby 1.9.0 y 1.9.1 (pero no te recomendamos que los usés)
+* Ruby 1.9.0 y 1.9.1 (pero no te recomendamos que los uses)
 
 No estar soportada oficialmente, significa que si las cosas solamente se rompen
 ahí y no en una plataforma soportada, asumimos que no es nuestro problema sino
 el suyo.
 
 Nuestro servidor CI también se ejecuta sobre ruby-head (que será la próxima
-versión 2.0.0) y la rama 1.9.4. Como están en movimiento constante, no podemos
+versión 2.1.0) y la rama 1.9.4. Como están en movimiento constante, no podemos
 garantizar nada. De todas formas, podés contar con que tanto 1.9.4-p0 como
-2.0.0-p0 sea soportadas.
+2.1.0-p0 sea soportadas.
 
 Sinatra debería funcionar en cualquier sistema operativo soportado por la
 implementación de Ruby elegida.
@@ -2677,7 +2679,7 @@ BlueRuby o cualquier versión de Ruby anterior a 1.8.7.
 Si querés usar el código de Sinatra más reciente, sentite libre de ejecutar
 tu aplicación sobre la rama master, en general es bastante estable.
 
-También liberamos prereleases de vez en cuando, así, podés hacer
+También liberamos prereleases de vez en cuando, así, podés hacer:
 
 ``` shell
 gem install sinatra --pre

data/README.md

@@ -12,10 +12,15 @@ get '/' do
 end
 ```
 
-Install the gem and run with:
+Install the gem:
 
 ``` shell
 gem install sinatra
+```
+
+And run with:
+
+``` shell
 ruby myapp.rb
 ```
 
@@ -166,6 +171,9 @@ You can also access named parameters via block parameters:
 
 ``` ruby
 get '/hello/:name' do |n|
+  # matches "GET /hello/foo" and "GET /hello/bar"
+  # params[:name] is 'foo' or 'bar'
+  # n stores params[:name]
   "Hello #{n}!"
 end
 ```
@@ -488,12 +496,13 @@ Available Options:
     
 Templates are assumed to be located directly under the `./views` directory. To 
 use a different views directory: 
-<tt>set :views, settings.root + '/templates'</tt>
+`set :views, settings.root + '/templates'`
 
 One important thing to remember is that you always have to reference templates 
 with symbols, even if they're in a subdirectory (in this case, use:
-<tt>'subdir/template'</tt>). You must use a symbol because otherwise rendering
-methods will render any strings passed to them directly.
+`:'subdir/template'` or `'subdir/template'.to_sym`). You must use a symbol
+because otherwise rendering methods will render any strings passed to them
+directly.
 
 ### Literal Templates
 
@@ -723,7 +732,6 @@ template than for the layout by passing the `:layout_engine` option.
   </tr>
 </table>
 
-
 It is not possible to call methods from textile, nor to pass locals to it. You
 therefore will usually use it in combination with another rendering engine:
 
@@ -1033,7 +1041,7 @@ other templates.
 ### Templates with `yield` and nested layouts
 
 A layout is usually just a template that calls `yield`.
-Such a template can by used either through the `:template` option as
+Such a template can be used either through the `:template` option as
 described above, or it can be rendered with a block as follows:
 
 ``` ruby
@@ -1993,7 +2001,7 @@ set :protection, :session => true
     properly. Note that the <tt>url</tt> helper will still produce absolute URLs, unless you
     pass in <tt>false</tt> as the second parameter.
   </dd>
-  <dd>Disabled per default.</dd>
+  <dd>Disabled by default.</dd>
 
   <dt>add_charsets</dt>
   <dd>
@@ -2009,7 +2017,7 @@ set :protection, :session => true
   </dd>
 
   <dt>bind</dt>
-  <dd>IP address to bind to (default: <tt>0.0.0.0</tt>). Only used for built-in server.</dd>
+  <dd>IP address to bind to (default: <tt>0.0.0.0</tt> <em>or</em> <tt>localhost</tt> if your `environment` is set to development.). Only used for built-in server.</dd>
 
   <dt>default_encoding</dt>
   <dd>encoding to assume if unknown (defaults to <tt>"utf-8"</tt>).</dd>
@@ -2730,14 +2738,14 @@ The following Ruby versions are officially supported:
   <dt>Rubinius</dt>
   <dd>
     Rubinius is officially supported (Rubinius >= 2.x). It is recommendended to
-    `gem install puma`.
+    <tt>gem install puma</tt>.
   </dd>
 
   <dt>JRuby</dt>
   <dd>
     The latest stable release of JRuby is officially supported. It is not
     recommended to use C extensions with JRuby. It is recommended to
-    `gem install trinidad`.
+    <tt>gem install trinidad</tt>.
   </dd>
 </dl>
 
@@ -2828,6 +2836,7 @@ To update the Sinatra sources in the future:
 cd myapp/sinatra
 git pull
 ```
+
 ### Install Globally
 
 You can build the gem on your own:

data/lib/sinatra/base.rb

@@ -28,9 +28,11 @@ module Sinatra
     end
 
     def preferred_type(*types)
-      return accept.first if types.empty?
+      accepts = accept # just evaluate once
+      return accepts.first if types.empty?
       types.flatten!
-      accept.detect do |pattern|
+      return types.first if accepts.empty?
+      accepts.detect do |pattern|
         type = types.detect { |t| File.fnmatch(pattern, t) }
         return type if type
       end
@@ -1414,34 +1416,66 @@ module Sinatra
       end
 
       def compile(path)
-        keys = []
         if path.respond_to? :to_str
-          ignore = ""
-          pattern = path.to_str.gsub(/[^\?\%\\\/\:\*\w]/) do |c|
-            ignore << escaped(c).join if c.match(/[\.@]/)
-            patt = encoded(c)
-            patt.gsub(/%[\da-fA-F]{2}/) do |match|
-              match.split(//).map {|char| char =~ /[A-Z]/ ? "[#{char}#{char.tr('A-Z', 'a-z')}]" : char}.join
+          keys = []
+          
+          # We append a / at the end if there was one.
+          # Reason: Splitting does not split off an empty
+          # string at the end if the split separator
+          # is at the end.
+          #
+          postfix = '/' if path =~ /\/\z/
+          
+          # Split the path into pieces in between forward slashes.
+          #
+          segments = path.split('/').map! do |segment|
+            ignore = []
+            
+            # Special character handling.
+            #
+            pattern = segment.to_str.gsub(/[^\?\%\\\/\:\*\w]/) do |c|
+              ignore << escaped(c).join if c.match(/[\.@]/)
+              patt = encoded(c)
+              patt.gsub(/%[\da-fA-F]{2}/) do |match|
+                match.split(//).map {|char| char =~ /[A-Z]/ ? "[#{char}#{char.tr('A-Z', 'a-z')}]" : char}.join
+              end
+            end
+            
+            ignore = ignore.uniq.join
+            
+            # Key handling.
+            #
+            pattern.gsub(/((:\w+)|\*)/) do |match|
+              if match == "*"
+                keys << 'splat'
+                "(.*?)"
+              else
+                keys << $2[1..-1]
+                ignore_pattern = safe_ignore(ignore)
+                
+                ignore_pattern
+              end
             end
           end
-          pattern.gsub!(/((:\w+)|\*)/) do |match|
-            if match == "*"
-              keys << 'splat'
-              "(.*?)"
+          
+          # Special case handling.
+          #
+          if segment = segments.pop
+            if segment.match(/\[\^\\\./)
+              parts = segment.rpartition(/\[\^\\\./)
+              parts[1] = '[^'
+              segments << parts.join
             else
-              keys << $2[1..-1]
-              ignore_pattern = safe_ignore(ignore)
-
-              ignore_pattern
+              segments << segment
             end
           end
-          [/\A#{pattern}\z/, keys]
+          [/\A#{segments.join('/')}#{postfix}\z/, keys]
         elsif path.respond_to?(:keys) && path.respond_to?(:match)
           [path, path.keys]
         elsif path.respond_to?(:names) && path.respond_to?(:match)
           [path, path.names]
         elsif path.respond_to? :match
-          [path, keys]
+          [path, []]
         else
           raise TypeError, path
         end

data/lib/sinatra/version.rb

@@ -1,3 +1,3 @@
 module Sinatra
-  VERSION = '1.4.1'
+  VERSION = '1.4.2'
 end

data/test/compile_test.rb

@@ -6,14 +6,14 @@ class CompileTest < Test::Unit::TestCase
   def self.converts pattern, expected_regexp
     it "generates #{expected_regexp.source} from #{pattern}" do
       compiled, _ = compiled pattern
-      assert_equal expected_regexp, compiled
+      assert_equal expected_regexp, compiled, "Pattern #{pattern} is not compiled into #{expected_regexp.source}. Was #{compiled.source}."
     end
   end
   def self.parses pattern, example, expected_params
     it "parses #{example} with #{pattern} into params #{expected_params}" do
       compiled, keys = compiled pattern
       match = compiled.match(example)
-      fail %Q{"#{example}" does not parse on pattern "#{pattern}".} unless match
+      fail %Q{"#{example}" does not parse on pattern "#{pattern}" (compiled pattern is #{compiled.source}).} unless match
 
       # Aggregate e.g. multiple splat values into one array.
       #
@@ -27,7 +27,7 @@ class CompileTest < Test::Unit::TestCase
         hash
       end
 
-      assert_equal(expected_params, params)
+      assert_equal expected_params, params, "Pattern #{pattern} does not match path #{example}."
     end
   end
   def self.fails pattern, example
@@ -45,10 +45,10 @@ class CompileTest < Test::Unit::TestCase
 
   converts "/", %r{\A/\z}
   parses "/", "/", {}
-
+  
   converts "/foo", %r{\A/foo\z}
   parses "/foo", "/foo", {}
-
+  
   converts "/:foo", %r{\A/([^/?#]+)\z}
   parses "/:foo", "/foo",       "foo" => "foo"
   parses "/:foo", "/foo.bar",   "foo" => "foo.bar"
@@ -58,97 +58,126 @@ class CompileTest < Test::Unit::TestCase
   fails  "/:foo", "/foo/bar"
   fails  "/:foo", "/"
   fails  "/:foo", "/foo/"
-
+  
   converts "/föö", %r{\A/f%[Cc]3%[Bb]6%[Cc]3%[Bb]6\z}
   parses "/föö", "/f%C3%B6%C3%B6", {}
-
+  
   converts "/:foo/:bar", %r{\A/([^/?#]+)/([^/?#]+)\z}
   parses "/:foo/:bar", "/foo/bar", "foo" => "foo", "bar" => "bar"
-
+  
   converts "/hello/:person", %r{\A/hello/([^/?#]+)\z}
   parses "/hello/:person", "/hello/Frank", "person" => "Frank"
-
+  
   converts "/?:foo?/?:bar?", %r{\A/?([^/?#]+)?/?([^/?#]+)?\z}
   parses "/?:foo?/?:bar?", "/hello/world", "foo" => "hello", "bar" => "world"
   parses "/?:foo?/?:bar?", "/hello",       "foo" => "hello", "bar" => nil
   parses "/?:foo?/?:bar?", "/",            "foo" => nil, "bar" => nil
   parses "/?:foo?/?:bar?", "",             "foo" => nil, "bar" => nil
-
+  
   converts "/*", %r{\A/(.*?)\z}
   parses "/*", "/",       "splat" => ""
   parses "/*", "/foo",    "splat" => "foo"
   parses "/*", "/foo/bar", "splat" => "foo/bar"
-
+  
   converts "/:foo/*", %r{\A/([^/?#]+)/(.*?)\z}
   parses "/:foo/*", "/foo/bar/baz", "foo" => "foo", "splat" => "bar/baz"
-
+  
   converts "/:foo/:bar", %r{\A/([^/?#]+)/([^/?#]+)\z}
   parses "/:foo/:bar", "/user@example.com/name", "foo" => "user@example.com", "bar" => "name"
-
+  
   converts "/test$/", %r{\A/test(?:\$|%24)/\z}
   parses "/test$/", "/test$/", {}
-
+  
   converts "/te+st/", %r{\A/te(?:\+|%2[Bb])st/\z}
   parses "/te+st/", "/te+st/", {}
   fails  "/te+st/", "/test/"
   fails  "/te+st/", "/teeest/"
-
+  
   converts "/test(bar)/", %r{\A/test(?:\(|%28)bar(?:\)|%29)/\z}
   parses "/test(bar)/", "/test(bar)/", {}
-
+  
   converts "/path with spaces", %r{\A/path(?:%20|(?:\+|%2[Bb]))with(?:%20|(?:\+|%2[Bb]))spaces\z}
   parses "/path with spaces", "/path%20with%20spaces", {}
   parses "/path with spaces", "/path%2Bwith%2Bspaces", {}
   parses "/path with spaces", "/path+with+spaces",     {}
-
+  
   converts "/foo&bar", %r{\A/foo(?:&|%26)bar\z}
   parses "/foo&bar", "/foo&bar", {}
-
+  
   converts "/:foo/*", %r{\A/([^/?#]+)/(.*?)\z}
   parses "/:foo/*", "/hello%20world/how%20are%20you", "foo" => "hello%20world", "splat" => "how%20are%20you"
-
+  
   converts "/*/foo/*/*", %r{\A/(.*?)/foo/(.*?)/(.*?)\z}
   parses "/*/foo/*/*", "/bar/foo/bling/baz/boom", "splat" => ["bar", "bling", "baz/boom"]
   fails  "/*/foo/*/*", "/bar/foo/baz"
-
+  
   converts "/test.bar", %r{\A/test(?:\.|%2[Ee])bar\z}
   parses "/test.bar", "/test.bar", {}
   fails  "/test.bar", "/test0bar"
-
-  converts "/:file.:ext", %r{\A/((?:[^\./?#%]|(?:%[^2].|%[2][^Ee]))+)(?:\.|%2[Ee])((?:[^\./?#%]|(?:%[^2].|%[2][^Ee]))+)\z}
+  
+  converts "/:file.:ext", %r{\A/((?:[^\./?#%]|(?:%[^2].|%[2][^Ee]))+)(?:\.|%2[Ee])((?:[^/?#%]|(?:%[^2].|%[2][^Ee]))+)\z}
   parses "/:file.:ext", "/pony.jpg",   "file" => "pony", "ext" => "jpg"
   parses "/:file.:ext", "/pony%2Ejpg", "file" => "pony", "ext" => "jpg"
   fails  "/:file.:ext", "/.jpg"
-
-  converts "/:name.?:format?", %r{\A/((?:[^\./?#%]|(?:%[^2].|%[2][^Ee]))+)(?:\.|%2[Ee])?((?:[^\./?#%]|(?:%[^2].|%[2][^Ee]))+)?\z}
+  
+  converts "/:name.?:format?", %r{\A/((?:[^\./?#%]|(?:%[^2].|%[2][^Ee]))+)(?:\.|%2[Ee])?((?:[^/?#%]|(?:%[^2].|%[2][^Ee]))+)?\z}
   parses "/:name.?:format?", "/foo",       "name" => "foo", "format" => nil
   parses "/:name.?:format?", "/foo.bar",   "name" => "foo", "format" => "bar"
   parses "/:name.?:format?", "/foo%2Ebar", "name" => "foo", "format" => "bar"
+  parses "/:name?.?:format", "/.bar", "name" => nil, "format" => "bar"
+  parses "/:name?.?:format?", "/.bar", "name" => nil, "format" => "bar"
+  parses "/:name?.:format?", "/.bar", "name" => nil, "format" => "bar"
+  fails  "/:name.:format", "/.bar"
   fails  "/:name.?:format?", "/.bar"
-
+  
   converts "/:user@?:host?", %r{\A/((?:[^@/?#%]|(?:%[^4].|%[4][^0]))+)(?:@|%40)?((?:[^@/?#%]|(?:%[^4].|%[4][^0]))+)?\z}
   parses "/:user@?:host?", "/foo@bar",     "user" => "foo", "host" => "bar"
   parses "/:user@?:host?", "/foo.foo@bar", "user" => "foo.foo", "host" => "bar"
   parses "/:user@?:host?", "/foo@bar.bar", "user" => "foo", "host" => "bar.bar"
-
+  
   # From https://gist.github.com/2154980#gistcomment-169469.
   #
   # converts "/:name(.:format)?", %r{\A/([^\.%2E/?#]+)(?:\(|%28)(?:\.|%2E)([^\.%2E/?#]+)(?:\)|%29)?\z}
   # parses "/:name(.:format)?", "/foo", "name" => "foo", "format" => nil
   # parses "/:name(.:format)?", "/foo.bar", "name" => "foo", "format" => "bar"
   fails "/:name(.:format)?", "/foo."
-
+  
   parses "/:id/test.bar", "/3/test.bar", {"id" => "3"}
   parses "/:id/test.bar", "/2/test.bar", {"id" => "2"}
   parses "/:id/test.bar", "/2E/test.bar", {"id" => "2E"}
   parses "/:id/test.bar", "/2e/test.bar", {"id" => "2e"}
-  fails  "/:id/test.bar", "/%2E/test.bar"
-
+  parses "/:id/test.bar", "/%2E/test.bar", {"id" => "%2E"}
+  
+  parses '/10/:id', '/10/test', "id" => "test"
+  parses '/10/:id', '/10/te.st', "id" => "te.st"
+  
+  parses '/10.1/:id', '/10.1/test', "id" => "test"
+  parses '/10.1/:id', '/10.1/te.st', "id" => "te.st"
+  parses '/:foo/:id', '/10.1/te.st', "foo" => "10.1", "id" => "te.st"
+  parses '/:foo/:id', '/10.1.2/te.st', "foo" => "10.1.2", "id" => "te.st"
+  parses '/:foo.:bar/:id', '/10.1/te.st', "foo" => "10", "bar" => "1", "id" => "te.st"
+  fails '/:foo.:bar/:id', '/10.1.2/te.st' # We don't do crazy.
+  
+  parses '/:a/:b.?:c?', '/a/b',       "a" => "a",   "b" => "b", "c" => nil
+  parses '/:a/:b.?:c?', '/a/b.c',     "a" => "a",   "b" => "b", "c" => "c"
+  parses '/:a/:b.?:c?', '/a.b/c',     "a" => "a.b", "b" => "c", "c" => nil
+  parses '/:a/:b.?:c?', '/a.b/c.d',   "a" => "a.b", "b" => "c", "c" => "d"
+  fails  '/:a/:b.?:c?', '/a.b/c.d/e'
+  
   parses "/:file.:ext", "/pony%2ejpg", "file" => "pony", "ext" => "jpg"
   parses "/:file.:ext", "/pony%E6%AD%A3%2Ejpg", "file" => "pony%E6%AD%A3", "ext" => "jpg"
   parses "/:file.:ext", "/pony%e6%ad%a3%2ejpg", "file" => "pony%e6%ad%a3", "ext" => "jpg"
   parses "/:file.:ext", "/pony正%2Ejpg", "file" => "pony正", "ext" => "jpg"
   parses "/:file.:ext", "/pony正%2ejpg", "file" => "pony正", "ext" => "jpg"
-  fails  "/:file.:ext", "/pony正..jpg"
+  parses "/:file.:ext", "/pony正..jpg", "file" => "pony正", "ext" => ".jpg"
   fails  "/:file.:ext", "/pony正.%2ejpg"
+  
+  converts "/:name.:format", %r{\A/((?:[^\./?#%]|(?:%[^2].|%[2][^Ee]))+)(?:\.|%2[Ee])((?:[^/?#%]|(?:%[^2].|%[2][^Ee]))+)\z}
+  parses "/:name.:format", "/file.tar.gz", "name" => "file", "format" => "tar.gz"
+  parses "/:name.:format1.:format2", "/file.tar.gz", "name" => "file", "format1" => "tar", "format2" => "gz"
+  parses "/:name.:format1.:format2", "/file.temp.tar.gz", "name" => "file", "format1" => "temp", "format2" => "tar.gz"
+  
+  # From issue #688.
+  #
+  parses "/articles/10.1103/:doi", "/articles/10.1103/PhysRevLett.110.026401", "doi" => "PhysRevLett.110.026401"
 end

data/test/routing_test.rb

@@ -877,7 +877,7 @@ class RoutingTest < Test::Unit::TestCase
       application/x-pkcs7-mime
       application/x-pkcs7-signature
     )
-    
+
     mime_types.each { |mime_type| assert mime_type.match(Sinatra::Request::HEADER_VALUE_WITH_PARAMS) }
   end
 
@@ -899,7 +899,17 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 'application/xml', body
     assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
 
-    get '/', {}, { :accept => 'text/html' }
+    get '/', {}, {}
+    assert ok?
+    assert_equal '', body
+    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
+
+    get '/', {}, { 'HTTP_ACCEPT' => '*/*' }
+    assert ok?
+    assert_equal '*/*', body
+    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
+
+    get '/', {}, { 'HTTP_ACCEPT' => 'text/html;q=0.9' }
     assert !ok?
 
     get '/foo', {}, { 'HTTP_ACCEPT' => 'text/html;q=0.9' }
@@ -907,6 +917,14 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 'text/html;q=0.9', body
 
     get '/foo', {}, { 'HTTP_ACCEPT' => '' }
+    assert ok?
+    assert_equal '', body
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => '*/*' }
+    assert ok?
+    assert_equal '*/*', body
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
     assert !ok?
 
     get '/stream', {}, { 'HTTP_ACCEPT' => 'text/event-stream' }
@@ -914,6 +932,14 @@ class RoutingTest < Test::Unit::TestCase
     assert_equal 'text/event-stream', body
 
     get '/stream', {}, { 'HTTP_ACCEPT' => '' }
+    assert ok?
+    assert_equal '', body
+
+    get '/stream', {}, { 'HTTP_ACCEPT' => '*/*' }
+    assert ok?
+    assert_equal '*/*', body
+
+    get '/stream', {}, { 'HTTP_ACCEPT' => 'application/xml' }
     assert !ok?
   end
 
@@ -959,20 +985,6 @@ class RoutingTest < Test::Unit::TestCase
     end
   end
 
-  it 'degrades gracefully when optional accept header is not provided' do
-    mock_app {
-      get '/', :provides => :xml do
-        env['HTTP_ACCEPT']
-      end
-      get '/' do
-        'default'
-      end
-    }
-    get '/'
-    assert ok?
-    assert_equal 'default', body
-  end
-
   it 'respects user agent preferences for the content type' do
     mock_app { get('/', :provides => [:png, :html]) { content_type }}
     get '/', {}, { 'HTTP_ACCEPT' => 'image/png;q=0.5,text/html;q=0.8' }
@@ -986,8 +998,6 @@ class RoutingTest < Test::Unit::TestCase
       get('/', :provides => :xml) { content_type }
       get('/') { 'no match' }
     end
-    get '/'
-    assert_body 'no match'
     get '/', {}, { 'HTTP_ACCEPT' => 'foo/*' }
     assert_body 'no match'
     get '/', {}, { 'HTTP_ACCEPT' => 'application/*' }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sinatra
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 1.4.2
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-15 00:00:00.000000000 Z
+date: 2013-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -236,7 +236,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2287557311002662172
+      hash: 748751327798285916
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -245,7 +245,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2287557311002662172
+      hash: 748751327798285916
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23