Improve the converter for the closemessage cmd

Author: Qwerty-133

close_message/close_message.py

@@ -11,21 +11,50 @@
 
 
 class UserFriendlyTimeOnly(time.UserFriendlyTime):
-    """A convertor class to convert user friendly time to a duration."""
+    """
+    A converter which parses user-friendly time durations.
+
+    Since this converter is meant for parsing close messages while
+    closing threads, both custom close messages and time durations are
+    parsed.
+
+    A default duration of time to close after can be provided.
+    """
+
+    def __init__(self, *, default_close_duration: t.Optional[str] = None) -> None:
+        self.default_close_duration = default_close_duration
 
     async def convert(self, ctx: commands.Context, argument: str) -> str:
-        """Convert the given argument to a user friendly time."""
-        converted = await super().convert(ctx, argument)
-        if converted.arg:
-            raise commands.BadArgument(
-                f'`{argument}` isn\'t a valid duration string.'
-            )
-        converted.arg = CLOSING_MESSAGE
-        return converted
+        """
+        Parse the time duration if provided and prefix any message.
+
+        The default close message is used as the close message.
+        The default close message is appended if a custom close
+        message is provided.
+
+        If only an integer is passed in, it is treated as the number
+        of minutes to close after.
+        """
+        if argument.strip().isdigit():
+            argument = f'{argument}m'
+
+        await super().convert(ctx, argument)
+
+        if self.default_close_duration and self.arg == argument:
+            # the user didn't enter a time or duration
+            await super().convert(ctx, f'{self.default_close_duration} {argument}')
+
+        if self.arg:
+            add_period = not self.arg.endswith((".", "!", "?"))
+            self.arg = self.arg + (". " if add_period else " ") + CLOSING_MESSAGE
+        else:
+            self.arg = CLOSING_MESSAGE
+
+        return self
 
 
 class CloseMessage(commands.Cog):
-    """A plugin that adds a command to close a thread after a given period with a set message."""
+    """A plugin that adds a close command with a default close message."""
 
     def __init__(self, bot: ModmailBot):
         self.bot = bot
@@ -34,18 +63,37 @@ def __init__(self, bot: ModmailBot):
     @commands.group(
         name="closemessage",
         aliases=("cm",),
-        usage="[after]",
-        help=f"Close the current thread with the message `{CLOSING_MESSAGE}`",
+        usage="[after] [close message]",
         invoke_without_command=True
     )
     @checks.has_permissions(PermissionLevel.SUPPORTER)
     @checks.thread_only()
-    async def close_message(self, ctx: commands.Context, *, after: t.Union[int, str] = '15m') -> commands.Command:
-        """Close the thread after the given duration with the set message."""
-        if isinstance(after, int):
-            after = f'{after}m'
+    async def close_message(
+        self,
+        ctx: commands.Context,
+        *,
+        after: str = ''  # noqa: F722
+    ) -> commands.Command:
+        """
+        Close the current thread with a message.
+
+        The default close message is used as the close message.
+        The default close message is appended if a custom close
+        message is provided.
+
+        15 minutes is the default period of time before the thread
+        closes.
+
+        If only an integer is passed in, it is treated as the number
+        of minutes to close after.
 
-        after = await UserFriendlyTimeOnly().convert(ctx, after)
+        Run `{prefix}help close` for additional information on how
+        durations and custom close messages can be provided.
+        """
+        # We're doing the conversion here to make the argument optional
+        # while still passing the converted argument instead of an
+        # empty string to the close command.
+        after = await UserFriendlyTimeOnly(default_close_duration='15m').convert(ctx, after)
         return await self.close_command(ctx, after=after)
 
     @close_message.command(aliases=('msg',))