Rewrite brigadier

1 files changed, 34 insertions, 79 deletions

diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs
index fe6f2ecc..95f4da01 100644
--- a/azalea-brigadier/src/builder/required_argument_builder.rs
+++ b/azalea-brigadier/src/builder/required_argument_builder.rs
@@ -1,91 +1,46 @@
-use super::argument_builder::BaseArgumentBuilder;
-use crate::{
-    arguments::argument_type::ArgumentType,
-    command::Command,
-    redirect_modifier::RedirectModifier,
-    suggestion::suggestion_provider::SuggestionProvider,
-    tree::{
-        argument_command_node::ArgumentCommandNode,
-        command_node::{BaseCommandNode, CommandNodeTrait},
-        root_command_node::RootCommandNode,
-    },
-};
-use std::any::Any;
-use std::fmt::Debug;
-
-pub struct RequiredArgumentBuilder<'a, S> {
-    arguments: RootCommandNode<'a, S>,
-    command: Option<Box<dyn Command<S>>>,
-    requirement: Box<dyn Fn(&S) -> bool>,
-    target: Option<Box<dyn CommandNodeTrait<S>>>,
-    modifier: Option<Box<dyn RedirectModifier<S>>>,
-    forks: bool,
-
-    name: String,
-    type_: Box<dyn ArgumentType<Into = dyn Any>>,
-    suggestions_provider: Option<Box<dyn SuggestionProvider<S>>>,
+use super::argument_builder::{ArgumentBuilder, ArgumentBuilderType};
+use crate::{parsers::Parser, string_reader::StringReader};
+use std::{any::Any, fmt::Debug, rc::Rc};
+
+/// 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<dyn Parser>,
 }
-
-impl<'a, S> RequiredArgumentBuilder<'a, S> {
-    pub fn new(name: String, type_: Box<dyn ArgumentType<Into = dyn Any>>) -> Self {
+impl Argument {
+    pub fn new(name: &str, parser: Rc<dyn Parser>) -> Self {
         Self {
-            name,
-            type_: type_,
-            suggestions_provider: None,
-            arguments: RootCommandNode::new(),
-            command: None,
-            requirement: Box::new(|_| true),
-            target: None,
-            modifier: None,
-            forks: false,
+            name: name.to_string(),
+            parser: parser,
         }
     }
 
-    pub fn argument(name: String, type_: Box<dyn ArgumentType<Into = dyn Any>>) -> Self {
-        Self::new(name, type_)
-    }
-
-    pub fn suggests(mut self, provider: Box<dyn SuggestionProvider<S>>) -> Self {
-        self.suggestions_provider = Some(provider);
-        self
-    }
-
-    pub fn suggestions_provider(&self) -> Option<Box<dyn SuggestionProvider<S>>> {
-        self.suggestions_provider
+    pub fn parse(&self, reader: &mut StringReader) -> Option<Rc<dyn Any>> {
+        self.parser.parse(reader)
     }
+}
 
-    pub fn get_type(&self) -> Box<dyn ArgumentType<Into = dyn Any>> {
-        self.type_
+impl From<Argument> for ArgumentBuilderType {
+    fn from(argument: Argument) -> Self {
+        Self::Argument(argument)
     }
+}
 
-    pub fn name(&self) -> &str {
-        &self.name
+impl Debug for Argument {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Argument")
+            .field("name", &self.name)
+            // .field("parser", &self.parser)
+            .finish()
     }
+}
 
-    // final ArgumentCommandNode<S> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement(), getRedirect(), getRedirectModifier(), isFork(), getSuggestionsProvider());
-
-    // for (final CommandNode<S> argument : getArguments()) {
-    // 	result.addChild(argument);
-    // }
-
-    // return result;
-    pub fn build(self) -> ArgumentCommandNode<'a, S> {
-        let result = ArgumentCommandNode {
-            name: self.name,
-            type_: self.type_,
-            command: self.base.command(),
-            requirement: self.base.requirement(),
-            redirect: self.base.get_redirect(),
-            modifier: self.base.get_redirect_modifier(),
-            forks: self.base.forks,
-            custom_suggestions: self.base.custom_suggestions,
-            ..ArgumentCommandNode::default()
-        };
-
-        for argument in self.base.arguments() {
-            result.add_child(argument);
-        }
-
-        result
-    }
+/// Shortcut for creating a new argument builder node.
+pub fn argument<'a, S: Any + Clone>(
+    name: &'a str,
+    parser: impl Parser + 'static,
+) -> ArgumentBuilder<S> {
+    ArgumentBuilder::new(Argument::new(name, Rc::new(parser)).into())
 }