Let ruff format code in docstrings the same way it formats our code

Author: tleonhardt

cmd2/annotated.py

@@ -32,6 +32,7 @@ def do_greet(self, name: str, count: int = 1, loud: bool = False):
 
     from typing import Annotated
 
+
     class MyApp(cmd2.Cmd):
         def color_choices(self) -> cmd2.Choices:
             return cmd2.Choices.from_values(["red", "green", "blue"])
@@ -40,9 +41,7 @@ def color_choices(self) -> cmd2.Choices:
         def do_paint(
             self,
             item: str,
-            color: Annotated[str, Option("--color", "-c",
-                                         choices_provider=color_choices,
-                                         help_text="Color to use")] = "blue",
+            color: Annotated[str, Option("--color", "-c", choices_provider=color_choices, help_text="Color to use")] = "blue",
         ):
             self.poutput(f"Painting {item} {color}")
 

cmd2/argparse_utils.py

@@ -16,10 +16,10 @@
 Example::
 
     # -f argument expects at least 3 values
-    parser.add_argument('-f', nargs=(3,))
+    parser.add_argument("-f", nargs=(3,))
 
     # -f argument expects 3 to 5 values
-    parser.add_argument('-f', nargs=(3, 5))
+    parser.add_argument("-f", nargs=(3, 5))
 
 
 **Completion**
@@ -38,8 +38,8 @@
 
     Example::
 
-        my_list = ['An Option', 'SomeOtherOption']
-        parser.add_argument('-o', '--options', choices=my_list)
+        my_list = ["An Option", "SomeOtherOption"]
+        parser.add_argument("-o", "--options", choices=my_list)
 
 ``choices_provider`` - pass a function that returns a Choices object. This is good in
 cases where the choices are dynamically generated when the user hits tab.
@@ -50,6 +50,7 @@ def my_choices_provider(self) -> Choices:
             ...
             return my_choices
 
+
         parser.add_argument("arg", choices_provider=my_choices_provider)
 
 ``completer`` - pass a function that does custom completion and returns a Completions object.
@@ -60,17 +61,16 @@ def my_choices_provider(self) -> Choices:
     Example::
 
         # This adds file-path completion to an argument
-        parser.add_argument('-o', '--options', completer=cmd2.Cmd.path_complete)
+        parser.add_argument("-o", "--options", completer=cmd2.Cmd.path_complete)
 
     You can use functools.partial() to prepopulate values of the underlying
     choices and completer functions/methods.
 
     Example::
 
         # This says to call path_complete with a preset value for its path_filter argument
-        dir_completer = functools.partial(path_complete,
-                                          path_filter=lambda path: os.path.isdir(path))
-        parser.add_argument('-o', '--options', completer=dir_completer)
+        dir_completer = functools.partial(path_complete, path_filter=lambda path: os.path.isdir(path))
+        parser.add_argument("-o", "--options", completer=dir_completer)
 
 For ``choices_provider`` and ``completer``, do not set them to a bound method. This
 is because ArgparseCompleter passes the `self` argument explicitly to these

cmd2/decorators.py

@@ -52,7 +52,7 @@ def with_category(
     Example:
     ```py
     class MyApp(cmd2.Cmd):
-        @cmd2.with_category('Text Functions')
+        @cmd2.with_category("Text Functions")
         def do_echo(self, args: cmd2.Statement) -> None:
             self.poutput(args)
     ```
@@ -159,12 +159,12 @@ class MyApp(cmd2.Cmd):
         # Basic usage: receives a list of words with quotes stripped
         @cmd2.with_argument_list
         def do_echo(self, arglist: list[str]) -> None:
-            self.poutput(' '.join(arglist))
+            self.poutput(" ".join(arglist))
 
         # Factory usage: preserves quotes in the argument list
         @cmd2.with_argument_list(preserve_quotes=True)
         def do_print_raw(self, arglist: list[str]) -> None:
-            self.poutput(' '.join(arglist))
+            self.poutput(" ".join(arglist))
     ```
 
     """
@@ -268,32 +268,34 @@ def with_argparser(
     Example:
     ```py
     parser = cmd2.Cmd2ArgumentParser()
-    parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
-    parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
-    parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
-    parser.add_argument('words', nargs='+', help='words to print')
+    parser.add_argument("-p", "--piglatin", action="store_true", help="atinLay")
+    parser.add_argument("-s", "--shout", action="store_true", help="N00B EMULATION MODE")
+    parser.add_argument("-r", "--repeat", type=int, help="output [n] times")
+    parser.add_argument("words", nargs="+", help="words to print")
+
 
     class MyApp(cmd2.Cmd):
         @cmd2.with_argparser(parser, preserve_quotes=True)
         def do_argprint(self, args: argparse.Namespace) -> None:
             "Print the options and argument list this options command was called with."
-            self.poutput(f'args: {args!r}')
+            self.poutput(f"args: {args!r}")
     ```
 
     Example with unknown args:
 
     ```py
     parser = cmd2.Cmd2ArgumentParser()
-    parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
-    parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
-    parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
+    parser.add_argument("-p", "--piglatin", action="store_true", help="atinLay")
+    parser.add_argument("-s", "--shout", action="store_true", help="N00B EMULATION MODE")
+    parser.add_argument("-r", "--repeat", type=int, help="output [n] times")
+
 
     class MyApp(cmd2.Cmd):
         @cmd2.with_argparser(parser, with_unknown_args=True)
         def do_argprint(self, args: argparse.Namespace, unknown_args: list[str]):
             "Print the options and argument list this options command was called with."
-            self.poutput(f'args: {args!r}')
-            self.poutput(f'unknown_args: {unknown_args}')
+            self.poutput(f"args: {args!r}")
+            self.poutput(f"unknown_args: {unknown_args}")
     ```
 
     """
@@ -447,14 +449,15 @@ def as_subcommand_to(
     base_parser.add_subparsers(title="subcommands", metavar="SUBCOMMAND", required=True)
     sub_parser = cmd2.Cmd2ArgumentParser()
 
+
     class MyApp(cmd2.Cmd):
         @cmd2.with_argparser(base_parser)
         def do_base(self, args: argparse.Namespace) -> None:
             args.cmd2_subcmd_handler(args)
 
-        @cmd2.as_subcommand_to('base', 'sub', sub_parser, help="the subcommand")
+        @cmd2.as_subcommand_to("base", "sub", sub_parser, help="the subcommand")
         def sub_handler(self, args: argparse.Namespace) -> None:
-            self.poutput('Subcommand executed')
+            self.poutput("Subcommand executed")
     ```
 
     """

cmd2/parsing.py

@@ -356,7 +356,7 @@ def is_valid_command(self, word: str, *, is_subcommand: bool = False) -> tuple[b
         If word is not a valid command, return ``False`` and an error string
         suitable for inclusion in an error message of your choice::
 
-            checkit = '>'
+            checkit = ">"
             valid, errmsg = statement_parser.is_valid_command(checkit)
             if not valid:
                 errmsg = f"alias: {errmsg}"

ruff.toml

@@ -179,7 +179,7 @@ line-ending = "auto"
 #
 # This is currently disabled by default, but it is planned for this
 # to be opt-out in the future.
-docstring-code-format = false
+docstring-code-format = true
 
 # Set the line length limit used when formatting code snippets in
 # docstrings.