commander-tool 1.0.0 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fe0b76d088b96fcd3e9a46d540f79ff38d10bb49d1f35c8ed4d2b1f9bd26ddb
-  data.tar.gz: 2c349bc20037922113ea90e74a00c6688495f1950bebe67c505d502c6bffff4d
+  metadata.gz: fc12456920e61c887d63c3224bbabe9b8c8850df925733a917c782da347ad2a6
+  data.tar.gz: fc30d88eac1a17c0effd957e5e1fc1cdcada2e83eda493087e2421b568e2ea88
 SHA512:
-  metadata.gz: 4c20b7c34bcdb2663ee7f4554ac25b1c41c8910fe62d21e9e91b60b47f651c54fdfc7aa0e7f529db11e6a1e27e26d61ba12bc40c5f08ff8ad8fbd7fe8679b4fa
-  data.tar.gz: 3bd9b6f788e3b2bb33e714520db2b57eb299cce3d95670b15dfb6a203cac16acc233a5c5b908647d1f3a2e5d9e2118fc32a4ca60d79a7f095afade07fe90734b
+  metadata.gz: f830e16aad8121ad5a59cf0a2f4ebf9ce8835e0c06ae2589e845137a06f4dc04f0bff5af628c467d25c04da944f11d393e9da67d025166035bb563819eccc24c
+  data.tar.gz: 759a7318b4a23153c992a3a5fb2422b3fd31efb6c2632cf38f2b279430aa92e7bf2fa539db240f07cceebe9fa4284d43dceeaf89c9325f51224001cdb49fc521

data/lib/commander-tool.rb

@@ -1,32 +1,54 @@
-require 'did_you_mean'
+require "did_you_mean"
 
 class Commander
+  VERSION = "1.0.2"
+
   class Command
-    attr_reader :name, :description, :options, :block
+    attr_reader :name, :description, :options, :block, :subcommands
 
-    def initialize(name, description = '', &block)
+    def initialize(name, description = "", &block)
       @name = name.to_s
-      @description = description
+      @description = description.to_s
       @options = []
+      @subcommands = {}
       @block = block
     end
 
-    def add_option(switches, description = '')
+    def add_option(switches, description = "")
       @options << Option.new(switches, description)
       self
     end
+
+    def add_subcommand(name, description = "", &block)
+      command = Command.new(name, description, &block)
+      @subcommands[command.name] = command
+      command
+    end
+
+    def has_subcommands?
+      !@subcommands.empty?
+    end
   end
 
   class Option
     attr_reader :switches, :description, :key
 
-    def initialize(switches, description = '')
-      @switches = switches
-      @description = description
+    def initialize(switches, description = "")
+      @switches = Array(switches).map(&:to_s)
+      @description = description.to_s
+
+      long =
+        @switches.find { |s| s.start_with?("--") }
+
+      short =
+        @switches.find { |s| s.start_with?("-") }
 
       @key =
-        switches.find { |s| s.start_with?('--') }&.sub(/^--/, '')&.tr('-', '_') ||
-        switches.find { |s| s.start_with?('-') }&.sub(/^-/, '')
+        if long
+          long.sub(/\A--/, "").tr("-", "_")
+        elsif short
+          short.sub(/\A-/, "").tr("-", "_")
+        end
     end
 
     def matches?(arg)
@@ -34,10 +56,9 @@ class Commander
     end
 
     def value_required?
-      description.include?('<') ||
-        description.include?('argument') ||
-        description.include?('value') ||
-        description.include?('VALUE')
+      @description.include?("<") ||
+        @description.match?(/\bargument\b/i) ||
+        @description.match?(/\bvalue\b/i)
     end
   end
 
@@ -46,141 +67,270 @@ class Commander
     @global_options = []
   end
 
-  def add_command(name, description = '', &block)
-    cmd = Command.new(name, description, &block)
-    @commands[cmd.name] = cmd
-    cmd
+  def add_command(name, description = "", &block)
+    command = Command.new(name, description, &block)
+    @commands[command.name] = command
+    command
   end
 
-  def add_option(switches, description = '')
+  def add_option(switches, description = "")
     @global_options << Option.new(switches, description)
     self
   end
 
   def parse(args = ARGV)
-    global_parsed, remaining_args =
-      parse_options(args, @global_options)
+    args = Array(args).dup
+
+    if args.empty?
+      print_usage
+      return
+    end
 
-    command_name = remaining_args.shift
+    if args.first == "--version" || args.first == "-v"
+      puts "Commander CLI v#{VERSION}"
+      return
+    end
 
-    if command_name.nil?
-      handle_no_command(global_parsed)
+    if args.first == "--help" || args.first == "-h"
+      print_usage
       return
     end
 
-    if @commands.key?(command_name)
-      command = @commands[command_name]
+    # Find the first registered top-level command.
+    command_index = nil
+    command = nil
 
-      cmd_parsed, command_args =
-        parse_options(remaining_args, command.options)
+    args.each_with_index do |arg, index|
+      next if arg.start_with?("-")
+
+      if @commands.key?(arg)
+        command_index = index
+        command = @commands[arg]
+        break
+      end
+    end
 
-      # Merge global and command options for execution
-      combined_options = global_parsed.merge(cmd_parsed)
+    unless command
+      name = args.find { |arg| !arg.start_with?("-") }
 
-      command.block.call(combined_options, command_args) if command.block
-    else
-      raise_unknown_command(command_name)
+      if name
+        raise_unknown_command(name)
+      else
+        raise_unknown_option(args.first, @global_options)
+      end
     end
+
+    # Only arguments BEFORE the command belong to global options.
+    global_args = args[0...command_index]
+
+    # Everything AFTER the command belongs to that command.
+    command_args = args[(command_index + 1)..] || []
+
+    global_options, = parse_options(
+      global_args,
+      @global_options
+    )
+
+    parse_command(
+      command,
+      command_args,
+      global_options
+    )
   end
 
   private
 
+  def parse_command(command, args, inherited_options)
+    args = args.dup
+
+    if command.has_subcommands?
+      subcommand_name = args.shift
+
+      if subcommand_name.nil?
+        print_command_help(command)
+        return
+      end
+
+      if subcommand_name == "--help" || subcommand_name == "-h"
+        print_command_help(command)
+        return
+      end
+
+      subcommand = command.subcommands[subcommand_name]
+
+      unless subcommand
+        raise_unknown_subcommand(
+          subcommand_name,
+          command
+        )
+      end
+
+      command_options, command_args =
+        parse_options(
+          args,
+          command.options
+        )
+
+      combined_options =
+        inherited_options.merge(command_options)
+
+      if subcommand.has_subcommands?
+        parse_command(
+          subcommand,
+          command_args,
+          combined_options
+        )
+      elsif subcommand.block
+        subcommand.block.call(
+          combined_options,
+          command_args
+        )
+      end
+
+      return
+    end
+
+    command_options, command_args =
+      parse_options(
+        args,
+        command.options
+      )
+
+    combined_options =
+      inherited_options.merge(command_options)
+
+    command.block.call(
+      combined_options,
+      command_args
+    ) if command.block
+  end
+
   def parse_options(args, available_options)
     parsed = {}
     remaining = []
+
     i = 0
 
     while i < args.length
       arg = args[i]
 
-      if arg.start_with?('-')
-        option = available_options.find { |opt| opt.matches?(arg) }
+      if arg == "--"
+        remaining.concat(args[(i + 1)..] || [])
+        break
+      end
+
+      unless arg.start_with?("-")
+        remaining << arg
+        i += 1
+        next
+      end
 
-        unless option
-          raise_unknown_option(arg, available_options)
+      option =
+        available_options.find do |candidate|
+          candidate.matches?(arg)
         end
 
-        next_arg = args[i + 1]
+      unless option
+        raise_unknown_option(
+          arg,
+          available_options
+        )
+      end
 
-        if option.value_required?
-          if next_arg.nil? || next_arg.start_with?('-')
-            raise_missing_argument(arg)
-          end
+      next_arg = args[i + 1]
 
-          parsed[option.key.to_sym] = next_arg
-          i += 2
-        elsif next_arg && !next_arg.start_with?('-')
+      if option.value_required?
+        if next_arg.nil? || next_arg.start_with?("-")
+          raise_missing_argument(arg)
+        end
+
+        parsed[option.key.to_sym] = next_arg
+        i += 2
+      else
+        if next_arg && !next_arg.start_with?("-")
           parsed[option.key.to_sym] = next_arg
           i += 2
         else
           parsed[option.key.to_sym] = true
           i += 1
         end
-      else
-        remaining << arg
-        i += 1
       end
     end
 
     [parsed, remaining]
   end
 
-  def raise_missing_argument(option_name)
-    abort "error: flag '#{option_name}' needs an argument"
+  def raise_missing_argument(option)
+    abort "error: flag '#{option}' needs an argument"
   end
 
-  def raise_unknown_command(command_name)
-    corrector = DidYouMean::SpellChecker.new(
-      dictionary: @commands.keys
-    )
+  def raise_unknown_command(name)
+    corrector =
+      DidYouMean::SpellChecker.new(
+        dictionary: @commands.keys
+      )
 
-    suggestions = corrector.correct(command_name)
+    suggestions = corrector.correct(name)
 
-    msg = "error: unknown command '#{command_name}'"
+    message =
+      "error: unknown command '#{name}'"
 
     unless suggestions.empty?
-      msg += "\n\nDid you mean?\n"
-      msg += suggestions.map { |s| "\t#{s}" }.join("\n")
+      message << "\n\nDid you mean?\n"
+      message << suggestions.map { |s| "\t#{s}" }.join("\n")
     end
 
-    abort msg
+    abort message
   end
 
-  def raise_unknown_option(option_name, available_options)
-    all_switches = available_options.flat_map(&:switches)
-
-    corrector = DidYouMean::SpellChecker.new(
-      dictionary: all_switches
-    )
+  def raise_unknown_subcommand(name, command)
+    corrector =
+      DidYouMean::SpellChecker.new(
+        dictionary: command.subcommands.keys
+      )
 
-    suggestions = corrector.correct(option_name)
+    suggestions = corrector.correct(name)
 
-    msg = "error: unknown option '#{option_name}'"
+    message =
+      "error: unknown command '#{name}'"
 
     unless suggestions.empty?
-      msg += "\n\nDid you mean?\n"
-      msg += suggestions.map { |s| "\t#{s}" }.join("\n")
+      message << "\n\nDid you mean?\n"
+      message << suggestions.map { |s| "\t#{s}" }.join("\n")
     end
 
-    abort msg
+    abort message
   end
 
-  def handle_no_command(options)
-    if options[:version] || options[:v]
-      puts "Commander CLI v1.0.0"
-      return
+  def raise_unknown_option(name, options)
+    switches =
+      options.flat_map(&:switches)
+
+    corrector =
+      DidYouMean::SpellChecker.new(
+        dictionary: switches
+      )
+
+    suggestions = corrector.correct(name)
+
+    message =
+      "error: unknown option '#{name}'"
+
+    unless suggestions.empty?
+      message << "\n\nDid you mean?\n"
+      message << suggestions.map { |s| "\t#{s}" }.join("\n")
     end
 
+    abort message
+  end
+
+  def print_usage
     puts "Usage: <command> [options]"
     puts
     puts "Commands:"
 
-    if @commands.empty?
-      puts "  No commands available."
-    else
-      @commands.each_value do |command|
-        puts "  #{command.name.ljust(20)} #{command.description}"
-      end
+    @commands.each_value do |command|
+      puts "  #{command.name.ljust(20)} #{command.description}"
     end
 
     unless @global_options.empty?
@@ -188,8 +338,24 @@ class Commander
       puts "Options:"
 
       @global_options.each do |option|
-        puts "  #{option.switches.join(', ').ljust(20)} #{option.description}"
+        puts "  #{option.switches.join(", ").ljust(20)} #{option.description}"
       end
     end
   end
+
+  def print_command_help(command)
+    puts "Usage: #{command.name} <subcommand> [options]"
+    puts
+
+    unless command.description.empty?
+      puts command.description
+      puts
+    end
+
+    puts "Commands:"
+
+    command.subcommands.each_value do |subcommand|
+      puts "  #{subcommand.name.ljust(20)} #{subcommand.description}"
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: commander-tool
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Jjjm