keight 0.1.0 → 0.2.0

data/bench/benchmarker.rb

@@ -1,13 +1,13 @@
 ###
-### $Release: 0.1.0 $
-### $Copyright: copyright(c) 2014-2015 kuwata-lab.com all rights reserved $
+### $Release: 0.2.0 $
+### $Copyright: copyright(c) 2014-2016 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###
 
 
 module Benchmarker
 
-  VERSION = "$Release: 0.1.0 $".split(/ /)[1]
+  VERSION = "$Release: 0.2.0 $".split(/ /)[1]
 
   def self.new(opts={}, &block)
     #: creates runner object and returns it.
@@ -240,6 +240,8 @@ END
     attr_accessor :label, :loop, :user, :sys, :total, :real
 
     def run
+      #: starts GC before running benchmark.
+      GC.start
       #: yields block for @loop times.
       ntimes = @loop || 1
       pt1 = Process.times

data/bin/k8rb

@@ -2,14 +2,12 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 0.1.0 $
-### $Copyright: copyright(c) 2014-2015 kuwata-lab.com all rights reserved $
+### $Release: 0.2.0 $
+### $Copyright: copyright(c) 2014-2016 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###
 
 
-require 'digest/sha1'
-
 require 'keight'
 require 'baby_erubis'
 
@@ -22,15 +20,16 @@ module K8
     @__current = nil
     @__actions = []
 
-    @action = proc do |action_name, desc|
+    @action = proc do |action_name, desc, dict|
       options = []
       method_name = nil
-      tuple = [action_name, desc, options, method_name]
+      (dict ||= {})[:desc] = desc
+      tuple = [action_name, dict, options, method_name]
       @__current = tuple
       @__actions << tuple
     end
 
-    @option = proc do |optdef_str, desc|
+    @option = proc do |optdef_str, desc, opts|
       tuple = @__current  or
         raise "@option.() is called without @action.()"
       tuple[2] << [optdef_str, desc]
@@ -72,7 +71,8 @@ module K8
         sb <<   "  #{script} ACTION [..OPTIONS..]"
         sb <<   ""
         sb <<   "Actions:"
-        self.class.each_action do |action_name, desc, options, _|
+        self.class.each_action do |action_name, dict, options, _|
+          desc = dict[:desc]
           next unless desc
           help = desc.lines.first.chomp()
           sb << "  #{script} %-15s # #{help}" % [action_name, help]
@@ -82,7 +82,7 @@ module K8
       else
         tuple = self.class.find_action(action_name)  or
           raise K8::OptionError.new("help #{action_name}: no such action.")
-        action_name, desc, options, method_name = tuple
+        action_name, dict, options, method_name = tuple
         pnames = self.method(method_name).parameters.collect {|kind, pname|
           case kind
           when :req  ;  pname
@@ -95,7 +95,7 @@ module K8
         }.compact()
         pnames.unshift('') unless pnames.empty?
         argstr = pnames.join(' ')
-        sb <<   "#{script} #{action_name}  - #{desc}"
+        sb <<   "#{script} #{action_name}  - #{dict[:desc]}"
         sb <<   ""
         sb <<   "Usage:"
         if options.empty?
@@ -109,15 +109,21 @@ module K8
             sb << "  %-20s # %s" % [optstr, optdesc] if optdesc
           end
         end
+        if dict[:example]
+          sb << ""
+          sb << "Examples:"
+          sb << dict[:example].gsub(/%SCRIPT%/, script)
+        end
       end
       sb << ""
       sb << ""
       return sb.join("\n")
     end
 
-    @action.(:init, "create project files")
+    @action.(:project, "create project files")
     @option.("-s, --skeleton=DIR", "directory of skeleton files")
-    def do_init(project_name, dir: nil)
+    def do_project(name, dir: nil)
+      project_name = name
       dir ||= K8::FILEPATH.sub(/\.rb\z/, '') + "/skeleton"
       if dir
         File.directory?(dir)  or
@@ -137,30 +143,139 @@ module K8
             o.mkdir("#{project_name}/#{base}", descs[base+"/"])
           elsif File.file?(path)
             content = path =~ /\Astatic\/lib|\.gz\z/  \
-            ? File.read(path, encoding: 'ascii-8bit')  \
-            : K8::SkeletonTemplate.new.from_file(path, 'ascii-8bit').render()
+                    ? File.read(path, encoding: 'ascii-8bit')  \
+                    : K8::SkeletonTemplate.new.from_file(path, 'ascii-8bit').render()
             o.mkfile("#{project_name}/#{base}", content, descs[base])
           else
             next
           end
         end
-        return
+        #
+        msg = <<-END
+
+        ##
+        ## File copied.
+        ## Please run 'rake setup' in '#{project_name}' directory, for example:
+        ##
+        ##    $ cd #{project_name}
+        ##    $ rake setup
+        ##    $ export APP_ENV='dev'      # or 'prod', 'stg', 'test'
+        ##    $ rake server port=8000
+        ##    $ open http://localhost:8000/
+        ##
+        END
+        return msg.gsub(/^        /, '')
       end
       0
     end
 
     @action.(:mapping, "show action mappings")
-    def do_mapping()
+    @option.("--format={text|json|yaml|javascript|jquery|angular}", "output format")
+    def do_mapping(format: nil)
       ENV['APP_MODE'] ||= 'dev'
       load_config()
       require './config/urlpath_mapping'
-      app = K8::RackApplication.new
-      $urlpath_mapping.each do |urlpath, children|
-        app.mount(urlpath, children)
+      return \
+        case format
+        when nil         ; _do_mapping_in_text_format()
+        when 'text'      ; _do_mapping_in_text_format()
+        when 'json'      ; _do_mapping_in_json_format()
+        when 'yaml'      ; _do_mapping_in_yaml_format()
+        when 'javascript'; _do_mapping_in_javascript_format(nil)
+        when 'jquery'    ; _do_mapping_in_javascript_format('type')
+        when 'angular'   ; _do_mapping_in_javascript_format('method')
+        else
+          raise OptionError.new("#{format}: expected one of text/json/yaml/javascript/jquery/angular.")
+        end
+    end
+
+    private
+
+    def _do_mapping(&block)
+      app = K8::RackApplication.new($urlpath_mapping)
+      app.each_mapping do |urlpath_pat, action_class, action_methods, |
+        yield urlpath_pat, action_class, action_methods
+      end
+    end
+    private :_do_mapping
+
+    def _do_mapping_in_json_format()
+      s = %Q`{ "mappings": [\n`.dup()
+      i = 0
+      _do_mapping do |urlpath_pat, action_class, action_methods|
+        i += 1
+        arr = action_methods.map {|k, v| %Q`"#{k}": "#{v}"` }
+        s << (i == 1 ? '  ' : ', ')
+        s << %Q`{"urlpath": "#{urlpath_pat}"`
+        s << %Q`, "class": \"#{action_class.name}"`
+        s << %Q`, "method": {#{arr.join(', ')}}}\n`
+      end
+      s << "] }\n"
+      return s
+    end
+
+    def _do_mapping_in_yaml_format()
+      s = ""
+      _do_mapping do |urlpath_pat, action_class, action_methods|
+        arr = action_methods.map {|k, v| "#{k}: #{v}" }
+        s << "- urlpath: '#{urlpath_pat}'\n"
+        s << "  class:   #{action_class.name}\n"
+        s << "  method:  {#{arr.join(', ')}}\n"
+        s << "\n"
+      end
+      return s
+    end
+
+    def _do_mapping_in_javascript_format(attr)
+      rexp = K8::ActionMapping::URLPATH_PARAM_REXP
+      defs = {}
+      _do_mapping do |urlpath_pat, action_class, action_methods|
+        (defs[action_class.name] ||= []) << [urlpath_pat, action_methods]
+      end
+      buf = []
+      defs.each do |action_class_name, pairs|
+        if action_class_name =~ /\A\w+\z/
+          buf << "#{action_class_name}:{\n"
+        else
+          buf << "'#{action_class_name}':{\n"
+        end
+        sep = ' '
+        pairs.each do |urlpath_pat, action_methods|
+          args = []; i = 0
+          urlpath_pat.scan(rexp) {|x, _| args << (x.empty? ? "_#{i+=1}" : x) }
+          a = args.dup()
+          js_urlpath = "'" + urlpath_pat.gsub(rexp) {|x, _| "'+#{a.shift}+'" } + "'"
+          js_urlpath.gsub!(/\+''/, '')
+          #
+          action_methods.each do |req_meth, action_method|
+            buf << sep; sep = ','
+            if attr
+              js_code = "return{#{attr}:'#{req_meth}',url:#{js_urlpath}}"
+              buf << "#{action_method}:function(#{args.join(',')}){#{js_code}}\n"
+            else
+              js_code = "function(#{args.join(',')}){return#{js_urlpath}}"
+              buf << "#{action_method}:{method:'#{req_meth}',urlpath:#{js_code}}\n"
+            end
+          end
+        end
+        buf << "},\n"
+      end
+      buf[-1] = "}\n" if buf[-1] == "},\n"
+      return buf.join()
+    end
+
+    def _do_mapping_in_text_format()
+      s = ""
+      _do_mapping do |urlpath_pat, action_class, action_methods|
+        action_methods.each do |req_meth, action_method|
+          s << "%-6s %-30s # %s\#%s\n" % [req_meth, urlpath_pat, action_class.name, action_method]
+        end
       end
-      return app.show_mappings()
+      return s
     end
 
+    public
+
     @action.(:configs, "list config keys and values")
     @option.("--getenv", "show actual ENV value")
     def do_configs(getenv: false)
@@ -245,6 +360,108 @@ module K8
     end
     private :__var_dump
 
+    @action.(:cdnjs, "search or download libraries from cdnjs.com")
+    @option.("-d, --basedir=DIR", "base directory (default: 'static/lib')")
+    def do_cdnjs(library=nil, version=nil, basedir: nil)
+      require 'open-uri'
+      require 'fileutils'
+      library.nil? || library =~ /\A\*?[-.\w]+\*?\z/  or
+        raise OptionError.new("#{library}: invalid library name.")
+      version.nil? || version =~ /\A\d+(\.\d+)+[-.\w]+\z/  or
+        raise OptionError.new("#{version}: version number expected.")
+      ## list or search libraries
+      if library.nil? || library.include?('*')
+        return _cdnjs_list(library)
+      ## list versions
+      elsif version.nil?
+        return _cdnjs_find(library)
+      ## download files
+      else
+        return _cdnjs_download(library, version, basedir)
+      end
+    end
+
+    def _cdnjs_list(pattern)
+      url  = "https://cdnjs.com/libraries"
+      rexp = %r'href="/libraries/([-.\w]+)"'
+      libs = open(url) {|f|
+        #f.grep(rexp) { $1 }  # not work
+        f.collect {|s| $1 if s =~ rexp }.compact.sort.uniq
+      }
+      if pattern
+        s = Regexp.escape(pattern)   # ex: '*foo.js*'    -> '\*foo\.js\*'
+        s = s.gsub(/\\\*/, '.*')     # ex: '\*foo\.js\*' -> '.*foo\.js.*'
+        s = "\\A#{s}\\z"             # ex: '.*foo\.js.*' -> '\A.*foo\.js.*\z'
+        rexp = Regexp.compile(s)
+        libs = libs.grep(rexp)
+      end
+      return (libs << "").join("\n")
+    end
+
+    def _cdnjs_find(library)
+      url = "https://cdnjs.com/libraries/#{library}"
+      rexp = %r'<option value="(.*?)".*?>\1</option>'
+      versions = open(url) {|f|
+        f.collect {|s| $1 if s =~ rexp }.compact()
+      }.sort_by {|verstr| _normalized_version(verstr) }
+      if versions.empty?
+        $stderr.puts "#{library}: no such library (GET #{url})."
+        return 1
+      end
+      return (versions << "").join("\n")
+    end
+
+    def _cdnjs_download(library, version, basedir=nil)
+      basedir ||= "static/lib"
+      File.exist?(basedir)  or
+        raise OptionError.new("#{basedir}: directory not exist.")
+      File.directory?(basedir)  or
+        raise OptionError.new("#{basedir}: not a directory.")
+      url = "https://cdnjs.com/libraries/#{library}/#{version}"
+      rexp = %r">https://cdnjs\.cloudflare\.com/ajax/libs/#{library}/#{Regexp.escape(version)}/([-.\w]+(?:\&\#x2F;[-.\w]+)*)<"
+      filenames = open(url) {|f|
+        f.collect {|s| $1.gsub(/\&\#x2F;/, '/') if s =~ rexp }.compact()
+      }
+      if filenames.empty?
+        $stderr.puts "#{library} #{version}: no files (GET #{url})."
+        return 1
+      end
+      baseurl = "https://cdnjs.cloudflare.com/ajax/libs"
+      filenames.each do |filename|
+        fileurl  = "#{baseurl}/#{library}/#{version}/#{filename}"
+        filepath = "#{basedir}/#{library}/#{version}/#{filename}"
+        FileUtils.mkdir_p(File.dirname(filepath))
+        print filepath, ' '
+        content = open(fileurl) {|f| f.read }
+        if _file_changed(filepath, content)
+          File.open(filepath, 'w') {|f| f.write(content) }
+          s = ""
+        else
+          s = " (not changed)"
+        end
+        puts "(#{_bytesize(content)} byte)#{s}"
+      end
+      return 0
+    end
+
+    def _normalized_version(version_str)
+      if version_str =~ /\A(\d+(?:\.\d+)*)(.*)/
+        return $1.split('.').map {|n| "%05d" % n.to_i }.join('.') + $2
+      else
+        return version_str
+      end
+    end
+
+    def _file_changed(filepath, expected)
+      return true unless File.exist?(filepath)
+      actual = File.read(filepath, encoding: expected.encoding)
+      return actual != expected
+    end
+
+    def _bytesize(string)
+      return string.bytesize.to_s.reverse.gsub(/(...)/, '\1,').sub(/,\z/, '').reverse
+    end
+
 
     if ENV['DEBUG']
       @action.(:debug, "debug")

data/keight.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification.new do |o|
   o.name          = "keight"
-  o.version       = "$Release: 0.1.0 $".split[1]
+  o.version       = "$Release: 0.2.0 $".split[1]
   o.author        = "makoto kuwata"
   o.email         = "kwa(at)kuwata-lab.com"
   o.platform      = Gem::Platform::RUBY
@@ -18,13 +18,12 @@ See https://github.com/kwatch/keight/tree/ruby for details.
 END
 
   o.files         = Dir[*%w[
-                      README.md MIT-LICENSE keight.gemspec setup.rb Rakefile
+                      README.md CHANGES.txt MIT-LICENSE keight.gemspec setup.rb Rakefile
                       bin/k8rb
                       lib/keight.rb lib/keight/**/*.{[a-z]*} lib/keight/**/.{[a-z]*}
                       test/*_test.rb test/data/* test/oktest.rb
                       bench/bench.rb bench/benchmarker.rb
                     ]]
-                      #lib/keight.rb lib/keight/**/*
   o.executables   = ["k8rb"]
   o.bindir        = ["bin"]
   #o.test_files   = o.files.grep(/^test\//)
@@ -34,4 +33,5 @@ END
   o.add_runtime_dependency 'rack', '~> 1.6'
   o.add_runtime_dependency 'baby_erubis', '~> 2.1', '>= 2.1.1'
   #o.add_development_dependency "oktest", "~> 0"
+  o.add_development_dependency 'rack-test_app', '~> 1.0', '>= 1.0.0'
 end

data/lib/keight.rb

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 0.1.0 $
-### $Copyright: copyright(c) 2014-2015 kuwata-lab.com all rights reserved $
+### $Release: 0.2.0 $
+### $Copyright: copyright(c) 2014-2016 kuwata-lab.com all rights reserved $
 ### $License: MIT License $
 ###
 
@@ -15,6 +15,8 @@ require 'digest/sha1'
 
 module K8
 
+  RELEASE  = '$Release: 0.2.0 $'.split()[1]
+
   FILEPATH = __FILE__
 
   HTTP_REQUEST_METHODS = {
@@ -26,7 +28,7 @@ module K8
     "PATCH"   => :PATCH,
     "OPTIONS" => :OPTIONS,
     "TRACE"   => :TRACE,
-  }.each {|k, _| k.freeze }
+  }
 
   HTTP_RESPONSE_STATUS = {
     100 => "Continue",
@@ -169,7 +171,7 @@ module K8
     '.docx'    => 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
     '.xlsx'    => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
     '.pptx'    => 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-  }.each {|k, v| k.freeze; v.freeze }
+  }.each {|_, v| v.freeze }  # hash keys are always frozen
 
 
   module Util
@@ -456,17 +458,17 @@ module K8
 
     attr_reader :env, :method, :path
 
+    def method(name=nil)
+      #; [!084jo] returns current request method when argument is not specified.
+      #; [!gwskf] calls Object#method() when argument specified.
+      return name ? super : @method
+    end
+
     def header(name)
       #; [!1z7wj] returns http header value from environment.
       return @env["HTTP_#{name.upcase.sub('-', '_')}"]
     end
 
-    def method(name=nil)
-      #; [!tp595] returns :GET, :POST, :PUT, ... when argument is not passed.
-      #; [!49f51] returns Method object when argument is passed.
-      return name.nil? ? @method : super(name)
-    end
-
     def request_method
       #; [!y8eos] returns env['REQUEST_METHOD'] as string.
       return @env['REQUEST_METHOD']
@@ -783,6 +785,25 @@ module K8
       return @action_method_mapping ||= ActionMethodMapping.new
     end
 
+    def self._build_action_info(full_urlpath_pattern)   # :nodoc:
+      #; [!ordhc] build ActionInfo objects for each action methods.
+      parent = full_urlpath_pattern
+      @action_infos = {}
+      _action_method_mapping().each do |urlpath_pat, methods|
+        methods.each do |req_meth, action_method_name|
+          info = ActionInfo.create(req_meth, "#{parent}#{urlpath_pat}")
+          @action_infos[action_method_name] = info
+        end
+      end
+      @action_infos
+    end
+
+    def self.[](action_method_name)
+      #; [!1tq8z] returns ActionInfo object corresponding to action method.
+      #; [!6g2iw] returns nil when not mounted yet.
+      return (@action_infos || {})[action_method_name]
+    end
+
   end
 
 
@@ -1001,6 +1022,85 @@ module K8
   end
 
 
+  ##
+  ## ex:
+  ##   info = ActionInfo.new('PUT', '/api/books/{id}')
+  ##   p info.method                 #=> "PUT"
+  ##   p info.urlpath(123)           #=> "/api/books/123"
+  ##   p info.form_action_attr(123)  #=> "/api/books/123?_method=PUT"
+  ##
+  class ActionInfo
+
+    def initialize(method, urlpath_format)
+      @method = method
+      @urlpath_format = urlpath_format   # ex: '/books/%s/comments/%s'
+    end
+
+    attr_reader :method
+
+    def method(name=nil)
+      return name ? super : @method
+    end
+
+    def urlpath(*args)
+      return @urlpath_format % args
+    end
+
+    def form_action_attr(*args)
+      #; [!qyhkm] returns '/api/books/123' when method is POST.
+      #; [!kogyx] returns '/api/books/123?_method=PUT' when method is not POST.
+      if @method == 'POST'
+        return urlpath(*args)
+      else
+        return "#{urlpath(*args)}?_method=#{@method}"
+      end
+    end
+
+    def self.create(meth, urlpath_pattern)
+      ## ex: '/books/{id}' -> '/books/%s'
+      #; [!1nk0i] replaces urlpath parameters with '%s'.
+      #; [!a7fqv] replaces '%' with'%%'.
+      rexp = /(.*?)\{(\w*?)(?::[^{}]*(?:\{[^{}]*?\}[^{}]*?)*)?\}/
+      urlpath_format = ''; n = 0
+      urlpath_pattern.scan(rexp) do |text, pname|
+        next if pname == 'ext'   # ignore '.html' or '.json'
+        urlpath_format << text.gsub(/%/, '%%') << '%s'
+        n += 1
+      end
+      rest = n > 0 ? Regexp.last_match.post_match : urlpath_pattern
+      urlpath_format << rest.gsub(/%/, '%%')
+      #; [!btt2g] returns ActionInfoN object when number of urlpath parameter <= 4.
+      #; [!x5yx2] returns ActionInfo object when number of urlpath parameter > 4.
+      return (SUBCLASSES[n] || ActionInfo).new(meth, urlpath_format)
+    end
+
+    SUBCLASSES = []     # :nodoc:
+
+  end
+
+  class ActionInfo0 < ActionInfo    # :nodoc:
+    def urlpath(); @urlpath_format; end
+  end
+
+  class ActionInfo1 < ActionInfo    # :nodoc:
+    def urlpath(a); @urlpath_format % [a]; end
+  end
+
+  class ActionInfo2 < ActionInfo    # :nodoc:
+    def urlpath(a, b); @urlpath_format % [a, b]; end
+  end
+
+  class ActionInfo3 < ActionInfo    # :nodoc:
+    def urlpath(a, b, c); @urlpath_format % [a, b, c]; end
+  end
+
+  class ActionInfo4 < ActionInfo    # :nodoc:
+    def urlpath(a, b, c, d); @urlpath_format % [a, b, c, d]; end
+  end
+
+  ActionInfo::SUBCLASSES << ActionInfo0 << ActionInfo1 << ActionInfo2 << ActionInfo3 << ActionInfo4
+
+
   class DefaultPatterns
 
     def initialize
@@ -1031,6 +1131,26 @@ module K8
   end
 
 
+  DEFAULT_PATTERNS = proc {
+    x = DefaultPatterns.new
+    #; [!i51id] registers '\d+' as default pattern of param 'id' or /_id\z/.
+    x.register('id',    '\d+') {|val| val.to_i }
+    x.register(/_id\z/, '\d+') {|val| val.to_i }
+    #; [!2g08b] registers '(?:\.\w+)?' as default pattern of param 'ext'.
+    x.register('ext',   '(?:\.\w+)?')
+    #; [!8x5mp] registers '\d\d\d\d-\d\d-\d\d' as default pattern of param 'date' or /_date\z/.
+    to_date = proc {|val|
+      #; [!wg9vl] raises 404 error when invalid date (such as 2012-02-30).
+      yr, mo, dy = val.split(/-/).map(&:to_i)
+      Date.new(yr, mo, dy)  rescue
+        raise HttpException.new(404, "#{val}: invalid date.")
+    }
+    x.register('date',    '\d\d\d\d-\d\d-\d\d', &to_date)
+    x.register(/_date\z/, '\d\d\d\d-\d\d-\d\d', &to_date)
+    x
+  }.call()
+
+
   class ActionMethodMapping
 
     def initialize
@@ -1073,370 +1193,248 @@ module K8
   end
 
 
-  class ActionClassMapping
-
-    def initialize
-      @mappings = []
-    end
+  class ActionMapping
 
-    ##
-    ## ex:
-    ##   mount '/',              WelcomeAction
-    ##   mount '/books',         BooksAction
-    ##   mount '/admin', [
-    ##           ['/session',    AdminSessionAction],
-    ##           ['/books',      AdminBooksAction],
-    ##         ]
-    ##
-    def mount(urlpath_pattern, action_class)
-      _mount(@mappings, urlpath_pattern, action_class)
-      #; [!w8mee] returns self.
+    def initialize(urlpath_mapping, default_patterns: DEFAULT_PATTERNS, urlpath_cache_size: 0,
+                                    enable_urlpath_param_range: true)
+      @default_patterns   = default_patterns || DefaultPatterns.new
+      #; [!34o67] keyword arg 'enable_urlpath_param_range' controls to generate range object or not.
+      @enable_urlpath_param_range = enable_urlpath_param_range
+      #; [!buj0d] prepares LRU cache if cache size specified.
+      @urlpath_cache_size = urlpath_cache_size
+      @urlpath_lru_cache  = urlpath_cache_size > 0 ? {} : nil
+      #; [!wsz8g] compiles urlpath mapping passed.
+      compile(urlpath_mapping)
+    end
+
+    def compile(urlpath_mapping)
+      #; [!6f3vl] compiles urlpath mapping.
+      @fixed_endpoints    = {}  # urlpath patterns which have no urlpath params
+      @variable_endpoints = []  # urlpath patterns which have any ulrpath param
+      @all_endpoints      = []  # all urlpath patterns (fixed + variable)
+      rexp_str = _compile_array(urlpath_mapping, '', '')
+      @urlpath_rexp       = Regexp.compile("\\A#{rexp_str}\\z")
       return self
     end
 
-    def _mount(mappings, urlpath_pattern, action_class)
-      child_mappings = nil
-      #; [!4l8xl] can accept array of pairs of urlpath and action class.
-      if action_class.is_a?(Array)
-        array = action_class
-        child_mappings = []
-        array.each {|upath, klass| _mount(child_mappings, upath, klass) }
-        action_class = nil
-      #; [!ne804] when target class name is string...
-      elsif action_class.is_a?(String)
-        str = action_class
-        action_class = _load_action_class(str, "mount('#{str}')")
-      #; [!lvxyx] raises error when not an action class.
-      else
-        action_class.is_a?(Class) && action_class < BaseAction  or
-          raise ArgumentError.new("mount('#{urlpath_pattern}'): Action class expected but got: #{action_class.inspect}")
-      end
-      #; [!30cib] raises error when action method is not defined in action class.
-      _validate_action_method_existence(action_class) if action_class
-      #; [!flb11] mounts action class to urlpath.
-      mappings << [urlpath_pattern, action_class || child_mappings]
-    end
-    private :_mount
-
-    def _validate_action_method_existence(action_class)
-      action_class._action_method_mapping.each do |_, action_methods|
-        action_methods.each do |req_meth, action_method_name|
-          action_class.method_defined?(action_method_name)  or
-            raise UnknownActionMethodError.new("#{req_meth.inspect}=>#{action_method_name.inspect}: unknown action method in #{action_class}.")
-        end
-      end
-    end
+    EMPTY_ARRAY = [].freeze     # :nodoc:
 
-    def _load_action_class(str, error)
-      #; [!9brqr] raises error when string format is invalid.
-      filepath, classname = str.split(/:/, 2)
-      classname  or
-        raise ArgumentError.new("#{error}: expected 'file/path:ClassName'.")
-      #; [!jpg56] loads file.
-      #; [!vaazw] raises error when failed to load file.
-      #; [!eiovd] raises original LoadError when it raises in loading file.
-      begin
-        require filepath
-      rescue LoadError => ex
-        raise unless ex.path == filepath
-        raise ArgumentError.new("#{error}: failed to require file.")
+    def lookup(req_urlpath)
+      #; [!j34yh] finds from fixed urlpaths at first.
+      if (tuple = @fixed_endpoints[req_urlpath])
+        _, action_class, action_methods = tuple
+        pnames = pvalues = EMPTY_ARRAY
+        return action_class, action_methods, pnames, pvalues
       end
-      #; [!au27n] finds target class.
-      #; [!k9bpm] raises error when target class not found.
-      begin
-        action_class = classname.split(/::/).inject(Object) {|c, x| c.const_get(x) }
-      rescue NameError
-        raise ArgumentError.new("#{error}: no such action class.")
+      #; [!uqwr7] uses LRU as cache algorithm.
+      cache = @urlpath_lru_cache
+      if cache && (result = cache.delete(req_urlpath))
+        cache[req_urlpath] = result    # delete & append to simulate LRU
+        return result
       end
-      #; [!t6key] raises error when target class is not an action class.
-      action_class.is_a?(Class) && action_class < BaseAction  or
-        raise ArgumentError.new("#{error}: not an action class.")
-      return action_class
-    end
-    private :_load_action_class
-
-    def traverse(&block)
-      _traverse(@mappings, "", &block)
-      self
-    end
-
-    def _traverse(mappings, base_urlpath_pat, &block)
-      #; [!ds0fp] yields with event (:enter, :map or :exit).
-      mappings.each do |urlpath_pattern, action_class|
-        yield :enter, base_urlpath_pat, urlpath_pattern, action_class, nil
-        curr_urlpath_pat = "#{base_urlpath_pat}#{urlpath_pattern}"
-        if action_class.is_a?(Array)
-          child_mappings = action_class
-          _traverse(child_mappings, curr_urlpath_pat, &block)
-        else
-          action_method_mapping = action_class._action_method_mapping
-          action_method_mapping.each do |upath_pat, action_methods|
-            yield :map, curr_urlpath_pat, upath_pat, action_class, action_methods
-          end
-        end
-        yield :exit, base_urlpath_pat, urlpath_pattern, action_class, nil
+      #; [!sos5i] returns nil when request path not matched to urlpath patterns.
+      m = @urlpath_rexp.match(req_urlpath)
+      return nil unless m
+      #; [!95q61] finds from variable urlpath patterns when not found in fixed ones.
+      index = m.captures.find_index('')
+      tuple = @variable_endpoints[index]
+      _, action_class, action_methods, urlpath_rexp, pnames, procs, range = tuple
+      #; [!1k1k5] converts urlpath param values by converter procs.
+      if range
+        str = req_urlpath[range]
+        pvalues = [procs[0] ? procs[0].call(str) : str]
+      else
+        strs = urlpath_rexp.match(req_urlpath).captures
+        pvalues = \
+          case procs.length
+          when 1; [procs[0] ? procs[0].call(strs[0]) : strs[0]]
+          when 2; [procs[0] ? procs[0].call(strs[0]) : strs[0],
+                   procs[1] ? procs[1].call(strs[1]) : strs[1]]
+          when 3; [procs[0] ? procs[0].call(strs[0]) : strs[0],
+                   procs[1] ? procs[1].call(strs[1]) : strs[1],
+                   procs[2] ? procs[2].call(strs[2]) : strs[2]]
+          else  ; procs.zip(strs).map {|pr, v| pr ? pr.call(v) : v }
+          end    # ex: ["123"] -> [123]
       end
+      #; [!jyxlm] returns action class and methods, parameter names and values.
+      result = [action_class, action_methods, pnames, pvalues]
+      #; [!uqwr7] stores result into cache if cache is enabled.
+      if cache
+        cache[req_urlpath] = result
+        #; [!3ps5g] deletes item from cache when cache size over limit.
+        cache.shift() if cache.length > @urlpath_cache_size
+      end
+      #
+      return result
     end
-    private :_traverse
 
-    def each_mapping
-      traverse() do
-        |event, base_urlpath_pat, urlpath_pat, action_class, action_methods|
-        next unless event == :map
-        full_urlpath_pat = "#{base_urlpath_pat}#{urlpath_pat}"
-        #; [!driqt] yields full urlpath pattern, action class and action methods.
-        yield full_urlpath_pat, action_class, action_methods
+    def each
+      #; [!2gwru] returns Enumerator if block is not provided.
+      return to_enum(:each) unless block_given?
+      #; [!7ynne] yields each urlpath pattern, action class and action methods.
+      @all_endpoints.each do |tuple|
+        urlpath_pat, action_class, action_methods, _ = tuple
+        yield urlpath_pat, action_class, action_methods
       end
       self
     end
 
-  end
-
-
-  class ActionFinder
-
-    def initialize(action_class_mapping, default_patterns=nil, urlpath_cache_size: 0)
-      @default_patterns = default_patterns || K8::DefaultPatterns.new
-      @urlpath_cache_size = urlpath_cache_size
-      #; [!wb9l8] enables urlpath cache when urlpath_cache_size > 0.
-      @urlpath_cache = urlpath_cache_size > 0 ? {} : nil   # LRU cache of variable urlpath
-      #; [!dnu4q] calls '#_construct()'.
-      _construct(action_class_mapping)
-    end
-
     private
 
-    def _construct(action_class_mapping)
-      ##
-      ## Example of @rexp:
-      ##     \A                                  # ...(0)
-      ##     (:?                                 # ...(1)
-      ##         /api                            # ...(2)
-      ##             (?:                         # ...(3)
-      ##                 /books                  # ...(2)
-      ##                     (?:                 # ...(3)
-      ##                         /\d+(\z)        # ...(4)
-      ##                     |                   # ...(5)
-      ##                         /\d+/edit(\z)   # ...(4)
-      ##                     )                   # ...(6)
-      ##             |                           # ...(7)
-      ##                 /authors                # ...(2)
-      ##                     (:?                 # ...(4)
-      ##                         /\d+(\z)        # ...(4)
-      ##                     |                   # ...(5)
-      ##                         /\d+/edit(\z)   # ...(4)
-      ##                     )                   # ...(6)
-      ##             )                           # ...(6)
-      ##     |                                   # ...(7)
-      ##         /admin                          # ...(2)
-      ##             (:?                         # ...(3)
-      ##                 ....
-      ##             )                           # ...(6)
-      ##     )                                   # ...(8)
-      ##
-      ## Example of @dict (fixed urlpaths):
-      ##     {
-      ##       "/api/books"                      # ...(9)
-      ##           => [BooksAction,   {:GET=>:do_index, :POST=>:do_create}],
-      ##       "/api/books/new"
-      ##           => [BooksAction,   {:GET=>:do_new}],
-      ##       "/api/authors"
-      ##           => [AuthorsAction, {:GET=>:do_index, :POST=>:do_create}],
-      ##       "/api/authors/new"
-      ##           => [AuthorsAction, {:GET=>:do_new}],
-      ##       "/admin/books"
-      ##           => ...
-      ##       ...
-      ##     }
-      ##
-      ## Example of @list (variable urlpaths):
-      ##     [
-      ##       [                                 # ...(10)
-      ##         %r'\A/api/books/(\d+)\z',
-      ##         ["id"], [proc {|x| x.to_i }],
-      ##         BooksAction,
-      ##         {:GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete},
-      ##       ],
-      ##       [
-      ##         %r'\A/api/books/(\d+)/edit\z',
-      ##         ["id"], [proc {|x| x.to_i }],
-      ##         BooksAction,
-      ##         {:GET=>:do_edit},
-      ##       ],
-      ##       ...
-      ##     ]
-      ##
-      @dict = {}
-      @list = []
-      #; [!956fi] builds regexp object for variable urlpaths (= containing urlpath params).
-      buf = ['\A']                         # ...(0)
-      buf << '(?:'                         # ...(1)
-      action_class_mapping.traverse do
-        |event, base_urlpath_pat, urlpath_pat, action_class, action_methods|
-        first_p = buf[-1] == '(?:'
-        case event
-        when :map
-          full_urlpath_pat = "#{base_urlpath_pat}#{urlpath_pat}"
-          if full_urlpath_pat =~ /\{.*?\}/
-            buf << '|' unless first_p      # ...(5)
-            buf << _compile(urlpath_pat, '', '(\z)').first  # ...(4)
-            full_urlpath_rexp_str, param_names, param_converters = \
-                _compile(full_urlpath_pat, '\A', '\z', true)
-            #; [!sl9em] builds list of variable urlpaths (= containing urlpath params).
-            @list << [Regexp.compile(full_urlpath_rexp_str),
-                      param_names, param_converters,
-                      action_class, action_methods]   # ...(9)
-          else
-            #; [!6tgj5] builds dict of fixed urlpaths (= no urlpath params).
-            @dict[full_urlpath_pat] = [action_class, action_methods] # ...(10)
-          end
-        when :enter
-          buf << '|' unless first_p        # ...(7)
-          buf << _compile(urlpath_pat, '', '').first  # ...(2)
-          buf << '(?:'                     # ...(3)
-        when :exit
-          if first_p
-            buf.pop()   # '(?:'
-            buf.pop()   # urlpath
-            buf.pop() if buf[-1] == '|'
-          else
-            buf << ')'                     # ...(6)
-          end
+    def _compile_array(mapping, base_urlpath_pat, urlpath_pat)
+      buf = []
+      curr_urlpath_pat = "#{base_urlpath_pat}#{urlpath_pat}"
+      mapping.each do |child_urlpath_pat, target|
+        child = child_urlpath_pat
+        #; [!w45ad] can compile nested array.
+        if target.is_a?(Array)
+          buf << _compile_array(target, curr_urlpath_pat, child)
+        #; [!wd2eb] accepts subclass of Action class.
+        elsif target.is_a?(Class) && target < Action
+          buf << _compile_class(target, curr_urlpath_pat, child)
+        #; [!l2kz5] requires library when filepath and classname specified.
+        elsif target.is_a?(String)
+          klass = _require_action_class(target)
+          buf << _compile_class(klass,  curr_urlpath_pat, child)
+        #; [!irt5g] raises TypeError when unknown object specified.
         else
-          raise "** internal error: event=#{event.inspect}"
+          raise TypeError.new("Action class or nested array expected, but got #{target.inspect}")
         end
       end
-      buf << ')'                           # ...(8)
-      @rexp = Regexp.compile(buf.join())
-      buf.clear()
-    end
-
-    def _compile(urlpath_pattern, start_pat='', end_pat='', grouping=false)
-      #; [!izsbp] compiles urlpath pattern into regexp string and param names.
-      #; [!olps9] allows '{}' in regular expression.
-      #parse_rexp = /(.*?)<(\w*)(?::(.*?))?>/
-      #parse_rexp = /(.*?)\{(\w*)(?::(.*?))?\}/
-      #parse_rexp  = /(.*?)\{(\w*)(?::(.*?(?:\{.*?\}.*?)*))?\}/
-      parse_rexp = /(.*?)\{(\w*)(?::([^{}]*?(?:\{[^{}]*?\}[^{}]*?)*))?\}/
-      param_names = []
-      converters  = []
-      s = ""
-      s << start_pat
-      urlpath_pattern.scan(parse_rexp) do |text, name, pat|
-        proc_ = nil
-        pat, proc_ = @default_patterns.lookup(name) if pat.nil? || pat.empty?
-        named = !name.empty?
-        param_names << name if named
-        converters << proc_ if named
-        #; [!vey08] uses grouping when 4th argument is true.
-        #; [!2zil2] don't use grouping when 4th argument is false.
-        #; [!rda92] ex: '/{id:\d+}' -> '/(\d+)'
-        #; [!jyz2g] ex: '/{:\d+}'   -> '/\d+'
-        #; [!hy3y5] ex: '/{:xx|yy}' -> '/(?:xx|yy)'
-        #; [!gunsm] ex: '/{id:xx|yy}' -> '/(xx|yy)'
-        if named && grouping
-          pat = "(#{pat})"
-        elsif pat =~ /\|/
-          pat = "(?:#{pat})"
+      #; [!bcgc9] skips classes which have only fixed urlpaths.
+      buf.compact!
+      rexp_str = _build_rexp_str(urlpath_pat, buf)
+      return rexp_str   # ex: '/api(?:/books/\d+(\z)|/authors/\d+(\z))'
+    end
+
+    def _compile_class(action_class, base_urlpath_pat, urlpath_pat)
+      buf = []
+      curr_urlpath_pat = "#{base_urlpath_pat}#{urlpath_pat}"
+      action_class._action_method_mapping.each do |child_urlpath_pat, methods|
+        #; [!ue766] raises error when action method is not defined in action class.
+        _validate_action_method_existence(action_class, methods)
+        #; ex: '/api/books/{id}' -> '\A/api/books/(\d+)\z', ['id'], [proc{|x| x.to_i}]
+        fullpath_pat = "#{curr_urlpath_pat}#{child_urlpath_pat}"
+        rexp_str, pnames, procs = _compile_urlpath_pat(fullpath_pat, true)
+        #; [!z2iax] classifies urlpath contains any parameter as variable one.
+        if pnames
+          fullpath_rexp = Regexp.compile("\\A#{rexp_str}\\z")
+          range = @enable_urlpath_param_range ? _range_of_urlpath_param(fullpath_pat) : nil
+          tuple = [fullpath_pat, action_class, methods, fullpath_rexp, pnames.freeze, procs, range]
+          @variable_endpoints << tuple
+          buf << (_compile_urlpath_pat(child_urlpath_pat).first << '(\z)')
+        #; [!rvdes] classifies urlpath contains no parameters as fixed one.
+        else
+          tuple = [fullpath_pat, action_class, methods]
+          @fixed_endpoints[fullpath_pat] = tuple
         end
-        s << Regexp.escape(text) << pat
+        #
+        @all_endpoints << tuple
       end
-      m = Regexp.last_match
-      rest = m ? m.post_match : urlpath_pattern
-      s << Regexp.escape(rest) << end_pat
-      ## ex: ['/api/books/(\d+)', ["id"], [proc {|x| x.to_i }]]
-      return s, param_names, converters
-    end
-
-    public
-
-    def find(req_path)
-      action_class, action_methods = @dict[req_path]
-      if action_class
-        #; [!p18w0] urlpath params are empty when matched to fixed urlpath pattern.
-        param_names  = []
-        param_values = []
-      #; [!gzy2w] fetches variable urlpath from LRU cache if LRU cache is enabled.
-      elsif (cache = @urlpath_cache) && (tuple = cache.delete(req_path))
-        cache[req_path] = tuple   # Hash in Ruby >=1.9 keeps keys' order!
-        action_class, action_methods, param_names, param_values = tuple
-      else
-        #; [!ps5jm] returns nil when not matched to any urlpath patterns.
-        m = @rexp.match(req_path)      or return nil
-        i = m.captures.find_index('')  or return nil
-        #; [!t6yk0] urlpath params are not empty when matched to variable urlpath apttern.
-        (full_urlpath_rexp,   # ex: /\A\/api\/books\/(\d+)\z/
-         param_names,         # ex: ["id"]
-         param_converters,    # ex: [proc {|x| x.to_i }]
-         action_class,        # ex: BooksAction
-         action_methods,      # ex: {:GET=>:do_show, :PUT=>:do_edit, ...}
-        ) = @list[i]
-        #; [!0o3fe] converts urlpath param values according to default patterns.
-        values = full_urlpath_rexp.match(req_path).captures
-        procs = param_converters
-        #param_values = procs.zip(values).map {|pr, v| pr ? pr.call(v) : v }
-        param_values = \
-            case procs.length
-            when 1; pr0 = procs[0]
-                    [pr0 ? pr0.call(values[0]) : values[0]]
-            when 2; pr0, pr1 = procs
-                    [pr0 ? pr0.call(values[0]) : values[0],
-                     pr1 ? pr1.call(values[1]) : values[1]]
-            else  ; procs.zip(values).map {|pr, v| pr ? pr.call(v) : v }
-            end    # ex: ["123"] -> [123]
-        #; [!v2zbx] caches variable urlpath into LRU cache if cache is enabled.
-        #; [!nczw6] LRU cache size doesn't growth over max cache size.
-        if cache
-          cache.shift() if cache.length > @urlpath_cache_size - 1
-          cache[req_path] = [action_class, action_methods, param_names, param_values]
+      #; [!6xwhq] builds action infos for each action methods.
+      action_class._build_action_info(curr_urlpath_pat) if action_class
+      #
+      rexp_str = _build_rexp_str(urlpath_pat, buf)
+      return rexp_str    # ex: '/books(?:/\d+(\z)|/\d+/edit(\z))'
+    end
+
+    ## ex: '/books', ['/\d+', '/\d+/edit']  ->  '/books(?:/\d+|/\d+/edit)'
+    def _build_rexp_str(urlpath_pat, buf)
+      return nil if buf.empty?
+      prefix = _compile_urlpath_pat(urlpath_pat).first
+      #; [!169ad] removes unnecessary grouping.
+      return "#{prefix}#{buf.first}" if buf.length == 1
+      return "#{prefix}(?:#{buf.join('|')})"
+    ensure
+      buf.clear()   # for GC
+    end
+
+    #; [!92jcn] '{' and '}' are available in urlpath param pattern.
+    #URLPATH_PARAM_REXP = /\{(\w*)(?::(.*?))?\}/
+    #URLPATH_PARAM_REXP = /\{(\w*)(?::(.*?(?:\{.*?\}.*?)*))?\}/
+    URLPATH_PARAM_REXP = /\{(\w*)(?::([^{}]*?(?:\{[^{}]*?\}[^{}]*?)*))?\}/
+    URLPATH_PARAM_REXP_NOGROUP = /\{(?:\w*)(?::(?:[^{}]*?(?:\{[^{}]*?\}[^{}]*?)*))?\}/
+    proc {|rx1, rx2|
+      rx1.source.gsub(/\(([^?])/, '(?:\1') == rx2.source  or
+        raise "*** assertion failed: #{rx1.source.inspect} != #{rx2.source.inspect}"
+    }.call(URLPATH_PARAM_REXP, URLPATH_PARAM_REXP_NOGROUP)
+
+    ## ex: '/books/{id}', true  ->  ['/books/(\d+)', ['id'], [proc{|x| x.to_i}]]
+    def _compile_urlpath_pat(urlpath_pat, enable_capture=false)
+      #; [!iln54] param names and conveter procs are nil when no urlpath params.
+      pnames = nil   # urlpath parameter names  (ex: ['id'])
+      procs  = nil   # proc objects to convert parameter value (ex: [proc{|x| x.to_i}])
+      #
+      rexp_str = urlpath_pat.gsub(URLPATH_PARAM_REXP) {
+        pname, s, proc_ = $1, $2, nil
+        s, proc_ = @default_patterns.lookup(pname) if s.nil?
+        #; [!lhtiz] skips empty param name.
+        #; [!66zas] skips param name starting with '_'.
+        skip = pname.empty? || pname.start_with?('_')
+        pnames ||= []; pnames << pname unless skip
+        procs  ||= []; procs  << proc_ unless skip
+        #; [!bi7gr] captures urlpath params when 2nd argument is truthy.
+        #; [!mprbx] ex: '/{id:x|y}' -> '/(x|y)', '/{:x|y}' -> '/(?:x|y)'
+        if enable_capture && ! skip
+          s = "(#{s})"
+        elsif s =~ /\|/
+          s = "(?:#{s})"
         end
-      end
-      #; [!ndktw] returns action class, action methods, urlpath names and values.
-      ## ex: [BooksAction, {:GET=>:do_show}, ["id"], [123]]
-      return action_class, action_methods, param_names, param_values
-    end
-
-  end
-
-
-  ## Router consists of urlpath mapping and finder.
-  class ActionRouter
-
-    def initialize(urlpath_cache_size: 0)
-      @mapping = ActionClassMapping.new
-      @default_patterns = DefaultPatterns.new
-      @finder  = nil
-      #; [!l1elt] saves finder options.
-      @finder_opts = {:urlpath_cache_size=>urlpath_cache_size}
-    end
-
-    attr_reader :default_patterns
-
-    def register(urlpath_param_name, default_pattern='[^/]*?', &converter)
-      #; [!boq80] registers urlpath param pattern and converter.
-      @default_patterns.register(urlpath_param_name, default_pattern, &converter)
-      self
-    end
-
-    def mount(urlpath_pattern, action_class)
-      #; [!uc996] mouts action class to urlpath.
-      @mapping.mount(urlpath_pattern, action_class)
-      #; [!trs6w] removes finder object.
-      @finder = nil
-      self
+        s
+      }
+      #; [!awfgs] returns regexp string, param names, and converter procs.
+      return rexp_str, pnames, procs   # ex: '/books/(\d+)', ['id'], [proc{|x| x.to_i}]}]
     end
 
-    def each_mapping(&block)
-      #; [!2kq9h] yields with full urlpath pattern, action class and action methods.
-      @mapping.each_mapping(&block)
+    ## raises error when action method is not defined in action class
+    def _validate_action_method_existence(action_class, action_methods)
+      action_methods.each do |req_meth, action_method_name|
+        action_class.method_defined?(action_method_name)  or
+          raise UnknownActionMethodError.new("#{req_meth.inspect}=>#{action_method_name.inspect}: unknown action method in #{action_class}.")
+      end
     end
 
-    def find(req_path)
-      #; [!zsuzg] creates finder object automatically if necessary.
-      #; [!9u978] urlpath_cache_size keyword argument will be passed to router oubject.
-      @finder ||= ActionFinder.new(@mapping, @default_patterns, @finder_opts)
-      #; [!m9klu] returns action class, action methods, urlpath param names and values.
-      return @finder.find(req_path)
+    ## range object to retrieve urlpath parameter value faster than Regexp matching
+    ## ex:
+    ##   urlpath_pat == '/books/{id}/edit'
+    ##   arr = urlpath_pat.split(/\{.*?\}/, -1)           #=> ['/books/', '/edit']
+    ##   range = (arr[0].length .. - (arr[01].length+1))  #=> 7..-6 (Range object)
+    ##   p "/books/123/edit"[range]                       #=> '123'
+    def _range_of_urlpath_param(urlpath_pattern)
+      rexp = URLPATH_PARAM_REXP_NOGROUP
+      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
+
+    ## ex: './api/admin/books:Admin::BookAPI'  ->  Admin::BookAPI
+    def _require_action_class(filepath_and_classname)
+      #; [!px9jy] requires file and finds class object.
+      str = filepath_and_classname   # ex: './admin/api/book:Admin::BookAPI'
+      filepath, classname = filepath_and_classname.split(':', 2)
+      begin
+        require filepath
+      rescue LoadError => ex
+        #; [!dlcks] don't rescue LoadError when it is not related to argument.
+        raise unless ex.path == filepath
+        #; [!mngjz] raises error when failed to load file.
+        raise LoadError.new("'#{str}': cannot load '#{filepath}'.")
+      end
+      #; [!8n6pf] class name may have module prefix name.
+      #; [!6lv7l] raises error when action class not found.
+      begin
+        klass = classname.split('::').inject(Object) {|cls, x| cls.const_get(x) }
+      rescue NameError
+        raise NameError.new("'#{str}': class not found (#{classname}).")
+      end
+      #; [!thf7t] raises TypeError when not a class.
+      klass.is_a?(Class)  or
+        raise TypeError.new("'#{str}': class name expected but got #{klass.inspect}.")
+      #; [!yqcgx] raises TypeError when not a subclass of K8::Action.
+      klass < Action  or
+        raise TypeError.new("'#{str}': expected subclass of K8::Action but not.")
+      #
+      return klass
     end
 
   end
@@ -1444,52 +1442,18 @@ module K8
 
   class RackApplication
 
-    def initialize(urlpath_mapping=[], urlpath_cache_size: 0)
-      @router = ActionRouter.new(urlpath_cache_size: urlpath_cache_size)
-      init_default_param_patterns(@router.default_patterns)
-      #; [!vkp65] mounts urlpath mappings if provided.
-      urlpath_mapping.each do |urlpath, klass|
-        @router.mount(urlpath, klass)
-      end if urlpath_mapping
-    end
-
-    def init_default_param_patterns(default_patterns)
-      #; [!i51id] registers '\d+' as default pattern of param 'id' or /_id\z/.
-      x = default_patterns
-      x.register('id',    '\d+') {|val| val.to_i }
-      x.register(/_id\z/, '\d+') {|val| val.to_i }
-      #; [!2g08b] registers '(?:\.\w+)?' as default pattern of param 'ext'.
-      x.register('ext',   '(?:\.\w+)?')
-      #; [!8x5mp] registers '\d\d\d\d-\d\d-\d\d' as default pattern of param 'date' or /_date\z/.
-      to_date = proc {|val|
-        #; [!wg9vl] raises 404 error when invalid date (such as 2012-02-30).
-        yr, mo, dy = val.split(/-/).map(&:to_i)
-        Date.new(yr, mo, dy)  rescue
-          raise HttpException.new(404, "#{val}: invalid date.")
-      }
-      x.register('date',    '\d\d\d\d-\d\d-\d\d', &to_date)
-      x.register(/_date\z/, '\d\d\d\d-\d\d-\d\d', &to_date)
+    def initialize(urlpath_mapping=[], default_patterns: DEFAULT_PATTERNS, urlpath_cache_size: 0,
+                                       enable_urlpath_param_range: true)
+      #; [!vkp65] mounts urlpath mappings.
+      @mapping = ActionMapping.new(urlpath_mapping,
+                                   default_patterns:    default_patterns,
+                                   urlpath_cache_size:  urlpath_cache_size,
+                                   enable_urlpath_param_range: enable_urlpath_param_range)
     end
-    protected :init_default_param_patterns
 
-    ##
-    ## ex:
-    ##   mount '/',         WelcomeAction
-    ##   mount '/books',    BooksAction
-    ##   mount '/admin',    [
-    ##           ['/session',    AdminSessionAction],
-    ##           ['/books',      AdminBooksAction],
-    ##         ]
-    ##
-    def mount(urlpath_pattern, action_class_or_array)
-      #; [!zwva6] mounts action class to urlpath pattern.
-      @router.mount(urlpath_pattern, action_class_or_array)
-      return self
-    end
-
-    def find(req_path)
+    def lookup(req_path)
       #; [!o0rnr] returns action class, action methods, urlpath names and values.
-      return @router.find(req_path)
+      return @mapping.lookup(req_path)
     end
 
     def call(env)
@@ -1512,8 +1476,16 @@ module K8
         req_meth_ = req_meth
       end
       begin
+        tuple4 = lookup(req.path)
+        #; [!vz07j] redirects only when request method is GET or HEAD.
+        if tuple4.nil? && req_meth_ == :GET
+          #; [!eb2ms] returns 301 when urlpath not found but found with tailing '/'.
+          #; [!02dow] returns 301 when urlpath not found but found without tailing '/'.
+          location = lookup_autoredirect_location(req)
+          return [301, {'Location'=>location}, []] if location
+        end
         #; [!rz13i] returns HTTP 404 when urlpath not found.
-        tuple4 = find(req.path)  or
+        tuple4  or
           raise HttpException.new(404)
         action_class, action_methods, urlpath_param_names, urlpath_param_values = tuple4
         #; [!rv3cf] returns HTTP 405 when urlpath found but request method not allowed.
@@ -1579,11 +1551,19 @@ END
       return false
     end
 
+    def lookup_autoredirect_location(req)
+      location = req.path.end_with?('/') ? req.path[0..-2] : "#{req.path}/"
+      return nil unless lookup(location)
+      #; [!2a9c9] adds query string to 'Location' header.
+      qs = req.env['QUERY_STRING']
+      return qs && ! qs.empty? ? "#{location}?#{qs}" : location
+    end
+
     public
 
     def each_mapping(&block)
       #; [!cgjyv] yields full urlpath pattern, action class and action methods.
-      @router.each_mapping(&block)
+      @mapping.each(&block)
       self
     end
 
@@ -1789,245 +1769,4 @@ END
   end
 
 
-  module Mock
-
-
-    module_function
-
-    def new_env(meth=:GET, path="/", query: nil, form: nil, multipart: nil, json: nil, input: nil, headers: nil, cookie: nil, env: nil)
-      #uri = "http://localhost:80#{path}"
-      #opts["REQUEST_METHOD"] = meth
-      #env = Rack::MockRequest.env_for(uri, opts)
-      require 'stringio' unless defined?(StringIO)
-      https = env && (env['rack.url_scheme'] == 'https' || env['HTTPS'] == 'on')
-      #
-      err = proc {|a, b|
-        ArgumentError.new("new_env(): not allowed both '#{a}' and '#{b}' at a time.")
-      }
-      ctype = nil
-      if form
-        #; [!c779l] raises ArgumentError when both form and json are specified.
-        ! json  or raise err.call('form', 'json')
-        input = Util.build_query_string(form)
-        ctype = "application/x-www-form-urlencoded"
-      end
-      if json
-        ! multipart  or raise err.call('json', 'multipart')
-        input = json.is_a?(String) ? json : JSON.dump(json)
-        ctype = "application/json"
-      end
-      if multipart
-        ! form  or raise err.call('multipart', 'form')
-        #; [!gko8g] 'multipart:' kwarg accepts Hash object (which is converted into multipart data).
-        if multipart.is_a?(Hash)
-          dict = multipart
-          multipart = dict.each_with_object(MultipartBuilder.new) do |(k, v), mp|
-            v.is_a?(File) ? mp.add_file(k, v) : mp.add(k, v.to_s)
-          end
-        end
-        input = multipart.to_s
-        m = /\A--(\S+)\r\n/.match(input)  or
-          raise ArgumentError.new("invalid multipart format.")
-        boundary = $1
-        ctype = "multipart/form-data; boundary=#{boundary}"
-      end
-      environ = {
-        "rack.version"      => [1, 3],
-        "rack.input"        => StringIO.new(input || ""),
-        "rack.errors"       => StringIO.new,
-        "rack.multithread"  => true,
-        "rack.multiprocess" => true,
-        "rack.run_once"     => false,
-        "rack.url_scheme"   => https ? "https" : "http",
-        "REQUEST_METHOD"    => meth.to_s,
-        "SERVER_NAME"       => "localhost",
-        "SERVER_PORT"       => https ? "443" : "80",
-        "QUERY_STRING"      => Util.build_query_string(query || ""),
-        "PATH_INFO"         => path,
-        "HTTPS"             => https ? "on" : "off",
-        "SCRIPT_NAME"       => "",
-        "CONTENT_LENGTH"    => (input ? input.bytesize.to_s : "0"),
-        "CONTENT_TYPE"      => ctype,
-      }
-      environ.delete("CONTENT_TYPE") if environ["CONTENT_TYPE"].nil?
-      headers.each do |name, value|
-        name =~ /\A[a-zA-Z0-9]+(?:-[a-zA-Z0-9]+)*\z/  or
-          raise ArgumentError.new("invalid http header name: #{name.inspect}")
-        value.is_a?(String)  or
-          raise ArgumentError.new("http header value should be a string but got: #{value.inspect}")
-        ## ex: 'X-Requested-With' -> 'HTTP_X_REQUESTED_WITH'
-        k = "HTTP_#{name.upcase.gsub(/-/, '_')}"
-        environ[k] = value
-      end if headers
-      env.each do |name, value|
-        case name
-        when /\Arack\./
-          # ok
-        when /\A[A-Z]+(_[A-Z0-9]+)*\z/
-          value.is_a?(String)  or
-            raise ArgumentError.new("rack env value should be a string but got: #{value.inspect}")
-        else
-          raise ArgumentError.new("invalid rack env key: #{name}")
-        end
-        environ[name] = value
-      end if env
-      if cookie
-        s = ! cookie.is_a?(Hash) ? cookie.to_s : cookie.map {|k, v|
-          "#{Util.percent_encode(k)}=#{Util.percent_encode(v)}"
-        }.join('; ')
-        s = "#{environ['HTTP_COOKIE']}; #{s}" if environ['HTTP_COOKIE']
-        environ['HTTP_COOKIE'] = s
-      end
-      return environ
-    end
-
-
-    class MultipartBuilder
-
-      def initialize(boundary=nil)
-        #; [!ajfgl] sets random string as boundary when boundary is nil.
-        @boundary = boundary || Util.randstr_b64()
-        @params = []
-      end
-
-      attr_reader :boundary
-
-      def add(name, value, filename=nil, content_type=nil)
-        #; [!tp4bk] detects content type from filename when filename is not nil.
-        content_type ||= Util.guess_content_type(filename) if filename
-        @params << [name, value, filename, content_type]
-        self
-      end
-
-      def add_file(name, file, content_type=nil)
-        #; [!uafqa] detects content type from filename when content type is not provided.
-        content_type ||= Util.guess_content_type(file.path)
-        #; [!b5811] reads file content and adds it as param value.
-        add(name, file.read(), File.basename(file.path), content_type)
-        #; [!36bsu] closes opened file automatically.
-        file.close()
-        self
-      end
-
-      def to_s
-        #; [!61gc4] returns multipart form string.
-        boundary = @boundary
-        s = "".force_encoding('ASCII-8BIT')
-        @params.each do |name, value, filename, content_type|
-          s <<   "--#{boundary}\r\n"
-          if filename
-            s << "Content-Disposition: form-data; name=\"#{name}\"; filename=\"#{filename}\"\r\n"
-          else
-            s << "Content-Disposition: form-data; name=\"#{name}\"\r\n"
-          end
-          s <<   "Content-Type: #{content_type}\r\n" if content_type
-          s <<   "\r\n"
-          s <<   value.force_encoding('ASCII-8BIT')
-          s <<   "\r\n"
-        end
-        s <<     "--#{boundary}--\r\n"
-        return s
-      end
-
-    end
-
-
-    ##
-    ## Wrapper class to test Rack application.
-    ##
-    ## ex:
-    ##   http = K8::Mock::TestApp.new(app)
-    ##   resp = http.GET('/api/hello', query={'name'=>'World'})
-    ##   assert_equal 200, resp.status
-    ##   assert_equal "application/json", resp.headers['Content-Type']
-    ##   assert_equal {"message"=>"Hello World!"}, resp.body_json
-    ##
-    class TestApp
-
-      def initialize(app=nil)
-        @app = app
-      end
-
-      def request(meth, path, query: nil, form: nil, multipart: nil, json: nil, input: nil, headers: nil, cookie: nil, env: nil)
-        #; [!4xpwa] creates env object and calls app with it.
-        env = K8::Mock.new_env(meth, path, query: query, form: form, multipart: multipart, json: json, input: input, headers: headers, cookie: cookie, env: env)
-        status, headers, body = @app.call(env)
-        return TestResponse.new(status, headers, body)
-      end
-
-      def GET     path, kwargs={}; request(:GET    , path, kwargs); end
-      def POST    path, kwargs={}; request(:POST   , path, kwargs); end
-      def PUT     path, kwargs={}; request(:PUT    , path, kwargs); end
-      def DELETE  path, kwargs={}; request(:DELETE , path, kwargs); end
-      def HEAD    path, kwargs={}; request(:HEAD   , path, kwargs); end
-      def PATCH   path, kwargs={}; request(:PATCH  , path, kwargs); end
-      def OPTIONS path, kwargs={}; request(:OPTIONS, path, kwargs); end
-      def TRACE   path, kwargs={}; request(:TRACE  , path, kwargs); end
-
-    end
-
-
-    class TestResponse
-
-      def initialize(status, headers, body)
-        @status  = status
-        @headers = headers
-        @body    = body
-      end
-
-      attr_accessor :status, :headers, :body
-
-      def body_binary
-        #; [!mb0i4] returns body as binary string.
-        s = @body.join()
-        @body.close() if @body.respond_to?(:close)
-        return s
-      end
-
-      def body_text
-        #; [!rr18d] error when 'Content-Type' header is missing.
-        ctype = @headers['Content-Type']  or
-          raise "body_text(): missing 'Content-Type' header."
-        #; [!dou1n] converts body text according to 'charset' in 'Content-Type' header.
-        if ctype =~ /; *charset=(\w[-\w]*)/
-          charset = $1
-        #; [!cxje7] assumes charset as 'utf-8' when 'Content-Type' is json.
-        elsif ctype == "application/json"
-          charset = 'utf-8'
-        #; [!n4c71] error when non-json 'Content-Type' header has no 'charset'.
-        else
-          raise "body_text(): missing 'charset' in 'Content-Type' header."
-        end
-        #; [!vkj9h] returns body as text string, according to 'charset' in 'Content-Type'.
-        return body_binary().force_encoding(charset)
-      end
-
-      def body_json
-        #; [!qnic1] returns Hash object representing JSON string.
-        return JSON.parse(body_text())
-      end
-
-      def content_type
-        #; [!40hcz] returns 'Content-Type' header value.
-        return @headers['Content-Type']
-      end
-
-      def content_length
-        #; [!5lb19] returns 'Content-Length' header value as integer.
-        #; [!qjktz] returns nil when 'Content-Length' is not set.
-        len = @headers['Content-Length']
-        return len ? len.to_i : len
-      end
-
-      def location
-        #; [!8y8lg] returns 'Location' header value.p
-        return @headers['Location']
-      end
-
-    end
-
-
-  end
-
-
 end