added more parsers; more tests

Author: dat2

src/lib.rs

@@ -1,3 +1,5 @@
+// #![deny(missing_docs)]
+
 #[macro_use]
 extern crate chomp;
 

src/parser.rs

@@ -1,27 +1,29 @@
+// #![deny(missing_docs)]
+
 use std::collections::HashMap;
 
 use std::marker::PhantomData;
 
 use combine::{Parser, ParseResult, Stream};
 use combine::char::{tab, char, crlf, string, letter, alpha_num};
-use combine::combinator::{many, none_of, or, optional, value};
+use combine::combinator::{between, many, none_of, or, optional, value};
 
 pub type Name = String;
 pub type SelectionSet = Vec<Selection>;
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub struct Document {
   definitions: Vec<Definition>,
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub enum Definition {
   Operation(Operation),
   SelectionSet(SelectionSet),
   Fragment(Fragment),
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub struct Operation {
   op_type: OperationType,
   name: Option<Name>,
@@ -44,29 +46,39 @@ impl Operation {
   }
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub enum OperationType {
   Query,
   Mutation,
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub struct VariableDefinition {
   variable: Variable,
   var_type: Type,
   default_value: Option<Value>,
 }
 
-type Variable = String;
+impl VariableDefinition {
+  fn new(variable: Variable, var_type: Type, default_value: Option<Value>) -> VariableDefinition {
+    VariableDefinition {
+      variable: variable,
+      var_type: var_type,
+      default_value: default_value,
+    }
+  }
+}
+
+pub type Variable = String;
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub enum Type {
   Named(Name),
   List(Box<Type>),
   NonNull(Box<Type>),
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub enum Value {
   Variable(Variable),
   Int(i32),
@@ -79,26 +91,26 @@ pub enum Value {
   Object(HashMap<String, Value>),
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub struct Directive {
   name: Name,
   arguments: Vec<Argument>,
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub struct Argument {
   name: Name,
   value: Value,
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub enum Selection {
   Field(Field),
   FragmentSpread(Name, Vec<Directive>),
   InlineFragment(Option<Type>, Vec<Directive>, SelectionSet),
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub struct Field {
   alias: Option<Name>,
   name: Name,
@@ -124,7 +136,7 @@ impl Field {
   }
 }
 
-#[derive(Debug,PartialEq)]
+#[derive(Debug,PartialEq,Clone)]
 pub struct Fragment {
   name: Name,
   type_condition: Type,
@@ -139,11 +151,14 @@ macro_rules! make_parser {
 
     ($name:ident ($input_var:ident : $input_item_type:ty) -> $output_type:ty { $($tmpl:tt)* } $($rest:tt)*) => {
 
-      pub struct $name<T> {
+      #[derive(Clone)]
+      #[allow(missing_docs)]
+      pub struct $name<T: Clone> {
         _phantom: PhantomData<T>,
       }
 
-      impl<T> $name<T> {
+      impl<T: Clone> $name<T> {
+          #[allow(missing_docs)]
           pub fn new() -> Self {
               $name {
                 _phantom: PhantomData
@@ -166,12 +181,15 @@ macro_rules! make_parser {
     ($name:ident ($input_var:ident : $input_item_type:ty , $($field:ident : &$typ:ty),*)
       -> $output_type:ty { $($tmpl:tt)* } $($rest:tt)*) => {
 
-        pub struct $name<'a, T> {
+        #[derive(Clone)]
+        #[allow(missing_docs)]
+        pub struct $name<'a, T: Clone> {
           _phantom: PhantomData<T>,
           $( $field: &'a $typ),*
         }
 
-        impl<'a, T> $name<'a, T> {
+        impl<'a, T: Clone> $name<'a, T> {
+          #[allow(missing_docs)]
           pub fn new($($field: &'a $typ),*) -> Self {
             $name {
               _phantom: PhantomData,
@@ -234,15 +252,33 @@ make_parser!(
 );
 
 make_parser!(
-  OperationTypeP(input: char) -> OperationType {
+  OperationDefinition(input: char) -> Operation {
+    OperationTypeParserarser::new()
+      .and(optional(NameParser::new()))
+      .and(optional(VariableDefinitions::new()))
+      .map(|((op_type,name),defns)| {
+        let variable_definitions = match defns {
+          Some(ds) => ds,
+          None => Vec::new()
+        };
+
+        Operation::new(op_type, name, variable_definitions, Vec::new())
+      })
+      .parse_stream(input)
+  }
+);
+
+make_parser!(
+  OperationTypeParserarser(input: char) -> OperationType {
     string("query").map(|_| OperationType::Query)
       .or(string("mutation").map(|_| OperationType::Mutation))
+      .skip(many::<Vec<_>,_>(or(WhiteSpace::new(), LineTerminator::new(&true))))
       .parse_stream(input)
   }
 );
 
 make_parser!(
-  NameP(input: char) -> Name {
+  NameParser(input: char) -> Name {
     or(letter(),char('_'))
       .map(|c| {
         let mut result = String::new();
@@ -254,35 +290,69 @@ make_parser!(
         f.push_str(&r);
         f
       })
+      .skip(many::<Vec<_>,_>(or(WhiteSpace::new(), LineTerminator::new(&true))))
       .parse_stream(input)
   }
 );
 
 make_parser!(
-  Alias(input: char) -> Name {
-    NameP::new()
+  VariableDefinitions(input: char) -> Vec<VariableDefinition> {
+    between(char('('), char(')'), many(VariableDefinitionP::new()))
+      .parse_stream(input)
+  }
+);
+
+make_parser!(
+  VariableDefinitionP(input: char) -> VariableDefinition {
+    VariableParser::new()
+      .and(TypeParser::new())
+      .map(|(variable,var_type)| {
+        VariableDefinition::new(variable, var_type, None)
+      })
+      .parse_stream(input)
+  }
+);
+
+make_parser!(
+  VariableParser(input: char) -> Variable {
+    char('$')
+      .with(NameParser::new()) // skip the $
+      .parse_stream(input)
+  }
+);
+
+make_parser!(
+  TypeParser(input: char) -> Type {
+    let named_type = NameParser::new().map(Type::Named);
+    let list_type = between(char('['),char(']'), TypeParser::new()).map(|t| Type::List(Box::new(t)));
+
+// i can't clone for some reason -.-
+    let non_null_type = char('!')
+      .with(or(
+        NameParser::new().map(Type::Named),
+        between(char('['),char(']'), TypeParser::new()).map(|t| Type::List(Box::new(t)))
+      ))
+      .map(|t| Type::NonNull(Box::new(t)));
+
+    non_null_type.or(named_type).or(list_type)
       .skip(many::<Vec<_>,_>(or(WhiteSpace::new(), LineTerminator::new(&true))))
-      .skip(char(':'))
       .parse_stream(input)
   }
 );
 
 make_parser!(
-  OperationDefinition(input: char) -> Operation {
-    OperationTypeP::new()
+  Alias(input: char) -> Name {
+    NameParser::new()
       .skip(many::<Vec<_>,_>(or(WhiteSpace::new(), LineTerminator::new(&true))))
-      .and(optional(NameP::new()))
-      .map(|(op_type,name)| {
-        Operation::new(op_type, name, Vec::new(), Vec::new())
-      })
+      .skip(char(':'))
       .parse_stream(input)
   }
 );
 
 #[cfg(test)]
 mod tests {
   use super::*;
-  use combine::{Parser,State};
+  use combine::{State, Parser};
 
   macro_rules! assert_successful_parse {
     ($parser:ident,$input:expr,$result:expr) => {
@@ -297,17 +367,19 @@ mod tests {
 
   #[test]
   fn test_parse_operationtype() {
-    assert_successful_parse!(OperationTypeP, "query", OperationType::Query);
-    assert_successful_parse!(OperationTypeP, "mutation", OperationType::Mutation);
+    assert_successful_parse!(OperationTypeParserarser, "query", OperationType::Query);
+    assert_successful_parse!(OperationTypeParserarser,
+                             "mutation",
+                             OperationType::Mutation);
   }
 
   #[test]
   fn test_parse_name() {
-    assert_successful_parse!(NameP, "_asd", String::from("_asd"));
-    assert_successful_parse!(NameP, "aasd", String::from("aasd"));
-    assert_successful_parse!(NameP, "zasd", String::from("zasd"));
-    assert_successful_parse!(NameP, "Aasd", String::from("Aasd"));
-    assert_successful_parse!(NameP, "Zasd", String::from("Zasd"));
+    assert_successful_parse!(NameParser, "_asd", String::from("_asd"));
+    assert_successful_parse!(NameParser, "aasd", String::from("aasd"));
+    assert_successful_parse!(NameParser, "zasd", String::from("zasd"));
+    assert_successful_parse!(NameParser, "Aasd", String::from("Aasd"));
+    assert_successful_parse!(NameParser, "Zasd", String::from("Zasd"));
   }
 
   #[test]
@@ -321,7 +393,10 @@ mod tests {
   fn test_parse_operation() {
     // named operation
     {
-      let result = Operation::new(OperationType::Mutation, Some(String::from("test")), Vec::new(), Vec::new());
+      let result = Operation::new(OperationType::Mutation,
+                                  Some(String::from("test")),
+                                  Vec::new(),
+                                  Vec::new());
       assert_successful_parse!(OperationDefinition, "mutation test", result);
     }
 
@@ -331,4 +406,22 @@ mod tests {
       assert_successful_parse!(OperationDefinition, "mutation", result);
     }
   }
+
+  #[test]
+  fn test_parse_type() {
+    assert_successful_parse!(TypeParser, "User", Type::Named(String::from("User")));
+    assert_successful_parse!(TypeParser,
+                             "[User]",
+                             Type::List(Box::new(Type::Named(String::from("User")))));
+  }
+
+  #[test]
+  fn test_parse_nonnull_type() {
+    assert_successful_parse!(TypeParser,
+                             "!User",
+                             Type::NonNull(Box::new(Type::Named(String::from("User")))));
+    assert_successful_parse!(TypeParser,
+                             "![User]",
+                             Type::NonNull(Box::new(Type::List(Box::new(Type::Named(String::from("User")))))));
+  }
 }