cli_class_tool 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b709fe8b17a110ea17968fb9d7d4ff45e2ceac57bed76c3dcda67438880dcdc4
-  data.tar.gz: 1ff6831f0c5bfbc9d54d8dac31e18fdad3003ec0d527bfb3999e11a472b1591b
+  metadata.gz: 46f243576af73a6b5e4b56a097e4876377f2f4b0b2871ea013955d6eb75addd0
+  data.tar.gz: c44bcb2a54d9f1c3e9d5c19543805ba16f0bd224f5ece98acb02da3be071bf31
 SHA512:
-  metadata.gz: f408128eb985f8ad45949c452be46aa55edc028f1dc060c2870afdbea358016258071e0cc8aadf155e867c0f8e7be4295e8045c699eb0f82c501feaeb9b7502b
-  data.tar.gz: 75d8bbfd502b9a331be9c57e25b7f824b2bf1d24c94f6fe477f64f2078dde1a76911b4964b0bdcf531098f895a753556778571f0a4354e1d2b733b1fedc56212
+  metadata.gz: 2d04141ca190c6a98bd4481156708c9fbff7f9550324bee3612c283959ad94b90efaf33484fd77b6425f3320ecf6e2e8996422e307506f837f07785267cf5686
+  data.tar.gz: 761917986fb8e915fc189e2d4cee710bd39ac44c968b421cca4ee65affd0d07ec7de9455a3e46e15beb1ee09110e966c72bc2be01e9746254256e50067308d88

data/CHANGELOG

@@ -1,7 +1,21 @@
 ------------------
-0.3.0  (2026-06-02)
+0.4.1  (2026-06-05)
+------------------
+
+* Fix definition on RunError
+* In DEBUG=1 mode, run() call stack depth can be tuned with DEBUG_CALL_STACK=<n>
+
+------------------
+0.4.0  (2026-06-05)
 ------------------
 
+* Add basic initializer for Common
+* Add Common::run() that will auto spawn a Common object and run the command with it.
+* log function can now be used in alternate object or class by including/extending CLIClassTool::Logger
+
+------------------
+0.3.0  (2026-06-02)
+------------------
 
 * Enforce module/class namespaces for all action classes (potentially breaking change)
 * Support automatic project-specific `RunError` generation with customized base error inheritance

data/lib/cli_class_tool/common.rb

@@ -1,39 +1,9 @@
 # Main module for generic CLI class-based tools and utilities
 module CLIClassTool
 
-    # Common utility class providing logging, configuration, and shell execution methods
-    class Common
-        # Hook to enforce namespace loading at load time
-        def self.inherited(subclass)
-            if subclass.name
-                parts = subclass.name.to_s.split('::')
-                if parts.size <= 1
-                    raise "CLIClassTool action classes must be defined within a named module/class namespace"
-                end
-            end
-        end
-
-        # List of available actions for this class
-        ACTION_LIST = [ :list_actions ]
-        # Help text for actions
-        ACTION_HELP = {}
-
+    # Logger for CLIClassTool::Common
+    module Logger
         private
-        # Get the parent module of this class (e.g. KernelWork or XXX)
-        def parent_module
-            @parent_module ||= begin
-                if self.class.name.nil?
-                    Object
-                else
-                    parts = self.class.name.split('::')
-                    if parts.size <= 1
-                        raise "CLIClassTool action classes must be defined within a named module/class namespace"
-                    end
-                    Object.const_get(parts[0...-1].join('::'))
-                end
-            end
-        end
-
         # Internal log method
         # @param lvl [String] Log level string (colored)
         # @param str [String] Message
@@ -50,28 +20,34 @@ module CLIClassTool
             out.print("# " + lvl.to_s() + ": " + str + "\r")
         end
 
-        # Raise error if system command failed
-        # @param check_err [Boolean] Whether to check for errors
-        # @param sysret [Process::Status] System return status
-        # @param ret [String, nil] Optional return message
+        # Compute the parent module of an object or a class
+        #
+        # @param obj [Object,Class] Object or class to get the Module from
         # @raise [StandardError] If command failed
-        def abort_if_err(check_err, sysret, ret = nil)
-            if sysret.exitstatus != 0 && check_err == true
-                unless parent_module.const_defined?(:RunError)
-                    raise "CLIClassTool parent module #{parent_module} must extend CLIClassTool::Utils to define RunError"
+        def obj_to_parent_mod(obj)
+            return obj if obj.class == Module
+
+            theClass = obj.is_a?(Class) ? obj : obj.class
+            if theClass.name.nil?
+                return Object
+            else
+                parts = theClass.name.split('::')
+                if parts.size <= 1
+                    raise "CLIClassTool action classes must be defined within a named module/class namespace"
                 end
-                raise(parent_module::RunError.new(sysret.exitstatus, ret))
+                return Object.const_get(parts[0...-1].join('::'))
             end
         end
 
-        # Debug command execution
-        # @param cmd_type [String] Type of command (e.g., 'git')
-        # @param cmd [String] The command string
-        def cmd_debug(cmd_type, cmd)
-            log(:DEBUG, "Called from #{caller[1]}")
-            log(:DEBUG, "Running #{cmd_type} command '#{cmd}'")
+        # Get the parent module of this class (e.g. KernelWork or XXX)
+        def parent_module
+            return @parent_module if @parent_module != nil
+
+            @parent_module = obj_to_parent_mod(self)
+            return @parent_module
         end
-        protected
+
+        public
         # Log a message with a specific level
         #
         # @param lvl [Symbol] Log level (:DEBUG, :INFO, :WARNING, :ERROR, etc.)
@@ -121,8 +97,68 @@ module CLIClassTool
             end
             return rep
         end
+    end
+
+    # Common utility class providing logging, configuration, and shell execution methods
+    class Common
+        # Hook to enforce namespace loading at load time
+        def self.inherited(subclass)
+            if subclass.name
+                parts = subclass.name.to_s.split('::')
+                if parts.size <= 1
+                    raise "CLIClassTool action classes must be defined within a named module/class namespace"
+                end
+            end
+        end
+
+        # List of available actions for this class
+        ACTION_LIST = [ :list_actions ]
+        # Help text for actions
+        ACTION_HELP = {}
+
+        # Give the Logger mathods to Common
+        include CLIClassTool::Logger
+
+        private
+        # Raise error if system command failed
+        # @param check_err [Boolean] Whether to check for errors
+        # @param sysret [Process::Status] System return status
+        # @param ret [String, nil] Optional return message
+        # @raise [StandardError] If command failed
+        def abort_if_err(check_err, sysret, ret = nil)
+            if sysret.exitstatus != 0 && check_err == true
+                unless parent_module.const_defined?(:RunError)
+                    raise "CLIClassTool parent module #{parent_module} must extend CLIClassTool::Utils to define RunError"
+                end
+                raise(parent_module::RunError.new(sysret.exitstatus, ret))
+            end
+        end
+
+        # Debug command execution
+        # @param cmd_type [String] Type of command (e.g., 'git')
+        # @param cmd [String] The command string
+        def cmd_debug(cmd_type, cmd)
+            log(:DEBUG, "Called from:")
+            depth=1
+            if ENV["DEBUG_CALL_DEPTH"].to_s() != ""
+                depth = ENV["DEBUG_CALL_DEPTH"].to_i()
+            end
+            [ depth, caller.length].min.downto(1){|x|
+                log(:DEBUG, " #{caller[x]}")
+            }
+            log(:DEBUG, "Running #{cmd_type} command '#{cmd}'")
+        end
+
 
         public
+        # Simple initializer for a Common object
+        #
+        # @param path [String] Path to run commands from
+        def initialize(path=".", caller_obj=self)
+            @path = path
+            @parent_module = obj_to_parent_mod(caller_obj)
+        end
+
         # Run a shell command
         #
         # @param cmd [String] Command to run
@@ -136,6 +172,10 @@ module CLIClassTool
             return ret
         end
 
+        def self.run(path, cmd, check_err = true)
+            obj = Common.new(path, self)
+            return obj.run(cmd, check_err)
+        end
         # Run a shell command using system() (interactive)
         #
         # @param cmd [String] Command to run

data/lib/cli_class_tool/utils.rb

@@ -4,17 +4,16 @@ module CLIClassTool
 
         # Hook called when a module extends CLIClassTool::Utils
         def self.extended(base)
-            possible_name = base.name ? "#{base.name}Error" : nil
+            return if base == nil
 
-            superclass = if possible_name && Object.const_defined?(possible_name)
-                Object.const_get(possible_name)
-            elsif base.const_defined?(:Error)
-                base.const_get(:Error)
-            else
-                CLIClassTool::RunError
+            lower_mod = base.name.split('::')[-1]
+            superclass_name = "#{base.name}::#{lower_mod}Error"
+
+            if ! Object.const_defined?(superclass_name)
+                raise("Could not find a base error class named #{superclass_name}")
             end
 
-            CLIClassTool.define_run_error(base, superclass)
+            CLIClassTool.define_run_error(base, Object.const_get(superclass_name))
         end
 
         # Convert a string to an action symbol, validating it against available actions
@@ -117,14 +116,10 @@ module CLIClassTool
 
             self._runOnClass(action, nil) {|kClass|
                 begin
-                    # Some class have their own execAction, because object creation might be tricky.
-                    if kClass.respond_to?(:execAction)
-                        ret = kClass.execAction(opts, action)
-                    else
-                        # Use load factory method if defined, else fall back to .new
-                        obj = kClass.respond_to?(:load) ? kClass.load() : kClass.new()
-                        ret = obj.public_send(action, opts)
-                    end
+                    # Use load factory method if defined, else fall back to .new
+                    obj = kClass.respond_to?(:load) ? kClass.load() : kClass.new()
+                    ret = obj.public_send(action, opts)
+
                     return ret.is_a?(Integer) ? ret : 0
                 rescue caught_error_class => e
                     puts("# " + "ERROR".red().to_s() + ": Action '#{action}' failed: #{e.message}")

data/lib/cli_class_tool.rb

@@ -1,31 +1,19 @@
 module CLIClassTool
-  class RunError < StandardError
-    attr_reader :err_code, :output
+    def self.define_run_error(parent_module, superclass)
+        klass = Class.new(superclass)
 
-    def initialize(err_code, output = nil)
-      @err_code = err_code
-      @output = output
-      super("Command failed with exit status #{err_code}#{output ? "\n#{output}" : ''}")
-    end
-  end
-
-  def self.define_run_error(parent_module, superclass = CLIClassTool::RunError)
-    klass = Class.new(superclass)
-
-    if !(superclass <= CLIClassTool::RunError)
-      klass.class_eval do
-        attr_reader :err_code, :output
+        klass.class_eval do
+            attr_reader :err_code, :msg
 
-        def initialize(err_code, output = nil)
-          @err_code = err_code
-          @output = output
-          super("Command failed with exit status #{err_code}#{output ? "\n#{output}" : ''}")
+            def initialize(err_code, output = nil)
+                @err_code = err_code
+                @msg = output
+                super("Command failed with exit status #{err_code}")
+            end
         end
-      end
+        parent_module.const_set(:RunError, klass)
     end
 
-    parent_module.const_set(:RunError, klass)
-  end
 end
 
 require_relative 'cli_class_tool/string'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: cli_class_tool
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Nicolas Morey
 bindir: bin
 cert_chain: []
-date: 2026-06-02 00:00:00.000000000 Z
+date: 2026-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake