add .requires

azalea-brigadier/src/builder/argument_builder.rs

@@ -66,6 +66,14 @@ impl<S: Any + Clone> ArgumentBuilder<S> {
         self.clone()
     }
 
+    pub fn requires<F>(&mut self, requirement: F) -> Self
+    where
+        F: Fn(Rc<S>) -> bool + 'static,
+    {
+        self.requirement = Rc::new(requirement);
+        self.clone()
+    }
+
     pub fn build(self) -> CommandNode<S> {
         CommandNode {
             value: self.value,

azalea-brigadier/src/dispatcher.rs

@@ -330,18 +330,45 @@ mod tests {
     //         assertThat(ex.getCursor(), is(0));
     //     }
     // }
-    // #[test]
+    #[test]
-    // fn execute_unknown_command() {
+    fn execute_unknown_command() {
-    //     let mut subject = CommandDispatcher::<Rc<CommandSource>>::new();
+        let mut subject = CommandDispatcher::<Rc<CommandSource>>::new();
-    //     subject.register(literal("bar"));
+        subject.register(literal("bar"));
-    //     subject.register(literal("baz"));
+        subject.register(literal("baz"));
 
-    //     assert_eq!(
+        let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {}));
-    //         subject
+
-    //             .execute("foo".into(), Rc::new(CommandSource {}))
+        let err = execute_result.err().unwrap();
-    //             .err()
+        match err.type_ {
-    //             .unwrap(),
+            BuiltInExceptions::DispatcherUnknownCommand => {}
-    //         BuiltInExceptions::DispatcherUnknownCommand.create()
+            _ => panic!("Unexpected error"),
-    //     );
+        }
+        assert_eq!(err.cursor().unwrap(), 0);
+    }
+    // @Test
+    // public void testExecuteImpermissibleCommand() throws Exception {
+    //     subject.register(literal("foo").requires(s -> false));
+
+    //     try {
+    //         subject.execute("foo", source);
+    //         fail();
+    //     } catch (final CommandSyntaxException ex) {
+    //         assertThat(ex.getType(), is(CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownCommand()));
+    //         assertThat(ex.getCursor(), is(0));
+    //     }
     // }
+    #[test]
+    fn execute_impermissible_command() {
+        let mut subject = CommandDispatcher::<Rc<CommandSource>>::new();
+        subject.register(literal("foo").requires(|_| false));
+
+        let execute_result = subject.execute("foo".into(), Rc::new(CommandSource {}));
+
+        let err = execute_result.err().unwrap();
+        match err.type_ {
+            BuiltInExceptions::DispatcherUnknownCommand => {}
+            _ => panic!("Unexpected error"),
+        }
+        assert_eq!(err.cursor().unwrap(), 0);
+    }
 }

azalea-brigadier/src/exceptions/command_syntax_exception.rs

@@ -5,7 +5,7 @@ use crate::message::Message;
 
 #[derive(Clone, PartialEq)]
 pub struct CommandSyntaxException {
-    type_: BuiltInExceptions,
+    pub type_: BuiltInExceptions,
     message: Message,
     input: Option<String>,
     cursor: Option<usize>,