internal static Directive FromDescription( DirectiveType directiveType, DirectiveDefinition definition, object source) { if (directiveType == null) { throw new ArgumentNullException(nameof(directiveType)); } if (definition == null) { throw new ArgumentNullException(nameof(definition)); } if (source == null) { throw new ArgumentNullException(nameof(source)); } if (definition.CustomDirective is null) { return(new Directive(directiveType, definition.ParsedDirective, source)); } else { return(new Directive(directiveType, definition.CustomDirective, source)); } }
private void VisitDirectiveDefinition(DirectiveDefinition node) { EnterNode(node); Visit(node.Arguments); ExitNode(node); }
public void FromString() { /* Given */ /* When */ DirectiveDefinition original = "directive @a(x: Int, y: Float) on FIELD"; /* Then */ Assert.Equal("a", original.Name); }
public void FromBytes() { /* Given */ /* When */ DirectiveDefinition original = Encoding.UTF8.GetBytes("directive @a(x: Int, y: Float) on FIELD") .AsReadOnlySpan(); /* Then */ Assert.Equal("a", original.Name); }
public void WithName() { /* Given */ DirectiveDefinition original = @"directive @a on SCHEMA"; /* When */ var modified = original .WithName("b"); /* Then */ Assert.Equal("a", original.Name); Assert.Equal("b", modified.Name); }
public void WithDescription() { /* Given */ DirectiveDefinition original = @"directive @a on SCHEMA"; /* When */ var modified = original .WithDescription("Description"); /* Then */ Assert.Null(original.Description); Assert.Equal("Description", modified.Description); }
public static bool TryGetArgument( this DirectiveDefinition definition, Name argumentName, [NotNullWhen(true)] out InputValueDefinition?argument) { if (definition.Arguments is null) { argument = null; return(false); } return(definition.Arguments.TryGet(argumentName, out argument)); }
protected override void EnterDirectiveDefinition(PrinterContext context, DirectiveDefinition directiveDefinition) { context.Append(' '); context.AppendDescription(directiveDefinition.Description); context.Append("directive"); context.Append(' '); context.Append($"@{directiveDefinition.Name}"); if (directiveDefinition.IsRepeatable) { context.Append(' '); context.Append("repeatable"); } }
public void WithArguments() { /* Given */ DirectiveDefinition original = @"directive @a on SCHEMA"; /* When */ var modified = original .WithArguments(new InputValueDefinition[] { "x: Int" }); /* Then */ Assert.Equal(1, modified.Arguments?.Count); }
private bool TryCompleteDirective( ICompletionContext context, DirectiveDefinition definition, ISet <string> processed, out Directive directive) { DirectiveType directiveType = context.GetDirectiveType(definition.Reference); directive = null; if (directiveType != null) { if (!processed.Add(directiveType.Name) && !directiveType.IsRepeatable) { context.ReportError(SchemaErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeResources.DirectiveCollection_DirectiveIsUnique, directiveType.Name)) .SetCode(ErrorCodes.Schema.MissingType) .SetTypeSystemObject(context.Type) .AddSyntaxNode(definition.ParsedDirective) .SetExtension("Source", _source) .Build()); } else if (directiveType.Locations.Contains(_location)) { directive = Directive.FromDescription(directiveType, definition, _source); } else { context.ReportError(SchemaErrorBuilder.New() .SetMessage(string.Format( CultureInfo.InvariantCulture, TypeResources.DirectiveCollection_LocationNotAllowed, directiveType.Name, _location)) .SetCode(ErrorCodes.Schema.MissingType) .SetTypeSystemObject(context.Type) .AddSyntaxNode(definition.ParsedDirective) .SetExtension("Source", _source) .Build()); } } return(directive != null); }
public void WithDirectiveLocations() { /* Given */ DirectiveDefinition original = @"directive @a on SCHEMA"; /* When */ var modified = original .WithDirectiveLocations(new[] { "FIELD" }); /* Then */ var location = Assert.Single(modified.DirectiveLocations); Assert.Equal("FIELD", location); }
protected override void ExitDirectiveDefinition(PrinterContext context, DirectiveDefinition directiveDefinition) { context.Append(" on"); context.Append(' '); var locations = directiveDefinition.DirectiveLocations; for (var i = 0; i < locations.Count; i++) { var location = locations[i]; context.Append(location); if (i != locations.Count - 1 && location.Length > 1) { context.Append(" | "); } } }
private void CompleteDirective( ICompletionContext context, DirectiveDefinition definition, ISet <string> processed) { DirectiveType directiveType = context.GetDirectiveType(definition.Reference); if (directiveType != null) { if (!processed.Add(directiveType.Name) && !directiveType.IsRepeatable) { // TODO : resources context.ReportError(SchemaErrorBuilder.New() .SetMessage( $"The specified directive `@{directiveType.Name}` " + "is unique and cannot be added twice.") .SetCode(TypeErrorCodes.MissingType) .SetTypeSystemObject(context.Type) .AddSyntaxNode(definition.ParsedDirective) .Build()); } else if (directiveType.Locations.Contains(_location)) { _directives.Add(Directive.FromDescription( directiveType, definition, _source)); } else { // TODO : resources context.ReportError(SchemaErrorBuilder.New() .SetMessage( $"The specified directive `@{directiveType.Name}` " + "is not allowed on the current location " + $"`{_location}`.") .SetCode(TypeErrorCodes.MissingType) .SetTypeSystemObject(context.Type) .AddSyntaxNode(definition.ParsedDirective) .Build()); } } }
protected DirectiveType DirectiveType(DirectiveDefinition definition) { var locations = definition .DirectiveLocations .Select(location => (DirectiveLocation)System.Enum.Parse(typeof(DirectiveLocation), location)) .ToList(); var args = Args(definition.Arguments).ToList(); _builder.DirectiveType( definition.Name, out var directiveType, locations, null, argsBuilder => args.ForEach(a => argsBuilder.Arg(a.Name, a.Type, a.DefaultValue, a.Description))); return(directiveType); }
private bool TryCompleteDirective( ITypeCompletionContext context, DirectiveDefinition definition, ISet <string> processed, [NotNullWhen(true)] out Directive?directive) { if (!context.TryGetDirectiveType( definition.Reference, out DirectiveType? directiveType)) { directive = null; return(false); } if (!processed.Add(directiveType.Name) && !directiveType.IsRepeatable) { context.ReportError( DirectiveCollection_DirectiveIsUnique( directiveType, context.Type, definition.ParsedDirective, _source)); directive = null; return(false); } if (directiveType.Locations.Contains(_location)) { directive = Directive.FromDescription(directiveType, definition, _source); return(true); } context.ReportError( DirectiveCollection_LocationNotAllowed( directiveType, _location, context.Type, definition.ParsedDirective, _source)); directive = null; return(false); }
private void AddDeprecatedDirective(string reason) { if (_deprecatedDirective != null) { Definition.Directives.Remove(_deprecatedDirective); } _deprecatedDirective = new DirectiveDefinition( new DeprecatedDirective(reason), Context.TypeInspector.GetTypeRef(typeof(DeprecatedDirective))); Definition.Directives.Add(_deprecatedDirective); if (!_deprecatedDependencySet) { Definition.Dependencies.Add(new TypeDependency( Context.TypeInspector.GetTypeRef(typeof(DeprecatedDirectiveType)), TypeDependencyKind.Completed)); _deprecatedDependencySet = true; } }
private string PrintDirectiveDefinition(DirectiveDefinition node) { var name = PrintName(node.Name); var args = node.Arguments?.Select(Print); var locations = node.DirectiveLocations; return(Join(new[] { "directive @", name, args.All(e => !e.Contains(Environment.NewLine)) ? Wrap("(", Join(args, ", "), ")") : Wrap( $"({Environment.NewLine}", Indent(Join(args, Environment.NewLine)), $"{Environment.NewLine})"), " on ", Join(locations, " | ") })); }
private void AddDeprectedDirective(string reason) { if (_deprecatedDirective != null) { Definition.Directives.Remove(_deprecatedDirective); } _deprecatedDirective = new DirectiveDefinition( new DeprecatedDirective(reason)); Definition.Directives.Add(_deprecatedDirective); if (!_deprecatedDependecySet) { Definition.Dependencies.Add(new TypeDependency( new ClrTypeReference( typeof(DeprecatedDirectiveType), TypeContext.None), TypeDependencyKind.Completed)); _deprecatedDependecySet = true; } }
public static Directive FromDescription( DirectiveType directiveType, DirectiveDefinition definition, object source) { if (directiveType is null) { throw new ArgumentNullException(nameof(directiveType)); } if (definition is null) { throw new ArgumentNullException(nameof(definition)); } if (source is null) { throw new ArgumentNullException(nameof(source)); } if (definition.CustomDirective is null) { return(new Directive( directiveType, CompleteArguments(directiveType, definition.ParsedDirective), null, source)); } else { DirectiveNode directiveNode = ParseValue( directiveType, definition.CustomDirective); return(new Directive( directiveType, CompleteArguments(directiveType, directiveNode), definition.CustomDirective, source)); } }
public DirectiveContext(DirectiveDefinition directive, GraphQLGenerationOptions options, Document document) { this.directive = directive; this.options = options; this.document = document; }
public static DirectiveDefinition WithDescription(this DirectiveDefinition definition, in StringValue?description)
protected virtual void ExitDirectiveDefinition(TContext context, DirectiveDefinition directiveDefinition) { }