more brigadier docs

6 files changed, 73 insertions, 8 deletions

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<S>(context: &CommandContext<S>, name: &str) -> Option<f64> {
+pub fn get_double<S>(context: &CommandContext<S>, name: &str) -> Option<f64> {
     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<S>(context: &CommandContext<S>, name: &str) -> Option<f32> {
+pub fn get_float<S>(context: &CommandContext<S>, name: &str) -> Option<f32> {
     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<S>(context: &CommandContext<S>, name: &str) -> Option<i64> {
+pub fn get_long<S>(context: &CommandContext<S>, name: &str) -> Option<i64> {
     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<S> ArgumentBuilder<S> {
         }
     }
 
+    /// 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<S>) -> 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<S>) -> 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<F>(mut self, f: F) -> Self
     where
         F: Fn(&CommandContext<S>) -> i32 + Send + Sync + 'static,
@@ -60,6 +83,22 @@ impl<S> ArgumentBuilder<S> {
         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::<CommandSource>::new();
+    /// # subject.register(
+    /// literal("foo")
+    ///     .requires(|s: Arc<CommandSource>| s.opped)
+    ///     // ...
+    ///     # .executes(|ctx: &CommandContext<CommandSource>| 42)
+    /// # );
     pub fn requires<F>(mut self, requirement: F) -> Self
     where
         F: Fn(Arc<S>) -> bool + Send + Sync + 'static,
@@ -95,6 +134,8 @@ impl<S> ArgumentBuilder<S> {
         self
     }
 
+    /// Manually build this node into a [`CommandNode`]. You probably don't need
+    /// to do this yourself.
     pub fn build(self) -> CommandNode<S> {
         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::<CommandSource>::new();
+/// ```
 pub struct CommandDispatcher<S>
 where
     Self: Sync + Send,
@@ -25,13 +31,22 @@ impl<S> CommandDispatcher<S> {
         }
     }
 
+    /// 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<S>) -> Arc<RwLock<CommandNode<S>>> {
         let build = Arc::new(RwLock::new(node.build()));
         self.root.write().add_child(&build);
         build
     }
 
-    pub fn parse(&self, command: StringReader, source: Arc<S>) -> ParseResults<S> {
+    pub fn parse(&self, command: StringReader, source: S) -> ParseResults<S> {
+        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<S> CommandDispatcher<S> {
         })
     }
 
+    /// 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<S>,
+        input: impl Into<StringReader>,
+        source: S,
     ) -> Result<i32, CommandSyntaxException> {
+        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,