rack-jet_router 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a998880ec075549282c7341aa711e2a9955ac330
-  data.tar.gz: a8792a73ca113ae0710654a2ccde67556719ba37
+  metadata.gz: da49b22574962dc8935525feba719fd735003f43
+  data.tar.gz: 9fa472683f55e9b366cc46b5f4f984295dffdf66
 SHA512:
-  metadata.gz: db17dd3ebcf17be118fec1b96b38f95ac7ac5f13266811f43df417ac36ec98f9e6ca2bbab9272c0f302dc164846796464f7171c1fc5f83826acafc6e54cf50cb
-  data.tar.gz: 07a8f384854139e73fb1bfca49b6ff1ad81dcf03cff5276baa86ad39a6e39558706837f98098cd8c0ba8636458f17081c49ca1ae41cb2da809d1fe7082bb3819
+  metadata.gz: c0e12966a998ba92c5c9edbeefa549ba2985650a2d4a164c5e0c0a23487b6622695cb4beab2c55af60e8269f579a97dcb84150386d1e972a1cd9b7aefaa1c75f
+  data.tar.gz: 6dfec9e6f75093ce20bdaefdd3ddac9dbd27fd5f5711f64d9bd44982bb7e58337d09604f552828d2ac76888cc5d545e0859701e64f3ce12d6d1eb1df820e8ef1

data/README.md

@@ -1,32 +1,59 @@
 # Rack::JetRouter
 
+($Release: 0.0.0 $)
+
 Rack::JetRouter is crazy-fast router library for Rack application,
 derived from [Keight.rb](https://github.com/kwatch/keight/tree/ruby).
 
+Rack::JetRouter requires Ruby >= 2.0.
+
 
 ## Benchmark
 
 Benchmark script is [here](https://github.com/kwatch/rack-jet_router/blob/dev/bench/bench.rb).
 
+### JetRouter vs. Rack vs. Sinatra vs. Keight.rb:
+
 ```
-## Ranking                        usec/req
-(Rack plain)  /api/hello             1.555 (100.0%) ********************
-(JetRouter)   /api/hello             1.597 ( 97.4%) *******************
-(JetRouter)   /api/hello/123         6.424 ( 24.2%) *****
-(R::Req+Res)  /api/hello             9.837 ( 15.8%) ***
-(Sinatra)     /api/hello           106.965 (  1.5%)
-(Sinatra)     /api/hello/123       116.672 (  1.3%)
+## Ranking                         usec/req  Graph (longer=faster)
+(Rack plain)  /api/aaa01             1.0619  ***************
+(Rack plain)  /api/aaa01/123         0.8729  ******************
+(R::Req+Res)  /api/aaa01             9.5361  **
+(R::Req+Res)  /api/aaa01/123         9.5321  **
+(JetRouter)   /api/aaa01             1.3231  ************
+(JetRouter)   /api/aaa01/123         5.9796  ***
+(Keight.rb)   /api/aaa01             6.4314  **
+(Keight.rb)   /api/aaa01/123        10.2339  **
+(Sinatra)     /api/aaa01           104.7575
+(Sinatra)     /api/aaa01/123       115.8220
 ```
 
 * If URL path has no path parameter (such as `/api/hello`),
-  Rack::JetRouter is just a litte slower than plain Rack application.
+  Rack::JetRouter is a litte shower than plain Rack application.
 * If URL path contains path parameter (such as `/api/hello/:id`),
-  Rack::JetRouter becomes slower, but it is enough small (about 6.4ns/req).
-* Overhead of Rack::JetRouter is smaller than that of Rack::Reqeust +
+  Rack::JetRouter becomes slower, but it is enough small (about 6usec/req).
+* Overhead of Rack::JetRouter is smaller than that of Rack::Reqeuast +
   Rack::Response.
 * Sinatra is too slow.
 
 
+### JetRouter vs. Rack::Multiplexer:
+
+```
+## Ranking                         usec/req  Graph (longer=faster)
+(JetRouter)   /api/aaa01             1.3231  ************
+(JetRouter)   /api/aaa01/123         5.9796  ***
+(JetRouter)   /api/zzz26             1.4089  ***********
+(JetRouter)   /api/zzz26/789         6.5142  **
+(Multiplexer) /api/aaa01             5.9073  ***
+(Multiplexer) /api/aaa01/123        18.2102  *
+(Multiplexer) /api/zzz26            24.4013  *
+(Multiplexer) /api/zzz26/789        36.1558
+```
+
+* JetRouter is about 3~5 times faster than Rack::Multiplexer.
+
+
 ## Examples
 
 ### #1: Depends only on Request Path
@@ -38,7 +65,7 @@ require 'rack'
 require 'rack/jet_router'
 
 ## Assume that welcome_app, books_api, ... are Rack application.
-urlpath_mapping = [
+mapping = [
     ['/'                       , welcome_app],
     ['/api', [
         ['/books', [
@@ -52,9 +79,9 @@ urlpath_mapping = [
     ]],
 ]
 
-router = Rack::JetRouter.new(urlpath_mapping)
-p router.find('/api/books/123.html')
-    #=> [book_api, {"id"=>"123", "format"=>"html"}]
+router = Rack::JetRouter.new(mapping)
+p router.lookup('/api/books/123.json')
+    #=> [book_api, {"id"=>"123", "format"=>"json"}]
 
 status, headers, body = router.call(env)
 ```
@@ -69,7 +96,7 @@ require 'rack'
 require 'rack/jet_router'
 
 ## Assume that welcome_app, book_list_api, ... are Rack application.
-urlpath_mapping = [
+mapping = [
     ['/'                       , {GET: welcome_app}],
     ['/api', [
         ['/books', [
@@ -83,8 +110,8 @@ urlpath_mapping = [
     ]],
 ]
 
-router = Rack::JetRouter.new(urlpath_mapping)
-p router.find('/api/books/123')
+router = Rack::JetRouter.new(mapping)
+p router.lookup('/api/books/123')
     #=> [{"GET"=>book_show_api, "PUT"=>book_update_api}, {"id"=>"123", "format"=>nil}]
 
 status, headers, body = router.call(env)
@@ -118,7 +145,7 @@ class BooksAPI < API
   def delete(id: nil); ....; end
 end
 
-urlpath_mapping = [
+mapping = [
     ['/api', [
         ['/books', [
             [''      , {GET:    [BooksAPI, :index],
@@ -129,11 +156,10 @@ urlpath_mapping = [
         ]],
     ]],
 ]
-router = Rack::JetRouter.new(urlpath_mapping)
-p router.find('/api/books/123')
-    #=> [{"GET"=>[BooksAPI, :show], "PUT"=>..., "DELETE"=>...}, {"id"=>"123"}]
-
-dict, args = router.find('/api/books/123')
+router = Rack::JetRouter.new(mapping)
+dict, args = router.lookup('/api/books/123')
+p dict   #=> {"GET"=>[BooksAPI, :show], "PUT"=>[...], "DELETE"=>[...]}
+p args   #=> {"id"=>"123"}
 klass, action = dict["GET"]
 handler = klass.new(Rack::Request.new(env), Rack::Response.new)
 handler.__send__(action, args)
@@ -145,8 +171,8 @@ handler.__send__(action, args)
 
 ### URL Path Parameters
 
-URL path parameters (such as `{"id"=>"123"}`) is available via
-`env['rack.urlpath_params']`.
+In Rack application, URL path parameters (such as `{"id"=>"123"}`) are
+available via `env['rack.urlpath_params']`.
 
 ```ruby
 BookApp = proc {|env|
@@ -175,7 +201,7 @@ end
 
 ### Variable URL Path Cache
 
-It is possible to classify URL path patterns into two types: fixed and variable.
+It is useful to classify URL path patterns into two types: fixed and variable.
 
 * **Fixed URL path pattern** doesn't contain any urlpath paramters.<br>
   Example: `/`, `/login`, `/api/books`
@@ -189,7 +215,7 @@ as well as fixed ones. It will make routing much faster.
 ```ruby
 ## Enable variable urlpath cache.
 router = Rack::JetRouter.new(urlpath_mapping, urlpath_cache_size: 200)
-p router.find('/api/books/123')   # caches even varaible urlpath
+p router.lookup('/api/books/123')   # caches even varaible urlpath
 ```
 
 
@@ -226,6 +252,16 @@ $License: MIT License $
 ## History
 
 
+### 2015-12-28: Release 1.1.0
+
+* **NOTICE** `Rack::JetRouter#find()` is renamed to `#lookup()`.<br>
+  `#find()` is also available for compatibility, but not recommended.
+* Performance improved when number of URL path parameter is 1.
+* Regular expression generated is improved.
+* Benchmark script is improved to take some command-line options.
+* Document fixed.
+
+
 ### 2015-12-06: Release 1.0.1
 
 * Fix document

data/lib/rack/jet_router.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 1.0.1 $
+### $Release: 1.1.0 $
 ### $Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###
@@ -30,7 +30,7 @@ module Rack
   ##       ]],
   ##   ]
   ##   router = Rack::JetRouter.new(urlpath_mapping)
-  ##   router.find('/api/books/123.html')
+  ##   router.lookup('/api/books/123.html')
   ##       #=> [book_api, {"id"=>"123", "format"=>"html"}]
   ##   status, headers, body = router.call(env)
   ##
@@ -49,13 +49,17 @@ module Rack
   ##       ]],
   ##   ]
   ##   router = Rack::JetRouter.new(urlpath_mapping)
-  ##   router.find('/api/books/123')
+  ##   router.lookup('/api/books/123')
   ##       #=> [{"GET"=>book_show_api, "PUT"=>book_update_api}, {"id"=>"123", "format"=>nil}]
   ##   status, headers, body = router.call(env)
   ##
   class JetRouter
 
-    def initialize(mapping, urlpath_cache_size: 0)
+    RELEASE = '$Release: 1.1.0 $'.split()[1]
+
+    def initialize(mapping, urlpath_cache_size: 0,
+                            enable_urlpath_param_range: true)
+      @enable_urlpath_param_range = enable_urlpath_param_range
       #; [!u2ff4] compiles urlpath mapping.
       (@urlpath_rexp,          # ex: {'/api/books'=>BooksApp}
        @fixed_urlpath_dict,    # ex: [[%r'\A/api/books/([^./]+)\z', ['id'], BookApp]]
@@ -70,12 +74,12 @@ module Rack
     def call(env)
       #; [!fpw8x] finds mapped app according to env['PATH_INFO'].
       req_path = env['PATH_INFO']
-      app, urlpath_params = find(req_path)
+      app, urlpath_params = lookup(req_path)
       #; [!wxt2g] guesses correct urlpath and redirects to it automaticaly when request path not found.
       #; [!3vsua] doesn't redict automatically when request path is '/'.
       unless app || req_path == '/'
         location = req_path =~ /\/\z/ ? req_path[0..-2] : req_path + '/'
-        app, urlpath_params = find(location)
+        app, urlpath_params = lookup(location)
         return redirect_to(location) if app
       end
       #; [!30x0k] returns 404 when request urlpath not found.
@@ -100,8 +104,8 @@ module Rack
     ## Finds app or Hash mapped to request path.
     ##
     ## ex:
-    ##    find('/api/books/123')   #=> [BookApp, {"id"=>"123"}]
-    def find(req_path)
+    ##    lookup('/api/books/123')   #=> [BookApp, {"id"=>"123"}]
+    def lookup(req_path)
       #; [!24khb] finds in fixed urlpaths at first.
       #; [!iwyzd] urlpath param value is nil when found in fixed urlpaths.
       obj = @fixed_urlpath_dict[req_path]
@@ -119,9 +123,15 @@ module Rack
       index = m.captures.find_index('')
       return nil unless index
       #; [!ijqws] returns mapped object and urlpath parameter values when urlpath found.
-      full_urlpath_rexp, param_names, obj = @variable_urlpath_list[index]
-      m = full_urlpath_rexp.match(req_path)
-      param_values = m.captures
+      full_urlpath_rexp, param_names, obj, range = @variable_urlpath_list[index]
+      if range
+        ## "/books/123"[7..-1] is faster than /\A\/books\/(\d+)\z/.match("/books/123")
+        str = req_path[range]
+        param_values = [str]
+      else
+        m = full_urlpath_rexp.match(req_path)
+        param_values = m.captures
+      end
       vars = build_urlpath_parameter_vars(param_names, param_values)
       #; [!84inr] caches result when variable urlpath cache enabled.
       if cache
@@ -131,6 +141,8 @@ module Rack
       return obj, vars
     end
 
+    alias find lookup      # :nodoc:      # for backward compatilibity
+
     protected
 
     ## Returns [404, {...}, [...]]. Override in subclass if necessary.
@@ -177,10 +189,10 @@ module Rack
     ## Compiles urlpath mapping. Called from '#initialize()'.
     def compile_mapping(mapping)
       rexp_buf          = ['\A']
-      prefix_pat        = ''
       fixed_urlpaths    = {}  # ex: {'/api/books'=>BooksApp}
       variable_urlpaths = []  # ex: [[%r'\A/api/books/([^./]+)\z', ['id'], BookApp]]
-      _compile_mapping(mapping, rexp_buf, prefix_pat, fixed_urlpaths, variable_urlpaths)
+      _compile_array(mapping, rexp_buf, '', '',
+                      fixed_urlpaths, variable_urlpaths)
       ## ex: %r'\A(?:/api(?:/books(?:/[^./]+(\z)|/[^./]+/edit(\z))))\z'
       rexp_buf << '\z'
       urlpath_rexp = Regexp.new(rexp_buf.join())
@@ -188,57 +200,67 @@ module Rack
       return urlpath_rexp, fixed_urlpaths, variable_urlpaths
     end
 
-    def _compile_mapping(mapping, rexp_buf, prefix_pat, fixed_dict, variable_list)
-      param_pat1 = '[^./]+'
-      param_pat2 = '([^./]+)'
+    def _compile_array(mapping, rexp_buf, base_urlpath_pat, urlpath_pat,
+                       fixed_dict, variable_list)
+      rexp_str, _ = compile_urlpath_pattern(urlpath_pat, false)
+      rexp_buf << rexp_str
       rexp_buf << '(?:'
       len = rexp_buf.length
-      mapping.each do |urlpath_pat, obj|
+      mapping.each do |child_urlpath_pat, obj|
         rexp_buf << '|' if rexp_buf.length != len
-        full_urlpath_pat = "#{prefix_pat}#{urlpath_pat}"
+        curr_urlpath_pat = "#{base_urlpath_pat}#{urlpath_pat}"
         #; [!ospaf] accepts nested mapping.
         if obj.is_a?(Array)
-          rexp_str, _ = compile_urlpath_pattern(urlpath_pat, param_pat1)
-          rexp_buf << rexp_str
-          len2 = rexp_buf.length
-          _compile_mapping(obj, rexp_buf, full_urlpath_pat, fixed_dict, variable_list)
-          #; [!pv2au] deletes unnecessary urlpath regexp.
-          if rexp_buf.length == len2
-            x = rexp_buf.pop()
-            x == rexp_str  or raise "assertion failed"
-          end
+          _compile_array(obj, rexp_buf, curr_urlpath_pat, child_urlpath_pat,
+                         fixed_dict, variable_list)
         #; [!2ktpf] handles end-point.
         else
-          #; [!guhdc] if mapping dict is specified...
-          if obj.is_a?(Hash)
-            obj = normalize_mapping_keys(obj)
-          end
-          #; [!l63vu] handles urlpath pattern as fixed when no urlpath params.
-          full_urlpath_rexp_str, param_names = compile_urlpath_pattern(full_urlpath_pat, param_pat2)
-          fixed_pattern = param_names.nil?
-          if fixed_pattern
-            fixed_dict[full_urlpath_pat] = obj
-          #; [!vfytw] handles urlpath pattern as variable when urlpath param exists.
-          else
-            rexp_str, _ = compile_urlpath_pattern(urlpath_pat, param_pat1)
-            rexp_buf << rexp_str << '(\z)'
-            full_urlpath_rexp = Regexp.new("\\A#{full_urlpath_rexp_str}\\z")
-            variable_list << [full_urlpath_rexp, param_names, obj]
-          end
+          _compile_object(obj, rexp_buf, curr_urlpath_pat, child_urlpath_pat,
+                          fixed_dict, variable_list)
         end
       end
       #; [!gfxgr] deletes unnecessary grouping.
       if rexp_buf.length == len
         x = rexp_buf.pop()    # delete '(?:'
         x == '(?:'  or raise "assertion failed"
+        #; [!pv2au] deletes unnecessary urlpath regexp.
+        x = rexp_buf.pop()    # delete rexp_str
+        x == rexp_str  or raise "assertion failed"
+      #; [!bh9lo] deletes unnecessary grouping which contains only an element.
+      elsif rexp_buf.length == len + 1
+        rexp_buf[-2] == '(?:'  or raise "assertion failed: rexp_buf[-2]=#{rexp_buf[-2].inspect}"
+        rexp_buf[-2] = ''
       else
         rexp_buf << ')'
       end
     end
 
+    def _compile_object(obj, rexp_buf, base_urlpath_pat, urlpath_pat,
+                        fixed_dict, variable_list)
+      #; [!guhdc] if mapping dict is specified...
+      if obj.is_a?(Hash)
+        obj = normalize_mapping_keys(obj)
+      end
+      #; [!l63vu] handles urlpath pattern as fixed when no urlpath params.
+      full_urlpath_pat = "#{base_urlpath_pat}#{urlpath_pat}"
+      full_urlpath_rexp_str, param_names = compile_urlpath_pattern(full_urlpath_pat, true)
+      fixed_pattern = param_names.nil?
+      if fixed_pattern
+        fixed_dict[full_urlpath_pat] = obj
+      #; [!vfytw] handles urlpath pattern as variable when urlpath param exists.
+      else
+        rexp_str, _ = compile_urlpath_pattern(urlpath_pat, false)
+        rexp_buf << (rexp_str << '(\z)')
+        full_urlpath_rexp = Regexp.new("\\A#{full_urlpath_rexp_str}\\z")
+        range = @enable_urlpath_param_range ? range_of_urlpath_param(full_urlpath_pat) : nil
+        variable_list << [full_urlpath_rexp, param_names, obj, range]
+      end
+    end
+
     ## Compiles '/books/:id' into ['/books/([^./]+)', ["id"]].
-    def compile_urlpath_pattern(urlpath_pat, param_pat='([^./]+)')
+    def compile_urlpath_pattern(urlpath_pat, enable_capture=true)
       s = "".dup()
+      param_pat = enable_capture ? '([^./]+)' : '[^./]+'
       param_names = []
       pos = 0
       urlpath_pat.scan(/:(\w+)|\((.*?)\)/) do |name, optional|
@@ -275,6 +297,16 @@ module Rack
       end
     end
 
+    def range_of_urlpath_param(urlpath_pattern)      # ex: '/books/:id/edit'
+      #; [!syrdh] returns Range object when urlpath_pattern contains just one param.
+      #; [!skh4z] returns nil when urlpath_pattern contains more than two params.
+      #; [!acj5b] returns nil when urlpath_pattern contains no params.
+      rexp = /:\w+|\(.*?\)/
+      arr = urlpath_pattern.split(rexp, -1)          # ex: ['/books/', '/edit']
+      return nil unless arr.length == 2
+      return (arr[0].length .. -(arr[1].length+1))   # ex: 7..-6  (Range object)
+    end
+
     def normalize_mapping_keys(dict)
       #; [!r7cmk] converts keys into string.
       #; [!z9kww] allows 'ANY' as request method.

data/rack-jet_router.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "rack-jet_router"
-  spec.version       = '$Release: 1.0.1 $'.split()[1]
+  spec.version       = '$Release: 1.1.0 $'.split()[1]
   spec.authors       = ["makoto kuwata"]
   spec.email         = ["kwa(at)kuwata-lab.com"]
 

data/test/rack/jet_router_test.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 1.0.1 $
+### $Release: 1.1.0 $
 ### $Copyright: copyright(c) 2015 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###
@@ -64,6 +64,35 @@ describe Rack::JetRouter do
   end
 
 
+  describe '#range_of_urlpath_param()' do
+
+    it "[!syrdh] returns Range object when urlpath_pattern contains just one param." do
+      jet_router.instance_exec(self) do |_|
+        r1 = range_of_urlpath_param('/books/:id')
+        _.ok {r1} == (7..-1)
+        _.ok {'/books/123'[r1]} == '123'
+        r2 = range_of_urlpath_param('/books/:id.html')
+        _.ok {r2} == (7..-6)
+        _.ok {'/books/4567.html'[r2]} == '4567'
+      end
+    end
+
+    it "[!skh4z] returns nil when urlpath_pattern contains more than two params." do
+      jet_router.instance_exec(self) do |_|
+        _.ok {range_of_urlpath_param('/books/:book_id/comments/:comment_id')} == nil
+        _.ok {range_of_urlpath_param('/books/:id(:format)')} == nil
+      end
+    end
+
+    it "[!acj5b] returns nil when urlpath_pattern contains no params." do
+      jet_router.instance_exec(self) do |_|
+        _.ok {range_of_urlpath_param('/books')} == nil
+      end
+    end
+
+  end
+
+
   describe '#compile_urlpath_pattern()' do
 
     it "[!joozm] escapes metachars with backslash in text part." do
@@ -110,9 +139,7 @@ describe Rack::JetRouter do
       ]
       expected = '
           \A
-          (?:
               /books/[^./]+(\z)
-          )
           \z
       '.gsub(/\s+/, '')
       jet_router.instance_exec(self) do |_|
@@ -122,7 +149,7 @@ describe Rack::JetRouter do
           '/'                => welcome_app,
         }
         _.ok {list} == [
-          [%r'\A/books/([^./]+)\z',      ['id'], book_show_api],
+          [%r'\A/books/([^./]+)\z',      ['id'], book_show_api, (7..-1)],
         ]
       end
     end
@@ -167,7 +194,7 @@ describe Rack::JetRouter do
               /api
                   (?:
                       /books2
-                          (?:/[^./]+(\z))
+                          /[^./]+(\z)
                   )
           )
           \z
@@ -181,7 +208,36 @@ describe Rack::JetRouter do
           '/api/books/new'   => book_new_api,
         }
         _.ok {list} == [
-          [%r'\A/api/books2/([^./]+)\z',  ['id'], book_show_api],
+          [%r'\A/api/books2/([^./]+)\z',  ['id'], book_show_api, (12..-1)],
+        ]
+      end
+    end
+
+    it "[!bh9lo] deletes unnecessary grouping which contains only an element." do
+      mapping = [
+        ['/api', [
+          ['/books', [
+            ['/:id'        , book_show_api],
+          ]],
+        ]],
+      ]
+      expected = '
+          \A
+          (?:
+              /api
+                  (?:
+                      /books
+                          /[^./]+(\z)
+                  )
+          )
+          \z
+      '.gsub(/\s+/, '')
+      jet_router.instance_exec(self) do |_|
+        rexp, dict, list = compile_mapping(mapping)
+        _.ok {rexp} == Regexp.new(expected)
+        _.ok {dict} == {}
+        _.ok {list} == [
+          [%r'\A/api/books/([^./]+)\z',  ['id'], book_show_api, (11..-1)],
         ]
       end
     end
@@ -211,9 +267,7 @@ describe Rack::JetRouter do
       ]
       expected = '
           \A
-          (?:
               /api/books/[^./]+(\z)
-          )
           \z
       '.gsub(/\s+/, '')
       jet_router.instance_exec(self) do |_|
@@ -222,7 +276,7 @@ describe Rack::JetRouter do
         _.ok {dict} == {
         }
         _.ok {list} == [
-          [%r'\A/api/books/([^./]+)\z',  ['id'], book_show_api],
+          [%r'\A/api/books/([^./]+)\z',  ['id'], book_show_api, (11..-1)],
         ]
       end
     end
@@ -235,9 +289,7 @@ describe Rack::JetRouter do
       ]
       expected = '
           \A
-          (?:
               /api/books/[^./]+(\z)
-          )
           \z
       '.gsub(/\s+/, '')
       jet_router.instance_exec(self) do |_|
@@ -248,7 +300,7 @@ describe Rack::JetRouter do
           '/api/books'       => book_list_api,
         }
         _.ok {list} == [
-          [%r'\A/api/books/([^./]+)\z',  ['id'], book_show_api],
+          [%r'\A/api/books/([^./]+)\z',  ['id'], book_show_api, (11..-1)],
         ]
       end
     end
@@ -272,7 +324,7 @@ describe Rack::JetRouter do
                       /api
                           (?:
                               /books
-                                  (?:/[^./]+(\z))
+                                  /[^./]+(\z)
                           )
                   )
           )
@@ -285,7 +337,7 @@ describe Rack::JetRouter do
           '/admin/api/books'       => book_list_api,
         }
         _.ok {list} == [
-          [%r'\A/admin/api/books/([^./]+)\z',  ['id'], book_show_api],
+          [%r'\A/admin/api/books/([^./]+)\z',  ['id'], book_show_api, (17..-1)],
         ]
       end
     end
@@ -371,7 +423,7 @@ describe Rack::JetRouter do
             |
                 /admin
                     (?:/books
-                        (?:/[^./]+(\z))
+                        /[^./]+(\z)
                     )
             )
             \z
@@ -388,13 +440,13 @@ describe Rack::JetRouter do
           },
         }
         _.ok {@variable_urlpath_list} == [
-          [%r'\A/api/books/([^./]+)\z',      ['id'], book_show_api],
-          [%r'\A/api/books/([^./]+)/edit\z', ['id'], book_edit_api],
-          [%r'\A/api/books/([^./]+)/comments\z',          ['book_id'], comment_create_api],
-          [%r'\A/api/books/([^./]+)/comments/([^./]+)\z', ['book_id', 'comment_id'], comment_update_api],
+          [%r'\A/api/books/([^./]+)\z',      ['id'], book_show_api, (11..-1)],
+          [%r'\A/api/books/([^./]+)/edit\z', ['id'], book_edit_api, (11..-6)],
+          [%r'\A/api/books/([^./]+)/comments\z',          ['book_id'], comment_create_api, (11..-10)],
+          [%r'\A/api/books/([^./]+)/comments/([^./]+)\z', ['book_id', 'comment_id'], comment_update_api, nil],
           [%r'\A/admin/books/([^./]+)\z',    ['id'], {'GET'    => admin_book_show_app,
                                                       'PUT'    => admin_book_update_app,
-                                                      'DELETE' => admin_book_delete_app}],
+                                                      'DELETE' => admin_book_delete_app}, (13..-1)],
         ]
       end
     end
@@ -402,30 +454,30 @@ describe Rack::JetRouter do
   end
 
 
-  describe '#find()' do
+  describe '#lookup()' do
 
     it "[!ijqws] returns mapped object and urlpath parameter values when urlpath found." do
-      ret = jet_router.find('/api/books/123')
+      ret = jet_router.lookup('/api/books/123')
       ok {ret} == [book_show_api, {"id"=>"123"}]
     end
 
     it "[!vpdzn] returns nil when urlpath not found." do
-      ok {jet_router.find('/api')}        == nil
-      ok {jet_router.find('/api/book')}   == nil
-      ok {jet_router.find('/api/books/')} == nil
+      ok {jet_router.lookup('/api')}        == nil
+      ok {jet_router.lookup('/api/book')}   == nil
+      ok {jet_router.lookup('/api/books/')} == nil
     end
 
     it "[!24khb] finds in fixed urlpaths at first." do
-      ok {jet_router.find('/')}            == [welcome_app, nil]
-      ok {jet_router.find('/api/books')}   == [book_list_api, nil]
+      ok {jet_router.lookup('/')}            == [welcome_app, nil]
+      ok {jet_router.lookup('/api/books')}   == [book_list_api, nil]
       dict = {'GET'=>admin_book_list_app, 'POST'=>admin_book_create_app}
-      ok {jet_router.find('/admin/books')} == [dict, nil]
+      ok {jet_router.lookup('/admin/books')} == [dict, nil]
     end
 
     it "[!iwyzd] urlpath param value is nil when found in fixed urlpaths." do
-      obj, vars = jet_router.find('/')
+      obj, vars = jet_router.lookup('/')
       ok {vars} == nil
-      obj, vars = jet_router.find('/api/books')
+      obj, vars = jet_router.lookup('/api/books')
       ok {vars} == nil
     end
 
@@ -434,14 +486,14 @@ describe Rack::JetRouter do
         ['/api/books/:id', book_show_api],
       ]
       r = Rack::JetRouter.new(mapping, urlpath_cache_size: 3)
-      pair = r.find('/api/books/123')
+      pair = r.lookup('/api/books/123')
       ok {pair} == [book_show_api, {"id"=>"123"}]
       r.instance_exec(self) do |_|
         _.ok {@variable_urlpath_cache} == {'/api/books/123'=>pair}
         #
         @variable_urlpath_cache['/api/books/999'] = [book_list_api, {"ID"=>"111"}]
       end
-      pair = r.find('/api/books/999')
+      pair = r.lookup('/api/books/999')
       ok {pair} == [book_list_api, {"ID"=>"111"}]
     end
 
@@ -451,9 +503,9 @@ describe Rack::JetRouter do
       ]
       r = Rack::JetRouter.new(mapping, urlpath_cache_size: 3)
       #
-      pair1 = r.find('/books/1'); ok {pair1} == [book_show_api, {"id"=>"1"}]
-      pair2 = r.find('/books/2'); ok {pair2} == [book_show_api, {"id"=>"2"}]
-      pair3 = r.find('/books/3'); ok {pair3} == [book_show_api, {"id"=>"3"}]
+      pair1 = r.lookup('/books/1'); ok {pair1} == [book_show_api, {"id"=>"1"}]
+      pair2 = r.lookup('/books/2'); ok {pair2} == [book_show_api, {"id"=>"2"}]
+      pair3 = r.lookup('/books/3'); ok {pair3} == [book_show_api, {"id"=>"3"}]
       r.instance_exec(self) do |_|
         _.ok {@variable_urlpath_cache} == {
           '/books/1'=>pair1,
@@ -462,7 +514,7 @@ describe Rack::JetRouter do
         }
       end
       #
-      pair4 = r.find('/books/4'); ok {pair4} == [book_show_api, {"id"=>"4"}]
+      pair4 = r.lookup('/books/4'); ok {pair4} == [book_show_api, {"id"=>"4"}]
       r.instance_exec(self) do |_|
         _.ok {@variable_urlpath_cache} == {
           '/books/2'=>pair2,
@@ -478,10 +530,10 @@ describe Rack::JetRouter do
       ]
       r = Rack::JetRouter.new(mapping, urlpath_cache_size: 3)
       #
-      pair1 = r.find('/books/1')
-      pair2 = r.find('/books/2')
-      pair3 = r.find('/books/3')
-      pair4 = r.find('/books/4')
+      pair1 = r.lookup('/books/1')
+      pair2 = r.lookup('/books/2')
+      pair3 = r.lookup('/books/3')
+      pair4 = r.lookup('/books/4')
       r.instance_exec(self) do |_|
         _.ok {@variable_urlpath_cache} == {
           '/books/2'=>pair2,
@@ -490,7 +542,7 @@ describe Rack::JetRouter do
         }
       end
       #
-      ok {r.find('/books/3')} == pair3
+      ok {r.lookup('/books/3')} == pair3
       r.instance_exec(self) do |_|
         _.ok {@variable_urlpath_cache} == {
           '/books/2'=>pair2,
@@ -499,7 +551,7 @@ describe Rack::JetRouter do
         }
       end
       #
-      ok {r.find('/books/1')} == pair1
+      ok {r.lookup('/books/1')} == pair1
       r.instance_exec(self) do |_|
         _.ok {@variable_urlpath_cache} == {
           '/books/4'=>pair4,

metadata

@@ -1,72 +1,73 @@
 --- !ruby/object:Gem::Specification
 name: rack-jet_router
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - makoto kuwata
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-06 00:00:00.000000000 Z
+date: 2015-12-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   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
   name: minitest
   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
   name: minitest-ok
   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'
-description: |
-  Super-fast router class for Rack application, derived from Keight.rb.
+description: 'Super-fast router class for Rack application, derived from Keight.rb.
+
+'
 email:
 - kwa(at)kuwata-lab.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
 - MIT-LICENSE
+- README.md
 - Rakefile
-- rack-jet_router.gemspec
 - lib/rack/jet_router.rb
-- test/test_helper.rb
+- rack-jet_router.gemspec
 - test/rack/jet_router_test.rb
+- test/test_helper.rb
 homepage: https://github.com/kwatch/rack-jet_router
 licenses:
 - MIT-License
@@ -77,17 +78,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Super-fast router class for Rack