WIP: Implement input extension

Author: tailhook

src/schema/ast.rs

@@ -173,6 +173,7 @@ pub struct InputObjectType {
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct InputObjectTypeExtension {
+    pub position: Pos,
     pub name: Name,
     pub directives: Vec<Directive>,
     pub fields: Vec<InputValue>,

src/schema/format.rs

@@ -342,7 +342,11 @@ impl Displayable for InputObjectType {
 
 impl Displayable for InputObjectTypeExtension {
     fn display(&self, f: &mut Formatter) {
-        unimplemented!();
+        f.indent();
+        f.write("extend input ");
+        f.write(&self.name);
+        format_directives(&self.directives, f);
+        format_inputs(&self.fields, f);
     }
 }
 

src/schema/grammar.rs

@@ -395,11 +395,10 @@ pub fn input_object_type<'a>(input: &mut TokenStream<'a>)
     (
         position(),
         ident("input").with(name()),
-        parser(implements_interfaces),
         parser(directives),
         parser(input_fields),
     )
-        .map(|(position, name, interfaces, directives, fields)| {
+        .map(|(position, name, directives, fields)| {
             InputObjectType {
                 position, name, directives, fields,
                 description: None,  // is filled in type_definition
@@ -408,6 +407,30 @@ pub fn input_object_type<'a>(input: &mut TokenStream<'a>)
         .parse_stream(input)
 }
 
+pub fn input_object_type_extension<'a>(input: &mut TokenStream<'a>)
+    -> ParseResult<InputObjectTypeExtension, TokenStream<'a>>
+{
+    (
+        position(),
+        ident("input").with(name()),
+        parser(directives),
+        parser(input_fields),
+    )
+        .flat_map(|(position, name, directives, fields)| {
+            if directives.is_empty() && fields.is_empty() {
+                let mut e = Errors::empty(position);
+                e.add_error(Error::expected_static_message(
+                    "Input object type extension should contain at least \
+                     one directive or field."));
+                return Err(e);
+            }
+            Ok(InputObjectTypeExtension {
+                position, name, directives, fields,
+            })
+        })
+        .parse_stream(input)
+}
+
 pub fn type_definition<'a>(input: &mut TokenStream<'a>)
     -> ParseResult<TypeDefinition, TokenStream<'a>>
 {
@@ -450,6 +473,7 @@ pub fn type_extension<'a>(input: &mut TokenStream<'a>)
         parser(interface_type_extension).map(TypeExtension::Interface),
         parser(union_type_extension).map(TypeExtension::Union),
         parser(enum_type_extension).map(TypeExtension::Enum),
+        parser(input_object_type_extension).map(TypeExtension::InputObject),
     )))
     .parse_stream(input)
 }

tests/schema_roundtrips.rs

@@ -45,5 +45,6 @@ fn roundtrip2(filename: &str) {
 #[test] fn enum_type() { roundtrip("enum"); }
 #[test] fn extend_enum() { roundtrip("extend_enum"); }
 #[test] fn input_type() { roundtrip("input_type"); }
+#[test] fn extend_input() { roundtrip2("extend_input"); }
 // Not yet fully supported
 //#[test] fn kitchen_sink() { roundtrip2("kitchen-sink"); }

tests/schemas/extend_input.graphql

@@ -0,0 +1,3 @@
+extend input InputType {
+  other: Float = 1.23e4
+}

tests/schemas/extend_input_canonical.graphql

@@ -0,0 +1,3 @@
+extend input InputType {
+  other: Float = 12300
+}