/// <summary> /// Generate the statements for pem certificate configuration. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns> /// <remarks>> /// X509Certificate2.CreateFromPemFile("cert.pem", "private.pem"); /// </remarks> private static ExpressionSyntax CreatePemCertificateStatements(CurlOptions curlOptions) { var newCertificateArguments = new LinkedList <ArgumentSyntax>(); newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName)); string methodName = null; if (curlOptions.HasCertificatePassword) { newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword)); methodName = "CreateFromEncryptedPemFile"; } else { methodName = "CreateFromPemFile"; } if (curlOptions.HasKey) { newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.KeyFileName)); } var createFromPemInvocationExpression = RoslynExtensions.CreateInvocationExpression(X509Certificate2ClassName, methodName, newCertificateArguments.ToArray()); var pfxTypeExpression = RoslynExtensions.CreateMemberAccessExpression("X509ContentType", "Pfx"); createFromPemInvocationExpression = RoslynExtensions.CreateInvocationExpression(createFromPemInvocationExpression, "Export", SyntaxFactory.Argument(pfxTypeExpression)); return(RoslynExtensions.CreateObjectCreationExpression(X509Certificate2ClassName, SyntaxFactory.Argument(createFromPemInvocationExpression))); }
/// <summary> /// Generates the file read all text expression. /// </summary> /// <param name="fileName">Name of the file.</param> /// <returns> /// <see cref="InvocationExpressionSyntax" /> expression. /// </returns> /// <remarks> /// File.ReadAllText("file name.txt") /// </remarks> private InvocationExpressionSyntax CreateFileReadAllTextExpression(string fileName) { return(RoslynExtensions.CreateInvocationExpression( "File", "ReadAllText", RoslynExtensions.CreateStringLiteralArgument(fileName))); }
/// <summary> /// Generates the header assignment statements. /// </summary> /// <param name="options">The options.</param> /// <returns>Collection of <see cref="StatementSyntax"/></returns> /// <remarks> /// request.Headers.TryAddWithoutValidation("Accept", "application/json"); /// request.Headers.TryAddWithoutValidation("User-Agent", "curl/7.60.0"); /// </remarks> private IEnumerable <StatementSyntax> CreateHeaderAssignmentStatements(CurlOptions options) { if (!options.HasHeaders && !options.HasCookies) { return(Enumerable.Empty <ExpressionStatementSyntax>()); } var statements = new LinkedList <ExpressionStatementSyntax>(); foreach (var header in options.Headers) { if (string.Equals(header.Key, HeaderNames.ContentType, StringComparison.InvariantCultureIgnoreCase)) { continue; } var tryAddHeaderStatement = CreateTryAddHeaderStatement( RoslynExtensions.CreateStringLiteralArgument(header.Key), RoslynExtensions.CreateStringLiteralArgument(header.Value)); statements.AddLast(tryAddHeaderStatement); } if (options.HasCookies) { statements.AddLast( CreateTryAddHeaderStatement( RoslynExtensions.CreateStringLiteralArgument("Cookie"), RoslynExtensions.CreateStringLiteralArgument(options.CookieValue))); } statements.TryAppendWhiteSpaceAtEnd(); return(statements); }
public ExpressionStatementSyntax CreateSetHttpVersionStatement(CurlOptions options) { var arguments = new LinkedList <ArgumentSyntax>(); var majorVersionArgument = options.HttpVersion switch { HttpVersion.Http09 => RoslynExtensions.CreateIntLiteralArgument(0), HttpVersion.Http10 => RoslynExtensions.CreateIntLiteralArgument(1), HttpVersion.Http11 => RoslynExtensions.CreateIntLiteralArgument(1), HttpVersion.Http20 => RoslynExtensions.CreateIntLiteralArgument(2), HttpVersion.Http30 => RoslynExtensions.CreateIntLiteralArgument(3), _ => throw new ArgumentOutOfRangeException() }; arguments.AddLast(majorVersionArgument); var minorVersionArgument = options.HttpVersion switch { HttpVersion.Http09 => RoslynExtensions.CreateIntLiteralArgument(9), HttpVersion.Http11 => RoslynExtensions.CreateIntLiteralArgument(1), _ => RoslynExtensions.CreateIntLiteralArgument(0) }; arguments.AddLast(minorVersionArgument); var versionObjectCreationExpression = RoslynExtensions.CreateObjectCreationExpression("Version", arguments.ToArray()); return(SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateMemberAssignmentExpression( RequestVariableName, "Version", versionObjectCreationExpression))); }
public MethodCollector(string csProjPath, IEnumerable <string> conditinalSymbols) { this.csProjPath = csProjPath; var compilation = RoslynExtensions.GetCompilationFromProject(csProjPath, conditinalSymbols.ToArray()).GetAwaiter().GetResult(); this.typeReferences = new ReferenceSymbols(compilation); var bothInterfaces = compilation.GetNamedTypeSymbols() .Where(x => x.TypeKind == TypeKind.Interface) .Where(x => { var all = x.AllInterfaces; if (all.Any(y => y == typeReferences.IServiceMarker) || all.Any(y => y == typeReferences.IStreamingHubMarker)) { return(true); } return(false); }) .ToArray(); serviceInterfaces = bothInterfaces .Where(x => x.AllInterfaces.Any(y => y == typeReferences.IServiceMarker) && x.AllInterfaces.All(y => y != typeReferences.IStreamingHubMarker)) .Distinct() .ToArray(); hubInterfaces = bothInterfaces .Where(x => x.AllInterfaces.Any(y => y == typeReferences.IStreamingHubMarker)) .Distinct() .ToArray(); }
/// <summary> /// Generate the HttpClient using statements with empty using block. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="UsingStatementSyntax"/>.</returns> /// <remarks> /// using (var httpClient = new HttpClient()) /// { /// } /// </remarks> private UsingStatementSyntax CreateHttpClientUsing(CurlOptions curlOptions) { var argumentSyntax = ShouldGenerateHandler(curlOptions) ? new[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName(HandlerVariableName)) } : new ArgumentSyntax[0]; return(RoslynExtensions.CreateUsingStatement(HttpClientVariableName, nameof(HttpClient), argumentSyntax)); }
public static async Task <MethodCollector> CreateCollector(string csProjPath, IEnumerable <string> conditinalSymbols, string framework, bool quiet) { MSBuildLocator.RegisterDefaults(); var compilation = await RoslynExtensions.GetCompilationFromProject(csProjPath, framework, quiet, conditinalSymbols.ToArray()); return(new MethodCollector(csProjPath, compilation)); }
/// <summary> /// Generates the string content creation expression. /// </summary> /// <param name="contentSyntax">The content syntax.</param> /// <returns> /// <see cref="ObjectCreationExpressionSyntax" /> expression. /// </returns> /// <remarks> /// new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json") /// </remarks> private ObjectCreationExpressionSyntax CreateStringContentCreation(ArgumentSyntax contentSyntax) { var arguments = new LinkedList <ArgumentSyntax>(); arguments.AddLast(contentSyntax); var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray()); return(stringContentCreation); }
private ExpressionStatementSyntax CreateStringContentAssignmentStatement(CurlOptions curlOptions) { var stringContentCreation = CreateStringContentCreation(curlOptions); return(SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateMemberAssignmentExpression( RequestVariableName, "Content", stringContentCreation)) .AppendWhiteSpace()); }
/// <summary> /// Generates the headers adding statement. /// </summary> /// <param name="keyArgumentSyntax">The header key argument syntax.</param> /// <param name="valueArgumentSyntax">The header value argument syntax.</param> /// <returns><see cref="ExpressionStatementSyntax"/> statement.</returns> /// <remarks> /// request.Headers.TryAddWithoutValidation("Accept", "application/json"); /// </remarks> private ExpressionStatementSyntax CreateTryAddHeaderStatement(ArgumentSyntax keyArgumentSyntax, ArgumentSyntax valueArgumentSyntax) { var invocationExpressionSyntax = RoslynExtensions.CreateInvocationExpression( RequestVariableName, "Headers", "TryAddWithoutValidation", keyArgumentSyntax, valueArgumentSyntax); return(SyntaxFactory.ExpressionStatement(invocationExpressionSyntax)); }
/// <summary> /// Generates the basic authorization statements. /// </summary> /// <param name="options">The options.</param> /// <returns>Collection of <see cref="StatementSyntax"/>.</returns> /// <remarks> /// var base64authorization = Convert.ToBase64String(Encoding.ASCII.GetBytes("username:password")); /// request.Headers.TryAddWithoutValidation("Authorization", $"Basic {base64authorization}"); /// </remarks> private StatementSyntax[] CreateBasicAuthorizationStatements(CurlOptions options) { var authorizationEncodingStatement = CreateBasicAuthorizationEncodingStatement(options); var interpolatedStringExpression = RoslynExtensions.CreateInterpolatedStringExpression("Basic ", SyntaxFactory.IdentifierName(Base64AuthorizationVariableName)); var tryAddHeaderStatement = CreateTryAddHeaderStatement( RoslynExtensions.CreateStringLiteralArgument("Authorization"), SyntaxFactory.Argument(interpolatedStringExpression)) .AppendWhiteSpace(); return(new StatementSyntax[] { authorizationEncodingStatement, tryAddHeaderStatement }); }
public AssemblyAttributeCollector(string csProjPath, IEnumerable <string> conditinalSymbols) { this.csProjPath = csProjPath; var compilation = RoslynExtensions.GetCompilationFromProject(csProjPath, conditinalSymbols.ToArray()).GetAwaiter().GetResult(); this.keyTupleMarker = compilation.GetTypeByMetadataName("ZeroFormatter.IKeyTuple"); var marker = compilation.GetTypeByMetadataName(HintAttributeDefinition.FullName); var attributes = compilation.Assembly.GetAttributes(); this.hintAttributes = attributes.Where(x => x.AttributeClass == marker).ToArray(); }
/// <summary> /// Generate the HttpClient using statements with empty using block. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="UsingStatementSyntax"/>.</returns> /// <remarks> /// using (var httpClient = new HttpClient()) /// { /// } /// </remarks> private UsingStatementSyntax CreateHttpClientUsing(CurlOptions curlOptions) { var argumentSyntax = ShouldGenerateHandler(curlOptions) ? new[] { SyntaxFactory.Argument(SyntaxFactory.IdentifierName(HandlerVariableName)) } : new ArgumentSyntax[0]; var usingStatement = RoslynExtensions.CreateUsingStatement(HttpClientVariableName, nameof(HttpClient), argumentSyntax); return(usingStatement .PrependComment("// In production code, don't destroy the HttpClient through using, but better use IHttpClientFactory factory or at least reuse an existing HttpClient instance" + Chars.NewLineString + "// https://docs.microsoft.com/en-us/aspnet/core/fundamentals/http-requests" + Chars.NewLineString + "// https://www.aspnetmonsters.com/2016/08/2016-08-27-httpclientwrong/")); }
private UsingStatementSyntax CreateRequestUsingStatement(CurlOptions curlOptions) { var methodNameArgument = RoslynExtensions.CreateStringLiteralArgument(curlOptions.HttpMethod); var httpMethodArgument = RoslynExtensions.CreateObjectCreationExpression(nameof(HttpMethod), methodNameArgument); var urlArgument = RoslynExtensions.CreateStringLiteralArgument(curlOptions.Url.ToString()); return(RoslynExtensions.CreateUsingStatement( RequestVariableName, nameof(HttpRequestMessage), SyntaxFactory.Argument(httpMethodArgument), urlArgument)); }
/// <summary> /// Generate the statements for sending a HttpRequestMessage. /// </summary> /// <returns><see cref="LocalDeclarationStatementSyntax"/> statement.</returns> /// <remarks> /// var response = await httpClient.SendAsync(request); /// </remarks> private LocalDeclarationStatementSyntax CreateSendStatement() { var invocationExpressionSyntax = RoslynExtensions.CreateInvocationExpression( HttpClientVariableName, "SendAsync", SyntaxFactory.Argument(SyntaxFactory.IdentifierName(RequestVariableName))); var awaitExpression = SyntaxFactory.AwaitExpression(invocationExpressionSyntax); var declarationSyntax = RoslynExtensions.CreateVariableInitializationExpression("response", awaitExpression); return(SyntaxFactory.LocalDeclarationStatement(declarationSyntax)); }
/// <summary> /// Generates the new byte array content expression. /// </summary> /// <param name="fileName">The file name.</param> /// <returns><see cref="ObjectCreationExpressionSyntax"/> expression.</returns> /// <remarks> /// new ByteArrayContent(File.ReadAllBytes("file1.txt")) /// </remarks> private ObjectCreationExpressionSyntax CreateNewByteArrayContentExpression(string fileName) { var fileReadExpression = RoslynExtensions.CreateInvocationExpression( "File", "ReadAllBytes", RoslynExtensions.CreateStringLiteralArgument(fileName)); var byteArrayContentExpression = RoslynExtensions.CreateObjectCreationExpression( "ByteArrayContent", SyntaxFactory.Argument(fileReadExpression)); return(byteArrayContentExpression); }
private IEnumerable <StatementSyntax> CreateBasicAuthorizationStatements(CurlOptions options) { var authorizationEncodingStatement = CreateBasicAuthorizationEncodingStatement(options); var stringStartToken = SyntaxFactory.Token(SyntaxKind.InterpolatedStringStartToken); var interpolatedStringContentSyntaxs = new SyntaxList <InterpolatedStringContentSyntax>() .Add(SyntaxFactory.InterpolatedStringText(SyntaxFactory.Token(SyntaxTriviaList.Empty, SyntaxKind.InterpolatedStringTextToken, "Basic ", null, SyntaxTriviaList.Empty))) .Add(SyntaxFactory.Interpolation(SyntaxFactory.IdentifierName(Base64AuthorizationVariableName))); var interpolatedStringArgument = SyntaxFactory.Argument(SyntaxFactory.InterpolatedStringExpression(stringStartToken, interpolatedStringContentSyntaxs)); var tryAddHeaderStatement = CreateTryAddHeaderStatement(RoslynExtensions.CreateStringLiteralArgument("Authorization"), interpolatedStringArgument) .AppendWhiteSpace(); return(new StatementSyntax[] { authorizationEncodingStatement, tryAddHeaderStatement }); }
private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions) { var statements = new LinkedList <StatementSyntax>(); const string MultipartVariableName = "multipartContent"; const string MultipartAddMethodName = "Add"; statements.AddLast( SyntaxFactory.LocalDeclarationStatement( RoslynExtensions.CreateVariableFromNewObjectExpression( MultipartVariableName, nameof(MultipartContent)))); if (!string.IsNullOrEmpty(curlOptions.Payload)) { var stringContentCreation = CreateStringContentCreation(curlOptions); var addStatement = SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateInvocationExpression( MultipartVariableName, MultipartAddMethodName, SyntaxFactory.Argument(stringContentCreation))); statements.AddLast(addStatement.AppendWhiteSpace()); } foreach (var file in curlOptions.Files) { var fileReadExpression = RoslynExtensions.CreateInvocationExpression( "File", "ReadAllBytes", RoslynExtensions.CreateStringLiteralArgument(file)); var byteArrayContentExpression = RoslynExtensions.CreateObjectCreationExpression( "ByteArrayContent", SyntaxFactory.Argument(fileReadExpression)); var addStatement = SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateInvocationExpression( MultipartVariableName, MultipartAddMethodName, SyntaxFactory.Argument(byteArrayContentExpression))); statements.AddLast(addStatement); } statements.TryAppendWhiteSpaceAtEnd(); return(statements); }
/// <summary> /// Generate the statements for p12 certificate configuration. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns> /// <remarks>> /// new X509Certificate2("certificate.crt", "password") /// </remarks> private static ExpressionSyntax CreateP12CertificateStatements(CurlOptions curlOptions) { var newCertificateArguments = new LinkedList <ArgumentSyntax>(); newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificateFileName)); if (curlOptions.HasCertificatePassword) { newCertificateArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.CertificatePassword)); } var newCertificateExpression = RoslynExtensions.CreateObjectCreationExpression( X509Certificate2ClassName, newCertificateArguments.ToArray()); return(newCertificateExpression); }
/// <summary> /// Generates the multipart content statements. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="StatementSyntax"/>.</returns> /// <remarks> /// var multipartContent = new MultipartContent(); /// multipartContent.Add(new StringContent("test", Encoding.UTF8, "application/x-www-form-urlencoded")); /// multipartContent.Add(new ByteArrayContent(File.ReadAllBytes("file1.txt"))); /// request.Content = multipartContent; /// </remarks> private IEnumerable <StatementSyntax> CreateMultipartContentStatements(CurlOptions curlOptions) { var statements = new LinkedList <StatementSyntax>(); const string MultipartVariableName = "multipartContent"; const string MultipartAddMethodName = "Add"; statements.AddLast( SyntaxFactory.LocalDeclarationStatement( RoslynExtensions.CreateVariableFromNewObjectExpression( MultipartVariableName, nameof(MultipartContent)))); if (!string.IsNullOrEmpty(curlOptions.Payload)) { var stringContentCreation = CreateStringContentCreation(curlOptions); var addStatement = SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateInvocationExpression( MultipartVariableName, MultipartAddMethodName, SyntaxFactory.Argument(stringContentCreation))); statements.AddLast(addStatement.AppendWhiteSpace()); } foreach (var file in curlOptions.DataFiles) { var byteArrayContentExpression = CreateNewByteArrayContentExpression(file); var addStatement = SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateInvocationExpression( MultipartVariableName, MultipartAddMethodName, SyntaxFactory.Argument(byteArrayContentExpression))); statements.AddLast(addStatement); } statements.AddLast(SyntaxFactory.ExpressionStatement( RoslynExtensions.CreateMemberAssignmentExpression( RequestVariableName, RequestContentPropertyName, SyntaxFactory.IdentifierName(MultipartVariableName)))); statements.TryAppendWhiteSpaceAtEnd(); return(statements); }
/// <summary> /// Generate the statements for HttpClient handler configuration. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <param name="result">The result.</param> /// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns> /// <remarks> /// var handler = new HttpClientHandler(); /// handler.UseCookies = false; /// </remarks> private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements( CurlOptions curlOptions, ConvertResult <string> result) { var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>(); var handlerInitialization = RoslynExtensions.CreateVariableFromNewObjectExpression( HandlerVariableName, nameof(HttpClientHandler)); statementSyntaxs.AddLast( SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization))); if (curlOptions.HasCookies) { var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression( HandlerVariableName, "UseCookies", SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)); statementSyntaxs.AddLast( SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression))); } if (curlOptions.HasProxy) { if (IsSupportedProxy(curlOptions.ProxyUri)) { var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression( HandlerVariableName, "Proxy", RoslynExtensions.CreateObjectCreationExpression("WebProxy", RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString()))); statementSyntaxs.AddLast( SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression))); } else { result.Warnings.Add($"Proxy scheme \"{curlOptions.ProxyUri.Scheme}\" is not supported"); } } statementSyntaxs.TryAppendWhiteSpaceAtEnd(); return(statementSyntaxs); }
private ObjectCreationExpressionSyntax CreateStringContentCreation(CurlOptions curlOptions) { var arguments = new LinkedList <ArgumentSyntax>(); arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.Payload)); var contentHeader = curlOptions.Headers.GetCommaSeparatedValues(HeaderNames.ContentType); if (contentHeader.Any()) { arguments.AddLast(SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("Encoding", "UTF8"))); arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(contentHeader.First())); } var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray()); return(stringContentCreation); }
/// <summary> /// Generates the string content creation expression. /// </summary> /// <param name="contentSyntax">The content syntax.</param> /// <param name="curlOptions">The curl options.</param> /// <returns> /// <see cref="ObjectCreationExpressionSyntax" /> expression. /// </returns> /// <remarks> /// new StringContent("{\"status\": \"resolved\"}", Encoding.UTF8, "application/json") /// </remarks> private ObjectCreationExpressionSyntax CreateStringContentCreation(ArgumentSyntax contentSyntax, CurlOptions curlOptions) { var arguments = new LinkedList <ArgumentSyntax>(); arguments.AddLast(contentSyntax); var contentHeader = curlOptions.Headers.GetCommaSeparatedValues(HeaderNames.ContentType).FirstOrDefault(); if (!string.IsNullOrEmpty(contentHeader)) { var contentTypeValues = contentHeader.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); arguments.AddLast(SyntaxFactory.Argument(RoslynExtensions.CreateMemberAccessExpression("Encoding", "UTF8"))); arguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(contentTypeValues[0].Trim())); } var stringContentCreation = RoslynExtensions.CreateObjectCreationExpression("StringContent", arguments.ToArray()); return(stringContentCreation); }
/// <summary> /// Generates the basic authorization encoding statement. /// </summary> /// <param name="options">The options.</param> /// <returns><see cref="LocalDeclarationStatementSyntax"/> statement.</returns> /// <remarks> /// var base64authorization = Convert.ToBase64String(Encoding.ASCII.GetBytes("username:password")); /// </remarks> private LocalDeclarationStatementSyntax CreateBasicAuthorizationEncodingStatement(CurlOptions options) { var asciiGetBytesInvocation = RoslynExtensions.CreateInvocationExpression( "Encoding", "ASCII", "GetBytes", RoslynExtensions.CreateStringLiteralArgument(options.UserPasswordPair)); var convertToBase64Invocation = RoslynExtensions.CreateInvocationExpression( "Convert", "ToBase64String", SyntaxFactory.Argument(asciiGetBytesInvocation)); var declarationSyntax = RoslynExtensions.CreateVariableInitializationExpression( Base64AuthorizationVariableName, convertToBase64Invocation); return(SyntaxFactory.LocalDeclarationStatement(declarationSyntax)); }
private async Task <Document> Initialize(Document document, FieldDeclarationSyntax localDeclaration, CancellationToken cancellationToken) { var tree = await document.GetSyntaxTreeAsync(cancellationToken); var root = tree.GetRoot(cancellationToken); var constructors = root.DescendantNodes().OfType <ConstructorDeclarationSyntax>().ToList(); var csor = constructors.FirstOrDefault(); SyntaxNode visitingRoot = root; if (csor == null) { var oldClass = localDeclaration.FirstAncestorOrSelf <ClassDeclarationSyntax>(); var className = oldClass.Identifier.ToString(); var paramList = RoslynExtensions.GenerateParameters(new[] { localDeclaration.Declaration.Type }); var newCtor = SyntaxFactory.ConstructorDeclaration( attributeLists: SyntaxFactory.List(new AttributeListSyntax[] { }), modifiers: SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)), identifier: oldClass.Identifier, parameterList: paramList, initializer: null, body: SyntaxFactory.Block(new[] { RoslynExtensions.GenerateCtorStatement(RoslynExtensions.GetFieldName(localDeclaration), RoslynExtensions.GetFieldVariableName(localDeclaration.Declaration.Type)) }), semicolonToken: default(SyntaxToken) ); csor = newCtor; visitingRoot = root.InsertNodesAfter(localDeclaration, new[] { newCtor }); } var cr = new ConstructorRewriter(csor, localDeclaration); var newRoot = cr.Visit(visitingRoot).WithAdditionalAnnotations(Formatter.Annotation); //var workspace = MSBuildWorkspace.Create(); //var formatted = Formatter.Format(newRoot, workspace); return(document.WithSyntaxRoot(newRoot)); }
/// <summary> /// Generate the statements for WebProxy object configuration. /// </summary> /// <param name="curlOptions">The curl options.</param> /// <returns>Collection of <see cref="MemberDeclarationSyntax" />.</returns> /// <remarks> /// handler.Proxy = new WebProxy("http://localhost:1080/") { UseDefaultCredentials = true } /// </remarks> private AssignmentExpressionSyntax CreateProxyStatements(CurlOptions curlOptions) { InitializerExpressionSyntax initializer = null; if (curlOptions.UseDefaultProxyCredentials) { var defaultCredentialsAssignment = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName("UseDefaultCredentials"), SyntaxFactory.LiteralExpression( SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword))); var syntaxList = new SeparatedSyntaxList <ExpressionSyntax>(); syntaxList = syntaxList.Add(defaultCredentialsAssignment); initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, syntaxList); } if (curlOptions.HasProxyUserName) { var proxyCredentialsArguments = new LinkedList <ArgumentSyntax>(); proxyCredentialsArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUserName)); proxyCredentialsArguments.AddLast(RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyPassword)); var defaultCredentialsAssignment = SyntaxFactory.AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, SyntaxFactory.IdentifierName("Credentials"), RoslynExtensions.CreateObjectCreationExpression("NetworkCredential", proxyCredentialsArguments.ToArray())); var syntaxList = new SeparatedSyntaxList <ExpressionSyntax>().Add(defaultCredentialsAssignment); initializer = SyntaxFactory.InitializerExpression(SyntaxKind.ObjectInitializerExpression, syntaxList); } var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression( HandlerVariableName, "Proxy", RoslynExtensions.CreateObjectCreationExpression( "WebProxy", initializer, RoslynExtensions.CreateStringLiteralArgument(curlOptions.ProxyUri.ToString()))); return(memberAssignmentExpression); }
public override SyntaxNode VisitConstructorDeclaration(ConstructorDeclarationSyntax constructorDeclaration) { if (constructor == constructorDeclaration) { var type = field.Declaration.Type; var variable = RoslynExtensions.GetFieldName(field); string parameter = variable; if (variable.StartsWith("_")) { parameter = variable.Substring(1); } else { variable = "this." + variable; } //var typeString = type.ToString(); //if (typeString.StartsWith("I")) //name = typeString.Substring(1); //name = Char.ToLowerInvariant(name[0]) + name.Substring(1); var p = SyntaxFactory.Parameter( new SyntaxList <AttributeListSyntax>(), new SyntaxTokenList(), type, SyntaxFactory.Identifier(parameter), null); var parameters = constructorDeclaration.ParameterList.AddParameters(p); var body = constructorDeclaration.Body; var statement = SyntaxFactory.ParseStatement(variable + " = " + parameter + ";" + Environment.NewLine);//.WithLeadingTrivia(SyntaxFactory.Tab, SyntaxFactory.Tab); body = body.AddStatements(statement); return(constructorDeclaration.WithParameterList(parameters).WithBody(body)); //(BlockSyntax)formatted); } return(base.VisitConstructorDeclaration(constructorDeclaration)); }
private static IEnumerable <MemberDeclarationSyntax> CreateCertificateStatement(CurlOptions curlOptions) { var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>(); var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression( HandlerVariableName, "ClientCertificateOptions", RoslynExtensions.CreateMemberAccessExpression("ClientCertificateOption", "Manual")); statementSyntaxs.AddLast( SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression))); var certificateCreationStatement = curlOptions.CertificateType switch { CertificateType.P12 => CreateP12CertificateStatements(curlOptions), CertificateType.Pem => CreatePemCertificateStatements(curlOptions), _ => throw new ArgumentOutOfRangeException(nameof(curlOptions.CertificateType), $"Unsupported certificate type {curlOptions.CertificateType}") }; var certificateAssignmentExpression = RoslynExtensions.CreateInvocationExpression( HandlerVariableName, "ClientCertificates", "Add", SyntaxFactory.Argument(certificateCreationStatement)); if (curlOptions.CertificateType == CertificateType.Pem) { certificateAssignmentExpression = certificateAssignmentExpression .PrependComment( Chars.NewLineString + "// PEM certificates support requires .NET 5 and higher" + Chars.NewLineString + "// Export to PFX is needed because of this bug https://github.com/dotnet/runtime/issues/23749#issuecomment-747407051" ); } statementSyntaxs.AddLast(SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(certificateAssignmentExpression))); return(statementSyntaxs); }
public MethodCollector(string csProjPath, IEnumerable <string> conditinalSymbols) { this.csProjPath = csProjPath; var compilation = RoslynExtensions.GetCompilationFromProject(csProjPath, conditinalSymbols.ToArray()).GetAwaiter().GetResult(); this.typeReferences = new ReferenceSymbols(compilation); var marker = compilation.GetTypeByMetadataName("MagicOnion.IServiceMarker"); baseInterface = compilation.GetTypeByMetadataName("MagicOnion.IService`1"); serviceTypes = compilation.GetNamedTypeSymbols() .Where(t => t.AllInterfaces.Any(x => x == marker)) .ToArray(); interfaces = serviceTypes .Concat(serviceTypes.SelectMany(x => x.AllInterfaces)) .Distinct() .Where(x => x != marker) .Where(t => t != baseInterface) .Where(x => !x.IsGenericType || x.ConstructedFrom != baseInterface) .ToArray(); }
private IEnumerable <MemberDeclarationSyntax> ConfigureHandlerStatements(CurlOptions curlOptions) { var statementSyntaxs = new LinkedList <MemberDeclarationSyntax>(); var handlerInitialization = RoslynExtensions.CreateVariableInitializationExpression( HandlerVariableName, RoslynExtensions.CreateObjectCreationExpression(nameof(HttpClientHandler))); statementSyntaxs.AddLast( SyntaxFactory.GlobalStatement(SyntaxFactory.LocalDeclarationStatement(handlerInitialization))); if (curlOptions.HasCookies) { var memberAssignmentExpression = RoslynExtensions.CreateMemberAssignmentExpression( HandlerVariableName, "UseCookies", SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)); statementSyntaxs.AddLast( SyntaxFactory.GlobalStatement(SyntaxFactory.ExpressionStatement(memberAssignmentExpression)) .AppendWhiteSpace()); } return(statementSyntaxs); }