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,