Remove async-graphql-derive dependency on graphql-parser.

async-graphql-derive/Cargo.toml

@@ -16,8 +16,8 @@ categories = ["network-programming", "asynchronous"]
 proc-macro = true
 
 [dependencies]
+async-graphql-parser = { path = "../async-graphql-parser", version = "0.1.0" }
 proc-macro2 = "1.0.6"
 syn = { version = "1.0.13", features = ["full"] }
 quote = "1.0.3"
-graphql-parser = "0.2.3"
 Inflector = "0.11.4"

async-graphql-derive/src/args.rs

@@ -1,5 +1,5 @@
-use crate::utils::{parse_guards, parse_validator, parse_value};
-use graphql_parser::query::Value;
+use crate::utils::{parse_guards, parse_validator};
+use async_graphql_parser::{parse_value, Value};
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{Attribute, AttributeArgs, Error, Lit, Meta, MetaList, NestedMeta, Result, Type};

async-graphql-derive/src/utils.rs

@@ -1,5 +1,4 @@
-use graphql_parser::parse_query;
-use graphql_parser::query::{Definition, OperationDefinition, ParseError, Query, Value};
+use async_graphql_parser::Value;
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{Error, Expr, Ident, Lit, Meta, MetaList, NestedMeta, Result};
@@ -13,27 +12,11 @@ pub fn get_crate_name(internal: bool) -> TokenStream {
     }
 }
 
-pub fn parse_value(s: &str) -> std::result::Result<Value, ParseError> {
-    let mut doc = parse_query(&format!("query ($a:Int!={}) {{ dummy }}", s))?;
-    let definition = doc.definitions.remove(0);
-    if let Definition::Operation(OperationDefinition::Query(Query {
-        mut variable_definitions,
-        ..
-    })) = definition
-    {
-        let var = variable_definitions.remove(0);
-        Ok(var.default_value.unwrap())
-    } else {
-        unreachable!()
-    }
-}
-
 pub fn build_value_repr(crate_name: &TokenStream, value: &Value) -> TokenStream {
     match value {
         Value::Variable(_) => unreachable!(),
         Value::Int(n) => {
-            let n = n.as_i64().unwrap();
-            quote! { #crate_name::Value::Int((#n as i32).into()) }
+            quote! { #crate_name::Value::Int(#n) }
         }
         Value::Float(n) => {
             quote! { #crate_name::Value::Float(#n) }

async-graphql-parser/src/lib.rs

@@ -4,10 +4,10 @@ extern crate pest_derive;
 extern crate thiserror;
 
 pub mod ast;
-mod query_parser;
 mod pos;
+mod query_parser;
 mod value;
 
-pub use query_parser::{parse_query, Error, Result};
 pub use pos::{Pos, Positioned};
+pub use query_parser::{parse_query, parse_value, Error, Result};
 pub use value::Value;

async-graphql-parser/src/query_parser.rs

@@ -120,6 +120,15 @@ pub fn parse_query<T: AsRef<str>>(input: T) -> Result<Document> {
     Ok(Document { definitions })
 }
 
+/// Parse a graphql value
+pub fn parse_value<T: AsRef<str>>(input: T) -> Result<Value> {
+    let value_pair: Pair<Rule> = QueryParser::parse(Rule::value, input.as_ref())?
+        .next()
+        .unwrap();
+    let mut pc = PositionCalculator::new(input.as_ref());
+    parse_value2(value_pair, &mut pc)
+}
+
 fn parse_named_operation_definition(
     pair: Pair<Rule>,
     pc: &mut PositionCalculator,
@@ -200,7 +209,7 @@ fn parse_named_operation_definition(
 fn parse_default_value(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Value> {
     for pair in pair.into_inner() {
         match pair.as_rule() {
-            Rule::value => return Ok(parse_value(pair, pc)?),
+            Rule::value => return Ok(parse_value2(pair, pc)?),
             _ => unreachable!(),
         }
     }
@@ -313,7 +322,7 @@ fn parse_variable(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Posit
     unreachable!()
 }
 
-fn parse_value(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Value> {
+fn parse_value2(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Value> {
     let pair = pair.into_inner().next().unwrap();
     Ok(match pair.as_rule() {
         Rule::object => parse_object_value(pair, pc)?,
@@ -348,7 +357,7 @@ fn parse_object_pair(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<(S
     for pair in pair.into_inner() {
         match pair.as_rule() {
             Rule::name => name = Some(pair.as_str().to_string()),
-            Rule::value => value = Some(parse_value(pair, pc)?),
+            Rule::value => value = Some(parse_value2(pair, pc)?),
             _ => unreachable!(),
         }
     }
@@ -373,7 +382,7 @@ fn parse_array_value(pair: Pair<Rule>, pc: &mut PositionCalculator) -> Result<Va
     for pair in pair.into_inner() {
         match pair.as_rule() {
             Rule::value => {
-                array.push(parse_value(pair, pc)?);
+                array.push(parse_value2(pair, pc)?);
             }
             _ => unreachable!(),
         }
@@ -393,7 +402,7 @@ fn parse_pair(
             Rule::value => {
                 value = {
                     let pos = pc.step(&pair);
-                    Some(Positioned::new(parse_value(pair, pc)?, pos))
+                    Some(Positioned::new(parse_value2(pair, pc)?, pos))
                 }
             }
             _ => unreachable!(),