pendragon 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47c14505bf8ecd94fbdfff0f4bd88ef93ae869d6
-  data.tar.gz: db2b7552746a423ce69adf38a727d1fe3a963c0c
+  metadata.gz: 34a16924c1d2032821eab7f8e670a9823cfe9e6e
+  data.tar.gz: f28901a7ae7bb3dd844b31fd09e65140ab40f700
 SHA512:
-  metadata.gz: c65a69814973dec2ff98523b6a090ad7e552403e349789ce5af6e28014b4d98d3d45c36498f9836887e6e143884e6539f6f45dc71b6be5021776f06aba3b9337
-  data.tar.gz: 62145cf3f8f5e16c26cbc56412be3bb29da00562abc3e10413da142365e7fcfb3c3c463c4677acd0fb0c4d1e65f9caa15c4a3820c60990f57dde24219f61695f
+  metadata.gz: 69305896d92e425a2901eb8670b644a55d1a22ddab91c33058889fcf7dae1bdcf6c288e0831cc98967cbe65838f182047e825f67cee641b631a39f92c74cf941
+  data.tar.gz: 6be88a0862cdcabe0206bdf3612869b4eb13f890478c4d16336bd2da4cf21c1132f8c561e0bc865d5ec8518b0cc2107d89f498cbc94ecf384bf47d28c8981d9a

data/.travis.yml

@@ -5,9 +5,16 @@ install:
   - bundle update
 rvm:
   - 2.0.0
+  - 2.1.0
+  - jruby-head
+  - rbx
 notifications:
   recipients:
     - namusyaka@gmail.com
 branches:
   only:
     - master
+matrix:
+  allow_failures:
+    - rvm: rbx
+    - rvm: jruby-head

data/Gemfile.lock

@@ -8,7 +8,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (4.0.2)
+    activesupport (4.0.3)
       i18n (~> 0.6, >= 0.6.4)
       minitest (~> 4.2)
       multi_json (~> 1.3)
@@ -17,11 +17,11 @@ GEM
     atomic (1.1.14)
     haml (4.0.5)
       tilt
-    http_router (0.11.0)
+    http_router (0.11.1)
       rack (>= 1.0.0)
       url_mount (~> 0.2.1)
     i18n (0.6.9)
-    metaclass (0.0.2)
+    metaclass (0.0.4)
     minitest (4.7.5)
     mocha (1.0.0)
       metaclass (~> 0.0.1)

data/README.md

@@ -1,136 +1,236 @@
 # Pendragon
 
-[![Build Status](https://travis-ci.org/namusyaka/pendragon.png)](https://travis-ci.org/namusyaka/pendragon)
+[![Build Status](https://travis-ci.org/namusyaka/pendragon.png)](https://travis-ci.org/namusyaka/pendragon) [![Gem Version](https://badge.fury.io/rb/pendragon.png)](http://badge.fury.io/rb/pendragon)
 
-Provides an HTTP router for use in Rack and Padrino.
+Pendragon provides an HTTP router for use in Rack and Padrino. 
+As a Rack application, it makes it easy to define complicated routing.
+As a Padrino plugin, your application uses Pendragon instead of http_router. 
+Therefore, some bugs of http_router will be fixed.
 
-Pendragon works only in Ruby2.0.
+*If you want to use in Ruby1.9, you can do it by using [mustermann/1.9-support branch](https://github.com/rkh/mustermann/tree/1.9-support).*
 
-If you want to use in Ruby1.9, you can do it by using [mustermann/1.9-support branch](https://github.com/rkh/mustermann/tree/1.9-support).
+```ruby
+Pendragon.new do
+  get("/"){ "hello world" }
+  get("/foo/:bar", name: :foo) do |params|
+    "foo is #{params[:bar]}"
+  end
+end
+```
 
 ## Installation
 
-add this line to your Gemfile.
+Depends on [rack](https://github.com/rack/rack) and [mustermann](https://github.com/rkh/mustermann).
 
-`gem 'pendragon'`
+`gem install pendragon`
 
-or
+## Usage
 
-`$ gem install pendragon`
+### Configuration
 
-## Configuration
+|name            |types  |default|description               |
+|:---------------|:------|:------|:-------------------------|
+|enable_compiler |boolean|false|The performance will be improved. However, it will increase the first load time.|
+|auto_rack_format|boolean|true|If disable this param, the block of route should return the response of valid rack format.|
 
-If you enable compiler, performance will be improved at the expense of some features as below.
-
-* Route priority will not work (Might support in the future).
-* Duplicated routes will not work correctly.
-* MethodNotAllowed will not work.
-
-This implementation was inspired by [rack-multiplexer](https://github.com/r7kamura/rack-multiplexer).
+#### `enable_compiler`
 
 ```ruby
+# Performance will be improved!
 Pendragon.configure do |config|
-  config.enable_compiler = true # default value is false
+  config.enable_compiler = true
 end
 ```
 
-## Example
+*The compiler mode was inspired by [rack-multiplexer](https://github.com/r7kamura/rack-multiplexer). Thank you!*
 
-Write this code to your config.ru.
+#### `auto_rack_format`
 
 ```ruby
-require 'pendragon'
+# Enable the param (default)
+Pendragon.new do
+  get("/"){ "hey" }
+end
 
-pendragon = Pendragon.new
-pendragon.add(:get, "/") do
-  "get"
+Pendragon.configure do |config|
+  config.auto_rack_format = false
+end
+# Disable the param
+Pendragon.new do
+  get("/"){ [200, {"Content-Type" => "text/html;charset=utf-8"}, ["hey"]] }
 end
+```
+
+### Register the route
+
+It has some methods to register a route. For example, `#get`, `#post` and `#delete` are so.
+This section introduces all those methods.
 
-pendragon.get("/hey") do
-  "hey"
+#### `add(verb, path, option, &block)`
+
+The method is the basis of the registration method of all.
+In comparison with other registration methods, one argument is increased.
+
+```ruby
+Pendragon.new do
+  # The two approach have the same meaning.
+  add(:get, "/"){ "hello world" }
+  get("/"){ "hello world" }
 end
+```
+
+#### `get(path, option, &block)`, `post`, `delete`, `put` and `head`
+
+Basically the usage is the same with `#add`.
+You may as well use those methods instead of `#add` because those methods are easy to understand.
 
-pendragon.post("/hey") do
-  "hey, postman!"
+```ruby
+Pendragon.new do
+  get("/"){ "hello world" }
+  post("/"){ "hello world" }
+  delete("/"){ "hello world" }
+  put("/"){ "hello world" }
+  head("/"){ "hello world" }
 end
+```
+
+##### Path
+
+The path must be an instance of String (this must be complied with the Mustermann::Sinatra's rule) or Regexp.
+
+##### Route options
+
+|name|types   |description               |
+|:----|:------|:-------------------------|
+|name |symbol |specify the name of route for `Pendragon::Router#path` method.|
+|order|integer|specify the order for the prioritized routes.|
+|capture|hash|specify the capture for matching condition. [more information here](https://github.com/rkh/mustermann)|
+|status|integer|specify the status code of response|
+|header|hash|specify the header of response|
 
+##### Block Parameters
 
-pendragon.get("/users/:user_id") do |params|
-  params.inspect
+The block is allowed to pass a parameter.
+It will be an instance of Hash.
+
+```ruby
+pendragon = Pendragon.new do
+  get("/:id/:foo/:bar"){|params| params.inspect }
 end
 
-run pendragon
+request = Rack::MockRequest.env_for("/123/hey/ho")
+pendragon.recognize(request).first.call #=> '{id: "123", foo: "hey", bar: "ho"}'
 ```
 
-## Normal path
+### Recognize the route
+
+The route registered can be recognized by several methods.
 
-### Base
+#### `recognize(request)`
+
+This method returns all the routes that match the conditions.
+The format of returns will be such as `[[Pendragon::Route, params], ...]`.
+The request must be an instance of `Rack::Request` or Hash created by `Rack::MockRequest.env_for`.
 
 ```ruby
 pendragon = Pendragon.new
+index = pendragon.get("/"){ "hello world" }
+foo   = pendragon.get("/foo/:bar"){ "foo is bar" }
 
-pendragon.add(:get, "/") do
-  "hello"
-end
+mock_request = Rack::MockRequest.env_for("/")
+route, params = pendragon.recognize(mock_request).first
+
+route.path == index.path #=> true
+params #=> {}
+
+mock_request = Rack::MockRequest.env_for("/foo/baz")
+route, params = pendragon.recognize(mock_request).first
+
+route.path == foo.path #=> true
+params #=> {bar: "baz"}
 ```
 
-### Regexp
+#### `recognize_path(path_info)`
 
-```ruby
-pendragon = Pendragon.new
+Recognizes a route from `path_info`.
+The method uses `#recognize`, but return value is not same with it.
+Maybe this is useful if you set the name to the route.
 
-pendragon.add(:get, /(\d+)/) do
-  "hello"
+```ruby
+pendragon = Pendragon.new do
+  get("/", name: :index){ "hello world" }
+  get("/:id", name: :foo){ "fooooo" }
 end
+
+pendragon.recognize_path("/") #=> [:index, {}]
+pendragon.recognize_path("/hey") #=> [:foo, {id: "hey"}]
 ```
 
-### Params
+#### `path(name, *args)`
 
-```ruby
-pendragon = Pendragon.new
+Recognizes a route from route's name, and expands the path from parameters.
+If you pass a name that does not exist, Pendragon raises `InvalidRouteException`.
+The parameters that is not required to expand will be treated as query.
 
-pendragon.add(:get, "/users/:name") do |params|
-  "hello #{params[:name]}"
+```ruby
+pendragon = Pendragon.new do
+  get("/", name: :index){ "hello world" }
+  get("/:id", name: :foo){ "fooooo" }
 end
 
-pendragon.add(:get, /\/page\/(.+?)/) do |params|
-  "show #{params[:captures]}"
-end
+pendragon.path(:index) #=> "/"
+pendragon.path(:foo, id: "123") #=> "/123"
+pendragon.path(:foo, id: "123", bar: "hey") #=> "/123?bar=hey"
 ```
 
-### Captures
+### Prioritized Routes
 
-```ruby
-pendragon = Pendragon.new
+Pendragon supports for respecting route order.
+If you want to use this, you should pass the `:order` option to the registration method.
 
-users = pendragon.add(:get, "/users/:name") do |params|
-  "hello #{params[:name]}"
+```ruby
+pendragon = Pendragon.new do
+  get("/", order: 1){ "two" }
+  get("/", order: 0){ "one" }
+  get("/", order: 2){ "three" }
 end
-users.captures[:name] = /\d+/
+
+request = Rack::MockRequest.env_for("/")
+pendragon.recognize(request).map{|route, _| route.call } #=> ["one", "two", "three"]
 ```
 
-### Name and Path
+### Passing
 
-```ruby
-pendragon = Pendragon.new
+A route can punt processing to the next matching route using `throw :pass`
 
-users = pendragon.add(:get, "/users/:name") do |params|
-  "hello #{params[:name]}"
+```ruby
+pendragon = Pendragon.new do
+  foo = nil
+  get("/"){ foo = "yay"; throw :pass }
+  get("/"){ foo }
 end
-users.name = :users
 
-pendragon.path(:users, :name => "howl") #=> "/users/howl"
+request = Rack::MockRequest.env_for("/")
+pendragon.call(request) #=> [200, {"Content-Type"=>"text/html;charset=utf-8"}, ["yay"]]
 ```
 
-## with Padrino
+### With Padrino
+
+Add `register Pendragon::Padrino` to your padrino application.
+Of course, Pendragon has compatibility with Padrino Routing.
 
-If you use Pendragon, your application does not use http_router.
 
 ```ruby
 require 'pendragon/padrino'
 
 class App < Padrino::Application
   register Pendragon::Padrino
+  
+  ##
+  # Also, your app's performance will be improved by using compiler mode.
+  # Pendragon.configure do |config|
+  #   config.enable_compiler = true
+  # end
 
   get :index do
     "hello pendragon!"

data/Rakefile

@@ -15,5 +15,11 @@ Rake::TestTask.new(:test_with_compiler) do |test|
   test.verbose = true
 end
 
-task :test => [:test_without_compiler, :test_with_compiler]
+Rake::TestTask.new(:configuration) do |test|
+  test.libs << 'test'
+  test.test_files = Dir['test/**/*_configuration.rb']
+  test.verbose = true
+end
+
+task :test => [:test_without_compiler, :test_with_compiler, :configuration]
 task :default => :test

data/lib/pendragon/compile_helpers.rb

@@ -2,40 +2,47 @@
 module Pendragon
   module CompileHelpers
     def compile!
-      @compiled_regexps = Pendragon::HTTP_VERBS.inject({}){|all, verb| all[verb] = []; all }
-      @routes.each_with_index do |route, index|
+      return if compiled?
+      @regexps = @routes.map.with_index do |route, index|
         regexp = route.matcher.handler
         regexp = regexp.to_regexp if route.matcher.mustermann?
-        @compiled_regexps[route.verb] << /(?<_#{index}>#{regexp})/
-        route.index = "_#{index}"
+        route.index = index
+        /(?<_#{index}>#{regexp})/
       end
-      @compiled_regexps.each_pair{|verb, regexps| @compiled_regexps[verb] = /\A#{Regexp.union(regexps)}\Z/ }
+      @regexps = compile(@regexps)
+    end
+
+    def compile(regexps, paths = [])
+      return paths if regexps.length.zero?
+      paths << Regexp.union(regexps)
+      regexps.shift
+      compile(regexps, paths)
     end
 
     def compiled?
-      !!@compiled_regexps
+      !!@regexps
     end
 
     def recognize_by_compiling_regexp(request)
-      path_info, verb, request_params = parse_request(request)
-
-      unless @compiled_regexps[verb] === path_info
-        old_path_info = path_info
-        path_info = path_info[0..-2] if path_info != "/" and path_info[-1] == "/"
-        raise NotFound if old_path_info == path_info || !(@compiled_regexps[verb] === path_info)
-      end
+      prepare! unless prepared?
+      pattern, verb, params = parse_request(request)
+      candidacies = match_with(pattern)
+      raise_exception(404) if candidacies.empty?
+      candidacies, allows = candidacies.partition{|route| route.verb == verb }
+      raise_exception(405, verbs: allows.map(&:verb)) if candidacies.empty?
+      candidacies.map{|route| [route, params_for(route, pattern, params)]}
+    end
 
-      route = @routes.select{|route| route.verb == verb }.detect{|route| Regexp.last_match(route.index) }
-      params, match_data = {}, route.match(path_info)
-      if match_data.names.empty?
-        params[:captures] = match_data.captures
-      else
-        params.merge!(match_data.names.inject({}){|result, name|
-          result[name.to_sym] = match_data[name] ? Rack::Utils.unescape(match_data[name]) : nil
-          result
-        }).merge!(request_params){|key, self_val, new_val| self_val || new_val }
+    def match_with(pattern)
+      offset = 0
+      conditions = [pattern]
+      conditions << pattern[0..-2] if pattern != "/" && pattern.end_with?("/")
+      loop.with_object([]) do |_, candidacies|
+        return candidacies unless conditions.any?{|x| @regexps[offset] === x }
+        route = @routes[offset..-1].detect{|route| Regexp.last_match("_#{route.index}") }
+        candidacies << route
+        offset = route.index + 1
       end
-      [[route, params]]
     end
   end
 end

data/lib/pendragon/configuration.rb

@@ -1,25 +1,33 @@
 module Pendragon
   class Configuration
 
+    # Define the accessor as boolean method
+    def self.attr_boolean_accessor(*keys)
+      keys.each do |key|
+        attr_accessor key
+        define_method("#{key}?"){ !!__send__(key) }
+      end
+    end
+
     # Enables to compile the routes
     # Improve the performance by using this option,
     # but some features will not work correctly.
     # @see Pendragon::Router#compile
-    attr_accessor :enable_compiler
+    attr_boolean_accessor :enable_compiler
+
+    # Automatically convert response into Rack format.
+    # Default value is `true`.
+    attr_boolean_accessor :auto_rack_format
 
     # Constructs an instance of Pendragon::Configuration
     def initialize
-      @enable_compiler = false
+      @enable_compiler  = false
+      @auto_rack_format = true
     end
 
     # Returns an instance variable
     def [](variable_name)
       instance_variable_get("@#{variable_name}")
     end
-
-    # Returns a boolean of @enable_compiler
-    def enable_compiler?
-      !!@enable_compiler
-    end
   end
 end

data/lib/pendragon/error_handler.rb

@@ -34,6 +34,10 @@ module Pendragon
   class MethodNotAllowed < ErrorHandler
     set :status, 405
     set :body,   "Method Not Allowed"
+
+    def initialize(verbs)
+      default_response[1].merge!("Allow" => verbs.map{|verb| verb.upcase } * ", ")
+    end
   end
 
   class BadRequest < ErrorHandler

data/lib/pendragon/matcher.rb

@@ -1,4 +1,4 @@
-require 'mustermann'
+require 'mustermann/sinatra'
 
 module Pendragon
   class Matcher
@@ -22,7 +22,7 @@ module Pendragon
     # @return [Nil] If the pattern doesn't matched this route, return a nil.
     #
     def match(pattern)
-      pattern = pattern[0..-2] if mustermann? and pattern != "/" and pattern[-1] == "/"
+      pattern = pattern[0..-2] if mustermann? and pattern != "/" and pattern.end_with?("/")
       handler.match(pattern)
     end
 
@@ -59,7 +59,7 @@ module Pendragon
       @handler ||=
         case @path
         when String
-          Mustermann.new(@path, :capture => @capture)
+          Mustermann::Sinatra.new(@path, :capture => @capture)
         when Regexp
           /^(?:#{@path})$/
         end

data/lib/pendragon/padrino/router.rb

@@ -13,32 +13,16 @@ module Pendragon
 
       def call(env)
         request = Rack::Request.new(env)
-        raise BadRequest unless valid_verb?(request.request_method)
-        prepare! unless prepared?
+        raise_exception(400) unless valid_verb?(request.request_method)
         [200, {}, recognize(request)]
       rescue BadRequest, NotFound, MethodNotAllowed
         $!.call
       end
 
       def path(name, *args)
-        params = args.delete_at(args.last.is_a?(Hash) ? -1 : 0) || {}
-        saved_args = args.dup
-        @routes.each do |route|
-          next unless route.options[:name] == name
-          matcher = route.matcher
-          if !args.empty? and matcher.mustermann?
-            matcher_names = matcher.names
-            params_for_expand = Hash[matcher_names.map{|matcher_name|
-              [matcher_name.to_sym, (params[matcher_name.to_sym] || args.shift)]
-            }]
-            params_for_expand.merge!(Hash[params.select{|k, v| !matcher_names.include?(name.to_sym) }])
-            args = saved_args.dup
-          else
-            params_for_expand = params.dup
-          end
-          return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path_for_generation
+        extract_with_name(name, *args) do |route, params, matcher|
+          matcher.mustermann? ? matcher.expand(params) : route.path_for_generation
         end
-        raise InvalidRouteException
       end
     end
   end

data/lib/pendragon/route.rb

@@ -1,21 +1,25 @@
 module Pendragon
   class Route
 
-    ##
     # The accessors are useful to access from Pendragon::Router
-    attr_accessor :block, :capture, :router, :options, :verb, :order
+    attr_accessor :name, :capture, :order, :options
 
-    ##
     # For compile option
     attr_accessor :index
 
-    ##
+    # The verb should be read from Pendragon::Router
+    attr_reader :verb, :block
+
+    # The router will be treated in this class.
+    attr_writer :router
+
     # Constructs a new instance of Pendragon::Route
     def initialize(path, verb, options = {}, &block)
       @block = block if block_given?
-      @path, @verb, @options = path, verb, options
+      @path, @verb = path, verb
       @capture = {}
       @order = 0
+      merge_with_options!(options)
     end
 
     def matcher
@@ -24,7 +28,7 @@ module Pendragon
     end
 
     def arity
-      block.arity
+      @block.arity
     end
 
     def call(*args)
@@ -35,19 +39,10 @@ module Pendragon
       matcher.match(pattern)
     end
 
-    def name
-      @options[:name]
-    end
-
-    def name=(value)
-      warn "[DEPRECATION] 'name=' is depreacted. Please use 'options[:name]=' instead"
-      @options[:name] = value
-    end
-
     def to(&block)
       @block = block if block_given?
-      @order = router.current
-      router.increment_order!
+      @order = @router.current
+      @router.increment_order!
     end
 
     def path(*args)
@@ -56,5 +51,33 @@ module Pendragon
       params.delete(:captures)
       matcher.expand(params) if matcher.mustermann?
     end
+
+    def params(pattern, parameters = {})
+      match_data, params = match(pattern), {}
+      if match_data.names.empty?
+        params.merge!(:captures => match_data.captures) unless match_data.captures.empty?
+        params
+      else
+        params = matcher.handler.params(pattern, :captures => match_data) || params
+        symbolize(params).merge(parameters){|key, old, new| old || new }
+      end
+    end
+
+    def symbolize(parameters)
+      parameters.inject({}){|result, (key, val)| result[key.to_sym] = val; result }
+    end
+
+    def merge_with_options!(options)
+      @options = {} unless @options
+      options.each_pair do |key, value|
+        accessor?(key) ? __send__("#{key}=", value) : (@options[key] = value)
+      end
+    end
+
+    def accessor?(key)
+      respond_to?("#{key}=") && respond_to?(key)
+    end
+
+    private :symbolize, :merge_with_options!, :accessor?
   end
 end

data/lib/pendragon/router.rb

@@ -33,15 +33,22 @@ module Pendragon
     # @return the Rack style response
     def call(env)
       request = Rack::Request.new(env)
-      raise BadRequest unless valid_verb?(request.request_method)
-      prepare! unless prepared?
-      route, params = recognize(request).first
-      body = route.arity != 0 ? route.call(params) : route.call
-      [200, {'Content-Type' => 'text/html;charset=utf-8'}, Array(body)]
+      raise_exception(400) unless valid_verb?(request.request_method)
+      recognize(request).each do |route, params|
+        catch(:pass){ return invoke(route, params) }
+      end
     rescue BadRequest, NotFound, MethodNotAllowed
       $!.call
     end
 
+    def invoke(route, params)
+      response = route.arity != 0 ? route.call(params) : route.call
+      return response unless Pendragon.configuration.auto_rack_format?
+      status = route.options[:status] || 200
+      header = {'Content-Type' => 'text/html;charset=utf-8'}.merge(route.options[:header] || {})
+      [status, header, Array(response)]
+    end
+
     # Provides some methods intuitive than #add
     # Basic usage is the same as #add
     # @see Pendragon::Router#add
@@ -70,15 +77,17 @@ module Pendragon
     # This method is executed only once in the initial load
     def prepare!
       @prepared = true
-      @routes.sort_by!(&:order) unless current.zero?
-      if Pendragon.configuration.enable_compiler?
-        class << self
-          include CompileHelpers
-          alias_method :old_recognize, :recognize
-          alias_method :recognize, :recognize_by_compiling_regexp
-        end
-        compile!
-      end
+      @routes.sort_by!(&:order)
+      self.class.setup_compiler! && compile! if Pendragon.configuration.enable_compiler?
+    end
+
+    # Setups the compiler by using CompileHelpers
+    # @see Pendragon::CompileHelpers
+    def self.setup_compiler!
+      include CompileHelpers
+      alias_method :old_recognize, :recognize
+      alias_method :recognize, :recognize_by_compiling_regexp
+      true
     end
 
     # @return [Boolean] the router is already prepared?
@@ -95,19 +104,9 @@ module Pendragon
     # @param request [Rack::Request]
     # @return [Array]
     def recognize(request)
-      path_info, verb, request_params = parse_request(request)
-      scan(path_info, verb) do |route|
-        params, match_data = {}, route.match(path_info)
-        if match_data.names.empty?
-          params[:captures] = match_data.captures
-        else
-          params.merge!(match_data.names.inject({}){|result, name|
-            result[name.to_sym] = match_data[name] ? Rack::Utils.unescape(match_data[name]) : nil
-            result
-          }).merge!(request_params){|key, self_val, new_val| self_val || new_val }
-        end
-        [route, params]
-      end
+      prepare! unless prepared?
+      pattern, verb, params = parse_request(request)
+      fetch(pattern, verb){|route| [route, params_for(route, pattern, params)] }
     end
 
     # Recognizes a given path
@@ -115,7 +114,7 @@ module Pendragon
     # @return [Array]
     def recognize_path(path_info)
       route, params = recognize(Rack::MockRequest.env_for(path_info)).first
-      [route.options[:name], params]
+      [route.name, params]
     end
 
     # Returns a expanded path matched with the conditions as arguments
@@ -126,23 +125,9 @@ module Pendragon
     #   router.path(:index, :id => 1) #=> "/1"
     #   router.path(:index, :id => 2, :foo => "bar") #=> "/1?foo=bar"
     def path(name, *args)
-      params = args.delete_at(args.last.is_a?(Hash) ? -1 : 0) || {}
-      saved_args = args.dup
-      @routes.each do |route|
-        next unless route.options[:name] == name
-        matcher = route.matcher
-        if !args.empty? and matcher.mustermann?
-          matcher_names = matcher.names
-          params_for_expand = Hash[matcher_names.map{|matcher_name|
-            [matcher_name.to_sym, (params[matcher_name.to_sym] || args.shift)]}]
-          params_for_expand.merge!(Hash[params.select{|k, v| !matcher_names.include?(name.to_sym) }])
-          args = saved_args.dup
-        else
-          params_for_expand = params.dup
-        end
-        return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path
+      extract_with_name(name, *args) do |route, params, matcher|
+        matcher.mustermann? ? matcher.expand(params) : route.path
       end
-      raise InvalidRouteException
     end
 
     private
@@ -153,19 +138,12 @@ module Pendragon
     end
 
     # @!visibility private
-    def scan(pattern, verb)
-      raise NotFound if (selected_routes = routes.select{|route| route.match(pattern) }).empty?
-
-      result = selected_routes.map do |route|
-        next unless verb == route.verb
-        yield route
-      end.compact
-
-      if result.empty?
-        raise MethodNotAllowed.new(selected_routes.map(&:verb))
-      else
-        result
-      end
+    def fetch(pattern, verb)
+      _routes = routes.select{|route| route.match(pattern) }
+      raise_exception(404) if _routes.empty?
+      result = _routes.map{|route| yield(route) if verb == route.verb }.compact
+      raise_exception(405, :verbs => _routes.map(&:verb)) if result.empty?
+      result
     end
 
     # @!visibility private
@@ -184,5 +162,49 @@ module Pendragon
         result
       end
     end
+
+    # @!visibility private
+    def params_for(route, pattern, params)
+      route.params(pattern, params)
+    end
+
+    # @!visibility private
+    # @example
+    #   extract_with_name(:index) do |route, params|
+    #     route.matcher.mustermann? ? route.matcher.expand(params) : route.path
+    #   end
+    def extract_with_name(name, *args)
+      params = args.delete_at(args.last.is_a?(Hash) ? -1 : 0) || {}
+      saved_args = args.dup
+      @routes.each do |route|
+        next unless route.name == name
+        matcher = route.matcher
+        if !args.empty? and matcher.mustermann?
+          matcher_names = matcher.names
+          params_for_expand = Hash[matcher_names.map{|matcher_name|
+            [matcher_name.to_sym, (params[matcher_name.to_sym] || args.shift)]}]
+          params_for_expand.merge!(Hash[params.select{|k, v| !matcher_names.include?(name.to_sym) }])
+          args = saved_args.dup
+        else
+          params_for_expand = params.dup
+        end
+        return yield(route, params_for_expand, matcher)
+      end
+      raise InvalidRouteException
+    end
+
+    # @!visibility private
+    def raise_exception(error_code, options = {})
+      raise ->(error_code) {
+        case error_code
+        when 400
+          BadRequest
+        when 404
+          NotFound
+        when 405
+          MethodNotAllowed.new(options[:verbs])
+        end
+      }.(error_code)
+    end
   end
 end

data/lib/pendragon/version.rb

@@ -1,4 +1,4 @@
 
 module Pendragon
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
 end

data/test/padrino_test.rb

@@ -148,7 +148,6 @@ describe "Pendragon::Padrino" do
   end
 
   should "match user agents" do
-    skip if enable_compiler?
     app = mock_app do
       get("/main", :agent => /IE/){ "hello IE" }
       get("/main"){ "hello" }
@@ -595,7 +594,6 @@ describe "Pendragon::Padrino" do
   end
 
   should '405 on wrong request_method' do
-    skip if enable_compiler?
     mock_app do
       post('/bar'){ "bar" }
     end
@@ -603,6 +601,15 @@ describe "Pendragon::Padrino" do
     assert_equal 405, status
   end
 
+  should "set Allow header when occur 405" do
+    mock_app do
+      post("/bar"){}
+      put("/bar"){}
+    end
+    get "/bar"
+    assert_equal "POST, PUT", response.headers['Allow']
+  end
+
   should 'respond to' do
     mock_app do
       get(:a, :provides => :js){ "js" }
@@ -847,7 +854,6 @@ describe "Pendragon::Padrino" do
 
 
   should 'respect priorities' do
-    skip if enable_compiler?
     route_order = []
     mock_app do
       get(:index, :priority => :normal) { route_order << :normal; pass }
@@ -1083,7 +1089,6 @@ describe "Pendragon::Padrino" do
   end
 
   should "transitions to the next matching route on pass" do
-    skip if enable_compiler?
     mock_app do
       get '/:foo' do
         pass
@@ -1263,7 +1268,6 @@ describe "Pendragon::Padrino" do
   end
 
   should 'allows custom route-conditions to be set via route options using two routes' do
-    skip if enable_compiler?
     protector = Module.new do
       def protect(*args)
         condition { authorize(params["user"], params["password"]) }
@@ -1329,7 +1333,6 @@ describe "Pendragon::Padrino" do
   end
 
   should "allow passing & halting in before filters" do
-    skip if enable_compiler?
     mock_app do
       controller do
         before { env['QUERY_STRING'] == 'secret' or pass }
@@ -1813,10 +1816,8 @@ describe "Pendragon::Padrino" do
     post '/hi.json', {'_method'=>'PUT'}
     assert_equal 200, status
     assert_equal 'hi', body
-    unless enable_compiler?
-      post '/hi.json'
-      assert_equal 405, status
-    end
+    post '/hi.json'
+    assert_equal 405, status
   end
 
   should 'parse nested params' do

data/test/pendragon_configuration.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../lib/pendragon', __FILE__)
+$:.unshift(File.dirname(__FILE__))
+require 'helper'
+
+describe Pendragon::Configuration do
+  setup{ @pendragon = pendragon }
+  teardown{ Pendragon.reset_configuration! }
+
+  describe "auto_rack_format" do
+    should "set `true` as default value" do
+      @pendragon.get("/"){ "hey" }
+      get "/"
+      assert_equal "hey", body
+      assert_equal true, Pendragon.configuration.auto_rack_format?
+    end
+
+    should "not serialize for rack format if `auto_rack_format` is false" do
+      Pendragon.configure do |config|
+        config.auto_rack_format = false
+      end
+
+      @pendragon.get("/"){ "hey" }
+      assert_raises(Rack::Lint::LintError){ get "/" }
+
+      @pendragon.post("/"){ [200, {'Content-Type' => 'text/html;charset=utf-8'}, ["hey"]] }
+      post "/"
+      assert_equal "hey", body
+      assert_equal false, Pendragon.configuration.auto_rack_format?
+    end
+  end
+end

data/test/pendragon_test.rb

@@ -82,7 +82,68 @@ describe Pendragon do
       head("/")
       assert_equal "", body
     end
+
+    should "support for correct options" do
+      named_route = @pendragon.get("/name/:name", name: :named_route){}
+      incorrect_route = @pendragon.get("/router", router: :incorrect!){}
+      status_route = @pendragon.get("/router", status: 200){}
+      assert_equal :named_route, named_route.name
+      assert_equal "/name/foo", @pendragon.path(:named_route, name: :foo)
+      assert_equal true, incorrect_route.instance_variable_get(:@router).instance_of?(Pendragon::Router)
+    end
+
+    should "allow to throw :pass for routing like journey" do
+      foo = nil
+      @pendragon.get("/"){ foo = "yay"; throw :pass }
+      @pendragon.get("/"){ foo }
+      get "/"
+      assert_equal "yay", body
+    end
   end
+
+  describe "route options" do
+    should "support for :capture option" do
+      capture = {foo: /\d+/, bar: "bar"}
+      route = @pendragon.get("/:foo/:bar", capture: capture){}
+      assert_equal route.capture, capture
+      assert_equal nil, route.match("/foo/bar")
+      assert_equal nil, route.match("/123/baz")
+      assert_equal true, route.match("/123/bar").instance_of?(MatchData)
+    end
+
+    should "support for :name option" do
+      route = @pendragon.get("/name/:name", name: :named_route){}
+      assert_equal :named_route, route.name
+      assert_equal "/name/foo", @pendragon.path(:named_route, name: :foo)
+    end
+
+    should "not support for :router option" do
+      route = @pendragon.get("/router", router: :incorrect!){}
+      assert_equal true, route.instance_variable_get(:@router).instance_of?(Pendragon::Router)
+    end
+
+    should "support for :order option" do
+      @pendragon.get("/", order: 2){ "three" }
+      @pendragon.get("/", order: 0){ "one" }
+      @pendragon.get("/", order: 1){ "two" }
+      request = Rack::MockRequest.env_for("/")
+      assert_equal ["one", "two", "three"], @pendragon.recognize(request).map{|route, _| route.call }
+    end
+
+    should "support for :status option" do
+      @pendragon.get("/", status: 201){ "hey" }
+      get "/"
+      assert_equal 201, status
+    end
+
+    should "support for :header option" do
+      header = {"Content-Type" => "text/plain;"}
+      @pendragon.get("/", header: header){ "hey" }
+      get "/"
+      assert_equal header.merge("Content-Length" => "3"), headers
+    end
+  end
+
   describe "regexp routing" do
     before(:each){ @pendragon.reset! }
 
@@ -107,18 +168,18 @@ describe Pendragon do
       foo_bar = @pendragon.add(:post, "/foo/bar", :name => :foo_bar){}
       users = @pendragon.add(:get, "/users/:user_id", :name => :users){}
 
-      assert_equal @pendragon.path(:index), "/"
-      assert_equal @pendragon.path(:foo_bar), "/foo/bar"
-      assert_equal @pendragon.path(:users, :user_id => 1), "/users/1"
-      assert_equal @pendragon.path(:users, :user_id => 1, :query => "string"), "/users/1?query=string"
+      assert_equal "/", @pendragon.path(:index)
+      assert_equal "/foo/bar", @pendragon.path(:foo_bar)
+      assert_equal "/users/1", @pendragon.path(:users, :user_id => 1)
+      assert_equal "/users/1?query=string", @pendragon.path(:users, :user_id => 1, :query => "string")
     end
 
     should "regexp" do
       index = @pendragon.add(:get, /.+?/, :name => :index){}
       foo_bar = @pendragon.add(:post, /\d+/, :name => :foo_bar){}
 
-      assert_equal @pendragon.path(:index), /.+?/
-      assert_equal @pendragon.path(:foo_bar), /\d+/
+      assert_equal /.+?/, @pendragon.path(:index)
+      assert_equal /\d+/, @pendragon.path(:foo_bar)
     end
   end
 
@@ -132,8 +193,17 @@ describe Pendragon do
       assert_equal "foo", body
       post("/")
       assert_equal "bar", body
-      assert_equal @app.path(:foo), "/"
-      assert_equal @app.path(:bar), "/"
+      assert_equal "/", @app.path(:foo)
+      assert_equal "/", @app.path(:bar)
+    end
+  end
+
+  describe "header" do
+    should "set Allow header when occur 405" do
+      @pendragon.get("/"){}
+      @pendragon.put("/"){}
+      post "/"
+      assert_equal "GET, PUT", response.header['Allow']
     end
   end
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: pendragon
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - namusyaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-15 00:00:00.000000000 Z
+date: 2014-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.3.0
 - !ruby/object:Gem::Dependency
@@ -42,56 +42,56 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.8.7
 - !ruby/object:Gem::Dependency
   name: rack-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.10.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: haml
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -114,7 +114,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .travis.yml
+- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - README.md
@@ -137,6 +137,7 @@ files:
 - test/compile_helper.rb
 - test/helper.rb
 - test/padrino_test.rb
+- test/pendragon_configuration.rb
 - test/pendragon_test.rb
 homepage: https://github.com/namusyaka/pendragon
 licenses:
@@ -148,17 +149,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Provides an HTTP router for use in Rack and Padrino.