rack-jet_router 1.3.1 → 1.4.0

data/bench/bench.rb

@@ -5,48 +5,85 @@
 ## Usage:
 ##   $ gem install bundler
 ##   $ bundler install
-##   $ ruby bench.rb --N=1000_000
-##   $ ruby bench.rb --N=1000_000 --rack=0 --sinatra=0 --multiplexer=0 # --hanami=0 --jetrouter=0 --keight=0
+##   $ ruby bench.rb -n 1000000
+##   $ ruby bench.rb -n 1000000 --rack=off --sinatra=off --multiplexer=off # --jet=off --keight=off --hanami=off --httprouter=off
 ##
 
 
 $LOAD_PATH << File.absolute_path("../../lib", __FILE__)
 
+
 require 'benchmarker'
 Benchmarker.parse_cmdopts()
 
-require 'rack'              rescue nil  unless '0' == $opt_rack
-require 'rack/jet_router'   rescue nil  unless '0' == $opt_jetrouter
-require 'rack/multiplexer'  rescue nil  unless '0' == $opt_multiplexer
-require 'sinatra/base'      rescue nil  unless '0' == $opt_sinatra
-require 'keight'            rescue nil  unless '0' == $opt_keight
-require 'hanami/router'     rescue nil  unless '0' == $opt_hanami
-
-flag_rack        = defined?(Rack) && $opt_rack != '0'
-flag_jetrouter   = defined?(Rack::JetRouter)
-flag_multiplexer = defined?(Rack::Multiplexer)
-flag_sinatra     = defined?(Sinatra)
-flag_keight      = defined?(K8)
-flag_hanami      = defined?(Hanami::Router)
-
-def version_info(name, opt, flag)
-  version = opt == '0' ? "(skipped)" \
-          : ! flag     ? "(not installed)" \
-          : yield
-  return "** %-20s : %s" % [name, version]
+
+class GetFlag
+
+  def initialize(defaults={})
+    @flag_all = to_bool($opt_all)
+    @defaults = defaults
+    @output   = String.new
+  end
+
+  attr_reader :output
+
+  def call(key, lib, &b)
+    default = @defaults[key]
+    default != nil  or
+      raise KeyError.new(key.inspect)
+    opt_val = eval "$opt_#{key}"
+    arr = [to_bool(opt_val), @flag_all, default]
+    flag = arr.find {|x| x != nil }
+    #
+    begin
+      require lib
+    rescue LoadError
+      flag = nil
+    end
+    #
+    version = flag == false ? "(skipped)" \
+            : flag == nil   ? "(not installed)" \
+            : yield
+    gem = [lib].flatten()[0].gsub('/', '-')
+    @output << "** %-20s : %s\n" % [gem, version]
+    #
+    return flag
+  end
+
+  def to_bool(val, default=nil)
+    case val
+    when 'on' , 'true' , 'yes', '1'  ; return true
+    when 'off', 'false', 'no' , '0'  ; return false
+    else                             ; return default
+    end
+  end
+
 end
 
-puts version_info("rack"            , $opt_rack       , flag_rack       ) { Rack.release }
-puts version_info("rack-jet_router" , $opt_jetrouter  , flag_jetrouter  ) { Rack::JetRouter::RELEASE }
-puts version_info("rack-multiplexer", $opt_multiplexer, flag_multiplexer) { Rack::Multiplexer::VERSION }
-puts version_info("sinatra"         , $opt_sinatra    , flag_sinatra    ) { Sinatra::VERSION }
-puts version_info("keight"          , $opt_keight     , flag_keight     ) { K8::RELEASE }
-puts version_info("hanami-router"   , $opt_hanami     , flag_hanami     ) { Hanami::Router::VERSION }
+get_flag = GetFlag.new(
+  :rack        => true,
+  :rocket      => false,
+  :jet         => true,
+  :keight      => true,
+  :hanami      => true,
+  :httprouter  => true,
+  :multiplexer => true,
+  :sinatra     => true,
+)
+
+
+flag_rack        = get_flag.(:rack       , "rack"            ) { Rack.release }
+flag_rocket      = get_flag.(:rocket     , "rocketrouter"    ) { RocketRouter::VERSION }
+flag_jet         = get_flag.(:jet        , "rack/jet_router" ) { Rack::JetRouter::RELEASE }
+flag_keight      = get_flag.(:keight     , "keight"          ) { K8::RELEASE }
+flag_hanami      = get_flag.(:hanami     , "hanami/router"   ) { Hanami::Router::VERSION }
+flag_httprouter  = get_flag.(:httprouter , "http_router"     ) { require "http_router/version"; HttpRouter::VERSION }
+flag_multiplexer = get_flag.(:multiplexer, "rack/multiplexer") { Rack::Multiplexer::VERSION }
+flag_sinatra     = get_flag.(:sinatra    , "sinatra/base"    ) { Sinatra::VERSION }
 
 
 ENTRIES = ('a'..'z').map.with_index {|x, i| "%s%02d" % [x*3, i+1] }
 
-#flag_sinatra   = false   # because too slow
 target_urlpaths = [
   "/api/aaa01",
   "/api/aaa01/123",
@@ -57,13 +94,36 @@ target_urlpaths = [
 ]
 
 
-if flag_rack
-
-  rack_app1 = proc do |env|
-    [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+def generate_apps(env_key, key_class)
+  if    key_class == String ; id, c_id = 'id', 'comment_id'
+  elsif key_class == Symbol ; id, c_id = :id, :comment_id
+  else                      ; raise "** internal error: key_class=#{key_class.inspect}"
   end
+  index_app = proc {|env|
+    [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+  }
+  show_app = proc {|env|
+    d = env[env_key]
+    [200, {"Content-Type"=>"text/html"}, ["<h1>id=#{d[id]}</h1>"]]
+  }
+  comment_app = proc {|env|
+    d = env[env_key]
+    [200, {"Content-Type"=>"text/html"}, ["<h1>id=#{d[id]}, comment_id=#{d[c_id]}</h1>"]]
+  }
+  return index_app, show_app, comment_app
+end
+
+
+def let(*args)
+  return (yield *args)
+end
+
 
-  rack_app4 = proc do |env; req, resp|
+rack_app = flag_rack && let() {
+  #proc do |env|
+  #  [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
+  #end
+  proc do |env; req, resp|
     req  = Rack::Request.new(env)
     resp = Rack::Response.new
     #[resp.status, resp.headers, ["<h1>hello</h1>"]]
@@ -73,73 +133,134 @@ if flag_rack
     resp.write("<h1>hello</h1>")
     resp.finish()
   end
-
-end
-
-
-if flag_jetrouter
-
-  jet_router = proc {
-    handler1 = proc {|env|
-      [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
-    }
-    handler2 = proc {|env|
-      d = env['rack.urlpath_params']
-      [200, {"Content-Type"=>"text/html"}, ["<h1>id=#{d['id']}</h1>"]]
-    }
-    handler3 = proc {|env|
-      d = env['rack.urlpath_params']
-      [200, {"Content-Type"=>"text/html"}, ["<h1>id=#{d['id']}, comment_id=#{d['comment_id']}</h1>"]]
-    }
-    mapping = [
-      ['/api', ENTRIES.each_with_object([]) {|x, arr|
-                 arr << ["/#{x}", [
-                           ['',      handler1],
-                           ['/:id',  handler2],
-                         ]]
-                 arr << ["/#{x}/:id/comments", [
-                           ['/:comment_id',  handler3],
-                         ]]
-               },
-      ],
-    ]
-    opts = {
-      cache_size:     ($opt_k8cache || 0).to_i,
-      _enable_range:  $opt_k8range != '0',
-      #prefix_minlength_target: /\A\/api\/\w/,
-    }
-    Rack::JetRouter.new(mapping, **opts)
-  }.call()
-
-end
+}
+
+
+rocket_app = flag_rocket && let() {
+  index_app, show_app, comment_app = generate_apps('rack.urlpath_params', String)
+  mapping = {
+    "/api" => ENTRIES.each_with_object({}) {|x, map|
+      map.update({
+        "/#{x}" => {
+          ""                => index_app,
+          "/{id}"           => show_app,
+          "/{id}/comments"  => {
+            "/{comment_id}" => comment_app,
+          },
+        },
+      })
+    },
+  }
+  opts = {
+  }
+  RocketRouter.new(mapping, **opts)
+}
+
+
+jet_app = flag_jet && let() {
+  index_app, show_app, comment_app = generate_apps('rack.urlpath_params', String)
+  mapping = {
+    "/api" => ENTRIES.each_with_object({}) {|x, map|
+      map.update({
+        "/#{x}" => {
+          ""                => index_app,
+          "/:id"            => show_app,
+          "/:id/comments"   => {
+            "/:comment_id"  => comment_app,
+          },
+        },
+      })
+    },
+  }
+  opts = {
+    cache_size:     0,
+    _enable_range:  true,
+    #prefix_minlength_target: /\A\/api\/\w/,
+  }
+  Rack::JetRouter.new(mapping, **opts)
+}
+
+
+keight_app = flag_keight && let() {
+  class K8HelloAction < K8::Action
+    mapping '',       :GET=>:do_index
+    mapping '/{id}',  :GET=>:do_show
+    def do_index()
+      "<h1>hello</h1>"
+    end
+    def do_show(id)
+      "<h1>id=#{id.inspect}</h1>"
+    end
+  end
+  class K8CommentAction < K8::Action
+    mapping '/{comment_id}',  :GET=>:do_show
+    def do_show(id, comment_id)
+      "<h1>id=#{id}, comment_id=#{comment_id}</h1>"
+    end
+  end
+  mapping = [
+    ["/api",    ENTRIES.each_with_object([]) {|x, arr|
+                  arr << ["/#{x}"              ,  K8HelloAction]
+                  arr << ["/#{x}/{id}/comments",  K8CommentAction]
+                }
+    ],
+  ]
+  opts = {
+    #urlpath_cache_size: 0,
+  }
+  K8::RackApplication.new(mapping, **opts)
+}
+
+
+hanami_app = flag_hanami && let() {
+  ## ref: https://github.com/hanami/router
+  index_app, show_app, comment_app = generate_apps('router.params', Symbol)
+  Hanami::Router.new do
+    scope "api" do
+      ENTRIES.each do |x|
+        get "/#{x}"    , to: index_app
+        get "/#{x}/:id", to: show_app
+        get "/#{x}/:id/comments/:comment_id", to: comment_app
+      end
+    end
+  end
+}
 
 
-if flag_multiplexer
-
-  mpx_app = Rack::Multiplexer.new().tap do |app|
-    handler1 = proc {|env|
-      [200, {"Content-Type"=>"text/html"}, ["<h1>hello</h1>"]]
-    }
-    handler2 = proc {|env|
-      d = env['rack.request.query_hash']
-      [200, {"Content-Type"=>"text/html"}, ["<h1>id=#{d['id']}</h1>"]]
-    }
-    handler3 = proc {|env|
-      d = env['rack.request.query_hash']
-      [200, {"Content-Type"=>"text/html"}, ["<h1>id=#{d['id']}, comment_id=#{d['comment_id']}</h1>"]]
-    }
+httprouter_app = flag_httprouter && let() {
+  require 'uri'
+  require 'cgi'
+  class <<URI
+    #alias unescape decode_www_form
+    def unescape(x)
+      CGI.unescape(x)
+    end
+  end
+  #
+  index_app, show_app, comment_app = generate_apps('router.params', Symbol)
+  HttpRouter.new.tap do |r|
     ENTRIES.each do |x|
-      app.get "/api/#{x}"     , handler1
-      app.get "/api/#{x}/:id" , handler2
-      app.get "/api/#{x}/:id/comments/:comment_id" , handler3
+      r.add("/api/#{x}"    ).to(index_app)
+      r.add("/api/#{x}/:id").to(show_app)
+      r.add("/api/#{x}/:id/comments/:comment_id").to(comment_app)
     end
   end
+}
 
-end
 
+multiplexer_app = flag_multiplexer && let() {
+  index_app, show_app, comment_app = generate_apps('rack.request.query_hash', String)
+  Rack::Multiplexer.new().tap do |app|
+    ENTRIES.each do |x|
+      app.get "/api/#{x}"     , index_app
+      app.get "/api/#{x}/:id" , show_app
+      app.get "/api/#{x}/:id/comments/:comment_id" , comment_app
+    end
+  end
+}
 
-if flag_sinatra
 
+sinatra_app = flag_sinatra && let() {
   class SinaApp < Sinatra::Base
     ## run benchmarks without middlewares
     set :sessions   , false
@@ -148,76 +269,19 @@ if flag_sinatra
     set :x_cascade  , false
     #
     ENTRIES.each do |x|
-      get "/api/#{x}"     do "<h1>hello</h1>" end
-      get "/api/#{x}/:id" do "<h1>id=#{params['id']}</h1>" end
-      get "/api/#{x}/:id/comments/:comment_id" do "<h1>id=#{params['id']}, comment_id=#{params['comment_id']}</h1>" end
-    end
-  end
-
-  sina_app = SinaApp.new
-
-end
-
-
-if flag_keight
-
-  class K8HelloAction < K8::Action
-    mapping '',       :GET=>:do_index
-    mapping '/{id}',  :GET=>:do_show
-    def do_index        ; "<h1>hello</h1>"; end
-    def do_show(id)     ; "<h1>id=#{id.inspect}</h1>"; end
-  end
-
-  class K8CommentAction < K8::Action
-    mapping '/{comment_id}',  :GET=>:do_show
-    def do_show(id, comment_id); "<h1>id=#{id}, comment_id=#{comment_id}</h1>"; end
-  end
-
-  k8_app = (proc {
-    mapping = [
-      ["/api", ENTRIES.each_with_object([]) {|x, arr|
-                 arr << ["/#{x}"              ,  K8HelloAction]
-                 arr << ["/#{x}/{id}/comments",  K8CommentAction]
-               }
-      ],
-    ]
-    opts = {
-      #urlpath_cache_size: 0,
-    }
-    K8::RackApplication.new(mapping, **opts)
-  }).call()
-
-  #k8_app.find('/api/books')     # warm up
-
-end
-
-
-if flag_hanami
-
-  ## ref: https://github.com/hanami/router
-  hanami_app = Hanami::Router.new do
-    index_handler = proc do |env|
-      [200, {"Content-Type": "text/html"}, ["<h1>hello</h1>"]]
-    end
-    show_handler = proc do |env|
-      d = env['router.params']
-      [200, {"Content-Type": "text/html"}, ["<h1>id=#{d[:id]}</h1>"]]
-    end
-    comment_handler = proc do |env|
-      d = env['router.params']
-      [200, {"Content-Type": "text/html"}, ["<h1>id=#{d[:id]}, comment_id=#{d[:comment_id]}</h1>"]]
-    end
-    #
-    scope "api" do
-      ENTRIES.each do |x|
-        get "/#{x}"    , to: index_handler
-        get "/#{x}/:id", to: show_handler
-        get "/#{x}/:id/comments/:comment_id", to: comment_handler
+      get "/api/#{x}" do
+        "<h1>hello</h1>"
+      end
+      get "/api/#{x}/:id" do
+        "<h1>id=#{params['id']}</h1>"
+      end
+      get "/api/#{x}/:id/comments/:comment_id" do
+        "<h1>id=#{params['id']}, comment_id=#{params['comment_id']}</h1>"
       end
     end
   end
-
-end
+  SinaApp.new
+}
 
 
 begin
@@ -235,10 +299,12 @@ def newenv(path)
 end
 
 
-N = ($opt_N || 100000).to_i
+N = Benchmarker::OPTIONS.delete(:loop) || 1000_000
 title = "Router library benchmark"
-Benchmarker.scope(title, width: 33, loop: 1, iter: 1, extra: 0, sleep: 0) do
+width = target_urlpaths.collect(&:length).max()
+Benchmarker.scope(title, width: width + 17, loop: 1, iter: 1, extra: 0, sleep: 0) do
 
+  puts get_flag.output()
   puts "** N=#{N}"
   puts ""
 
@@ -251,117 +317,137 @@ Benchmarker.scope(title, width: 33, loop: 1, iter: 1, extra: 0, sleep: 0) do
   end
 
   ### Rack
-  if flag_rack
-    #target_urlpaths.each do |x|
-    #  rack_app1.call(newenv(x))              # warm up
-    #  task "(Rack plain app) #{x}" do        # no routing
-    #    env = newenv(x)
-    #    i = 0; n = N
-    #    while (i += 1) <= n
-    #      tuple = rack_app1.call(env)
-    #    end
-    #    tuple
-    #  end
-    #end
-    target_urlpaths.each do |x|
-      rack_app4.call(newenv(x))            # warm up
-      task "(Rack::Req+Res)  #{x}" do        # no routing
-        env = newenv(x)
-        i = 0; n = N
-        while (i += 1) <= n
-          tuple = rack_app4.call(env)
-        end
-        tuple
+  #flag_rack and target_urlpaths.each do |path|
+  #  rack_app.call(newenv(path))               # warm up
+  #  task "(Rack plain app) #{path}" do        # no routing
+  #    env = newenv(path)
+  #    i = 0; n = N
+  #    while (i += 1) <= n
+  #      result = rack_app.call(env)
+  #    end
+  #    result
+  #  end
+  #end
+  flag_rack and target_urlpaths.each do |path|
+    rack_app.call(newenv(path))               # warm up
+    task "(Rack::Req+Res)  #{path}" do        # no routing
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = rack_app.call(env)
+      end
+      result
+    end
+  end
+
+  ### RocketRouter
+  flag_rocket and target_urlpaths.each do |path|
+    rocket_app.call(newenv(path))             # warm up
+    task "(RocketRouter)   #{path}" do
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = rocket_app.call(env)
+        #result = rocket_app.find(path)
       end
+      result
     end
   end
 
   ### Rack::JetRouter
-  if flag_jetrouter
-    target_urlpaths.each do |x|
-      jet_router.call(newenv(x))             # warm up
-      task "(JetRouter)      #{x}" do
-        env = newenv(x)
-        i = 0; n = N
-        while (i += 1) <= n
-          tuple = jet_router.call(env)
-        end
-        tuple
+  flag_jet and target_urlpaths.each do |path|
+    jet_app.call(newenv(path))                # warm up
+    task "(JetRouter)      #{path}" do
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = jet_app.call(env)
+        #result = jet_app.find(path)
       end
+      result
     end
   end
 
-  ### Rack::Multiplexer
-  if flag_multiplexer
-    target_urlpaths.each do |x|
-      mpx_app.call(newenv(x))                # warm up
-      task "(Multiplexer)    #{x}" do
-        env = newenv(x)
-        i = 0; n = N
-        while (i += 1) <= n
-          tuple = mpx_app.call(env)
-        end
-        tuple
+  ### Keight
+  flag_keight and target_urlpaths.each do |path|
+    keight_app.call(newenv(path))             # warm up
+    task "(Keight)         #{path}" do
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = keight_app.call(env)
       end
+      result
     end
   end
 
-  ### Sinatra
-  if flag_sinatra
-    target_urlpaths.each do |x|
-      sina_app.call(newenv(x))               # warm up
-      task "(Sinatra)        #{x}" do
-        env = newenv(x)
-        i = 0; n = N
-        while (i += 1) <= n
-          tuple = sina_app.call(env)
-        end
-        tuple
+  ### Hanami::Router
+  flag_hanami and target_urlpaths.each do |path|
+    hanami_app.call(newenv(path))             # warm up
+    task "(Hanami::Router) #{path}" do
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = hanami_app.call(env)
+        #result = hanami_app.route(path)
       end
+      result
     end
   end
 
-  ### Keight
-  if flag_keight
-    target_urlpaths.each do |x|
-      k8_app.call(newenv(x))                 # warm up
-      task "(Keight)         #{x}" do
-        env = newenv(x)
-        i = 0; n = N
-        while (i += 1) <= n
-          tuple = k8_app.call(env)
-        end
-        tuple
+  ### HttpRouter
+  flag_httprouter and target_urlpaths.each do |path|
+    httprouter_app.call(newenv(path))         # warm up
+    task "(HttpRouter)     #{path}" do
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = httprouter_app.call(env)
+        #result = httprouter_app.route(path)
       end
+      result
     end
   end
 
-  ### Hanami
-  if flag_hanami
-    target_urlpaths.each do |x|
-      hanami_app.call(newenv(x))          # warm up
-      task "(Hanami::Router) #{x}" do
-        env = newenv(x)
-        i = 0; n = N
-        while (i += 1) <= n
-          tuple = hanami_app.call(env)
-        end
-        tuple
+  ### Rack::Multiplexer
+  flag_multiplexer and target_urlpaths.each do |path|
+    multiplexer_app.call(newenv(path))        # warm up
+    task "(Multiplexer)    #{path}" do
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = multiplexer_app.call(env)
       end
+      result
+    end
+  end
+
+  ### Sinatra
+  flag_sinatra and target_urlpaths.each do |path|
+    sinatra_app.call(newenv(path))            # warm up
+    task "(Sinatra)        #{path}" do
+      env = newenv(path)
+      i = 0; n = N
+      while (i += 1) <= n
+        result = sinatra_app.call(env)
+      end
+      result
     end
   end
 
   ## validation
-  validate do |val|   # or: validate do |val, task_name, tag|
-    tuple = val
-    assert tuple[0] == 200, "200 expected but got #{tuple[0]}"
+  validate do |result|   # or: validate do |result, task_name, tag|
+    tuple = result
+    assert tuple[0] == 200, "Expected 200 but got #{tuple[0]}"
     body = tuple[2].each {|x| break x }
-    assert body == "<h1>hello</h1>" || \
-           body == "<h1>id=123</h1>" || \
-           body == "<h1>id=456</h1>" || \
-           body == "<h1>id=123, comment_id=7</h1>" || \
-           body == "<h1>id=456, comment_id=7</h1>", \
-           "#{body.inspect}: unpexpected body"
+    expected_bodies = [
+      "<h1>hello</h1>",
+      "<h1>id=123</h1>",
+      "<h1>id=456</h1>",
+      "<h1>id=123, comment_id=7</h1>",
+      "<h1>id=456, comment_id=7</h1>",
+    ]
+    assert expected_bodies.include?(body), "#{body.inspect}: Unpexpected body."
   end
 
 end