feat(src): Actually allow access to the parsed values via getters

src/lib.rs

@@ -72,24 +72,45 @@
 //! 1. `function() print(`
 //! 1. `Hi!`
 //! 1. `) end`
-use std::fmt::Display;
+use std::{fmt::Display, str::FromStr};
 
-use pest::{error::Error, Parser};
+use parsing::{Rule, TrinitryParser};
-use pest_derive::Parser;
+use pest::error::Error;
 
-#[derive(Parser)]
+mod parsing;
-#[grammar = "trinitry.pest"]
+
-pub struct Trinitry {
+pub struct TrinitryInvokation {
     command: String,
     arguments: Vec<String>,
 }
 
-impl Trinitry {
+impl TrinitryInvokation {
-    pub fn new(input: &str) -> Result<Self, Error<Rule>> {
+    pub fn new(input: &str) -> Result<Self, <Self as FromStr>::Err> {
-        let parsed = Self::parse(Rule::trinitry, input)?;
+        input.parse()
+    }
 
+    pub fn command(&self) -> &str {
+        &self.command
+    }
+
+    pub fn arguments(&self) -> &[String] {
+        &self.arguments
+    }
+}
+
+impl FromStr for TrinitryInvokation {
+    type Err = Error<Rule>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let parsed = TrinitryParser::new(s)?;
+        Ok(Self::from(parsed))
+    }
+}
+
+impl From<TrinitryParser<'_>> for TrinitryInvokation {
+    fn from(parsed: TrinitryParser) -> Self {
         let command = {
-            let command: Vec<_> = parsed.clone().find_tagged("command").collect();
+            let command: Vec<_> = parsed.0.clone().find_tagged("command").collect();
 
             // Ensure that we have only one command
             // This should be ensured by the grammar, thus the 'debug_assert'
@@ -102,9 +123,9 @@ impl Trinitry {
                 .expect("This should contain exactly one element")
                 .to_owned()
         };
-        let arguments: Vec<_> = parsed.clone().find_tagged("argument").collect();
+        let arguments: Vec<_> = parsed.0.clone().find_tagged("argument").collect();
 
-        Ok(Trinitry {
+        Self {
             command: command.as_str().to_owned(),
             arguments: arguments
                 .iter()
@@ -134,11 +155,11 @@ impl Trinitry {
                     arg.to_owned()
                 })
                 .collect(),
-        })
+        }
     }
 }
 
-impl Display for Trinitry {
+impl Display for TrinitryInvokation {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.arguments.is_empty() {
             f.write_str(&self.command)
@@ -156,12 +177,12 @@ mod tests;
 
 #[cfg(test)]
 mod test {
-    use crate::Trinitry;
+    use crate::TrinitryInvokation;
 
     #[test]
     fn parse_cmd() {
         let string = "quit";
-        let p = Trinitry::new(string).unwrap_or_else(|e| {
+        let p = TrinitryInvokation::new(string).unwrap_or_else(|e| {
             panic!("{}", e);
         });
         assert_eq!(&p.command, "quit");
@@ -171,7 +192,7 @@ mod test {
     #[test]
     fn parse_arg_clean() {
         let string = r##"lua print("Hi")"##;
-        let p = Trinitry::new(string).unwrap_or_else(|e| {
+        let p = TrinitryInvokation::new(string).unwrap_or_else(|e| {
             panic!("{}", e);
         });
         assert_eq!(&p.command, "lua");
@@ -181,7 +202,7 @@ mod test {
     #[test]
     fn parse_arg_quote() {
         let string = r##"write "some 'file' name""##;
-        let p = Trinitry::new(string).unwrap_or_else(|e| {
+        let p = TrinitryInvokation::new(string).unwrap_or_else(|e| {
             panic!("{}", e);
         });
         assert_eq!(&p.command, "write");
@@ -191,7 +212,7 @@ mod test {
     #[test]
     fn parse_arg_single_quote() {
         let string = r##"write 'some "file" name'"##;
-        let p = Trinitry::new(string).unwrap_or_else(|e| {
+        let p = TrinitryInvokation::new(string).unwrap_or_else(|e| {
             panic!("{}", e);
         });
         assert_eq!(&p.command, "write");
@@ -201,7 +222,7 @@ mod test {
     #[test]
     fn parse_arg_multi() {
         let string = r##"write 'some "file" name' "other name" last"##;
-        let p = Trinitry::new(string).unwrap_or_else(|e| {
+        let p = TrinitryInvokation::new(string).unwrap_or_else(|e| {
             panic!("{}", e);
         });
 

src/parsing.rs

@@ -0,0 +1,13 @@
+use pest::{error::Error, iterators::Pairs, Parser};
+use pest_derive::Parser;
+
+#[derive(Parser)]
+#[grammar = "trinitry.pest"]
+pub(crate) struct TrinitryParser<'a>(pub(crate) Pairs<'a, Rule>);
+
+impl<'a> TrinitryParser<'a> {
+    pub fn new(input: &'a str) -> Result<Self, Error<Rule>> {
+        let parsed = Self::parse(Rule::trinitry, input)?;
+        Ok(Self(parsed))
+    }
+}