benry-cmdapp 0.2.0 → 1.0.0

data/test/app_test.rb

@@ -1,1365 +1,1169 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'oktest'
 
-require 'benry/cmdapp'
-require_relative './shared'
+require_relative 'shared'
 
 
 Oktest.scope do
 
 
+  topic Benry::CmdApp::Application do
 
-  topic Benry::CmdApp::Config do
+    before do
+      @config = Benry::CmdApp::Config.new("test app", "1.2.3", app_command: "testapp")
+      @app = Benry::CmdApp::Application.new(@config)
+    end
 
 
-    topic '#initialize()' do
+    topic '#main()' do
 
-      spec "[!uve4e] sets command name automatically if not provided." do
-        config = Benry::CmdApp::Config.new("test")
-        ok {config.app_command} != nil
-        ok {config.app_command} == File.basename($0)
+      spec "[!65e9n] returns `0` as status code." do
+        ret = nil
+        capture_sio { ret = @app.main(["help"]) }
+        ok {ret} == 0
       end
 
-    end
-
+      case_when "[!bkbb4] when error raised..." do
 
-  end
+        spec "[!k4qov] not catch error if debug mode is enabled." do
+          debug_mode = $DEBUG_MODE
+          at_end { $DEBUG_MODE = debug_mode }
+          pr = proc { @app.main(["--debug", "foobar"]) }
+          ok {pr}.raise?(Benry::CmdApp::CommandError, "foobar: Action not found.")
+        end
 
+        spec "[!lhlff] catches error if BaseError raised or `should_rescue?()` returns true." do
+          pr = proc { @app.main(["testerr1"]) }
+          ok {pr}.raise?(ZeroDivisionError)
+          #
+          r = recorder()
+          r.fake_method(@app, :should_rescue? => true)
+          sout, serr = capture_sio(tty: true) do
+            pr = proc { @app.main(["testerr1"]) }
+            ok {pr}.NOT.raise?(ZeroDivisionError)
+          end
+          ok {sout} == ""
+          ok {serr} =~ /\A\e\[31m\[ERROR\]\e\[0m divided by 0$/
+        end
 
-  topic Benry::CmdApp::AppOptionSchema do
+        spec "[!35x5p] prints error into stderr." do
+          sout, serr = capture_sio(tty: true) { @app.main(["foobar"]) }
+          ok {sout} == ""
+          ok {serr} =~ /^\e\[31m\[ERROR\]\e\[0m foobar: Action not found.\n/
+        end
 
+        spec "[!z39bh] prints backtrace unless error is a CommandError." do
+          sout, serr = capture_sio { @app.main(["testerr2"]) }
+          ok {sout} == ""
+          ok {serr} =~ /^\[ERROR\] testerr2: Looped action detected.\n/
+          ok {serr} =~ /^    From .*:\d+:in /
+        end
 
-    topic '#initialize()' do
+        spec "[!dzept] returns `1` as status code." do
+          ret = nil
+          capture_sio { ret = @app.main(["help", "foo"]) }
+          ok {ret} == 1
+        end
 
-      def new_gschema(desc="", version=nil, **kwargs)
-        config = Benry::CmdApp::Config.new(desc, version, **kwargs)
-        x = Benry::CmdApp::AppOptionSchema.new(config)
-        return x
       end
 
-      spec "[!3ihzx] do nothing when config is nil." do
-        x = nil
-        pr = proc { x = Benry::CmdApp::AppOptionSchema.new(nil) }
-        ok {pr}.NOT.raise?(Exception)
-        ok {x}.is_a?(Benry::CmdApp::AppOptionSchema)
-      end
+    end
 
-      spec "[!tq2ol] adds '-h, --help' option if 'config.option_help' is set." do
-        x = new_gschema(option_help: true)
-        ok {x.find_long_option("help")} != nil
-        ok {x.find_short_option("h")}   != nil
-        x = new_gschema(option_help: false)
-        ok {x.find_long_option("help")} == nil
-        ok {x.find_short_option("h")}   == nil
-      end
 
-      spec "[!mbtw0] adds '-V, --version' option if 'config.app_version' is set." do
-        x = new_gschema("", "0.0.0")
-        ok {x.find_long_option("version")} != nil
-        ok {x.find_short_option("V")}      != nil
-        x = new_gschema("", nil)
-        ok {x.find_long_option("version")} == nil
-        ok {x.find_short_option("V")}      == nil
-      end
+    topic '#run()' do
 
-      spec "[!f5do6] adds '-a, --all' option if 'config.option_all' is set." do
-        x = new_gschema(option_all: true)
-        ok {x.find_long_option("all")} != nil
-        ok {x.find_short_option("a")}  != nil
-        x = new_gschema(option_all: false)
-        ok {x.find_long_option("all")} == nil
-        ok {x.find_short_option("a")}  == nil
+      spec "[!etbbc] calls setup method at beginning of this method." do
+        r = recorder()
+        r.record_method(@app, :setup)
+        capture_sio { @app.run("help") }
+        ok {r[0].name} == :setup
+        ok {r[0].args} == []
       end
 
-      spec "[!cracf] adds '-v, --verbose' option if 'config.option_verbose' is set." do
-        x = new_gschema(option_verbose: true)
-        ok {x.find_long_option("verbose")} != nil
-        ok {x.find_short_option("v")}  != nil
-        x = new_gschema(option_verbose: false)
-        ok {x.find_long_option("verbose")} == nil
-        ok {x.find_short_option("v")}  == nil
+      spec "[!hguvb] handles global options." do
+        sout, serr = capture_sio { @app.run("--version") }
+        ok {sout} == "1.2.3\n"
+        ok {serr} == ""
+        sout, serr = capture_sio { @app.run("--help") }
+        ok {sout} =~ /^Usage:\n/
+        ok {serr} == ""
       end
 
-      spec "[!2vil6] adds '-q, --quiet' option if 'config.option_quiet' is set." do
-        x = new_gschema(option_quiet: true)
-        ok {x.find_long_option("quiet")} != nil
-        ok {x.find_short_option("q")}  != nil
-        x = new_gschema(option_quiet: false)
-        ok {x.find_long_option("quiet")} == nil
-        ok {x.find_short_option("q")}  == nil
+      spec "[!pf1d2] calls teardown method at end of this method." do
+        r = recorder()
+        r.record_method(@app, :teardown)
+        capture_sio { @app.run("hello", "Alice") }
+        ok {r.length} == 1
+        ok {r[0].name} == :teardown
+        ok {r[0].args} == []
+        #
+        begin
+          capture_sio { @app.run("testerr1") }
+        rescue ZeroDivisionError
+          nil
+        end
+        ok {r.length} == 2
+        ok {r[0].name} == :teardown
+        ok {r[0].args} == []
       end
 
-      spec "[!6zw3j] adds '--color=<on|off>' option if 'config.option_color' is set." do
-        x = new_gschema(option_color: true)
-        ok {x.find_long_option("color")} != nil
-        x = new_gschema(option_quiet: false)
-        ok {x.find_long_option("color")} == nil
-      end
+    end
 
-      spec "[!29wfy] adds '-D, --debug' option if 'config.option_debug' is set." do
-        x = new_gschema(option_debug: true)
-        ok {x.find_long_option("debug")} != nil
-        ok {x.find_short_option("D")}    != nil
-        x = new_gschema(option_debug: false)
-        ok {x.find_long_option("debug")} == nil
-        ok {x.find_short_option("D")}    == nil
-      end
 
-      spec "[!s97go] adds '-T, --trace' option if 'config.option_trace' is set." do
-        x = new_gschema(option_trace: true)
-        ok {x.find_long_option("trace")} != nil
-        ok {x.find_short_option("T")}    != nil
-        x = new_gschema(option_debug: false)
-        ok {x.find_long_option("trace")} == nil
-        ok {x.find_short_option("T")}    == nil
-      end
+    topic '#handle_action()' do
 
-    end
+      case_when "[!3qw3p] when no arguments specified..." do
 
+        spec "[!zl9em] lists actions if default action is not set." do
+          sout, serr = capture_sio { @app.run() }
+          ok {sout} =~ /\AActions:\n/
+          ok {sout} =~ /^  hello +: greeting message$/
+          ok {serr} == ""
+        end
 
-    topic '#sort_options_in_this_order()' do
+        spec "[!89hqb] lists all actions including hidden ones if `-a` or `--all` specified." do
+          sout, serr = capture_sio { @app.run() }
+          ok {sout} !~ /^  debuginfo/
+          sout, serr = capture_sio { @app.run("-a") }
+          ok {sout} =~ /^  debuginfo +: hidden action$/
+        end
 
-      def new_gschema(desc="app test", version="1.0.0")
-        config = Benry::CmdApp::Config.new(desc, version)
-        config.option_all = true
-        config.option_verbose = true
-        config.option_quiet = true
-        config.option_debug = true
-        return Benry::CmdApp::AppOptionSchema.new(config)
-      end
+        spec "[!k4xxp] runs default action if it is set." do
+          @config.default_action = "hello"
+          sout, serr = capture_sio { @app.run() }
+          ok {sout} !~ /^\AActions:/
+          ok {sout} == "Hello, world!\n"
+        end
 
-      spec "[!6udxr] sorts options in order of keys specified." do
-        x = new_gschema()
-        keys1 = x.each.collect(&:key)
-        ok {keys1} == [:help, :version, :all, :verbose, :quiet, :debug]
-        x.sort_options_in_this_order(:help, :quiet, :verbose, :all, :trace, :debug, :version)
-        keys2 = x.each.collect(&:key)
-        ok {keys2} == [:help, :quiet, :verbose, :all, :debug, :version]
       end
 
-      spec "[!8hhuf] options which key doesn't appear in keys are moved at end of options." do
-        x = new_gschema()
-        x.sort_options_in_this_order(:quiet, :verbose, :all, :debug)  # missing :help and :version
-        keys = x.each.collect(&:key)
-        ok {keys[-2]} == :help
-        ok {keys[-1]} == :version
-        ok {keys} == [:quiet, :verbose, :all, :debug, :help, :version]
-      end
+      case_when "[!xaamy] when prefix specified..." do
 
-    end
+        spec "[!7l3fh] lists actions starting with prefix." do
+          sout, serr = capture_sio { @app.run("git:") }
+          ok {sout} == <<END
+Actions:
+  git:stage          : same as `git add -p`
+  git:staged         : same as `git diff --cached`
+  git:unstage        : same as `git reset HEAD`
+END
+        end
 
+        spec "[!g0k1g] lists all actions including hidden ones if `-a` or `--all` specified." do
+          sout, serr = capture_sio { @app.run("-a", "git:") }
+          ok {sout} == <<END
+Actions:
+  git:correct        : same as `git commit --amend`
+  git:stage          : same as `git add -p`
+  git:staged         : same as `git diff --cached`
+  git:unstage        : same as `git reset HEAD`
+END
+        end
 
-  end
+      end
 
+      case_when "[!vphz3] else..." do
 
-  topic Benry::CmdApp::Application do
-    include CommonTestingHelper
-
-    class AppTest < Benry::CmdApp::ActionScope
-      @action.("print greeting message")
-      @option.(:lang, "-l, --lang=<en|fr|it>", "language")
-      def sayhello(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."
+        spec "[!bq39a] runs action with arguments." do
+          sout, serr = capture_sio { @app.run("hello", "Alice") }
+          ok {sout} == "Hello, Alice!\n"
+        end
+
+        spec "[!5yd8x] returns 0 when action invoked successfully." do
+          ret = nil
+          capture_sio { ret = @app.run("hello", "Alice") }
+          ok {ret} == 0
         end
+
       end
-    end
 
-    before do
-      @config = Benry::CmdApp::Config.new("test app", "1.0.0",
-                                          app_name: "TestApp", app_command: "testapp",
-                                          default_action: nil,
-                                          option_all: true, option_debug: true)
-      @app = Benry::CmdApp::Application.new(@config)
     end
 
-    def _run_app(*args)
-      sout, serr = capture_sio { @app.run(*args) }
-      ok {serr} == ""
-      return sout
-    end
 
+    topic '#render_help_message()' do
 
-    topic '#initialize()' do
+      spec "[!2oax5] returns action help message if action name is specified." do
+        ret = @app.render_help_message("hello")
+        ok {ret} == <<"END"
+\e[1mtestapp hello\e[0m --- greeting message
 
-      spec "[!jkprn] creates option schema object according to config." do
-        c = Benry::CmdApp::Config.new("test", "1.0.0", option_debug: true)
-        app = Benry::CmdApp::Application.new(c)
-        schema = app.instance_variable_get('@schema')
-        ok {schema}.is_a?(Benry::CmdOpt::Schema)
-        items = schema.each.to_a()
-        ok {items[0].key} == :help
-        ok {items[1].key} == :version
-        ok {items[2].key} == :debug
-        ok {schema.option_help()} == <<END
-  -h, --help     : print help message
-  -V, --version  : print version
-  -D, --debug    : debug mode (set $DEBUG_MODE to true)
+\e[1;34mUsage:\e[0m
+  $ \e[1mtestapp hello\e[0m [<options>] [<name>]
+
+\e[1;34mOptions:\e[0m
+  -l, --lang=<lang>  : language name (en/fr/it)
 END
       end
 
-      spec "[!h786g] acceps callback block." do
-        config = Benry::CmdApp::Config.new("test app")
-        n = 0
-        app = Benry::CmdApp::Application.new(config) do |args|
-          n += 1
-        end
-        ok {app.callback}.is_a?(Proc)
-        ok {n} == 0
-        app.callback.call([])
-        ok {n} == 1
-        app.callback.call([])
-        ok {n} == 2
+      spec "[!d6veb] returns application help message if action name is not specified." do
+        ret = @app.render_help_message(nil)
+        ok {ret} =~ /^\e\[1;34mUsage:\e\[0m$/
+        ok {ret} =~ /^\e\[1;34mOptions:\e\[0m$/
+        ok {ret} =~ /^\e\[1;34mActions:\e\[0m$/
+      end
+
+      spec "[!tf2wp] includes hidden actions and options into help message if `all: true` passed." do
+        rexp1 = /^\e\[2m      --debug        : debug mode\e\[0m/
+        rexp2 = /^\e\[2m  debuginfo          : hidden action\e\[0m/
+        #
+        s = @app.render_help_message(nil, all: true)
+        ok {s} =~ rexp1
+        ok {s} =~ rexp2
+        #
+        s = @app.render_help_message(nil, all: false)
+        ok {s} !~ rexp1
+        ok {s} !~ rexp2
       end
 
     end
 
 
-    topic '#main()' do
+    topic '#setup()' do
 
-      after do
-        $cmdapp_config = nil
+      spec "[!6hi1y] stores current application." do
+        at_end { Benry::CmdApp._set_current_app(nil) }
+        ok {Benry::CmdApp.current_app()} == nil
+        @app.__send__(:setup)
+        ok {Benry::CmdApp.current_app()} == @app
       end
 
-      spec "[!y6q9z] runs action with options." do
-        sout, serr = capture_sio { @app.main(["sayhello", "-l", "it", "Alice"]) }
-        ok {serr} == ""
-        ok {sout} == "Ciao, Alice!\n"
-      end
+    end
 
-      spec "[!a7d4w] prints error message with '[ERROR]' prompt." do
-        sout, serr = capture_sio { @app.main(["sayhello", "Alice", "Bob"]) }
-        ok {serr} == "\e[0;31m[ERROR]\e[0m sayhello: Too much arguments (at most 1).\n"
-        ok {sout} == ""
-      end
 
-      spec "[!r7opi] prints filename and line number on where error raised if DefinitionError." do
-        class MainTest1 < Benry::CmdApp::ActionScope
-          prefix "main1"
-          @action.("test")
-          def err1
-            MainTest1.class_eval do
-              @action.("test")
-              @option.(:foo, "--foo", "foo")
-              def err2(bar: nil)   # should have keyword parameter 'foo'
-              end
-            end
-          end
-        end
-        lineno = __LINE__ - 5
-        sout, serr = capture_sio { @app.main(["main1:err1"]) }
-        ok {sout} == ""
-        serr = serr.sub(/file: \/.*?test\//, 'file: test/')
-        ok {serr} == <<"END"
-\e[0;31m[ERROR]\e[0m def err2(): Should have keyword parameter 'foo' for '@option.(:foo)', but not.
-\t\(file: test\/app_test\.rb, line: #{lineno})
-END
-      end
+    topic '#teardown()' do
 
-      spec "[!v0zrf] error location can be filtered by block." do
-        class MainTest2 < Benry::CmdApp::ActionScope
-          prefix "main2"
-          @action.("test")
-          def err2
-            _err2()
-          end
-          def _err2()
-            MainTest2.class_eval do  # == lineno2
-              @action.("test")
-              @option.(:foo, "--foo", "foo")
-              def err2x(bar: nil)    # == lineno1
-              end
-            end
-          end
-        end
-        lineno1 = __LINE__ - 5
-        lineno2 = lineno1 - 3
-        ## no filter
-        sout, serr = capture_sio { @app.main(["main2:err2"]) }
-        ok {sout} == ""
-        ok {serr} =~ /\t\(file: .*\/app_test\.rb, line: #{lineno1}\)\n/
-        ## filter by block
-        sout, serr = capture_sio {
-          @app.main(["main2:err2"]) {|exc| exc.lineno == lineno2 }
-        }
-        ok {sout} == ""
-        ok {serr} =~ /\t\(file: .*\/app_test\.rb, line: #{lineno2}\)\n/
+      spec "[!t44mv] removes current applicatin from data store." do
+        at_end { Benry::CmdApp._set_current_app(nil) }
+        ok {Benry::CmdApp.current_app()} == nil
+        @app.__send__(:setup)
+        ok {Benry::CmdApp.current_app()} == @app
       end
 
-      spec "[!6ro6n] not catch error when $DEBUG_MODE is on." do
-        bkup = $DEBUG_MODE
-        begin
-          pr = proc { @app.main(["-D", "sayhello", "Alice", "Bob"]) }
-          ok {pr}.raise?(Benry::CmdApp::CommandError,
-                         "sayhello: Too much arguments (at most 1).")
-        ensure
-          $DEBUG_MODE = bkup
-        end
-      end
+    end
 
-      spec "[!5oypr] returns 0 as exit code when no errors occurred." do
-        ret = nil
-        sout, serr = capture_sio do
-          ret = @app.main(["sayhello", "Alice", "-l", "it"])
-        end
-        ok {ret} == 0
-        ok {serr} == ""
-        ok {sout} == "Ciao, Alice!\n"
-      end
 
-      spec "[!qk5q5] returns 1 as exit code when error occurred." do
-        ret = nil
-        sout, serr = capture_sio do
-          ret = @app.main(["sayhello", "Alice", "Bob"])
-        end
-        ok {ret} == 1
-        ok {serr} == "\e[0;31m[ERROR]\e[0m sayhello: Too much arguments (at most 1).\n"
-        ok {sout} == ""
+    topic '#parse_global_options()' do
+
+      spec "[!9c9r8] parses global options." do
+        args = ["-hl", "foo"]
+        opts = @app.instance_eval { parse_global_options(args) }
+        ok {opts} == {help: true, list: true}
+        ok {args} == ["foo"]
       end
 
     end
 
 
-    topic '#run()' do
+    topic '#toggle_global_options()' do
 
-      class AppRunTest < Benry::CmdApp::ActionScope
-        #
-        @action.("test config")
-        def check_config()
-          puts "$cmdapp_config.class=#{$cmdapp_config.class.name}"
-        end
-        #
-        @action.("test global option parseing")
-        @option.(:help, "-h, --help", "print help")
-        def test_globalopt(help: false)
-          puts "help=#{help}"
-        end
-        #
-        @action.("test debug option")
-        def test_debugopt(help: false)
-          puts "$DEBUG_MODE=#{$DEBUG_MODE}"
-        end
-        #
-        @action.("arity test")
-        def test_arity1(xx, yy, zz=nil)
-        end
+      spec "[!xwcyl] sets `$VERBOSE_MODE` and `$QUIET_MODE` according to global options." do
+        at_end { $VERBOSE_MODE = nil; $QUIET_MODE = nil }
         #
-        @action.("arity test with variable args")
-        def test_arity2(xx, yy, zz=nil, *rest)
-        end
+        opts = {verbose: true}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {$VERBOSE_MODE} == true
+        ok {$QUIET_MODE} == false
         #
-        @action.("raises exception")
-        def test_exception1()
-          1/0
-        end
-        #
-        @action.("loop test")
-        def test_loop1()
-          run_action_once("test-loop2")
-        end
-        @action.("loop test")
-        def test_loop2()
-          run_action_once("test-loop1")
-        end
+        opts = {quiet: true}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {$VERBOSE_MODE} == false
+        ok {$QUIET_MODE} == true
       end
 
-      spec "[!t4ypg] sets $cmdapp_config at beginning." do
-        sout, serr = capture_sio { @app.run("check-config") }
-        ok {serr} == ""
-        ok {sout} == "$cmdapp_config.class=Benry::CmdApp::Config\n"
+      spec "[!sucqp] sets `$DEBUG_MODE` according to global options." do
+        at_end { $DEBUG_MODE = nil }
+        opts = {debug: true}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {$DEBUG_MODE} == true
       end
 
-      spec "[!pyotc] sets global options to '@global_options'." do
-        ok {@app.instance_variable_get('@global_options')} == nil
-        capture_sio { @app.run("--help") }
-        ok {@app.instance_variable_get('@global_options')} == {:help=>true}
+      spec "[!510eb] sets `$COLOR_MODE` according to global option." do
+        bkup = $COLOR_MODE
+        at_end { $COLOR_MODE = bkup }
+        $COLOR_MODE = nil
+        #
+        opts = {color: true}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {$COLOR_MODE} == true
+        #
+        opts = {color: false}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {$COLOR_MODE} == false
       end
 
-      spec "[!go9kk] sets global variables according to global options." do
-        config = Benry::CmdApp::Config.new("test app", "1.0.0",
-                                           option_verbose: true,
-                                           option_quiet: true,
-                                           option_debug: true,
-                                           option_color: true)
-        app = Benry::CmdApp::Application.new(config)
-        bkup = [$QUIET_MODE, $DEBUG_MODE, $COLOR_MODE]
-        begin
-          ['-v', '--verbose'].each do |x|
-            $QUIET_MODE, $DEBUG_MODE, $COLOR_MODE = nil, nil, nil
-            capture_sio { app.run(x, '-h') }
-            ok {[$QUIET_MODE, $DEBUG_MODE, $COLOR_MODE]} == [false, nil, nil]
-          end
-          #
-          ['-q', '--quiet'].each do |x|
-            $QUIET_MODE, $DEBUG_MODE, $COLOR_MODE = nil, nil, nil
-            capture_sio { app.run(x, '-h') }
-            ok {[$QUIET_MODE, $DEBUG_MODE, $COLOR_MODE]} == [true, nil, nil]
-          end
-          #
-          ['-D', '--debug'].each do |x|
-            $QUIET_MODE, $DEBUG_MODE, $COLOR_MODE = nil, nil, nil
-            capture_sio { app.run(x, '-h') }
-            ok {[$QUIET_MODE, $DEBUG_MODE, $COLOR_MODE]} == [nil, true, nil]
-          end
-          #
-          ['--color', '--color=on'].each do |x|
-            $QUIET_MODE, $DEBUG_MODE, $COLOR_MODE = nil, nil, nil
-            capture_sio { app.run(x, '-h') }
-            ok {[$QUIET_MODE, $DEBUG_MODE, $COLOR_MODE]} == [nil, nil, true]
-          end
-          ['--color=off'].each do |x|
-            $QUIET_MODE, $DEBUG_MODE, $COLOR_MODE = nil, nil, nil
-            capture_sio { app.run(x, '-h') }
-            ok {[$QUIET_MODE, $DEBUG_MODE, $COLOR_MODE]} == [nil, nil, false]
-          end
-        ensure
-          $QUIET_MODE, $DEBUG_MODE, $COLOR_MODE = bkup
-        end
+      spec "[!y9fow] sets `config.trace_mode` if global option specified." do
+        opts = {trace: true}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {@config.trace_mode} == true
+        #
+        opts = {trace: false}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {@config.trace_mode} == false
       end
 
-      spec "[!5iczl] skip actions if help option or version option specified." do
-        def @app.do_callback(args, global_opts)
-          @_called_ = args.dup
-        end
-        capture_sio { @app.run("--help") }
-        ok {@app.instance_variable_get('@_called_')} == nil
-        capture_sio { @app.run("--version") }
-        ok {@app.instance_variable_get('@_called_')} == nil
-        capture_sio { @app.run("sayhello") }
-        ok {@app.instance_variable_get('@_called_')} == ["sayhello"]
+      spec "[!dply7] sets `$DRYRUN_MODE` according to global option." do
+        ok {$DRYRUN_MODE} == nil
+        at_end { $DRYRUN_MODE = nil }
+        #
+        opts = {dryrun: true}
+        @app.instance_eval { toggle_global_options(opts) }
+        ok {$DRYRUN_MODE} == true
       end
 
-      spec "[!w584g] calls callback method." do
-        def @app.do_callback(args, global_opts)
-          @_called_ = args.dup
+    end
+
+
+    topic '#handle_global_options()' do
+
+      spec "[!366kv] prints help message if global option `-h, --help` specified." do
+        opts = {help: true}
+        sout, serr = capture_sio do
+          @app.instance_eval { handle_global_options(opts, []) }
         end
-        ok {@app.instance_variable_get('@_called_')} == nil
-        capture_sio { @app.run("sayhello") }
-        ok {@app.instance_variable_get('@_called_')} == ["sayhello"]
+        ok {sout} =~ /^Usage:/
+        ok {sout} =~ /^Options:/
+        ok {sout} =~ /^Actions:/
       end
 
-      spec "[!pbug7] skip actions if callback method throws `:SKIP`." do
-        def @app.do_callback(args, global_opts)
-          @_called1 = args.dup
-          throw :SKIP
-        end
-        def @app.do_find_action(args, global_opts)
-          super
-          @_called2 = args.dup
+      spec "[!7mapy] includes hidden actions into help message if `-a, --all` specified." do
+        rexp1 = /^      --debug        : debug mode$/
+        rexp2 = /^  debuginfo          : hidden action$/
+        #
+        opts = {help: true}
+        sout, serr = capture_sio do
+          @app.instance_eval { handle_global_options(opts, []) }
         end
-        ok {@app.instance_variable_get('@_called1')} == nil
-        ok {@app.instance_variable_get('@_called2')} == nil
-        capture_sio { @app.run("sayhello") }
-        ok {@app.instance_variable_get('@_called1')} == ["sayhello"]
-        ok {@app.instance_variable_get('@_called2')} == nil
-      end
-
-      spec "[!avxos] prints candidate actions if action name ends with ':'." do
-        class CandidateTest1 < Benry::CmdApp::ActionScope
-          prefix "candi:date1"
-          @action.("test")
-          def bbb(); end
-          @action.("test")
-          def aaa(); end
+        ok {sout} !~ rexp1
+        ok {sout} !~ rexp2
+        #
+        opts = {help: true, all: true}
+        sout, serr = capture_sio do
+          @app.instance_eval { handle_global_options(opts, []) }
         end
-        ## without tty
-        sout, serr = capture_sio(tty: false) { @app.run("candi:date1:") }
-        ok {serr} == ""
-        ok {sout} == <<"END"
-Actions:
-  candi:date1:aaa    : test
-  candi:date1:bbb    : test
-END
-        ## with tty
-        sout, serr = capture_sio(tty: true) { @app.run("candi:date1:") }
-        ok {serr} == ""
-        ok {sout} == <<"END"
-\e[34mActions:\e[0m
-  \e[1mcandi:date1:aaa   \e[0m : test
-  \e[1mcandi:date1:bbb   \e[0m : test
-END
+        ok {sout} =~ rexp1
+        ok {sout} =~ rexp2
       end
 
-      spec "[!eeh0y] candidates are not printed if 'config.feat_candidate' is false." do
-        class CandidateTest5 < Benry::CmdApp::ActionScope
-          prefix "candi:date5"
-          @action.("test b")
-          def bbb(); end
-          @action.("test a")
-          def aaa(); end
+      spec "[!dkjw8] prints version number if global option `-V, --version` specified." do
+        opts = {version: true}
+        sout, serr = capture_sio do
+          @app.instance_eval { handle_global_options(opts, []) }
         end
-        ## flag is on
-        @app.config.feat_candidate = false
-        pr = proc { @app.run("candi:date5:") }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "candi:date5:: Unknown action.")
-        ## flag is off
-        @app.config.feat_candidate = true
-        sout, serr = capture_sio(tty: false) { @app.run("candi:date5:") }
-        ok {serr} == ""
-        ok {sout} == <<"END"
-Actions:
-  candi:date5:aaa    : test a
-  candi:date5:bbb    : test b
-END
+        ok {sout} == "1.2.3\n"
       end
 
-      spec "[!l0g1l] skip actions if no action specified and 'config.default_help' is set." do
-        def @app.do_find_action(args, global_opts)
-          ret = super
-          @_args1 = args.dup
-          @_result = ret
-          ret
+      spec "[!hj4hf] prints action and alias list if global option `-l, --list` specified." do
+        opts = {list: true}
+        sout, serr = capture_sio(tty: true) do
+          @app.instance_eval { handle_global_options(opts, []) }
         end
-        def @app.do_run_action(metadata, args, global_opts)
-          ret = super
-          @_args2 = args.dup
-          ret
+        ok {sout} =~ /\A\e\[1;34mActions:\e\[0m$/
+        if Benry::CmdApp::REGISTRY.metadata_each.any? {|md| md.alias? }
+          ok {sout} =~ /\n\n\e\[1;34mAliases:\e\[0m$/
+        else
+          ok {sout} !~ /Aliases:/
         end
-        @app.config.default_help = true
-        capture_sio { @app.run() }
-        ok {@app.instance_variable_get('@_args1')} == []
-        ok {@app.instance_variable_get('@_result')} == nil
-        ok {@app.instance_variable_get('@_args2')} == nil
       end
 
-      spec "[!x1xgc] run action with options and arguments." do
-        sout, serr = capture_sio { @app.run("sayhello", "Alice", "-l", "it") }
-        ok {serr} == ""
-        ok {sout} == "Ciao, Alice!\n"
-      end
-
-      spec "[!agfdi] reports error when action not found." do
-        pr = proc { @app.run("xxx-yyy") }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "xxx-yyy: Unknown action.")
-      end
-
-      spec "[!v5k56] runs default action if action not specified." do
-        @config.default_action = "sayhello"
-        sout, serr = capture_sio { @app.run() }
-        ok {serr} == ""
-        ok {sout} == "Hello, world!\n"
-      end
-
-      spec "[!o5i3w] reports error when default action not found." do
-        @config.default_action = "xxx-zzz"
-        pr = proc { @app.run() }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "xxx-zzz: Unknown default action.")
-      end
-
-      spec "[!7h0ku] prints help if no action but 'config.default_help' is true." do
-        expected, serr = capture_sio { @app.run("-h") }
-        ok {serr} == ""
-        ok {expected} =~ /^Usage:/
+      spec "[!tyxwo] includes hidden actions into action list if `-a, --all` specified." do
+        rexp = /^  debuginfo +: hidden action$/
         #
-        @config.default_help = true
-        sout, serr = capture_sio { @app.run() }
-        ok {serr} == ""
-        ok {sout} == expected
+        opts = {list: true}
+        sout, serr = capture_sio do
+          @app.instance_eval { handle_global_options(opts, []) }
+        end
+        ok {sout} !~ rexp
+        #
+        opts = {list: true, all: true}
+        sout, serr = capture_sio do
+          @app.instance_eval { handle_global_options(opts, []) }
+        end
+        ok {sout} =~ rexp
       end
 
-      spec "[!n60o0] reports error when action nor default action not specified." do
-        @config.default_action = nil
-        pr = proc { @app.run() }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "testapp: Action name required (run `testapp -h` for details).")
+      spec "[!ooiaf] prints topic list if global option '-L <topic>' specified." do
+        Benry::CmdApp.define_alias('h0053', 'hello')
+        Benry::CmdApp.define_abbrev('g0053:', 'git:')
+        at_end {
+          Benry::CmdApp.undef_alias('h0053')
+          #Benry::CmdApp.undef_abbrev('g0053:')
+          Benry::CmdApp::REGISTRY.instance_eval { @abbrev_dict.delete('g0053:') }
+        }
+        #
+        chead = '\e\[1;34mCategories:\e\[0m'
+        data = [
+          [/\A\e\[1;34mActions:\e\[0m$/            , ["action" , "actions"  ]],
+          [/\A\e\[1;34mAliases:\e\[0m$/            , ["alias"  , "aliases"  ]],
+          [/\A\e\[1;34mAbbreviations:\e\[0m$/      , ["abbrev" , "abbrevs"  ]],
+          [/\A#{chead} \e\[2m\(depth=0\)\e\[0m$/, ["category" , "categories" ]],
+          [/\A#{chead} \e\[2m\(depth=1\)\e\[0m$/, ["category1", "categories1"]],
+          [/\A#{chead} \e\[2m\(depth=2\)\e\[0m$/, ["category2", "categories2"]],
+          [/\A#{chead} \e\[2m\(depth=3\)\e\[0m$/, ["category3", "categories3"]],
+        ]
+        data.each do |rexp, topics|
+          topics.each do |topic|
+            g_opts = {topic: topic}
+            sout, serr = capture_sio(tty: true) do
+              @app.instance_eval { handle_global_options(g_opts, []) }
+            end
+            ok {sout} =~ rexp
+          end
+        end
       end
 
-      spec "[!hk6iu] unsets $cmdapp_config at end." do
-        bkup = $cmdapp_config
-        $cmdapp_config = nil
-        begin
-          sout, serr = capture_sio { @app.run("check-config") }
-          ok {sout} == "$cmdapp_config.class=Benry::CmdApp::Config\n"
-          ok {$cmdapp_config} == nil
-        ensure
-          $cmdapp_config = bkup
+      spec "[!ymifi] includes hidden actions into topic list if `-a, --all` specified." do
+        g_opts = {topic: "action", all: true}
+        sout, serr = capture_sio do
+          @app.instance_eval { handle_global_options(g_opts, []) }
         end
+        ok {sout} =~ /\AActions:$/
+        ok {sout} =~ /^  debuginfo          : hidden action$/
       end
 
-      spec "[!wv22u] calls teardown method at end of running action." do
-        def @app.do_teardown(*args)
-          @_args = args
+      spec "[!k31ry] returns `0` if help or version or actions printed." do
+        keys = [:help, :version, :list]
+        keys.each do |key|
+          ret = nil
+          opts = {key => true}
+          capture_sio do
+            ret = @app.instance_eval { handle_global_options(opts, []) }
+          end
+          ok {ret} == 0
         end
-        ok {@app.instance_variable_get('@_args')} == nil
-        sout, serr = capture_sio { @app.run("check-config") }
-        ok {@app.instance_variable_get('@_args')} == [nil]
       end
 
-      spec "[!dhba4] calls teardown method even if exception raised." do
-        def @app.do_teardown(*args)
-          @_args = args
-        end
-        ok {@app.instance_variable_get('@_args')} == nil
-        pr = proc { @app.run("test-exception1") }
-        ok {pr}.raise?(ZeroDivisionError) do |exc|
-          ok {@app.instance_variable_get('@_args')} == [exc]
+      spec "[!9agnb] returns `nil` if do nothing." do
+        ret = nil
+        opts = {color: true, debug: true}
+        capture_sio do
+          ret = @app.instance_eval { handle_global_options(opts, []) }
         end
+        ok {ret} == nil
       end
 
     end
 
 
-    topic '#help_message()' do
+    topic '#render_action_help()' do
 
-      spec "[!owg9y] returns help message." do
-        msg = @app.help_message()
-        msg = uncolorize(msg)
-        ok {msg}.start_with?(<<END)
-TestApp (1.0.0) -- test app
+      spec "[!c510c] returns action help message." do
+        s = @app.instance_eval { render_action_help("hello") }
+        ok {s} == <<"END"
+\e[1mtestapp hello\e[0m --- greeting message
 
-Usage:
-  $ testapp [<options>] [<action> [<arguments>...]]
+\e[1;34mUsage:\e[0m
+  $ \e[1mtestapp hello\e[0m [<options>] [<name>]
 
-Options:
-  -h, --help         : print help message
-  -V, --version      : print version
-  -a, --all          : list all actions including private (hidden) ones
-  -D, --debug        : debug mode (set $DEBUG_MODE to true)
-
-Actions:
+\e[1;34mOptions:\e[0m
+  -l, --lang=<lang>  : language name (en/fr/it)
 END
       end
 
     end
 
 
-    topic '#do_create_global_option_schema()' do
-
-      spec "[!u3zdg] creates global option schema object according to config." do
-        config = Benry::CmdApp::Config.new("test app", "1.0.0",
-                                           option_all: true, option_quiet: true)
-        app = Benry::CmdApp::Application.new(config)
-        x = app.__send__(:do_create_global_option_schema, config)
-        ok {x}.is_a?(Benry::CmdApp::AppOptionSchema)
-        ok {x.find_long_option("all")}     != nil
-        ok {x.find_long_option("quiet")}   != nil
-        ok {x.find_long_option("verbose")} == nil
-        ok {x.find_long_option("debug")}   == nil
-      end
+    topic '#render_application_help()' do
 
-    end
+      spec "[!iyxxb] returns application help message." do
+        actual = @app.instance_eval { render_application_help() }
+        expected = <<"END"
+\e[1mtestapp\e[0m \e[2m(1.2.3)\e[0m --- test app
 
+\e[1;34mUsage:\e[0m
+  $ \e[1mtestapp\e[0m [<options>] <action> [<arguments>...]
 
-    topic '#do_create_help_message_builder()' do
+\e[1;34mOptions:\e[0m
+  -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
 
-      spec "[!pk5da] creates help message builder object." do
-        config = Benry::CmdApp::Config.new("test app", "1.0.0",
-                                           option_all: true, option_quiet: true)
-        app = Benry::CmdApp::Application.new(config)
-        x = app.__send__(:do_create_help_message_builder, config, app.schema)
-        ok {x}.is_a?(Benry::CmdApp::AppHelpBuilder)
+\e[1;34mActions:\e[0m
+END
+        ok {actual}.start_with?(expected)
+        ok {actual} =~ /^  hello              : greeting message$/
+        ok {actual} =~ /^  git:stage          : same as `git add -p`$/
       end
 
     end
 
 
-    topic '#do_parse_global_options()' do
-
-      spec "[!5br6t] parses only global options and not parse action options." do
-        sout, serr = capture_sio { @app.run("test-globalopt", "--help") }
-        ok {serr} == ""
-        ok {sout} == "help=true\n"
-      end
+    topic '#render_version()' do
 
-      spec "[!kklah] raises InvalidOptionError if global option value is invalid." do
-        pr = proc { @app.run("-hoge", "test-globalopt") }
-        ok {pr}.raise?(Benry::CmdApp::InvalidOptionError, "-o: Unknown option.")
+      spec "[!bcp2g] returns version number string." do
+        s = @app.instance_eval { render_version() }
+        ok {s} == "1.2.3\n"
       end
 
     end
 
 
-    topic '#do_toggle_global_switches()' do
+    topic '#render_item_list()' do
 
-      before do
-        @config = Benry::CmdApp::Config.new("test app", "1.0.0",
-                                            option_verbose: true,
-                                            option_quiet: true,
-                                            option_debug: true,
-                                            option_color: true,
-                                            option_trace: true)
-        @app = Benry::CmdApp::Application.new(@config)
+      class FakeAppHelpBuilder < Benry::CmdApp::ApplicationHelpBuilder
+        def section_availables(include=true, all: false); return nil; end
+        def section_candidates(prefix, all: false); return nil; end
+        def section_categories(depth=1, all: false); return nil; end
       end
 
-      spec "[!j6u5x] sets $QUIET_MODE to false if '-v' or '--verbose' specified." do
-        bkup = $QUIET_MODE
-        begin
-          ["-v", "--verbose"].each do |opt|
-            $QUIET_MODE = true
-            sout, serr = capture_sio { @app.run(opt, "test-debugopt") }
-            ok {serr} == ""
-            ok {$QUIET_MODE} == false
-          end
-        ensure
-          $QUIET_MODE = bkup
+      def fake_app_help_builder(&b)
+        Benry::CmdApp.module_eval do
+          remove_const :APPLICATION_HELP_BUILDER_CLASS
+          const_set    :APPLICATION_HELP_BUILDER_CLASS, FakeAppHelpBuilder
+        end
+        yield
+      ensure
+        Benry::CmdApp.module_eval do
+          remove_const :APPLICATION_HELP_BUILDER_CLASS
+          const_set    :APPLICATION_HELP_BUILDER_CLASS, Benry::CmdApp::ApplicationHelpBuilder
         end
       end
 
-      spec "[!p1l1i] sets $QUIET_MODE to true if '-q' or '--quiet' specified." do
-        bkup = $QUIET_MODE
-        begin
-          ["-q", "--quiet"].each do |opt|
-            $QUIET_MODE = nil
-            sout, serr = capture_sio { @app.run(opt, "test-debugopt") }
-            ok {serr} == ""
-            ok {$QUIET_MODE} == true
-          end
-        ensure
-          $QUIET_MODE = bkup
+      case_when "[!tftl5] when prefix is not specified..." do
+
+        spec "[!36vz6] returns action list string if any actions defined." do
+          s = @app.instance_eval { render_item_list(nil) }
+          ok {s} !~ /\A\e\[1;34mUsage:\e\[0m$/
+          ok {s} !~ /\A\e\[1;34mOptions:\e\[0m$/
+          ok {s} =~ /\A\e\[1;34mActions:\e\[0m$/
         end
-      end
 
-      spec "[!2zvf9] sets $COLOR_MODE to true/false according to '--color' option." do
-        bkup = $COLOR_MODE
-        begin
-          [["--color", true], ["--color=on", true], ["--color=off", false]].each do |opt, val|
-            $COLOR_MODE = !val
-            sout, serr = capture_sio { @app.run(opt, "test-debugopt") }
-            ok {serr} == ""
-            ok {$COLOR_MODE} == val
+        spec "[!znuy4] raises CommandError if no actions defined." do
+          fake_app_help_builder() do
+            pr = proc { @app.instance_eval { render_item_list(nil) } }
+            ok {pr}.raise?(Benry::CmdApp::CommandError,
+                           "No actions defined.")
           end
-        ensure
-          $COLOR_MODE = bkup
         end
+
       end
 
-      spec "[!ywl1a] sets $DEBUG_MODE to true if '-D' or '--debug' specified." do
-        bkup = $DEBUG_MODE
-        begin
-          ["-D", "--debug"].each do |opt|
-            $DEBUG_MODE = false
-            sout, serr = capture_sio { @app.run(opt, "test-debugopt") }
-            ok {serr} == ""
-            ok {sout} == "$DEBUG_MODE=true\n"
-            ok {$DEBUG_MODE} == true
-          end
-        ensure
-          $DEBUG_MODE = bkup
+      case_when "[!jcq4z] when separator is specified..." do
+
+        spec "[!w1j1e] returns top prefix list if ':' specified." do
+          s = @app.instance_eval { render_item_list(":") }
+          ok {s} !~ /\A\e\[1;34mUsage:\e\[0m$/
+          ok {s} !~ /\A\e\[1;34mOptions:\e\[0m$/
+          ok {s} !~ /\A\e\[1;34mActions:\e\[0m$/
+          ok {s} =~ /\A\e\[1;34mCategories:\e\[0m \e\[2m\(depth=\d+\)\e\[0m$/
+          #
+          ok {s} !~ /^  hello/
+         #ok {s} =~ /^  foo: \(\d+\)$/
+          ok {s} =~ /^  git: \(\d+\)$/
+          ok {s} =~ /^  giit: \(\d+\)/
+          ok {s} !~ /^  hello/
+          #
+          ok {s} =~ /^  giit: \(\d\d\)         : gitt commands$/
+          ok {s} !~ /^  giit:branch: \(\d+\)$/
+          ok {s} !~ /^  giit:commit: \(\d+\)$/
+          ok {s} !~ /^  giit:repo: \(\d+\)$/
+          ok {s} !~ /^  giit:staging: \(\d+\)$/
         end
-      end
 
-      spec "[!8trmz] sets $TRACE_MODE to true if '-T' or '--trace' specified." do
-        bkup = $TRACE_MODE
-        begin
-          ["-T", "--trace"].each do |opt|
-            $TRACE_MODE = false
-            sout, serr = capture_sio { @app.run(opt, "test-debugopt") }
-            ok {serr} == ""
-            ok {$TRACE_MODE} == true
+        spec "[!bgput] returns two depth prefix list if '::' specified." do
+          s = @app.instance_eval { render_item_list("::") }
+          ok {s} !~ /\A\e\[1;34mUsage:\e\[0m$/
+          ok {s} !~ /\A\e\[1;34mOptions:\e\[0m$/
+          ok {s} !~ /\A\e\[1;34mActions:\e\[0m$/
+          ok {s} =~ /\A\e\[1;34mCategories:\e\[0m \e\[2m\(depth=\d+\)\e\[0m$/
+          #
+         #ok {s} =~ /^  foo: \(\d+\)$/
+          ok {s} =~ /^  git: \(\d+\)$/
+          ok {s} =~ /^  giit: \(\d\)          : gitt commands$/
+          ok {s} !~ /^  hello/
+          #
+          ok {s} =~ /^  giit:branch: \(\d+\)$/
+          ok {s} =~ /^  giit:commit: \(\d+\)$/
+          ok {s} =~ /^  giit:repo: \(\d+\)$/
+          ok {s} =~ /^  giit:staging: \(\d+\)$/
+        end
+
+        spec "[!tiihg] raises CommandError if no actions found having prefix." do
+          fake_app_help_builder() do
+            pr = proc { @app.instance_eval { render_item_list(":") } }
+            ok {pr}.raise?(Benry::CmdApp::CommandError,
+                           "Prefix of actions not found.")
           end
-        ensure
-          $TRACE_MODE = bkup
         end
+
       end
 
-    end
+      case_when "[!xut9o] when prefix is specified..." do
 
+        spec "[!z4dqn] filters action list by prefix if specified." do
+          s = @app.instance_eval { render_item_list("git:") }
+          ok {s} == <<"END"
+\e[1;34mActions:\e[0m
+  git:stage          : same as `git add -p`
+  git:staged         : same as `git diff --cached`
+  git:unstage        : same as `git reset HEAD`
+END
+        end
 
-    topic '#do_handle_global_options()' do
+        spec "[!1834c] raises CommandError if no actions found with names starting with that prefix." do
+          fake_app_help_builder() do
+            pr = proc { @app.instance_eval { render_item_list("git:") } }
+            ok {pr}.raise?(Benry::CmdApp::CommandError,
+                           "No actions found with names starting with 'git:'.")
+          end
+        end
 
-      def new_app()
-        kws = {
-          app_name:       "TestApp",
-          app_command:    "testapp",
-          option_all:     true,
-          option_verbose: true,
-          option_quiet:   true,
-          option_color:   true,
-          option_debug:   true,
-          default_action: nil,
-        }
-        config = Benry::CmdApp::Config.new("test app", "1.0.0", **kws)
-        return Benry::CmdApp::Application.new(config)
       end
 
-      spec "[!xvj6s] prints help message if '-h' or '--help' specified." do
-        expected = <<"END"
-TestApp (1.0.0) -- test app
-
-Usage:
-  $ testapp [<options>] [<action> [<arguments>...]]
+      case_else "[!xjdrm] else..." do
 
-Options:
-  -h, --help         : print help message
-  -V, --version      : print version
-  -a, --all          : list all actions including private (hidden) ones
-  -v, --verbose      : verbose mode
-  -q, --quiet        : quiet mode
-  --color[=<on|off>] : enable/disable color
-  -D, --debug        : debug mode (set $DEBUG_MODE to true)
-
-Actions:
-END
-        app = new_app()
-        ["-h", "--help"].each do |opt|
-          sout, serr = capture_sio { app.run(opt) }
-          ok {serr} == ""
-          ok {sout}.start_with?(expected)
+        spec "[!9r4w9] raises ArgumentError." do
+          pr = proc { @app.instance_eval { render_item_list("git") } }
+          ok {pr}.raise?(ArgumentError,
+                         "\"git\": Invalid value as a prefix.")
         end
+
       end
 
-      spec "[!lpoz7] prints help message of action if action name specified with help option." do
-        expected = <<"END"
-testapp sayhello -- print greeting message
+    end
 
-Usage:
-  $ testapp sayhello [<options>] [<user>]
 
-Options:
-  -l, --lang=<en|fr|it> : language
-END
-        app = new_app()
-        ["-h", "--help"].each do |opt|
-          sout, serr = capture_sio { app.run(opt, "sayhello") }
-          ok {serr} == ""
-          ok {sout} == expected
-        end
-      end
+    topic '#render_topic_list()' do
 
-      spec "[!fslsy] prints version if '-V' or '--version' specified." do
-        app = new_app()
-        ["-V", "--version"].each do |opt|
-          sout, serr = capture_sio { app.run(opt, "xxx") }
-          ok {serr} == ""
-          ok {sout} == "1.0.0\n"
-        end
+      spec "[!uzmml] renders topic list." do
+        x = @app.__send__(:render_topic_list, "action")
+        ok {x} =~ /\A\e\[1;34mActions:\e\[0m$/
+        ok {x} =~ /^  hello              : greeting message$/
+        #
+        Benry::CmdApp.define_alias("chiaou", ["hello", "-l", "it"])
+        x = @app.__send__(:render_topic_list, "alias")
+        ok {x} =~ /\A\e\[1;34mAliases:\e\[0m$/
+        ok {x} =~ /^  chiaou             : alias for 'hello -l it'$/
+        #
+        x = @app.__send__(:render_topic_list, "category")
+        ok {x} =~ /\A\e\[1;34mCategories:\e\[0m \e\[2m\(depth=0\)\e\[0m$/
+        ok {x} =~ /^  git: \(3\)$/
+        ok {x} =~ /^  giit: \(\d+\) +: gitt commands$/
+        #
+        Benry::CmdApp.define_abbrev("g31:", "git:")
+        x = @app.__send__(:render_topic_list, "abbrev")
+        ok {x} =~ /\A\e\[1;34mAbbreviations:\e\[0m$/
+        ok {x} =~ /^  g31: +=>  git:$/
+      end
+
+      spec "[!vrzu0] topic 'category1' or 'categories2' is acceptable." do
+        x = @app.__send__(:render_topic_list, "category1")
+        ok {x} =~ /\A\e\[1;34mCategories:\e\[0m \e\[2m\(depth=1\)\e\[0m$/
+        ok {x} =~ /^  git: \(3\)$/
+        ok {x} =~ /^  giit: \(\d+\) +: gitt commands$/
+        ok {x} !~ /^  giit:branch:/
+        ok {x} !~ /^  giit:repo:/
+        #
+        x = @app.__send__(:render_topic_list, "category2")
+        ok {x} =~ /\A\e\[1;34mCategories:\e\[0m \e\[2m\(depth=2\)\e\[0m$/
+        ok {x} =~ /^  git: \(3\)$/
+        ok {x} =~ /^  giit: \(0\) +: gitt commands$/
+        ok {x} =~ /^  giit:branch: \(2\)$/
+        ok {x} =~ /^  giit:repo: \(7\)$/
+        ok {x} !~ /^  giit:repo:config:/
+        ok {x} !~ /^  giit:repo:remote:/
+        #
+        x = @app.__send__(:render_topic_list, "categories3")
+        ok {x} =~ /\A\e\[1;34mCategories:\e\[0m \e\[2m\(depth=3\)\e\[0m$/
+        ok {x} =~ /^  git: \(3\)$/
+        ok {x} =~ /^  giit: \(0\) +: gitt commands$/
+        ok {x} =~ /^  giit:branch: \(2\)$/
+        ok {x} =~ /^  giit:repo: \(2\)$/
+        ok {x} =~ /^  giit:repo:config: \(3\)$/
+        ok {x} =~ /^  giit:repo:remote: \(2\)$/
+      end
+
+      spec "[!xyn5g] global option '-L metadata' renders registry data in YAML format." do
+        config = Benry::CmdApp::Config.new("test app", "0.0.0")
+        app = Benry::CmdApp::Application.new(config)
+        sout, serr = capture_sio { app.run("-L", "metadata") }
+        ok {serr} == ""
+        require 'yaml'
+        ydoc = YAML.load(sout)
+        ok {ydoc["actions"]}.is_a?(Array)
+        ok {ydoc["aliases"]}.is_a?(Array)
+        ok {ydoc["categories"]}.is_a?(Array)
+        ok {ydoc["abbreviations"]}.is_a?(Array)
       end
 
     end
 
 
-    topic '#do_callback()' do
+    topic '#handle_blank_action()' do
 
-      def new_app(&block)
-        @config = Benry::CmdApp::Config.new("test app", "1.0.0")
-        return Benry::CmdApp::Application.new(@config, &block)
-      end
-
-      spec "[!xwo0v] calls callback if provided." do
-        called = nil
-        app = new_app do |args, global_opts, config|
-          called = [args.dup, global_opts, config]
-        end
-        ok {called} == nil
-        without_tty { app.run("sayhello") }
-        ok {called} != nil
-        ok {called[0]} == ["sayhello"]
-        ok {called[1]} == {}
-        ok {called[2]} == @config
-      end
-
-      spec "[!lljs1] calls callback only once." do
-        n = 0
-        app = new_app do |args, global_opts, config|
-          n += 1
+      spec "[!seba7] prints action list and returns `0`." do
+        ret = nil
+        sout, serr = capture_sio do
+          ret = @app.instance_eval { handle_blank_action() }
         end
-        ok {n} == 0
-        without_tty { app.run("sayhello") }
-        ok {n} == 1
-        without_tty { app.run("sayhello") }
-        ok {n} == 1
-        without_tty { app.run("sayhello") }
-        ok {n} == 1
+        ok {sout} !~ /\AUsage:$/
+        ok {sout} !~ /\AOptions:$/
+        ok {sout} =~ /\AActions:$/
+        ok {ret} == 0
       end
 
     end
 
 
-    topic '#do_find_action()' do
+    topic '#handle_prefix()' do
 
-      spec "[!bm8np] returns action metadata." do
-        x = @app.__send__(:do_find_action, ["sayhello"], {})
-        ok {x}.is_a?(Benry::CmdApp::ActionMetadata)
-        ok {x.name} == "sayhello"
+      spec "[!8w301] prints action list starting with prefix and returns `0`." do
+        ret = nil
+        sout, serr = capture_sio do
+          ret = @app.instance_eval { handle_prefix("git:") }
+        end
+        ok {ret} == 0
+        ok {sout} == <<"END"
+Actions:
+  git:stage          : same as `git add -p`
+  git:staged         : same as `git diff --cached`
+  git:unstage        : same as `git reset HEAD`
+END
       end
 
-      spec "[!vl0zr] error when action not found." do
-        pr = proc { @app.__send__(:do_find_action, ["hiyo"], {}) }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "hiyo: Unknown action.")
-      end
+    end
 
-      spec "[!gucj7] if no action specified, finds default action instead." do
-        @app.config.default_action = "sayhello"
-        x = @app.__send__(:do_find_action, [], {})
-        ok {x}.is_a?(Benry::CmdApp::ActionMetadata)
-        ok {x.name} == "sayhello"
-      end
 
-      spec "[!388rs] error when default action not found." do
-        @app.config.default_action = "hiyo"
-        pr = proc { @app.__send__(:do_find_action, [], {}) }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "hiyo: Unknown default action.")
-      end
+    topic '#start_action()' do
 
-      spec "[!drmls] returns nil if no action specified but 'config.default_help' is set." do
-        @app.config.default_action = nil
-        @app.config.default_help = true
-        x = @app.__send__(:do_find_action, [], {})
-        ok {x} == nil
+      spec "[!vbymd] runs action with args and returns `0`." do
+        ret = nil
+        sout, serr = capture_sio do
+          ret = @app.instance_eval { start_action("hello", ["-l", "it", "Alice"]) }
+        end
+        ok {ret} == 0
+        ok {sout} == "Chao, Alice!\n"
       end
 
-      spec "[!hs589] error when action nor default action not specified." do
-        @app.config.default_action = nil
-        @app.config.default_help = false
-        pr = proc { @app.__send__(:do_find_action, [], {}) }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "testapp: Action name required (run `testapp -h` for details).")
+      spec "[!6htva] supports abbreviation of prefix." do
+        Benry::CmdApp.define_abbrev("g1:", "git:")
+        sout, serr = capture_sio do
+          @app.instance_eval do
+            start_action("g1:stage", ["."])
+            start_action("g1:unstage", [])
+          end
+        end
+        ok {sout} == <<'END'
+git add -p .
+git reset HEAD
+END
       end
 
     end
 
 
-    topic '#do_run_action()' do
+    topic '#new_context()' do
 
-      spec "[!62gv9] parses action options even if specified after args." do
-        sout, serr = capture_sio { @app.run("sayhello", "Alice", "-l", "it") }
-        ok {serr} == ""
-        ok {sout} == "Ciao, Alice!\n"
+      spec "[!9ddcl] creates new context object with config object." do
+        x = @app.instance_eval { new_context() }
+        ok {x}.is_a?(Benry::CmdApp::ApplicationContext)
+        ok {x.instance_variable_get(:@config)} == @config
       end
 
-      spec "[!6mlol] error if action requries argument but nothing specified." do
-        pr = proc { @app.run("test-arity1") }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "test-arity1: Argument required.")
-      end
+    end
 
-      spec "[!72jla] error if action requires N args but specified less than N args." do
-        pr = proc { @app.run("test-arity1", "foo") }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "test-arity1: Too less arguments (at least 2).")
-      end
 
-      spec "[!zawxe] error if action requires N args but specified over than N args." do
-        pr = proc { @app.run("test-arity1", "foo", "bar", "baz", "boo") }
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "test-arity1: Too much arguments (at most 3).")
-      end
+    topic '#print_str()' do
 
-      spec "[!y97o3] action can take any much args if action has variable arg." do
-        pr = proc {
-          capture_sio { @app.run("test-arity2", "foo", "bar", "baz", "boo") }
-        }
-        ok {pr}.NOT.raise?(Exception)
+      spec "[!yiabh] do nothing if str is nil." do
+        sout, serr = capture_sio do
+          @app.instance_eval { print_str nil }
+        end
+        ok {sout} == ""
+        ok {serr} == ""
       end
 
-      spec "[!cf45e] runs action with arguments and options." do
-        sout, serr = capture_sio { @app.run("sayhello", "-l", "it", "Bob") }
-        ok {serr} == ""
-        ok {sout} == "Ciao, Bob!\n"
+      spec "[!6kyv9] prints string as is if color mode is enabled." do
+        bkup = $COLOR_MODE; at_end { $COLOR_MODE = bkup }
+        $COLOR_MODE = true
+        sout, serr = capture_sio do
+          @app.instance_eval { print_str("\e[1mHello\e[0m") }
+        end
+        ok {sout} == "\e[1mHello\e[0m"
       end
 
-      spec "[!tsal4] detects looped action." do
-        pr = proc { @app.run("test-loop1") }
-        ok {pr}.raise?(Benry::CmdApp::LoopedActionError,
-                       "test-loop1: Action loop detected.")
+      spec "[!lxhvq] deletes escape characters from string and prints it if color mode is disabled." do
+        bkup = $COLOR_MODE; at_end { $COLOR_MODE = bkup }
+        $COLOR_MODE = false
+        sout, serr = capture_sio do
+          @app.instance_eval { print_str("\e[1mHello\e[0m") }
+        end
+        ok {sout} == "Hello"
       end
 
     end
 
 
-    topic '#do_print_help_message()' do
+    topic '#print_error()' do
 
-      spec "[!eabis] prints help message of action if action name provided." do
-        sout, serr = capture_sio { @app.run("-h", "sayhello") }
-        ok {serr} == ""
-        ok {sout} == <<'END'
-testapp sayhello -- print greeting message
+      fixture(:err) {
+        begin
+          1/0
+        rescue ZeroDivisionError => err
+        end
+        err
+      }
 
-Usage:
-  $ testapp sayhello [<options>] [<user>]
+      spec "[!sdbj8] prints exception as error message." do |err|
+        sout, serr = capture_sio(tty: true) do
+          @app.instance_eval { print_error(err) }
+        end
+        ok {sout} == ""
+        ok {serr} == "\e[31m[ERROR]\e[0m divided by 0\n"
+      end
 
-Options:
-  -l, --lang=<en|fr|it> : language
-END
+      spec "[!6z0mu] prints colored error message if stderr is a tty." do |err|
+        sout, serr = capture_sio(tty: true) do
+          @app.instance_eval { print_error(err) }
+        end
+        ok {sout} == ""
+        ok {serr} == "\e[31m[ERROR]\e[0m divided by 0\n"
       end
 
-      spec "[!cgxkb] error if action for help option not found." do
-        ["-h", "--help"].each do |opt|
-          pr = proc { @app.run(opt, "xhello") }
-          ok {pr}.raise?(Benry::CmdApp::CommandError,
-                         "xhello: Action not found.")
+      spec "[!k1s3o] prints non-colored error message if stderr is not a tty." do |err|
+        sout, serr = capture_sio(tty: false) do
+          @app.instance_eval { print_error(err) }
         end
+        ok {sout} == ""
+        ok {serr} == "[ERROR] divided by 0\n"
       end
 
-      spec "[!nv0x3] prints help message of command if action name not provided." do
-        sout, serr = capture_sio { @app.run("-h") }
-        ok {serr} == ""
-        ok {sout}.start_with?(<<'END')
-TestApp (1.0.0) -- test app
+    end
 
-Usage:
-  $ testapp [<options>] [<action> [<arguments>...]]
 
-Options:
-  -h, --help         : print help message
-  -V, --version      : print version
-  -a, --all          : list all actions including private (hidden) ones
-  -D, --debug        : debug mode (set $DEBUG_MODE to true)
+    topic '#print_backtrace()' do
 
-Actions:
-END
-      end
+      fixture(:err) {
+        begin
+          1/0
+        rescue ZeroDivisionError => err
+        end
+        err
+      }
 
-      spec "[!4qs7y] shows private (hidden) actions/options if '--all' option specified." do
-        class HiddenTest < Benry::CmdApp::ActionScope
-          private
-          @action.("hidden test")
-          @option.(:trace, "-T", "enable tracing", hidden: true)
-          def hidden1(trace: false)
-          end
+      spec "[!i010e] skips backtrace in `benry/cmdapp.rb`." do |err|
+        sout, serr = capture_sio() do
+          @app.instance_eval { print_backtrace(err) }
         end
-        #
-        ok {_run_app("-h", "--all")}  =~ /^  hidden1 +: hidden test$/
-        ok {_run_app("--help", "-a")} =~ /^  hidden1 +: hidden test$/
-        ok {_run_app("-h")}           !~ /^  hidden1 +: hidden test$/
-        #
-        ok {_run_app("-ha", "hidden1")}         =~ /^  -T +: enable tracing$/
-        ok {_run_app("-h", "--all", "hidden1")} =~ /^  -T +: enable tracing$/
-        ok {_run_app("--help", "hidden1")}      !~ /^  -T +: enable tracing$/
+        ok {sout} == ""
+        ok {serr} !~ /benry\/cmdapp\.rb/
+        ok {serr} =~ /app_test\.rb/
       end
 
-      spec "[!l4d6n] `all` flag should be true or false, not nil." do
-        config = Benry::CmdApp::Config.new("test app", "1.0.0", option_all: true)
-        app = Benry::CmdApp::Application.new(config)
-        def app.help_message(all)
-          @_all_ = all
-          super
+      spec "[!ilaxg] skips backtrace if `#skip_backtrace?()` returns truthy value." do |err|
+        sout1, serr1 = capture_sio() do
+          @app.instance_eval { print_backtrace(err) }
         end
-        msg = without_tty { app.run("-h") }
-        ok {app.instance_variable_get('@_all_')} != nil
-        ok {app.instance_variable_get('@_all_')} == false
+        ok {serr1} =~ /app_test\.rb/
         #
-        msg = without_tty { app.run("-ha") }
-        ok {app.instance_variable_get('@_all_')} != nil
-        ok {app.instance_variable_get('@_all_')} == true
+        r = recorder()
+        r.fake_method(@app, :'skip_backtrace?' => true)
+        sout2, serr2 = capture_sio() do
+          @app.instance_eval { print_backtrace(err) }
+        end
+        ok {serr2} == ""
       end
 
-      spec "[!efaws] prints colorized help message when stdout is a tty." do
-        sout, serr = capture_sio(tty: true) { @app.run("-h") }
-        ok {serr} == ""
-        ok {sout}.include?(<<"END")
-\e[34mUsage:\e[0m
-  $ \e[1mtestapp\e[0m [<options>] [<action> [<arguments>...]]
-END
-      ok {sout}.include?(<<"END")
-\e[34mOptions:\e[0m
-  \e[1m-h, --help        \e[0m : print help message
-  \e[1m-V, --version     \e[0m : print version
-END
-      ok {sout}.include?(<<"END")
-\e[34mActions:\e[0m
-END
+      spec "[!5sa5k] prints filename and line number in slant format if stdout is a tty." do |err|
+        sout, serr = capture_sio(tty: true) do
+          @app.instance_eval { print_backtrace(err) }
+        end
+        ok {sout} == ""
+        ok {serr} =~ /\A    \e\[3mFrom test\/app_test\.rb:\d+:in `\/'\e\[0m/
       end
 
-      spec "[!9vdy1] prints non-colorized help message when stdout is not a tty." do
-        sout, serr = capture_sio(tty: false) { @app.run("-h") }
-        ok {serr} == ""
-        ok {sout}.include?(<<"END")
-Usage:
-  $ testapp [<options>] [<action> [<arguments>...]]
-END
-      ok {sout}.include?(<<"END")
-Options:
-  -h, --help         : print help message
-  -V, --version      : print version
-END
-      ok {sout}.include?(<<"END")
-Actions:
+      spec "[!2sg9r] not to try to read file content if file not found." do |err|
+        newbt = [
+          "#{__FILE__}:#{__LINE__}:in `foo`",
+          "-e:#{__LINE__}:in `bar`",
+          "#{__FILE__}:#{__LINE__}:in `baz`",
+        ]
+        n = __LINE__ - 4   # base lineno
+        err.set_backtrace(newbt)
+        sout, serr = capture_sio(tty: true) do
+          @app.instance_eval { print_backtrace(err) }
+        end
+        ok {sout} == ""
+        ok {serr} == <<"END"
+    \e[3mFrom test/app_test.rb:#{n+0}:in `foo`\e[0m
+        "\#{__FILE__}:\#{__LINE__}:in `foo`",
+    \e[3mFrom -e:#{n+1}:in `bar`\e[0m
+    \e[3mFrom test/app_test.rb:#{n+2}:in `baz`\e[0m
+        "\#{__FILE__}:\#{__LINE__}:in `baz`",
 END
       end
 
-      spec "[!gsdcu] prints colorized help message when '--color[=on]' specified." do
-        @config.option_color = true
-        app = Benry::CmdApp::Application.new(@config)
-        bkup = $COLOR_MODE
-        begin
-          sout, serr = capture_sio(tty: false) { app.run("-h", "--color") }
-          ok {serr} == ""
-          ok {sout}.include?(<<"END")
-\e[34mUsage:\e[0m
-  $ \e[1mtestapp\e[0m [<options>] [<action> [<arguments>...]]
-END
-          ok {sout}.include?(<<"END")
-\e[34mOptions:\e[0m
-  \e[1m-h, --help        \e[0m : print help message
-  \e[1m-V, --version     \e[0m : print version
-END
-          ok {sout}.include?(<<"END")
-\e[34mActions:\e[0m
-END
-        ensure
-          $COLOR_MODE = bkup
+      spec "[!ihizf] prints lines of each backtrace entry." do |err|
+        sout, serr = capture_sio(tty: true) do
+          @app.instance_eval { print_backtrace(err) }
         end
+        ok {sout} == ""
+        ok {serr} =~ /^        1\/0\n/
       end
 
-      spec "[!be8y2] prints non-colorized help message when '--color=off' specified." do
-        @config.option_color = true
-        app = Benry::CmdApp::Application.new(@config)
-        bkup = $COLOR_MODE
-        begin
-          sout, serr = capture_sio(tty: true) { app.run("-h", "--color=off") }
-          ok {serr} == ""
-          ok {sout}.include?(<<"END")
-Usage:
-  $ testapp [<options>] [<action> [<arguments>...]]
-END
-          ok {sout}.include?(<<"END")
-Options:
-  -h, --help         : print help message
-  -V, --version      : print version
-END
-          ok {sout}.include?(<<"END")
-Actions:
-END
-        ensure
-          $COLOR_MODE = bkup
+      spec "[!8wzxg] prints backtrace of exception." do |err|
+        sout, serr = capture_sio() do
+          @app.instance_eval { print_backtrace(err) }
         end
+        ok {sout} == ""
+        ok {serr} =~ /\A    From test\/app_test\.rb:\d+:in `\/'\n        1\/0\n/
       end
 
     end
 
 
-    topic '#do_validate_actions()' do
+    topic '#skip_backtrace?()' do
 
-      spec "[!6xhvt] reports warning at end of help message." do
-        class ValidateActionTest1 < Benry::CmdApp::ActionScope
-          prefix "validate1", alias_of: :test
-          @action.("test")
-          def test1(); end
+      spec "[!r2fmv] ignores backtraces if matched to 'config.backtrace_ignore_rexp'." do
+        @config.backtrace_ignore_rexp = /\/foobar\.rb/
+        bt1 = "/home/yourname/foobar.rb:123:"
+        bt2 = "/home/yourname/blabla.rb:123:"
+        _ = self
+        @app.instance_eval do
+          _.ok {skip_backtrace?(bt1)} == 14
+          _.ok {skip_backtrace?(bt2)} == nil
         end
-        @app.config.default_help = true
-        begin
-          [["-h"], []].each do |args|
-            sout, serr = capture_sio { @app.run(*args) }
-            ok {serr} == <<'END'
+      end
 
-** [warning] in 'ValidateActionTest1' class, `alias_of: :test` specified but corresponding action not exist.
-END
-          end
-        ensure
-          ValidateActionTest1.class_eval { @__aliasof__ = nil }
+      spec "[!c6f11] not ignore backtraces if 'config.backtrace_ignore_rexp' is not set." do
+        @config.backtrace_ignore_rexp = nil
+        bt1 = "/home/yourname/foobar.rb:123:"
+        bt2 = "/home/yourname/blabla.rb:123:"
+        _ = self
+        @app.instance_eval do
+          _.ok {skip_backtrace?(bt1)} == false
+          _.ok {skip_backtrace?(bt2)} == false
         end
       end
 
-      spec "[!iy241] reports warning if `alias_of:` specified in action class but corresponding action not exist." do
-        class ValidateActionTest2 < Benry::CmdApp::ActionScope
-          prefix "validate2", alias_of: :test2
-          @action.("test")
-          def test(); end
-        end
-        begin
-          sout, serr = capture_sio { @app.__send__(:do_validate_actions, [], {}) }
-          ok {serr} == <<'END'
+    end
 
-** [warning] in 'ValidateActionTest2' class, `alias_of: :test2` specified but corresponding action not exist.
-END
-        ensure
-          ValidateActionTest2.class_eval { @__aliasof__ = nil }
-        end
-      end
 
-      spec "[!h7lon] reports warning if `action:` specified in action class but corresponding action not exist." do
-        class ValidateActionTest3 < Benry::CmdApp::ActionScope
-          prefix "validate3", action: :test3
-          @action.("test")
-          def test(); end
-        end
-        begin
-          sout, serr = capture_sio { @app.__send__(:do_validate_actions, [], {}) }
-          ok {serr} == <<'END'
+    topic '#read_file_as_lines()' do
 
-** [warning] in 'ValidateActionTest3' class, `action: :test3` specified but corresponding action not exist.
-END
-        ensure
-          ValidateActionTest3.class_eval { @__default__ = nil }
-        end
+      spec "[!e9c74] reads file content as an array of line." do
+        lines = @app.instance_eval { read_file_as_lines(__FILE__) }
+        ok {lines}.is_a?(Array)
+        ok {lines[__LINE__ - 2]} == "        ok {lines}.is_a?(Array)\n"
       end
 
     end
 
 
-    topic '#do_print_candidates()' do
+    topic '#should_rescue?()' do
 
-      spec "[!0e8vt] prints candidate action names including prefix name without tailing ':'." do
-        class CandidateTest2 < Benry::CmdApp::ActionScope
-          prefix "candi:date2", action: :eee
-          @action.("test1")
-          def ddd(); end
-          @action.("test2")
-          def ccc(); end
-          @action.("test3")
-          def eee(); end
-        end
-        sout, serr = capture_sio do
-          @app.__send__(:do_print_candidates, ["candi:date2:"], {})
-        end
-        ok {serr} == ""
-        ok {sout} == <<"END"
-Actions:
-  candi:date2        : test3
-  candi:date2:ccc    : test2
-  candi:date2:ddd    : test1
-END
+      spec "[!8lwyn] returns trueif exception is a BaseError." do
+        x = @app.__send__(:should_rescue?, Benry::CmdApp::DefinitionError.new)
+        ok {x} == true
+        x = @app.__send__(:should_rescue?, RuntimeError.new)
+        ok {x} == false
       end
 
-      spec "[!85i5m] candidate actions should include alias names." do
-        class CandidateTest3 < Benry::CmdApp::ActionScope
-          prefix "candi:date3", action: :ggg
-          @action.("test1")
-          def hhh(); end
-          @action.("test2")
-          def fff(); end
-          @action.("test3")
-          def ggg(); end
-        end
-        Benry::CmdApp.action_alias("pupu", "candi:date3:fff")
-        Benry::CmdApp.action_alias("popo", "candi:date3:fff")
-        Benry::CmdApp.action_alias("candi:date3:xxx", "candi:date3:hhh")
-        sout, serr = capture_sio do
-          @app.__send__(:do_print_candidates, ["candi:date3:"], {})
-        end
-        ok {serr} == ""
-        ok {sout} == <<"END"
-Actions:
-  candi:date3        : test3
-  candi:date3:fff    : test2
-                       (alias: pupu, popo)
-  candi:date3:hhh    : test1
-                       (alias: candi:date3:xxx)
-  candi:date3:xxx    : alias of 'candi:date3:hhh' action
-END
-      end
+    end
 
-      spec "[!i2azi] raises error when no candidate actions found." do
-        pr = proc do
-          @app.__send__(:do_print_candidates, ["candi:date9:"], {})
-        end
-        ok {pr}.raise?(Benry::CmdApp::CommandError,
-                       "No actions starting with 'candi:date9:'.")
-      end
-
-      spec "[!k3lw0] private (hidden) action should not be printed as candidates." do
-        class CandidateTest4 < Benry::CmdApp::ActionScope
-          prefix "candi:date4"
-          @action.("test1")
-          def kkk(); end
-          private
-          @action.("test2")
-          def iii(); end
-          public
-          @action.("test3")
-          def jjj(); end
-        end
-        sout, serr = capture_sio do
-          @app.__send__(:do_print_candidates, ["candi:date4:"], {})
-        end
-        ok {serr} == ""
-        ok {sout} == <<"END"
-Actions:
-  candi:date4:jjj    : test3
-  candi:date4:kkk    : test1
-END
-      end
 
-      spec "[!j4b54] shows candidates in strong format if important." do
-        class CandidateTest6 < Benry::CmdApp::ActionScope
-          prefix "candi:date6"
-          @action.("test1")
-          def t1(); end
-          @action.("test2", important: true)
-          def t2(); end
-        end
-        Benry::CmdApp.action_alias("candi:date6", "candi:date6:t2")
-        sout, serr = capture_sio(tty: true) do
-          @app.__send__(:do_print_candidates, ["candi:date6:"], {})
-        end
-        ok {serr} == ""
-        ok {sout} == <<END
-\e[34mActions:\e[0m
-  \e[1m\e[4mcandi:date6\e[0m       \e[0m : alias of 'candi:date6:t2' action
-  \e[1mcandi:date6:t1    \e[0m : test1
-  \e[1m\e[4mcandi:date6:t2\e[0m    \e[0m : test2
-                       (alias: candi:date6)
+  end
+
+
+  topic Benry::CmdApp::GlobalOptionSchema do
+
+    def new_schema(config)
+      return Benry::CmdApp::GlobalOptionSchema.new(config)
+    end
+
+
+    topic '#initialize()' do
+
+      spec "[!ppcvp] adds options according to config object." do
+        config = Benry::CmdApp::Config.new("sample app", "1.2.3")
+        schema = new_schema(config)
+        ok {schema.get(:help)}    != nil
+        ok {schema.get(:version)} != nil
+        ok {schema.get(:list)}    != nil
+        ok {schema.get(:all)}     != nil
+        ok {schema.get(:verbose)} == nil
+        ok {schema.get(:quiet)}   == nil
+        ok {schema.get(:color)}   == nil
+        ok {schema.get(:debug)}   != nil
+        ok {schema.get(:debug)}.hidden?
+        ok {schema.to_s} == <<"END"
+  -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
+END
+        ok {schema.get(:trace)}   == nil
+        #
+        config.option_help   = false
+        config.option_version = false
+        config.option_list   = false
+        config.option_all    = false
+        config.option_verbose = true
+        config.option_quiet  = true
+        config.option_color  = true
+        config.option_debug  = true
+        config.option_trace  = true
+        #
+        schema = new_schema(config)
+        ok {schema.get(:help)}    == nil
+        ok {schema.get(:version)} == nil
+        ok {schema.get(:list)}    == nil
+        ok {schema.get(:all)}     == nil
+        ok {schema.get(:verbose)} != nil
+        ok {schema.get(:quiet)}   != nil
+        ok {schema.get(:color)}   != nil
+        ok {schema.get(:trace)}   != nil
+        ok {schema.get(:debug)}.NOT.hidden?
+      end
+
+      spec "[!doj0k] if config option is `:hidden`, makes option as hidden." do
+        config = Benry::CmdApp::Config.new("sample app", "1.2.3")
+        config.option_help    = :hidden
+        config.option_version = :hidden
+        config.option_list    = :hidden
+        config.option_topic   = :hidden
+        config.option_all     = :hidden
+        config.option_verbose = :hidden
+        config.option_quiet   = :hidden
+        config.option_color   = :hidden
+        config.option_debug   = :hidden
+        config.option_trace   = :hidden
+        #
+        schema = new_schema(config)
+        ok {schema.get(:help   ).hidden?} == true
+        ok {schema.get(:version).hidden?} == true
+        ok {schema.get(:list   ).hidden?} == true
+        ok {schema.get(:topic  ).hidden?} == true
+        ok {schema.get(:all    ).hidden?} == true
+        ok {schema.get(:verbose).hidden?} == true
+        ok {schema.get(:quiet  ).hidden?} == true
+        ok {schema.get(:color  ).hidden?} == true
+        ok {schema.get(:debug  ).hidden?} == true
+        ok {schema.get(:trace  ).hidden?} == true
+        #
+        ok {schema.option_help()} == ""
+        ok {schema.option_help(all: true)} == <<'END'
+      --help           : print help message (of action if specified)
+      --version        : print version
+      --list           : list actions and aliases
+  -L <topic>           : topic list (actions|aliases|categories|abbrevs)
+      --all            : list hidden actions/options, too
+      --verbose        : verbose mode
+      --quiet          : quiet mode
+  --color[=<on|off>]   : color mode
+      --debug          : debug mode
+      --trace          : trace mode
 END
       end
 
-      spec "[!q3819] shows candidates in weak format if not important." do
-        class CandidateTest7 < Benry::CmdApp::ActionScope
-          prefix "candi:date7"
-          @action.("test1")
-          def t1(); end
-          @action.("test2", important: false)
-          def t2(); end
-        end
-        Benry::CmdApp.action_alias("candi:date7", "candi:date7:t2")
-        sout, serr = capture_sio(tty: true) do
-          @app.__send__(:do_print_candidates, ["candi:date7:"], {})
-        end
-        ok {serr} == ""
-        ok {sout} == <<END
-\e[34mActions:\e[0m
-  \e[1m\e[2mcandi:date7\e[0m       \e[0m : alias of 'candi:date7:t2' action
-  \e[1mcandi:date7:t1    \e[0m : test1
-  \e[1m\e[2mcandi:date7:t2\e[0m    \e[0m : test2
-                       (alias: candi:date7)
-END
+      spec "[!umjw5] add nothing if config is nil." do
+        schema = new_schema(nil)
+        ok {schema}.empty?
       end
 
     end
 
 
-    topic '#do_setup()' do
-
-      spec "[!pkio4] sets config object to '$cmdapp_config'." do
-        $cmdapp_config = nil
-        @app.__send__(:do_setup,)
-        ok {$cmdapp_config} != nil
-        ok {$cmdapp_config} == @app.config
-      end
+    topic '#reorder_options(*keys)' do
 
-      spec "[!qwjjv] sets application object to '$cmdapp_application'." do
-        $cmdapp_application = nil
-        @app.__send__(:do_setup,)
-        ok {$cmdapp_application} != nil
-        ok {$cmdapp_application} == @app
+      spec "[!2cp9s] sorts options in order of keys specified." do
+        config = Benry::CmdApp::Config.new("sample app", "1.2.3", option_debug: true)
+        schema = new_schema(config)
+        ok {schema.to_s} == <<'END'
+  -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
+      --debug    : debug mode
+END
+        #
+        schema.reorder_options(:list, :topic, :help, :all, :debug, :version)
+        ok {schema.to_s} == <<'END'
+  -l, --list     : list actions and aliases
+  -h, --help     : print help message (of action if specified)
+  -a, --all      : list hidden actions/options, too
+      --debug    : debug mode
+  -V, --version  : print version
+END
       end
 
-      spec "[!kqfn1] remove built-in 'help' action if `config.help_action == false`." do
-        ameta = Benry::CmdApp::INDEX.get_action("help")
-        ok {Benry::CmdApp::INDEX.action_exist?("help")} == true
-        begin
-          @config.help_action = false
-          @app.__send__(:do_setup,)
-          ok {Benry::CmdApp::INDEX.action_exist?("help")} == false
-        ensure
-          Benry::CmdApp::INDEX.register_action("help", ameta)
-        end
+      spec "[!xe7e1] moves options which are not included in specified keys to end of option list." do
+        config = Benry::CmdApp::Config.new("sample app", "1.2.3", option_debug: true)
+        schema = new_schema(config)
+        schema.reorder_options(:list, :help)
+        ok {schema.to_s} == <<'END'
+  -l, --list     : list actions and aliases
+  -h, --help     : print help message (of action if specified)
+  -V, --version  : print version
+  -a, --all      : list hidden actions/options, too
+      --debug    : debug mode
+END
       end
 
     end
 
 
-    topic '#do_teardown()' do
+  end
 
-      spec "[!zxeo7] clears '$cmdapp_config'." do
-        $cmdapp_config = "AAA"
-        @app.__send__(:do_teardown, nil)
-        ok {$cmdapp_config} == nil
-      end
 
-      spec "[!ufm1d] clears '$cmdapp_application'." do
-        $cmdapp_application = @app
-        @app.__send__(:do_teardown, nil)
-        ok {$cmdapp_application} == nil
+  topic Benry::CmdApp::MetadataRenderer do
+
+
+    topic '#render_metadata()' do
+
+      before do
+        reg = Benry::CmdApp::REGISTRY
+        @registry = Benry::CmdApp::Registry.new
+        r = @registry
+        r.metadata_add(reg.metadata_get("hello"))
+        r.metadata_add(Benry::CmdApp::AliasMetadata.new("hi", "hello", []))
+        r.category_add("cat:", "test category")
+        r.abbrev_add("c:", "cat:")
+      end
+
+      EXPECTED = <<'END'
+actions:
+  - action:    hello
+    desc:      "greeting message"
+    class:     MyAction
+    method:    hello
+    hidden:    false
+    paramstr:  "[<name>]"
+    parameters:
+      - param:   name
+        type:    opt
+      - param:   lang
+        type:    key
+    options:
+      - key:     lang
+        desc:    "language name (en/fr/it)"
+        optdef:  "-l, --lang=<lang>"
+        short:   l
+        long:    lang
+        param:   "<lang>"
+        paramreq: required
+        hidden:  false
+
+aliases:
+  - alias:     hi
+    desc:      "alias for 'hello'"
+    action:    hello
+
+categories:
+  - prefix:    "cat:"
+    count:     0
+    desc:      "test category"
+
+abbreviations:
+  - abbrev:    "c:"
+    prefix:    "cat:"
+END
+
+      spec "[!gduge] renders registry data in YAML format." do
+        renderer = Benry::CmdApp::MetadataRenderer.new(@registry)
+        yaml = renderer.render_metadata()
+        ok {yaml} == EXPECTED
       end
 
     end