15303850882

Committed 28 May 2025 03:11PM UTC coverage: 78.364% (+21.0%) from 57.326%

Build # 15303850882

Build Type

push

github

Committed by

leonov-anton

Commit Message

Merge branch 'main' of https://github.com/leonov-anton/QueryUrlParams

Coverage Stats

110 of 182 branches covered (60.44%)

Branch coverage included in aggregate %.

647 of 784 relevant lines covered (82.53%)

7.95 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.6

/src/QueryUrlParamsGenerator/SourceGenerators/PropertyHandlers/PropertyStringBuilderHandlers.cs

﻿using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using QueryUrlParamsGenerator.Models;
using QueryUrlParamsGenerator.SourceGenerators.PropertyHandlers.Base;
using System;
using System.Linq;

namespace QueryUrlParamsGenerator.SourceGenerators.PropertyHandlers
{
    internal class InnerUrlParametersDtoPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        private const string queryParameterClassAttributeName = "GenerateQueryUrlAttribute";

        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.GetAttributes().Any(a => a.AttributeClass?.Name == queryParameterClassAttributeName);

        public override StatementSyntax[] GetStatements(PropertyInfo prop)
        {
            var classSymbol = (INamedTypeSymbol)prop.Type;

            var namespaceSymbol = classSymbol.ContainingNamespace;
            var namespaceName = namespaceSymbol?.IsGlobalNamespace == true
                ? string.Empty
                : namespaceSymbol?.ToString() ?? "Generated";

            return
            [
                SyntaxFactory.IfStatement(
                    SyntaxFactory.BinaryExpression(
                        SyntaxKind.GreaterThanExpression,
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.IdentifierName("sb"),
                            SyntaxFactory.IdentifierName("Length")
                        ),
                        SyntaxFactory.LiteralExpression(
                            SyntaxKind.NumericLiteralExpression,
                            SyntaxFactory.Literal(0)
                        )),
                    SyntaxFactory.ExpressionStatement(
                        SyntaxFactory.InvocationExpression(
                            SyntaxFactory.MemberAccessExpression(
                                SyntaxKind.SimpleMemberAccessExpression,
                                SyntaxFactory.IdentifierName("sb"),
                                SyntaxFactory.IdentifierName("Append")
                            ),
                            SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
                                SyntaxFactory.Argument(
                                    SyntaxFactory.LiteralExpression(
                                        SyntaxKind.StringLiteralExpression,
                                        SyntaxFactory.Literal("&")
                                    ))))))
                    ),

                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.IdentifierName("sb"),
                            SyntaxFactory.IdentifierName("Append")
                        ),
                        SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
                            SyntaxFactory.Argument(
                                SyntaxFactory.InvocationExpression(
                                    SyntaxFactory.MemberAccessExpression(
                                        SyntaxKind.SimpleMemberAccessExpression,
                                        SyntaxFactory.ParseName($"global::{namespaceName}.{classSymbol.Name}Extensions"),
                                        SyntaxFactory.IdentifierName("GetObjectUrlParams")
                                    ),
                                    SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(
                                        SyntaxFactory.Argument(
                                            SyntaxFactory.MemberAccessExpression(
                                                SyntaxKind.SimpleMemberAccessExpression,
                                                SyntaxFactory.IdentifierName("obj"),
                                                SyntaxFactory.IdentifierName(prop.OriginalName)
                                            )))))))))
                )
            ];
        }
    }

    internal class DictionaryPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.MetadataName == "Dictionary`2";

        public override StatementSyntax[] GetStatements(PropertyInfo prop) =>
            [
                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.ParseName(queryParamBuilderNamespase),
                            SyntaxFactory.IdentifierName("AppendParams")),
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList<ArgumentSyntax>(
                                new SyntaxNodeOrToken[] {
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.IdentifierName("sb")),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                                            SyntaxFactory.Literal(prop.Name))),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.MemberAccessExpression(
                                            SyntaxKind.SimpleMemberAccessExpression,
                                            SyntaxFactory.IdentifierName("obj"),
                                            SyntaxFactory.IdentifierName(prop.OriginalName)))
                                }))))
            ];
    }

    internal class EnumerablePropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.AllInterfaces.Any(i =>
                i.OriginalDefinition.SpecialType == SpecialType.System_Collections_IEnumerable
                && prop.Type.SpecialType != SpecialType.System_String);

        public override StatementSyntax[] GetStatements(PropertyInfo prop) =>
            [
                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.ParseName(queryParamBuilderNamespase),
                            SyntaxFactory.IdentifierName("AppendParams")),
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList<ArgumentSyntax>(
                                new SyntaxNodeOrToken[] {
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.IdentifierName("sb")),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                                            SyntaxFactory.Literal(prop.Name))),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.MemberAccessExpression(
                                            SyntaxKind.SimpleMemberAccessExpression,
                                            SyntaxFactory.IdentifierName("obj"),
                                            SyntaxFactory.IdentifierName(prop.OriginalName)))
                                }))))
            ];
    }

    internal class StringPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.SpecialType == SpecialType.System_String;
    }

    internal class DoublePropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.SpecialType == SpecialType.System_Double;
    }

    internal class IntPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.SpecialType == SpecialType.System_Int32;
    }

    internal class DateTimePropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.SpecialType == SpecialType.System_DateTime;

        public override StatementSyntax[] GetStatements(PropertyInfo prop)
        {
            string defaultFormat = "yyyy-MM-ddTHH:mm:ssZ";
            var dateTimeAttr = prop.AttributeInfos.FirstOrDefault(a => a.TypeName == "DateTimeFormatAttribute");
            var format = dateTimeAttr == null
                        ? defaultFormat
                        : dateTimeAttr.NamedArgumentInfo
                              .OfType<StringArgumentInfo>()
                              .Concat(dateTimeAttr.ConstructorArgumentInfo.OfType<StringArgumentInfo>())
                              .Where(a => string.Equals(a.Name, "Format", StringComparison.OrdinalIgnoreCase))
                              .Select(a => a.Value)
                              .FirstOrDefault(v => !string.IsNullOrWhiteSpace(v)) ?? defaultFormat;
            
            return
            [
                //SyntaxFactory.ParseStatement($"{queryParamBuilderNamespase}.AppendParam(sb, \"{prop.Name}\", obj.{prop.OriginalName}?.ToString(\"{format}\"));"),

                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.ParseName(queryParamBuilderNamespase),
                            SyntaxFactory.IdentifierName("AppendParam")),
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList<ArgumentSyntax>(
                                new SyntaxNodeOrToken[] {
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.IdentifierName("sb")),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                                            SyntaxFactory.Literal(prop.Name))),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.ConditionalAccessExpression(
                                            SyntaxFactory.MemberAccessExpression(
                                                SyntaxKind.SimpleMemberAccessExpression,
                                                SyntaxFactory.IdentifierName("obj"),
                                                SyntaxFactory.IdentifierName(prop.OriginalName)),
                                            SyntaxFactory.InvocationExpression(
                                                SyntaxFactory.MemberBindingExpression(
                                                    SyntaxFactory.IdentifierName("ToString")),
                                                SyntaxFactory.ArgumentList(
                                                    SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(
                                                        SyntaxFactory.Argument(
                                                            SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                                                                SyntaxFactory.Literal(format))))))))
                                }))))
            ];
        }
    }

    internal class BooleanPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.SpecialType == SpecialType.System_Boolean;
    }

    internal class DecimalPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.SpecialType == SpecialType.System_Decimal;
    }

    internal class EnumPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) =>
            prop.Type.TypeKind == TypeKind.Enum;

        public override StatementSyntax[] GetStatements(PropertyInfo prop)
        {
            bool isString = prop.AttributeInfos.Any(a => a.TypeName == "EnumAsStringAttribute");
            return
            [
                SyntaxFactory.ParseStatement($"{queryParamBuilderNamespase}.AppendParam(sb, \"{prop.Name}\", obj.{prop.OriginalName}, {isString.ToString().ToLowerInvariant()});"),

                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.ParseName(queryParamBuilderNamespase),
                            SyntaxFactory.IdentifierName("AppendParam")),
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList<ArgumentSyntax>(
                                new SyntaxNodeOrToken[] {
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.IdentifierName("sb")),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                                            SyntaxFactory.Literal(prop.Name))),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(
                                            isString ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression))
                                }))))
            ];
        }
    }

    internal class DefaultPropertyHandlerStringBuilder : PropertyHandlerBase
    {
        public override bool CanHandle(PropertyInfo prop) => true;
        
        public override StatementSyntax[] GetStatements(PropertyInfo prop) =>
            [
                SyntaxFactory.ExpressionStatement(
                    SyntaxFactory.InvocationExpression(
                        SyntaxFactory.MemberAccessExpression(
                            SyntaxKind.SimpleMemberAccessExpression,
                            SyntaxFactory.ParseName(queryParamBuilderNamespase),
                            SyntaxFactory.IdentifierName("AppendParam")),
                        SyntaxFactory.ArgumentList(
                            SyntaxFactory.SeparatedList<ArgumentSyntax>(
                                new SyntaxNodeOrToken[] {
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.IdentifierName("sb")),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,
                                            SyntaxFactory.Literal(prop.Name))),
                                    SyntaxFactory.Token(SyntaxKind.CommaToken),
                                    SyntaxFactory.Argument(
                                        SyntaxFactory.ConditionalAccessExpression(
                                            SyntaxFactory.MemberAccessExpression(
                                                SyntaxKind.SimpleMemberAccessExpression,
                                                SyntaxFactory.IdentifierName("obj"),
                                                SyntaxFactory.IdentifierName(prop.OriginalName)),
                                            SyntaxFactory.InvocationExpression(
                                                SyntaxFactory.MemberBindingExpression(
                                                    SyntaxFactory.IdentifierName("ToString")))))
                                }))))
            ];
    }
}

1	using Microsoft.CodeAnalysis;
2	using Microsoft.CodeAnalysis.CSharp;
3	using Microsoft.CodeAnalysis.CSharp.Syntax;
4	using QueryUrlParamsGenerator.Models;
5	using QueryUrlParamsGenerator.SourceGenerators.PropertyHandlers.Base;
6	using System;
7	using System.Linq;
8
9	namespace QueryUrlParamsGenerator.SourceGenerators.PropertyHandlers
10	{
11	internal class InnerUrlParametersDtoPropertyHandlerStringBuilder : PropertyHandlerBase
12	{
13	private const string queryParameterClassAttributeName = "GenerateQueryUrlAttribute";
14
15	public override bool CanHandle(PropertyInfo prop) =>
16	prop.Type.GetAttributes().Any(a => a.AttributeClass?.Name == queryParameterClassAttributeName);	132!
17
18	public override StatementSyntax[] GetStatements(PropertyInfo prop)
19	{	1✔
20	var classSymbol = (INamedTypeSymbol)prop.Type;	1✔
21
22	var namespaceSymbol = classSymbol.ContainingNamespace;	1✔
23	var namespaceName = namespaceSymbol?.IsGlobalNamespace == true	1!
24	? string.Empty	1✔
25	: namespaceSymbol?.ToString() ?? "Generated";	1✔
26
27	return	1✔
28	[	1✔
29	SyntaxFactory.IfStatement(	1✔
30	SyntaxFactory.BinaryExpression(	1✔
31	SyntaxKind.GreaterThanExpression,	1✔
32	SyntaxFactory.MemberAccessExpression(	1✔
33	SyntaxKind.SimpleMemberAccessExpression,	1✔
34	SyntaxFactory.IdentifierName("sb"),	1✔
35	SyntaxFactory.IdentifierName("Length")	1✔
36	),	1✔
37	SyntaxFactory.LiteralExpression(	1✔
38	SyntaxKind.NumericLiteralExpression,	1✔
39	SyntaxFactory.Literal(0)	1✔
40	)),	1✔
41	SyntaxFactory.ExpressionStatement(	1✔
42	SyntaxFactory.InvocationExpression(	1✔
43	SyntaxFactory.MemberAccessExpression(	1✔
44	SyntaxKind.SimpleMemberAccessExpression,	1✔
45	SyntaxFactory.IdentifierName("sb"),	1✔
46	SyntaxFactory.IdentifierName("Append")	1✔
47	),	1✔
48	SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(	1✔
49	SyntaxFactory.Argument(	1✔
50	SyntaxFactory.LiteralExpression(	1✔
51	SyntaxKind.StringLiteralExpression,	1✔
52	SyntaxFactory.Literal("&")	1✔
53	))))))	1✔
54	),	1✔
55		1✔
56	SyntaxFactory.ExpressionStatement(	1✔
57	SyntaxFactory.InvocationExpression(	1✔
58	SyntaxFactory.MemberAccessExpression(	1✔
59	SyntaxKind.SimpleMemberAccessExpression,	1✔
60	SyntaxFactory.IdentifierName("sb"),	1✔
61	SyntaxFactory.IdentifierName("Append")	1✔
62	),	1✔
63	SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(	1✔
64	SyntaxFactory.Argument(	1✔
65	SyntaxFactory.InvocationExpression(	1✔
66	SyntaxFactory.MemberAccessExpression(	1✔
67	SyntaxKind.SimpleMemberAccessExpression,	1✔
68	SyntaxFactory.ParseName($"global::{namespaceName}.{classSymbol.Name}Extensions"),	1✔
69	SyntaxFactory.IdentifierName("GetObjectUrlParams")	1✔
70	),	1✔
71	SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(	1✔
72	SyntaxFactory.Argument(	1✔
73	SyntaxFactory.MemberAccessExpression(	1✔
74	SyntaxKind.SimpleMemberAccessExpression,	1✔
75	SyntaxFactory.IdentifierName("obj"),	1✔
76	SyntaxFactory.IdentifierName(prop.OriginalName)	1✔
77	)))))))))	1✔
78	)	1✔
79	];	1✔
80	}	1✔
81	}
82
83	internal class DictionaryPropertyHandlerStringBuilder : PropertyHandlerBase
84	{
85	public override bool CanHandle(PropertyInfo prop) =>
86	prop.Type.MetadataName == "Dictionary`2";	26✔
87
88	public override StatementSyntax[] GetStatements(PropertyInfo prop) =>
89	[	1✔
90	SyntaxFactory.ExpressionStatement(	1✔
91	SyntaxFactory.InvocationExpression(	1✔
92	SyntaxFactory.MemberAccessExpression(	1✔
93	SyntaxKind.SimpleMemberAccessExpression,	1✔
94	SyntaxFactory.ParseName(queryParamBuilderNamespase),	1✔
95	SyntaxFactory.IdentifierName("AppendParams")),	1✔
96	SyntaxFactory.ArgumentList(	1✔
97	SyntaxFactory.SeparatedList<ArgumentSyntax>(	1✔
98	new SyntaxNodeOrToken[] {	1✔
99	SyntaxFactory.Argument(	1✔
100	SyntaxFactory.IdentifierName("sb")),	1✔
101	SyntaxFactory.Token(SyntaxKind.CommaToken),	1✔
102	SyntaxFactory.Argument(	1✔
103	SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,	1✔
104	SyntaxFactory.Literal(prop.Name))),	1✔
105	SyntaxFactory.Token(SyntaxKind.CommaToken),	1✔
106	SyntaxFactory.Argument(	1✔
107	SyntaxFactory.MemberAccessExpression(	1✔
108	SyntaxKind.SimpleMemberAccessExpression,	1✔
109	SyntaxFactory.IdentifierName("obj"),	1✔
110	SyntaxFactory.IdentifierName(prop.OriginalName)))	1✔
111	}))))	1✔
112	];	1✔
113	}
114
115	internal class EnumerablePropertyHandlerStringBuilder : PropertyHandlerBase
116	{
117	public override bool CanHandle(PropertyInfo prop) =>
118	prop.Type.AllInterfaces.Any(i =>	25✔
119	i.OriginalDefinition.SpecialType == SpecialType.System_Collections_IEnumerable	370✔
120	&& prop.Type.SpecialType != SpecialType.System_String);	370✔
121
122	public override StatementSyntax[] GetStatements(PropertyInfo prop) =>
123	[	1✔
124	SyntaxFactory.ExpressionStatement(	1✔
125	SyntaxFactory.InvocationExpression(	1✔
126	SyntaxFactory.MemberAccessExpression(	1✔
127	SyntaxKind.SimpleMemberAccessExpression,	1✔
128	SyntaxFactory.ParseName(queryParamBuilderNamespase),	1✔
129	SyntaxFactory.IdentifierName("AppendParams")),	1✔
130	SyntaxFactory.ArgumentList(	1✔
131	SyntaxFactory.SeparatedList<ArgumentSyntax>(	1✔
132	new SyntaxNodeOrToken[] {	1✔
133	SyntaxFactory.Argument(	1✔
134	SyntaxFactory.IdentifierName("sb")),	1✔
135	SyntaxFactory.Token(SyntaxKind.CommaToken),	1✔
136	SyntaxFactory.Argument(	1✔
137	SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,	1✔
138	SyntaxFactory.Literal(prop.Name))),	1✔
139	SyntaxFactory.Token(SyntaxKind.CommaToken),	1✔
140	SyntaxFactory.Argument(	1✔
141	SyntaxFactory.MemberAccessExpression(	1✔
142	SyntaxKind.SimpleMemberAccessExpression,	1✔
143	SyntaxFactory.IdentifierName("obj"),	1✔
144	SyntaxFactory.IdentifierName(prop.OriginalName)))	1✔
145	}))))	1✔
146	];	1✔
147	}
148
149	internal class StringPropertyHandlerStringBuilder : PropertyHandlerBase
150	{
151	public override bool CanHandle(PropertyInfo prop) =>
152	prop.Type.SpecialType == SpecialType.System_String;	24✔
153	}
154
155	internal class DoublePropertyHandlerStringBuilder : PropertyHandlerBase
156	{
157	public override bool CanHandle(PropertyInfo prop) =>
158	prop.Type.SpecialType == SpecialType.System_Double;	7✔
159	}
160
161	internal class IntPropertyHandlerStringBuilder : PropertyHandlerBase
162	{
163	public override bool CanHandle(PropertyInfo prop) =>
164	prop.Type.SpecialType == SpecialType.System_Int32;	6✔
165	}
166
167	internal class DateTimePropertyHandlerStringBuilder : PropertyHandlerBase
168	{
169	public override bool CanHandle(PropertyInfo prop) =>
170	prop.Type.SpecialType == SpecialType.System_DateTime;	2✔
171
172	public override StatementSyntax[] GetStatements(PropertyInfo prop)
173	{	1✔
174	string defaultFormat = "yyyy-MM-ddTHH:mm:ssZ";	1✔
175	var dateTimeAttr = prop.AttributeInfos.FirstOrDefault(a => a.TypeName == "DateTimeFormatAttribute");	1✔
176	var format = dateTimeAttr == null	1!
177	? defaultFormat	1✔
178	: dateTimeAttr.NamedArgumentInfo	1✔
179	.OfType<StringArgumentInfo>()	1✔
180	.Concat(dateTimeAttr.ConstructorArgumentInfo.OfType<StringArgumentInfo>())	1✔
181	.Where(a => string.Equals(a.Name, "Format", StringComparison.OrdinalIgnoreCase))	×
182	.Select(a => a.Value)	×
183	.FirstOrDefault(v => !string.IsNullOrWhiteSpace(v)) ?? defaultFormat;	1✔
184
185	return	1✔
186	[	1✔
187	//SyntaxFactory.ParseStatement($"{queryParamBuilderNamespase}.AppendParam(sb, \"{prop.Name}\", obj.{prop.OriginalName}?.ToString(\"{format}\"));"),	1✔
188		1✔
189	SyntaxFactory.ExpressionStatement(	1✔
190	SyntaxFactory.InvocationExpression(	1✔
191	SyntaxFactory.MemberAccessExpression(	1✔
192	SyntaxKind.SimpleMemberAccessExpression,	1✔
193	SyntaxFactory.ParseName(queryParamBuilderNamespase),	1✔
194	SyntaxFactory.IdentifierName("AppendParam")),	1✔
195	SyntaxFactory.ArgumentList(	1✔
196	SyntaxFactory.SeparatedList<ArgumentSyntax>(	1✔
197	new SyntaxNodeOrToken[] {	1✔
198	SyntaxFactory.Argument(	1✔
199	SyntaxFactory.IdentifierName("sb")),	1✔
200	SyntaxFactory.Token(SyntaxKind.CommaToken),	1✔
201	SyntaxFactory.Argument(	1✔
202	SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,	1✔
203	SyntaxFactory.Literal(prop.Name))),	1✔
204	SyntaxFactory.Token(SyntaxKind.CommaToken),	1✔
205	SyntaxFactory.Argument(	1✔
206	SyntaxFactory.ConditionalAccessExpression(	1✔
207	SyntaxFactory.MemberAccessExpression(	1✔
208	SyntaxKind.SimpleMemberAccessExpression,	1✔
209	SyntaxFactory.IdentifierName("obj"),	1✔
210	SyntaxFactory.IdentifierName(prop.OriginalName)),	1✔
211	SyntaxFactory.InvocationExpression(	1✔
212	SyntaxFactory.MemberBindingExpression(	1✔
213	SyntaxFactory.IdentifierName("ToString")),	1✔
214	SyntaxFactory.ArgumentList(	1✔
215	SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(	1✔
216	SyntaxFactory.Argument(	1✔
217	SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,	1✔
218	SyntaxFactory.Literal(format))))))))	1✔
219	}))))	1✔
220	];	1✔
221	}	1✔
222	}
223
224	internal class BooleanPropertyHandlerStringBuilder : PropertyHandlerBase
225	{
226	public override bool CanHandle(PropertyInfo prop) =>
227	prop.Type.SpecialType == SpecialType.System_Boolean;	1✔
228	}
229
230	internal class DecimalPropertyHandlerStringBuilder : PropertyHandlerBase
231	{
232	public override bool CanHandle(PropertyInfo prop) =>
233	prop.Type.SpecialType == SpecialType.System_Decimal;	×
234	}
235
236	internal class EnumPropertyHandlerStringBuilder : PropertyHandlerBase
237	{
238	public override bool CanHandle(PropertyInfo prop) =>
239	prop.Type.TypeKind == TypeKind.Enum;	×
240
241	public override StatementSyntax[] GetStatements(PropertyInfo prop)
242	{	×
243	bool isString = prop.AttributeInfos.Any(a => a.TypeName == "EnumAsStringAttribute");	×
244	return	×
245	[	×
246	SyntaxFactory.ParseStatement($"{queryParamBuilderNamespase}.AppendParam(sb, \"{prop.Name}\", obj.{prop.OriginalName}, {isString.ToString().ToLowerInvariant()});"),	×
247		×
248	SyntaxFactory.ExpressionStatement(	×
249	SyntaxFactory.InvocationExpression(	×
250	SyntaxFactory.MemberAccessExpression(	×
251	SyntaxKind.SimpleMemberAccessExpression,	×
252	SyntaxFactory.ParseName(queryParamBuilderNamespase),	×
253	SyntaxFactory.IdentifierName("AppendParam")),	×
254	SyntaxFactory.ArgumentList(	×
255	SyntaxFactory.SeparatedList<ArgumentSyntax>(	×
256	new SyntaxNodeOrToken[] {	×
257	SyntaxFactory.Argument(	×
258	SyntaxFactory.IdentifierName("sb")),	×
259	SyntaxFactory.Token(SyntaxKind.CommaToken),	×
260	SyntaxFactory.Argument(	×
261	SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,	×
262	SyntaxFactory.Literal(prop.Name))),	×
263	SyntaxFactory.Token(SyntaxKind.CommaToken),	×
264	SyntaxFactory.Argument(	×
265	SyntaxFactory.LiteralExpression(	×
266	isString ? SyntaxKind.TrueLiteralExpression : SyntaxKind.FalseLiteralExpression))	×
267	}))))	×
268	];	×
269	}	×
270	}
271
272	internal class DefaultPropertyHandlerStringBuilder : PropertyHandlerBase
273	{
274	public override bool CanHandle(PropertyInfo prop) => true;	×
275
276	public override StatementSyntax[] GetStatements(PropertyInfo prop) =>
277	[	×
278	SyntaxFactory.ExpressionStatement(	×
279	SyntaxFactory.InvocationExpression(	×
280	SyntaxFactory.MemberAccessExpression(	×
281	SyntaxKind.SimpleMemberAccessExpression,	×
282	SyntaxFactory.ParseName(queryParamBuilderNamespase),	×
283	SyntaxFactory.IdentifierName("AppendParam")),	×
284	SyntaxFactory.ArgumentList(	×
285	SyntaxFactory.SeparatedList<ArgumentSyntax>(	×
286	new SyntaxNodeOrToken[] {	×
287	SyntaxFactory.Argument(	×
288	SyntaxFactory.IdentifierName("sb")),	×
289	SyntaxFactory.Token(SyntaxKind.CommaToken),	×
290	SyntaxFactory.Argument(	×
291	SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression,	×
292	SyntaxFactory.Literal(prop.Name))),	×
293	SyntaxFactory.Token(SyntaxKind.CommaToken),	×
294	SyntaxFactory.Argument(	×
295	SyntaxFactory.ConditionalAccessExpression(	×
296	SyntaxFactory.MemberAccessExpression(	×
297	SyntaxKind.SimpleMemberAccessExpression,	×
298	SyntaxFactory.IdentifierName("obj"),	×
299	SyntaxFactory.IdentifierName(prop.OriginalName)),	×
300	SyntaxFactory.InvocationExpression(	×
301	SyntaxFactory.MemberBindingExpression(	×
302	SyntaxFactory.IdentifierName("ToString")))))	×
303	}))))	×
304	];	×
305	}
306	}

leonov-anton / QueryUrlParams / 15303850882

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous