benry-cmdapp 0.1.0 → 1.0.0

data/test/shared.rb

@@ -1,75 +1,138 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
 
-module CommonTestingHelper
+require 'oktest'
 
-  def uncolorize(str)
-    return str.gsub(/\e\[.*?m/, '')
+require 'benry/cmdapp'
+
+
+class MyAction < Benry::CmdApp::Action
+
+  @action.("greeting message")
+  @option.(:lang, "-l, --lang=<lang>", "language name (en/fr/it)")
+  def hello(name="world", lang: "en")
+    case lang
+    when "en"  ; puts "Hello, #{name}!"
+    when "fr"  ; puts "Bonjour, #{name}!"
+    when "it"  ; puts "Chao, #{name}!"
+    else
+      raise "#{lang}: unkown language"
+    end
   end
 
-  def without_tty(&block)
-    result = nil
-    capture_sio(tty: false) { result = yield }
-    return result
+  @action.("hidden action", hidden: true)
+  @option.(:val, "--val=<val>", "something value", hidden: true)
+  def debuginfo(val: nil)
+    puts "val: #{val.inspect}"
   end
 
-  def with_tty(&block)
-    result = nil
-    capture_sio(tty: true) { result = yield }
-    return result
+  @action.("raises ZeroDivisionError")
+  def testerr1()
+    1/0
   end
 
-  def with_important(keyval={}, &block)
-    bkup = {}
-    keyval.each do |name, val|
-      action = Benry::CmdApp::INDEX.get_action(name)
-      bkup[name] = action.important
-      action.instance_variable_set('@important', val)
-    end
-    begin
-      yield
-    ensure
-      bkup.each do |name, val|
-        action = Benry::CmdApp::INDEX.get_action(name)
-        action.instance_variable_set('@important', val)
-      end
-    end
+  @action.("looped action")
+  def testerr2()
+    run_once "testerr3"
+  end
+
+  @action.("looped action")
+  def testerr3()
+    run_action "testerr2"
   end
 
-  module_function
+end
+
+
+class GitAction < Benry::CmdApp::Action
+  category "git:"
 
-  def clear_index_except(klass)
-    actions = Benry::CmdApp::INDEX.instance_variable_get('@actions')
-    aliases = Benry::CmdApp::INDEX.instance_variable_get('@aliases')
-    @_bkup_actions = actions.dup()
-    actions.delete_if {|_, x| x.klass != klass }
-    anames = actions.keys()
-    @_bkup_aliases = aliases.dup()
-    aliases.delete_if {|_, x| ! anames.include?(x.action_name) }
+  @action.("same as `git add -p`")
+  def stage(*file)
+    puts "git add -p #{file.join(' ')}"
   end
 
-  def restore_index()
-    actions = Benry::CmdApp::INDEX.instance_variable_get('@actions')
-    aliases = Benry::CmdApp::INDEX.instance_variable_get('@aliases')
-    actions.update(@_bkup_actions)
-    aliases.update(@_bkup_aliases)
+  @action.("same as `git diff --cached`")
+  def staged()
+    puts "git diff --cached"
+  end
+
+  @action.("same as `git reset HEAD`")
+  def unstage()
+    puts "git reset HEAD"
+  end
+
+  private
+
+  @action.("same as `git commit --amend`")
+  def correct()
+    puts "git commit --amend"
   end
 
 end
 
 
-module ActionMetadataTestingHelper
-  include CommonTestingHelper
+class DeepPrefixAction < Benry::CmdApp::Action
+  category "giit:", "gitt commands" do
+
+    #@action.("show current status in compact format")
+    #def status()
+    #  sys "git status -sb"
+    #end
+
+    category "staging:" do
+      @action.("add changes into staging area")
+      def add(); end
+      @action.("show changes in staging area")
+      def show(); end
+      @action.("delete changes in staging area")
+      def delete(); end
+    end
+
+    category "commit:" do
+      @action.("list commits")
+      def list(); end
+    end
+
+    category "branch:" do
+      @action.("list branches")
+      def list(); end
+      @action.("switch branch")
+      def switch(name); end
+    end
+
+    category "repo:" do
+      @action.("create direcotry, move to it, and init repository")
+      def create(); end
+      @action.("initialize git repository with initial empty commit")
+      def init(); end
+
+      category "config:" do
+        @action.("add config of repository")
+        def add(); end
+        @action.("delete config of repository")
+        def delete(); end
+        @action.("list config of repository")
+        def list(); end
+      end
+
+      category "remote:" do
+        @action.("list remote repositories")
+        def list(); end
+        @action.("set remote repo url ('github:<user>/<proj>' available)")
+        def set(); end
+      end
+
+    end
 
-  def new_schema(lang: true)
-    schema = Benry::Cmdopt::Schema.new
-    schema.add(:lang, "-l, --lang=<en|fr|it>", "language") if lang
-    return schema
   end
 
-  def new_metadata(schema, meth=:halo1, **kwargs)
-    metadata = Benry::CmdApp::ActionMetadata.new(meth.to_s, MetadataTestAction, meth, "greeting", schema, **kwargs)
-    return metadata
+  category "md:", "markdown actions" do
+    @action.("create *.html", hidden: true)
+    def html(); end
+    @action.("create *.txt", hidden: true)
+    def txt(); end
   end
 
 end

data/test/util_test.rb

@@ -1,9 +1,22 @@
 # -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
-require 'oktest'
 
-require 'benry/cmdapp'
-require_relative './shared'
+require_relative 'shared'
+
+
+class UtilTestObject
+  def foo0(aa, bb, cc=0, dd=nil, *rest, xx: nil, yy: nil); end
+  def foo1(x); end
+  def foo2(x=0); end
+  def foo3(*x); end
+  def foo4(x, y=0, *z); end
+  def foo5(x: 0, y: nil); end
+  def foo6a(file, *file_); end
+  def foo6b(file=nil, *file_); end
+  def foo7a(file, *file2); end
+  def foo7b(file=nil, *file2); end
+end
 
 
 Oktest.scope do
@@ -12,172 +25,214 @@ Oktest.scope do
   topic Benry::CmdApp::Util do
 
 
-    topic '.hidden_name?()' do
+    topic '.#method2action()' do
+
+      spec "[!bt77a] converts method name (Symbol) to action name (String)." do
+        ok {Benry::CmdApp::Util.method2action(:foo)} == "foo"
+      end
 
-      spec "[!fcfic] returns true if name is '_foo'." do
-        ok {Benry::CmdApp::Util.hidden_name?("_foo")} == true
+      spec "[!o5822] converts `:foo_` into `'foo'`." do
+        ok {Benry::CmdApp::Util.method2action(:foo_)} == "foo"
       end
 
-      spec "[!po5co] returns true if name is '_foo:bar'." do
-        ok {Benry::CmdApp::Util.hidden_name?("_foo:bar")} == true
+      spec "[!msgjc] converts `:aa__bb____cc` into `'aa:bb:cc'`." do
+        ok {Benry::CmdApp::Util.method2action(:aa__bb__cc)}     == "aa:bb:cc"
+        ok {Benry::CmdApp::Util.method2action(:aa____bb____cc)} == "aa:bb:cc"
+        ok {Benry::CmdApp::Util.method2action(:aa__bb____cc)}   == "aa:bb:cc"
       end
 
-      spec "[!9iqz3] returns true if name is 'foo:_bar'." do
-        ok {Benry::CmdApp::Util.hidden_name?("foo:_bar")} == true
+      spec "[!qmkfv] converts `:aa_bb_cc` into `'aa-bb-cc'`." do
+        ok {Benry::CmdApp::Util.method2action(:aa__bb__cc)} == "aa:bb:cc"
       end
 
-      spec "[!mjjbg] returns false if else." do
-        ok {Benry::CmdApp::Util.hidden_name?("foo")} == false
-        ok {Benry::CmdApp::Util.hidden_name?("foo_")} == false
-        ok {Benry::CmdApp::Util.hidden_name?("foo_:bar")} == false
-        ok {Benry::CmdApp::Util.hidden_name?("foo:bar_")} == false
+      spec "[!tvczb] converts `:_aa_bb:_cc_dd:_ee` into `'_aa-bb:_cc-dd:_ee'`." do
+        ok {Benry::CmdApp::Util.method2action("_aa_bb:_cc_dd:_ee")} == "_aa-bb:_cc-dd:_ee"
       end
 
     end
 
 
-    topic '.schema_empty?()' do
+    topic '.#method2help()' do
 
-      spec "[!8t5ju] returns true if schema empty." do
-        sc = Benry::CmdOpt::Schema.new
-        ok {Benry::CmdApp::Util.schema_empty?(sc)} == true
-        sc.add(:help, "-h", "help")
-        ok {Benry::CmdApp::Util.schema_empty?(sc)} == false
+      before do
+        @obj = UtilTestObject.new
       end
 
-      spec "[!c4ljy] returns true if schema contains only private (hidden) options." do
-        sc = Benry::CmdOpt::Schema.new
-        sc.add(:_help, "-h", "help")
-        ok {Benry::CmdApp::Util.schema_empty?(sc)} == true
-        sc.add(:version, "-V", "version")
-        ok {Benry::CmdApp::Util.schema_empty?(sc)} == false
+      spec "[!q3y3a] returns command argument string which represents method parameters." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo0)} == " <aa> <bb> [<cc> [<dd> [<rest>...]]]"
       end
 
-    end
+      spec "[!r6u58] converts `.foo(x)` into `' <x>'`." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo1)} == " <x>"
+      end
+
+      spec "[!8be14] converts `.foo(x=0)` into `' [<x>]'`." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo2)} == " [<x>]"
+      end
 
+      spec "[!skofc] converts `.foo(*x)` into `' [<x>...]'`." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo3)} == " [<x>...]"
+      end
 
-    topic '.method2action()' do
+      spec "[!61xy6] converts `.foo(x, y=0, *z)` into `' <x> [<y> [<z>...]]'`." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo4)} == " <x> [<y> [<z>...]]"
+      end
 
-      spec "[!801f9] converts action name 'aa_bb_cc_' into 'aa_bb_cc'." do
-        ok {Benry::CmdApp::Util.method2action("aa_")} == "aa"
-        ok {Benry::CmdApp::Util.method2action("_aa_")} == "_aa"
+      spec "[!0342t] ignores keyword parameters." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo5)} == ""
       end
 
-      spec "[!9pahu] converts action name 'aa__bb__cc' into 'aa:bb:cc'." do
-        ok {Benry::CmdApp::Util.method2action("aa__bb__cc")} == "aa:bb:cc"
+      spec "[!mbxy5] converts `.foo(x, *x_)` into `' <x>...'`." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo6a)} == " <file>..."
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo6b)} == " [<file>...]"
       end
 
-      spec "[!7a1s7] converts action name 'aa_bb:_cc_dd' into 'aa-bb:_cc-dd'." do
-        ok {Benry::CmdApp::Util.method2action("aa_bb:cc_dd")} == "aa-bb:cc-dd"
-        ok {Benry::CmdApp::Util.method2action("aa_bb:_cc_dd")} == "aa-bb:_cc-dd"
-        ok {Benry::CmdApp::Util.method2action("aa___bb")} == "aa:_bb"
+      spec "[!mh9ni] converts `.foo(x, *x2)` into `' <x>...'`." do
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo7a)} == " <file>..."
+        ok {Benry::CmdApp::Util.method2help(@obj, :foo7b)} == " [<file>...]"
       end
 
     end
 
 
-    topic '.colorize?()' do
+    topic '.#param2arg()' do
 
-      spec "[!801y1] returns $COLOR_MODE value if it is not nil." do
-        bkup = $COLOR_MODE
-        begin
-          $COLOR_MODE = true
-          ok {Benry::CmdApp::Util.colorize?()} == true
-          $COLOR_MODE = false
-          ok {Benry::CmdApp::Util.colorize?()} == false
-        ensure
-          $COLOR_MODE = bkup
-        end
+      spec "[!ahvsn] converts parameter name (Symbol) into argument name (String)." do
+        ok {Benry::CmdApp::Util.param2arg(:foo)} == "foo"
       end
 
-      spec "[!0harg] returns true if stdout is a tty." do
-        capture_sio(tty: true) {
-          ok {Benry::CmdApp::Util.colorize?()} == true
-        }
+      spec "[!27dpw] converts `:aa_or_bb_or_cc` into `'aa|bb|cc'`." do
+        ok {Benry::CmdApp::Util.param2arg(:aa_or_bb_or_cc)} == "aa|bb|cc"
       end
 
-      spec "[!u1j1x] returns false if stdout is not a tty." do
-        capture_sio(tty: false) {
-          ok {Benry::CmdApp::Util.colorize?()} == false
-        }
+      spec "[!to41h] converts `:aa__bb__cc` into `'aa.bb.cc'`." do
+        ok {Benry::CmdApp::Util.param2arg(:aa__bb__cc)} == "aa.bb.cc"
+      end
+
+      spec "[!2ma08] converts `:aa_bb_cc` into `'aa-bb-cc'`." do
+        ok {Benry::CmdApp::Util.param2arg(:aa_bb_cc)} == "aa-bb-cc"
       end
 
     end
 
 
-    topic '.del_escape_seq()' do
+    topic '.#validate_args_and_kwargs()' do
 
-      spec "[!wgp2b] deletes escape sequence." do
-        s = "  \e[1m%-18s\e[0m : %s"
-        ok {Benry::CmdApp::Util.del_escape_seq(s)} == "  %-18s : %s"
+      spec "[!jalnr] returns error message if argument required but no args specified." do
+        def g1(x); end
+        errmsg = Benry::CmdApp::Util.validate_args_and_kwargs(self, :g1, [], {})
+        ok {errmsg} == "Argument required (but nothing specified)."
       end
 
-    end
-
+      spec "[!gv6ow] returns error message if too less arguments." do
+        def g2(x, y); end
+        errmsg = Benry::CmdApp::Util.validate_args_and_kwargs(self, :g2, ["A"], {})
+        ok {errmsg} == "Too less arguments (at least 2 args)."
+      end
 
-    topic '._important?()' do
+      spec "[!q5rp3] returns error message if argument specified but no args expected." do
+        def g3(); end
+        errmsg = Benry::CmdApp::Util.validate_args_and_kwargs(self, :g3, ["A"], {})
+        ok {errmsg} == %q|"A": Unexpected argument (expected no args).|
+      end
 
-      spec "[!0yz2h] returns nil if tag == nil." do
-        ok {Benry::CmdApp::Util._important?(nil)} == nil
+      spec "[!dewkt] returns error message if too much arguments specified." do
+        def g4(x); end
+        errmsg = Benry::CmdApp::Util.validate_args_and_kwargs(self, :g4, ["A", "B"], {})
+        ok {errmsg} == "Too much arguments (at most 1 args)."
       end
 
-      spec "[!h5pid] returns true if tag == :important." do
-        ok {Benry::CmdApp::Util._important?(:important)} == true
-        ok {Benry::CmdApp::Util._important?("important")} == true
+      spec "[!u7wgm] returns error message if unknown keyword argument specified." do
+        def g5(x: 0); end
+        errmsg = Benry::CmdApp::Util.validate_args_and_kwargs(self, :g5, [], {y: "abc"})
+        ok {errmsg} == "y: Unknown keyword argument."
       end
 
-      spec "[!7zval] returns false if tag == :unimportant." do
-        ok {Benry::CmdApp::Util._important?(:unimportant)} == false
-        ok {Benry::CmdApp::Util._important?("unimportant")} == false
+      spec "[!2ep76] returns nil if no error found." do
+        def g6(x, y=nil, z: 0); end
+        errmsg = Benry::CmdApp::Util.validate_args_and_kwargs(self, :g6, ["A", "B"], {z: "abc"})
+        ok {errmsg} == nil
       end
 
-      spec "[!z1ygi] supports nested tag." do
-        ok {Benry::CmdApp::Util._important?([:important, :foo])} == true
-        ok {Benry::CmdApp::Util._important?([:bar, :unimportant])} == false
+    end
+
+
+    topic '.#delete_escape_chars()' do
+
+      spec "[!snl3e] removes escape chars from string." do
+        s = "\e[1;34mUsage:\e[0m (default: help)"
+        x = Benry::CmdApp::Util.delete_escape_chars(s)
+        ok {x} == "Usage: (default: help)"
       end
 
     end
 
 
-    topic '.format_help_line()' do
+    topic '.#color_mode?()' do
+
+      spec "[!xyta1] returns value of $COLOR_MODE if it is not nil." do
+        bkup = $COLOR_MODE
+        at_end { $COLOR_MODE = bkup }
+        #
+        $COLOR_MODE = true
+        ok {Benry::CmdApp::Util.color_mode?} == true
+        $COLOR_MODE = false
+        ok {Benry::CmdApp::Util.color_mode?} == false
+      end
 
-      fixture :format do
-        "  [[%-10s]] : %s"
+      spec "[!8xufh] returns value of $stdout.tty? if $COLOR_MODE is nil." do
+        bkup = $COLOR_MODE
+        at_end { $COLOR_MODE = bkup }
+        #
+        $COLOR_MODE = nil
+        x = nil
+        capture_sio(tty: true) { x = Benry::CmdApp::Util.color_mode? }
+        ok {x} == true
+        capture_sio(tty: false) { x = Benry::CmdApp::Util.color_mode? }
+        ok {x} == false
       end
 
-      spec "[!xx1vj] if `important == nil` then format help line with no decoration." do
-        |format|
-        s = Benry::CmdApp::Util.format_help_line(format, "<action>", "<desc>", nil)
-        ok {s} == "  [[<action>  ]] : <desc>"
+    end
+
+
+    topic '.#method_override?()' do
+
+      class DummyA
+        def f1(); end
+      end
+      module DummyB
+        def f2(); end
+      end
+      class DummyC < DummyA
+        include DummyB
+        def f3(); end
       end
 
-      spec "[!oaxp1] if `important == true` then format help line with strong decoration." do
-        |format|
-        s = Benry::CmdApp::Util.format_help_line(format, "<action>", "<desc>", true)
-        ok {s} == "  [[\e[4m<action>\e[0m  ]] : <desc>"
+      spec "[!ldd1x] returns true if method defined in parent or ancestor classes." do
+        ok {Benry::CmdApp::Util.method_override?(DummyC, :f1)} == true
+        ok {Benry::CmdApp::Util.method_override?(DummyC, :f2)} == true
+        ok {Benry::CmdApp::Util.method_override?(DummyC, :print)} == true
       end
 
-      spec "[!bdhh6] if `important == false` then format help line with weak decoration." do
-        |format|
-        s = Benry::CmdApp::Util.format_help_line(format, "<action>", "<desc>", false)
-        ok {s} == "  [[\e[2m<action>\e[0m  ]] : <desc>"
+      spec "[!bc65v] returns false if meethod not defined in parent nor ancestor classes." do
+        ok {Benry::CmdApp::Util.method_override?(DummyC, :f3)} == false
+        ok {Benry::CmdApp::Util.method_override?(DummyC, :hoge)} == false
       end
 
     end
 
 
-    topic '.fill_with_decoration()' do
+    topic '.#name_should_be_a_string()' do
 
-      spec "[!udrbj] returns decorated string with padding by white spaces." do
-        format = "  [[%-10s]] : %s"
-        s = Benry::CmdApp::Util.fill_with_decoration(format, "<action>") {|s| "\e[1m#{s}\e[0m" }
-        ok {s} == "\e[1m<action>\e[0m  "
+      spec "[!9j4d0] do nothing if name is a string." do
+        x = Benry::CmdApp::Util.name_should_be_a_string("hello", "Action", Benry::CmdApp::DefinitionError)
+        ok {x} == nil
       end
 
-      spec "[!7bl2b] considers minus sign in format." do
-        format = "  [[%10s]] : %s"
-        s = Benry::CmdApp::Util.fill_with_decoration(format, "<action>") {|s| "\e[1m#{s}\e[0m" }
-        ok {s} == "  \e[1m<action>\e[0m"
+      spec "[!a2n8y] raises error if name is not a string." do
+        pr = proc { Benry::CmdApp::Util.name_should_be_a_string(:hello, "Action", Benry::CmdApp::DefinitionError) }
+        ok {pr}.raise?(Benry::CmdApp::DefinitionError,
+                       "`:hello`: Action name should be a string, but got Symbol object.")
       end
 
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: benry-cmdapp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - kwatch
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-12 00:00:00.000000000 Z
+date: 2023-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benry-cmdopt
@@ -17,6 +17,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.0
 - !ruby/object:Gem::Dependency
   name: oktest
   requirement: !ruby/object:Gem::Requirement
@@ -58,12 +64,16 @@ files:
 - doc/benry-cmdapp.html
 - doc/css/style.css
 - lib/benry/cmdapp.rb
-- test/action_test.rb
 - test/app_test.rb
+- test/config_test.rb
+- test/context_test.rb
 - test/func_test.rb
 - test/help_test.rb
-- test/index_test.rb
+- test/metadata_test.rb
+- test/misc_test.rb
+- test/registry_test.rb
 - test/run_all.rb
+- test/scope_test.rb
 - test/shared.rb
 - test/util_test.rb
 homepage: https://kwatch.github.io/benry-ruby/benry-cmdapp.html
@@ -88,11 +98,15 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: Command-line application framework`
+summary: Command-line application framework
 test_files:
-- test/action_test.rb
 - test/app_test.rb
+- test/config_test.rb
+- test/context_test.rb
 - test/func_test.rb
 - test/help_test.rb
-- test/index_test.rb
+- test/metadata_test.rb
+- test/misc_test.rb
+- test/registry_test.rb
+- test/scope_test.rb
 - test/util_test.rb