feat: implement switch commands

crates/command_definitions/src/lib.rs

@@ -26,8 +26,8 @@ pub fn all() -> impl Iterator<Item = Command> {
         .chain(member::cmds())
         .chain(config::cmds())
         .chain(fun::cmds())
-        .map(|cmd| cmd.flag(("plaintext", ["pt"])))
-        .map(|cmd| cmd.flag(("raw", ["r"])))
+        .chain(switch::cmds())
+        .map(|cmd| cmd.flag(("plaintext", ["pt"])).flag(("raw", ["r"])))
 }
 
 pub const RESET: (&str, [&str; 2]) = ("reset", ["clear", "default"]);

crates/command_definitions/src/switch.rs

@@ -1 +1,31 @@
+use super::*;
 
+pub fn cmds() -> impl Iterator<Item = Command> {
+    let switch = ("switch", ["sw"]);
+
+    let edit = ("edit", ["e", "replace"]);
+    let r#move = ("move", ["m", "shift", "offset"]);
+    let delete = ("delete", ["remove", "erase", "cancel", "yeet"]);
+    let copy = ("copy", ["add", "duplicate", "dupe"]);
+    let out = "out";
+
+    [
+        command!(switch, out => "switch_out"),
+        command!(switch, r#move, OpaqueString => "switch_move"), // TODO: datetime parsing
+        command!(switch, delete => "switch_delete").flag(("all", ["clear", "c"])),
+        command!(switch, edit, out => "switch_edit_out"),
+        command!(switch, edit, MemberRefs => "switch_edit")
+            .flag(("first", ["f"]))
+            .flag(("remove", ["r"]))
+            .flag(("append", ["a"]))
+            .flag(("prepend", ["p"])),
+        command!(switch, copy, MemberRefs => "switch_copy")
+            .flag(("first", ["f"]))
+            .flag(("remove", ["r"]))
+            .flag(("append", ["a"]))
+            .flag(("prepend", ["p"])),
+        command!(switch, ("commands", ["help"]) => "switch_commands"),
+        command!(switch, MemberRefs => "switch_do"),
+    ]
+    .into_iter()
+}

crates/command_parser/src/parameter.rs

@@ -11,6 +11,7 @@ use crate::token::{Token, TokenMatchResult};
 pub enum ParameterValue {
     OpaqueString(String),
     MemberRef(String),
+    MemberRefs(Vec<String>),
     SystemRef(String),
     GuildRef(String),
     MemberPrivacyTarget(String),
@@ -39,10 +40,14 @@ impl Parameter {
 impl Display for Parameter {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self.kind {
-            ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => {
+            ParameterKind::OpaqueString => {
                 write!(f, "[{}]", self.name)
             }
+            ParameterKind::OpaqueStringRemainder => {
+                write!(f, "[{}]...", self.name)
+            }
             ParameterKind::MemberRef => write!(f, "<target member>"),
+            ParameterKind::MemberRefs => write!(f, "<member 1> <member 2> <member 3>..."),
             ParameterKind::SystemRef => write!(f, "<target system>"),
             ParameterKind::GuildRef => write!(f, "<target guild>"),
             ParameterKind::MemberPrivacyTarget => write!(f, "<privacy target>"),
@@ -77,6 +82,7 @@ pub enum ParameterKind {
     OpaqueString,
     OpaqueStringRemainder,
     MemberRef,
+    MemberRefs,
     SystemRef,
     GuildRef,
     MemberPrivacyTarget,
@@ -92,6 +98,7 @@ impl ParameterKind {
             ParameterKind::OpaqueString => "string",
             ParameterKind::OpaqueStringRemainder => "string",
             ParameterKind::MemberRef => "target",
+            ParameterKind::MemberRefs => "targets",
             ParameterKind::SystemRef => "target",
             ParameterKind::GuildRef => "target",
             ParameterKind::MemberPrivacyTarget => "member_privacy_target",
@@ -103,7 +110,10 @@ impl ParameterKind {
     }
 
     pub(crate) fn remainder(&self) -> bool {
-        matches!(self, ParameterKind::OpaqueStringRemainder)
+        matches!(
+            self,
+            ParameterKind::OpaqueStringRemainder | ParameterKind::MemberRefs
+        )
     }
 
     pub(crate) fn match_value(&self, input: &str) -> Result<ParameterValue, SmolStr> {
@@ -113,12 +123,14 @@ impl ParameterKind {
                 Ok(ParameterValue::OpaqueString(input.into()))
             }
             ParameterKind::MemberRef => Ok(ParameterValue::MemberRef(input.into())),
+            ParameterKind::MemberRefs => Ok(ParameterValue::MemberRefs(
+                input.split(' ').map(|s| s.trim().to_string()).collect(),
+            )),
             ParameterKind::SystemRef => Ok(ParameterValue::SystemRef(input.into())),
             ParameterKind::MemberPrivacyTarget => MemberPrivacyTargetKind::from_str(input)
                 .map(|target| ParameterValue::MemberPrivacyTarget(target.as_ref().into())),
-            ParameterKind::SystemPrivacyTarget => SystemPrivacyTargetKind::from_str(input).map(
-                |target| ParameterValue::SystemPrivacyTarget(target.as_ref().into()),
-            ),
+            ParameterKind::SystemPrivacyTarget => SystemPrivacyTargetKind::from_str(input)
+                .map(|target| ParameterValue::SystemPrivacyTarget(target.as_ref().into())),
             ParameterKind::PrivacyLevel => PrivacyLevelKind::from_str(input)
                 .map(|level| ParameterValue::PrivacyLevel(level.as_ref().into())),
             ParameterKind::Toggle => {

crates/commands/src/bin/write_cs_glue.rs

@@ -167,6 +167,7 @@ fn get_param_ty(kind: ParameterKind) -> &'static str {
     match kind {
         ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => "string",
         ParameterKind::MemberRef => "PKMember",
+        ParameterKind::MemberRefs => "List<PKMember>",
         ParameterKind::SystemRef => "PKSystem",
         ParameterKind::MemberPrivacyTarget => "MemberPrivacySubject",
         ParameterKind::SystemPrivacyTarget => "SystemPrivacySubject",
@@ -181,6 +182,7 @@ fn get_param_param_ty(kind: ParameterKind) -> &'static str {
     match kind {
         ParameterKind::OpaqueString | ParameterKind::OpaqueStringRemainder => "Opaque",
         ParameterKind::MemberRef => "Member",
+        ParameterKind::MemberRefs => "Members",
         ParameterKind::SystemRef => "System",
         ParameterKind::MemberPrivacyTarget => "MemberPrivacyTarget",
         ParameterKind::SystemPrivacyTarget => "SystemPrivacyTarget",

crates/commands/src/commands.udl

@@ -9,6 +9,7 @@ interface CommandResult {
 [Enum]
 interface Parameter {
 	MemberRef(string member);
+	MemberRefs(sequence<string> members);
 	SystemRef(string system);
 	GuildRef(string guild);
 	MemberPrivacyTarget(string target);

crates/commands/src/lib.rs

@@ -23,6 +23,7 @@ pub enum CommandResult {
 #[derive(Debug, Clone)]
 pub enum Parameter {
     MemberRef { member: String },
+    MemberRefs { members: Vec<String> },
     SystemRef { system: String },
     GuildRef { guild: String },
     MemberPrivacyTarget { target: String },
@@ -37,6 +38,7 @@ impl From<ParameterValue> for Parameter {
     fn from(value: ParameterValue) -> Self {
         match value {
             ParameterValue::MemberRef(member) => Self::MemberRef { member },
+            ParameterValue::MemberRefs(members) => Self::MemberRefs { members },
             ParameterValue::SystemRef(system) => Self::SystemRef { system },
             ParameterValue::MemberPrivacyTarget(target) => Self::MemberPrivacyTarget { target },
             ParameterValue::SystemPrivacyTarget(target) => Self::SystemPrivacyTarget { target },