keight 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5674423ea6090c2163b9bff12f3ec5f2a1542dce
-  data.tar.gz: ecde3e22c5720bfd8be224b45bb3f2e28db092dc
+  metadata.gz: 923c4e6baf4553cb3047243d07112aa60766c9b1
+  data.tar.gz: 2027f244a4b0f0b1d77a641a97ee3764c553f442
 SHA512:
-  metadata.gz: 0a976045af16e6ff169a3fe46decb0b9c0fe8d30ed4848dc8d5669298766c3651be375c2dc4690614f3b740c4b599ec209594d82203aaf3e3f05397f1eade1a3
-  data.tar.gz: 75720c41ec1250de00b5aeb2c1ed332b674d6c90e7a238bf4263fc1226caf9eedabb9c7d00ca1278f4a9d0609e9f59110d01e0b8e60f7e525d045e01bf744467
+  metadata.gz: f26f07c359d237c4e39ddde6e7003ad3de3f2e60b3e2b1847649708fdc22c75b4d49e88bc5dce10097058f4d435921611a99f22d1957a2850cad76a18e58d739
+  data.tar.gz: 8cc8943acb7246deb713802de0dc4873de70c62e7bed6431cdbe34503fe29d269b749090172ff4e407ab01c00f1c4250324064df239fd7484d96fa574738e0db

data/CHANGES.md

@@ -0,0 +1,237 @@
+Changes
+=======
+
+Release 0.3.0 (2016-10-13)
+--------------------------
+
+### Enhancements
+
+* URL path parameter format can accept parameter type (`int`, `str`, `date`).  
+  ex: `/api/books/{id:int}`, `/blog/{entry_date:date}`
+
+* `K8::Util::TemporaryFile` class added. It allows you to create temporary
+  file which will be removed automatically *after* sending response body.  
+  See document of `K8::Util::TemporaryFile` for details.
+
+* `K8::Util::ShellCommand` class added. It allows you to send command output
+  as response body. For example, execute SQL, convert into CSV, and send it
+  as response.  
+  See document of `K8::Util::ShellCommand` for details.
+
+* `@action_args` is available in `K8::Action` class.  
+  `@action_args` represents URL path parameter arguments.  
+  For example, `@action_args == [123]` when urlpath pattern is `/books/{id}`
+  and request path is `/books/123`.
+
+* `@req.params_form()`, `@req.params_multipart()` and `@req.params_json()`
+  now take max content length.  
+  ex:
+
+      strs = @req.params_form(10*1024*104)  # max: 10MB
+      strs = @req.params_form               # same as above
+
+      strs, files = @req.params_multipart(100*1024*1024)  # max: 100MB
+      strs, files = @req.params_multipart                 # same as above
+
+      hash = @req.params_json(10*1024*104)  # max: 10MB
+      hash = @req.params_json               # same as above
+
+* Add `K8::ActionMapping#urlpath_rexp`.
+  You can confirm regexp of action mapping by that attribute.  
+  ex:
+
+      ## what regexp is used for request routing?
+      mappings = [
+        ['/api', [
+          ['/books',    BooksAction],
+          ['/authors',  AuthorsAction],
+        ]
+      ]
+      p K8::ActionMapping.new(mapping).urlpath_rexp
+
+* Regard '.*' at end of urlpath pattern as extension pattern.  
+  ex:
+
+      class BooksAPI < K8::Action
+
+        ## ex: '.*' is same as '{_:<(?:\.\w+)?>}'
+        mapping '.*'     , :GET=>:do_index
+
+        ## ex: '/{id}.*' is same as '/{id}{_:<(?:\.\w+)?>}'
+        mapping '/{id}.*', :GET=>:do_show
+
+        def do_index
+          p @req.path_ext    #=> ex: '.json', '.html', etc
+        end
+        def do_show(id)
+          p @req.path_ext    #=> ex: '.json', '.html', etc
+        end
+      end
+
+* Define `@req.path_ext` which returns such as `.json` or `.html`.
+
+* Define `@resp.status_line` which returns such as `"200 OK"` or `"302 Found"`.
+
+* `@resp.set_cookie()` now accepts Time object as `expires` keyword arg.
+
+* New HTTP response status codes are added.  
+  #
+
+      103 Checkpoint                           # Unofficial
+      306 Switch Proxy                         # -
+      308 Permanent Redirect                   # RFC 7538
+      421 Misdirected Request                  # RFC 7540
+      428 Precondition Required                # RFC 6585
+      429 Too Many Requests                    # RFC 6585
+      431 Request Header Fields Too Large      # RFC 6585
+      444 No Response                          # nginx
+      451 Unavailable For Legal Reasons        # -
+      495 SSL Certificate Error                # nginx
+      496 SSL Certificate Required             # nginx
+      497 HTTP Request Sent to HTTPS Port      # nginx
+      499 Client Closed Request                # nginx
+      509 Bandwidth Limit Exceeded             # Apache Web Server/cPanel
+      511 Network Authentication Required      # RFC 6585
+      520 Unknown Error                        # CloudFlare
+      521 Web Server Is Down                   # CloudFlare
+      522 Connection Timed Out                 # CloudFlare
+      523 Origin Is Unreachable                # CloudFlare
+      524 A Timeout Occurred"                  # CloudFlare
+      525 SSL Handshake Failed                 # CloudFlare
+      526 Invalid SSL Certificate              # CloudFlare
+
+* `k8rb cdnjs` now calls CDNJS.com api instead of scraping HTML page.
+
+
+### Incomppatible changes
+
+* URL path parameter format is changed.  
+  (old) `/books/{id:\d+}`  
+  (new) `/books/{id:int}` or `/books/{id:int<\d+>}`  
+  See document for details.
+
+* Rename `@req.method` to `@req.meth`.  
+  `@req.method` is also available, but not recommended. Use `@req.meth`.
+
+* Rename `K8::BaseAction[]#method` to `K8::BaseAction[]#meth`.  
+  ex:
+
+      p BooksAction[:do_show].meth     #=> :GET
+      p BooksAction[:do_update].meth   #=> :PUT
+      p BooksAction[:do_delete].meth   #=> :DELETE
+
+* Rename `K8::BaseAction[]#urlpath()` to `BooksAction[]#path()`.  
+  ex:
+
+      p BooksAction[:do_show].path(123)     #=> "/api/books/123"
+      p BooksAction[:do_update].path(123)   #=> "/api/books/123"
+      p BooksAction[:do_delete].path(123)   #=> "/api/books/123"
+
+* Rename `@current_action` to `@action_name` in `K8::Action` class.
+  It represents current action name, such as `:do_index` or `:do_show`.
+
+* `@req.params` now raises `K8::PayloadParseError` for JSON data,
+  because `@req.params` should return hash object of string, but
+  JSON data contains non-string values.
+  Use `@req.json` instead fo `@req.params`.
+
+* `@req.params` now raises `K8::PayloadParseError` for multipart data,
+  because `@req.params` should return hash object of string, but
+  multipart form contains file data which is not a string value.
+  Use `@req.multipart` instead fo `@req.params`.
+
+* Rename `K8::Request` class to `K8::RackRequest`.
+
+* Rename `K8::Response` class to `K8::RackResponse`.
+
+* Rename `K8::REQUEST_CLASS` to `K8::RackApplication::REQUEST_CLASS`.
+* Rename `K8::RESPONSE_CLASS` to `K8::RackApplication::RESPONSE_CLASS`.
+* Move `K8::ActionMapping#lookup()` to `K8::RackApplication` class.
+* Remove 'K8::DefaultPatterns' class.
+* Remove 'K8::DEFAULT_PATTERNS' object.
+
+* `k8rb mapping` command is removed. Use `rake mapping` instead.
+* `k8rb configs` command is removed. Use `rake configs` instead.
+
+* Remove `K8::BaseConfig` and `K8::SecretValue` classes.
+  Use 'benry-config' gem instead.
+
+* Remove 'keight/skeleton/*' files. File are moved to
+  https://github.com/kwatch/keight-ruby-boilerpl8/releases .
+
+* Remove `K8::RackApplicaiton#lookup_autoredirect_location()`.
+
+
+### Changes
+
+* Rewrite `K8::ActionMapping` class entirely.
+* Remove `K8::ActionMethodMapping` class.
+* Rewrite `K8::RackRequest#params_form`, `#params_multipart` and `#params_json`.
+* Move session initialization code from `K8::BaseAction` to `K8::Action`.
+* Remove dependency to `baby_erubis` gem.
+
+
+Release 0.2.0 (2016-01-06)
+--------------------------
+
+* [change] `K8::RackApplication#mount()` is removed.  
+  Use `K8::RackApplication.new([...])` instead.
+
+* [change] `k8rb init` is renamed to `k8rb project`.  
+  ex:
+
+      $ k8rb project myapp1
+      $ cd myapp1
+
+* [enhance] Auto redirection support.
+  For example, `GET /books` is defined and `GET /books/` is requested,
+  then it will be redirected to `GET /books`.
+
+* [enhance] Performance improved for variable urlpath.
+
+* [enhance] Implement urlpath helpers.  
+  ex:
+
+      p BookAPI[:do_update].method          #=> :PUT
+      p BookAPI[:do_update].urlpath(123)    #=> '/api/books/123'
+      p BookAPI[:do_update].form_action_attr(123)  #=> '/api/books/123?_method=PUT'
+
+* [change] `k8rb mapping` now prints output in text format, not YAML format.
+
+* [enhance] `k8rb mapping` supports `--format=FORMAT` option.  
+  ex:
+
+      $ k8rb mapping --format=text   # or yaml/json/javascript/jquery/angular
+
+* [enhance] `k8rb` command supports `cdnjs` action which download JavaScript
+  libraries from cdnjs.com.  
+  ex:
+
+      $ k8rb cdnjs                   # list library
+      $ k8rb cdnjs 'jquery*'         # search library
+      $ k8rb cdnjs jquery            # list versions
+      $ k8rb cdnjs jquery 2.1.4      # download library
+
+* [change] `k8rb init` command downloads jquery and modernizr from cdnjs.com.
+
+* [change] `K8::Mock` and `K8::TestApp` are removed.
+  Use rack-test_app gem instead.
+
+* [bugfix] Document fixed.
+
+* [internal] Remove `K8::ActionClassMapping`, `K8::ActionRouter` and
+  `K8::ActionFinder` classes.
+
+* [internal] Define new class `K8::ActionMapping` instead of remove classes.
+
+
+Release 0.1.0 (2015-10-27)
+--------------------------
+
+* Public release
+
+
+Release 0.0.1 (2015-10-26)
+--------------------------
+
+* Test release

data/README.md

@@ -1,14 +1,14 @@
 Keight.rb README
 ================
 
-($Release: 0.2.0 $)
+($Release: 0.3.0 $)
 
 
 Overview
 --------
 
 Keight.rb is the very fast web application framework for Ruby.
-It is about 100 times faster than Rails and 20 times faster than Sinatra.
+It runs about 100 times faster than Rails, and 20 times faster than Sinatra.
 
 *Keight.rb is under development and is subject to change without notice.*
 
@@ -50,7 +50,7 @@ $ export PATH=$GEM_HOME/bin:$PATH
 $ gem install keight
 $ vi hello.rb      # see below
 $ vi config.ru     # != 'config.rb'
-$ rackup -p 8000 config.ru
+$ rackup -p 4423 config.ru
 ```
 
 hello.rb:
@@ -65,13 +65,14 @@ class HelloAction < K8::Action
   mapping '/{id}'  , :GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete
 
   def do_index
-    #{"message"=>"Hello"}   # JSON
-    "<h1>Hello</h1>"        # HTML
+    return {"message"=>"Hello"}   # JSON
+    #return "<h1>Hello</h1>"      # HTML
   end
 
   def do_show(id)
     ## 'id' or 'xxx_id' will be converted into integer.
-    "<h1>Hello: id=#{id.inspect}</h1>"
+    return {"id"=>id}
+    #return "<h1>id=#{id.inspect}</h1>"
   end
 
   def do_create    ; "<p>create</p>"; end
@@ -86,13 +87,12 @@ config.ru:
 ```ruby
 # -*- coding: utf-8 -*-
 require 'keight'
-require './hello'
 
 mapping = [
   ['/api', [
-    ['/hello'     , HelloAction],
-    ## or
-    #['/hello'    , "./hello:HelloAction"],
+    ['/hello'    , "./hello:HelloAction"],
+    ### or
+    #['/hello'     , HelloAction],
   ]],
 ]
 app = K8::RackApplication.new(mapping)
@@ -100,31 +100,54 @@ app = K8::RackApplication.new(mapping)
 run app
 ```
 
-Open http://localhost:8000/api/hello or http://localhost:8000/api/hello/123
+Open http://localhost:4423/api/hello or http://localhost:4423/api/hello/123
 with your browser.
 
-Do you like it? If so, try `k8rb project myapp1` to generate project skeleton.
+How do you like it? Try the following steps to generate your project.
 
 ```console
 $ mkdir gems                         # if necessary
 $ export GEM_HOME=$PWD/gems          # if necessary
 $ export PATH=$GEM_HOME/bin:$PATH    # if necessary
-$ gem install -N keight
-$ k8rb help                          # show help
-$ k8rb project myapp1                # create new project
-$ cd myapp1/
-$ rake setup                         # install gems and download libs
-$ export APP_ENV=dev    # 'dev', 'prod', or 'stg'
-$ k8rb help mapping
-$ k8rb mapping                       # list urlpath mappings
-$ k8rb mapping --format=javascript   # or jquery,angular,json,yaml
-$ k8rb configs                       # list config parameters
-$ rake server port=8000
-$ open http://localhost:8000/
-$ ab -n 10000 -c 100 http://localhost:8000/api/hello
+
+$ gem install keight    # or: gem install boilerpl8
+$ k8rb project myapp1   # or: boilerpl8 github:kwatch/keight-ruby myapp1
+## select CSS framework
+**    1. None
+**    2. Bootstrap
+**    3. Pure (recommended)
+** Which CSS framework do you like? [1-3]: 1
+
+$ cd myapp1
+$ export APP_MODE=dev                # 'dev', 'prod', or 'stg'
+$ rake -T
+$ ls public
+$ rake server port=4423
+$ open http://localhost:4423/
+$ ab -n 10000 -c 100 http://localhost:4423/api/hello.json
 ```
 
 
+Command `k8rb`
+--------------
+
+Keight.rb provices `k8rb`.
+
+* `k8rb project myapp1` creates new project.  
+  (Note: This is equvarent to `boilerpl8 github:kwatch/keight-ruby myapp1`.)
+
+* `k8rb cdnjs -d static/lib jquery 3.1.0` downloads jQuery files
+  from cdnjs.com and stores into `static/lib` directory.  
+  (Note: This is equivarent to `cdnget cdnjs jquery 3.1.0 static/lib`.)
+
+`k8rb` command is provided mainly for backward compatibility.
+You can use [boilerpl8](https://github.com/kwatch/boilerpl8/tree/ruby)
+and [cdnget](https://github.com/kwatch/cdnget/tree/ruby-release)
+inead of `k8rb project` and `k8rb cdnjs`.
+`k8rb` is specific to Keight.rb, but both boilerpl8 and cdnget are
+available in any project.
+
+
 CheatSheet
 ----------
 
@@ -134,8 +157,8 @@ require 'keight'
 class HelloAction < K8::Action
 
   ## mapping
-  mapping '',              :GET=>:do_hello_world
-  mapping '/{name:\w+}',   :GET=>:do_hello
+  mapping ''             , :GET=>:do_hello_world
+  mapping '/{name:str}'  , :GET=>:do_hello
 
   ## request, response, and helpers
 
@@ -148,14 +171,16 @@ class HelloAction < K8::Action
     ## request
     @req                   # K8::Request object (!= Rack::Request)
     @req.env               # Rack environment
-    @req.method            # ex: :GET, :POST, :PUT, ...
+    @req.meth              # ex: :GET, :POST, :PUT, ...
     @req.request_method    # ex: "GET", "POST", "PUT", ...
-    @req.path              # ex: '/api/hello'
+    @req.path              # ex: '/api/hello.json'
+    @req.path_ext          # ex: '.json'
+    @req.query_string      # query string (String)
     @req.query             # query string (Hash)
     @req.form              # form data (Hash)
     @req.multipart         # multipart form data ([Hash, Hash])
     @req.json              # JSON data (Hash)
-    @req.params            # query, form, multipart or json
+    @req.params            # query or form (not multipart nor json!)
     @req.cookies           # cookies (Hash)
     @req.xhr?              # true when requested by jQuery etc
     @req.client_ip_addr    # ex: '127.0.0.1'
@@ -163,11 +188,16 @@ class HelloAction < K8::Action
     ## response
     @resp                  # K8::Response object (!= Rack::Response)
     @resp.status_code      # ex: 200
+    @resp.status_code=(i)  # ex: i=200
+    @resp.status_line      # ex: "200 OK"
     @resp.status           # alias of @resp.status_code
+    @resp.status=(i)       # alias of @resp.status_code=(i)
     @resp.headers          # Hash object
     @resp.set_cookie(k, v) # cookie
-    @resp.content_type     # same as @resp.headers['Content-Type']
-    @resp.content_length   # same as @resp.headers['Content-Length'].to_i
+    @resp.content_type        # same as @resp.headers['Content-Type']
+    @resp.content_type=(s)    # same as @resp.headers['Content-Type'] = s
+    @resp.content_length      # same as @resp.headers['Content-Length']
+    @resp.content_length=(i)  # same as @resp.headers['Content-Length'] = i.to_s
 
     ## session (requires Rack::Session)
     @sess[key] = val       # set session data
@@ -175,7 +205,7 @@ class HelloAction < K8::Action
 
     ## helpers
     token = csrf_token()   # get csrf token
-    validation_failed()    # same as @resp.status_code = 422
+    validation_failed()    # same as @resp.status = 422
     return redirect_to(location, 302, flash: "message")
     return send_file(filepath)
 
@@ -195,20 +225,24 @@ class HelloAction < K8::Action
   def handle_content(content)   # convert content
     if content.is_a?(Hash)
       @resp.content_type = 'application/json'
-      return [JSON.dump(content)]
+      return JSON.dump(content)
     end
     super
   end
 
   def handle_exception(ex)   # exception handler
-    meth = "on_#{ex.class.name}"
-    return __send__(meth, ex) if respond_to?(meth)
+    proc_ = WHEN_RAISED[ex.class]
+    return self.instance_exec(ex, &proc_) if proc_
     super
   end
 
+  WHEN_RAISED = {}
+  WHEN_RAISED[NotFound]     = proc {|ex| ... }
+  WHEN_RAISED[NotPermitted] = proc {|ex| ... }
+
   def csrf_protection_required?
     x = @req.method
-    return x == :POST || x == :PUT || x == :DELETE
+    return x == :POST || x == :PUT || x == :DELETE || x == :PATCH
   end
 
 end
@@ -219,7 +253,7 @@ urlpath_mapping = [
   ['/api', [
     ['/books'        , './app/api/books:BooksAPI'],
     ['/books/{book_id}/comments'
-                     , './app/api/book_comments:BookCommentsAPI'],
+                     , './app/api/books:BookCommentsAPI'],
     ['/orders'       , './app/api/orders:OrdersAPI'],
   ]],
 ]
@@ -231,13 +265,136 @@ opts = {
 app = K8::RackApplication.new(urlpath_mapping, opts)
 
 ## misc
-p HelloAction[:do_update].method        #=> :GET
-p HelloAction[:do_update].urlpath(123)  #=> "/api/books/123"
+p HelloAction[:do_update].meth          #=> :PUT
+p HelloAction[:do_update].path(123)     #=> "/api/books/123"
 p HelloAction[:do_update].form_action_attr(123)
                                         #=> "/api/books/123?_method=PUT"
 ```
 
 
+URL Mapping
+-----------
+
+Rails-like mapping:
+
+```ruby
+class BookAPI < K8::Action
+
+  mapping ''       , :GET=>:do_index, :POST=>:do_create
+  mapping '/new'   , :GET=>:do_new
+  mapping '/{id}'  , :GET=>:do_show, :PUT=>:do_update, :DELETE=>:do_delete
+  mapping '/{id}/edit', :GET=>:do_edit
+
+  def do_index()   ; {"list": []}; end
+  def do_create()  ; {"list": []}; end
+  def do_new()     ; {"item": id}; end
+  def do_show(id)  ; {"item": id}; end
+  def do_edit(id)  ; {"item": id}; end
+  def do_update(id); {"item": id}; end
+  def do_delete(id); {"item": id}; end
+  # (Note: 'do_' prefix is NOT mandatory.)
+
+end
+```
+
+Data type and pattern:
+
+```ruby
+class BookAPI < K8::Action
+
+  ##
+  ## data type and pattern
+  ##
+  mapping '/{name:str<[^/]+>}' , :GET=>:do_show1
+  mapping '/{id:int<\d+>}'     , :GET=>:do_show2
+  mapping '/{birthday:date<\d\d\d\d-\d\d-\d\d>}', :GET=>:do_show3
+
+  ##
+  ## default pattern
+  ##  - '/{name:str}' is same as '/{name:str<[^/]+>}'
+  ##  - '/{id:int}' is same as '/{id:int<\d+>}'
+  ##  - '/{birthday:date}' is same as '/{birthday:date<\d\d\d\d-\d\d-\d\d>}'
+  ##
+  mapping '/{name:str}'        , :GET=>:do_show1
+  mapping '/{id:int}'          , :GET=>:do_show2
+  mapping '/{birthday:date}'   , :GET=>:do_show3
+
+  ##
+  ## default data type
+  ##  - 'id' and '*_id' are int type
+  ##  - 'date' and '*_date' are date type
+  ##  - others are str type
+  ##
+  mapping '/{name}'      , :GET=>:do_show1   # same as '{name:str}'
+  mapping '/{id}'        , :GET=>:do_show2   # same as '{id:int}'
+  mapping '/{birth_date}', :GET=>:do_show3   # same as '{birth_date:date}'
+
+  ##
+  ## pattern with default data type
+  ##
+  mapping '/{code:<[A-Z]{3}>}', ...  # same as '/{code:str<[A-Z]{3}>'
+  mapping '/{id:<[1-9]\d*>}'  , ...  # same as '/{id:int<\d{4}>}'
+
+end
+```
+
+Path extension (such as '.json' or '.html'):
+
+```ruby
+class FooAPI < K8::Action
+
+  ## ex: '.*' is same as '{_:<(?:\w+)?>}' which matches to any extension.
+  mapping '.*'       , :GET=>:do_index
+
+  ## ex: '/{id}.*' is same as '/{id}{_:<(?:\w+)?>}' which matches to any extension.
+  mapping '/{id}.*'  , :GET=>:do_show
+
+  def do_index
+    p @req.path_ext    #=> ex: '.json', '.html', and so on
+  end
+
+  def do_show(id)
+    p @req.path_ext    #=> ex: '.json', '.html', and so on
+  end
+
+end
+```
+
+URL mapping helper:
+
+```ruby
+## for example
+p BookAPI[:do_index].meth        #=> :GET
+p BookAPI[:do_index].path        #=> "/api/books"
+p BookAPI[:do_create].meth       #=> :POST
+p BookAPI[:do_create].path       #=> "/api/books"
+p BookAPI[:do_show].meth         #=> :GET
+p BookAPI[:do_show].path(123)    #=> "/api/books/123"
+p BookAPI[:do_update].meth       #=> :PUT
+p BookAPI[:do_update].path(123)  #=> "/api/books/123"
+p BookAPI[:do_delete].meth       #=> :DELETE
+p BookAPI[:do_delete].path(123)  #=> "/api/books/123"
+
+p BookAPI[:do_index ].form_action_attr()   #=> "/api/books"
+p BookAPI[:do_create].form_action_attr()   #=> "/api/books"
+p BookAPI[:do_show  ].form_action_attr(9)  #=> "/api/books/9"
+p BookAPI[:do_update].form_action_attr(9)  #=> "/api/books/9?_method=PUT"
+p BookAPI[:do_delete].form_action_attr(9)  #=> "/api/books/9?_method=DELETE"
+```
+
+Show URL mappings:
+
+```console
+$ k8rb project myapp1   # or: boilerpl8 github:kwatch/keight-ruby myapp1
+$ cd myapp1
+$ rake mapping:text       # list url mapping
+$ rake mapping:yaml       # list in YAML format
+$ rake mapping:json       # list in JSON format
+$ rake mapping:jquery     # list for jQuery
+$ rake mapping:angularjs  # list for AngularJS
+```
+
+
 Topics
 ------
 
@@ -272,8 +429,8 @@ This will make routing for variable one much faster.
 
 ### Default Pattern of URL Path Parameter
 
-URL path parameter `{id}` and `{xxx_id}` are regarded as `{id:\d+}` and
-`{xxx_id:\d+}` respectively and converted into positive interger automatically.
+URL path parameter `{id}` and `{xxx_id}` are regarded as `{id:int<\d+>}` and
+`{xxx_id:int<\d+>}` respectively and converted into positive interger automatically.
 For example:
 
 ```ruby
@@ -287,8 +444,8 @@ end
 ```
 
 URL path parameter `{date}` and `{xxx_date}` are regarded as
-`{date:\d\d\d\d-\d\d-\d\d}` and `{xxx_date:\d\d\d\d-\d\d-\d\d}` respectively
-and converted into Date object automatically.
+`{date:date<\d\d\d\d-\d\d-\d\d>}` and `{xxx_date:date<\d\d\d\d-\d\d-\d\d>}`
+respectively and converted into Date object automatically.
 For example:
 
 ```ruby
@@ -301,10 +458,8 @@ class BlogAPI < K8::Action
 end
 ```
 
-**If you specify `{id:\d+}` or `{date:\d\d\d\d-\d\d-\d\d}` explicitly,
-URL path parameter value is not converted into integer nor Date object.**
-In other words, you can cancel automatic conversion by specifing regular
-expression of URL path parameters.
+If you don't like auto-convert, specify data type and pettern explicitly.
+For example, `{id:str<\d+>}` or `{date:str<\d\d\d\d-\d\d-\d\d>}`.
 
 
 ### Nested Routing
@@ -312,8 +467,8 @@ expression of URL path parameters.
 ```ruby
 urlpath_mapping = [
     ['/api', [
-        ['/books'                      , BookAPI],
-        ['/books/{book_id}/comments'   , BookCommentsAPI],
+        ['/books'                    , "./app/api/books:BookAPI"],
+        ['/books/{book_id}/comments' , "./app/api/books:BookCommentsAPI"],
     ]],
 ]
 ```
@@ -322,15 +477,16 @@ urlpath_mapping = [
 ### URL Path Helpers
 
 ```ruby
-p BooksAPI[:do_index].method          #=> :GET
-p BooksAPI[:do_index].urlpath()       #=> "/api/books"
+p BooksAPI[:do_index].meth         #=> :GET
+p BooksAPI[:do_index].path()       #=> "/api/books"
+p BooksAPI[:do_update].form_action_attr(123)   #=> "/api/books/123"
 
-p BooksAPI[:do_update].method         #=> :PUT
-p BooksAPI[:do_update].urlpath(123)   #=> "/api/books/123"
+p BooksAPI[:do_update].meth        #=> :PUT
+p BooksAPI[:do_update].path(123)   #=> "/api/books/123"
 p BooksAPI[:do_update].form_action_attr(123)   #=> "/api/books/123?_method=PUT"
 ```
 
-(Notice that these are availabe after `K8::RackApplication` object is created.)
+(Notice that these are availabe after `K8::RackApplication.new()` is called.)
 
 
 ### Routing for JavaScript
@@ -338,35 +494,34 @@ p BooksAPI[:do_update].form_action_attr(123)   #=> "/api/books/123?_method=PUT"
 Keight.rb can generate JavaScript routing file.
 
 ```console
-$ k8rb project myapp1
-$ cd myapp1/
-$ k8rb mapping --format=javascript | less  # or 'jquery', 'angular'
-$ mkdir -p static/js
-$ jsfile=static/js/urlpath_mapping.js
-$ rm -f $jsfile
-$ echo 'var Mapping = {'           >> $jsfile
-$ k8rb mapping --format=javascript >> $jsfile
-$ echo '};'                        >> $jsfile
+$ k8rb project myapp1   # or: boilerpl8 github:kwatch/keight-ruby myapp1
+$ cd myapp1
+$ rake mapping:text         # list URL path mapping
+$ rake mapping:yaml         # list in YAML format
+$ rake mapping:json         # list in JSON format
+$ rake mapping:jquery       # list for jQuery
+$ rake mapping:angularjs    # list for AngularJS
 ```
 
 
 ### Download JavaScript Libraries
 
-Keight.rb can download Javascript or CSS libraries from [cdnjs.com].
-It is good idea to make layout of JavaScript libraries to be same as CDN.
-
-[cdnjs.com]: https://cdnjs.com/
+Install `cdnget` gem in order to download such as jQuery or Bootstrap.
 
 ```console
-$ k8rb project myapp1
-$ cd myapp1/
-$ k8rb help cdnjs
-$ k8rb cdnjs                 # list libraries
-$ k8rb cdnjs 'jquery*'       # search libraries
-$ k8rb cdnjs jquery          # list versions
-$ k8rb cdnjs jquery 2.1.4    # download library
-## or
-$ k8rb cdnjs --basedir=static/lib jquery 2.1.4
+$ gem install cdnget
+$ cdnget                                 # list CDN
+$ cdnget cdnjs                           # list libraries
+$ cdnget cdnjs 'jquery*'                 # search libraries
+$ cdnget cdnjs jquery                    # list versions
+$ cdnget cdnjs jquery 2.2.4              # list files
+$ cdnget cdnjs jquery 2.2.4 static/lib   # download files
+static/lib/jquery/2.2.4/jquery.js ... Done (257,551 byte)
+static/lib/jquery/2.2.4/jquery.min.js ... Done (85,578 byte)
+static/lib/jquery/2.2.4/jquery.min.map ... Done (129,572 byte)
+
+$ ls static/lib/jquery/2.2.4
+jquery.js	jquery.min.js	jquery.min.map
 ```
 
 
@@ -382,22 +537,71 @@ I don't think Keight.rb is so fast. Other frameworks are just too slow.
 
 #### How to setup template engine?
 
-Try `k8rb project myapp1; cd myapp1; less app/action.rb`.
+Try `k8rb project myapp1; less myapp1/app/action.rb`.  
+(or `boilerpl8 github:kwatch/keight-ruby myapp1; less myapp1/app/action.rb`).
 
 
 #### How to support static files?
 
-Try `k8rb project myapp1; cd myapp1; less app/action.rb`.
+Try `k8rb project myapp1; less myapp1/app/action.rb`.  
+(or `boilerpl8 github:kwatch/keight-ruby myapp1; less myapp1/app/action.rb`).
 
 
 #### How to setup session?
 
-Try `k8rb project myapp1; cd myapp1; less config.ru`.
+Try `k8rb project myapp1; less myapp1/app/config.ru`.  
+(or `boilerpl8 github:kwatch/keight-ruby myapp1; less myapp1/app/config.ru`).
+
+
+#### Is it necessary to add 'do_' prefix to action methods?
+
+No. You can define `index()` or `show(id)` instead of `do_index()` or
+`do_show(id)`, like Ruby on Rails.
 
 
 #### Can I use Rack::Request and Rack::Response instead of Keight's?
 
-Try `K8::REQUEST_CLASS = Rack::Request; K8::RESPONSE_CLASS = Rack::Response`.
+Try `K8::RackApplication::REQUEST_CLASS = Rack::Request` and
+`K8::RackApplication::RESPONSE_CLASS = Rack::Response`.
+
+
+#### Why does `@req.multipart` returns two Hash objects?
+
+Because in order NOT to mix string objects and file objects in a hash.
+
+```ruby
+## str_params contains only string or array of string.
+## file_params contains only file object or array of file.
+str_params, file_params = @req.multipart
+p str_params['name'].strip
+    #=> no error because str_params['name'] is a string
+
+## It is easy to merge two hash objects (but not recommended).
+p str_params.merge(file_params)
+```
+
+In contrast, `Rack::Request#POST()` may contains both string and file.
+
+```ruby
+req = Rack::Request.new(env)
+p req.POST['name'].strip
+    #=> will raise error when req.POST['name'] is file object uploaded
+```
+
+
+#### Why does `@req.params` raise error when multipart form data?
+
+Because `@req.multipart` returns two Hash objects. See above section.
+
+
+#### Why does `@req.params` raise error for JSON data?
+
+Because both `@req.query` and `@req.form` returns a Hash object containing
+only string values, but `@req.json` returns a Hash object containing
+non-string values sucha as integer or boolean.
+
+Use `@req.json` instead of `@req.params` for JSON data.
+
 
 
 License and Copyright