benry-cmdapp 0.1.0 → 1.0.0

data/README.md

@@ -1,6 +1,6 @@
 # Benry-CmdApp
 
-($Release: 0.1.0 $)
+($Release: 1.0.0 $)
 
 
 ## What's This?
@@ -9,17 +9,17 @@ Benry-CmdApp is a framework to create command-line application.
 If you want create command-line application which takes sub-commands
 like `git`, `docker`, or `npm`, Benry-CmdApp is the solution.
 
-Base idea:
+Basic idea:
 
-* Sub-command (= action) is defined as a method in Ruby.
+* Action (= sub-command) is defined as a method in Ruby.
 * Commnad-line arguments are passed to action method as positional arguments.
 * Command-line options are passed to action method as keyword arguments.
 
 For example:
 
-* `<command> foo` in command-line invokes action method `foo()` in Ruby.
-* `<command> foo arg1 arg2` invokes `foo("arg1", "arg2")`.
-* `<command> foo arg --opt=val` invokes `foo("arg", opt: "val")`.
+* `<command> hello` in command-line invokes action method `hello()` in Ruby.
+* `<command> hello arg1 arg2` invokes `hello("arg1", "arg2")`.
+* `<command> hello arg --opt=val` invokes `hello("arg", opt: "val")`.
 
 Links:
 
@@ -36,7 +36,7 @@ Benry-CmdApp requires Ruby >= 2.3.
 
 * [What's This?](#whats-this)
 * [Install](#install)
-* [Usage](#usage)
+* [Basic Usage](#basic-usage)
   * [Action](#action)
   * [Method Name and Action Name](#method-name-and-action-name)
   * [Parameter Name in Help Message of Action](#parameter-name-in-help-message-of-action)
@@ -45,34 +45,47 @@ Benry-CmdApp requires Ruby >= 2.3.
   * [Option Value Validation](#option-value-validation)
   * [Callback for Option Value](#callback-for-option-value)
   * [Boolean (On/Off) Option](#boolean-onoff-option)
-  * [Prefix of Action Name](#prefix-of-action-name)
+  * [Option Set](#option-set)
+  * [Copy Options](#copy-options)
+  * [Option Error and Action Error](#option-error-and-action-error)
+* [Advanced Feature](#advanced-feature)
+  * [Category of Action](#category-of-action)
+  * [Nested Category](#nested-category)
+  * [Category Action or Alias](#category-action-or-alias)
   * [Invoke Other Action](#invoke-other-action)
-  * [Action Alias](#action-alias)
+  * [Cleaning Up Block](#cleaning-up-block)
+  * [Alias for Action](#alias-for-action)
+  * [Abbreviation of Category](#abbreviation-of-category)
   * [Default Action](#default-action)
-  * [Default Help](#default-help)
-  * [Private (Hidden) Action](#private-hidden-action)
-  * [Private (Hidden) Option](#private-hidden-option)
+  * [Action List and Category List](#action-list-and-category-list)
+  * [Hidden Action](#hidden-action)
+  * [Hidden Option](#hidden-option)
+  * [Important Actions or Options](#important-actions-or-options)
 * [Configuratoin and Customization](#configuratoin-and-customization)
   * [Application Configuration](#application-configuration)
   * [Customization of Global Options](#customization-of-global-options)
   * [Customization of Global Option Behaviour](#customization-of-global-option-behaviour)
   * [Custom Hook of Application](#custom-hook-of-application)
-  * [Customization of Command Help Message](#customization-of-command-help-message)
+  * [Customization of Application Help Message](#customization-of-application-help-message)
   * [Customization of Action Help Message](#customization-of-action-help-message)
+  * [Customization of Section Title in Help Message](#customization-of-section-title-in-help-message)
 * [Q & A](#q--a)
-  * [Q: How to Append Some Tasks to Existing Action?](#q-how-to-append-some-tasks-to-existing-action)
-  * [Q: How to Re-define Existing Action?](#q-how-to-re-define-existing-action)
-  * [Q: How to Delete Existing Action/Alias?](#q-how-to-delete-existing-actionalias)
-  * [Q: How to Show Entering Into or Exitting From Action?](#q-how-to-show-entering-into-or-exitting-from-action)
-  * [Q: How to Enable/Disable Color Mode?](#q-how-to-enabledisable-color-mode)
-  * [Q: How to Define Multiple Option, like `-I` Option of Ruby?](#q-how-to-define-multiple-option-like--i-option-of-ruby)
-  * [Q: How to Specify Detailed Description of Option?](#q-how-to-specify-detailed-description-of-option)
-  * [Q: How to Copy All Options from Other Action?](#q-how-to-copy-all-options-from-other-action)
-  * [Q: What is the Difference Between `prefix(alias_of:)` and `prefix(action:)`?](#q-what-is-the-difference-between-prefixalias_of-and-prefixaction)
-  * [Q: How to Change Order of Options in Help Message?](#q-how-to-change-order-of-options-in-help-message)
-  * [Q: Is It Possible to Make Action Names Emphasised or Weaken?](#q-is-it-possible-to-make-action-names-emphasised-or-weaken)
-  * [Q: Is It Possible to Add Metadata to Action or Option?](#q-is-it-possible-to-add-metadata-to-action-or-option)
-  * [Q: How to Make Error Messages I18Ned?](#q-how-to-make-error-messages-i18ned)
+  * [Q: How to show all backtraces of exception?](#q-how-to-show-all-backtraces-of-exception)
+  * [Q: How to specify description to arguments of actions?](#q-how-to-specify-description-to-arguments-of-actions)
+  * [Q: How to append some tasks to an existing action?](#q-how-to-append-some-tasks-to-an-existing-action)
+  * [Q: How to delete an existing action/alias?](#q-how-to-delete-an-existing-actionalias)
+  * [Q: How to re-define an existing action?](#q-how-to-re-define-an-existing-action)
+  * [Q: How to show entering into or exitting from actions?](#q-how-to-show-entering-into-or-exitting-from-actions)
+  * [Q: How to enable/disable color mode?](#q-how-to-enabledisable-color-mode)
+  * [Q: How to define a multiple option, like `-I` option of Ruby?](#q-how-to-define-a-multiple-option-like--i-option-of-ruby)
+  * [Q: How to show global option `-L <topic>` in help message?](#q-how-to-show-global-option--l-topic-in-help-message)
+  * [Q: How to specify detailed description of options?](#q-how-to-specify-detailed-description-of-options)
+  * [Q: How to list only aliases (or actions) excluding actions (or aliases) ?](#q-how-to-list-only-aliases-or-actions-excluding-actions-or-aliases-)
+  * [Q: How to change the order of options in help message?](#q-how-to-change-the-order-of-options-in-help-message)
+  * [Q: How to add metadata to actions or options?](#q-how-to-add-metadata-to-actions-or-options)
+  * [Q: How to remove common help option from all actions?](#q-how-to-remove-common-help-option-from-all-actions)
+  * [Q: Is it possible to show details of actions and aliases?](#q-is-it-possible-to-show-details-of-actions-and-aliases)
+  * [Q: How to make error messages I18Ned?](#q-how-to-make-error-messages-i18ned)
 * [License and Copyright](#license-and-copyright)
 
 <!-- /TOC -->
@@ -87,40 +100,49 @@ $ gem install benry-cmdapp
 
 
 
-## Usage
+## Basic Usage
 
 
 ### Action
 
-* Inherit action class and define action methods in it.
+How to define actions:
+
+* (1) Inherit action class.
+* (2) Define action methods with `@action.()`.
+* (3) Create an application object and run it.
+
+Note:
+
+* Use `@action.()`, not `@action()`.
+* Command-line arguments are passed to action method as positional arguments.
 * An action class can have several action methods.
 * It is ok to define multiple action classes.
-* Command-line arguments are passed to action method as positional arguments.
 
 File: ex01.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-## action
+## (1) Inherit action class.
 class MyAction < Benry::CmdApp::Action    # !!!!
 
+  ## (2) Define action methods with `@action.()`.
   @action.("print greeting message")      # !!!!
-  def hello(user="world")                 # !!!!
-    puts "Hello, #{user}!"
+  def hello(name="world")                 # !!!!
+    puts "Hello, #{name}!"
   end
 
 end
 
-## configuration
-config = Benry::CmdApp::Config.new("sample app", "1.0.0")
-config.default_help = true
-
-## run application
-app = Benry::CmdApp::Application.new(config)
-status_code = app.main()
+## (3) Create an application object and run it.
+status_code = Benry::CmdApp.main("sample app", "1.0.0")
 exit status_code
+## or:
+#config = Benry::CmdApp::Config.new("sample app", "1.0.0")
+#app = Benry::CmdApp::Application.new(config)
+#status_code = app.main()
+#exit status_code
 ```
 
 Output:
@@ -137,32 +159,48 @@ Help message of command:
 
 ```console
 [bash]$ ruby ex01.rb -h     # or `--help`
-ex01.rb (1.0.0) -- sample app
+ex01.rb (1.0.0) --- sample app
 
 Usage:
-  $ ex01.rb [<options>] [<action> [<arguments>...]]
+  $ ex01.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
   -V, --version      : print version
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
 
 Actions:
   hello              : print greeting message
+  help               : print help message (of action if specified)
 ```
 
 Help message of action:
 
 ```console
-[bash]$ ruby ex01.rb -h hello
-ex01.rb hello -- print greeting message
+[bash]$ ruby ex01.rb -h hello     # or: ruby ex01.rb --help hello
+ex01.rb hello --- print greeting message
+
+Usage:
+  $ ex01.rb hello [<name>]
+```
+
+* Benry-CmdApp adds `-h` and `--help` options to each action automatically.
+  Output of `ruby ex01.rb hello -h` and `ruby ex01.rb -h hello` will be the same.
+
+```console
+[bash]$ ruby ex01.rb hello -h     # or: ruby ex01.rb helo --help
+ex01.rb hello --- print greeting message
 
 Usage:
-  $ ex01.rb hello [<user>]
+  $ ex01.rb hello [<name>]
 ```
 
 
 ### Method Name and Action Name
 
+Rules between method name and action name:
+
 * Method name `print_` results in action name `print`.
   This is useful to define actions which name is same as Ruby keyword or popular functions.
 * Method name `foo_bar_baz` results in action name `foo-bar-baz`.
@@ -171,7 +209,7 @@ Usage:
 File: ex02.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -196,26 +234,33 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("test app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+status_code = Benry::CmdApp.main("test app")
+exit status_code
+## or:
+#config = Benry::CmdApp::Config.new("test app")
+#app = Benry::CmdApp::Application.new(config)
+#status_code = app.main()
+#exit status_code
 ```
 
 Help message:
 
 ```console
 [bash]$ ruby ex02.rb --help
-ex02.rb -- test app
+ex02.rb --- test app
 
 Usage:
-  $ ex02.rb [<options>] [<action> [<arguments>...]]
+  $ ex02.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
 
 Actions:
   foo-bar-baz        : sample #2
   foo:bar:baz        : sample #3
+  help               : print help message (of action if specified)
   print              : sample #1
 ```
 
@@ -235,62 +280,85 @@ foo__bar__baz
 
 ### Parameter Name in Help Message of Action
 
-In help message of action, positional parameters of action methods are printed under the name conversion rule.
+In help message of an action, positional parameters of action methods are printed under the name conversion rule.
 
 * Parameter `foo` is printed as `<foo>`.
 * Parameter `foo_bar_baz` is printed as `<foo-bar-baz>`.
 * Parameter `foo_or_bar_or_baz` is printed as `<foo|bar|baz>`.
+* Parameter `foobar__xxx` is printed as `<foobar.xxx>`.
 
 In addition, positional parameters are printed in different way according to its kind.
 
 * If parameter `foo` is required (= doesn't have default value), it will be printed as `<foo>`.
 * If parameter `foo` is optional (= has default value), it will be printed as `[<foo>]`.
 * If parameter `foo` is variable length (= `*foo` style), it will be printed as `[<foo>...]`.
+* If parameter `foo` is required or optional and `foo_` is variable length, it will be printed as `<foo>...`.
 
 
 File: ex03.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("parameter names test")
-  def test1(aaa, bbb_or_ccc, ddd=nil, eee=nil, *fff)  # !!!!
+  @action.("name conversion test")
+  def test1(file_name, file_or_dir, file__html)  # !!!!
+    # ...
+  end
+
+  @action.("parameter kind test")
+  def test2(aaa, bbb, ccc=nil, ddd=nil, *eee)  # !!!!
+    # ...
+  end
+
+  @action.("parameter combination test")
+  def test3(file, *file_)  # !!!!
+    files = [file] + file_
     # ...
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+status_code = Benry::CmdApp.main("sample app", "1.0.0")
+exit status_code
 ```
 
 Help message:
 
 ```console
 [bash]$ ruby ex03.rb -h test1
-hoge.rb test1 -- parameter names test
+ex03.rb test1 --- name conversion test
+
+Usage:
+  $ ex03.rb test1 <file-name> <file|dir> <file.html>  # !!!!
+
+[bash]$ ruby ex03.rb -h test2
+ex03.rb test2 --- parameter kind test
 
 Usage:
-  $ ex03.rb test1 <aaa> <bbb|ccc> [<ddd> [<eee> [<fff>...]]]  # !!!!
+  $ ex03.rb test2 <aaa> <bbb> [<ccc> [<ddd> [<eee>...]]]  # !!!!
+
+[bash]$ ruby ex03.rb -h test3
+ex03.rb test3 --- parameter combination test
+
+Usage:
+  $ ex03.rb test3 <file>...                           # !!!!
 ```
 
 
 ### Options
 
 * Action can take command-line options.
-* Option values specified in command-line are passed to actio method as keyword arguments.
+* Option values specified in command-line are passed to action method as keyword arguments.
 
 File: ex04.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-## action
 class MyAction < Benry::CmdApp::Action
 
   @action.("print greeting message")
@@ -301,20 +369,13 @@ class MyAction < Benry::CmdApp::Action
     when "fr" ; puts "Bonjour, #{user}!"
     when "it" ; puts "Ciao, #{user}!"
     else
-      raise "#{lang}: unknown language."
+      raise "#{lang}: Unknown language."
     end
   end
 
 end
 
-## configuration
-config = Benry::CmdApp::Config.new("sample app", "1.0.0")
-config.default_help = true
-
-## run application
-app = Benry::CmdApp::Application.new(config)
-status_code = app.main()
-exit status_code
+exit Benry::CmdApp.main("sample app", "1.0.0")
 ```
 
 Output:
@@ -336,10 +397,9 @@ Ciao, world!
 File: ex05.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-## action
 class MyAction < Benry::CmdApp::Action
 
   @action.("print greeting message")
@@ -353,21 +413,14 @@ class MyAction < Benry::CmdApp::Action
       when "fr" ; puts "Bonjour, #{user}!"
       when "it" ; puts "Ciao, #{user}!"
       else
-        raise "#{lang}: unknown language."
+        raise "#{lang}: Unknown language."
       end
     end
   end
 
 end
 
-## configuration
-config = Benry::CmdApp::Config.new("sample app", "1.0.0")
-config.default_help = true
-
-## run application
-app = Benry::CmdApp::Application.new(config)
-status_code = app.main()
-exit status_code
+exit Benry::CmdApp.main("sample app", "1.0.0")
 ```
 
 Output:
@@ -377,51 +430,75 @@ Output:
 Bonjour, Alice!
 Bonjour, Alice!
 Bonjour, Alice!
-`````
+```
 
 Help message:
 
 ```console
 [bash]$ ruby ex05.rb -h hello
-ex05.rb hello -- print greeting message
+ex05.rb hello --- print greeting message
 
 Usage:
   $ ex05.rb hello [<options>] [<user>]
 
 Options:
-  -l, --lang=<en|fr|it> : language        # !!!!
+  -l, --lang=<en|fr|it> : language
       --repeat=<N>   : repeat <N> times   # !!!!
 ```
 
-For usability reason, Benry::CmdApp supports `--lang=<val>` style long option
-and doesn't support `--lang <val>` style option.
-Benry::CmdApp regards `--lang <val>` as 'long option without argument'
+* If an option defined but the corresponding keyword argument is missing, error will be raised.
+* If an action method accepts any keyword arguments (such as `**kwargs`), nothing will be raised.
+
+```ruby
+  ### ERROR: option `:repeat` is defined but keyword arg `repeat:` is missing.
+  @action.("greeting message")
+  @option.(:lang  , "-l <lang>", "language")
+  @option.(:repeat, "-n <N>"   , "repeat N times")
+  def hello(user="world", lang: "en")
+    ....
+  end
+
+  ### NO ERROR: `**kwargs` accepts any keyword arguments.
+  @action.("greeting message")
+  @option.(:lang  , "-l <lang>", "language")
+  @option.(:repeat, "-n <N>"   , "repeat N times")
+  def hello(user="world", lang: "en", **kwargs)
+    ....
+  end
+```
+
+For usability reason, Benry-CmdApp supports `--lang=<val>` style of long option
+but doesn't support `--lang <val>` style.
+Benry-CmdApp regards `--lang <val>` as 'long option without argument'
 and 'argument for command'.
 
 ```console
 [bash]$ ruby ex05.rb hello --lang fr         # ``--lang fr`` != ``--lang=fr``
-[ERROR] --lang: argument required.
+[ERROR] --lang: Argument required.
 ```
 
 
 ### Option Definition Format
 
-Option definition format should be one of:
-
-* (short option) `-q`  : no values.
-* (short option) `-f <file>` : value required.
-* (short option) `-i[<width>]` : value is optional.
-* (long option) `--quiet`  : no values.
-* (long option) `--file=<file>` : value required.
-* (long option) `--indent[=<width>]` : value is optional.
-* (short & long) `-q, --quiet`  : no values.
-* (short & long) `-f, --file=<file>` : value required.
-* (short & long) `-i, --indent[=<width>]` : value is optional.
+There are 9 option definition formats.
+
+* When the option takes no value:
+  * `-q` --- Short style.
+  * `--quiet` --- Long style.
+  * `-q, --quiet` --- Short and long style.
+* When the option takes a required value:
+  * `-f <path>` --- Short style.
+  * `--file=<path>` --- Long style.
+  * `-f, --file=<path>` --- Short and long style.
+* When the option takes an optional value:
+  * `-i[<N>]` --- Short style.
+  * `--indent[=<N>]` --- Long style.
+  * `-i, --indent[=<N>]` --- Short and long style.
 
 File: ex06.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -455,9 +532,7 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("test app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("test app")
 ```
 
 Output:
@@ -493,7 +568,7 @@ Help message:
 
 ```ruby
 [bash]$ ruby ex06.rb -h test1
-ex06.rb test1 -- short options
+ex06.rb test1 --- short options
 
 Usage:
   $ ex06.rb test1 [<options>]
@@ -504,7 +579,7 @@ Options:
   -i[<N>]            : indent width
 
 [bash]$ ruby ex06.rb -h test2
-ex06.rb test2 -- long options
+ex06.rb test2 --- long options
 
 Usage:
   $ ex06.rb test2 [<options>]
@@ -515,7 +590,7 @@ Options:
   --indent[=<N>]     : indent width
 
 [bash]$ ruby ex06.rb -h test3
-ex06.rb test3 -- short and long options
+ex06.rb test3 --- short and long options
 
 Usage:
   $ ex06.rb test3 [<options>]
@@ -540,10 +615,9 @@ Options:
 File: ex07.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-## action
 class MyAction < Benry::CmdApp::Action
 
   @action.("print greeting message")
@@ -560,34 +634,27 @@ class MyAction < Benry::CmdApp::Action
       when "fr" ; puts "Bonjour, #{user}!"
       when "it" ; puts "Ciao, #{user}!"
       else
-        raise "#{lang}: unknown language."
+        raise "#{lang}: Unknown language."
       end
     end
   end
 
 end
 
-## configuration
-config = Benry::CmdApp::Config.new("sample app", "1.0.0")
-config.default_help = true
-
-## run application
-app = Benry::CmdApp::Application.new(config)
-status_code = app.main()
-exit status_code
+exit Benry::CmdApp.main("sample app", "1.0.0")
 ```
 
 Output:
 
 ```console
 [bash]$ ruby ex07.rb hello -l japan
-[ERROR] -l japan: pattern unmatched.
+[ERROR] -l japan: Pattern unmatched.
 
 [bash]$ ruby ex07.rb hello -l ja
-[ERROR] -l ja: expected one of en/fr/it.
+[ERROR] -l ja: Expected one of en/fr/it.
 
 [bash]$ ruby ex07.rb hello --repeat=abc
-[ERROR] --repeat=abc: integer expected.
+[ERROR] --repeat=abc: Integer expected.
 
 [bash]$ ruby ex07.rb hello --repeat=100
 [ERROR] --repeat=100: Too large (max: 10).
@@ -605,10 +672,9 @@ Callback can:
 File: ex08.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-## action
 class MyAction < Benry::CmdApp::Action
 
   @action.("print greeting message")
@@ -617,7 +683,7 @@ class MyAction < Benry::CmdApp::Action
 		  rexp: /\A\w\w\z/) {|v| v.downcase }    # !!!!
   @option.(:repeat, "    --repeat=<N>", "repeat <N> times",
                   type: Integer) {|v|                    # !!!!
-		    v > 0 or raise "not positive value." # !!!!
+		    v > 0 or raise "Not positive value." # !!!!
                     v                                    # !!!!
                   }                                      # !!!!
   def hello(user="world", lang: "en", repeat: 1)
@@ -627,21 +693,14 @@ class MyAction < Benry::CmdApp::Action
       when "fr" ; puts "Bonjour, #{user}!"
       when "it" ; puts "Ciao, #{user}!"
       else
-        raise "#{lang}: unknown language."
+        raise "#{lang}: Unknown language."
       end
     end
   end
 
 end
 
-## configuration
-config = Benry::CmdApp::Config.new("sample app", "1.0.0")
-config.default_help = true
-
-## run application
-app = Benry::CmdApp::Application.new(config)
-status_code = app.main()
-exit status_code
+exit Benry::CmdApp.main("sample app", "1.0.0")
 ```
 
 Output:
@@ -651,13 +710,13 @@ Output:
 Bonjour, world!
 
 [bash]$ ruby ex08.rb hello --repeat=0
-[ERROR] --repeat=0: not positive value.
+[ERROR] --repeat=0: Not positive value.
 ```
 
 
 ### Boolean (On/Off) Option
 
-Benry::CmdApp doesn't support `--[no-]foobar` style option.
+Benry-CmdApp doesn't support `--[no-]foobar` style option.
 Instead, define boolean (on/off) option.
 
 * Specify `type: TrueClass` to `@option.()`.
@@ -667,7 +726,7 @@ Instead, define boolean (on/off) option.
 File: ex09.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -682,9 +741,7 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("sample app", "1.0.0")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app", "1.0.0")
 ```
 
 Output:
@@ -720,7 +777,7 @@ If you want default value of flag to `true`, use `value:` keyword argument.
 File: ex10.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -734,9 +791,7 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("git helper")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("git helper")
 ```
 
 Output:
@@ -749,7 +804,7 @@ verbose=true
 verbose=false
 
 [bash]$ ruby ex10.rb flagtest2 --quiet=on   # error
-[ERROR] --quiet=on: unexpected argument.
+[ERROR] --quiet=on: Unexpected argument.
 ```
 
 In above example, `--quiet=on` will be error because option is defined as
@@ -761,8 +816,8 @@ If you want to allow `--quiet=on`, specify option argument and `type: TrueClass`
   ...(snip)...
 
   @action.("flag test")
-  @option.(:verbose, "-q, --quiet[=<on|off]", "quiet mode",  # !!!!
-                     type: TrueClass, value: false)          # !!!!
+  @option.(:verbose, "-q, --quiet[=<on|off>]", "quiet mode",  # !!!!
+                     type: TrueClass, value: false)           # !!!!
   def flagtest2(verbose: true)
     puts "verbose=#{verbose.inspect}"
   end
@@ -771,380 +826,850 @@ If you want to allow `--quiet=on`, specify option argument and `type: TrueClass`
 ```
 
 
-### Prefix of Action Name
+### Option Set
 
-* `prefix: "foo:bar"` in action class adds prefix `foo:bar:` to each action name.
-* Method name `def baz__test()` with `prefix: "foo:bar"` results in action name `foo:bar:baz:test`.
+Option set handles multiple options as a object.
+Option set will help you to define same options into multiple actions.
 
 File: ex11.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
-  prefix "foo:bar"            # !!!!
 
-  @action.("test action #1")
-  def test1()                 # action name: 'foo:bar:test1'
-    puts __method__
+  optset1 = optionset() {                             # !!!!
+    @option.(:host , "-H, --host=<host>" , "host name")
+    @option.(:port , "-p, --port=<port>" , "port number", type: Integer)
+  }
+  optset2 = optionset() {                             # !!!!
+    @option.(:user , "-u, --user=<user>" , "user name")
+  }
+
+  @action.("connect to postgresql server")
+  @optionset.(optset1, optset2)                           # !!!!
+  def postgresql(host: nil, port: nil, user: nil)
+    puts "psql ...."
   end
 
-  @action.("test action #2")
-  def baz__test2()            # action name: 'foo:bar:baz:test2'
-    puts __method__
+  @action.("connect to mysql server")
+  @optionset.(optset1, optset2)                           # !!!!
+  def mysql(host: nil, port: nil, user: nil)
+    puts "mysql ...."
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("Sample App")
 ```
 
-Output:
+Help message:
 
 ```console
-[bash]$ ruby ex11.rb foo:bar:test1
-test1
+[bash]$ ruby ex11.rb -h postgresql       # !!!!
+ex11.rb postgresql --- connect to postgresql
 
-[bash]$ ruby ex11.rb foo:bar:baz:test2
-baz__test2
-```
+Usage:
+  $ ex11.rb postgresql [<options>]
 
-Help message:
+Options:
+  -H, --host=<host>  : host name         # !!!!
+  -p, --port=<port>  : port number       # !!!!
+  -u, --user=<user>  : user name         # !!!!
 
-```console
-[bash]$ ruby ex11.rb -h
-ex11.rb -- sample app
+[bash]$ ruby ex11.rb -h mysql            # !!!!
+ex11.rb mysql --- connect to mysql
 
 Usage:
-  $ ex11.rb [<options>] [<action> [<arguments>...]]
+  $ ex11.rb mysql [<options>]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -H, --host=<host>  : host name         # !!!!
+  -p, --port=<port>  : port number       # !!!!
+  -u, --user=<user>  : user name         # !!!!
+```
 
-Actions:
-  foo:bar:baz:test2  : test action #2
-  foo:bar:test1      : test action #1
+Option set object has the following methods.
+
+* `OptionSet#select(:key1, :key2, ...)` ---
+  Creates new OptionSet object with copying options which are filtered by the keys specified.
+* `OptionSet#exclude(:key1, :key2, ...)` ---
+  Creates new OptionSet object with copying options which are filtered by dropping the options that key is included in specified keys.
+
+```ruby
+  @action.("connect to postgresql server")
+  @optionset.(optset1.select(:host, :port))    # !!!!
+  def postgresql(host: nil, port: nil)
+    ....
+  end
+
+  @action.("connect to mysql server")
+  @optionset.(optset1.exclude(:port))          # !!!!
+  def mysql(host: nil)
+    ....
+  end
 ```
 
-* `prefix: "foo:bar", action: :test` defines `foo:bar` action (intead of `foo:bar:test`) with `test()` method.
+
+### Copy Options
+
+`@copy_options.()` copies options from other action.
 
 File: ex12.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
-  prefix "foo:bar", action: :test3_      # !!!!
-  ## or:
-  #prefix "foo:bar", action: "test3"     # !!!!
 
-  @action.("test action #1")
-  def test1()                 # action name: 'foo:bar:test1'
-    puts __method__
+  @action.("connect to postgresql")
+  @option.(:host , "-H, --host=<host>" , "host name")
+  @option.(:port , "-p, --port=<port>" , "port number", type: Integer)
+  @option.(:user , "-u, --user=<user>" , "user name")
+  def postgresql(host: nil, port: nil, user: nil)
+    puts "psql ...."
   end
 
-  @action.("test action #3")
-  def test3_()                # action name: 'foo:bar'
-    puts __method__
+  @action.("connect to mysql")
+  @copy_options.("postgresql")                 # !!!!!
+  def mysql(host: nil, port: nil, user: nil)
+    puts "mysql ...."
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
-```
-
-Output:
-
-```console
-[bash]$ ruby ex12.rb foo:bar:test1
-test1
-
-[bash]$ ruby ex12.rb foo:bar:test3
-[ERROR] foo:bar:test2: unknown action.
-
-[bash]$ ruby ex12.rb foo:bar
-test3_
+exit Benry::CmdApp.main("Sample App")
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex12.rb -h
-ex12.rb -- sample app
+[bash]$ ruby ex12.rb -h mysql       # !!!!
+ex12.rb mysql --- connect to mysql
 
 Usage:
-  $ ex12.rb [<options>] [<action> [<arguments>...]]
+  $ ex12.rb mysql [<options>]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
-
-Actions:
-  foo:bar            : test action #3
-  foo:bar:test1      : test action #1
+  -H, --host=<host>  : host name
+  -p, --port=<port>  : port number
+  -u, --user=<user>  : user name
 ```
 
+If you want to exclude some options from copying, specify `exlude:` keyword argument.
+For example, `@copy_options.("hello", exclude: [:help, :lang])` copies all options of `hello` action excluding `:help` and `:lang` options.
 
-### Invoke Other Action
 
-* `run_action!()` invokes other action.
-* `run_action_once()` invokes other action only once.
-  This is equivarent to 'prerequisite task' feature in task runner application.
+### Option Error and Action Error
+
+* `option_error()` returns (not raise) `Benry::CmdApp::OptionError` object.
+* `action_error()` returns (not raise) `Benry::CmdApp::ActionError` object.
+* These are available in action method.
 
 File: ex13.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("create build dir")
-  def prepare()
-    puts "rm -rf build"
-    puts "mkdir build"
-  end
-
-  @action.("build something")
-  def build()
-    run_action_once("prepare")        # !!!!
-    run_action_once("prepare")        # skipped because already invoked
-    puts "echo 'README' > build/README.txt"
-    puts "zip -r build.zip build"
+  @action.("invoke openssl command")
+  @option.(:encrypt, "--encrypt", "encrypt a file")
+  @option.(:decrypt, "--decrypt", "decrypt a file")
+  def openssl(filename, encrypt: false, decrypt: false)
+    if encrypt == false && decrypt == false
+      raise option_error("Required '--encrypt' or '--decrypt' option.") # !!!!
+    end
+    opt = encrypt ? "enc" : "dec"
+    command = "openssl #{opt} ..."
+    result = system command
+    if result == false
+      raise action_error("Command failed: #{command}")   # !!!!
+    end
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("Sample App")
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex13.rb build
-rm -rf build                          # invoked only once!!!!
-mkdir build                           # invoked only once!!!!
-echo 'README' > build/README.txt
-zip -r build.zip build
+[bash]$ ruby ex13.rb openssl file.txt
+[ERROR] Required '--encrypt' or '--decrypt' option.  #<== option_error()
+
+[bash]$ ruby ex13.rb openssl --encrypt file.txt
+enc: Use -help for summary.
+[ERROR] Command failed: openssl enc ...              #<== action_error()
+    From ex13.rb:17:in `openssl'
+        raise action_error("Command failed: #{command}")
+    From ex13.rb:25:in `<main>'
+        exit app.main()
+```
+
+If you want to show all stacktrace, add `--debug` global option.
+
+```console
+[bash]$ ruby ex13.rb --debug openssl --encrypt file.txt
+enc: Use -help for summary.
+ex13.rb:17:in `openssl': Command failed: openssl enc ... (Benry::CmdApp::ActionError)
+	from /home/yourname/cmdapp.rb:988:in `_invoke_action'
+	from /home/yourname/cmdapp.rb:927:in `start_action'
+	from /home/yourname/cmdapp.rb:1794:in `start_action'
+	from /home/yourname/cmdapp.rb:1627:in `handle_action'
+	from /home/yourname/cmdapp.rb:1599:in `run'
+	from /home/yourname/cmdapp.rb:1571:in `main'
 ```
 
-* When looped action is detected, Benry::CmdApp aborts action.
 
-File: ex14.rb
+
+## Advanced Feature
+
+
+### Category of Action
+
+* `category "foo:bar:"` in action class adds prefix `foo:bar:` to each action name.
+* Category name should be specified as a prefix string ending with `:`. For example, `category "foo:"` is OK but `category "foo"` will be error.
+* Symbol is not allowed. For example, `category :foo` will be error.
+* Method name `def baz__test()` with `category "foo:bar:"` results in the action name `foo:bar:baz:test`.
+
+File: ex21.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-class LoopedAction < Benry::CmdApp::Action
-
-  @action.("test #1")
-  def test1()
-    run_action_once("test2")
-  end
+class SampleAction < Benry::CmdApp::Action
+  category "foo:bar:"                # !!!!
 
-  @action.("test #2")
-  def test2()
-    run_action_once("test3")
+  @action.("test action #1")
+  def test1()                      # action name: 'foo:bar:test1'
+    puts __method__                #=> test1
+    puts methods().grep(/test1/)   #=> foo__bar__test1
   end
 
-  @action.("test #3")
-  def test3()
-    run_action_once("test1")          # !!!!
+  @action.("test action #2")
+  def baz__test2()                 # action name: 'foo:bar:baz:test2'
+    puts __method__                #=> baz__test2
+    puts methods().grep(/test2/)   #=> foo__bar__baz__test2
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex14.rb test1
-[ERROR] test1: looped action detected.
+[bash]$ ruby ex21.rb -l
+Actions:
+  foo:bar:baz:test2  : test action #2
+  foo:bar:test1      : test action #1
+  help               : print help message (of action if specified)
 
-[bash]$ ruby ex14.rb test3
-[ERROR] test3: looped action detected.
+[bash]$ ruby ex21.rb foo:bar:test1
+test1                         # <== puts __method__
+foo__bar__test1               # <== puts methods().grep(/test1/)
+
+[bash]$ ruby ex21.rb foo:bar:baz:test2
+baz__test2                    # <== puts __method__
+foo__bar__baz__test2          # <== puts methods().grep(/test1/)
 ```
 
+(INTERNAL MECHANISM):
+As shown in the above output, Benry-CmdApp internally renames `test1()` and `baz__test2()` methods within category `foo:bar:` to `foo__bar__test1()` and `foo__bar__baz__test2()` respectively.
+`__method__` seems to keep original method name, but don't be fooled, methods are renamed indeed.
+Due to this mechanism, it is possible to define the same name methods in different categories with no confliction.
+
+* `category()` can take a description text of category.
+  For example, `category "foo:", "Bla bla"` registers `"Bla bla` as a description of category `foo:`.
+  Description of category is displayed in list of category list.
+  See [Action List and Prefix List](#action-list-and-prefix-list) section for details.
 
-### Action Alias
 
-* Alias of action provides alternative short name of action.
+### Nested Category
 
-File: ex15.rb
+`category()` can take a block which represents sub-category.
+
+File: ex22.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-class SampleAction < Benry::CmdApp::Action
-  prefix "foo:bar"
+class GitAction < Benry::CmdApp::Action
+  category "git:"                   # top level category
 
-  @action.("test action #1")
-  def test1()                 # action name: 'foo:bar:test1'
-    puts __method__
+  @action.("show current status in compact format")
+  def status(path=".")
+    puts "git status -sb #{path}"
   end
 
-end
-
-Benry::CmdApp.action_alias "test", "foo:bar:test1"   # !!!!
+  category "commit:" do             # sub level category
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
-```
+    @action.("create a new commit")
+    def create(message: nil)
+      puts "git commit"
+    end
 
-Output:
+  end
 
-```console
-[bash]$ ruby ex15.rb test             # alias name
-test1
+  category "branch:" do             # sub level category
 
-[bash]$ ruby ex15.rb foo:bar:test1    # original action name
-test1
-```
+    @action.("create a new branch")
+    def create(branch)
+      puts "git checkout -b #{branch}"
+    end
 
-Help message:
+  end
 
-```console
-[bash]$ ruby ex15.rb -h
-ex15.rb -- sample app
+end
 
-Usage:
-  $ ex15.rb [<options>] [<action> [<arguments>...]]
+exit Benry::CmdApp.main("sample app")
+```
 
-Options:
-  -h, --help         : print help message (of action if action specified)
+Output:
 
+```console
+[bash]$ ruby ex22.rb -l
 Actions:
-  foo:bar:test1      : test action #1
-  test               : alias to 'foo:bar:test1' action
+  git:branch:create  : create a new branch
+  git:commit:create  : create a new commit
+  git:status         : show current status in compact format
+  help               : print help message (of action if specified)
 ```
 
-* Alias can include positional and keyword arguments in definition.
+Block of `category()` is nestable.
 
-File: ex16.rb
+File: ex23.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-class MyAction < Benry::CmdApp::Action
+class GitAction < Benry::CmdApp::Action
+
+  category "git:" do                 # top level category
+
+    @action.("show current status in compact format")
+    def status(path=".")
+      puts "git status -sb #{path}"
+    end
+
+    category "commit:" do            # sub level category
+
+      @action.("create a new commit")
+      def create(message: nil)
+        puts "git commit"
+      end
+
+    end
+
+    category "branch:" do            # sub level category
+
+      @action.("create a new branch")
+      def create(branch)
+        puts "git checkout -b #{branch}"
+      end
 
-  @action.("print greeting message")
-  @option.(:lang, "-l, --lang=<lang>", "language", enum: ["en", "fr", "it"])
-  def hello(user="world", lang: "en")
-    case lang
-    when "en" ; puts "Hello, #{user}!"
-    when "fr" ; puts "Bonjour, #{user}!"
-    when "it" ; puts "Ciao, #{user}!"
-    else
-      raise "#{lang}: unknown language."
     end
+
   end
 
 end
 
-Benry::CmdApp.action_alias("bonjour", "hello", "--lang=fr")        # !!!!
-Benry::CmdApp.action_alias("ciao"   , "hello", "Bob", "-l", "it")  # !!!!
-
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex16.rb hello
-Hello, world!
-
-[bash]$ ruby ex16.rb bonjour           # !!!!
-Bonjour, world!
-
-[bash]$ ruby ex16.rb bonjour Alice     # !!!!
-Bonjour, Alice!
-
-[bash]$ ruby ex16.rb ciao              # !!!!
-Ciao, Bob!
+[bash]$ ruby ex23.rb -l
+Actions:
+  git:branch:create  : create a new branch
+  git:commit:create  : create a new commit
+  git:status         : show current status in compact format
+  help               : print help message (of action if specified)
 ```
 
 
-### Default Action
+### Category Action or Alias
 
-* `config.default = "test1"` defines default action.
-  In this case, action `test1` will be invoked if action name not specified in command-line.
-* Default action name is shown in help message.
+* `category "foo:bar:", action: "blabla"` defines `foo:bar` action (instead of `foo:bar:blabla`) with `blabla()` method.
 
-File: ex17.rb
+File: ex24.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
+  category "foo:bar:", action: "test3"      # !!!!
 
   @action.("test action #1")
-  def test1()
+  def test1()                 # action name: 'foo:bar:test1'
+    puts __method__
+  end
+
+  @action.("test action #3")
+  def test3()                 # action name: 'foo:bar'
     puts __method__
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-config.default_action = "test1"     # !!!!
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex17.rb test1
-test1
+[bash]$ ruby ex24.rb -l
+Actions:
+  foo:bar            : test action #3    # !!!! not 'foo:bar:test3'
+  foo:bar:test1      : test action #1
+  help               : print help message (of action if specified)
 
-[bash]$ ruby ex17.rb               # no action name!!!!
+[bash]$ ruby ex24.rb foo:bar:test1
 test1
+
+[bash]$ ruby ex24.rb foo:bar:test3       # !!!! not available because renamed
+[ERROR] foo:bar:test3: Action not found.
+
+[bash]$ ruby ex24.rb foo:bar             # !!!! available because renamed
+test3
+```
+
+<!--
+* `category "foo:", alias_for: "blabla"` defines `foo` as an alias for `foo:blabla` action.
+  See [Alias for Action](#alias-of-action) section about alias for action.
+
+* Keyword arguments `action:` and `alias_for:` are exclusive.
+  It is not allowed to specify both of them at the same time.
+  See [Q: What is the difference between category(alias_for:) and category(action:)?](#q-what-is-the-difference-between-categoryalias_for-and-categoryaction) section for details.
+-->
+
+* Action name (and also category name) should be specified as a string. Symbol is not allowed.
+
+```ruby
+    ## Symbol is not allowed
+    category :foo                       #=> error
+    category "foo:", action: :blabla    #=> error
+```
+
+
+### Invoke Other Action
+
+* `run_action()` invokes other action.
+* `run_once()` invokes other action only once.
+  This is equivarent to 'prerequisite task' feature in task runner application.
+
+File: ex25.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class SampleAction < Benry::CmdApp::Action
+
+  @action.("create build dir")
+  def prepare()
+    puts "rm -rf build"
+    puts "mkdir build"
+  end
+
+  @action.("build something")
+  def build()
+    run_once("prepare")        # !!!!
+    run_once("prepare")        # skipped because already invoked
+    puts "echo 'README' > build/README.txt"
+    puts "zip -r build.zip build"
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex25.rb build
+rm -rf build                          # invoked only once!!!!
+mkdir build                           # invoked only once!!!!
+echo 'README' > build/README.txt
+zip -r build.zip build
+```
+
+* Action name should be a string. Symbol is not allowed.
+
+```ruby
+    ## Error because action name is not a string.
+    run_once(:prepare)
+```
+
+* When looped action is detected, Benry-CmdApp aborts action.
+
+File: ex26.rb
+
+```ruby
+require 'benry/cmdapp'
+
+class LoopedAction < Benry::CmdApp::Action
+
+  @action.("test #1")
+  def test1()
+    run_once("test2")
+  end
+
+  @action.("test #2")
+  def test2()
+    run_once("test3")
+  end
+
+  @action.("test #3")
+  def test3()
+    run_once("test1")          # !!!!
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex26.rb test1
+[ERROR] test1: Looped action detected.
+
+[bash]$ ruby ex26.rb test3
+[ERROR] test3: Looped action detected.
+```
+
+
+### Cleaning Up Block
+
+* `at_end { ... }` registers a clean-up block that is invoked at end of process (not at end of action).
+* This is very useful to register clean-up blocks in preparation action.
+* Registered blocks are invoked in reverse order of registration.
+  For example, `at_end { puts "A" }; at_end { puts "B" }; at_end { puts "C" }` prints "C", "B", and "A" at end of process.
+
+File: ex27.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class SampleAction < Benry::CmdApp::Action
+
+  @action.("create build dir")
+  def prepare()
+    puts "mkdir -p build"
+    ## register cleaning up block in preparation task
+    at_end { puts "rm -rf build" }      # !!!!
+  end
+
+  @action.("build something")
+  def build()
+    run_once("prepare")
+    puts "echo 'README' > build/README.txt"
+    puts "zip -r build.zip build"
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex27.rb build
+mkdir -p build
+echo 'README' > build/README.txt
+zip -r build.zip build
+rm -rf build    # !!!! clean-up block invoked at the end of process !!!!
+```
+
+
+### Alias for Action
+
+Alias provides alternative short name of action.
+
+* `define_alias()` in action class defines an alias with taking action category into account.
+* `Benry::CmdApp.define_alias()` defines an alias, without taking category into account.
+
+File: ex28.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class GitAction < Benry::CmdApp::Action
+  category "git:"                                   # !!!!
+
+  @action.("show current status in compact mode")
+  def status()
+    puts "git status -sb"
+  end
+
+  define_alias "st", "status"                     # !!!!
+  ## or:
+  #Benry::CmdApp.define_alias "st", "git:status"  # !!!!
+
+  category "staging:" do                            # !!!!
+
+    @action.("show changes in staging area")
+    def show()
+      puts "git diff --cached"
+    end
+
+    define_alias "staged" , "show"                # !!!!
+    ## or:
+    #Benry::CmdApp.define_alias "staged", "git:staging:show" # !!!!
+
+  end
+
+end
+
+Benry::CmdApp.define_alias "git", "git:status"    # !!!!
+
+exit Benry::CmdApp.main("sample app")
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex17.rb -h
-ex17.rb -- sample app
+[bash]$ ruby ex28.rb -h
+ex28.rb --- sample app
 
 Usage:
-  $ ex17.rb [<options>] [<action> [<arguments>...]]
+  $ ex28.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
 
-Actions: (default: test1)                   # !!!!
-  test1              : test action #1
+Actions:
+  git                : alias for 'git:status'           # !!!!
+  git:staging:show   : show changes in staging area
+  git:status         : show current status in compact mode
+  help               : print help message (of action if specified)
+  st                 : alias for 'git:status'           # !!!!
+  staged             : alias for 'git:staging:show'     # !!!!
 ```
 
+Output:
+
+```console
+[bash]$ ruby ex28.rb st                # alias name
+git status -sb
 
-### Default Help
+[bash]$ ruby ex28.rb git:status        # original action name
+git status -sb
 
-* `config.default_help = true` prints help message if action not specified in command-line.
-* This is very useful when you don't have proper default action. It's recommended.
-* `config.default_action` is prior than `config.default_help`.
+[bash]$ ruby ex28.rb staged            # alias name
+git diff --cached
 
-File: ex18.rb
+[bash]$ ruby ex28.rb git:staging:show  # original action name
+git diff --cached
+
+[bash]$ ruby ex28.rb git               # alias name
+git status -sb
+```
+
+* Aliases are printed in the help message of action (if defined).
+
+```console
+[bash]$ ruby ex28.rb git:status -h
+ex28.rb git:status --- show current status in compact mode
+
+Usage:
+  $ ex28.rb git:status
+
+Aliases:                                               # !!!!
+  git                : alias for 'git:status'           # !!!!
+  st                 : alias for 'git:status'           # !!!!
+```
+
+* Both alias and action names should be string. Symbol is not allowed.
 
 ```ruby
-#!/usr/bin/env ruby
+## Error because alias name is a Symbol.
+Benry::CmdApp.define_alias :test, "hello"
+
+## Error because action name is a Symbol.
+Benry::CmdApp.define_alias "test", :hello
+```
+
+* Target action (second argument of `define_alias()`) can be an array of string
+  which contains action name and options.
+
+File: ex29.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class MyAction < Benry::CmdApp::Action
+
+  @action.("print greeting message")
+  @option.(:lang, "-l, --lang=<lang>", "language", enum: ["en", "fr", "it"])
+  def hello(user="world", lang: "en")
+    case lang
+    when "en" ; puts "Hello, #{user}!"
+    when "fr" ; puts "Bonjour, #{user}!"
+    when "it" ; puts "Ciao, #{user}!"
+    else
+      raise "#{lang}: Unknown language."
+    end
+  end
+
+end
+
+Benry::CmdApp.define_alias("bonjour", ["hello", "--lang=fr"])        # !!!!
+Benry::CmdApp.define_alias("ciao"   , ["hello", "-l", "it", "Bob"])  # !!!!
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex29.rb hello
+Hello, world!
+
+[bash]$ ruby ex29.rb bonjour           # !!!!
+Bonjour, world!
+
+[bash]$ ruby ex29.rb bonjour Alice     # !!!!
+Bonjour, Alice!
+
+[bash]$ ruby ex29.rb ciao              # !!!!
+Ciao, Bob!
+```
+
+* It is not allowed to define an alias for other alias.
+
+```
+## define an alias
+Benry::CmdApp.define_alias("hello-it"   , ["hello", "-l", "it"])
+
+## ERROR: define an alias for other alias
+Benry::CmdApp.define_alias("ciao"       , "hello-it")   # !!!!
+```
+
+<!--
+* `category "foo:", alias_for: "bar"` defines new alias `foo` which is an alias for `foo:bar` action.
+
+File: ex30.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class GitAction < Benry::CmdApp::Action
+  category "git:", alias_for: "status"
+
+  @action.("show status in compact format")
+  def status(path=".")
+    system "git status -sb #{path}"
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex30.rb -l
+Actions:
+  git                : alias for 'git:status'                     # !!!!
+  git:status         : show status in compact format
+  help               : print help message (of action if specified)
+```
+-->
+
+* Global option `-L alias` lists all aliases.
+  This option is hidden in default, therefore not shown in help message but available in default (for debug purpose).
+
+```console
+[bash]$ ruby ex30.rb -L alias
+Aliases:
+  git                : alias for 'git:status'
+```
+
+
+### Abbreviation of Category
+
+Abbreviation of category is a shortcut of category prefix.
+For example, when `b:` is an abbreviation of a category prefix `git:branch:`, you can invoke `git:branch:create` action by `b:create`.
+
+File: ex31.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class GitAction < Benry::CmdApp::Action
+
+  category "git:" do
+
+    category "branch:" do
+
+      @action.("create a new branch")
+      def create(branch)
+        puts "git checkout -b #{branch}"
+      end
+
+    end
+
+  end
+
+end
+
+## define abbreviation 'b:' of category prefix 'git:branch:'
+Benry::CmdApp.define_abbrev("b:", "git:branch:")     # !!!!
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex31.rb b:create topic1    # invokes 'git:branch:create' !!!!
+git checkout -b topic1
+```
+
+Global option `-L abbrev` lists all abbreviations.
+This option is hidden in default, therefore not shown in help message but available in default (for debug purpose).
+
+```console
+[bash]$ ruby ex31.rb -L abbrev
+Abbreviations:
+  b:         =>  git:branch:
+```
+
+
+### Default Action
+
+* `config.default_action = "test1"` defines default action.
+  In this case, action `test1` will be invoked if action name not specified in command-line.
+* Default action name is shown in help message.
+
+File: ex32.rb
+
+```ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -1156,39 +1681,262 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-config.default_help = true     # !!!!
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app", "1.0.0",
+                        default_action: "test1")   # !!!!
+## or:
+#config = Benry::CmdApp::Config.new("sample app", "1.0.0")
+#config.default_action = "test1"     # !!!!
+#app = Benry::CmdApp::Application.new(config)
+#exit app.main()
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex18.rb            # no action name!!!!
-ex18.rb -- sample app
+[bash]$ ruby ex32.rb test1
+test1
+
+[bash]$ ruby ex32.rb               # no action name!!!!
+test1
+```
+
+Help message:
+
+```console
+[bash]$ ruby ex32.rb -h
+ex32.rb --- sample app
 
 Usage:
-  $ ex18.rb [<options>] [<action> [<arguments>...]]
+  $ ex32.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
 
+Actions: (default: test1)                   # !!!!
+  help               : print help message (of action if specified)
+  test1              : test action #1
+```
+
+
+### Action List and Category List
+
+When `config.default_action` is not specified, Benry-CmdAction lists action names if action name is not specified in command-line.
+
+File: ex33.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class SampleAction < Benry::CmdApp::Action
+
+  @action.("test action #1")
+  def test1()
+  end
+
+  category "foo:" do
+
+    @action.("test action #2")
+    def test2()
+    end
+
+  end
+
+  category "bar:" do
+
+    @action.("test action #3")
+    def test3()
+    end
+
+    category "baz:" do
+
+      @action.("test action #4")
+      def test4()
+      end
+
+    end
+
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex33.rb            # no action name!!!!
 Actions:
+  bar:baz:test4      : test action #4
+  bar:test3          : test action #3
+  foo:test2          : test action #2
+  help               : print help message (of action if specified)
   test1              : test action #1
 ```
 
+Command-line option `-l, --list` also prints the same result of the above example.
+This is useful if you specify default action name wit `config.default_action`.
+
+Action name list contains alias names, too.
+If you want to list only action names (or alias names), specify `-L action` or `-L alias` option.
+See [Q: How to list only aliases (or actions) excluding actions (or aliases) ?](#q-how-to-list-only-aliases-or-actions-excluding-actions-or-aliases-) for details.
+
+If category prefix (such as `xxx:`) is specified instead of action name,
+Benry-CmdApp lists action names which have that category prefix.
+
+Output:
+
+```console
+[bash]$ ruby ex33.rb foo:              # !!!!
+Actions:
+  foo:test2          : test action #2
+
+[bash]$ ruby ex33.rb bar:              # !!!!
+Actions:
+  bar:baz:test4      : test action #4
+  bar:test3          : test action #3
+```
+
+If `:` is specified instead of action name, Benry-CmdApp lists top-level category prefixes of action names and number of actions under the each category prefix.
+
+Outuput:
+
+```console
+[bash]$ ruby ex33.rb :                 # !!!!
+Categories: (depth=1)
+  bar: (2)           # !!! two actions ('bar:test3' and 'bar:baz:test4')
+  foo: (1)           # !!! one action ('foo:text2')
+```
+
+In the above example, only top-level category prefixes are displayed.
+If you specified `::` instead of `:`, second-level category prefixes are displayed,
+for example `foo:xxx:` and `foo:yyy:`.
+Of course, `:::` displays more level category prefixes.
+
+File: ex34.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class GitAction < Benry::CmdApp::Action
+  category "git:"
+
+  category "staging:" do
+    @action.("...");  def add(); end
+    @action.("...");  def show(); end
+    @action.("...");  def delete(); end
+  end
+
+  category "branch:" do
+    @action.("...");  def list(); end
+    @action.("...");  def switch(name); end
+  end
+
+  category "repo:" do
+    @action.("...");  def create(); end
+    @action.("...");  def init(); end
+
+    category "config:" do
+      @action.("...");  def add(); end
+      @action.("...");  def delete(); end
+      @action.("...");  def list(); end
+    end
+
+    category "remote:" do
+      @action.("...");  def list(); end
+      @action.("...");  def set(); end
+    end
+
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex34.rb :
+Categories: (depth=1)
+  git: (12)
+
+[bash]$ ruby ex34.rb ::             # !!!!
+Categories: (depth=2)
+  git: (0)
+  git:branch: (2)
+  git:repo: (7)
+  git:staging: (3)
+
+[bash]$ ruby ex34.rb :::            # !!!!
+Categories: (depth=3)
+  git: (0)
+  git:branch: (2)
+  git:repo: (2)
+  git:repo:config: (3)
+  git:repo:remote: (2)
+  git:staging: (3)
+```
+
+`category()` can take a description of category as second argument.
+Descriptions of category are displayed in the category prefix list.
+
+File: ex35.rb
+
+```ruby
+# coding: utf-8
+require 'benry/cmdapp'
+
+class SampleAction < Benry::CmdApp::Action
+
+  category "foo:", "description of Foo" do
+    @action.("test action #2")
+    def test2()
+    end
+  end
+
+  category "bar:", "description of Bar" do
+    @action.("test action #3")
+    def test3()
+    end
+
+    category "baz:", "description fo Baz" do
+      @action.("test action #4")
+      def test4()
+      end
+    end
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex35.rb :                       # !!!!
+Categories: (depth=1)
+  bar: (2)           : description of Bar    # !!!!
+  foo: (1)           : description of Foo    # !!!!
+```
+
 
-### Private (Hidden) Action
+### Hidden Action
 
-* If action method is private, Benry::CmdApp regards that action as private.
-* Private actions are hidden in help message.
-* Private actions are shown when `-a` or `--all` option enabled and specified.
+* If `hidden: true` keyword argument passed to `@action.()`,
+  or action method is private, then Benry-CmdApp regards that action as hidden.
+* Hidden actions are not shown in help message nor action list by default.
+* Hidden actions are shown when `-a` or `--all` option is specified in command-line.
 
-File: ex20.rb
+File: ex36.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -1198,13 +1946,12 @@ class SampleAction < Benry::CmdApp::Action
     puts __method__
   end
 
-  @action.("test action #2")
+  @action.("test action #2", hidden: true)  # !!!!
   def test2()
     puts __method__
   end
-  private :test2               # !!!! private method !!!!
 
-  private                      # !!!! private method !!!!
+  private                      # !!!!
 
   @action.("test action #3")
   def test3()
@@ -1213,86 +1960,64 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-config.option_all = true       # !!!! enable '-a, --all' option !!!!
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
-Help message (without `-a` nor `--all`):
+Action list (without `-a` nor `--all`):
 
 ```console
-[bash]$ ruby ex20.rb -h
-ex20.rb -- sample app
-
-Usage:
-  $ ex20.rb [<options>] [<action> [<arguments>...]]
-
-Options:
-  -h, --help         : print help message (of action if action specified)
-  -a, --all          : list all actions/options including private (hidden) ones
-
+[bash]$ ruby ex36.rb
 Actions:
+  help               : print help message (of action if specified)
   test1              : test action #1
 ```
 
-Help message (with `-a` or `--all`):
+Action list (with `-a` or `--all`):
 
 ```console
-[bash]$ ruby ex20.rb -h --all      # !!!!
-ex20.rb -- sample app
-
-Usage:
-  $ ex20.rb [<options>] [<action> [<arguments>...]]
-
-Options:
-  -h, --help         : print help message (of action if action specified)
-  -a, --all          : list all actions/options including private (hidden) ones
-
+[bash]$ ruby ex36.rb --all      # !!!!
 Actions:
+  help               : print help message (of action if specified)
   test1              : test action #1
   test2              : test action #2          # !!!!
   test3              : test action #3          # !!!!
 ```
 
 
-### Private (Hidden) Option
+### Hidden Option
 
-* Options which name stars with `_` are treated as private option.
-* Private options are hidden in help message of action.
-* Private options are shown when `-a` or `--all` option enabled and specified.
+* Options defined with `hidden: true` keyword argument are treated as hidden option.
+* Hidden options are not shown in help message of action.
+* Hidden options are shown when `-a` or `--all` option is specified in command-line.
 
-File: ex21.rb
+File: ex37.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
   @action.("test action")
   @option.(:verbose, "-v", "verbose mode")
-  @option.(:_debug , "-D", "debug mode")      # !!!!
-  def test1(verbose: false, _debug: false)
-    puts "verbose=#{verbose}, _debug=#{_debug}"
+  @option.(:debug , "-D", "debug mode", hidden: true)      # !!!!
+  def test1(verbose: false, debug: false)
+    puts "verbose=#{verbose}, debug=#{debug}"
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-config.option_all = true       # !!!! enable '-a, --all' option !!!!
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Help message (without `-a` nor `--all`):
 
 ```console
-[bash]$ ruby ex21.rb -h test1
-ex21.rb test1 -- test action
+[bash]$ ruby ex37.rb -h test1
+ex37.rb test1 --- test action
 
 Usage:
-  $ ex21.rb test1 [<options>]
+  $ ex37.rb test1 [<options>]
 
 Options:
   -v                 : verbose mode
@@ -1301,17 +2026,79 @@ Options:
 Help message (with `-a` or `--all`)
 
 ```console
-[bash]$ ruby ex21.rb -h --all test1           # !!!!
-ex21.rb test1 -- test action
+[bash]$ ruby ex37.rb -h --all test1           # !!!!
+ex37.rb test1 --- test action
 
 Usage:
-  $ ex21.rb test1 [<options>]
+  $ ex37.rb test1 [<options>]
 
 Options:
+  -h, --help         : print help message     # !!!!
   -v                 : verbose mode
   -D                 : debug mode             # !!!!
 ```
 
+In the above example, `-h, --help` option as well as `-D` option is shown.
+In fact, Benry-CmdApp automatically adds `-h, --help` option to each action in hidden mode.
+Therefore all actions accept `-h, --help` option.
+
+For this reason, you should NOT define `-h` or `--help` options for your actions.
+
+
+### Important Actions or Options
+
+It is possible to mark actions or options as important or not.
+
+* Actions or options marked as important are emphasized in help message.
+* Actions or options marked as not important are weaken in help message.
+
+File: ex38.rb
+
+```ruby
+require 'benry/cmdapp'
+
+class SampleAction < Benry::CmdApp::Action
+
+  @action.("important action", important: true)   # !!!!
+  def test1()
+  end
+
+  @action.("not important action", important: false)   # !!!!
+  def test2()
+  end
+
+  @action.("sample")
+  @option.(:foo, "--foo", "important option", important: true)
+  @option.(:bar, "--bar", "not important option", important: false)
+  def test3(foo: nil, bar: nil)
+  end
+
+end
+
+exit Benry::CmdApp.main("sample app")
+```
+
+Output:
+
+```console
+[bash]$ ruby ex38.rb -l
+Actions:
+  help               : print help message (of action if specified)
+  test1              : important action      # !!!! bold font !!!!
+  test2              : not important action  # !!!! gray color !!!!
+  test3              : sample
+
+[bash]$ ruby ex38.rb -h test3
+ex38.rb test3 --- sample
+
+Usage:
+  $ ex38.rb test3 [<options>]
+
+Options:
+  --foo              : important option      # !!!! bold font !!!!
+  --bar              : not important option  # !!!! gray color !!!!
+```
+
 
 
 ## Configuratoin and Customization
@@ -1324,67 +2111,105 @@ Options:
 * `config.app_desc = "..."` sets command description which is shown in help message. (required)
 * `config.app_version = "1.0.0"` enables `-V` and `--version` option, and prints version number if `-V` or `--version` option specified. (default: `nil`)
 * `config.app_command = "<command>"` sets command name which is shown in help message. (default: `File.basname($0)`)
+* `config.app_name = "<string>"` sets application name which is shown in help message. (default: same as `config.app_command`)
+* `config.app_usage = "<text>" (or `["<text1>", "<text2>", ...]`) sets usage string in help message. (default: `" <action> [<arguments>...]"`)
 * `config.app_detail = "<text>"` sets detailed description of command which is showin in help message. (default: `nil`)
+* `config.backtrace_ignore_rexp = /.../` sets regular expression to ignore backtrace when error raised. (default: `nil`)
+* `config.help_description = "<text>"` sets text of 'Description:' section in help message. (default: `nil`)
+* `config.help_postamble = {"<Title>:" => "<text>"}` sets postamble of help message, such as 'Example:' or 'Tips:'. (default: `nil`)
 * `config.default_action = "<action>"` sets default action name. (default: `nil`)
-* `config.default_help = true` prints help message if no action names specified in command-line. (default: `false`)
 * `config.option_help = true` enables `-h` and `--help` options. (default: `true`)
-* `config.option_all = true` enables `-a` and `--all` options which shows private (hidden) actions and options into help message. (default: `false`)
+* `config.option_version = true` enables `-V` and `--version` options. (default: `true` if `app_version` provided, `false` if else)
+* `config.option_list = true` enables `-l` and `--list` options. (default: `true`)
+* `config.option_topic = true` enables `-L <topic>` option. (default: `:hidden`)
+* `config.option_all = true` enables `-a` and `--all` options which shows private (hidden) actions and options into help message. (default: `true`)
 * `config.option_verbose = true` enables `-v` and `--verbose` options which sets `$QUIET_MODE = false`. (default: `false`)
 * `config.option_quiet = true` enables `-q` and `--quiet` options which sets `$QUIET_MODE = true`. (default: `false`)
 * `config.option_color = true` enables `--color[=<on|off>]` option which sets `$COLOR_MODE = true/false`. This affects to help message colorized or not. (default: `false`)
-* `config.option_debug = true` enables `-D` and `--debug` options which sets `$DEBUG_MODE = true`. (default: `false`)
-* `config.option_trace = true` enables `-T` and `--trace` options which sets `$TRACE_MODE = true`. Entering into and exitting from action are reported when trace mode is on. (default: `false`)
-* `config.help_aliases = true` adds `Aliases:` section in help message. (default: `false`)
-* `config.help_sections = [["<title>", "<text>"], ...]` adds section title and text into help message. (default: `[]`)
-* `config.help_postamble = "<text>"` sets postamble text in help message, such as 'Examples:' or 'Tips:'. (default: `nil`)
-* `config.feat_candidate = true` enables feature to list action names starting with 'foo:' when action name specified in command-line is `foo:`. (default: `true`)
-* `config.format_help = "  %-18s : %s"` sets format of options and actions in help message. (default: `"  \e[1m%-18s\e[0m : %s"`)
-* `config.format_usage = "  $ %s %s"` sets format of usage in help message. (default: `"  $ \e[1m%s\e[0m %s"`)
-* `config.format_heading = "[%s]"` sets format of heading in help message. (default: `"\e[34m%s\e[0m"`)
+* `config.option_debug = true` enables `-D` and `--debug` options which sets `$DEBUG_MODE = true`. (default: `:hidden`)
+* `config.option_trace = true` enables `-T` and `--trace` options. Entering into and exitting from action are reported when trace mode is on. (default: `false`)
+* `config.option_dryrun = true` enables `-X` and `--dryrun` options which sets `$DRYRUN_MODE = true`. (default: `false`)
+* `config.format_option = "  %-18s : %s"` sets format of options in help message. (default: `"  %-18s : %s"`)
+* `config.format_action = "  %-18s : %s"` sets format of actions in help message. (default: `"  %-18s : %s"`)
+* `config.format_usage = "  $ %s"` sets format of usage in help message. (default: `"  $ %s"`)
+* `config.format_avvrev = "  %-10s =>  %s"` sets format of abbreviations in output of `-L abbrev` option. (default: `"  %-10s =>  %s"`)
+* `config.format_usage = "  $ %s"` sets format of usage in help message. (default: `"  $ %s"`)
+* `config.format_category = "  $-18s : %s""` sets format of category prefixes in output of `-L category` option. (default: `nil` which means to use value of `config.format_action`)
 
-File: ex22.rb
+File: ex41.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-config = Benry::CmdApp::Config.new("sample app", "1.0.0")
-#config.default_help = true
-
-config.class.instance_methods(false).each do |name|
-  next if name =~ /=$/
-  next if ! config.class.method_defined?("#{name}=")
-  val = config.__send__(name)
-  puts "%-25s = %s" % ["config.#{name}", val.inspect]
+config = Benry::CmdApp::Config.new("sample app", "1.0.0", app_name: "Sample App")
+config.each(sort: false) do |name, val|
+  puts "config.%-20s = %s" % [name, val.inspect]
 end
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex22.rb
-config.app_desc           = "sample app"
-config.app_version        = "1.0.0"
-config.app_name           = "ex22.rb"
-config.app_command        = "ex22.rb"
-config.app_detail         = nil
-config.default_action     = nil
-config.default_help       = false
-config.option_help        = true
-config.option_all         = false
-config.option_verbose     = false
-config.option_quiet       = false
-config.option_color       = false
-config.option_debug       = false
-config.option_trace       = false
-config.help_aliases       = false
-config.help_sections      = []
-config.help_postamble     = nil
-config.feat_candidate     = true
-config.format_help        = "  \e[1m%-18s\e[0m : %s"
-config.format_usage       = "  $ \e[1m%s\e[0m %s"
-config.format_heading     = "\e[34m%s\e[0m"
-config.format_appname     = "\e[1m%s\e[0m"
+[bash]$ ruby ex41.rb
+config.app_desc             = "sample app"
+config.app_version          = "1.0.0"
+config.app_name             = "Sample App"
+config.app_command          = "ex41.rb"             # == File.basename($0)
+config.app_usage            = nil
+config.app_detail           = nil
+config.default_action       = nil
+config.help_description     = nil
+config.help_postamble       = nil
+config.format_option        = "  %-18s : %s"
+config.format_action        = "  %-18s : %s"
+config.format_usage         = "  $ %s"
+config.format_category      = nil
+config.deco_command         = "\e[1m%s\e[0m"        # bold
+config.deco_header          = "\e[1;34m%s\e[0m"     # bold, blue
+config.deco_extra           = "\e[2m%s\e[0m"        # gray color
+config.deco_strong          = "\e[1m%s\e[0m"        # bold
+config.deco_weak            = "\e[2m%s\e[0m"        # gray color
+config.deco_hidden          = "\e[2m%s\e[0m"        # gray color
+config.deco_debug           = "\e[2m%s\e[0m"        # gray color
+config.deco_error           = "\e[31m%s\e[0m"       # red
+config.option_help          = true
+config.option_version       = true
+config.option_list          = true
+config.option_topic         = :hidden
+config.option_all           = true
+config.option_verbose       = false
+config.option_quiet         = false
+config.option_color         = false
+config.option_debug         = :hidden
+config.option_trace         = false
+config.option_dryrun        = false
+config.backtrace_ignore_rexp = nil
+config.trace_mode           = nil
+```
+
+You may notice that the value of `config.option_debug` is `:hidden`.
+If value of `config.option_xxxx` is `:hidden`, then corresponding global option is enabled as hidden option.
+Therefore you can see `--debug` option in help message if you add `-h` and `-a` (or `--all`) option.
+
+Help message:
+
+```console
+$ ruby ex37.rb -h -a                          # !!!!
+ex37.rb --- sample app
+
+Usage:
+  $ ex37.rb [<options>] <action> [<arguments>...]
+
+Options:
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
+      --debug        : debug mode             # !!!!
+
+Actions:
+  help               : print help message (of action if specified)
+  test1              : test action
 ```
 
 
@@ -1392,14 +2217,14 @@ config.format_appname     = "\e[1m%s\e[0m"
 
 To add custom global options:
 
-* (1) Create global option schema object.
+* (1) Create a global option schema object.
 * (2) Add custom options to it.
 * (3) Pass it to `Application.new()`.
 
-File: ex23.rb
+File: ex42.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -1413,7 +2238,7 @@ end
 
 ## (1) create global option shema
 config = Benry::CmdApp::Config.new("sample app")
-schema = Benry::CmdApp::AppOptionSchema.new(config)  # !!!!
+schema = Benry::CmdApp::GlobalOptionSchema.new(config)  # !!!!
 
 ## (2) add custom options to it
 schema.add(:logging, "--logging", "enable logging")    # !!!!
@@ -1427,81 +2252,106 @@ exit app.main()
 Help message:
 
 ```console
-[bash]$ ruby ex23.rb -h
-ex23.rb -- sample app
+[bash]$ ruby ex42.rb -h
+ex42.rb --- sample app
 
 Usage:
-  $ ex23.rb [<options>] [<action> [<arguments>...]]
+  $ ex42.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
   --logging          : enable logging          # !!!!
 
 Actions:
+  help               : print help message (of action if specified)
   test1              : test action
 ```
 
 To customize global options entirely:
 
-* (1) Create empty `AppOptionSchema` object.
+* (1) Create empty `GlobalOptionSchema` object.
 * (2) Add global options as you want.
 * (3) Create and execute Application object with it.
 
-File: ex24.rb
+File: ex43.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
-## (1) Create empty ``AppOptionSchema`` object.
-schema = Benry::CmdApp::AppOptionSchema.new(nil)   # !!!!
+## (1) Create empty ``GlobalOptionSchema`` object.
+schema = Benry::CmdApp::GlobalOptionSchema.new(nil)   # !!!!
 
 ## (2) Add global options as you want.
 schema.add(:help   , "-h, --help"   , "print help message")
 schema.add(:version, "-V, --version", "print version")
-schema.add(:all    , "-a, --all"    , "list all actions/options")
+schema.add(:list   , "-l, --list"   , "list actions and aliases")
+schema.add(:all    , "-a, --all"    , "list hidden actions/options, too")
 schema.add(:verbose, "-v, --verbose", "verbose mode")
 schema.add(:quiet  , "-q, --quiet"  , "quiet mode")
-schema.add(:color  , "--color[=<on|off>]", "enable/disable color", type: TrueClass)
+schema.add(:color  , "--color[=<on|off>]", "enable/disable color mode", type: TrueClass)
 schema.add(:debug  , "-D, --debug"  , "set $DEBUG_MODE to true")
 schema.add(:trace  , "-T, --trace"  , "report enter into and exit from action")
 
 ## (3) Create and execute Application object with it.
-config = Benry::CmdApp::Config.new("sample app")
+config = Benry::CmdApp::Config.new("sample app", "1.0.0")
 app = Benry::CmdApp::Application.new(config, schema)  # !!!!
 exit app.main()
 ```
 
+Help message:
+
+```console
+[bash]$ ruby ex43.rb -h
+ex43.rb (1.0.0) --- sample app
+
+Usage:
+  $ ex43.rb [<options>] <action> [<arguments>...]
+
+Options:
+  -h, --help         : print help message
+  -V, --version      : print version
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
+  -v, --verbose      : verbose mode
+  -q, --quiet        : quiet mode
+  --color[=<on|off>] : enable/disable color mode
+  -D, --debug        : set $DEBUG_MODE to true
+  -T, --trace        : report enter into and exit from action
+
+Actions:
+  help               : print help message (of action if specified)
+```
+
+
 
 ### Customization of Global Option Behaviour
 
 * (1) Define subclass of `Application` class.
-* (2) Override `#do_toggle_global_switches()` method.
+* (2) Override `#toggle_global_options()` method.
 * (3) Create and execute subclass object of `Application`.
 
-File: ex25.rb
+File: ex44.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 ## (1) Define subclass of ``Application`` class.
 class MyApplication < Benry::CmdApp::Application
 
-  ## (2) Override ``#do_toggle_global_switches()`` method.
-  def do_toggle_global_switches(_args, global_opts)
-    super
-    ## here is original behaviour
-    #global_opts.each do |key, val|
-    #  case key
-    #  when :verbose ; $QUIET_MODE = ! val
-    #  when :quiet   ; $QUIET_MODE = val
-    #  when :color   ; $COLOR_MODE = val
-    #  when :debug   ; $DEBUG_MODE = val
-    #  when :trace   ; $TRACE_MODE = val
-    #  else          ; # do nothing
-    #  end
-    #end
+  ## (2) Override ``#toggle_global_options()`` method.
+  def toggle_global_options(global_opts)
+    status_code = super
+    return status_code if status_code  # `return 0` means "stop process successfully",
+                                       # `return 1` means "stop process as failed".
+    if global_opts[:logging]
+      require 'logger'
+      $logger = Logger.new(STDOUT)
+    end
+    return nil                   # `return nil` means "continue process".
   end
 
 end
@@ -1514,15 +2364,15 @@ exit app.main()
 
 Of course, prepending custom module to Application class is also effective way.
 
-File: ex26.rb
+File: ex45.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 module MyApplicationMod
 
-  def do_toggle_global_switches(_args, global_opts)
+  def toggle_global_options(global_opts)
     # ....
   end
 
@@ -1539,13 +2389,13 @@ exit app.main()
 ### Custom Hook of Application
 
 * (1) Define subclass of Application class.
-* (2) Override callback method.
+* (2) Override `#handle_action()` method.
 * (3) Create and execute custom application object.
 
-File: ex27.rb
+File: ex46.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -1560,78 +2410,37 @@ end
 ## (1) Define subclass of Application class
 class MyApplication < Benry::CmdApp::Application   # !!!!
 
-  ## (2) Override callback method
-  def do_callback(args, global_opts)               # !!!!
+  ## (2) Override method
+  def handle_action(action, args)                  # !!!!
     #p @config
-    #p @schema
-    if global_opts[:logging]
-      require 'logger'
-      $logger = Logger.new(STDOUT)
-    end
-    ## if return :SKIP, action skipped (not invoked).
-    #return :SKIP
+    $logger.debug("action=#{action}, args=#{args.inspect}") if $logger
+    super                                          # !!!!
   end
 
-  ## or:
-  #def do_handle_global_options(args, global_opts)
-  #  if global_opts[:logging]
-  #    require 'logger'
-  #    $logger = Logger.new(STDOUT)
-  #  end
-  #  super
-  #end
-
 end
 
 ## (3) create and execute custom application object
 config = Benry::CmdApp::Config.new("sample app")
-schema = Benry::CmdApp::AppOptionSchema.new(config)
+schema = Benry::CmdApp::GlobalOptionSchema.new(config)
 schema.add(:logging, "--logging", "enable logging")
 app = MyApplication.new(config, schema)             # !!!!
 exit app.main()
 ```
 
-* [EXPERIMENTAL] Instead of defining subclass of Application, you can pass callback block to Application object.
-
-File: ex28.rb
-
-```ruby
-#!/usr/bin/env ruby
-require 'benry/cmdapp'
-
-class SampleAction < Benry::CmdApp::Action
-
-  @action.("test action")
-  def test1()
-    $logger.info("logging message") if $logger
-  end
-
-end
-
-config = Benry::CmdApp::Config.new("sample app")
-schema = Benry::CmdApp::AppOptionSchema.new(config)
-schema.add(:logging, "--logging", "enable logging")
-app = Benry::CmdApp::Application.new(config, schema) do   # !!!!
-  |args, global_opts, config|                             # !!!!
-  if global_opts[:logging]                                # !!!!
-    require 'logger'                                      # !!!!
-    $logger = Logger.new(STDOUT)                          # !!!!
-  end                                                     # !!!!
-  #:SKIP                                                  # !!!!
-end                                                       # !!!!
-exit app.main()
-```
 
+### Customization of Application Help Message
 
-### Customization of Command Help Message
+If you want to just add more text into application help message,
+set the followings:
 
-If you want to just add more text into command help message,
-set `config.app_detail`, `config.help_sections`, and/or `config.help_postamble`.
+.* `config.app_detail = <text>` --- print text before 'Usage:' section.
+.* `config.help_description = <text>` --- print text after 'Usage:' section as 'Description:' section.
+.* `config.help_postamble = {<head> => <text>}` --- print at end of help message.
 
-File: ex29.rb
+File: ex47.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
@@ -1643,12 +2452,14 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-config.app_detail = "Document: https://...."      # !!!!
-config.help_sections = [                          # !!!!
-  ["Example:", "  $ <command> hello Alice"],      # !!!!
+config = Benry::CmdApp::Config.new("sample app", "1.0.0")
+config.app_detail = "See https://...."            # !!!!
+config.help_description = "  Bla bla bla"         # !!!!
+config.help_postamble = [                         # !!!!
+  {"Example:" => "  $ <command> hello Alice\n"},  # !!!!
+  "(Tips: ....)",                                 # !!!!
 ]                                                 # !!!!
-config.help_postamble = "(Tips: ....)"            # !!!!
+
 app = Benry::CmdApp::Application.new(config)
 exit app.main()
 ```
@@ -1656,288 +2467,337 @@ exit app.main()
 Help message:
 
 ```console
-[bash]$ ruby ex29.rb -h
-ex29.rb -- sample app
+[bash]$ ruby ex47.rb -h
+ex47.rb --- sample app
 
-Document: https://....              # !!!! app.detail !!!!
+See https://....                       # !!!!
 
 Usage:
-  $ ex29.rb [<options>] [<action> [<arguments>...]]
+  $ ex47.rb [<options>] <action> [<arguments>...]
+
+Description:                           # !!!!
+  Bla bla bla                          # !!!!
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
 
 Actions:
   hello              : test action #1
 
-Example:                            # !!!! help_sections !!!!
-  $ <command> hello Alice           # !!!! help_sections !!!!
+Example:                                # !!!!
+  $ <command> hello Alice               # !!!!
 
-(Tips: ....)                        # !!!! help_postamble !!!!
+(Tips: ....)                            # !!!!
 ```
 
 If you want to change behaviour of building command help message:
 
-* (1) Define subclass of `Benry::CmdApp::AppHelpBuilder` class.
+* (1) Define subclass of `Benry::CmdApp::ApplicationHelpBuilder` class.
 * (2) Override methods.
 * (3) Create an instance object of the class.
 * (4) Pass it to Application object.
 
-File: ex30.rb
+File: ex48.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("greeting message")
+  @action.("print greeting message")
   def hello(user="world")
     puts "Hello, #{user}!"
   end
 
 end
 
-## (1) Define subclass of ``Benry::CmdApp::AppHelpBuilder`` class.
-class MyAppHelpBuilder < Benry::CmdApp::AppHelpBuilder
+## (1) Define subclass of ``Benry::CmdApp::ApplicationHelpBuilder`` class.
+class MyAppHelpBuilder < Benry::CmdApp::ApplicationHelpBuilder
 
   ## (2) Override methods.
-  def build_help_message(all=false, format=nil)
-    super
-  end
-  def build_preamble(all=false)
+  def build_help_message(gschema, all: false)
     super
   end
-  def build_usage(all=false)
+  def section_preamble()
     super
   end
-  def build_options(all=false, format=nil)
+  def section_usage()
     super
   end
-  def build_actions(all=false, format=nil)
+  def section_options(global_opts_schema, all: false)
     super
   end
-  def build_postamble(all=false)
+  def section_actions(include_aliases=true, all: false)
     super
   end
-  def heading(str)
+  def section_postamble()
     super
   end
+  ### optional (for `-L <topic>` option)
+  #def section_candidates(prefix, all: false); super; end
+  #def section_aliases(all: false); super; end
+  #def section_abbrevs(all: false); super; end
+  #def section_categories(depth=0, all: false); super; end
 end
 
 ## (3) Create an instance object of the class.
 config = Benry::CmdApp::Config.new("sample app")
-schema = Benry::CmdApp::AppOptionSchema.new(config)
+schema = Benry::CmdApp::GlobalOptionSchema.new(config)
 schema.add(:logging, "--logging", "enable logging")
-help_builder = MyAppHelpBuilder.new(config, schema)     # !!!!
+app_help_builder = MyAppHelpBuilder.new(config)      # !!!!
 
 ## (4) Pass it to Application object.
-app = Benry::CmdApp::Application.new(config, schema, help_builder) # !!!!
+app = Benry::CmdApp::Application.new(config, schema, app_help_builder) # !!!!
 exit app.main()
 ```
 
 More simple way:
 
-* (1) Create a module and override methods of `Benry::CmdApp::AppHelpBuilder` class.
-* (2) Prepend it to `Benry::CmdApp::AppHelpBuilder` class.
+* (1) Create a module and override methods of `Benry::CmdApp::ApplicationHelpBuilder` class.
+* (2) Prepend it to `Benry::CmdApp::ApplicationHelpBuilder` class.
 * (3) Create and execute Application object.
 
-File: ex31.rb
+File: ex49.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("greeting message")
+  @action.("print greeting message")
   def hello(user="world")
     puts "Hello, #{user}!"
   end
 
 end
 
-## (1) Create a module and override methods of ``AppHelpBuilder`` class.
+## (1) Create a module and override methods of ``ApplicationHelpBuilder`` class.
 module MyHelpBuilderMod
-  def build_help_message(all=false, format=nil)
+  def build_help_message(gschema, all: false)
     super
   end
-  def build_preamble(all=false)
+  def section_preamble()
     super
   end
-  def build_usage(all=false)
+  def section_usage()
     super
   end
-  def build_options(all=false, format=nil)
+  def section_options(global_opts_schema, all: false)
     super
   end
-  def build_actions(all=false, format=nil)
+  def section_actions(include_aliases=true, all: false)
     super
   end
-  def build_postamble(all=false)
-    super
-  end
-  def heading(str)
+  def section_postamble()
     super
   end
+  ### optional (for `-L <topic>` option)
+  #def section_candidates(prefix, all: false); super; end
+  #def section_aliases(all: false); super; end
+  #def section_abbrevs(all: false); super; end
+  #def section_categories(depth=0, all: false); super; end
 end
 
-## (2) Prepend it to ``Benry::CmdApp::AppHelpBuilder`` class.
-Benry::CmdApp::AppHelpBuilder.prepend(MyHelpBuilderMod)
+## (2) Prepend it to ``Benry::CmdApp::ApplicationHelpBuilder`` class.
+Benry::CmdApp::ApplicationHelpBuilder.prepend(MyHelpBuilderMod)
 
-## (3) Create and execute Application object.
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+## (3) Run application.
+exit Benry::CmdApp.main("sample app")
 ```
 
 
 ### Customization of Action Help Message
 
 If you want to just add more text into action help message,
-pass `detail:` and/or `postamble:` keyword arguments to `@action.()`.
+pass the following keyword arguments to `@action.()`.
 
-File: ex32.rb
+* `detail: <text>` --- printed before 'Usage:' section.
+* `description: <text>` --- printed after 'Usage:' section as 'Description:' section, like `man` command in UNIX.
+* `postamble: {<header> => <text>}` --- printed at end of help message as a dedicated section.
+
+File: ex50.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
   @action.("test action #1",
-           detail: "Document: https://....",      # !!!!
-           postamble: "(Tips: ....)")             # !!!!
+           detail: "See https://....",           # !!!!
+           description: "  Bla bla bla",         # !!!!
+           postamble: {"Example:" => "  ...."})  # !!!!
   def hello(user="world")
     puts "Hello, #{user}!"
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex32.rb -h
-ex32.rb hello -- test action #1
+[bash]$ ruby ex50.rb -h hello
+ex50.rb hello --- test action #1
 
-Document: https://....                  # !!!!
+See https://....                  # !!!!
 
 Usage:
-  $ ex32.rb hello [<user>]
+  $ ex50.rb hello [<user>]
 
-(Tips: ....)                            # !!!!
+Description:                      # !!!!
+  Bla bla bla                     # !!!!
+
+Example:
+  ....                            # !!!!
 ```
 
 If you want to change behaviour of building action help message:
 
-* (1) Create a module and override methods of `Benry::CmdApp::ActionHelpBuilder` class.
-* (2) Prepend it to `Benry::CmdApp::ActionHelpBuilder` class.
-* (3) Create and execute Application object.
+* (1) Define subclass of `ActionHelpBuilder` class.
+* (2) Override methods.
+* (3) Create an instance object of the class.
+* (4) Pass it to Application object.
 
-File: ex33.rb
+File: ex51.rb
 
 ```ruby
-#!/usr/bin/env ruby
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("greeting message")
+  @action.("print greeting message")
   def hello(user="world")
     puts "Hello, #{user}!"
   end
 
 end
 
-## (1) Create a module and override methods of ``ActionHelpBuilder`` class.
-module MyActionHelpBuilderMod
-  def build_help_message(command, all=false)
+## (1) Define subclass of ``ActionHelpBuilder`` class.
+class MyActionHelpBuilder < Benry::CmdApp::ActionHelpBuilder
+  ## (2) Override methods.
+  def build_help_message(metadata, all: false)
     super
   end
-  def build_preamble(command, all=false)
+  def section_preamble(metadata)
     super
   end
-  def build_usage(command, all=false)
+  def section_usage(metadata, all: false)
     super
   end
-  def build_options(command, all=false)
+  def section_description(metadata)
     super
   end
-  def build_postamble(command, all=false)
+  def section_options(metadata, all: false)
     super
   end
-  def heading(str)
+  def section_postamble(metadata)
     super
   end
 end
 
-## (2) Prepend it to ``Benry::CmdApp::ActionHelpBuilder`` class.
-Benry::CmdApp::ActionHelpBuilder.prepend(MyActionHelpBuilderMod)  # !!!!
-
-## (3) Create and execute Application object.
+## (3) Create an instance object of the class.
 config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
+action_help_builder = MyActionHelpBuilder.new(config)
+
+## (4) Pass it to Application object.
+schema = Benry::CmdApp::GlobalOptionSchema.new(config)
+app = Benry::CmdApp::Application.new(config, schema, nil, action_help_builder)
 exit app.main()
 ```
 
 Another way:
 
-* (1) Define subclass of `ActionHelpBuilder` class.
-* (2) Set it to `ACTION_HELP_BUILDER_CLASS` constant value.
-* (3) Create and execute Application object.
+* (1) Create a module and override methods of `Benry::CmdApp::ActionHelpBuilder` class.
+* (2) Prepend it to `Benry::CmdApp::ActionHelpBuilder` class.
+* (3) Run application.
 
-File: ex34.rb
+File: ex52.rb
 
 ```ruby
-#!/usr/bin/env ruby
+# coding: utf-8
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("greeting message")
+  @action.("print greeting message")
   def hello(user="world")
     puts "Hello, #{user}!"
   end
 
 end
 
-## (1) Define subclass of ``ActionHelpBuilder`` class.
-class MyActionHelpBuilder < Benry::CmdApp::ActionHelpBuilder
-  def build_help_message(command, all=false)
+## (1) Create a module and override methods of ``ActionHelpBuilder`` class.
+module MyActionHelpBuilderMod
+  def build_help_message(metadata, all: false)
     super
   end
-  def build_preamble(command, all=false)
+  def section_preamble(metadata)
     super
   end
-  def build_usage(command, all=false)
+  def section_usage(metadata, all: false)
     super
   end
-  def build_options(command, all=false)
+  def section_description(metadata)
     super
   end
-  def build_postamble(command, all=false)
+  def section_options(metadata, all: false)
     super
   end
-  def heading(str)
+  def section_postamble(metadata)
     super
   end
 end
 
-## (2) Set it to ``ACTION_HELP_BUILDER_CLASS`` constant value.
-Benry::CmdApp.module_eval do
-  remove_const :ACTION_HELP_BUILDER_CLASS
-  const_set :ACTION_HELP_BUILDER_CLASS, MyActionHelpBuilder
-end
+## (2) Prepend it to ``Benry::CmdApp::ActionHelpBuilder`` class.
+Benry::CmdApp::ActionHelpBuilder.prepend(MyActionHelpBuilderMod)  # !!!!
 
-## (3) Create and execute Application object.
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+## (3) Run application.
+exit Benry::CmdApp::main("sample app")
+```
+
+
+### Customization of Section Title in Help Message
+
+If you want to change section titles such as 'Options:' or 'Actions:'
+in the help message, override the constants representing section titles.
+
+The following constants are defined in `BaseHelperBuilder` class.
+
+```ruby
+module Benry::CmdApp
+  class BaseHelpBuilder
+    HEADER_USAGE       = "Usage:"
+    HEADER_DESCRIPTION = "Description:"
+    HEADER_OPTIONS     = "Options:"
+    HEADER_ACTIONS     = "Actions:"
+    HEADER_ALIASES     = "Aliases:"
+    HEADER_ABBREVS     = "Abbreviations:"
+    HEADER_CATEGORIES  = "Categories:"
+```
+
+You can override them in `ApplicationHelpBuilder` or `ActionHelpBuilder`
+classes which are subclass of `BaseHandlerBuilder` class.
+
+```ruby
+## for example
+Benry::CmdApp::ApplicationHelpBuilder::HEADER_ACTIONS = "ACTIONS:"
+Benry::CmdApp::ActionHelpBuilder::HEADER_OPTIONS = "OPTIONS:"
+```
+
+If you want to change just decoration of section titles,
+set `config.deco_header`.
+
+```ruby
+config = Benry::CmdApp::Config.new("Test App", "1.0.0")
+config.deco_header = "\e[1;34m%s\e[0m"     # bold, blue
+#config.deco_header = "\e[1;4m%s\e[0m"     # bold, underline
 ```
 
 
@@ -1945,11 +2805,25 @@ exit app.main()
 ## Q & A
 
 
-### Q: How to Append Some Tasks to Existing Action?
+### Q: How to show all backtraces of exception?
+
+A: Add `--deubg` option.
+Benry-CmdApp catches exceptions and handles their backtrace
+automatically in default, but doesn't catch them when `--debug`
+option is specified.
+
+
+### Q: How to specify description to arguments of actions?
+
+A: Can't. It is possible to specify description to actions or options,
+but not possible to arguments of actions.
+
+
+### Q: How to append some tasks to an existing action?
 
 A: (a) Use method alias, or (b) use prepend.
 
-File: ex41.rb
+File: ex61.rb
 
 ```ruby
 require 'benry/cmdapp'
@@ -1970,7 +2844,7 @@ end
 
 ## (a) use method alias
 class SampleAction               # open existing class
-  alias __old_hello hello        # alias of existing method
+  alias __old_hello hello        # alias for existing method
   def hello(user="world")        # override existing method
     puts "---- >8 ---- >8 ----"
     __old_hello(user)            # call original method
@@ -1988,31 +2862,34 @@ module SampleMod                 # define new module
 end
 SampleAction.prepend(SampleMod)  # prepend it to existing class
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex41.rb hello
+[bash]$ ruby ex61.rb hello
 ---- >8 ---- >8 ----
 Hello, world!
 ---- 8< ---- 8< ----
 
-[bash]$ ruby ex41.rb hi Alice
+[bash]$ ruby ex61.rb hi Alice
 ~~~~ >8 ~~~~ >8 ~~~~
 Hi, Alice!
 ~~~~ 8< ~~~~ 8< ~~~~
 ```
 
 
-### Q: How to Re-define Existing Action?
+### Q: How to delete an existing action/alias?
 
-A: Remove existing action at first, and re-define action.
+A: Call `Benry::CmdApp.undef_action("<action>")` or `Benry::CmdApp.undef_alias("<alias>")`.
 
-File: ex42.rb
+
+### Q: How to re-define an existing action?
+
+A: First remove the existing action, then re-define the action.
+
+File: ex62.rb
 
 ```ruby
 require 'benry/cmdapp'
@@ -2026,7 +2903,7 @@ class SampleAction < Benry::CmdApp::Action
 
 end
 
-Benry::CmdApp.delete_action("hello")        # !!!!
+Benry::CmdApp.undef_action("hello")        # !!!!
 
 class OtherAction < Benry::CmdApp::Action
 
@@ -2037,38 +2914,34 @@ class OtherAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex42.rb -h
-ex42.rb -- sample app
+[bash]$ ruby ex62.rb -h
+ex62.rb --- sample app
 
 Usage:
-  $ ex42.rb [<options>] [<action> [<arguments>...]]
+  $ ex62.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
 
 Actions:
   hello              : other action       # !!!!
+  help               : print help message (of action if specified)
 ```
 
 
-### Q: How to Delete Existing Action/Alias?
-
-A: Call `Benry::CmdApp.delete_action("<action>")` or `Benry::CmdApp.delete_alias("<alias>")`.
-
-
-### Q: How to Show Entering Into or Exitting From Action?
+### Q: How to show entering into or exitting from actions?
 
 A: Set `config.option_trace = true` and pass `-T` (or `--trace`) option.
 
-File: ex43.rb
+File: ex63.rb
 
 ```ruby
 require 'benry/cmdapp'
@@ -2082,82 +2955,81 @@ class SampleAction < Benry::CmdApp::Action
 
   @action.("build")
   def build()
-    run_action_once("prepare")
+    run_once("prepare")
     puts "... build something ..."
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-config.option_trace = true                          # !!!!
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app", "1.0.0",
+     			option_trace: true)    # !!!! (or `:hidden`)
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex43.rb -T build           # !!!!
-## enter: build
-## enter: prepare
+[bash]$ ruby ex63.rb --trace build              # !!!!
+### enter: build
+### enter: prepare
 ... prepare something ...
-## exit:  prepare
+### exit:  prepare
 ... build something ...
-## exit:  build
+### exit:  build
 ```
 
 
-### Q: How to Enable/Disable Color Mode?
+### Q: How to enable/disable color mode?
 
 A: Set `config.option_color = true` and pass `--color=on` or `--color=off` option.
 
-File: ex44.rb
+File: ex64.rb
 
 ```ruby
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("greeting message")
+  @action.("print greeting message")
   def hello(user="world")
     puts "Hello, #{user}!"
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-config.option_color = true                       # !!!!
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app",
+                        option_color: true)         # !!!!
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex44.rb -h
-ex44.rb -- sample app
+[bash]$ ruby ex64.rb -h
+ex64.rb --- sample app
 
 Usage:
-  $ ex44.rb [<options>] [<action> [<arguments>...]]
+  $ ex64.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -a, --all          : list hidden actions/options, too
   --color[=<on|off>] : enable/disable color      # !!!!
 
 Actions:
-  hello              : greeting message
+  hello              : print greeting message
 
-[bash]$ ruby ex44.rb -h --color=off              # !!!!
+[bash]$ ruby ex64.rb -h --color=off              # !!!!
 
-[bash]$ ruby ex44.rb -h --color=on               # !!!!
+[bash]$ ruby ex64.rb -h --color=on               # !!!!
+[bash]$ ruby ex64.rb -h --color                  # !!!!
 ```
 
 
-### Q: How to Define Multiple Option, like `-I` Option of Ruby?
+### Q: How to define a multiple option, like `-I` option of Ruby?
 
 A: Provide block parameter on `@option.()`.
 
-File: ex45.rb
+File: ex65.rb
 
 ```ruby
 require 'benry/cmdapp'
@@ -2172,30 +3044,33 @@ class TestAction < Benry::CmdApp::Action
     ## or:                                                   # !!!!
     #(options[key] || []) << val                             # !!!!
   }                                                          # !!!!
-  def test(path: [])
+  def test_(path: [])
     puts "path=#{path.inspect}"     #=> path=["/tmp", "/var/tmp"]
   end
 
 end
 
-config = Benry::CmdApp::Config.new("test app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("test app")
 ```
 
 Output:
 
 ```console
-[bash]$ ruby ex45.rb test -I /tmp -I /var/tmp     # !!!!
+[bash]$ ruby ex65.rb test -I /tmp -I /var/tmp     # !!!!
 path=["/tmp", "/var/tmp"]                         # !!!!
 ```
 
 
-### Q: How to Specify Detailed Description of Option?
+### Q: How to show global option `-L <topic>` in help message?
+
+A: Set `config.option_topic = true` (default: `:hidden`).
+
+
+### Q: How to specify detailed description of options?
 
 A: Add `detail:` keyword argument to `@option.()`.
 
-File: ex46.rb
+File: ex66.rb
 
 ```ruby
 require 'benry/cmdapp'
@@ -2204,99 +3079,48 @@ class TestAction < Benry::CmdApp::Action
 
   @action.("detailed description test")
   @option.(:mode, "-m <mode>", "output mode", detail: <<"END")
-    v, verbose: print many output
-    q, quiet:   print litte output
-    c, compact: print summary output
+   v, verbose: print many output
+   q, quiet:   print litte output
+   c, compact: print summary output
 END
-  def test(mode: nil)
+  def test_(mode: nil)
     puts "mode=#{mode.inspect}"
   end
 
 end
 
-config = Benry::CmdApp::Config.new("test app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("test app")
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex46.rb -h test
-ex46.rb test -- detailed description test
+[bash]$ ruby ex66.rb -h test
+ex66.rb test --- detailed description test
 
 Usage:
-  $ ex46.rb test [<options>]
+  $ ex66.rb test [<options>]
 
 Options:
   -m <mode>          : output mode
-                           v, verbose: print many output
-                           q, quiet:   print litte output
-                           c, compact: print summary output
-```
-
-
-### Q: How to Copy All Options from Other Action?
-
-A: Use `@copy_options.()`.
-
-File: ex47.rb
-
-```ruby
-require 'benry/cmdapp'
-
-class SampleAction < Benry::CmdApp::Action
-
-  @action.("test action #1")
-  @option.(:verbose, "-v, --verbose", "verbose mode")
-  @option.(:file, "-f, --file=<file>", "filename")
-  @option.(:indent, "-i, --indent[=<N>]", "indent")
-  def test1(verbose: false, file: nil, indent: nil)
-    puts "verbose=#{verbose}, file=#{file}, indent=#{indent}"
-  end
-
-  @action.("test action #2")
-  @copy_options.("test1")         # !!!! copy options from test1 !!!!
-  @option.(:debug, "-D, --debug", "debug mode")
-  def test2(verbose: false, file: nil, indent: nil, debug: false)
-    puts "verbose=#{verbose}, file=#{file}, indent=#{indent}, debug=#{debug}"
-  end
-
-end
-
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
-```
-
-Help message of `test2` action:
-
-```console
-[bash]$ ruby ex47.rb -h test2
-ex47.rb test2 -- test action #2
-
-Usage:
-  $ ex47.rb test2 [<options>]
-
-Options:
-  -v, --verbose      : verbose mode     # copied!!
-  -f, --file=<file>  : filename         # copied!!
-  -i, --indent[=<N>] : indent           # copied!!
-  -D, --debug        : debug mode
+                          v, verbose: print many output
+                          q, quiet:   print litte output
+                          c, compact: print summary output
 ```
 
 
-### Q: What is the Difference Between `prefix(alias_of:)` and `prefix(action:)`?
+<!--
+### Q: What is the difference between `category(alias_for:)` and `category(action:)`?
 
 A: The former defines an alias, and the latter doesn't.
 
-File: ex48.rb
+File: ex67.rb
 
 ```ruby
 require 'benry/cmdapp'
 
 class AaaAction < Benry::CmdApp::Action
-  prefix "aaa", alias_of: :print_        # (or) alias_of: "print"
+  category "aaa:", alias_for: "print"
 
   @action.("test #1")
   def print_()
@@ -2306,7 +3130,7 @@ class AaaAction < Benry::CmdApp::Action
 end
 
 class BbbAction < Benry::CmdApp::Action
-  prefix "bbb", action: :print_         # (or) action: "print"
+  category "bbb:", action: "print"
 
   @action.("test #2")
   def print_()
@@ -2315,156 +3139,173 @@ class BbbAction < Benry::CmdApp::Action
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
+exit Benry::CmdApp.main("sample app")
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex48.rb
-ex48.rb -- sample app
+[bash]$ ruby ex67.rb -h
+ex67.rb --- sample app
 
 Usage:
-  $ ex48.rb [<options>] [<action> [<arguments>...]]
+  $ ex67.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -h, --help         : print help message (of action if action specified)
+  -h, --help         : print help message (of action if specified)
+  -l, --list         : list actions and aliases
+  -L <topic>         : topic list (actions|aliases|categories|abbrevs)
+  -a, --all          : list hidden actions/options, too
 
 Actions:
-  aaa                : alias of 'aaa:print' action    # !!!!
+  aaa                : alias for 'aaa:print' action   # !!!!
   aaa:print          : test #1
   bbb                : test #2                        # !!!!
+  help               : print help message (of action if specified)
 ```
 
-In the above example, alias `aaa` is defined due to `prefix(alias_of:)`,
-and action `bbb` is not an alias due to `prefix(action:)`.
+In the above example, alias `aaa` is defined due to `category(alias_for:)`,
+and action `bbb` is not an alias due to `category(action:)`.
+-->
 
 
-### Q: How to Change Order of Options in Help Message?
+### Q: How to list only aliases (or actions) excluding actions (or aliases) ?
 
-A: Call `AppOptionSchema#sort_options_in_this_order()`.
+A: Specify global option `-L alias` or `-L action`.
+
+```console
+[bash]$ ruby gitexample.rb -l
+Actions:
+  git                : alias for 'git:status'
+  git:stage          : put changes of files into staging area
+  git:staged         : show changes in staging area
+  git:status         : show status in compact format
+  git:unstage        : remove changes from staging area
+  stage              : alias for 'git:stage'
+  staged             : alias for 'git:staged'
+  unstage            : alias for 'git:unstage'
+
+### list only aliases (ordered by action name automatically)
+[bash]$ ruby gitexample.rb -L alias     # !!!!
+Aliases:
+  stage              : alias for 'git:stage'
+  staged             : alias for 'git:staged'
+  git                : alias for 'git:status'
+  unstage            : alias for 'git:unstage'
+
+### list only actions
+[bash]$ ruby gitexample.rb -L action     # !!!!
+Actions:
+  git:stage          : put changes of files into staging area
+  git:staged         : show changes in staging area
+  git:status         : show status in compact format
+  git:unstage        : remove changes from staging area
+```
+
+Notice that `-L alias` sorts aliases by action names.
+This is the intended behaviour.
 
-File: ex49.rb
+
+### Q: How to change the order of options in help message?
+
+A: Call `GlobalOptionSchema#reorder_options()`.
+
+File: ex68.rb
 
 ```ruby
 require 'benry/cmdapp'
 
 config = Benry::CmdApp::Config.new("sample app", "1.0.0",
-  option_all:       true,
+  option_verbose:   true,
   option_quiet:     true,
   option_color:     true,
 )
-schema = Benry::CmdApp::AppOptionSchema.new(config)
-keys = [:all, :quiet, :color, :help, :version]         # !!!!
-schema.sort_options_in_this_order(*keys)               # !!!!
+schema = Benry::CmdApp::GlobalOptionSchema.new(config)
+keys = [:verbose, :quiet, :color, :help, :version, :all, :target, :list]  # !!!!
+schema.reorder_options(*keys)               # !!!!
 app = Benry::CmdApp::Application.new(config, schema)
 ## or:
 #app = Benry::CmdApp::Application.new(config)
-#app.schema.sort_options_in_this_order(*keys)          # !!!!
+#app.schema.reorder_options(*keys)          # !!!!
 exit app.main()
 ```
 
 Help message:
 
 ```console
-[bash]$ ruby ex49.rb -h
-ex49.rb (1.0.0) -- sample app
+[bash]$ ruby ex68.rb -h
+ex68.rb (1.0.0) --- sample app
 
 Usage:
-  $ ex49.rb [<options>] [<action> [<arguments>...]]
+  $ ex68.rb [<options>] <action> [<arguments>...]
 
 Options:
-  -a, --all          : list all actions/options including private (hidden) ones
+  -v, --verbose      : verbose mode
   -q, --quiet        : quiet mode
-  --color[=<on|off>] : enable/disable color
-  -h, --help         : print help message (of action if action specified)
+  --color[=<on|off>] : color mode
+  -h, --help         : print help message (of action if specified)
   -V, --version      : print version
+  -a, --all          : list hidden actions/options, too
+  -L <topic>         : topic list (actions|aliases|categories|abbrevs)
+  -l, --list         : list actions and aliases
 
 Actions:
-
+  help               : print help message (of action if specified)
 ```
 
 
-### Q: Is It Possible to Make Action Names Emphasised or Weaken?
+### Q: How to add metadata to actions or options?
 
-A: Yes. When you pass `important: true` to `@action.()`, that action will be printed with unerline in help message. When you pass `important: false`, that action will be printed in gray color.
+A: Pass `tag:` keyword argument to `@action.()` or `@option.()`.
 
-File: ex50.rb
+* `tag:` keyword argument accept any type of value such as symbol, string, array, and so on.
+* Currenty, Benry-CmdApp doesn't provide the good way to use it effectively.
+  This feature may be used by command-line application or framework based on Benry-CmdApp.
+
+File: ex69.rb
 
 ```ruby
 require 'benry/cmdapp'
 
 class SampleAction < Benry::CmdApp::Action
 
-  @action.("empasized", important: true)   # !!!!
-  def test1()
-  end
-
-  @action.("weaken", important: false)   # !!!!
-  def test2()
+  @action.("print greeting message", tag: :important)            # !!!!
+  @option.(:repeat, "-r <N>", "repeat N times", tag: :important) # !!!!
+  def hello(user="world", repeat: nil)
+    (repeat || 1).times do
+      puts "Hello, #{user}!"
+    end
   end
 
 end
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
-```
-
-Help message:
-
-```console
-[bash]$ ruby ex50.rb -h
-ex50.rb -- sample app
-
-Usage:
-  $ ex50.rb [<options>] [<action> [<arguments>...]]
-
-Options:
-  -h, --help         : print help message (of action if action specified)
-
-Actions:
-  test1              : empasized     # !!!! printed with underline !!!!
-  test2              : weaken        # !!!! printed in gray color !!!!
+exit Benry::CmdApp.main("sample app")
 ```
 
 
-### Q: Is It Possible to Add Metadata to Action or Option?
-
-A: Yes. Pass `tag:` keyword argument to `@action.()` or `@option.()`.
+### Q: How to remove common help option from all actions?
 
-* `tag:` keyword argument accept any type of value such as symbol, string, array, and so on.
-* Currenty, Benry::CmdApp doesn't provide the good way to use it effectively.
-  This feature may be used by command-line application or framework based on Benry::CmdApp.
+A: Clears `Benry::CmdApp::ACTION_SHARED_OPTIONS` which is an array of option item.
 
-File: ex51.rb
+File: ex70.rb
 
 ```ruby
 require 'benry/cmdapp'
 
-class SampleAction < Benry::CmdApp::Action
+arr = Benry::CmdApp::ACTION_SHARED_OPTIONS
+arr.clear()
+```
 
-  @action.("print greeting message", tag: :important)            # !!!!
-  @option.(:repeat, "-r <N>", "repeat N times", tag: :important) # !!!!
-  def hello(user="world", repeat: nil)
-    (repeat || 1).times do
-      puts "Hello, #{user}!"
-    end
-  end
 
-end
+### Q: Is it possible to show details of actions and aliases?
 
-config = Benry::CmdApp::Config.new("sample app")
-app = Benry::CmdApp::Application.new(config)
-exit app.main()
-```
+A: Try global option `-L metadata`.
+It prints detailed data of actions and aliases in YAML format.
 
 
-### Q: How to Make Error Messages I18Ned?
+### Q: How to make error messages I18Ned?
 
-A: Currently not supported. May be supported in the future release.
+A: Currently not supported. May be supported in a future release.