Support did-you-mean functionality in thor

When an invocation errors out because it cannot find a corresponding command, this will attempt to suggest alternatives in the case of typos. Also, when invalid switches are passed and checking for invalid switches is enabled, it will attempt to suggest alternatives as well.

Author: kddnewton

lib/thor/base.rb

@@ -493,8 +493,7 @@ def public_command(*names)
       alias_method :public_task, :public_command
 
       def handle_no_command_error(command, has_namespace = $thor_runner) #:nodoc:
-        raise UndefinedCommandError, "Could not find command #{command.inspect} in #{namespace.inspect} namespace." if has_namespace
-        raise UndefinedCommandError, "Could not find command #{command.inspect}."
+        raise UndefinedCommandError.new(command, all_commands.keys, (namespace if has_namespace))
       end
       alias_method :handle_no_task_error, :handle_no_command_error
 

lib/thor/error.rb

@@ -10,6 +10,35 @@ class Error < StandardError
 
   # Raised when a command was not found.
   class UndefinedCommandError < Error
+    class SpellChecker
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def corrections
+        @corrections ||= spell_checker.correct(error.command).map(&:inspect)
+      end
+
+      def spell_checker
+        DidYouMean::SpellChecker.new(dictionary: error.all_commands)
+      end
+    end
+
+    attr_reader :command, :all_commands
+
+    def initialize(command, all_commands, namespace)
+      @command = command
+      @all_commands = all_commands
+
+      message = "Could not find command #{command.inspect}"
+      message = namespace ? "#{message} in #{namespace.inspect} namespace." : "#{message}."
+
+      super(message)
+    end
+
+    prepend DidYouMean::Correctable
   end
   UndefinedTaskError = UndefinedCommandError
 
@@ -22,11 +51,44 @@ class InvocationError < Error
   end
 
   class UnknownArgumentError < Error
+    class SpellChecker
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def corrections
+        @corrections ||=
+          error.unknown.flat_map { |unknown| spell_checker.correct(unknown) }.uniq.map(&:inspect)
+      end
+
+      def spell_checker
+        @spell_checker ||=
+          DidYouMean::SpellChecker.new(dictionary: error.switches)
+      end
+    end
+
+    attr_reader :switches, :unknown
+
+    def initialize(switches, unknown)
+      @switches = switches
+      @unknown = unknown
+
+      super("Unknown switches #{unknown.map(&:inspect).join(', ')}")
+    end
+
+    prepend DidYouMean::Correctable
   end
 
   class RequiredArgumentMissingError < InvocationError
   end
 
   class MalformattedArgumentError < InvocationError
   end
+
+  DidYouMean::SPELL_CHECKERS.merge!(
+    'Thor::UndefinedCommandError' => UndefinedCommandError::SpellChecker,
+    'Thor::UnknownArgumentError' => UnknownArgumentError::SpellChecker
+  )
 end

lib/thor/parser/options.rb

@@ -127,7 +127,7 @@ def check_unknown!
 
       # an unknown option starts with - or -- and has no more --'s afterward.
       unknown = to_check.select { |str| str =~ /^--?(?:(?!--).)*$/ }
-      raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
+      raise UnknownArgumentError.new(@switches.keys, unknown) unless unknown.empty?
     end
 
   protected

spec/base_spec.rb

@@ -262,6 +262,15 @@ def hello
       end.to raise_error(Thor::UndefinedCommandError, 'Could not find command "what" in "my_script" namespace.')
     end
 
+    it "suggests commands that are similar if there is a typo" do
+      expected = <<~MSG
+        Could not find command "paintz" in "barn" namespace.
+        Did you mean?  "paint"
+      MSG
+
+      expect(capture(:stderr) { Barn.start(%w(paintz)) }).to eq(expected)
+    end
+
     it "does not steal args" do
       args = %w(foo bar --force true)
       MyScript.start(args)
@@ -271,7 +280,7 @@ def hello
     it "checks unknown options" do
       expect(capture(:stderr) do
         MyScript.start(%w(foo bar --force true --unknown baz))
-      end.strip).to eq("Unknown switches '--unknown'")
+      end.strip).to eq("Unknown switches \"--unknown\"")
     end
 
     it "checks unknown options except specified" do

spec/parser/options_spec.rb

@@ -113,7 +113,13 @@ def remaining
     it "raises an error for unknown switches" do
       create :foo => "baz", :bar => :required
       parse("--bar", "baz", "--baz", "unknown")
-      expect { check_unknown! }.to raise_error(Thor::UnknownArgumentError, "Unknown switches '--baz'")
+
+      expected = <<~MSG.chomp
+        Unknown switches "--baz"
+        Did you mean?  "--bar"
+      MSG
+
+      expect { check_unknown! }.to raise_error(Thor::UnknownArgumentError, expected)
     end
 
     it "skips leading non-switches" do

spec/thor_spec.rb

@@ -182,7 +182,7 @@ def exec(*args)
       it "does not accept if first non-option looks like an option, but only refuses that invalid option" do
         expect(capture(:stderr) do
           my_script2.start(%w[exec --foo command --bar])
-        end.strip).to eq("Unknown switches '--foo'")
+        end.strip).to eq("Unknown switches \"--foo\"")
       end
 
       it "still accepts options that are given before non-options" do
@@ -196,7 +196,7 @@ def exec(*args)
       it "does not accept when non-option looks like an option and is after real options" do
         expect(capture(:stderr) do
           my_script2.start(%w[exec --verbose --foo])
-        end.strip).to eq("Unknown switches '--foo'")
+        end.strip).to eq("Unknown switches \"--foo\"")
       end
 
       it "still accepts options that require a value" do
@@ -236,25 +236,25 @@ def checked(*args)
     it "does not accept if non-option that looks like an option is before the arguments" do
       expect(capture(:stderr) do
         my_script.start(%w[checked --foo command --bar])
-      end.strip).to eq("Unknown switches '--foo, --bar'")
+      end.strip).to eq("Unknown switches \"--foo\", \"--bar\"")
     end
 
     it "does not accept if non-option that looks like an option is after an argument" do
       expect(capture(:stderr) do
         my_script.start(%w[checked command --foo --bar])
-      end.strip).to eq("Unknown switches '--foo, --bar'")
+      end.strip).to eq("Unknown switches \"--foo\", \"--bar\"")
     end
 
     it "does not accept when non-option that looks like an option is after real options" do
       expect(capture(:stderr) do
         my_script.start(%w[checked --verbose --foo])
-      end.strip).to eq("Unknown switches '--foo'")
+      end.strip).to eq("Unknown switches \"--foo\"")
     end
 
     it "does not accept when non-option that looks like an option is before real options" do
       expect(capture(:stderr) do
         my_script.start(%w[checked --foo --verbose])
-      end.strip).to eq("Unknown switches '--foo'")
+      end.strip).to eq("Unknown switches \"--foo\"")
     end
 
     it "still accepts options that require a value" do