brigadier suggestions

closes #109

16 files changed, 511 insertions, 3 deletions

diff --git a/azalea-brigadier/tests/arguments/bool_argument_type_test.rs b/azalea-brigadier/tests/arguments/bool_argument_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/arguments/bool_argument_type_test.rs
+++ b/azalea-brigadier/tests/arguments/bool_argument_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/arguments/double_argument_type_test.rs b/azalea-brigadier/tests/arguments/double_argument_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/arguments/double_argument_type_test.rs
+++ b/azalea-brigadier/tests/arguments/double_argument_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/arguments/float_argument_type_test.rs b/azalea-brigadier/tests/arguments/float_argument_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/arguments/float_argument_type_test.rs
+++ b/azalea-brigadier/tests/arguments/float_argument_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/arguments/integer_argument_type_test.rs b/azalea-brigadier/tests/arguments/integer_argument_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/arguments/integer_argument_type_test.rs
+++ b/azalea-brigadier/tests/arguments/integer_argument_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/arguments/long_argument_type_test.rs b/azalea-brigadier/tests/arguments/long_argument_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/arguments/long_argument_type_test.rs
+++ b/azalea-brigadier/tests/arguments/long_argument_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/arguments/string_argument_type_test.rs b/azalea-brigadier/tests/arguments/string_argument_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/arguments/string_argument_type_test.rs
+++ b/azalea-brigadier/tests/arguments/string_argument_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/builder/literal_argument_builder_test.rs b/azalea-brigadier/tests/builder/literal_argument_builder_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/builder/literal_argument_builder_test.rs
+++ b/azalea-brigadier/tests/builder/literal_argument_builder_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/builder/required_argument_builder_test.rs b/azalea-brigadier/tests/builder/required_argument_builder_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/builder/required_argument_builder_test.rs
+++ b/azalea-brigadier/tests/builder/required_argument_builder_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/command_dispatcher_usages_test.rs b/azalea-brigadier/tests/command_dispatcher_usages_test.rs
index 0464dea7..a80a2a97 100755
--- a/azalea-brigadier/tests/command_dispatcher_usages_test.rs
+++ b/azalea-brigadier/tests/command_dispatcher_usages_test.rs
@@ -1,6 +1,6 @@
 use std::{collections::HashSet, sync::Arc};
 
-use azalea_brigadier::{prelude::*, tree::CommandNode};
+use azalea_brigadier::{prelude::*, string_reader::StringReader, tree::CommandNode};
 use parking_lot::RwLock;
 
 fn setup() -> CommandDispatcher<()> {
@@ -141,3 +141,54 @@ fn test_smart_usage_root() {
 
     assert_eq!(actual, expected);
 }
+
+#[test]
+fn test_smart_usage_h() {
+    let subject = setup();
+    let results = subject.get_smart_usage(&get(&subject, "h").read(), &());
+
+    let actual = results
+        .into_iter()
+        .map(|(k, v)| (k.read().name().to_owned(), v))
+        .collect::<HashSet<_>>();
+
+    let expected = vec![
+        (get(&subject, "h 1"), "[1] i"),
+        (get(&subject, "h 2"), "[2] i ii"),
+        (get(&subject, "h 3"), "[3]"),
+    ];
+
+    let expected = expected
+        .into_iter()
+        .map(|(k, v)| (k.read().name().to_owned(), v.to_owned()))
+        .collect::<HashSet<_>>();
+
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn test_smart_usage_offset_h() {
+    let subject = setup();
+    let mut offset_h = StringReader::from("/|/|/h");
+    offset_h.cursor = 5;
+
+    let results = subject.get_smart_usage(&get(&subject, "h").read(), &());
+
+    let actual = results
+        .into_iter()
+        .map(|(k, v)| (k.read().name().to_owned(), v))
+        .collect::<HashSet<_>>();
+
+    let expected = vec![
+        (get(&subject, "h 1"), "[1] i"),
+        (get(&subject, "h 2"), "[2] i ii"),
+        (get(&subject, "h 3"), "[3]"),
+    ];
+
+    let expected = expected
+        .into_iter()
+        .map(|(k, v)| (k.read().name().to_owned(), v.to_owned()))
+        .collect::<HashSet<_>>();
+
+    assert_eq!(actual, expected);
+}
diff --git a/azalea-brigadier/tests/command_suggestions_test.rs b/azalea-brigadier/tests/command_suggestions_test.rs
index 8b137891..a907dd6e 100755
--- a/azalea-brigadier/tests/command_suggestions_test.rs
+++ b/azalea-brigadier/tests/command_suggestions_test.rs
@@ -1 +1,446 @@
+use azalea_brigadier::{
+    context::StringRange, prelude::*, string_reader::StringReader, suggestion::Suggestion,
+};
 
+fn test_suggestions(
+    subject: &CommandDispatcher<()>,
+    contents: &str,
+    cursor: usize,
+    range: StringRange,
+    suggestions: Vec<&str>,
+) {
+    let result = CommandDispatcher::get_completion_suggestions_with_cursor(
+        subject.parse(contents.into(), ()),
+        cursor,
+    );
+    assert_eq!(result.range(), range);
+
+    let mut expected = Vec::new();
+    for suggestion in suggestions {
+        expected.push(Suggestion::new(range, suggestion));
+    }
+
+    assert_eq!(result.list(), expected);
+}
+
+fn input_with_offset(input: &str, offset: usize) -> StringReader {
+    let mut result = StringReader::from(input);
+    result.cursor = offset;
+    result
+}
+
+#[test]
+fn get_completion_suggestions_root_commands() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(literal("foo"));
+    subject.register(literal("bar"));
+    subject.register(literal("baz"));
+
+    let result = CommandDispatcher::get_completion_suggestions(subject.parse("".into(), ()));
+
+    assert_eq!(result.range(), StringRange::at(0));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::at(0), "bar"),
+            Suggestion::new(StringRange::at(0), "baz"),
+            Suggestion::new(StringRange::at(0), "foo")
+        ]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_root_commands_with_input_offset() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(literal("foo"));
+    subject.register(literal("bar"));
+    subject.register(literal("baz"));
+
+    let result = CommandDispatcher::get_completion_suggestions(
+        subject.parse(input_with_offset("OOO", 3), ()),
+    );
+
+    assert_eq!(result.range(), StringRange::at(3));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::at(3), "bar"),
+            Suggestion::new(StringRange::at(3), "baz"),
+            Suggestion::new(StringRange::at(3), "foo")
+        ]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_root_commands_partial() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(literal("foo"));
+    subject.register(literal("bar"));
+    subject.register(literal("baz"));
+
+    let result = CommandDispatcher::get_completion_suggestions(subject.parse("b".into(), ()));
+
+    assert_eq!(result.range(), StringRange::between(0, 1));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::between(0, 1), "bar"),
+            Suggestion::new(StringRange::between(0, 1), "baz")
+        ]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_root_commands_partial_with_input_offset() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(literal("foo"));
+    subject.register(literal("bar"));
+    subject.register(literal("baz"));
+
+    let result = CommandDispatcher::get_completion_suggestions(
+        subject.parse(input_with_offset("Zb", 1), ()),
+    );
+
+    assert_eq!(result.range(), StringRange::between(1, 2));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::between(1, 2), "bar"),
+            Suggestion::new(StringRange::between(1, 2), "baz")
+        ]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_sub_commands() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(
+        literal("parent")
+            .then(literal("foo"))
+            .then(literal("bar"))
+            .then(literal("baz")),
+    );
+
+    let result = CommandDispatcher::get_completion_suggestions(subject.parse("parent ".into(), ()));
+
+    assert_eq!(result.range(), StringRange::at(7));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::at(7), "bar"),
+            Suggestion::new(StringRange::at(7), "baz"),
+            Suggestion::new(StringRange::at(7), "foo")
+        ]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_moving_cursor_sub_commands() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(
+        literal("parent_one")
+            .then(literal("faz"))
+            .then(literal("fbz"))
+            .then(literal("gaz")),
+    );
+
+    subject.register(literal("parent_two"));
+
+    test_suggestions(
+        &subject,
+        "parent_one faz ",
+        0,
+        StringRange::at(0),
+        vec!["parent_one", "parent_two"],
+    );
+    test_suggestions(
+        &subject,
+        "parent_one faz ",
+        1,
+        StringRange::between(0, 1),
+        vec!["parent_one", "parent_two"],
+    );
+    test_suggestions(
+        &subject,
+        "parent_one faz ",
+        7,
+        StringRange::between(0, 7),
+        vec!["parent_one", "parent_two"],
+    );
+    test_suggestions(
+        &subject,
+        "parent_one faz ",
+        8,
+        StringRange::between(0, 8),
+        vec!["parent_one"],
+    );
+    test_suggestions(&subject, "parent_one faz ", 10, StringRange::at(0), vec![]);
+    test_suggestions(
+        &subject,
+        "parent_one faz ",
+        11,
+        StringRange::at(11),
+        vec!["faz", "fbz", "gaz"],
+    );
+    test_suggestions(
+        &subject,
+        "parent_one faz ",
+        12,
+        StringRange::between(11, 12),
+        vec!["faz", "fbz"],
+    );
+    test_suggestions(
+        &subject,
+        "parent_one faz ",
+        13,
+        StringRange::between(11, 13),
+        vec!["faz"],
+    );
+    test_suggestions(&subject, "parent_one faz ", 14, StringRange::at(0), vec![]);
+    test_suggestions(&subject, "parent_one faz ", 15, StringRange::at(0), vec![]);
+}
+
+#[test]
+fn get_completion_suggestions_sub_commands_partial() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(
+        literal("parent")
+            .then(literal("foo"))
+            .then(literal("bar"))
+            .then(literal("baz")),
+    );
+
+    let parse = subject.parse("parent b".into(), ());
+
+    let result = CommandDispatcher::get_completion_suggestions(parse);
+
+    assert_eq!(result.range(), StringRange::between(7, 8));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::between(7, 8), "bar"),
+            Suggestion::new(StringRange::between(7, 8), "baz")
+        ]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_sub_commands_partial_with_input_offset() {
+    let mut subject = CommandDispatcher::<()>::new();
+    subject.register(
+        literal("parent")
+            .then(literal("foo"))
+            .then(literal("bar"))
+            .then(literal("baz")),
+    );
+
+    let parse = subject.parse(input_with_offset("junk parent b", 5), ());
+
+    let result = CommandDispatcher::get_completion_suggestions(parse);
+
+    assert_eq!(result.range(), StringRange::between(12, 13));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::between(12, 13), "bar"),
+            Suggestion::new(StringRange::between(12, 13), "baz")
+        ]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_redirect() {
+    let mut subject = CommandDispatcher::<()>::new();
+    let actual = subject.register(literal("actual").then(literal("sub")));
+    subject.register(literal("redirect").redirect(actual));
+
+    let parse = subject.parse("redirect ".into(), ());
+
+    let result = CommandDispatcher::get_completion_suggestions(parse);
+
+    assert_eq!(result.range(), StringRange::at(9));
+    assert_eq!(
+        result.list(),
+        vec![Suggestion::new(StringRange::at(9), "sub")]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_redirect_partial() {
+    let mut subject = CommandDispatcher::<()>::new();
+    let actual = subject.register(literal("actual").then(literal("sub")));
+    subject.register(literal("redirect").redirect(actual));
+
+    let parse = subject.parse("redirect s".into(), ());
+
+    let result = CommandDispatcher::get_completion_suggestions(parse);
+
+    assert_eq!(result.range(), StringRange::between(9, 10));
+    assert_eq!(
+        result.list(),
+        vec![Suggestion::new(StringRange::between(9, 10), "sub")]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_moving_cursor_redirect() {
+    let mut subject = CommandDispatcher::<()>::new();
+    let actual_one = subject.register(
+        literal("actual_one")
+            .then(literal("faz"))
+            .then(literal("fbz"))
+            .then(literal("gaz")),
+    );
+
+    subject.register(literal("actual_two"));
+
+    subject.register(literal("redirect_one").redirect(actual_one.clone()));
+    subject.register(literal("redirect_two").redirect(actual_one));
+
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        0,
+        StringRange::at(0),
+        vec!["actual_one", "actual_two", "redirect_one", "redirect_two"],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        9,
+        StringRange::between(0, 9),
+        vec!["redirect_one", "redirect_two"],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        10,
+        StringRange::between(0, 10),
+        vec!["redirect_one"],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        12,
+        StringRange::at(0),
+        vec![],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        13,
+        StringRange::at(13),
+        vec!["faz", "fbz", "gaz"],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        14,
+        StringRange::between(13, 14),
+        vec!["faz", "fbz"],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        15,
+        StringRange::between(13, 15),
+        vec!["faz"],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        16,
+        StringRange::at(0),
+        vec![],
+    );
+    test_suggestions(
+        &subject,
+        "redirect_one faz ",
+        17,
+        StringRange::at(0),
+        vec![],
+    );
+}
+
+#[test]
+fn get_completion_suggestions_redirect_partial_with_input_offset() {
+    let mut subject = CommandDispatcher::<()>::new();
+    let actual = subject.register(literal("actual").then(literal("sub")));
+    subject.register(literal("redirect").redirect(actual));
+
+    let parse = subject.parse(input_with_offset("/redirect s", 1), ());
+
+    let result = CommandDispatcher::get_completion_suggestions(parse);
+
+    assert_eq!(result.range(), StringRange::between(10, 11));
+    assert_eq!(
+        result.list(),
+        vec![Suggestion::new(StringRange::between(10, 11), "sub")]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_redirect_lots() {
+    let mut subject = CommandDispatcher::<()>::new();
+    let loop_ = subject.register(literal("redirect"));
+    subject.register(
+        literal("redirect").then(literal("loop").then(argument("loop", integer()).redirect(loop_))),
+    );
+
+    let result = CommandDispatcher::get_completion_suggestions(
+        subject.parse("redirect loop 1 loop 02 loop 003 ".into(), ()),
+    );
+
+    assert_eq!(result.range(), StringRange::at(33));
+    assert_eq!(
+        result.list(),
+        vec![Suggestion::new(StringRange::at(33), "loop")]
+    );
+}
+
+#[test]
+fn get_completion_suggestions_execute_simulation() {
+    let mut subject = CommandDispatcher::<()>::new();
+    let execute = subject.register(literal("execute"));
+    subject.register(
+        literal("execute")
+            .then(literal("as").then(argument("name", word()).redirect(execute.clone())))
+            .then(literal("store").then(argument("name", word()).redirect(execute)))
+            .then(literal("run").executes(|_| 0)),
+    );
+
+    let parse = subject.parse("execute as Dinnerbone as".into(), ());
+
+    let result = CommandDispatcher::get_completion_suggestions(parse);
+
+    assert!(result.is_empty());
+}
+
+#[test]
+fn get_completion_suggestions_execute_simulation_partial() {
+    let mut subject = CommandDispatcher::<()>::new();
+    let execute = subject.register(literal("execute"));
+    subject.register(
+        literal("execute")
+            .then(
+                literal("as")
+                    .then(literal("bar").redirect(execute.clone()))
+                    .then(literal("baz").redirect(execute.clone())),
+            )
+            .then(literal("store").then(argument("name", word()).redirect(execute)))
+            .then(literal("run").executes(|_| 0)),
+    );
+
+    let parse = subject.parse("execute as bar as ".into(), ());
+
+    let result = CommandDispatcher::get_completion_suggestions(parse);
+
+    assert_eq!(result.range(), StringRange::at(18));
+    assert_eq!(
+        result.list(),
+        vec![
+            Suggestion::new(StringRange::at(18), "bar"),
+            Suggestion::new(StringRange::at(18), "baz")
+        ]
+    );
+}
diff --git a/azalea-brigadier/tests/context/command_context_test.rs b/azalea-brigadier/tests/context/command_context_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/context/command_context_test.rs
+++ b/azalea-brigadier/tests/context/command_context_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/context/parsed_argument_test.rs b/azalea-brigadier/tests/context/parsed_argument_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/context/parsed_argument_test.rs
+++ b/azalea-brigadier/tests/context/parsed_argument_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/exceptions/dynamic_command_syntax_exception_type_test.rs b/azalea-brigadier/tests/exceptions/dynamic_command_syntax_exception_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/exceptions/dynamic_command_syntax_exception_type_test.rs
+++ b/azalea-brigadier/tests/exceptions/dynamic_command_syntax_exception_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/exceptions/simple_command_syntax_exception_type_test.rs b/azalea-brigadier/tests/exceptions/simple_command_syntax_exception_type_test.rs
index e69de29b..8b137891 100755
--- a/azalea-brigadier/tests/exceptions/simple_command_syntax_exception_type_test.rs
+++ b/azalea-brigadier/tests/exceptions/simple_command_syntax_exception_type_test.rs
@@ -0,0 +1 @@
+
diff --git a/azalea-brigadier/tests/suggestion/mod.rs b/azalea-brigadier/tests/suggestion/mod.rs
index 7b96af2b..0ac50d52 100644
--- a/azalea-brigadier/tests/suggestion/mod.rs
+++ b/azalea-brigadier/tests/suggestion/mod.rs
@@ -1,3 +1,3 @@
 mod suggestion_test;
 mod suggestions_builder_test;
-mod suggestions_test;
\ No newline at end of file
+mod suggestions_test;
diff --git a/azalea-brigadier/tests/suggestion/suggestions_test.rs b/azalea-brigadier/tests/suggestion/suggestions_test.rs
index 12a2c73b..987dfb71 100755
--- a/azalea-brigadier/tests/suggestion/suggestions_test.rs
+++ b/azalea-brigadier/tests/suggestion/suggestions_test.rs
@@ -7,7 +7,7 @@ use azalea_brigadier::{
 
 #[test]
 fn merge_empty() {
-    let merged = Suggestions::<()>::merge("foo b", &[]);
+    let merged = Suggestions::merge("foo b", &[]);
     assert!(merged.is_empty());
 }