Added consume_definition (#42)

Author: That3Percent

src/query/ast.rs

@@ -19,7 +19,7 @@ impl<'a> Document<'a, String> {
         // To support both reference and owned values in the AST,
         // all string data is represented with the ::common::Str<'a, T: Text<'a>> 
         // wrapper type.
-        // This type must carry the liftetime of the query string,
+        // This type must carry the lifetime of the query string,
         // and is stored in a PhantomData value on the Str type.
         // When using owned String types, the actual lifetime of
         // the Ast nodes is 'static, since no references are kept,

src/query/grammar.rs

@@ -206,11 +206,20 @@ pub fn parse_query<'a, S>(s: &'a str) -> Result<Document<'a, S>, ParseError>
     Ok(doc)
 }
 
+/// Parses a single ExecutableDefinition and returns an AST as well as the
+/// remainder of the input which is unparsed
+pub fn consume_definition<'a, S>(s: &'a str) -> Result<(Definition<'a, S>, &'a str), ParseError> where S: Text<'a> {
+    let tokens = TokenStream::new(s);
+    let (doc, tokens) = parser(definition).parse(tokens)?;
+
+    Ok((doc, &s[tokens.offset()..]))
+}
+
 #[cfg(test)]
 mod test {
     use crate::position::Pos;
     use crate::query::grammar::*;
-    use super::parse_query;
+    use super::{parse_query, consume_definition};
 
     fn ast(s: &str) -> Document<String> {
         parse_query::<String>(&s).unwrap().to_owned()
@@ -292,6 +301,35 @@ mod test {
     }
 
     #[test]
+    fn consume_single_query() {
+        let (query, remainder) = consume_definition::<String>("query { a } query { b }").unwrap();
+        assert!(matches!(query, Definition::Operation(_)));
+        assert_eq!(remainder, "query { b }");
+    }
+
+    #[test]
+    fn consume_full_text() {
+        let (query, remainder) = consume_definition::<String>("query { a }").unwrap();
+        assert!(matches!(query, Definition::Operation(_)));
+        assert_eq!(remainder, "");
+    }
+
+    #[test]
+    fn consume_single_query_preceding_non_graphql() {
+        let (query, remainder) =
+            consume_definition::<String>("query { a } where a > 1 => 10.0").unwrap();
+        assert!(matches!(query, Definition::Operation(_)));
+        assert_eq!(remainder, "where a > 1 => 10.0");
+    }
+
+    #[test]
+    fn consume_fails_without_operation() {
+        let err = consume_definition::<String>("where a > 1 => 10.0")
+            .expect_err("Expected parse to fail with an error");
+        let err = format!("{}", err);
+        assert_eq!(err, "query parse error: Parse error at 1:1\nUnexpected `where[Name]`\nExpected `{`, `query`, `mutation`, `subscription` or `fragment`\n");
+    }
+  
     fn recursion_too_deep() {
         let query = format!("{}(b: {}{}){}", "{ a".repeat(30), "[".repeat(25), "]".repeat(25),  "}".repeat(30));
         let result = parse_query::<&str>(&query);

src/query/mod.rs

@@ -6,6 +6,6 @@ mod format;
 mod grammar;
 
 
-pub use self::grammar::parse_query;
+pub use self::grammar::{parse_query, consume_definition};
 pub use self::error::ParseError;
 pub use self::ast::*;

src/tokenizer.rs

@@ -33,6 +33,12 @@ pub struct TokenStream<'a> {
     recursion_limit: usize,
 }
 
+impl TokenStream<'_> {
+    pub(crate) fn offset(&self) -> usize {
+        self.off
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct Checkpoint {
     position: Pos,