rack-jet_router 1.3.1 → 1.4.0

data/lib/rack/jet_router.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 ###
-### $Release: 1.3.1 $
+### $Release: 1.4.0 $
 ### $Copyright: copyright(c) 2015 kwatch@gmail.com $
 ### $License: MIT License $
 ###
@@ -56,22 +56,17 @@ module Rack
   ##     status, headers, body = router.call(env)
   ##
   ## Example #3:
-  ##     class Map < Hash         # define subclass of Hash
-  ##     end
-  ##     def Map(**kwargs)        # define helper method to create Map object easily
-  ##       return Map.new.update(kwargs)
-  ##     end
   ##     mapping = {
-  ##         "/"                       => Map(GET: home_app),
+  ##         "/"                       => {GET: home_app},  # not {"GET"=>home_app}
   ##         "/api" => {
-  ##             "/books" => {
-  ##                 ""                => Map(GET: book_list_app, POST: book_create_app),
-  ##                 "/:id(.:format)"  => Map(GET: book_show_app, PUT: book_update_app),
-  ##                 "/:book_id/comments/:comment_id" => Map(POST: comment_create_app),
+  ##             "/books" => {            # not {"GET"=>..., "POST"=>...}
+  ##                 ""                => {GET: book_list_app, POST: book_create_app},
+  ##                 "/:id(.:format)"  => {GET: book_show_app, PUT: book_update_app},
+  ##                 "/:book_id/comments/:comment_id" => {POST: comment_create_app},
   ##             },
   ##         },
   ##         "/admin" => {
-  ##             "/books"              => Map(ANY: admin_books_app),
+  ##             "/books"              => {ANY: admin_books_app},  # not {"ANY"=>...}
   ##         },
   ##     }
   ##     router = Rack::JetRouter.new(mapping)
@@ -81,7 +76,7 @@ module Rack
   ##
   class JetRouter
 
-    RELEASE = '$Release: 1.3.1 $'.split()[1]
+    RELEASE = '$Release: 1.4.0 $'.split()[1]
 
     #; [!haggu] contains available request methods.
     REQUEST_METHODS = %w[GET POST PUT DELETE PATCH HEAD OPTIONS TRACE LINK UNLINK] \
@@ -136,15 +131,33 @@ module Rack
       #
       #; [!x2l32] gathers all endpoints.
       builder = Builder.new(self, _enable_range)
+      param_rexp = /[:*]\w+|\(.*?\)/
+      tmplist = []
       builder.traverse_mapping(mapping) do |path, item|
         @all_endpoints << [path, item]
+        #; [!l63vu] handles urlpath pattern as fixed when no urlpath params.
+        if path !~ param_rexp
+          @fixed_endpoints[path] = item
+        #; [!ec0av] treats '/foo(.html|.json)' as three fixed urlpaths.
+        #; [!ylyi0] stores '/foo' as fixed path when path pattern is '/foo(.:format)'.
+        elsif path =~ /\A([^:*\(\)]*)\(([^\(\)]+)\)\z/
+          @fixed_endpoints[$1] = item unless $1.empty?
+          arr = []
+          $2.split('|').each do |s|
+            next if s.empty?
+            if s.include?(':')
+              arr << s
+            else
+              @fixed_endpoints[$1 + s] = item
+            end
+          end
+          tmplist << ["#{$1}(#{arr.join('|')})", item] unless arr.empty?
+        else
+          tmplist << [path, item]
+        end
       end
-      #; [!l63vu] handles urlpath pattern as fixed when no urlpath params.
-      param_rexp = /:\w+|\(.*?\)/
-      pairs1, pairs2 = @all_endpoints.partition {|path, _| path =~ param_rexp }
-      pairs2.each {|path, item| @fixed_endpoints[path] = item }
       #; [!saa1a] compiles compound urlpath regexp.
-      tree = builder.build_tree(pairs1)
+      tree = builder.build_tree(tmplist)
       @urlpath_rexp = builder.build_rexp(tree) do |tuple|
         #; [!f1d7s] builds variable endpoint list.
         @variable_endpoints << tuple
@@ -213,11 +226,12 @@ module Rack
       index = m.captures.index('')
       return nil unless index
       #; [!ijqws] returns mapped object and urlpath parameter values when urlpath found.
-      full_urlpath_rexp, param_names, obj, range = @variable_endpoints[index]
+      full_urlpath_rexp, param_names, obj, range, sep = @variable_endpoints[index]
       if range
         ## "/books/123"[7..-1] is faster than /\A\/books\/(\d+)\z/.match("/books/123")[1]
         str = req_path[range]
-        values = [str]
+        ## `"/a/1/b/2"[3..-1].split('/b/')` is faster than `%r!\A/a/(\d+)/b/(\d+)\z!.match("/a/1/b/2").captures`
+        values = sep ? str.split(sep) : [str]
       else
         m = full_urlpath_rexp.match(req_path)
         values = m.captures
@@ -343,7 +357,7 @@ module Rack
         mapping.each do |sub_path, item|
           full_path = base_path + sub_path
           #; [!2ntnk] nested dict mapping can have subclass of Hash as handlers.
-          if item.class == mapping_class
+          if _submapping?(item, mapping_class)
             #; [!dj0sh] traverses mapping recursively.
             _traverse_mapping(item, full_path, mapping_class, &block)
           else
@@ -355,6 +369,13 @@ module Rack
         end
       end
 
+      def _submapping?(item, mapping_class)
+        #; [!qlp3f] returns false if item is like '{GET: ...}'.
+        return false if item.is_a?(Hash) && item.keys.all? {|k| k.is_a?(Symbol) }
+        #; [!1pmtl] returns true only if item class is same as mapping_class.
+        return item.class == mapping_class
+      end
+
       def _normalize_method_mapping(dict)
         return @router.normalize_method_mapping(dict)
       end
@@ -364,47 +385,66 @@ module Rack
       def build_tree(entrypoint_pairs)
         #; [!6oa05] builds nested hash object from mapping data.
         tree = {}         # tree is a nested dict
-        param_d = {}
+        pnames_d = {}
         entrypoint_pairs.each do |path, item|
           d = tree
           sb = ['\A']
-          pos = 0
-          params = []
-          #; [!uyupj] handles urlpath parameter such as ':id'.
-          #; [!j9cdy] handles optional urlpath parameter such as '(.:format)'.
-          path.scan(/:(\w+)|\((.*?)\)/) do
-            param = $1; optional = $2         # ex: $1=='id' or $2=='.:format'
-            m = Regexp.last_match()
-            str = path[pos, m.begin(0) - pos]
-            pos = m.end(0)
-            #; [!akkkx] converts urlpath param into regexp.
-            pat1, pat2 = _param_patterns(param, optional) do |param_|
-              param_.freeze
-              params << (param_d[param_] ||= param_)
-            end
-            #; [!po6o6] param regexp should be stored into nested dict as a Symbol.
+          pnames = _parse_path(path, sb, pnames_d) do |str, pat1|
+            #; [!po6o6] param regexp should be stored into nested dict as a Regexp.
             d = _next_dict(d, str) unless str.empty?
-            d = (d[pat1.intern] ||= {})       # ex: pat1=='[^./?]+'
-            #; [!zoym3] urlpath string should be escaped.
-            sb << Regexp.escape(str) << pat2  # ex: pat2=='([^./?]+)'
-          end
-          #; [!o642c] remained string after param should be handled correctly.
-          str = pos == 0 ? path : path[pos..-1]
-          unless str.empty?
-            d = _next_dict(d, str)
-            sb << Regexp.escape(str)          # ex: str=='.html'
+            d = (d[Regexp.compile(pat1).freeze] ||= {}) if pat1   # ex: pat1=='[^./?]+'
           end
           sb << '\z'
+          rexp = Regexp.compile(sb.join())
           #; [!kz8m7] range object should be included into tuple if only one param exist.
-          range = @enable_range ? _range_of_urlpath_param(path) : nil
+          if @enable_range
+            range, separator = _range_of_urlpath_param(path)
+          else
+            range = separator = nil
+          end
           #; [!c6xmp] tuple should be stored into nested dict with key 'nil'.
-          d[nil] = [Regexp.compile(sb.join()), params, item, range]
+          d[nil] = [rexp, pnames, item, range, separator]
         end
         return tree
       end
 
       private
 
+      def _parse_path(path, sb, pnames_d, &b)
+        pos = 0
+        pnames = []
+        #; [!uyupj] handles urlpath parameter such as ':id'.
+        #; [!k7oxt] handles urlpath parameter such as ':filepath'.
+        #; [!j9cdy] handles optional urlpath parameter such as '(.:format)'.
+        path.scan(/([:*]\w+)|\((.*?)\)/) do
+          param = $1; optional = $2         # ex: $1=='id' or $2=='.:format'
+          m = Regexp.last_match()
+          str = path[pos, m.begin(0) - pos]
+          pos = m.end(0)
+          #; [!akkkx] converts urlpath param into regexp.
+          #; [!lwgt6] handles '|' (OR) pattern in '()' such as '(.html|.json)'.
+          pat1, pat2 = _param_patterns(param, optional) do |pname|
+            pname.freeze
+            pnames << (pnames_d[pname] ||= pname)
+          end
+          yield str, pat1
+          #; [!zoym3] urlpath string should be escaped.
+          sb << Regexp.escape(str) << pat2  # ex: pat2=='([^./?]+)'
+          #; [!2axyy] raises error if '*path' param is not at end of path.
+          if param =~ /\A\*/
+            pos == path.length  or
+              raise ArgumentError.new("#{path}: Invalid path parameter ('#{param}' should be at end of the path).")
+          end
+        end
+        #; [!o642c] remained string after param should be handled correctly.
+        str = pos == 0 ? path : path[pos..-1]
+        unless str.empty?
+          yield str, nil
+          sb << Regexp.escape(str)          # ex: str=='.html'
+        end
+        return pnames
+      end
+
       def _next_dict(d, str)
         #; [!s1rzs] if new key exists in dict...
         if d.key?(str)
@@ -419,7 +459,7 @@ module Rack
           if found
             #; [!5fh08] keeps order of keys in dict.
             d[key] = d.delete(key)
-          #; [!4wdi7] ignores Symbol key (which represents regexp).
+          #; [!4wdi7] ignores non-string key (which represents regexp).
           #; [!66sdb] ignores nil key (which represents leaf node).
           elsif key.is_a?(String) && key[0] == c
             found = true
@@ -472,10 +512,13 @@ module Rack
 
       def _param_patterns(param, optional, &callback)
         #; [!j90mw] returns '[^./?]+' and '([^./?]+)' if param specified.
+        #; [!jbvyb] returns '.*' and '(.*)' if param is like '*filepath'.
         if param
           optional == nil  or raise "** internal error"
-          yield param
-          pat1 = _param2rexp(param)     # ex: '[^./?]+'
+          param =~ /\A([:*])(\w+)\z/  or raise "** internal error"
+          pname = $2
+          yield pname
+          pat1 = $1 == '*' ? '.*' : _param2rexp(pname)  # ex: '[^./?]+'
           pat2 = "(#{pat1})"
         #; [!raic7] returns '(?:\.[^./?]+)?' and '(?:\.([^./?]+))?' if optional param is '(.:format)'.
         elsif optional == ".:format"
@@ -485,12 +528,16 @@ module Rack
         #; [!69yj9] optional string can contains other params.
         elsif optional
           sb = ['(?:']
-          optional.scan(/(.*?)(?::(\w+))/) do |str, param_|
-            pat = _param2rexp(param)                  # ex: pat == '[^./?]+'
-            sb << Regexp.escape(str) << "<<#{pat}>>"  # ex: sb << '(?:\.<<[^./?]+>>)?'
-            yield param_
+          #; [!oh9c6] optional string can have '|' (OR).
+          optional.split('|').each_with_index do |string, i|
+            sb << '|' if i > 0
+            string.scan(/(.*?)(?::(\w+))/) do |str, pname|
+              pat = _param2rexp(pname)                  # ex: pat == '[^./?]+'
+              sb << Regexp.escape(str) << "<<#{pat}>>"  # ex: sb << '(?:\.<<[^./?]+>>)?'
+              yield pname
+            end
+            sb << Regexp.escape($' || string)
           end
-          sb << Regexp.escape($' || optional)
           sb << ')?'
           s = sb.join()
           pat1 = s.gsub('<<', '' ).gsub('>>', '' )    # ex: '(?:\.[^./?]+)?'
@@ -528,23 +575,33 @@ module Rack
           case k
           when nil    ; sb << '(\z)'           ; yield v
           when String ; sb << Regexp.escape(k) ; _build_rexp(v, sb, &b)
-          when Symbol ; sb << k.to_s           ; _build_rexp(v, sb, &b)
+          when Regexp ; sb << k.source         ; _build_rexp(v, sb, &b)
           else        ; raise "** internal error"
           end
         end
         sb << ')' if nested_dict.length > 1
       end
 
-      def _range_of_urlpath_param(urlpath_pattern)      # ex: '/books/:id/edit'
+      def _range_of_urlpath_param(urlpath_pattern)      # ex: '/books/:id/comments/:comment_id.json'
         #; [!93itq] returns nil if urlpath pattern includes optional parameters.
         return nil if urlpath_pattern =~ /\(/
         #; [!syrdh] returns Range object when urlpath_pattern contains just one param.
+        #; [!elsdx] returns Range and separator string when urlpath_pattern contains two params.
         #; [!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)
+        rexp = /[:*]\w+/
+        arr = urlpath_pattern.split(rexp, -1)   # ex: ['/books/', '/comments/', '.json']
+        case arr.length
+        when 2                                  # ex: arr == ['/books/', '.json']
+          range = arr[0].length .. -(arr[1].length+1)
+          return range, nil                     # ex: (7..-6), nil
+        when 3                                  # ex: arr == ['/books/', '/comments/', '.json']
+          return nil if arr[1].empty?
+          range = arr[0].length .. -(arr[2].length+1)
+          return range, arr[1]                  # ex: (7..-6), '/comments/'
+        else
+          return nil
+        end
       end
 
     end

data/rack-jet_router.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "rack-jet_router"
-  spec.version       = "$Release: 1.3.1 $".split()[1]
+  spec.version       = "$Release: 1.4.0 $".split()[1]
   spec.author        = "kwatch"
   spec.email         = "kwatch@gmail.com"
   spec.platform      = Gem::Platform::RUBY

data/test/builder_test.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 ###
-### $Release: 1.3.1 $
+### $Release: 1.4.0 $
 ### $Copyright: copyright(c) 2015 kwatch@gmail.com $
 ### $License: MIT License $
 ###
@@ -25,6 +25,8 @@ Oktest.scope do
     comment_create_api     = proc {|env| [200, {}, ["comment_create_api"]]}
     comment_update_api     = proc {|env| [200, {}, ["comment_update_api"]]}
     #
+    staticfile_api   = proc {|env| [200, {}, ["staticfile_api"]]}
+    #
 
     def _find(d, k)
       return d.key?(k) ? d[k] : _find(d.to_a[0][1], k)
@@ -49,21 +51,21 @@ Oktest.scope do
         id = '[^./?]+'
         ok {dict} == {
           "/api/books/" => {
-            :'[^./?]+' => {
+            /[^.\/?]+/ => {
               nil => [/\A\/api\/books\/(#{id})\z/,
-                      ["id"], book_show_api, 11..-1],
+                      ["id"], book_show_api, 11..-1, nil],
               "/" => {
                 "edit" => {
                   nil => [/\A\/api\/books\/(#{id})\/edit\z/,
-                          ["id"], book_edit_api, 11..-6],
+                          ["id"], book_edit_api, 11..-6, nil],
                 },
                 "comments" => {
                   nil => [/\A\/api\/books\/(#{id})\/comments\z/,
-                          ["book_id"], comment_create_api, 11..-10],
+                          ["book_id"], comment_create_api, 11..-10, nil],
                   "/" => {
-                    :'[^./?]+' => {
+                    /[^.\/?]+/ => {
                       nil => [/\A\/api\/books\/(#{id})\/comments\/(#{id})\z/,
-                              ["book_id", "comment_id"], comment_update_api, nil],
+                              ["book_id", "comment_id"], comment_update_api, (11..-1), '/comments/'],
                     },
                   },
                 },
@@ -82,14 +84,14 @@ Oktest.scope do
         id = '[^./?]+'
         ok {dict} == {
           "/api/books/" => {
-            :"[^./?]+" => {
+            /[^.\/?]+/ => {
               "/comments" => {
                 nil => [%r`\A/api/books/(#{id})/comments\z`,
-                        ["book_id"], {"POST"=>comment_create_api}, (11..-10)],
+                        ["book_id"], {"POST"=>comment_create_api}, (11..-10), nil],
                 "/" => {
-                  :"[^./?]+" => {
+                  /[^.\/?]+/ => {
                     nil => [%r`\A/api/books/(#{id})/comments/(#{id})\z`,
-                            ["book_id", "id"], {"PUT"=>comment_update_api}, nil],
+                            ["book_id", "id"], {"PUT"=>comment_update_api}, (11..-1), '/comments/'],
                   },
                 },
               },
@@ -98,6 +100,20 @@ Oktest.scope do
         }
       end
 
+      spec "[!k7oxt] handles urlpath parameter such as ':filepath'." do
+        endpoint_pairs = [
+          ["/static/*filepath"    , {"GET"=>staticfile_api}],
+        ]
+        dict = @builder.build_tree(endpoint_pairs)
+        ok {dict} == {
+          "/static/" => {
+            /.*/ => {
+              nil => [/\A\/static\/(.*)\z/, ["filepath"], {"GET"=>staticfile_api}, (8..-1), nil],
+            },
+          },
+        }
+      end
+
       spec "[!j9cdy] handles optional urlpath parameter such as '(.:format)'." do
         endpoint_pairs = [
           ["/api/books(.:format)"    , {"GET"=>book_list_api}],
@@ -107,14 +123,14 @@ Oktest.scope do
         id = '[^./?]+'
         ok {dict} == {
           "/api/books" => {
-            :"(?:\\.[^./?]+)?" => {
+            /(?:\.[^.\/?]+)?/ => {
               nil => [%r`\A/api/books(?:\.(#{id}))?\z`,
-                      ["format"], {"GET"=>book_list_api}, nil]},
+                      ["format"], {"GET"=>book_list_api}, nil, nil]},
             "/" => {
-              :"[^./?]+" => {
-                :"(?:\\.[^./?]+)?" => {
+              /[^.\/?]+/ => {
+                /(?:\.[^.\/?]+)?/ => {
                   nil => [%r`\A/api/books/(#{id})(?:\.(#{id}))?\z`,
-                          ["id", "format"], {"GET"=>book_show_api}, nil],
+                          ["id", "format"], {"GET"=>book_show_api}, nil, nil],
                 },
               },
             },
@@ -132,12 +148,22 @@ Oktest.scope do
         ok {tuple[0]} == %r`\A/api/books/(#{id})\z`
       end
 
-      spec "[!po6o6] param regexp should be stored into nested dict as a Symbol." do
+      spec "[!lwgt6] handles '|' (OR) pattern in '()' such as '(.html|.json)'." do
+        endpoint_pairs = [
+          ["/api/books/:id(.html|.json)", book_show_api],
+        ]
+        dict = @builder.build_tree(endpoint_pairs)
+        tuple = _find(dict, nil)
+        id = '[^./?]+'
+        ok {tuple[0]} == %r`\A/api/books/(#{id})(?:\.html|\.json)?\z`
+      end
+
+      spec "[!po6o6] param regexp should be stored into nested dict as a Regexp." do
         endpoint_pairs = [
           ["/api/books/:id", book_show_api],
         ]
         dict = @builder.build_tree(endpoint_pairs)
-        ok {dict["/api/books/"].keys()} == [:'[^./?]+']
+        ok {dict["/api/books/"].keys()} == [/[^.\/?]+/]
       end
 
       spec "[!zoym3] urlpath string should be escaped." do
@@ -150,6 +176,15 @@ Oktest.scope do
         ok {tuple[0]} == %r`\A/api/books\.dir\.tmp/(#{id})\.tar\.gz\z`
       end
 
+      spec "[!2axyy] raises error if '*path' param is not at end of path." do
+        endpoint_pairs = [
+          ["/static/*filepath.css", staticfile_api],
+        ]
+        pr = proc { @builder.build_tree(endpoint_pairs) }
+        ok {pr}.raise?(ArgumentError,
+                       "/static/*filepath.css: Invalid path parameter ('*filepath' should be at end of the path).")
+      end
+
       spec "[!o642c] remained string after param should be handled correctly." do
         endpoint_pairs = [
           ["/api/books/:id(.:format)(.gz)", book_show_api],
@@ -168,7 +203,7 @@ Oktest.scope do
         tuple = _find(dict, nil)
         id = '[^./?]+'
         ok {tuple} == [%r`\A/api/books/(#{id})\.json\z`,
-                       ["id"], book_show_api, (11..-6)]
+                       ["id"], book_show_api, (11..-6), nil]
       end
 
       spec "[!c6xmp] tuple should be stored into nested dict with key 'nil'." do
@@ -179,10 +214,10 @@ Oktest.scope do
         id = '[^./?]+'
         ok {dict} == {
           "/api/books/" => {
-            :"[^./?]+" => {
+            /[^.\/?]+/ => {
               ".json" => {
                 nil => [%r`\A/api/books/(#{id})\.json\z`,
-                        ["id"], book_show_api, (11..-6)],
+                        ["id"], book_show_api, (11..-6), nil],
               },
             },
           },
@@ -324,6 +359,29 @@ Oktest.scope do
     end
 
 
+    topic '#_submapping?()' do
+
+      spec "[!qlp3f] returns false if item is like '{GET: ...}'." do
+        x = @builder.instance_eval { _submapping?({GET: 1, POST: 2}, Hash) }
+        ok {x} == false
+        x = @builder.instance_eval { _submapping?({"GET"=>1}, Hash) }
+        ok {x} == true
+      end
+
+      spec "[!1pmtl] returns true only if item class is same as mapping_class." do
+        x = @builder.instance_eval { _submapping?({"GET"=>1}, Hash) }
+        ok {x} == true
+        x = @builder.instance_eval { _submapping?(["GET", 1], Array) }
+        ok {x} == true
+        x = @builder.instance_eval { _submapping?({"GET"=>1}, Array) }
+        ok {x} == false
+        x = @builder.instance_eval { _submapping?(Map("GET"=>1), Array) }
+        ok {x} == false
+      end
+
+    end
+
+
     topic '#_next_dict()' do
 
       case_when "[!s1rzs] if new key exists in dict..." do
@@ -358,13 +416,13 @@ Oktest.scope do
         ok {dict.keys} == ["aa1", "bb", "cc1"]
       end
 
-      spec "[!4wdi7] ignores Symbol key (which represents regexp)." do
-        dict = {"aa1" => {"aa2"=>10}, :"bb1" => {"bb2"=>20}}
+      spec "[!4wdi7] ignores non-string key (which represents regexp)." do
+        dict = {"aa1" => {"aa2"=>10}, /bb1/ => {"bb2"=>20}}
         d2 = @builder.instance_eval { _next_dict(dict, "bb1") }
         ok {d2} == {}
         ok {dict} == {
           "aa1" => {"aa2"=>10},
-          :"bb1" => {"bb2"=>20},
+          /bb1/ => {"bb2"=>20},
           "bb1" => {},
         }
         ok {dict["bb1"]}.same?(d2)
@@ -477,12 +535,20 @@ Oktest.scope do
 
       spec "[!j90mw] returns '[^./?]+' and '([^./?]+)' if param specified." do
         x = nil
-        s1, s2 = @builder.instance_eval { _param_patterns("id", nil) {|a| x = a } }
+        s1, s2 = @builder.instance_eval { _param_patterns(":id", nil) {|a| x = a } }
         ok {s1} == '[^./?]+'
         ok {s2} == '([^./?]+)'
         ok {x} == "id"
       end
 
+      spec "[!jbvyb] returns '.*' and '(.*)' if param is like '*filepath'." do
+        x = nil
+        s1, s2 = @builder.instance_eval { _param_patterns("*filepath", nil) {|a| x = a } }
+        ok {s1} == '.*'
+        ok {s2} == '(.*)'
+        ok {x} == "filepath"
+      end
+
       spec "[!raic7] returns '(?:\.[^./?]+)?' and '(?:\.([^./?]+))?' if optional param is '(.:format)'." do
         x = nil
         s1, s2 = @builder.instance_eval { _param_patterns(nil, ".:format") {|a| x = a } }
@@ -499,6 +565,14 @@ Oktest.scope do
         ok {arr} == ["yr", "mo", "dy"]
       end
 
+      spec "[!oh9c6] optional string can have '|' (OR)." do
+        arr = []
+        s1, s2 = @builder.instance_eval { _param_patterns(nil, ".html|.json") {|a| arr << a } }
+        ok {s1} == '(?:\.html|\.json)?'
+        ok {s2} == '(?:\.html|\.json)?'
+        ok {arr} == []
+      end
+
     end
 
 
@@ -507,12 +581,12 @@ Oktest.scope do
       spec "[!65yw6] converts nested dict into regexp." do
         dict = {
           "/api/books/" => {
-            :"[^./?]+" => {
+            /[^.\/?]+/ => {
               nil => [],
               "/comments" => {
                 nil => [],
                 "/" => {
-                  :"[^./?]+" => {
+                  /[^.\/?]+/ => {
                     nil => [],
                   },
                 },
@@ -528,10 +602,10 @@ Oktest.scope do
       spec "[!hs7vl] '(?:)' and '|' are added only if necessary." do
         dict = {
           "/api/books/" => {
-            :"[^./?]+" => {
+            /[^.\/?]+/ => {
               "/comments" => {
                 "/" => {
-                  :"[^./?]+" => {
+                  /[^.\/?]+/ => {
                     nil => [],
                   },
                 },
@@ -547,11 +621,11 @@ Oktest.scope do
       spec "[!7v7yo] nil key means leaf node and yields block argument." do
         dict = {
           "/api/books/" => {
-            :"[^./?]+" => {
+            /[^.\/?]+/ => {
               nil => [9820],
               "/comments" => {
                 "/" => {
-                  :"[^./?]+" => {
+                  /[^.\/?]+/ => {
                     nil => [1549],
                   },
                 },
@@ -569,7 +643,7 @@ Oktest.scope do
       spec "[!hda6m] string key should be escaped." do
         dict = {
           "/api/books/" => {
-            :"[^./?]+" => {
+            /[^.\/?]+/ => {
               ".json" => {
                 nil => [],
               }
@@ -584,7 +658,7 @@ Oktest.scope do
       spec "[!b9hxc] symbol key means regexp string." do
         dict = {
           "/api/books/" => {
-            :'\d+' => {
+            /\d+/ => {
               nil => [],
             },
           },
@@ -607,19 +681,33 @@ Oktest.scope do
 
       spec "[!syrdh] returns Range object when urlpath_pattern contains just one param." do
         @builder.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'
+          t = _range_of_urlpath_param('/books/:id')
+          _.ok {t} == [(7..-1), nil]
+          _.ok {'/books/123'[t[0]]} == '123'
+          #
+          t = _range_of_urlpath_param('/books/:id.html')
+          _.ok {t} == [(7..-6), nil]
+          _.ok {'/books/4567.html'[t[0]]} == '4567'
+        end
+      end
+
+      spec "[!elsdx] returns Range and separator string when urlpath_pattern contains two params." do
+        @builder.instance_exec(self) do |_|
+          t = _range_of_urlpath_param('/books/:id/comments/:comment_id.json')
+          _.ok {t} == [(7..-6), '/comments/']
+          _.ok {'/books/123/comments/456.json'[t[0]]} == "123/comments/456"
+          _.ok {'/books/123/comments/456.json'[t[0]].split(t[1])} == ["123", "456"]
+          #
+          t = _range_of_urlpath_param('/books/:id/comments/:comment_id')
+          _.ok {t} == [(7..-1), '/comments/']
+          _.ok {'/books/123/comments/456'[t[0]]} == "123/comments/456"
+          _.ok {'/books/123/comments/456'[t[0]].split(t[1])} == ["123", "456"]
         end
       end
 
       spec "[!skh4z] returns nil when urlpath_pattern contains more than two params." do
         @builder.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
+          _.ok {_range_of_urlpath_param('/books/:book_id/comments/:c_id/foo/:foo_id')} == nil
         end
       end