Refactor: DRY up codebase and reduce complexity

- BlockDSL: replace manual delegation with method_missing
- Unify command method via command_base_for hook (CommandDSL + Tool)
- Extract long_flag/short_flag/signature onto OptionDefinition
- HelpFormatter: self-managing sections, remove option_signature
- derive_command_name: use demodulize/underscore from core_ext
- Runner: resolve aliases via terms, add find_subcommand
- Tool#start: collapse rescue chain to Athena::Error
- Util::Formatting: extend self instead of self. prefix
- Condense getter/setter DSL methods to ternaries

Author: voltechs

lib/athena/command.rb

@@ -45,13 +45,9 @@ def inherited(subclass)
 
       def derive_command_name
         return nil if self == Command || abstract_class?
-        base = name&.split("::")&.last
+        base = name&.demodulize
         return nil unless base
-        base.gsub(/Command$/, "")
-            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-            .downcase
-            .to_sym
+        base.sub(/Command$/, "").underscore.to_sym
       end
 
       def register_subcommand(subclass)

lib/athena/dsl/block_dsl.rb

@@ -2,41 +2,26 @@
 
 module Athena
   module DSL
-    # Evaluation context for block-based command definitions.
-    # Translates block DSL calls into class-level DSL calls on the
-    # underlying Command subclass.
     class BlockDSL
       def initialize(command_class)
         @command_class = command_class
       end
 
-      def description(text)
-        @command_class.description(text)
-      end
-
-      def aliases(*names)
-        @command_class.aliases(*names)
-      end
-
-      def option(name, type = nil, **opts)
-        @command_class.option(name, type, **opts)
-      end
-
-      def flag(name, **opts)
-        @command_class.flag(name, **opts)
+      def run(&block)
+        @command_class.define_method(:run) { |*args| instance_exec(*args, &block) }
       end
 
-      def argument(name, type = String, **opts)
-        @command_class.argument(name, type, **opts)
-      end
+      private
 
-      def command(name, **opts, &block)
-        @command_class.command(name, **opts, &block)
+      def respond_to_missing?(name, include_private = false)
+        @command_class.respond_to?(name) || super
       end
 
-      def run(&block)
-        @command_class.define_method(:run) do |*args|
-          instance_exec(*args, &block)
+      def method_missing(name, *args, **opts, &block)
+        if @command_class.respond_to?(name)
+          @command_class.public_send(name, *args, **opts, &block)
+        else
+          super
         end
       end
     end

lib/athena/dsl/command_dsl.rb

@@ -2,23 +2,13 @@
 
 module Athena
   module DSL
-    # Class-level DSL methods extended into Athena::Command.
-    # These are called during class body evaluation.
     module CommandDSL
       def description(text = nil)
-        if text
-          @description = text
-        else
-          @description || ""
-        end
+        text ? (@description = text) : (@description || "")
       end
 
       def aliases(*names)
-        if names.any?
-          @aliases = names.flatten.map(&:to_sym)
-        else
-          @aliases || []
-        end
+        names.any? ? (@aliases = names.flatten.map(&:to_sym)) : (@aliases || [])
       end
 
       def option(name, type = nil, short: nil, description: nil, default: nil, required: false)
@@ -38,21 +28,23 @@ def argument(name, type = String, description: nil, required: true, default: nil
         )
       end
 
-      # Block-based subcommand definition.
-      # Creates an anonymous Command subclass, evaluates the block, and
-      # registers it as a subcommand of the receiver.
       def command(name, aliases: [], &block)
-        klass = Class.new(self)
+        klass = Class.new(command_base_for(name))
         klass.command_name = name.to_sym
         klass.aliases(*aliases) if aliases.any?
 
-        # Give it a const name for inspect/debugging
         const_name = name.to_s.split("_").map(&:capitalize).join
         const_set(const_name, klass) if const_name.match?(/\A[A-Z]/)
 
-        Athena::DSL::BlockDSL.new(klass).instance_eval(&block) if block
+        BlockDSL.new(klass).instance_eval(&block) if block
         klass
       end
+
+      private
+
+      def command_base_for(_name)
+        self
+      end
     end
   end
 end

lib/athena/help_formatter.rb

@@ -10,28 +10,29 @@ def initialize(command_class, command_path: [])
     end
 
     def format
-      lines = []
-      lines << description_section if command_class.description.present?
-      lines << version_section if command_class.respond_to?(:version) && command_class.version
-      lines << usage_section
-      lines << subcommands_section if command_class.subcommands.any?
-      lines << options_section if command_class.option_definitions.any?
-      lines << arguments_section if command_class.argument_definitions.any?
-      lines.compact.join("\n\n") + "\n"
+      [
+        description_section,
+        version_section,
+        usage_section,
+        subcommands_section,
+        options_section,
+        arguments_section
+      ].compact.join("\n\n") + "\n"
     end
 
     private
 
     def description_section
-      command_class.description
+      desc = command_class.description
+      desc if desc.present?
     end
 
     def version_section
-      "Version: #{command_class.version.to_s.light_blue}"
+      ver = command_class.respond_to?(:version) && command_class.version
+      "Version: #{ver.to_s.light_blue}" if ver
     end
 
     def usage_section
-      parts = ["Usage:".light_cyan]
       path = command_path.any? ? command_path.join(" ") : command_class.command_name.to_s
       usage = path.light_red
       usage += " [options]".light_cyan if command_class.option_definitions.any?
@@ -40,13 +41,12 @@ def usage_section
         label = arg.required ? "<#{arg.name}>" : "[#{arg.name}]"
         usage += " #{label}".light_yellow
       end
-      parts << usage
-      parts.join(" ")
+      "Usage:".light_cyan + " " + usage
     end
 
     def subcommands_section
       subs = command_class.subcommands
-      return nil if subs.empty?
+      return if subs.empty?
 
       max_width = subs.keys.map { |k| k.to_s.length }.max
       Util::Formatting.reset_colors!
@@ -68,13 +68,13 @@ def subcommands_section
 
     def options_section
       opts = command_class.option_definitions
-      return nil if opts.empty?
+      return if opts.empty?
 
-      max_width = opts.values.map { |o| option_signature(o).length }.max
+      max_width = opts.values.map { |o| o.signature.length }.max
 
       lines = ["Options:".light_cyan]
       opts.each_value do |opt|
-        sig = option_signature(opt).ljust(max_width + 2)
+        sig = opt.signature.ljust(max_width + 2)
         desc = opt.description || ""
         default_note = opt.default_value ? " (default: #{opt.default_value})".light_black : ""
         lines << "  #{sig.light_green} #{desc}#{default_note}"
@@ -84,7 +84,7 @@ def options_section
 
     def arguments_section
       args = command_class.argument_definitions
-      return nil if args.empty?
+      return if args.empty?
 
       max_width = args.map { |a| a.name.to_s.length }.max
 
@@ -97,14 +97,5 @@ def arguments_section
       end
       lines.join("\n")
     end
-
-    def option_signature(opt)
-      parts = []
-      parts << "-#{opt.short}," if opt.short
-      long = "--#{opt.name.to_s.tr('_', '-')}"
-      long += "=VALUE" unless opt.boolean?
-      parts << long
-      parts.join(" ")
-    end
   end
 end

lib/athena/option_definition.rb

@@ -21,20 +21,26 @@ def default_value
       boolean? ? (default.nil? ? false : default) : default
     end
 
-    # Register this option with a stdlib OptionParser instance.
-    # When the option is encountered, its value is stored in +store+.
+    def long_flag
+      flag = "--#{name.to_s.tr('_', '-')}"
+      flag += "=VALUE" unless boolean?
+      flag
+    end
+
+    def short_flag
+      "-#{short}" if short
+    end
+
+    def signature
+      [("#{short_flag}," if short), long_flag].compact.join(" ")
+    end
+
     def attach(parser, store)
-      args = []
-      args << "-#{short}" if short
-      long_flag = "--#{name.to_s.tr('_', '-')}"
-      long_flag += "=VALUE" unless boolean?
-      args << long_flag
+      args = [short_flag, long_flag].compact
       args << type if type && !boolean?
       args << description if description
 
-      parser.on(*args) do |value|
-        store[name] = value
-      end
+      parser.on(*args) { |value| store[name] = value }
     end
   end
 end

lib/athena/runner.rb

@@ -9,7 +9,6 @@ def initialize(root, argv)
       @argv = argv.dup
     end
 
-    # Resolve the ARGV to a command class, instantiate, and run.
     def execute
       command_class, remaining, path = resolve(root, argv)
 
@@ -24,8 +23,7 @@ def execute
       end
 
       instance = command_class.new(remaining)
-      args = instance.args
-      instance.run(*args)
+      instance.run(*instance.args)
     end
 
     private
@@ -38,24 +36,25 @@ def version_requested?(args)
       args.include?("--version") || args.include?("-V")
     end
 
-    # Walk the command tree, consuming subcommand tokens from argv.
-    # Returns [CommandClass, remaining_argv, command_path].
     def resolve(command_class, args, path = [])
       path << (command_class.command_name || command_class.name || "command").to_s
       return [command_class, args, path] if args.empty?
 
       token = args.first
-
-      # Don't treat flags as subcommand names
       return [command_class, args, path] if token.start_with?("-")
 
-      sub = command_class.subcommands[token.to_sym]
+      sub = find_subcommand(command_class, token.to_sym)
       if sub
         args.shift
         resolve(sub, args, path)
       else
         [command_class, args, path]
       end
     end
+
+    def find_subcommand(command_class, token)
+      command_class.subcommands[token] ||
+        command_class.subcommands.each_value.find { |cmd| cmd.terms.include?(token) }
+    end
   end
 end

lib/athena/tool.rb

@@ -15,34 +15,19 @@ def command_class(klass = nil)
       end
 
       def tool_name(name = nil)
-        if name
-          self.command_name = name
-        else
-          command_name
-        end
+        name ? (self.command_name = name) : command_name
       end
 
       def version(ver = nil)
-        if ver
-          @version = ver
-        else
-          @version
-        end
+        ver ? (@version = ver) : @version
       end
 
       def start(argv = ARGV)
-        runner = Runner.new(self, argv.dup)
-        runner.execute
+        Runner.new(self, argv.dup).execute
       rescue Interrupt
         $stderr.puts "\nAborted."
         exit 130
-      rescue CommandNotFound => e
-        $stderr.puts e.message
-        exit 1
-      rescue MissingArgument => e
-        $stderr.puts e.message
-        exit 1
-      rescue AbstractCommand => e
+      rescue Athena::Error => e
         $stderr.puts e.message
         exit 1
       end
@@ -60,6 +45,10 @@ def inherited(subclass)
 
       private
 
+      def command_base_for(_name)
+        command_class || self
+      end
+
       def create_command_base(tool_subclass)
         return if tool_subclass.command_class
 
@@ -75,26 +64,22 @@ def wire_command_class(klass)
 
         klass.define_singleton_method(:inherited) do |subclass|
           super(subclass)
+          cmd_name = subclass.command_name
+          if cmd_name && !subclass.abstract_class?
+            subclass.instance_variable_set(:@_derived_name, cmd_name)
+            tool.subcommands[cmd_name] = subclass
+          end
         end
 
         klass.define_singleton_method(:inherited_command_name_set) do |subclass|
           cmd_name = subclass.command_name
-          tool.subcommands[cmd_name] = subclass if cmd_name && !subclass.abstract_class?
+          if cmd_name && !subclass.abstract_class?
+            derived = subclass.instance_variable_get(:@_derived_name)
+            tool.subcommands.delete(derived) if derived && derived != cmd_name
+            tool.subcommands[cmd_name] = subclass
+          end
         end
       end
     end
-
-    def self.command(name, aliases: [], &block)
-      base = command_class || self
-      klass = Class.new(base)
-      klass.command_name = name.to_sym
-      klass.aliases(*aliases) if aliases.any?
-
-      const_name = name.to_s.split("_").map(&:capitalize).join
-      const_set(const_name, klass) if const_name.match?(/\A[A-Z]/)
-
-      Athena::DSL::BlockDSL.new(klass).instance_eval(&block) if block
-      klass
-    end
   end
 end