eightball/PluralKit
1
0
Fork 0
mirror of https://github.com/PluralKit/PluralKit.git synced 2026-02-13 09:10:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

implement rest of group and member commands

Browse source
This commit is contained in:
dusk 2025-10-01 00:51:45 +00:00
parent 95fc7e9f60
commit 1943687c70
No known key found for this signature in database
13 changed files with 705 additions and 443 deletions
Download patch file Download diff file Expand all files Collapse all files

156
crates/command_definitions/src/group.rs
View file

@ -16,6 +16,136 @@ pub fn cmds() -> impl Iterator<Item = Command> {
let group = group();
let group_target = targeted();
let group_new = tokens!(group, ("new", ["n"]));
let group_new_cmd =
[command!(group_new, ("name", OpaqueString) => "group_new").help("Creates a new group")]
.into_iter();
let group_info_cmd =
[command!(group_target => "group_info").help("Shows information about a group")]
.into_iter();
let group_name = tokens!(
group_target,
("name", ["rename", "changename", "setname", "rn"])
);
let group_name_cmd = [
command!(group_name => "group_show_name").help("Shows the group's name"),
command!(group_name, ("clear", ["c"]) => "group_clear_name")
.flag(("yes", ["y"]))
.help("Clears the group's name"),
command!(group_name, ("name", OpaqueString) => "group_rename").help("Renames the group"),
]
.into_iter();
let group_display_name = tokens!(group_target, ("displayname", ["dn", "nick", "nickname"]));
let group_display_name_cmd = [
command!(group_display_name => "group_show_display_name")
.help("Shows the group's display name"),
command!(group_display_name, ("clear", ["c"]) => "group_clear_display_name")
.flag(("yes", ["y"]))
.help("Clears the group's display name"),
command!(group_display_name, ("name", OpaqueString) => "group_change_display_name")
.help("Changes the group's display name"),
]
.into_iter();
let group_description = tokens!(
group_target,
(
"description",
["desc", "describe", "d", "bio", "info", "text", "intro"]
)
);
let group_description_cmd = [
command!(group_description => "group_show_description")
.help("Shows the group's description"),
command!(group_description, ("clear", ["c"]) => "group_clear_description")
.flag(("yes", ["y"]))
.help("Clears the group's description"),
command!(group_description, ("description", OpaqueString) => "group_change_description")
.help("Changes the group's description"),
]
.into_iter();
let group_icon = tokens!(
group_target,
("icon", ["avatar", "picture", "image", "pic", "pfp"])
);
let group_icon_cmd = [
command!(group_icon => "group_show_icon").help("Shows the group's icon"),
command!(group_icon, ("clear", ["c"]) => "group_clear_icon")
.flag(("yes", ["y"]))
.help("Clears the group's icon"),
command!(group_icon, ("icon", Avatar) => "group_change_icon")
.help("Changes the group's icon"),
]
.into_iter();
let group_banner = tokens!(group_target, ("banner", ["splash", "cover"]));
let group_banner_cmd = [
command!(group_banner => "group_show_banner").help("Shows the group's banner"),
command!(group_banner, ("clear", ["c"]) => "group_clear_banner")
.flag(("yes", ["y"]))
.help("Clears the group's banner"),
command!(group_banner, ("banner", Avatar) => "group_change_banner")
.help("Changes the group's banner"),
]
.into_iter();
let group_color = tokens!(group_target, ("color", ["colour"]));
let group_color_cmd = [
command!(group_color => "group_show_color").help("Shows the group's color"),
command!(group_color, ("clear", ["c"]) => "group_clear_color")
.flag(("yes", ["y"]))
.help("Clears the group's color"),
command!(group_color, ("color", OpaqueString) => "group_change_color")
.help("Changes the group's color"),
]
.into_iter();
let group_privacy = tokens!(group_target, ("privacy", ["priv"]));
let group_privacy_cmd = [
command!(group_privacy => "group_show_privacy")
.help("Shows the group's privacy settings"),
command!(group_privacy, ("all", ["a"]), ("level", PrivacyLevel) => "group_change_privacy_all")
.help("Changes all privacy settings for the group"),
command!(group_privacy, ("privacy", GroupPrivacyTarget), ("level", PrivacyLevel) => "group_change_privacy")
.help("Changes a specific privacy setting for the group"),
]
.into_iter();
let group_public_cmd = [
command!(group_target, ("public", ["pub"]) => "group_set_public")
.help("Sets the group to public"),
]
.into_iter();
let group_private_cmd = [
command!(group_target, ("private", ["priv"]) => "group_set_private")
.help("Sets the group to private"),
]
.into_iter();
let group_delete_cmd = [
command!(group_target, ("delete", ["destroy", "erase", "yeet"]) => "group_delete")
.flag(("yes", ["y"]))
.help("Deletes the group"),
]
.into_iter();
let group_id_cmd =
[command!(group_target, "id" => "group_id").help("Shows the group's ID")].into_iter();
let group_front = tokens!(group_target, ("front", ["fronter", "fronters", "f"]));
let group_front_cmd = [
command!(group_front, ("percent", ["p", "%"]) => "group_fronter_percent")
.flag(("duration", OpaqueString))
.flag(("fronters-only", ["fo"]))
.flag("flat"),
]
.into_iter();
let apply_list_opts = |cmd: Command| cmd.flags(get_list_flags());
let group_list_members = tokens!(group_target, ("members", ["list", "ls"]));
@ -27,6 +157,14 @@ pub fn cmds() -> impl Iterator<Item = Command> {
.into_iter()
.map(apply_list_opts);
let group_modify_members_cmd = [
command!(group_target, "add", MemberRefs => "group_add_member")
.flag(("all", ["a"])),
command!(group_target, ("remove", ["delete", "del", "rem"]), MemberRefs => "group_remove_member")
.flag(("all", ["a"])),
]
.into_iter();
let system_groups_cmd = [
command!(group, ("list", ["ls"]) => "group_list_groups"),
command!(group, ("search", ["find", "query"]), ("query", OpaqueStringRemainder) => "group_search_groups"),
@ -34,5 +172,21 @@ pub fn cmds() -> impl Iterator<Item = Command> {
.into_iter()
.map(apply_list_opts);
system_groups_cmd.chain(group_list_members_cmd)
group_new_cmd
.chain(group_info_cmd)
.chain(group_name_cmd)
.chain(group_display_name_cmd)
.chain(group_description_cmd)
.chain(group_icon_cmd)
.chain(group_banner_cmd)
.chain(group_color_cmd)
.chain(group_privacy_cmd)
.chain(group_public_cmd)
.chain(group_private_cmd)
.chain(group_front_cmd)
.chain(group_modify_members_cmd)
.chain(group_delete_cmd)
.chain(group_id_cmd)
.chain(group_list_members_cmd)
.chain(system_groups_cmd)
}

16
crates/command_definitions/src/member.rs
View file

@ -301,7 +301,17 @@ pub fn cmds() -> impl Iterator<Item = Command> {
]
.into_iter()
.map(|cmd| cmd.flags(get_list_flags()));
let member_group_cmds = member_list_group_cmds;
let member_add_remove_group_cmds = [
command!(member_group, "add", ("groups", GroupRefs) => "member_group_add")
.help("Adds a member to one or more groups"),
command!(member_group, ("remove", ["rem"]), ("groups", GroupRefs) => "member_group_remove")
.help("Removes a member from one or more groups"),
]
.into_iter();
let member_display_id_cmd =
[command!(member_target, "id" => "member_id").help("Displays a member's ID")].into_iter();
let member_delete_cmd =
[command!(member_target, delete => "member_delete").help("Deletes a member")].into_iter();
@ -325,7 +335,9 @@ pub fn cmds() -> impl Iterator<Item = Command> {
.chain(member_avatar_cmds)
.chain(member_proxy_settings_cmd)
.chain(member_message_settings_cmd)
.chain(member_display_id_cmd)
.chain(member_delete_cmd)
.chain(member_easter_eggs)
.chain(member_group_cmds)
.chain(member_list_group_cmds)
.chain(member_add_remove_group_cmds)
}

68
crates/command_parser/src/parameter.rs
View file

@ -13,9 +13,11 @@ pub enum ParameterValue {
MemberRef(String),
MemberRefs(Vec<String>),
GroupRef(String),
GroupRefs(Vec<String>),
SystemRef(String),
GuildRef(String),
MemberPrivacyTarget(String),
GroupPrivacyTarget(String),
SystemPrivacyTarget(String),
PrivacyLevel(String),
Toggle(bool),
@ -50,9 +52,11 @@ impl Display for Parameter {
ParameterKind::MemberRef => write!(f, "<target member>"),
ParameterKind::MemberRefs => write!(f, "<member 1> <member 2> <member 3>..."),
ParameterKind::GroupRef => write!(f, "<target group>"),
ParameterKind::GroupRefs => write!(f, "<group 1> <group 2> <group 3>..."),
ParameterKind::SystemRef => write!(f, "<target system>"),
ParameterKind::GuildRef => write!(f, "<target guild>"),
ParameterKind::MemberPrivacyTarget => write!(f, "<privacy target>"),
ParameterKind::GroupPrivacyTarget => write!(f, "<privacy target>"),
ParameterKind::SystemPrivacyTarget => write!(f, "<privacy target>"),
ParameterKind::PrivacyLevel => write!(f, "[privacy level]"),
ParameterKind::Toggle => write!(f, "on/off"),
@ -86,9 +90,11 @@ pub enum ParameterKind {
MemberRef,
MemberRefs,
GroupRef,
GroupRefs,
SystemRef,
GuildRef,
MemberPrivacyTarget,
GroupPrivacyTarget,
SystemPrivacyTarget,
PrivacyLevel,
Toggle,
@ -103,9 +109,11 @@ impl ParameterKind {
ParameterKind::MemberRef => "target",
ParameterKind::MemberRefs => "targets",
ParameterKind::GroupRef => "target",
ParameterKind::GroupRefs => "targets",
ParameterKind::SystemRef => "target",
ParameterKind::GuildRef => "target",
ParameterKind::MemberPrivacyTarget => "member_privacy_target",
ParameterKind::GroupPrivacyTarget => "group_privacy_target",
ParameterKind::SystemPrivacyTarget => "system_privacy_target",
ParameterKind::PrivacyLevel => "privacy_level",
ParameterKind::Toggle => "toggle",
@ -116,7 +124,9 @@ impl ParameterKind {
pub(crate) fn remainder(&self) -> bool {
matches!(
self,
ParameterKind::OpaqueStringRemainder | ParameterKind::MemberRefs
ParameterKind::OpaqueStringRemainder
| ParameterKind::MemberRefs
| ParameterKind::GroupRefs
)
}
@ -127,6 +137,9 @@ impl ParameterKind {
Ok(ParameterValue::OpaqueString(input.into()))
}
ParameterKind::GroupRef => Ok(ParameterValue::GroupRef(input.into())),
ParameterKind::GroupRefs => Ok(ParameterValue::GroupRefs(
input.split(' ').map(|s| s.trim().to_string()).collect(),
)),
ParameterKind::MemberRef => Ok(ParameterValue::MemberRef(input.into())),
ParameterKind::MemberRefs => Ok(ParameterValue::MemberRefs(
input.split(' ').map(|s| s.trim().to_string()).collect(),
@ -134,6 +147,8 @@ impl ParameterKind {
ParameterKind::SystemRef => Ok(ParameterValue::SystemRef(input.into())),
ParameterKind::MemberPrivacyTarget => MemberPrivacyTargetKind::from_str(input)
.map(|target| ParameterValue::MemberPrivacyTarget(target.as_ref().into())),
ParameterKind::GroupPrivacyTarget => GroupPrivacyTargetKind::from_str(input)
.map(|target| ParameterValue::GroupPrivacyTarget(target.as_ref().into())),
ParameterKind::SystemPrivacyTarget => SystemPrivacyTargetKind::from_str(input)
.map(|target| ParameterValue::SystemPrivacyTarget(target.as_ref().into())),
ParameterKind::PrivacyLevel => PrivacyLevelKind::from_str(input)
@ -146,8 +161,13 @@ impl ParameterKind {
}
}
pub(crate) fn skip_if_cant_match(&self) -> bool {
matches!(self, ParameterKind::Toggle)
pub(crate) fn skip_if_cant_match(&self) -> Option<Option<ParameterValue>> {
match self {
ParameterKind::Toggle => Some(None),
ParameterKind::MemberRefs => Some(Some(ParameterValue::MemberRefs(Vec::new()))),
ParameterKind::GroupRefs => Some(Some(ParameterValue::GroupRefs(Vec::new()))),
_ => None,
}
}
}
@ -200,6 +220,48 @@ impl FromStr for MemberPrivacyTargetKind {
}
}
pub enum GroupPrivacyTargetKind {
Name,
Icon,
Description,
Banner,
List,
Metadata,
Visibility,
}
impl AsRef<str> for GroupPrivacyTargetKind {
fn as_ref(&self) -> &str {
match self {
Self::Name => "name",
Self::Icon => "icon",
Self::Description => "description",
Self::Banner => "banner",
Self::List => "list",
Self::Metadata => "metadata",
Self::Visibility => "visibility",
}
}
}
impl FromStr for GroupPrivacyTargetKind {
type Err = SmolStr;
fn from_str(s: &str) -> Result<Self, Self::Err> {
// todo: this doesnt parse all the possible ways
match s.to_lowercase().as_str() {
"name" => Ok(Self::Name),
"avatar" | "icon" => Ok(Self::Icon),
"description" => Ok(Self::Description),
"banner" => Ok(Self::Banner),
"list" => Ok(Self::List),
"metadata" => Ok(Self::Metadata),
"visibility" => Ok(Self::Visibility),
_ => Err("invalid group privacy target".into()),
}
}
}
pub enum SystemPrivacyTargetKind {
Name,
Avatar,

10
crates/command_parser/src/token.rs
View file

@ -68,8 +68,14 @@ impl Token {
value: matched,
},
Err(err) => {
if param.kind().skip_if_cant_match() {
return None;
if let Some(maybe_empty) = param.kind().skip_if_cant_match() {
match maybe_empty {
Some(matched) => TokenMatchResult::MatchedParameter {
name: param.name().into(),
value: matched,
},
None => return None,
}
} else {
TokenMatchResult::ParameterMatchError {
input: input.into(),

4
crates/commands/src/bin/write_cs_glue.rs
View file

@ -258,8 +258,10 @@ fn get_param_ty(kind: ParameterKind) -> &'static str {
ParameterKind::MemberRef => "PKMember",
ParameterKind::MemberRefs => "List<PKMember>",
ParameterKind::GroupRef => "PKGroup",
ParameterKind::GroupRefs => "List<PKGroup>",
ParameterKind::SystemRef => "PKSystem",
ParameterKind::MemberPrivacyTarget => "MemberPrivacySubject",
ParameterKind::GroupPrivacyTarget => "GroupPrivacySubject",
ParameterKind::SystemPrivacyTarget => "SystemPrivacySubject",
ParameterKind::PrivacyLevel => "PrivacyLevel",
ParameterKind::Toggle => "bool",
@ -274,8 +276,10 @@ fn get_param_param_ty(kind: ParameterKind) -> &'static str {
ParameterKind::MemberRef => "Member",
ParameterKind::MemberRefs => "Members",
ParameterKind::GroupRef => "Group",
ParameterKind::GroupRefs => "Groups",
ParameterKind::SystemRef => "System",
ParameterKind::MemberPrivacyTarget => "MemberPrivacyTarget",
ParameterKind::GroupPrivacyTarget => "GroupPrivacyTarget",
ParameterKind::SystemPrivacyTarget => "SystemPrivacyTarget",
ParameterKind::PrivacyLevel => "PrivacyLevel",
ParameterKind::Toggle => "Toggle",

2
crates/commands/src/commands.udl
View file

@ -11,9 +11,11 @@ interface Parameter {
MemberRef(string member);
MemberRefs(sequence<string> members);
GroupRef(string group);
GroupRefs(sequence<string> groups);
SystemRef(string system);
GuildRef(string guild);
MemberPrivacyTarget(string target);
GroupPrivacyTarget(string target);
SystemPrivacyTarget(string target);
PrivacyLevel(string level);
OpaqueString(string raw);

4
crates/commands/src/lib.rs
View file

@ -25,9 +25,11 @@ pub enum Parameter {
MemberRef { member: String },
MemberRefs { members: Vec<String> },
GroupRef { group: String },
GroupRefs { groups: Vec<String> },
SystemRef { system: String },
GuildRef { guild: String },
MemberPrivacyTarget { target: String },
GroupPrivacyTarget { target: String },
SystemPrivacyTarget { target: String },
PrivacyLevel { level: String },
OpaqueString { raw: String },
@ -41,8 +43,10 @@ impl From<ParameterValue> for Parameter {
ParameterValue::MemberRef(member) => Self::MemberRef { member },
ParameterValue::MemberRefs(members) => Self::MemberRefs { members },
ParameterValue::GroupRef(group) => Self::GroupRef { group },
ParameterValue::GroupRefs(groups) => Self::GroupRefs { groups },
ParameterValue::SystemRef(system) => Self::SystemRef { system },
ParameterValue::MemberPrivacyTarget(target) => Self::MemberPrivacyTarget { target },
ParameterValue::GroupPrivacyTarget(target) => Self::GroupPrivacyTarget { target },
ParameterValue::SystemPrivacyTarget(target) => Self::SystemPrivacyTarget { target },
ParameterValue::PrivacyLevel(level) => Self::PrivacyLevel { level },
ParameterValue::OpaqueString(raw) => Self::OpaqueString { raw },