From 12370ab07609bf78baef4ec2302fa4ba44317dae Mon Sep 17 00:00:00 2001 From: mat Date: Fri, 5 May 2023 23:09:57 -0500 Subject: change some things to be Arc+RwLock in brigadier --- .../tests/builder/argument_builder_test.rs | 13 +++++------ azalea-brigadier/tests/command_dispatcher_test.rs | 25 ++++++++++++---------- 2 files changed, 21 insertions(+), 17 deletions(-) (limited to 'azalea-brigadier/tests') diff --git a/azalea-brigadier/tests/builder/argument_builder_test.rs b/azalea-brigadier/tests/builder/argument_builder_test.rs index e570c988..ee44f5e6 100755 --- a/azalea-brigadier/tests/builder/argument_builder_test.rs +++ b/azalea-brigadier/tests/builder/argument_builder_test.rs @@ -17,13 +17,14 @@ use super::ArgumentBuilder; // @Test // public void testArguments() throws Exception { -// final RequiredArgumentBuilder argument = argument("bar", integer()); +// final RequiredArgumentBuilder argument = argument("bar", +// integer()); // builder.then(argument); // assertThat(builder.getArguments(), hasSize(1)); -// assertThat(builder.getArguments(), hasItem((CommandNode) argument.build())); -// } +// assertThat(builder.getArguments(), hasItem((CommandNode) +// argument.build())); } #[test] fn test_arguments() { @@ -37,7 +38,7 @@ fn test_arguments() { .arguments .children .values() - .any(|e| *e.borrow() == *built_argument)); + .any(|e| *e.read() == *built_argument)); } // @Test @@ -61,8 +62,8 @@ fn test_arguments() { // builder.then(literal("foo")); // } -// private static class TestableArgumentBuilder extends ArgumentBuilder> { -// @Override +// private static class TestableArgumentBuilder extends +// ArgumentBuilder> { @Override // protected TestableArgumentBuilder getThis() { // return this; // } diff --git a/azalea-brigadier/tests/command_dispatcher_test.rs b/azalea-brigadier/tests/command_dispatcher_test.rs index e30dd2c1..fb0085ba 100755 --- a/azalea-brigadier/tests/command_dispatcher_test.rs +++ b/azalea-brigadier/tests/command_dispatcher_test.rs @@ -251,31 +251,34 @@ fn execute_redirected_multiple_times() { let parse = subject.parse(input.into(), Rc::new(CommandSource {})); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); - assert_eq!(parse.context.root, root); + assert_eq!(*parse.context.root.read(), *root.read()); assert_eq!(parse.context.nodes[0].range, parse.context.range); - assert_eq!(parse.context.nodes[0].node, redirect_node); + assert_eq!(*parse.context.nodes[0].node.read(), *redirect_node.read()); let child1 = parse.context.child.clone(); assert!(child1.is_some()); assert_eq!(child1.clone().unwrap().range.get(input), "redirected"); assert_eq!(child1.clone().unwrap().nodes.len(), 1); - assert_eq!(child1.clone().unwrap().root, root); + assert_eq!(*child1.clone().unwrap().root.read(), *root.read()); assert_eq!( child1.clone().unwrap().nodes[0].range, child1.clone().unwrap().range ); - assert_eq!(child1.clone().unwrap().nodes[0].node, redirect_node); + assert_eq!( + *child1.clone().unwrap().nodes[0].node.read(), + *redirect_node.read() + ); let child2 = child1.unwrap().child.clone(); assert!(child2.is_some()); assert_eq!(child2.clone().unwrap().range.get(input), "actual"); assert_eq!(child2.clone().unwrap().nodes.len(), 1); - assert_eq!(child2.clone().unwrap().root, root); + assert_eq!(*child2.clone().unwrap().root.read(), *root.read()); assert_eq!( child2.clone().unwrap().nodes[0].range, child2.clone().unwrap().range ); - assert_eq!(child2.unwrap().nodes[0].node, concrete_node); + assert_eq!(*child2.unwrap().nodes[0].node.read(), *concrete_node.read()); assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 42); } @@ -299,18 +302,18 @@ fn execute_redirected() { let parse = subject.parse(input.into(), Rc::new(CommandSource {})); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); - assert_eq!(parse.context.root, subject.root); + assert_eq!(*parse.context.root.read(), *subject.root.read()); assert_eq!(parse.context.nodes[0].range, parse.context.range); - assert_eq!(parse.context.nodes[0].node, redirect_node); + assert_eq!(*parse.context.nodes[0].node.read(), *redirect_node.read()); let parent = parse.context.child.clone(); assert!(parent.is_some()); let parent = parent.unwrap(); assert_eq!(parent.range.get(input), "actual"); assert_eq!(parent.nodes.len(), 1); - assert_eq!(parse.context.root, subject.root); + assert_eq!(*parse.context.root.read(), *subject.root.read()); assert_eq!(parent.nodes[0].range, parent.range); - assert_eq!(parent.nodes[0].node, concrete_node); + assert_eq!(*parent.nodes[0].node.read(), *concrete_node.read()); assert_eq!(parent.source, Rc::new(CommandSource {})); assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 2); @@ -406,5 +409,5 @@ fn get_path() { fn find_node_doesnt_exist() { let subject = CommandDispatcher::<()>::new(); - assert_eq!(subject.find_node(&["foo", "bar"]), None) + assert!(subject.find_node(&["foo", "bar"]).is_none()) } -- cgit v1.2.3 From f825544e2776ab545ff0a9c674b68183120695cb Mon Sep 17 00:00:00 2001 From: mat Date: Fri, 5 May 2023 23:23:11 -0500 Subject: CommandDispatcher is now Send+Sync --- azalea-brigadier/src/builder/argument_builder.rs | 20 ++++---- .../src/builder/required_argument_builder.rs | 13 ++++-- azalea-brigadier/src/command_dispatcher.rs | 10 ++-- azalea-brigadier/src/context/command_context.rs | 10 ++-- .../src/context/command_context_builder.rs | 14 +++--- azalea-brigadier/src/modifier.rs | 4 +- azalea-brigadier/src/tree/mod.rs | 14 +++--- azalea-brigadier/tests/command_dispatcher_test.rs | 54 +++++++++++----------- 8 files changed, 71 insertions(+), 68 deletions(-) (limited to 'azalea-brigadier/tests') diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs index a1f3d6ae..c6f2146a 100755 --- a/azalea-brigadier/src/builder/argument_builder.rs +++ b/azalea-brigadier/src/builder/argument_builder.rs @@ -7,7 +7,7 @@ use crate::{ }; use super::{literal_argument_builder::Literal, required_argument_builder::Argument}; -use std::{fmt::Debug, rc::Rc, sync::Arc}; +use std::{fmt::Debug, sync::Arc}; #[derive(Debug, Clone)] pub enum ArgumentBuilderType { @@ -20,11 +20,11 @@ pub struct ArgumentBuilder { arguments: CommandNode, command: Command, - requirement: Rc) -> bool>, + requirement: Arc) -> bool + Send + Sync>, target: Option>>>, forks: bool, - modifier: Option>>, + modifier: Option>>, } /// A node that isn't yet built. @@ -36,7 +36,7 @@ impl ArgumentBuilder { ..Default::default() }, command: None, - requirement: Rc::new(|_| true), + requirement: Arc::new(|_| true), forks: false, modifier: None, target: None, @@ -54,17 +54,17 @@ impl ArgumentBuilder { pub fn executes(mut self, f: F) -> Self where - F: Fn(&CommandContext) -> i32 + 'static, + F: Fn(&CommandContext) -> i32 + Send + Sync + 'static, { - self.command = Some(Rc::new(f)); + self.command = Some(Arc::new(f)); self } pub fn requires(mut self, requirement: F) -> Self where - F: Fn(Rc) -> bool + 'static, + F: Fn(Arc) -> bool + Send + Sync + 'static, { - self.requirement = Rc::new(requirement); + self.requirement = Arc::new(requirement); self } @@ -75,7 +75,7 @@ impl ArgumentBuilder { pub fn fork( self, target: Arc>>, - modifier: Rc>, + modifier: Arc>, ) -> Self { self.forward(target, Some(modifier), true) } @@ -83,7 +83,7 @@ impl ArgumentBuilder { pub fn forward( mut self, target: Arc>>, - modifier: Option>>, + modifier: Option>>, fork: bool, ) -> Self { if !self.arguments.children.is_empty() { diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs index 9d4d9e0a..0363d204 100755 --- a/azalea-brigadier/src/builder/required_argument_builder.rs +++ b/azalea-brigadier/src/builder/required_argument_builder.rs @@ -2,17 +2,17 @@ use super::argument_builder::{ArgumentBuilder, ArgumentBuilderType}; use crate::{ arguments::ArgumentType, exceptions::CommandSyntaxException, string_reader::StringReader, }; -use std::{any::Any, fmt::Debug, rc::Rc}; +use std::{any::Any, fmt::Debug, rc::Rc, sync::Arc}; /// An argument node type. The `T` type parameter is the type of the argument, /// which can be anything. #[derive(Clone)] pub struct Argument { pub name: String, - parser: Rc, + parser: Arc, } impl Argument { - pub fn new(name: &str, parser: Rc) -> Self { + pub fn new(name: &str, parser: Arc) -> Self { Self { name: name.to_string(), parser, @@ -40,6 +40,9 @@ impl Debug for Argument { } /// Shortcut for creating a new argument builder node. -pub fn argument(name: &str, parser: impl ArgumentType + 'static) -> ArgumentBuilder { - ArgumentBuilder::new(Argument::new(name, Rc::new(parser)).into()) +pub fn argument( + name: &str, + parser: impl ArgumentType + Send + Sync + 'static, +) -> ArgumentBuilder { + ArgumentBuilder::new(Argument::new(name, Arc::new(parser)).into()) } diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs index 0d84171e..384a28dd 100755 --- a/azalea-brigadier/src/command_dispatcher.rs +++ b/azalea-brigadier/src/command_dispatcher.rs @@ -13,8 +13,8 @@ use std::{cmp::Ordering, collections::HashMap, mem, rc::Rc, sync::Arc}; /// The root of the command tree. You need to make this to register commands. #[derive(Default)] pub struct CommandDispatcher -// where -// Self: Sync + Send, +where + Self: Sync + Send, { pub root: Arc>>, } @@ -32,7 +32,7 @@ impl CommandDispatcher { build } - pub fn parse(&self, command: StringReader, source: Rc) -> ParseResults { + pub fn parse(&self, command: StringReader, source: Arc) -> ParseResults { let context = CommandContextBuilder::new(self, source, self.root.clone(), command.cursor()); self.parse_nodes(&self.root, &command, context).unwrap() } @@ -91,7 +91,7 @@ impl CommandDispatcher { let parse = self .parse_nodes(redirect, &reader, child_context) .expect("Parsing nodes failed"); - context.with_child(Rc::new(parse.context)); + context.with_child(Arc::new(parse.context)); return Ok(ParseResults { context, reader: parse.reader, @@ -144,7 +144,7 @@ impl CommandDispatcher { pub fn execute( &self, input: StringReader, - source: Rc, + source: Arc, ) -> Result { let parse = self.parse(input, source); Self::execute_parsed(parse) diff --git a/azalea-brigadier/src/context/command_context.rs b/azalea-brigadier/src/context/command_context.rs index 88af2002..1734bb05 100755 --- a/azalea-brigadier/src/context/command_context.rs +++ b/azalea-brigadier/src/context/command_context.rs @@ -9,15 +9,15 @@ use std::{any::Any, collections::HashMap, fmt::Debug, rc::Rc, sync::Arc}; /// A built `CommandContextBuilder`. pub struct CommandContext { - pub source: Rc, + pub source: Arc, pub input: String, pub arguments: HashMap, pub command: Command, pub root_node: Arc>>, pub nodes: Vec>, pub range: StringRange, - pub child: Option>>, - pub modifier: Option>>, + pub child: Option>>, + pub modifier: Option>>, pub forks: bool, } @@ -56,8 +56,8 @@ impl Debug for CommandContext { } impl CommandContext { - pub fn copy_for(&self, source: Rc) -> Self { - if Rc::ptr_eq(&source, &self.source) { + pub fn copy_for(&self, source: Arc) -> Self { + if Arc::ptr_eq(&source, &self.source) { return self.clone(); } CommandContext { diff --git a/azalea-brigadier/src/context/command_context_builder.rs b/azalea-brigadier/src/context/command_context_builder.rs index 54063879..78088941 100755 --- a/azalea-brigadier/src/context/command_context_builder.rs +++ b/azalea-brigadier/src/context/command_context_builder.rs @@ -9,18 +9,18 @@ use crate::{ modifier::RedirectModifier, tree::{Command, CommandNode}, }; -use std::{collections::HashMap, fmt::Debug, rc::Rc, sync::Arc}; +use std::{collections::HashMap, fmt::Debug, sync::Arc}; pub struct CommandContextBuilder<'a, S> { pub arguments: HashMap, pub root: Arc>>, pub nodes: Vec>, pub dispatcher: &'a CommandDispatcher, - pub source: Rc, + pub source: Arc, pub command: Command, - pub child: Option>>, + pub child: Option>>, pub range: StringRange, - pub modifier: Option>>, + pub modifier: Option>>, pub forks: bool, } @@ -44,7 +44,7 @@ impl Clone for CommandContextBuilder<'_, S> { impl<'a, S> CommandContextBuilder<'a, S> { pub fn new( dispatcher: &'a CommandDispatcher, - source: Rc, + source: Arc, root_node: Arc>>, start: usize, ) -> Self { @@ -66,7 +66,7 @@ impl<'a, S> CommandContextBuilder<'a, S> { self.command = command.clone(); self } - pub fn with_child(&mut self, child: Rc>) -> &Self { + pub fn with_child(&mut self, child: Arc>) -> &Self { self.child = Some(child); self } @@ -92,7 +92,7 @@ impl<'a, S> CommandContextBuilder<'a, S> { nodes: self.nodes.clone(), source: self.source.clone(), command: self.command.clone(), - child: self.child.clone().map(|c| Rc::new(c.build(input))), + child: self.child.clone().map(|c| Arc::new(c.build(input))), range: self.range.clone(), forks: self.forks, modifier: self.modifier.clone(), diff --git a/azalea-brigadier/src/modifier.rs b/azalea-brigadier/src/modifier.rs index d40d59f9..bebdd0cb 100755 --- a/azalea-brigadier/src/modifier.rs +++ b/azalea-brigadier/src/modifier.rs @@ -1,6 +1,6 @@ -use std::rc::Rc; +use std::sync::Arc; use crate::{context::CommandContext, exceptions::CommandSyntaxException}; pub type RedirectModifier = - dyn Fn(&CommandContext) -> Result>, CommandSyntaxException>; + dyn Fn(&CommandContext) -> Result>, CommandSyntaxException> + Send + Sync; diff --git a/azalea-brigadier/src/tree/mod.rs b/azalea-brigadier/src/tree/mod.rs index 902e288b..cec972dc 100755 --- a/azalea-brigadier/src/tree/mod.rs +++ b/azalea-brigadier/src/tree/mod.rs @@ -10,9 +10,9 @@ use crate::{ modifier::RedirectModifier, string_reader::StringReader, }; -use std::{collections::HashMap, fmt::Debug, hash::Hash, ptr, rc::Rc, sync::Arc}; +use std::{collections::HashMap, fmt::Debug, hash::Hash, ptr, sync::Arc}; -pub type Command = Option) -> i32>>; +pub type Command = Option) -> i32 + Send + Sync>>; /// An ArgumentBuilder that has been built. #[non_exhaustive] @@ -24,10 +24,10 @@ pub struct CommandNode { pub arguments: HashMap>>>, pub command: Command, - pub requirement: Rc) -> bool>, + pub requirement: Arc) -> bool + Send + Sync>, pub redirect: Option>>>, pub forks: bool, - pub modifier: Option>>, + pub modifier: Option>>, } impl Clone for CommandNode { @@ -90,7 +90,7 @@ impl CommandNode { } } - pub fn can_use(&self, source: Rc) -> bool { + pub fn can_use(&self, source: Arc) -> bool { (self.requirement)(source) } @@ -221,7 +221,7 @@ impl Default for CommandNode { arguments: HashMap::new(), command: None, - requirement: Rc::new(|_| true), + requirement: Arc::new(|_| true), redirect: None, forks: false, modifier: None, @@ -257,7 +257,7 @@ impl PartialEq for CommandNode { // idk how to do this better since we can't compare `dyn Fn`s if let Some(otherexecutes) = &other.command { #[allow(clippy::vtable_address_comparisons)] - if !Rc::ptr_eq(selfexecutes, otherexecutes) { + if !Arc::ptr_eq(selfexecutes, otherexecutes) { return false; } } else { diff --git a/azalea-brigadier/tests/command_dispatcher_test.rs b/azalea-brigadier/tests/command_dispatcher_test.rs index fb0085ba..4479cfa2 100755 --- a/azalea-brigadier/tests/command_dispatcher_test.rs +++ b/azalea-brigadier/tests/command_dispatcher_test.rs @@ -1,4 +1,4 @@ -use std::rc::Rc; +use std::sync::Arc; use azalea_brigadier::{ arguments::integer_argument_type::integer, @@ -25,7 +25,7 @@ fn create_and_execute_command() { assert_eq!( subject - .execute("foo".into(), Rc::new(CommandSource {})) + .execute("foo".into(), Arc::new(CommandSource {})) .unwrap(), 42 ); @@ -38,7 +38,7 @@ fn create_and_execute_offset_command() { assert_eq!( subject - .execute(input_with_offset("/foo", 1), Rc::new(CommandSource {})) + .execute(input_with_offset("/foo", 1), Arc::new(CommandSource {})) .unwrap(), 42 ); @@ -52,13 +52,13 @@ fn create_and_merge_commands() { assert_eq!( subject - .execute("base foo".into(), Rc::new(CommandSource {})) + .execute("base foo".into(), Arc::new(CommandSource {})) .unwrap(), 42 ); assert_eq!( subject - .execute("base bar".into(), Rc::new(CommandSource {})) + .execute("base bar".into(), Arc::new(CommandSource {})) .unwrap(), 42 ); @@ -70,7 +70,7 @@ fn execute_unknown_command() { subject.register(literal("bar")); subject.register(literal("baz")); - let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo".into(), Arc::new(CommandSource {})); let err = execute_result.err().unwrap(); match err.type_ { @@ -85,7 +85,7 @@ fn execute_impermissible_command() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").requires(|_| false)); - let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo".into(), Arc::new(CommandSource {})); let err = execute_result.err().unwrap(); match err.type_ { @@ -100,7 +100,7 @@ fn execute_empty_command() { let mut subject = CommandDispatcher::new(); subject.register(literal("")); - let execute_result = subject.execute("".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("".into(), Arc::new(CommandSource {})); let err = execute_result.err().unwrap(); match err.type_ { @@ -115,7 +115,7 @@ fn execute_unknown_subcommand() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").executes(|_| 42)); - let execute_result = subject.execute("foo bar".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo bar".into(), Arc::new(CommandSource {})); let err = execute_result.err().unwrap(); match err.type_ { @@ -130,7 +130,7 @@ fn execute_incorrect_literal() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").executes(|_| 42).then(literal("bar"))); - let execute_result = subject.execute("foo baz".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo baz".into(), Arc::new(CommandSource {})); let err = execute_result.err().unwrap(); match err.type_ { @@ -150,7 +150,7 @@ fn execute_ambiguous_incorrect_argument() { .then(literal("baz")), ); - let execute_result = subject.execute("foo unknown".into(), Rc::new(CommandSource {})); + let execute_result = subject.execute("foo unknown".into(), Arc::new(CommandSource {})); let err = execute_result.err().unwrap(); match err.type_ { @@ -174,7 +174,7 @@ fn execute_subcommand() { assert_eq!( subject - .execute("foo =".into(), Rc::new(CommandSource {})) + .execute("foo =".into(), Arc::new(CommandSource {})) .unwrap(), 100 ); @@ -185,7 +185,7 @@ fn parse_incomplete_literal() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").then(literal("bar").executes(|_| 42))); - let parse = subject.parse("foo ".into(), Rc::new(CommandSource {})); + let parse = subject.parse("foo ".into(), Arc::new(CommandSource {})); assert_eq!(parse.reader.remaining(), " "); assert_eq!(parse.context.nodes.len(), 1); } @@ -195,7 +195,7 @@ fn parse_incomplete_argument() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").then(argument("bar", integer()).executes(|_| 42))); - let parse = subject.parse("foo ".into(), Rc::new(CommandSource {})); + let parse = subject.parse("foo ".into(), Arc::new(CommandSource {})); assert_eq!(parse.reader.remaining(), " "); assert_eq!(parse.context.nodes.len(), 1); } @@ -212,7 +212,7 @@ fn execute_ambiguious_parent_subcommand() { assert_eq!( subject - .execute("test 1 2".into(), Rc::new(CommandSource {})) + .execute("test 1 2".into(), Arc::new(CommandSource {})) .unwrap(), 100 ); @@ -232,7 +232,7 @@ fn execute_ambiguious_parent_subcommand_via_redirect() { assert_eq!( subject - .execute("redirect 1 2".into(), Rc::new(CommandSource {})) + .execute("redirect 1 2".into(), Arc::new(CommandSource {})) .unwrap(), 100 ); @@ -248,7 +248,7 @@ fn execute_redirected_multiple_times() { let input = "redirected redirected actual"; - let parse = subject.parse(input.into(), Rc::new(CommandSource {})); + let parse = subject.parse(input.into(), Arc::new(CommandSource {})); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); assert_eq!(*parse.context.root.read(), *root.read()); @@ -287,19 +287,19 @@ fn execute_redirected_multiple_times() { fn execute_redirected() { let mut subject = CommandDispatcher::new(); - let source1 = Rc::new(CommandSource {}); - let source2 = Rc::new(CommandSource {}); + let source1 = Arc::new(CommandSource {}); + let source2 = Arc::new(CommandSource {}); - let modifier = move |_: &CommandContext| -> Result>, CommandSyntaxException> { + let modifier = move |_: &CommandContext| -> Result>, CommandSyntaxException> { Ok(vec![source1.clone(), source2.clone()]) }; let concrete_node = subject.register(literal("actual").executes(|_| 42)); let redirect_node = - subject.register(literal("redirected").fork(subject.root.clone(), Rc::new(modifier))); + subject.register(literal("redirected").fork(subject.root.clone(), Arc::new(modifier))); let input = "redirected actual"; - let parse = subject.parse(input.into(), Rc::new(CommandSource {})); + let parse = subject.parse(input.into(), Arc::new(CommandSource {})); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); assert_eq!(*parse.context.root.read(), *subject.root.read()); @@ -314,7 +314,7 @@ fn execute_redirected() { assert_eq!(*parse.context.root.read(), *subject.root.read()); assert_eq!(parent.nodes[0].range, parent.range); assert_eq!(*parent.nodes[0].node.read(), *concrete_node.read()); - assert_eq!(parent.source, Rc::new(CommandSource {})); + assert_eq!(parent.source, Arc::new(CommandSource {})); assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 2); } @@ -329,7 +329,7 @@ fn execute_orphaned_subcommand() { .executes(|_| 42), ); - let result = subject.execute("foo 5".into(), Rc::new(CommandSource {})); + let result = subject.execute("foo 5".into(), Arc::new(CommandSource {})); assert!(result.is_err()); let result = result.unwrap_err(); assert_eq!( @@ -348,7 +348,7 @@ fn execute_invalid_other() { assert_eq!( subject - .execute("world".into(), Rc::new(CommandSource {})) + .execute("world".into(), Arc::new(CommandSource {})) .unwrap(), 42 ); @@ -364,7 +364,7 @@ fn parse_no_space_separator() { .executes(|_| 42), ); - let result = subject.execute("foo$".into(), Rc::new(CommandSource {})); + let result = subject.execute("foo$".into(), Arc::new(CommandSource {})); assert!(result.is_err()); let result = result.unwrap_err(); assert_eq!( @@ -384,7 +384,7 @@ fn execute_invalid_subcommand() { .executes(|_| 42), ); - let result = subject.execute("foo bar".into(), Rc::new(CommandSource {})); + let result = subject.execute("foo bar".into(), Arc::new(CommandSource {})); assert!(result.is_err()); let result = result.unwrap_err(); // this fails for some reason, i blame mojang -- cgit v1.2.3 From 53d51a5ca92aa8ddea9d82b6b44ac7aaa06c2095 Mon Sep 17 00:00:00 2001 From: mat Date: Sun, 7 May 2023 02:50:52 -0500 Subject: more brigadier docs --- azalea-brigadier/README.md | 21 +++++- .../src/arguments/double_argument_type.rs | 2 +- .../src/arguments/float_argument_type.rs | 2 +- .../src/arguments/long_argument_type.rs | 2 +- azalea-brigadier/src/builder/argument_builder.rs | 41 +++++++++++ azalea-brigadier/src/command_dispatcher.rs | 27 ++++++- azalea-brigadier/src/lib.rs | 7 +- azalea-brigadier/tests/command_dispatcher_test.rs | 82 ++++++---------------- 8 files changed, 114 insertions(+), 70 deletions(-) (limited to 'azalea-brigadier/tests') diff --git a/azalea-brigadier/README.md b/azalea-brigadier/README.md index c5aff629..6e573c8b 100755 --- a/azalea-brigadier/README.md +++ b/azalea-brigadier/README.md @@ -4,4 +4,23 @@ A Rust port of Mojang's [Brigadier](https://github.com/Mojang/brigadier) command # Examples -See the [tests](https://github.com/mat-1/azalea/tree/main/azalea-brigadier/tests). +```rust +use azalea_brigadier::prelude::*; +use std::sync::Arc; + +#[derive(Debug, PartialEq)] +struct CommandSource {} + +let mut subject = CommandDispatcher::new(); +subject.register(literal("foo").executes(|_| 42)); + +assert_eq!( + subject + .execute("foo", Arc::new(CommandSource {})) + .unwrap(), + 42 +); +``` + +See the [tests](https://github.com/mat-1/azalea/tree/main/azalea-brigadier/tests) for more. + diff --git a/azalea-brigadier/src/arguments/double_argument_type.rs b/azalea-brigadier/src/arguments/double_argument_type.rs index 117a11cc..d83bfb2a 100644 --- a/azalea-brigadier/src/arguments/double_argument_type.rs +++ b/azalea-brigadier/src/arguments/double_argument_type.rs @@ -45,7 +45,7 @@ impl ArgumentType for Double { pub fn double() -> impl ArgumentType { Double::default() } -pub fn get_integer(context: &CommandContext, name: &str) -> Option { +pub fn get_double(context: &CommandContext, name: &str) -> Option { context .argument(name) .unwrap() diff --git a/azalea-brigadier/src/arguments/float_argument_type.rs b/azalea-brigadier/src/arguments/float_argument_type.rs index f335f11a..0d194efe 100644 --- a/azalea-brigadier/src/arguments/float_argument_type.rs +++ b/azalea-brigadier/src/arguments/float_argument_type.rs @@ -45,7 +45,7 @@ impl ArgumentType for Float { pub fn float() -> impl ArgumentType { Float::default() } -pub fn get_integer(context: &CommandContext, name: &str) -> Option { +pub fn get_float(context: &CommandContext, name: &str) -> Option { context .argument(name) .unwrap() diff --git a/azalea-brigadier/src/arguments/long_argument_type.rs b/azalea-brigadier/src/arguments/long_argument_type.rs index 435dd92a..9b3469b6 100644 --- a/azalea-brigadier/src/arguments/long_argument_type.rs +++ b/azalea-brigadier/src/arguments/long_argument_type.rs @@ -45,7 +45,7 @@ impl ArgumentType for Long { pub fn long() -> impl ArgumentType { Long::default() } -pub fn get_integer(context: &CommandContext, name: &str) -> Option { +pub fn get_long(context: &CommandContext, name: &str) -> Option { context .argument(name) .unwrap() diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs index c6f2146a..643a3bd0 100755 --- a/azalea-brigadier/src/builder/argument_builder.rs +++ b/azalea-brigadier/src/builder/argument_builder.rs @@ -43,15 +43,38 @@ impl ArgumentBuilder { } } + /// Continue building this node with a child node. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # let mut subject = CommandDispatcher::<()>::new(); + /// literal("foo").then( + /// literal("bar").executes(|ctx: &CommandContext<()>| 42) + /// ) + /// # ; + /// ``` pub fn then(self, argument: ArgumentBuilder) -> Self { self.then_built(argument.build()) } + /// Add an already built child node to this node. + /// + /// You should usually use [`Self::then`] instead. pub fn then_built(mut self, argument: CommandNode) -> Self { self.arguments.add_child(&Arc::new(RwLock::new(argument))); self } + /// Set the command to be executed when this node is reached. If this is not + /// present on a node, it is not a valid command. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # let mut subject = CommandDispatcher::<()>::new(); + /// # subject.register( + /// literal("foo").executes(|ctx: &CommandContext<()>| 42) + /// # ); + /// ``` pub fn executes(mut self, f: F) -> Self where F: Fn(&CommandContext) -> i32 + Send + Sync + 'static, @@ -60,6 +83,22 @@ impl ArgumentBuilder { self } + /// Set the requirement for this node to be considered. If this is not + /// present on a node, it is considered to always pass. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # use std::sync::Arc; + /// # pub struct CommandSource { + /// # pub opped: bool, + /// # } + /// # let mut subject = CommandDispatcher::::new(); + /// # subject.register( + /// literal("foo") + /// .requires(|s: Arc| s.opped) + /// // ... + /// # .executes(|ctx: &CommandContext| 42) + /// # ); pub fn requires(mut self, requirement: F) -> Self where F: Fn(Arc) -> bool + Send + Sync + 'static, @@ -95,6 +134,8 @@ impl ArgumentBuilder { self } + /// Manually build this node into a [`CommandNode`]. You probably don't need + /// to do this yourself. pub fn build(self) -> CommandNode { let mut result = CommandNode { value: self.arguments.value, diff --git a/azalea-brigadier/src/command_dispatcher.rs b/azalea-brigadier/src/command_dispatcher.rs index a14b5009..595bc57d 100755 --- a/azalea-brigadier/src/command_dispatcher.rs +++ b/azalea-brigadier/src/command_dispatcher.rs @@ -11,6 +11,12 @@ use crate::{ use std::{cmp::Ordering, collections::HashMap, mem, rc::Rc, sync::Arc}; /// The root of the command tree. You need to make this to register commands. +/// +/// ``` +/// # use azalea_brigadier::prelude::*; +/// # struct CommandSource; +/// let mut subject = CommandDispatcher::::new(); +/// ``` pub struct CommandDispatcher where Self: Sync + Send, @@ -25,13 +31,22 @@ impl CommandDispatcher { } } + /// Add a new node to the root. + /// + /// ``` + /// # use azalea_brigadier::prelude::*; + /// # let mut subject = CommandDispatcher::<()>::new(); + /// subject.register(literal("foo").executes(|_| 42)); + /// ``` pub fn register(&mut self, node: ArgumentBuilder) -> Arc>> { let build = Arc::new(RwLock::new(node.build())); self.root.write().add_child(&build); build } - pub fn parse(&self, command: StringReader, source: Arc) -> ParseResults { + pub fn parse(&self, command: StringReader, source: S) -> ParseResults { + let source = Arc::new(source); + let context = CommandContextBuilder::new(self, source, self.root.clone(), command.cursor()); self.parse_nodes(&self.root, &command, context).unwrap() } @@ -140,11 +155,17 @@ impl CommandDispatcher { }) } + /// Parse and execute the command using the given input and context. The + /// number returned depends on the command, and may not be of significance. + /// + /// This is a shortcut for `Self::parse` and `Self::execute_parsed`. pub fn execute( &self, - input: StringReader, - source: Arc, + input: impl Into, + source: S, ) -> Result { + let input = input.into(); + let parse = self.parse(input, source); Self::execute_parsed(parse) } diff --git a/azalea-brigadier/src/lib.rs b/azalea-brigadier/src/lib.rs index 8b8e116e..161ef83a 100755 --- a/azalea-brigadier/src/lib.rs +++ b/azalea-brigadier/src/lib.rs @@ -14,8 +14,11 @@ pub mod tree; pub mod prelude { pub use crate::{ arguments::{ - double_argument_type::double, float_argument_type::float, - integer_argument_type::integer, long_argument_type::long, string_argument_type::string, + double_argument_type::{double, get_double}, + float_argument_type::{float, get_float}, + integer_argument_type::{get_integer, integer}, + long_argument_type::{get_long, long}, + string_argument_type::{get_string, greedy_string, string, word}, }, builder::{literal_argument_builder::literal, required_argument_builder::argument}, command_dispatcher::CommandDispatcher, diff --git a/azalea-brigadier/tests/command_dispatcher_test.rs b/azalea-brigadier/tests/command_dispatcher_test.rs index 4479cfa2..eecbf668 100755 --- a/azalea-brigadier/tests/command_dispatcher_test.rs +++ b/azalea-brigadier/tests/command_dispatcher_test.rs @@ -18,19 +18,6 @@ fn input_with_offset(input: &str, offset: usize) -> StringReader { result } -#[test] -fn create_and_execute_command() { - let mut subject = CommandDispatcher::new(); - subject.register(literal("foo").executes(|_| 42)); - - assert_eq!( - subject - .execute("foo".into(), Arc::new(CommandSource {})) - .unwrap(), - 42 - ); -} - #[test] fn create_and_execute_offset_command() { let mut subject = CommandDispatcher::new(); @@ -38,7 +25,7 @@ fn create_and_execute_offset_command() { assert_eq!( subject - .execute(input_with_offset("/foo", 1), Arc::new(CommandSource {})) + .execute(input_with_offset("/foo", 1), &CommandSource {}) .unwrap(), 42 ); @@ -50,18 +37,8 @@ fn create_and_merge_commands() { subject.register(literal("base").then(literal("foo").executes(|_| 42))); subject.register(literal("base").then(literal("bar").executes(|_| 42))); - assert_eq!( - subject - .execute("base foo".into(), Arc::new(CommandSource {})) - .unwrap(), - 42 - ); - assert_eq!( - subject - .execute("base bar".into(), Arc::new(CommandSource {})) - .unwrap(), - 42 - ); + assert_eq!(subject.execute("base foo", &CommandSource {}).unwrap(), 42); + assert_eq!(subject.execute("base bar", &CommandSource {}).unwrap(), 42); } #[test] @@ -70,7 +47,7 @@ fn execute_unknown_command() { subject.register(literal("bar")); subject.register(literal("baz")); - let execute_result = subject.execute("foo".into(), Arc::new(CommandSource {})); + let execute_result = subject.execute("foo", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -85,7 +62,7 @@ fn execute_impermissible_command() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").requires(|_| false)); - let execute_result = subject.execute("foo".into(), Arc::new(CommandSource {})); + let execute_result = subject.execute("foo", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -100,7 +77,7 @@ fn execute_empty_command() { let mut subject = CommandDispatcher::new(); subject.register(literal("")); - let execute_result = subject.execute("".into(), Arc::new(CommandSource {})); + let execute_result = subject.execute("", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -115,7 +92,7 @@ fn execute_unknown_subcommand() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").executes(|_| 42)); - let execute_result = subject.execute("foo bar".into(), Arc::new(CommandSource {})); + let execute_result = subject.execute("foo bar", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -130,7 +107,7 @@ fn execute_incorrect_literal() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").executes(|_| 42).then(literal("bar"))); - let execute_result = subject.execute("foo baz".into(), Arc::new(CommandSource {})); + let execute_result = subject.execute("foo baz", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -150,7 +127,7 @@ fn execute_ambiguous_incorrect_argument() { .then(literal("baz")), ); - let execute_result = subject.execute("foo unknown".into(), Arc::new(CommandSource {})); + let execute_result = subject.execute("foo unknown", &CommandSource {}); let err = execute_result.err().unwrap(); match err.type_ { @@ -172,12 +149,7 @@ fn execute_subcommand() { .executes(|_| 42), ); - assert_eq!( - subject - .execute("foo =".into(), Arc::new(CommandSource {})) - .unwrap(), - 100 - ); + assert_eq!(subject.execute("foo =", &CommandSource {}).unwrap(), 100); } #[test] @@ -185,7 +157,7 @@ fn parse_incomplete_literal() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").then(literal("bar").executes(|_| 42))); - let parse = subject.parse("foo ".into(), Arc::new(CommandSource {})); + let parse = subject.parse("foo ".into(), &CommandSource {}); assert_eq!(parse.reader.remaining(), " "); assert_eq!(parse.context.nodes.len(), 1); } @@ -195,7 +167,7 @@ fn parse_incomplete_argument() { let mut subject = CommandDispatcher::new(); subject.register(literal("foo").then(argument("bar", integer()).executes(|_| 42))); - let parse = subject.parse("foo ".into(), Arc::new(CommandSource {})); + let parse = subject.parse("foo ".into(), &CommandSource {}); assert_eq!(parse.reader.remaining(), " "); assert_eq!(parse.context.nodes.len(), 1); } @@ -210,12 +182,7 @@ fn execute_ambiguious_parent_subcommand() { .then(argument("right", integer()).then(argument("sub", integer()).executes(|_| 100))), ); - assert_eq!( - subject - .execute("test 1 2".into(), Arc::new(CommandSource {})) - .unwrap(), - 100 - ); + assert_eq!(subject.execute("test 1 2", &CommandSource {}).unwrap(), 100); } #[test] @@ -231,9 +198,7 @@ fn execute_ambiguious_parent_subcommand_via_redirect() { subject.register(literal("redirect").redirect(real)); assert_eq!( - subject - .execute("redirect 1 2".into(), Arc::new(CommandSource {})) - .unwrap(), + subject.execute("redirect 1 2", &CommandSource {}).unwrap(), 100 ); } @@ -248,7 +213,7 @@ fn execute_redirected_multiple_times() { let input = "redirected redirected actual"; - let parse = subject.parse(input.into(), Arc::new(CommandSource {})); + let parse = subject.parse(input.into(), &CommandSource {}); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); assert_eq!(*parse.context.root.read(), *root.read()); @@ -299,7 +264,7 @@ fn execute_redirected() { subject.register(literal("redirected").fork(subject.root.clone(), Arc::new(modifier))); let input = "redirected actual"; - let parse = subject.parse(input.into(), Arc::new(CommandSource {})); + let parse = subject.parse(input.into(), CommandSource {}); assert_eq!(parse.context.range.get(input), "redirected"); assert_eq!(parse.context.nodes.len(), 1); assert_eq!(*parse.context.root.read(), *subject.root.read()); @@ -314,7 +279,7 @@ fn execute_redirected() { assert_eq!(*parse.context.root.read(), *subject.root.read()); assert_eq!(parent.nodes[0].range, parent.range); assert_eq!(*parent.nodes[0].node.read(), *concrete_node.read()); - assert_eq!(parent.source, Arc::new(CommandSource {})); + assert_eq!(*parent.source, CommandSource {}); assert_eq!(CommandDispatcher::execute_parsed(parse).unwrap(), 2); } @@ -329,7 +294,7 @@ fn execute_orphaned_subcommand() { .executes(|_| 42), ); - let result = subject.execute("foo 5".into(), Arc::new(CommandSource {})); + let result = subject.execute("foo 5", &CommandSource {}); assert!(result.is_err()); let result = result.unwrap_err(); assert_eq!( @@ -346,12 +311,7 @@ fn execute_invalid_other() { subject.register(literal("w").executes(|_| panic!("This should not run"))); subject.register(literal("world").executes(|_| 42)); - assert_eq!( - subject - .execute("world".into(), Arc::new(CommandSource {})) - .unwrap(), - 42 - ); + assert_eq!(subject.execute("world", &CommandSource {}).unwrap(), 42); } #[test] @@ -364,7 +324,7 @@ fn parse_no_space_separator() { .executes(|_| 42), ); - let result = subject.execute("foo$".into(), Arc::new(CommandSource {})); + let result = subject.execute("foo$", &CommandSource {}); assert!(result.is_err()); let result = result.unwrap_err(); assert_eq!( @@ -384,7 +344,7 @@ fn execute_invalid_subcommand() { .executes(|_| 42), ); - let result = subject.execute("foo bar".into(), Arc::new(CommandSource {})); + let result = subject.execute("foo bar", &CommandSource {}); assert!(result.is_err()); let result = result.unwrap_err(); // this fails for some reason, i blame mojang -- cgit v1.2.3