/// <summary>
/// Parses an interface type definition.
/// <see cref="InterfaceTypeDefinition" />:
/// Description? interface Name Directives[isConstant=true]?
/// FieldsDefinition?
/// </summary>
/// <param name="context">The parser context.</param>
private InterfaceTypeDefinitionNode ParseInterfaceTypeDefinition()
{
TokenInfo start = Start();
MoveNext();
NameNode name = ParseName();
List <DirectiveNode> directives =
ParseDirectives(true);
List <FieldDefinitionNode> fields =
ParseFieldsDefinition();
Location?location = CreateLocation(in start);
return(new InterfaceTypeDefinitionNode
(
location,
name,
TakeDescription(),
directives,
fields
));
}
public void EnumTypeDefinitionWithoutDirectives_ArgumentNullException()
{
// arrange
var source = new Source("foo");
var start = new SyntaxToken(
TokenKind.StartOfFile, 0, 0, 1, 1, null);
var location = new Location(source, start, start);
var name = new NameNode("foo");
var description = new StringValueNode("bar");
var values = new List <EnumValueDefinitionNode>();
// act
Action a = () => new EnumTypeDefinitionNode(
location,
name,
description,
null,
values);
// assert
Assert.Throws <ArgumentNullException>(a);
}
private static InputObjectTypeDefinitionNode ParseInputObjectTypeDefinition(
ParserContext context)
{
SyntaxToken start = context.Current;
StringValueNode description = ParseDescription(context);
context.ExpectInputKeyword();
NameNode name = ParseName(context);
List <DirectiveNode> directives =
ParseDirectives(context, true);
List <InputValueDefinitionNode> fields =
ParseInputFieldsDefinition(context);
Location location = context.CreateLocation(start);
return(new InputObjectTypeDefinitionNode
(
location,
name,
description,
directives,
fields
));
}
/// <summary>
/// Parses an enum type definition.
/// <see cref="EnumTypeDefinitionNode" />:
/// Description? enum Name Directives[Const]? EnumValuesDefinition?
/// </summary>
/// <param name="context">The parser context.</param>
private static EnumTypeDefinitionNode ParseEnumTypeDefinition(
ParserContext context)
{
SyntaxToken start = context.Current;
StringValueNode description = ParseDescription(context);
context.ExpectEnumKeyword();
NameNode name = ParseName(context);
List <DirectiveNode> directives =
ParseDirectives(context, true);
List <EnumValueDefinitionNode> values =
ParseEnumValuesDefinition(context);
Location location = context.CreateLocation(start);
return(new EnumTypeDefinitionNode
(
location,
name,
description,
directives,
values
));
}
/// <summary>
/// Parses an union type definition.
/// <see cref="UnionTypeDefinitionNode" />:
/// Description? union Name Directives[isConstant=true]?
/// UnionMemberTypes?
/// </summary>
/// <param name="context">The parser context.</param>
private static UnionTypeDefinitionNode ParseUnionTypeDefinition(
ParserContext context)
{
SyntaxToken start = context.Current;
StringValueNode description = ParseDescription(context);
context.ExpectUnionKeyword();
NameNode name = ParseName(context);
List <DirectiveNode> directives =
ParseDirectives(context, true);
List <NamedTypeNode> types =
ParseUnionMemberTypes(context);
Location location = context.CreateLocation(start);
return(new UnionTypeDefinitionNode
(
location,
name,
description,
directives,
types
));
}
public void CreateDirectiveDefinition()
{
// arrange
var name = new NameNode("foo");
var description = new StringValueNode("bar");
var arguments = new List <InputValueDefinitionNode>();
var locations = new List <NameNode>();
// act
var directiveDefinition = new DirectiveDefinitionNode(
null, name, description, true,
arguments, locations);
// assert
Assert.Equal(NodeKind.DirectiveDefinition,
directiveDefinition.Kind);
Assert.Null(directiveDefinition.Location);
Assert.Equal(name, directiveDefinition.Name);
Assert.Equal(description, directiveDefinition.Description);
Assert.Equal(arguments, directiveDefinition.Arguments);
Assert.Equal(locations, directiveDefinition.Locations);
Assert.True(directiveDefinition.IsRepeatable);
Assert.False(directiveDefinition.IsUnique);
}
public void EnumTypeDefinitionWithoutLocation()
{
// arrange
var name = new NameNode("foo");
var description = new StringValueNode("bar");
var directives = new List <DirectiveNode>();
var values = new List <EnumValueDefinitionNode>();
// act
var type = new EnumTypeDefinitionNode(
null,
name,
description,
directives,
values);
// assert
Assert.Equal(NodeKind.EnumTypeDefinition, type.Kind);
Assert.Null(type.Location);
Assert.Equal(name, type.Name);
Assert.Equal(description, type.Description);
Assert.Equal(directives, type.Directives);
Assert.Equal(values, type.Values);
}
private ScalarTypeExtensionNode ParseScalarTypeExtension(
ParserContext context)
{
SyntaxToken start = context.Current;
context.ExpectExtendKeyword();
context.ExpectScalarKeyword();
NameNode name = context.ParseName();
List <DirectiveNode> directives =
ParseDirectives(context, true);
if (directives.Count == 0)
{
throw context.Unexpected(start);
}
Location location = context.CreateLocation(start);
return(new ScalarTypeExtensionNode
(
location,
name,
directives
));
}
/// <summary>
/// Parses an object type definition.
/// <see cref="ObjectTypeDefinitionNode" />:
/// Description?
/// type Name ImplementsInterfaces? Directives[isConstant=true]? FieldsDefinition?
/// </summary>
/// <param name="context">The parser context.</param>
private ObjectTypeDefinitionNode ParseObjectTypeDefinition()
{
TokenInfo start = Start();
// skip type keyword
MoveNext();
NameNode name = ParseName();
List <NamedTypeNode> interfaces = ParseImplementsInterfaces();
List <DirectiveNode> directives = ParseDirectives(true);
List <FieldDefinitionNode> fields = ParseFieldsDefinition();
Location location = CreateLocation(in start);
return(new ObjectTypeDefinitionNode
(
location,
name,
TakeDescription(),
directives,
interfaces,
fields
));
}
public FragmentSpreadNode WithName(NameNode name)
{
return(new FragmentSpreadNode(Location, name, Directives));
}
public VariableNode(
NameNode name)
: this(null, name)
{
}
public InterfaceTypeDefinitionNode WithName(NameNode name)
{
return(new InterfaceTypeDefinitionNode(
Location, name, Description,
Directives, Fields));
}
public ArgumentNode WithName(NameNode name)
{
return(new ArgumentNode(Location, name, Value));
}
public ScalarTypeDefinitionNode WithName(NameNode name)
{
return(new ScalarTypeDefinitionNode(
Location, name, Description,
Directives));
}
public InterfaceTypeExtensionNode WithName(NameNode name)
{
return(new InterfaceTypeExtensionNode(
Location, name, Directives, Fields));
}
public EnumValueDefinitionNode WithName(NameNode name)
{
return(new EnumValueDefinitionNode(
Location, name, Description, Directives));
}
public InputValueDefinitionNode WithName(NameNode name)
{
return(new InputValueDefinitionNode(
Location, name, Description,
Type, DefaultValue, Directives));
}
public NamedTypeNode WithName(NameNode name)
{
return(new NamedTypeNode(Location, name));
}
public NamedTypeNode(Location?location, NameNode name)
{
Location = location;
Name = name ?? throw new ArgumentNullException(nameof(name));
}
public NamedTypeNode(NameNode name)
: this(null, name)
{
}
public DirectiveNode(
NameNode name,
IReadOnlyCollection <ArgumentNode> arguments)
: this(null, name, arguments)
{
}
protected override void VisitName(NameNode node)
{
_writer.Write(node.Value);
}
public DirectiveNode WithName(NameNode name)
{
return(new DirectiveNode(Location, name, Arguments));
}
public EnumTypeExtensionNode WithName(NameNode name)
{
return(new EnumTypeExtensionNode(
Location, name,
Directives, Values));
}
public ArgumentNode(
NameNode name,
IValueNode value)
: this(null, name, value)
{
}
public ArgumentNode(Location?location, NameNode name, IValueNode value)
{
Location = location;
Name = name ?? throw new ArgumentNullException(nameof(name));
Value = value ?? throw new ArgumentNullException(nameof(value));
}
protected virtual NameNode RewriteName(
NameNode node,
TContext context)
{
return(node);
}
public FieldNode WithName(NameNode name)
{
return(new FieldNode(Location, name, Alias,
Directives, Arguments, SelectionSet));
}
public ObjectFieldNode WithName(NameNode name)
{
return(new ObjectFieldNode(Location, name, Value));
}
public UnionTypeExtensionNode WithName(NameNode name)
{
return(new UnionTypeExtensionNode(
Location, name, Directives, Types));
}
