Changed cmd2 to use autocompleter by default for all argparse commands. Not all tests are passing yet.

2 files changed, 100 insertions, 13 deletions

diff --git a/examples/subcommands.py b/examples/subcommands.py
index 031b17b2..03088c93 100755
--- a/examples/subcommands.py
+++ b/examples/subcommands.py
@@ -53,15 +53,22 @@ class SubcommandsExample(cmd2.Cmd):
 
     # create the parser for the "bar" subcommand
     parser_bar = base_subparsers.add_parser('bar', help='bar help')
-    parser_bar.add_argument('z', help='string')
     parser_bar.set_defaults(func=base_bar)
 
+    bar_subparsers = parser_bar.add_subparsers(title='layer3', help='help for 3rd layer of commands')
+    parser_bar.add_argument('z', help='string')
+
+    bar_subparsers.add_parser('apple', help='apple help')
+    bar_subparsers.add_parser('artichoke', help='artichoke help')
+    bar_subparsers.add_parser('cranberries', help='cranberries help')
+
     # create the parser for the "sport" subcommand
     parser_sport = base_subparsers.add_parser('sport', help='sport help')
-    parser_sport.add_argument('sport', help='Enter name of a sport')
+    sport_arg = parser_sport.add_argument('sport', help='Enter name of a sport')
+    setattr(sport_arg, 'arg_choices', sport_item_strs)
 
     # Set both a function and tab completer for the "sport" subcommand
-    parser_sport.set_defaults(func=base_sport, completer=complete_base_sport)
+    parser_sport.set_defaults(func=base_sport)
 
     @with_argparser(base_parser)
     def do_base(self, args):
@@ -75,7 +82,7 @@ class SubcommandsExample(cmd2.Cmd):
             self.do_help('base')
 
     # Enable tab completion of base to make sure the subcommands' completers get called.
-    complete_base = cmd2.Cmd.cmd_with_subs_completer
+    # complete_base = cmd2.Cmd.cmd_with_subs_completer
 
 
 if __name__ == '__main__':
diff --git a/examples/tab_autocompletion.py b/examples/tab_autocompletion.py
index c704908f..2c200757 100755
--- a/examples/tab_autocompletion.py
+++ b/examples/tab_autocompletion.py
@@ -13,6 +13,15 @@ from typing import List
 import cmd2
 from cmd2 import with_argparser, with_category, argparse_completer
 
+actors = ['Mark Hamill', 'Harrison Ford', 'Carrie Fisher', 'Alec Guinness', 'Peter Mayhew',
+          'Anthony Daniels', 'Adam Driver', 'Daisy Ridley', 'John Boyega', 'Oscar Isaac',
+          'Lupita Nyong\'o', 'Andy Serkis', 'Liam Neeson', 'Ewan McGregor', 'Natalie Portman',
+          'Jake Lloyd', 'Hayden Christensen', 'Christopher Lee']
+
+def query_actors() -> List[str]:
+    """Simulating a function that queries and returns a completion values"""
+    return actors
+
 
 class TabCompleteExample(cmd2.Cmd):
     """ Example cmd2 application where we a base command which has a couple subcommands."""
@@ -27,10 +36,6 @@ class TabCompleteExample(cmd2.Cmd):
     show_ratings = ['TV-Y', 'TV-Y7', 'TV-G', 'TV-PG', 'TV-14', 'TV-MA']
     static_list_directors = ['J. J. Abrams', 'Irvin Kershner', 'George Lucas', 'Richard Marquand',
                              'Rian Johnson', 'Gareth Edwards']
-    actors = ['Mark Hamill', 'Harrison Ford', 'Carrie Fisher', 'Alec Guinness', 'Peter Mayhew',
-              'Anthony Daniels', 'Adam Driver', 'Daisy Ridley', 'John Boyega', 'Oscar Isaac',
-              'Lupita Nyong\'o', 'Andy Serkis', 'Liam Neeson', 'Ewan McGregor', 'Natalie Portman',
-              'Jake Lloyd', 'Hayden Christensen', 'Christopher Lee']
     USER_MOVIE_LIBRARY = ['ROGUE1', 'SW_EP04', 'SW_EP05']
     MOVIE_DATABASE_IDS = ['SW_EP01', 'SW_EP02', 'SW_EP03', 'ROGUE1', 'SW_EP04',
                           'SW_EP05', 'SW_EP06', 'SW_EP07', 'SW_EP08', 'SW_EP09']
@@ -183,10 +188,6 @@ class TabCompleteExample(cmd2.Cmd):
     # The media command demonstrates a completer with multiple layers of subcommands
     #   - This example uses a flat completion lookup dictionary
 
-    def query_actors(self) -> List[str]:
-        """Simulating a function that queries and returns a completion values"""
-        return TabCompleteExample.actors
-
     def _do_media_movies(self, args) -> None:
         if not args.command:
             self.do_help('media movies')
@@ -264,7 +265,7 @@ class TabCompleteExample(cmd2.Cmd):
     # name collisions.
     def complete_media(self, text, line, begidx, endidx):
         """ Adds tab completion to media"""
-        choices = {'actor': self.query_actors,  # function
+        choices = {'actor': query_actors,  # function
                    'director': TabCompleteExample.static_list_directors  # static list
                    }
         completer = argparse_completer.AutoCompleter(TabCompleteExample.media_parser, arg_choices=choices)
@@ -275,6 +276,85 @@ class TabCompleteExample(cmd2.Cmd):
         return results
 
     ###################################################################################
+    # The media command demonstrates a completer with multiple layers of subcommands
+    #   - This example tags a completion attribute on each action
+
+    def _do_vid_media_movies(self, args) -> None:
+        if not args.command:
+            self.do_help('media movies')
+        elif args.command == 'list':
+            for movie_id in TabCompleteExample.MOVIE_DATABASE:
+                movie = TabCompleteExample.MOVIE_DATABASE[movie_id]
+                print('{}\n-----------------------------\n{}   ID: {}\nDirector: {}\nCast:\n    {}\n\n'
+                      .format(movie['title'], movie['rating'], movie_id,
+                              ', '.join(movie['director']),
+                              '\n    '.join(movie['actor'])))
+
+    def _do_vid_media_shows(self, args) -> None:
+        if not args.command:
+            self.do_help('media shows')
+
+        elif args.command == 'list':
+            for show_id in TabCompleteExample.SHOW_DATABASE:
+                show = TabCompleteExample.SHOW_DATABASE[show_id]
+                print('{}\n-----------------------------\n{}   ID: {}'
+                      .format(show['title'], show['rating'], show_id))
+                for season in show['seasons']:
+                    ep_list = show['seasons'][season]
+                    print('  Season {}:\n    {}'
+                          .format(season,
+                                  '\n    '.join(ep_list)))
+                print()
+
+    video_parser = argparse_completer.ACArgumentParser(prog='media')
+
+    video_types_subparsers = video_parser.add_subparsers(title='Media Types', dest='type')
+
+    vid_movies_parser = video_types_subparsers.add_parser('movies')
+    vid_movies_parser.set_defaults(func=_do_vid_media_movies)
+
+    vid_movies_commands_subparsers = vid_movies_parser.add_subparsers(title='Commands', dest='command')
+
+    vid_movies_list_parser = vid_movies_commands_subparsers.add_parser('list')
+
+    vid_movies_list_parser.add_argument('-t', '--title', help='Title Filter')
+    vid_movies_list_parser.add_argument('-r', '--rating', help='Rating Filter', nargs='+',
+                                        choices=ratings_types)
+    director_action = vid_movies_list_parser.add_argument('-d', '--director', help='Director Filter')
+    actor_action = vid_movies_list_parser.add_argument('-a', '--actor', help='Actor Filter', action='append')
+    setattr(director_action, argparse_completer.ACTION_ARG_CHOICES, static_list_directors)
+    setattr(actor_action, argparse_completer.ACTION_ARG_CHOICES, query_actors)
+
+    vid_movies_add_parser = vid_movies_commands_subparsers.add_parser('add')
+    vid_movies_add_parser.add_argument('title', help='Movie Title')
+    vid_movies_add_parser.add_argument('rating', help='Movie Rating', choices=ratings_types)
+    director_action = vid_movies_add_parser.add_argument('-d', '--director', help='Director', nargs=(1, 2), required=True)
+    actor_action = vid_movies_add_parser.add_argument('actor', help='Actors', nargs='*')
+    setattr(director_action, argparse_completer.ACTION_ARG_CHOICES, static_list_directors)
+    setattr(actor_action, argparse_completer.ACTION_ARG_CHOICES, query_actors)
+
+    vid_movies_delete_parser = vid_movies_commands_subparsers.add_parser('delete')
+
+    vid_shows_parser = video_types_subparsers.add_parser('shows')
+    vid_shows_parser.set_defaults(func=_do_vid_media_shows)
+
+    vid_shows_commands_subparsers = vid_shows_parser.add_subparsers(title='Commands', dest='command')
+
+    vid_shows_list_parser = vid_shows_commands_subparsers.add_parser('list')
+
+    @with_category(CAT_AUTOCOMPLETE)
+    @with_argparser(video_parser)
+    def do_video(self, args):
+        """Video management command demonstrates multiple layers of subcommands being handled by AutoCompleter"""
+        func = getattr(args, 'func', None)
+        if func is not None:
+            # Call whatever subcommand function was selected
+            func(self, args)
+        else:
+            # No subcommand was provided, so call help
+            self.do_help('video')
+
+    ###################################################################################
     # The library command demonstrates a completer with multiple layers of subcommands
     # with different completion results per sub-command
     #   - This demonstrates how to build a tree of completion lookups to pass down