pendragon 0.6.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 914465eff1ee8117a07da6fd8f8e9619885003d2
-  data.tar.gz: dec0c29b856f107c142018b068e978012de160c9
+  metadata.gz: cd0edab5d92da0e54a220b00f8f7d494b4db1e3b
+  data.tar.gz: 543fc628f35ff975c0a24812ea09a3fa6d21c8b1
 SHA512:
-  metadata.gz: 9defb1e67cef1b199bc9b556467a17c56e9fa94a97421a5fbcc6b519fd9039d4ba55e9f9d02f7c2bb4ead6a1cb954e12052fbc59c7697b5a59db52e72691da68
-  data.tar.gz: 97473aaab4ccbfbbc7e8ab6147935107c45fd9852463abe53a8285f3e1bbccc32163298fee0c6e97060aa0377d67f42d80f428585a1f8b14dc9df874cddfb699
+  metadata.gz: 2bc2a1c2b90272591d3b1c3c1447f2f1502636ac741406bb3b2fa3ae2e106fae188876147e4235857a7f9ff6b5cbe900b3da9f561bc6d65fc5f695b9c117add6
+  data.tar.gz: d65be58e80f6ba365a8d11a5523426e83bca18929417874e199a072e13c1509bba27720e9e9775cd9314cf9db8f00aa111b090a077743b0ab153e3725b358015

data/.travis.yml

@@ -4,8 +4,10 @@ install:
   - gem update --system
   - bundle update
 rvm:
-  - 2.0.0
-  - 2.1.0
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0-preview3
   - jruby
   - rbx
 notifications:

data/Gemfile

@@ -1,3 +1,10 @@
 source 'https://rubygems.org'
 
+gem 'rake'
+gem 'rack-test'
+gem 'test-unit'
+gem 'mocha'
+gem 'sinatra'
+gem 'yard'
+gem 'modulla'
 gemspec

data/Gemfile.lock

@@ -1,104 +1,48 @@
 PATH
   remote: .
   specs:
-    pendragon (0.6.1)
-      mustermann19 (~> 0.3.0)
+    pendragon (0.6.2)
+      mustermann
       rack (>= 1.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (4.1.6)
-      i18n (~> 0.6, >= 0.6.9)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.1)
-      tzinfo (~> 1.1)
-    enumerable-lazy (0.0.1)
-    haml (4.0.5)
-      tilt
-    http_router (0.11.1)
-      rack (>= 1.0.0)
-      url_mount (~> 0.2.1)
-    i18n (0.6.11)
-    json (1.8.1)
-    json (1.8.1-java)
-    mail (2.5.4)
-      mime-types (~> 1.16)
-      treetop (~> 1.4.8)
     metaclass (0.0.4)
-    mime-types (1.25.1)
-    minitest (5.4.2)
     mocha (1.1.0)
       metaclass (~> 0.0.1)
-    moneta (0.7.20)
-    mustermann19 (0.3.1)
-      enumerable-lazy
-    padrino (0.12.4)
-      padrino-admin (= 0.12.4)
-      padrino-cache (= 0.12.4)
-      padrino-core (= 0.12.4)
-      padrino-gen (= 0.12.4)
-      padrino-helpers (= 0.12.4)
-      padrino-mailer (= 0.12.4)
-      padrino-support (= 0.12.4)
-    padrino-admin (0.12.4)
-      padrino-core (= 0.12.4)
-      padrino-helpers (= 0.12.4)
-    padrino-cache (0.12.4)
-      moneta (~> 0.7.0)
-      padrino-core (= 0.12.4)
-      padrino-helpers (= 0.12.4)
-    padrino-core (0.12.4)
-      activesupport (>= 3.1)
-      http_router (~> 0.11.0)
-      padrino-support (= 0.12.4)
-      rack-protection (>= 1.5.0)
-      sinatra (~> 1.4.2)
-      thor (~> 0.18)
-    padrino-gen (0.12.4)
-      bundler (~> 1.0)
-      padrino-core (= 0.12.4)
-    padrino-helpers (0.12.4)
-      i18n (~> 0.6, >= 0.6.7)
-      padrino-support (= 0.12.4)
-      tilt (~> 1.4.1)
-    padrino-mailer (0.12.4)
-      mail (~> 2.5.3)
-      padrino-core (= 0.12.4)
-    padrino-support (0.12.4)
-      activesupport (>= 3.1)
-    polyglot (0.3.5)
-    rack (1.5.2)
+    modulla (0.1.1)
+    mustermann (0.4.0)
+      tool (~> 0.2)
+    power_assert (0.3.0)
+    rack (1.5.5)
     rack-protection (1.5.3)
       rack
-    rack-test (0.6.2)
+    rack-test (0.6.3)
       rack (>= 1.0)
-    rake (10.3.2)
-    sinatra (1.4.5)
-      rack (~> 1.4)
+    rake (11.3.0)
+    sinatra (1.4.7)
+      rack (~> 1.5)
       rack-protection (~> 1.4)
-      tilt (~> 1.3, >= 1.3.4)
-    thor (0.19.1)
-    thread_safe (0.3.4)
-    thread_safe (0.3.4-java)
-    tilt (1.4.1)
-    treetop (1.4.15)
-      polyglot
-      polyglot (>= 0.3.1)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-    url_mount (0.2.1)
-      rack
+      tilt (>= 1.3, < 3)
+    test-unit (3.2.1)
+      power_assert
+    tilt (2.0.5)
+    tool (0.2.3)
+    yard (0.9.5)
 
 PLATFORMS
-  java
   ruby
 
 DEPENDENCIES
-  haml
-  mocha (>= 0.10.0)
-  padrino (~> 0.12.2)
+  mocha
+  modulla
   pendragon!
-  rack-test (>= 0.5.0)
-  rake (>= 0.8.7)
+  rack-test
+  rake
+  sinatra
+  test-unit
+  yard
+
+BUNDLED WITH
+   1.12.5

data/README.md

@@ -2,268 +2,145 @@
 
 [![Build Status](https://travis-ci.org/namusyaka/pendragon.svg?branch=master)](https://travis-ci.org/namusyaka/pendragon) [![Gem Version](https://badge.fury.io/rb/pendragon.svg)](http://badge.fury.io/rb/pendragon)
 
-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 provides an HTTP router and its toolkit for use in Rack. As a Rack application, it makes it easy to define complicated routing. 
+Algorithms of the router are used in [Padrino](https://github.com/padrino/padrino-framework) and [Grape](https://github.com/ruby-grape/grape), it's fast, flexible and robust.
+
+*If you want to use in Ruby-1.9, you can do it by using [mustermann19](https://github.com/namusyaka/mustermann19).*
 
-*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]}"
+  get('/') { [200, {}, ['hello world']] }
+  namespace :users do
+    get('/',    to: -> { [200, {}, ['User page index']] })
+    get('/:id', to: -> (id) { [200, {}, [id]] })
+    get('/:id/comments') { |id| [200, {}, [User.find_by(id: id).comments.to_json]] }
   end
 end
 ```
 
-## Installation
-
-Depends on [rack](https://github.com/rack/rack) and [mustermann](https://github.com/rkh/mustermann).
+## Router Patterns
 
-`gem install pendragon`
-
-## Usage
+|Type  |Description  |Note  |
+|---|---|---|
+|[liner](https://github.com/namusyaka/pendragon/blob/master/lib/pendragon/liner.rb)  |Linear search, Optimized Mustermann patterns | |
+|[realism](https://github.com/namusyaka/pendragon/blob/master/lib/pendragon/realism.rb)  |First route is detected by union regexps (Actually, O(1) in ruby level), routes since the first time will be retected by linear search | this algorithm is using in Grape |
+|[radix](https://github.com/namusyaka/pendragon-radix)  |Radix Tree, not using Mustermann and regexp| requires C++11 |
 
-### 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.|
-|lock            |boolean|false|If you enable this option, all requests to synchronize on a mutex lock|
+## Installation
 
-#### `enable_compiler`
+Add this line to your application's Gemfile:
 
 ```ruby
-# Performance will be improved!
-Pendragon.new do |config|
-  config.enable_compiler = true
-end
+gem 'pendragon'
 ```
 
-*The compiler mode was inspired by [rack-multiplexer](https://github.com/r7kamura/rack-multiplexer). Thank you!*
+And then execute:
 
-#### `auto_rack_format`
+    $ bundle
 
-```ruby
-# Enable the param (default)
-Pendragon.new do
-  get("/"){ "hey" }
-end
+Or install it yourself as:
 
-pendragon = Pendragon.new do |config|
-  config.auto_rack_format = false
-end
-# Disable the param
-pendragon.get("/"){ [200, {"Content-Type" => "text/html;charset=utf-8"}, ["hey"]] }
-```
+    $ gem install pendragon
 
-#### `lock`
 
-```ruby
-pendragon = Pendragon.new do |config|
-  config.lock = true
-end
-```
+## Usage
 
-If you use pendragon in threaded environment, you should enable this option to avoid compiling all routes again and again.
+### Selects router pattern
 
-#### Deprecated
+You can select router pattern as following code.
 
 ```ruby
-# Global configuration style is deprecated since 0.5.0
-Pendragon.configure do |config|
-  config.enable_compiler = true
-end
+# Gets Linear router class by passing type in `Pendragon.[]`
+Pendragon[:linear] #=> Pendragon::Linear
 
-# Please use new syntax.
-pendragon = Pendragon.new do |config|
-  config.enable_compiler = true
-end
+# Specify :type to construction of Pendragon.
+Pendragon.new(type: :linear) { ... }
 ```
 
-### Register a route
+### Registers a route
 
 It has some methods to register a route. For example, `#get`, `#post` and `#delete` are so.
 This section introduces all those methods.
 
-#### `add(verb, path, option, &block)`
+#### `route(method, path, **options, &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" }
+  route('GET', ?/){ [200, {}, ['hello']] }
 end
 ```
 
-#### `get(path, option, &block)`, `post`, `delete`, `put` and `head`
+#### `get(path, **options, &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.
+Basically the usage is the same with `#route`.
+You may as well use those methods instead of `#route` because those methods are easy to understand.
 
 ```ruby
 Pendragon.new do
-  get("/"){ "hello world" }
-  post("/"){ "hello world" }
-  delete("/"){ "hello world" }
-  put("/"){ "hello world" }
-  head("/"){ "hello world" }
+  get   (?/) { [200, {}, ['hello']] }
+  post  (?/) { [200, {}, ['hello']] }
+  delete(?/) { [200, {}, ['hello']] }
+  put   (?/) { [200, {}, ['hello']] }
+  head  (?/) { [200, {}, ['hello']] }
 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
-
-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
-
-request = Rack::MockRequest.env_for("/123/hey/ho")
-pendragon.recognize(request).first.call #=> '{id: "123", foo: "hey", bar: "ho"}'
-```
-
-### Recognize the route
-
-The route registered can be recognized by several methods.
-
-#### `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`.
+### Mounts Rack Application
 
-```ruby
-pendragon = Pendragon.new
-index = pendragon.get("/"){ "hello world" }
-foo   = pendragon.get("/foo/:bar"){ "foo is bar" }
-
-mock_request = Rack::MockRequest.env_for("/")
-route, params = pendragon.recognize(mock_request).first
-
-route.path == index.path #=> true
-params #=> {}
+You can easily mount your rack application onto Pendragon.
 
-mock_request = Rack::MockRequest.env_for("/foo/baz")
-route, params = pendragon.recognize(mock_request).first
-
-route.path == foo.path #=> true
-params #=> {bar: "baz"}
-```
-
-#### `recognize_path(path_info)`
-
-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.
+*Please note that pendragon distinguishes between processing Proc and Rack Application.*
 
 ```ruby
-pendragon = Pendragon.new do
-  get("/", name: :index){ "hello world" }
-  get("/:id", name: :foo){ "fooooo" }
+class RackApp
+  def call(env)
+    puts env #=> rack default env
+    [200, {}, ['hello']]
+  end
 end
 
-pendragon.recognize_path("/") #=> [:index, {}]
-pendragon.recognize_path("/hey") #=> [:foo, {id: "hey"}]
-```
-
-#### `path(name, *args)`
-
-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.
-
-```ruby
-pendragon = Pendragon.new do
-  get("/", name: :index){ "hello world" }
-  get("/:id", name: :foo){ "fooooo" }
+Pendragon.new do
+  get '/ids/:id', to: -> (id) { p id } # Block parameters are available
+  get '/rack/:id', to: RackApp.new # RackApp#call will be called, `id` is not passed and `env` is passed instead.
 end
-
-pendragon.path(:index) #=> "/"
-pendragon.path(:foo, id: "123") #=> "/123"
-pendragon.path(:foo, id: "123", bar: "hey") #=> "/123?bar=hey"
 ```
 
-### Prioritized Routes
+### Halt
 
-Pendragon supports for respecting route order.
-If you want to use this, you should pass the `:order` option to the registration method.
+You can halt to processing by calling `throw :halt` inside your route.
 
 ```ruby
-pendragon = Pendragon.new do
-  get("/", order: 1){ "two" }
-  get("/", order: 0){ "one" }
-  get("/", order: 2){ "three" }
+Pendragon.new do
+  get ?/ do
+    throw :halt, [404, {}, ['not found']]
+    [200, {}, ['failed to halt']]
+  end
 end
-
-request = Rack::MockRequest.env_for("/")
-pendragon.recognize(request).map{|route, _| route.call } #=> ["one", "two", "three"]
 ```
 
-### Passing
+### Cascading
 
-A route can punt processing to the next matching route using `throw :pass`
+A route can punt to the next matching route by using `X-Cascade` header.
 
 ```ruby
 pendragon = Pendragon.new do
-  foo = nil
-  get("/"){ foo = "yay"; throw :pass }
-  get("/"){ foo }
-end
-
-request = Rack::MockRequest.env_for("/")
-pendragon.call(request) #=> [200, {"Content-Type"=>"text/html;charset=utf-8"}, ["yay"]]
-```
-
-### With Padrino
-
-Add `register Pendragon::Padrino` to your padrino application.
-Of course, Pendragon has compatibility with Padrino Routing.
-
-
-```ruby
-require 'pendragon/padrino'
-
-class App < Padrino::Application
-  register Pendragon::Padrino
-
-  # Also, your app's performance will be improved by using compiler mode.
-  set :pendragon, enable_compiler: true
-
-  get :index do
-    "hello pendragon!"
-  end
-
-  get :users, :map => "/users/:user_id/", :user_id => /\d+/ do |user_id|
-    params.inspect
+  foo = 1
+  get ?/ do
+    [200, { 'X-Cascade' => 'pass' }, ['']]
   end
 
-  get :user_items, :map => "/users/:user_id/:item_id", :user_id => /\d+/, :item_id => /[1-9]+/ do |user_id, item_id|
-    "Show #{user_id} and #{item_id}"
+  get ?/ do
+    [200, {}, ['goal!']]
   end
 end
+
+env = Rack::MockRequest.env_for(?/)
+pendragon.call(env) #=> [200, {}, ['goal!']]
 ```
 
 ## Contributing