Command API

crates/valence_command/README.md

@@ -0,0 +1,41 @@
+# valence_command
+
+Command API for minecraft with supported brigadier arguments.
+
+## Raw usage
+
+To use command API 'raw', you need to know `Parse` trait.
+
+```rust
+// Anything what can be &str
+let input = "gamemode @s creative";
+
+// StrReader is needed for Parse trait to work with.
+let mut reader = StrReader::new(input);
+
+// Here we are using Parse trait. It returns an ParsingResult (it is not a standard result)
+// It has 2 fields. suggestions and result
+// Result contains error or an object.
+// Suggestions contains suggestions.
+let gamemode_literal_result = <&str>::parse(None, reader, ParsingPurpose::Reading);
+
+if let Err((err_pos, err)) = gamemode_literal_result.result {
+    // Handle error
+
+    // Component of error (usually this need to be sent to an user)
+    let text = err.build();
+
+}
+
+// str itself
+let gamemode_literal = gamemode_literal_result.result.unwrap();
+
+// to parse next argument you would need to skip a whitespace, because each Parse parse only its own chars.
+// for now only "gamemode" parsed
+
+if !reader.skip_char(' ') {
+    // next char is not whitespace otherwise it is skipped and returned true.
+}
+
+// continue parsing.
+```

crates/valence_command/src/entity.rs

@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use std::num::NonZeroI32;
 
 use valence_core::game_mode::GameMode;
+use valence_core::text::Text;
 use valence_core::translation_key::{
     ARGUMENT_ENTITY_OPTIONS_INAPPLICABLE, ARGUMENT_ENTITY_OPTIONS_LIMIT_TOOSMALL,
     ARGUMENT_ENTITY_OPTIONS_SORT_IRREVERSIBLE, ARGUMENT_ENTITY_OPTIONS_UNKNOWN,
@@ -274,10 +275,48 @@ impl From<EntitySelectorFlagSuggestions<CEnumSuggestions<GameMode>>> for EntityS
     }
 }
 
+#[ctor::ctor]
+static PROP_NAMES: [Suggestion<'static>; 21] = {
+    macro_rules! els {
+        ($($f: expr,)*) => {
+            [$(Suggestion {
+                message: Cow::Borrowed(concat!($f, "=")),
+                tooltip: Some(Text::translate(
+                    Cow::Borrowed(concat!("argument.entity.options.", $f, ".description")),
+                    vec![],
+                )),
+            },)*]
+        }
+    }
+
+    els!(
+        "x",
+        "y",
+        "z",
+        "distance",
+        "dx",
+        "dy",
+        "dz",
+        "x_rotation",
+        "y_rotation",
+        "scores",
+        "tag",
+        "team",
+        "name",
+        "type",
+        "predicate",
+        "nbt",
+        "level",
+        "gamemode",
+        "advancements",
+        "limit",
+        "sort",
+    )
+};
+
 impl<'a> ParsingBuild<ParsingSuggestions<'a>> for EntitySelectorSuggestions {
     fn build(self) -> ParsingSuggestions<'a> {
         const NEXT: &[Suggestion<'static>] = &[Suggestion::new_str(","), Suggestion::new_str("]")];
-        const PROP_NAMES: &[Suggestion<'static>] = &[];
         const SELECTORS: &[Suggestion<'static>] = &[
             Suggestion::new_str("p"),
             Suggestion::new_str("r"),
@@ -290,7 +329,7 @@ impl<'a> ParsingBuild<ParsingSuggestions<'a>> for EntitySelectorSuggestions {
         const OPTION_END: &[Suggestion<'static>] = &[Suggestion::new_str("}")];
         match self {
             Self::Next => ParsingSuggestions::Borrowed(NEXT),
-            Self::Name => ParsingSuggestions::Borrowed(PROP_NAMES),
+            Self::Name => ParsingSuggestions::Borrowed(PROP_NAMES.as_slice()),
             Self::Selector => ParsingSuggestions::Borrowed(SELECTORS),
             Self::EqSign => ParsingSuggestions::Borrowed(EQ_SIGN),
             Self::OptionEnter => ParsingSuggestions::Borrowed(OPTION_ENTER),

crates/valence_command/src/lib.rs

@@ -1,3 +1,5 @@
+#![doc = include_str!("../README.md")]
+
 pub mod block;
 pub mod cenum;
 pub mod entity;

crates/valence_command/src/parser.rs

@@ -10,7 +10,7 @@ use crate::reader::{StrCursor, StrReader};
 #[derive(Clone, Debug)]
 pub struct Suggestion<'a> {
     pub message: Cow<'a, str>,
-    pub tooltip: Option<Cow<'a, Text>>,
+    pub tooltip: Option<Text>,
 }
 
 impl<'a> Suggestion<'a> {

crates/valence_command/src/primitive.rs

@@ -395,6 +395,26 @@ where
     }
 }
 
+// a.k.a Literal
+impl<'a> Parse<'a> for &'a str {
+    type Data = ();
+
+    type Error = NoParsingBuild;
+
+    type Suggestions = NoParsingBuild;
+
+    fn parse(
+        _data: Option<&Self::Data>,
+        reader: &mut StrReader<'a>,
+        _purpose: ParsingPurpose,
+    ) -> ParsingResult<Self, Self::Suggestions, Self::Error> {
+        ParsingResult {
+            suggestions: None,
+            result: Ok(Some(reader.read_unquoted_str())),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/valence_command/src/resource.rs

@@ -31,3 +31,6 @@ impl<'a> BrigadierArgument<'a> for ResourceLocation<'a> {
         Parser::ResourceLocation
     }
 }
+
+// resource, resource_key, resource_tag, resource_tag_or_key should be
+// implemented when registry system will be fully implemented.