implement default spec argument types

1 files changed, 55 insertions, 12 deletions

diff --git a/src/utils/parse.py b/src/utils/parse.py
index aa7a9ee1..3af092f1 100644
--- a/src/utils/parse.py
+++ b/src/utils/parse.py
@@ -156,36 +156,79 @@ def format_token_replace(s: str, vars: typing.Dict[str, str],
         s = s[:i] + vars[token.replace(sigil, "", 1)] + s[i+len(token):]
     return s
 
-class ArgumentSpecType(object):
-    def __init__(self, type_name: str, name: str, exported: str):
+class SpecArgumentType(object):
+    def __init__(self, type_name: str, name: typing.Optional[str], exported: str):
         self.type = type_name
-        self.name = name
+        self._name = name
         self.exported = exported
 
-class ArgumentSpec(object):
-    def __init__(self, optional: bool, types: typing.List[ArgumentSpecType]):
+    def name(self) -> typing.Optional[str]:
+        return self._name
+    def simple(self, args: typing.List[str]) -> typing.Tuple[typing.Any, int]:
+        return None, -1
+    def error(self) -> typing.Optional[str]:
+        return None
+
+class SpecArgumentTypeWord(SpecArgumentType):
+    def simple(self, args: typing.List[str]) -> typing.Tuple[typing.Any, int]:
+        if args:
+            return args[0], 1
+        return None, 1
+class SpecArgumentTypeWordLower(SpecArgumentTypeWord):
+    def simple(self, args: typing.List[str]) -> typing.Tuple[typing.Any, int]:
+        out = SpecArgumentTypeWord.simple(self, args)
+        if out[0]:
+            return out[0].lower(), out[1]
+        return out
+
+class SpecArgumentTypeString(SpecArgumentType):
+    def name(self):
+        return "%s ..." % SpecArgumentType.name(self)
+    def simple(self, args: typing.List[str]) -> typing.Tuple[typing.Any, int]:
+        return " ".join(args), len(args)
+class SpecArgumentTypeTime(SpecArgumentType):
+    def name(self):
+        return "+%s" % (SpecArgumentType.name(self) or "time")
+    def simple(self, args: typing.List[str]) -> typing.Tuple[typing.Any, int]:
+        time, _ = timed_args(args)
+        return time, 1
+    def error(self) -> typing.Optional[str]:
+        return "Invalid timeframe"
+
+SPEC_ARGUMENT_TYPES = {
+    "word": SpecArgumentTypeWord,
+    "wordlower": SpecArgumentTypeWordLower,
+    "string": SpecArgumentTypeString,
+    "time": SpecArgumentTypeTime
+}
+
+class SpecArgument(object):
+    def __init__(self, optional: bool, types: typing.List[SpecArgumentType]):
         self.optional = optional
         self.types = types
 
-def argument_spec(spec: str) -> typing.List[ArgumentSpec]:
-    out: typing.List[ArgumentSpec] = []
+def argument_spec(spec: str) -> typing.List[SpecArgument]:
+    out: typing.List[SpecArgument] = []
     for spec_argument in spec.split(" "):
         optional = spec_argument[0] == "?"
 
-        argument_types: typing.List[ArgumentSpecType] = []
+        argument_types: typing.List[SpecArgumentType] = []
         for argument_type in spec_argument[1:].split("|"):
             exported = ""
             if "~" in argument_type:
                 exported = argument_type.split("~", 1)[1]
                 argument_type = argument_type.replace("~", "", 1)
 
-            argument_type_name = argument_type
+            argument_type_name: typing.Optional[str] = None
             name_end = argument_type.find(">")
-            if argument_type[0] == "<" and name_end > 0:
+            if argument_type.startswith("<") and name_end > 0:
                 argument_type_name = argument_type[1:name_end]
                 argument_type = argument_type[name_end+1:]
 
-            argument_types.append(ArgumentSpecType(argument_type,
+            argument_type_class = SpecArgumentType
+            if argument_type in SPEC_ARGUMENT_TYPES:
+                argument_type_class = SPEC_ARGUMENT_TYPES[argument_type]
+            argument_types.append(argument_type_class(argument_type,
                 argument_type_name, exported))
-        out.append(ArgumentSpec(optional, argument_types))
+        out.append(SpecArgument(optional, argument_types))
     return out