Feature/fuzzy suggestions (#64)

* Added feature to display possible incorrect word in command line

* get close matches when command is correct but arguments are misspelled

* Refactor and added tests

* Do not print help message when incorrect words found

* Added tests

* Fix tests and format error message

* Change in test

* Refactor: remove unused import and doc changes

* Fix: initialization and docs

* Added changelog

* Refactor

* Fix: Argument flag with underscore while displaying suggestions

Author: kiran-chaudhary

CHANGELOG.md

@@ -20,6 +20,8 @@ how a consumer would use the library (e.g. adding unit tests, updating documenta
 
 ### Added
 
+- Display, `Fuzzy suggestions`, valid keywords matching mistyped commands or arguments.
+
 - `code42 alerts`:
     - Ability to search/poll for alerts with checkpointing using one of the following commands:
       - `print` to output to stdout.

src/code42cli/invoker.py

@@ -1,14 +1,22 @@
 import sys
 
+import difflib
+
 from py42.exceptions import Py42HTTPError, Py42ForbiddenError
 
 from code42cli.compat import str
 from code42cli.errors import Code42CLIError
 from code42cli.parser import ArgumentParserError, CommandParser
 from code42cli.logger import get_main_cli_logger
 
+_DIFFLIB_CUT_OFF = 0.7
+
 
 class CommandInvoker(object):
+
+    _COMMAND_KEYWORDS = {}
+    _COMMAND_ARG_KEYWORDS = {}
+
     def __init__(self, top_command, cmd_parser=None):
         self._top_command = top_command
         self._cmd_parser = cmd_parser or CommandParser()
@@ -72,6 +80,7 @@ def _load_subcommands(self, path, node):
         for command in node.subcommands:
             new_key = u"{} {}".format(path, command.name).strip()
             self._commands[new_key] = command
+            self._set_command_keywords(new_key)
 
     def _try_run_command(self, command, path_parts, input_args):
         """Runs a command called using `path_parts` by parsing
@@ -82,9 +91,65 @@ def _try_run_command(self, command, path_parts, input_args):
                 parser = self._cmd_parser.prepare_cli_help(command)
             else:
                 parser = self._cmd_parser.prepare_command(command, path_parts)
+                self._set_argument_keywords(path_parts[0], command.get_arg_configs())
             parsed_args = self._cmd_parser.parse_args(input_args)
             parsed_args.func(parsed_args)
         except ArgumentParserError as err:
-            get_main_cli_logger().log_error(err)
-            parser.print_help(sys.stderr)
+            logger = get_main_cli_logger()
+            logger.print_and_log_error(u"{}".format(err))
+            possible_correct_words = self._find_incorrect_word_match(err, path_parts)
+            if possible_correct_words:
+                logger.print_and_log_error(u"Did you mean one of the following?")
+                for possible_correct_word in possible_correct_words:
+                    logger.print_info(u"     {}".format(possible_correct_word))
+
+            else:
+                parser.print_help(sys.stderr)
             sys.exit(2)
+
+    @staticmethod
+    def _get_arg_flags(arguments):
+        flag_names = []
+        for arg in arguments.values():
+            arg_flags = [name for name in arg.settings["options_list"] if name.startswith("-")]
+            flag_names.extend(arg_flags)
+        return flag_names
+
+    def _set_argument_keywords(self, command_key, arguments):
+        self._COMMAND_ARG_KEYWORDS[command_key] = set()
+        self._COMMAND_ARG_KEYWORDS[command_key].update(CommandInvoker._get_arg_flags(arguments))
+
+    def _set_command_keywords(self, new_key):
+        """Creates a dictionary, with top level command as key and set of all its subcommands
+        as values.
+        """
+        command_keys = new_key.split()
+        if len(command_keys) == 1:
+            self._COMMAND_KEYWORDS[command_keys[0]] = set()
+        else:
+            self._COMMAND_KEYWORDS[command_keys[0]].update(command_keys[1:])
+
+    def _find_incorrect_word_match(self, error, path_parts):
+        possible_correct_words = []
+
+        try:
+            # Here we assume the error string contains ":", for case where it doesn't we
+            # assume the error is not due to misspelled word and we return error as is.
+            error_detail, unmatched_words = str(error).split(u":")
+        except ValueError:
+            return possible_correct_words
+
+        if not unmatched_words or error_detail != u"unrecognized arguments":
+            return possible_correct_words
+
+        # Arg-parser sets the first/leftmost incorrect command keyword in the error message.
+        unmatched_word = unmatched_words.split()[0]
+
+        if not path_parts:
+            available_values = self._COMMAND_KEYWORDS.keys()
+        elif unmatched_word.strip().startswith('-'):
+            available_values = self._COMMAND_ARG_KEYWORDS[path_parts[0]]
+        else:
+            available_values = self._COMMAND_KEYWORDS[path_parts[0]]
+
+        return difflib.get_close_matches(unmatched_word, available_values, cutoff=_DIFFLIB_CUT_OFF)

tests/test_invoker.py

@@ -10,6 +10,8 @@
 from code42cli.errors import Code42CLIError
 from code42cli.invoker import CommandInvoker
 from code42cli.parser import ArgumentParserError, CommandParser
+from code42cli.cmds import profile
+from code42cli.cmds.securitydata import main as secmain
 
 
 def dummy_method(one, two, three=None):
@@ -28,6 +30,19 @@ def load_sub_subcommands():
     return [Command("inner1", "the innerdesc1", handler=dummy_method)]
 
 
+def load_real_sub_commands():
+    return [
+    Command(
+        u"profile", u"", subcommand_loader=profile.load_subcommands
+    ),
+    Command(
+        u"security-data",
+        u"",
+        subcommand_loader=secmain.load_subcommands,
+    )
+    ]
+
+
 @pytest.fixture
 def mock_parser(mocker):
     return mocker.MagicMock(spec=CommandParser)
@@ -146,3 +161,30 @@ def test_run_when_cli_error_occurs_logs_request(self, mocker, mock_parser, caplo
         with caplog.at_level(logging.ERROR):
             invoker.run(["testsub1", "inner1", "one", "two", "--invalid", "test"])
             assert "a code42cli error" in caplog.text
+
+    def test_run_incorrect_command_suggests_proper_sub_commands(self, caplog):
+        command = Command(u"", u"", subcommand_loader=load_real_sub_commands)
+        cmd_invoker = CommandInvoker(command)
+        with pytest.raises(SystemExit):
+            cmd_invoker.run([u"profile", u"crate"])
+        with caplog.at_level(logging.ERROR):
+            assert u"Did you mean one of the following?" in caplog.text
+            assert u"create" in caplog.text
+            
+    def test_run_incorrect_command_suggests_proper_main_commands(self, caplog):
+        command = Command(u"", u"", subcommand_loader=load_real_sub_commands)
+        cmd_invoker = CommandInvoker(command)
+        with pytest.raises(SystemExit):
+            cmd_invoker.run([u"prfile", u"crate"])
+        with caplog.at_level(logging.ERROR):
+            assert u"Did you mean one of the following?" in caplog.text
+            assert u"profile" in caplog.text
+            
+    def test_run_incorrect_command_suggests_proper_argument_name(self, caplog):
+        command = Command(u"", u"", subcommand_loader=load_real_sub_commands)
+        cmd_invoker = CommandInvoker(command)
+        with pytest.raises(SystemExit):
+            cmd_invoker.run([u"security-data", u"write-to", u"abc", u"--filename"])
+        with caplog.at_level(logging.ERROR):
+            assert u"Did you mean one of the following?" in caplog.text
+            assert u"--file-name" in caplog.text