rack-jet_router 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55c3dc8f5747e61e864ee478f7336d755dc022cb4ebc2f75baeae2b2f1059bd8
-  data.tar.gz: '085324025413ff2d565f6aad7d8fc1827486d9454772f3c745fb1bd3f3d575f3'
+  metadata.gz: 9f8d5e69ec9a40e0698eb97d91f28882b9398f19ec85d2a412a5e79c86efc8fe
+  data.tar.gz: 6d7f33be397ffe163fbe4ac87e050213c7f05fdef37adfc3a1189ccb2861d608
 SHA512:
-  metadata.gz: 357cfa2babfeb364ff8ca485247eed0f1cb9f7a0c5d7c5ff7c907d593d488bb3e365e198cb6eaf89328b7f85c3e349e273793ade17ee1e94822eed139df90bd0
-  data.tar.gz: a6bb2a5d973fa092f356b733ce4ca5f1af335ec53f7d83f9087e0dec271ada489ae80576ba71a4199dd084a6ffc3a25e74e6c29d8e2a1ff0c0e535e2fcf83e8e
+  metadata.gz: 1685c663f0116bb2e6953bdd47f4bfa2976c9fd38b24f12e973b0893d16b307f67a5416fd6e7718650449f4a745a4f3b8cb33ff6d00e1e9c103c211a54cc9f7d
+  data.tar.gz: e0a8e23518ad123315c562f83b393df77caf06f680a349a5bf9303e4e05b0c239a16dd2500752d15c4aa6899c4f0d846753673cadd2b82f0e257ca00ef25c2df

data/CHANGES.md

@@ -2,6 +2,16 @@ CHANGES
 =======
 
 
+Release 1.4.0 (2024-01-02)
+--------------------------
+
+* [enhance] Supports '*file' style path parameter.
+* [enhance] Allows to use mormal Hash object as request method mapping.
+* [enhance] Supports `(.html|.json)` style pattern.
+* [enhance] Treats `/foo(.html|.json)` as three fixed paths `/foo`, `/foo.html` and `/foo.json`. This is much faster than `/foo(.:format)`.
+* [enhance] Rewrite benchmark script.
+
+
 Release 1.3.1 (2023-12-10)
 --------------------------
 

data/README.md

@@ -1,6 +1,6 @@
 # Rack::JetRouter
 
-($Release: 1.3.1 $)
+($Release: 1.4.0 $)
 
 Rack::JetRouter is crazy-fast router library for Rack application,
 derived from [Keight.rb](https://github.com/kwatch/keight/tree/ruby).
@@ -93,30 +93,29 @@ Benchmark script is [here](https://github.com/kwatch/rack-jet_router/blob/releas
 ### #1: Depends only on Request Path
 
 ```ruby
-# -*- coding: utf-8 -*-
-
 require 'rack'
 require 'rack/jet_router'
 
 ## Assume that welcome_app, books_api, ... are Rack application.
-mapping = [
-    ['/'                       , welcome_app],
-    ['/api', [
-        ['/books', [
-            [''                , books_api],
-            ['/:id(.:format)'  , book_api],
-            ['/:book_id/comments/:comment_id', comment_api],
-        ]],
-    ]],
-    ['/admin', [
-        ['/books'              , admin_books_app],
-    ]],
-]
+mapping = {
+    "/"                       => welcome_app,
+    "/api" => {
+        "/books" => {
+            ""                => books_api,
+            "/:id(.:format)"  => book_api,
+            "/:book_id/comments/:comment_id" => comment_api,
+        },
+    },
+    "/admin" => {
+        "/books"              => admin_books_app,
+    },
+}
 
 router = Rack::JetRouter.new(mapping)
 p router.lookup('/api/books/123.json')
     #=> [book_api, {"id"=>"123", "format"=>"json"}]
 
+env = Rack::MockRequest.env_for("/api/books/123.json", method: 'GET')
 status, headers, body = router.call(env)
 ```
 
@@ -124,30 +123,29 @@ status, headers, body = router.call(env)
 ### #2: Depends on both Request Path and Method
 
 ```ruby
-# -*- coding: utf-8 -*-
-
 require 'rack'
 require 'rack/jet_router'
 
 ## Assume that welcome_app, book_list_api, ... are Rack application.
-mapping = [
-    ['/'                       , {GET: welcome_app}],
-    ['/api', [
-        ['/books', [
-            [''                , {GET: book_list_api, POST: book_create_api}],
-            ['/:id(.:format)'  , {GET: book_show_api, PUT: book_update_api}],
-            ['/:book_id/comments/:comment_id', {POST: comment_create_api}],
-        ]],
-    ]],
-    ['/admin', [
-        ['/books'              , {ANY: admin_books_app}],
-    ]],
-]
+mapping = {
+    "/"                       => {GET: welcome_app},   # not {"GET"=>...}
+    "/api" => {
+        "/books" => {            # not {"GET"=>..., "POST"=>...}
+            ""                => {GET: book_list_api, POST: book_create_api},
+            "/:id(.:format)"  => {GET: book_show_api, PUT: book_update_api},
+            "/:book_id/comments/:comment_id" => {POST: comment_create_api},
+        },
+    },
+    "/admin" => {
+        "/books"              => {ANY: admin_books_app},   # not {"ANY"=>...}
+    },
+}
 
 router = Rack::JetRouter.new(mapping)
 p router.lookup('/api/books/123')
     #=> [{"GET"=>book_show_api, "PUT"=>book_update_api}, {"id"=>"123", "format"=>nil}]
 
+env = Rack::MockRequest.env_for("/api/books/123", method: 'GET')
 status, headers, body = router.call(env)
 ```
 
@@ -158,8 +156,6 @@ automatically when passing to `Rack::JetRouter.new()`.
 ### #3: RESTful Framework
 
 ```ruby
-# -*- coding: utf-8 -*-
-
 require 'rack'
 require 'rack/jet_router'
 
@@ -179,33 +175,33 @@ class BooksAPI < API
   def delete(id: nil); ....; end
 end
 
-mapping = [
-    ['/api', [
-        ['/books', [
-            [''      , {GET:    [BooksAPI, :index],
-                        POST:   [BooksAPI, :create]}],
-            ['/:id'  , {GET:    [BooksAPI, :show],
+mapping = {
+    "/api" => {
+        "/books" => {  # not {"GET"=>..., "POST"=>...}
+            ""      => {GET:    [BooksAPI, :index],
+                        POST:   [BooksAPI, :create]},
+            "/:id"  => {GET:    [BooksAPI, :show],
                         PUT:    [BooksAPI, :update],
-                        DELETE: [BooksAPI, :delete]}],
-        ]],
-    ]],
-]
+                        DELETE: [BooksAPI, :delete]},
+        },
+    },
+}
 router = Rack::JetRouter.new(mapping)
-dict, args = router.lookup('/api/books/123')
+dict, args = router.lookup("/api/books/123")
 p dict   #=> {"GET"=>[BooksAPI, :show], "PUT"=>[...], "DELETE"=>[...]}
 p args   #=> {"id"=>"123"}
-klass, action = dict["GET"]
+klass, method_name = dict["GET"]
 handler = klass.new(Rack::Request.new(env), Rack::Response.new)
-handler.__send__(action, args)
+handler.__send__(method_name, args)
 ```
 
 
 ## Topics
 
 
-### Nested Array v.s. Nested Hash
+### Nested Hash v.s. Nested Array
 
-URL path mapping can be not only nested Array but also nested Hash.
+URL path mapping can be not only nested Hash but also nested Array.
 
 ```ruby
 ## nested Array
@@ -229,11 +225,12 @@ mapping = {
 }
 ```
 
-But nested Hash mapping can't include request method mappings, because
-it is hard to distinguish between URL path mapping and request method mapping.
+When using nested Hash, request method mappings should be ``{GET: ...}``
+instead of ``{"GET"=>...}``, because with the latter it is hard to
+distinguish between URL path mapping and request method mapping.
 
 ```ruby
-## NOT OK
+## OK
 mapping = {
     "/api" => {
         "/books" => {
@@ -242,24 +239,13 @@ mapping = {
         },
     },
 }
-```
-
-In this case, define subclass of Hash class and use it instead of Hash.
-
-```ruby
-class Map < Hash       # define subclass of Hash class
-end
 
-def Map(**kwargs)      # helper method to create subclass object
-  return Map.new.update(kwargs)
-end
-
-## OK
+## Not OK
 mapping = {
     "/api" => {
         "/books" => {
-            ""      => Map(GET: book_list_api, POST: book_create_api),
-            "/:id"  => Map(GET: book_show_api, PUT: book_update_api),
+            ""      => {"GET"=>book_list_api, "POST"=>book_create_api},
+            "/:id"  => {"GET"=>book_show_api, "PUT"=>book_update_api},
         },
     },
 }
@@ -302,6 +288,32 @@ end
 ```
 
 
+### File Path Type Parameters
+
+If path parameter is ``*foo`` instead of ``:foo``, that parameter matches to any path.
+
+```ruby
+## Assume that book_api and staticfile_app are Rack application.
+mapping = {
+    "/api" => {
+        "/books" => {
+            "/:id"  => book_api,
+        },
+    },
+    "/static/*filepath" => staticfile_app,   # !!!
+}
+
+router = Rack::JetRouter.new(mapping)
+app, args = router.lookup("/static/images/logo.png") # !!!
+p app    #=> staticfile_app
+p args   #=> {"filepath"=>"images/logo.png"}
+```
+
+``*foo`` should be at end of the URL path.
+For example, ``/static/*filepath`` is OK, while ``"/static/*filepath.html"``
+or ``"/static/(*filepath)"`` raises error.
+
+
 ### Integer Type Parameters
 
 Keyword argument ``int_param:`` of ``JetRouter.new()`` specifies
@@ -320,9 +332,9 @@ rack_app = proc {|env|
   [200, {}, [text]]
 }
 
-mapping = [
-  ["/api/books/:book_id", rack_app]
-]
+mapping = {
+  "/api/books/:book_id" => rack_app,
+}
 router = Rack::JetRouter.new(mapping, int_param: /(?:\A|_)id\z/
 
 env = Rack::MockRequest.env_for("/api/books/123")
@@ -339,8 +351,6 @@ puts tuple[2]     #=> 404 Not Found
 ```
 
 
-<!--
-
 ### URL Path Multiple Extension
 
 It is available to specify multiple extension of URL path.
@@ -362,8 +372,6 @@ In above example, the following URL path patterns are enabled.
 Notice that ``env['rack.urlpath_params']['format']`` is not set
 because ``:format`` is not specified in URL path pattern.
 
--->
-
 
 ### Auto-redirection
 

data/bench/Gemfile

@@ -2,12 +2,13 @@
 
 source "https://rubygems.org"
 
+gem "benchmarker"
+
 gem "rack"
-gem "sinatra"
+#gem "rocketrouter"
 gem "rack-jet_router"
-gem "rack-multiplexer"
 gem "keight"
 #gem "hanami"
 gem "hanami-router"
-
-gem "benchmarker"
+gem "rack-multiplexer"
+gem "sinatra"

data/bench/Rakefile.rb

@@ -5,7 +5,7 @@
 desc "run 'bench.rb' script"
 task :bench, :N do |t, args|
   n = args[:N] || 1000000
-  ruby "bench.rb", "--N=#{n}"
-  #ruby "bench.rb", "--N=#{n}", "--sinatra=0", "--multiplexer=0"
-  #ruby "bench.rb", "--N=#{n}", "--rack=0", "--jetrouter=0", "--keight=0", "--multiplexer=0", "--sinatra=0", "--hanami=0"
+  ruby "bench.rb", "-n", n
+  #ruby "bench.rb", "-n", n, "--sinatra=0", "--multiplexer=0"
+  #ruby "bench.rb", "-n", n, "--rack=0", "--jetrouter=0", "--keight=0", "--multiplexer=0", "--sinatra=0", "--hanami=0"
 end