Merge pull request #1304 from cjoudrey/amp-delimited-implements

Separate multiple inherited interfaces with `&`

Author: Robert Mosolgo

lib/graphql/language/lexer.rb

@@ -45,6 +45,7 @@
   EQUALS =        '=';
   BANG =          '!';
   PIPE =          '|';
+  AMP =           '&';
 
   QUOTED_STRING = QUOTE STRING_CHAR* QUOTE;
   BLOCK_STRING = BLOCK_QUOTE BLOCK_STRING_CHAR* BLOCK_QUOTE;
@@ -86,6 +87,7 @@
     EQUALS        => { emit(:EQUALS, ts, te, meta) };
     BANG          => { emit(:BANG, ts, te, meta) };
     PIPE          => { emit(:PIPE, ts, te, meta) };
+    AMP           => { emit(:AMP, ts, te, meta) };
     IDENTIFIER    => { emit(:IDENTIFIER, ts, te, meta) };
     COMMENT       => { record_comment(ts, te, meta) };
 

lib/graphql/language/lexer.rl

@@ -152,10 +152,6 @@ rule
     | operation_type
     | schema_keyword
 
-  name_list:
-      name             { return [make_node(:TypeName, name: val[0])] }
-    | name_list name   { val[0] << make_node(:TypeName, name: val[1]) }
-
   enum_value_definition:
     enum_name directives_list_opt { return make_node(:EnumValueDefinition, name: val[0], directives: val[1], description: get_description(val[0])) }
 
@@ -306,7 +302,17 @@ rule
 
   implements_opt:
       /* none */ { return [] }
-    | IMPLEMENTS name_list { return val[1] }
+    | IMPLEMENTS AMP interfaces_list { return val[2] }
+    | IMPLEMENTS interfaces_list { return val[1] }
+    | IMPLEMENTS legacy_interfaces_list { return val[1] }
+
+  interfaces_list:
+      name                     { return [make_node(:TypeName, name: val[0])] }
+    | interfaces_list AMP name { val[0] << make_node(:TypeName, name: val[2]) }
+
+  legacy_interfaces_list:
+      name                        { return [make_node(:TypeName, name: val[0])] }
+    | legacy_interfaces_list name { val[0] << make_node(:TypeName, name: val[1]) }
 
   input_value_definition:
       name COLON type default_value_opt directives_list_opt {

lib/graphql/language/parser.rb

@@ -154,7 +154,7 @@ def print_scalar_type_definition(scalar_type)
       def print_object_type_definition(object_type)
         out = print_description(object_type)
         out << "type #{object_type.name}"
-        out << " implements " << object_type.interfaces.map(&:name).join(", ") unless object_type.interfaces.empty?
+        out << " implements " << object_type.interfaces.map(&:name).join(" & ") unless object_type.interfaces.empty?
         out << print_directives(object_type.directives)
         out << print_field_definitions(object_type.fields)
       end

lib/graphql/language/parser.y

@@ -44,6 +44,80 @@
     assert_equal schema_string, document.to_query_string
   end
 
+  describe "implements" do
+    it "parses when there are no interfaces" do
+      schema = "
+        type A {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal [], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses with leading ampersand" do
+      schema = "
+        type A implements & B {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses with leading ampersand and multiple interfaces" do
+      schema = "
+        type A implements & B & C {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses without leading ampersand" do
+      schema = "
+        type A implements B {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "parses without leading ampersand and multiple interfaces" do
+      schema = "
+        type A implements B & C {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+    end
+
+    it "supports the old way of parsing multiple interfaces for backwards compatibility" do
+      schema = "
+        type A implements B, C {
+          a: String
+        }
+      "
+
+      document = subject.parse(schema)
+
+      assert_equal ["B", "C"], document.definitions[0].interfaces.map(&:name)
+    end
+  end
+
   describe ".parse_file" do
     it "assigns filename to all nodes" do
       example_filename = "spec/support/parser/filename_example.graphql"

lib/graphql/language/printer.rb

@@ -115,7 +115,7 @@
           # Union description
           union AnnotatedUnion @onUnion = A | B
 
-          type Foo implements Bar {
+          type Foo implements Bar & AnnotatedInterface {
             one: Type
             two(argument: InputType!): Type
             three(argument: InputType, other: String): Int

spec/graphql/language/parser_spec.rb

@@ -515,7 +515,7 @@
           scalar: String!
         }
 
-        type NonNullStringBox1Impl implements SomeBox, NonNullStringBox1 {
+        type NonNullStringBox1Impl implements SomeBox & NonNullStringBox1 {
           scalar: String!
           unrelatedField: String
           deepBox: SomeBox
@@ -525,7 +525,7 @@
           scalar: String!
         }
 
-        type NonNullStringBox2Impl implements SomeBox, NonNullStringBox2 {
+        type NonNullStringBox2Impl implements SomeBox & NonNullStringBox2 {
           scalar: String!
           unrelatedField: String
           deepBox: SomeBox