Renamed @with_argument_parser decorator to @with_argparser

Also:
- Reanamed foo and bar subcommand methods to base_foo and base_bar

Author: tleonhardt

cmd2.py

@@ -308,7 +308,7 @@ def cmd_wrapper(instance, cmdline):
     return arg_decorator
 
 
-def with_argument_parser(argparser, subcommand_names=None):
+def with_argparser(argparser, subcommand_names=None):
     """A decorator to alter a cmd2 method to populate its ``args`` argument by parsing arguments
     with the given instance of argparse.ArgumentParser.
 
@@ -1463,7 +1463,7 @@ def show(self, args, parameter):
     set_parser.add_argument('-l', '--long', action='store_true', help='describe function of parameter')
     set_parser.add_argument('settable', nargs='*', help='[param_name] [value]')
 
-    @with_argument_parser(set_parser)
+    @with_argparser(set_parser)
     def do_set(self, args):
         """Sets a settable parameter or shows current settings of parameters.
 
@@ -1825,7 +1825,7 @@ def do_ipy(self, arg):
 /regex/             items matching regular expression"""
     history_parser.add_argument('arg', nargs='?', help=_history_arg_help)
 
-    @with_argument_parser(history_parser)
+    @with_argparser(history_parser)
     def do_history(self, args):
         """View, run, edit, and save previously entered commands."""
         # If an argument was supplied, then retrieve partial contents of the history

docs/argument_processing.rst

@@ -13,15 +13,15 @@ Argument Processing
 4. Adds the usage message from the argument parser to your command.
 5. Checks if the ``-h/--help`` option is present, and if so, display the help message for the command
 
-These features are all provided by the ``@with_argument_parser`` decorator.
+These features are all provided by the ``@with_argparser`` decorator.
 
 Using the argument parser decorator
 ===================================
 
 For each command in the ``cmd2`` subclass which requires argument parsing,
 create an instance of ``argparse.ArgumentParser()`` which can parse the
 input appropriately for the command. Then decorate the command method with
-the ``@with_argument_parser`` decorator, passing the argument parser as the
+the ``@with_argparser`` decorator, passing the argument parser as the
 first parameter to the decorator. This changes the second argumen to the command method, which will contain the results
 of ``ArgumentParser.parse_args()``.
 
@@ -33,7 +33,7 @@ Here's what it looks like::
       argparser.add_argument('-r', '--repeat', type=int, help='output [n] times')
       argparser.add_argument('word', nargs='?', help='word to say')
 
-      @with_argument_parser(argparser)
+      @with_argparser(argparser)
       def do_speak(self, opts)
          """Repeats what you tell me to."""
          arg = opts.word
@@ -47,7 +47,7 @@ Here's what it looks like::
 
 .. note::
 
-   The ``@with_argument_parser`` decorator sets the ``prog`` variable in
+   The ``@with_argparser`` decorator sets the ``prog`` variable in
    the argument parser based on the name of the method it is decorating.
    This will override anything you specify in ``prog`` variable when
    creating the argument parser.
@@ -57,14 +57,14 @@ Help Messages
 =============
 
 By default, cmd2 uses the docstring of the command method when a user asks
-for help on the command. When you use the ``@with_argument_parser``
+for help on the command. When you use the ``@with_argparser``
 decorator, the docstring for the ``do_*`` method is used to set the description for the ``argparse.ArgumentParser`` is
 With this code::
 
    argparser = argparse.ArgumentParser()
    argparser.add_argument('tag', help='tag')
    argparser.add_argument('content', nargs='+', help='content to surround with tag')
-   @with_argument_parser(argparser)
+   @with_argparser(argparser)
    def do_tag(self, args):
       """create a html tag"""
       self.stdout.write('<{0}>{1}</{0}>'.format(args.tag, ' '.join(args.content)))
@@ -92,7 +92,7 @@ docstring on your method empty::
    argparser = argparse.ArgumentParser(description='create an html tag')
    argparser.add_argument('tag', help='tag')
    argparser.add_argument('content', nargs='+', help='content to surround with tag')
-   @with_argument_parser(argparser)
+   @with_argparser(argparser)
    def do_tag(self, args):
       self.stdout.write('<{0}>{1}</{0}>'.format(args.tag, ' '.join(args.content)))
       self.stdout.write('\n')
@@ -121,7 +121,7 @@ To add additional text to the end of the generated help message, use the ``epilo
    )
    argparser.add_argument('tag', help='tag')
    argparser.add_argument('content', nargs='+', help='content to surround with tag')
-   @with_argument_parser(argparser)
+   @with_argparser(argparser)
    def do_tag(self, args):
       self.stdout.write('<{0}>{1}</{0}>'.format(args.tag, ' '.join(args.content)))
       self.stdout.write('\n')
@@ -190,7 +190,7 @@ Here's what it looks like::
 
 Sub-commands
 ============
-Sub-commands are supported for commands using either the ``@with_argument_parser`` or
+Sub-commands are supported for commands using either the ``@with_argparser`` or
 ``@with_argparser_and_unknown_args`` decorator.  The syntax for supporting them is based on argparse sub-parsers.
 
 See the subcommands_ example to learn more about how to use sub-commands in your ``cmd2`` application.

examples/arg_print.py

@@ -14,7 +14,7 @@
 import cmd2
 import pyparsing
 
-from cmd2 import with_argument_list, with_argument_parser, with_argparser_and_unknown_args
+from cmd2 import with_argument_list, with_argparser, with_argparser_and_unknown_args
 
 
 class ArgumentAndOptionPrinter(cmd2.Cmd):
@@ -47,7 +47,7 @@ def do_lprint(self, arglist):
     oprint_parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
     oprint_parser.add_argument('words', nargs='+', help='words to print')
 
-    @with_argument_parser(oprint_parser)
+    @with_argparser(oprint_parser)
     def do_oprint(self, args):
         """Print the options and argument list this options command was called with."""
         print('oprint was called with the following\n\toptions: {!r}'.format(args))

examples/argparse_example.py

@@ -14,7 +14,7 @@
 import argparse
 import sys
 
-from cmd2 import Cmd, options, with_argument_parser, with_argument_list
+from cmd2 import Cmd, options, with_argparser, with_argument_list
 from optparse import make_option
 
 
@@ -47,7 +47,7 @@ def __init__(self, ip_addr=None, port=None, transcript_files=None):
     speak_parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
     speak_parser.add_argument('words', nargs='+', help='words to say')
 
-    @with_argument_parser(speak_parser)
+    @with_argparser(speak_parser)
     def do_speak(self, args):
         """Repeats what you tell me to."""
         words = []
@@ -68,7 +68,7 @@ def do_speak(self, args):
     tag_parser.add_argument('tag', help='tag')
     tag_parser.add_argument('content', nargs='+', help='content to surround with tag')
 
-    @with_argument_parser(tag_parser)
+    @with_argparser(tag_parser)
     def do_tag(self, args):
         """create a html tag"""
         self.poutput('<{0}>{1}</{0}>'.format(args.tag, ' '.join(args.content)))

examples/example.py

@@ -14,7 +14,7 @@
 import random
 import argparse
 
-from cmd2 import Cmd, with_argument_parser
+from cmd2 import Cmd, with_argparser
 
 
 class CmdLineApp(Cmd):
@@ -44,7 +44,7 @@ def __init__(self):
     speak_parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
     speak_parser.add_argument('words', nargs='+', help='words to say')
 
-    @with_argument_parser(speak_parser)
+    @with_argparser(speak_parser)
     def do_speak(self, args):
         """Repeats what you tell me to."""
         words = []
@@ -66,7 +66,7 @@ def do_speak(self, args):
     mumble_parser.add_argument('-r', '--repeat', type=int, help='how many times to repeat')
     mumble_parser.add_argument('words', nargs='+', help='words to say')
 
-    @with_argument_parser(mumble_parser)
+    @with_argparser(mumble_parser)
     def do_mumble(self, args):
         """Mumbles what you tell me to."""
         repetitions = args.repeat or 1

examples/pirate.py

@@ -7,7 +7,7 @@
 It demonstrates many features of cmd2.
 """
 import argparse
-from cmd2 import Cmd, with_argument_parser
+from cmd2 import Cmd, with_argparser
 
 
 class Pirate(Cmd):
@@ -78,7 +78,7 @@ def do_sing(self, arg):
     yo_parser.add_argument('-c', '--commas', action='store_true', help='Intersperse commas')
     yo_parser.add_argument('beverage', help='beverage to drink with the chant')
 
-    @with_argument_parser(yo_parser)
+    @with_argparser(yo_parser)
     def do_yo(self, args):
         """Compose a yo-ho-ho type chant with flexible options."""
         chant = ['yo'] + ['ho'] * args.ho

examples/subcommands.py

@@ -9,7 +9,7 @@
 import argparse
 
 import cmd2
-from cmd2 import with_argument_parser
+from cmd2 import with_argparser
 
 
 class SubcommandsExample(cmd2.Cmd):
@@ -19,11 +19,11 @@ def __init__(self):
         cmd2.Cmd.__init__(self)
 
     # sub-command functions for the base command
-    def foo(self, args):
+    def base_foo(self, args):
         """foo subcommand of base command"""
         self.poutput(args.x * args.y)
 
-    def bar(self, args):
+    def base_bar(self, args):
         """bar sucommand of base command"""
         self.poutput('((%s))' % args.z)
 
@@ -35,17 +35,17 @@ def bar(self, args):
     parser_foo = base_subparsers.add_parser('foo', help='foo help')
     parser_foo.add_argument('-x', type=int, default=1, help='integer')
     parser_foo.add_argument('y', type=float, help='float')
-    parser_foo.set_defaults(func=foo)
+    parser_foo.set_defaults(func=base_foo)
 
     # create the parser for the "bar" sub-command
     parser_bar = base_subparsers.add_parser('bar', help='bar help')
     parser_bar.add_argument('z', help='string')
-    parser_bar.set_defaults(func=bar)
+    parser_bar.set_defaults(func=base_bar)
 
     # Create a list of subcommand names, which is used to enable tab-completion of sub-commands
     subcommands = ['foo', 'bar']
 
-    @with_argument_parser(base_parser, subcommands)
+    @with_argparser(base_parser, subcommands)
     def do_base(self, args):
         """Base command help"""
         try:

tests/test_argparse.py

@@ -20,7 +20,7 @@ def __init__(self):
     say_parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
     say_parser.add_argument('words', nargs='+', help='words to say')
 
-    @cmd2.with_argument_parser(say_parser)
+    @cmd2.with_argparser(say_parser)
     def do_say(self, args):
         """Repeat what you tell me to."""
         words = []
@@ -41,7 +41,7 @@ def do_say(self, args):
     tag_parser.add_argument('tag', help='tag')
     tag_parser.add_argument('content', nargs='+', help='content to surround with tag')
 
-    @cmd2.with_argument_parser(tag_parser)
+    @cmd2.with_argparser(tag_parser)
     def do_tag(self, args):
         self.stdout.write('<{0}>{1}</{0}>'.format(args.tag, ' '.join(args.content)))
         self.stdout.write('\n')
@@ -178,11 +178,11 @@ def __init__(self):
         cmd2.Cmd.__init__(self)
 
     # sub-command functions for the base command
-    def foo(self, args):
+    def base_foo(self, args):
         """foo subcommand of base command"""
         self.poutput(args.x * args.y)
 
-    def bar(self, args):
+    def base_bar(self, args):
         """bar sucommand of base command"""
         self.poutput('((%s))' % args.z)
 
@@ -194,12 +194,12 @@ def bar(self, args):
     parser_foo = base_subparsers.add_parser('foo', help='foo help')
     parser_foo.add_argument('-x', type=int, default=1, help='integer')
     parser_foo.add_argument('y', type=float, help='float')
-    parser_foo.set_defaults(func=foo)
+    parser_foo.set_defaults(func=base_foo)
 
     # create the parser for the "bar" sub-command
     parser_bar = base_subparsers.add_parser('bar', help='bar help')
     parser_bar.add_argument('z', help='string')
-    parser_bar.set_defaults(func=bar)
+    parser_bar.set_defaults(func=base_bar)
 
     # Create a list of subcommand names, which is used to enable tab-completion of sub-commands
     subcommands = ['foo', 'bar']

tests/test_completion.py

@@ -429,11 +429,11 @@ def __init__(self):
         cmd2.Cmd.__init__(self)
 
     # sub-command functions for the base command
-    def foo(self, args):
+    def base_foo(self, args):
         """foo subcommand of base command"""
         self.poutput(args.x * args.y)
 
-    def bar(self, args):
+    def base_bar(self, args):
         """bar sucommand of base command"""
         self.poutput('((%s))' % args.z)
 
@@ -445,17 +445,17 @@ def bar(self, args):
     parser_foo = base_subparsers.add_parser('foo', help='foo help')
     parser_foo.add_argument('-x', type=int, default=1, help='integer')
     parser_foo.add_argument('y', type=float, help='float')
-    parser_foo.set_defaults(func=foo)
+    parser_foo.set_defaults(func=base_foo)
 
     # create the parser for the "bar" sub-command
     parser_bar = base_subparsers.add_parser('bar', help='bar help')
     parser_bar.add_argument('z', help='string')
-    parser_bar.set_defaults(func=bar)
+    parser_bar.set_defaults(func=base_bar)
 
     # Create a list of subcommand names, which is used to enable tab-completion of sub-commands
     subcommands = ['foo', 'bar']
 
-    @cmd2.with_argument_parser(base_parser, subcommands)
+    @cmd2.with_argparser(base_parser, subcommands)
     def do_base(self, args):
         """Base command help"""
         try: