private void GenerateExtensionMethod(ClassDeclaration extensionClass, Method method, MethodParameter methodParameter)
{
foreach (var parameterEntityRef in methodParameter.Type.ParameterEntity.Refs.Where(r => r.ModelRef.IsModel))
{
var m = GenerateMethod(extensionClass, method);
m.Modifiers |= Modifiers.Static;
var extensionArgument = new MethodArgumentDeclaration(parameterEntityRef.ModelRef, ToArgumentName(parameterEntityRef.ModelRef.Model.Name))
{
IsExtension = true
};
m.Statements.Clear();
var invoke = new MethodInvokeExpression(new CastExpression(extensionArgument, new TypeReference("IGitLabObject")).CreateMemberReferenceExpression("GitLabClient", m.Name));
foreach (var arg in m.Arguments.ToList())
{
if (arg.Data.TryGetValue("Parameter", out var parameter) && methodParameter == parameter)
{
m.Arguments.Remove(arg);
invoke.Arguments.Add(extensionArgument);
}
else
{
invoke.Arguments.Add(arg);
}
}
m.Statements.Add(new ReturnStatement(invoke));
m.Name = m.Name.Replace(extensionClass.Name, "", StringComparison.OrdinalIgnoreCase);
m.Arguments.Insert(0, extensionArgument);
}
}
private void GenerateFileExtensionMethod(ClassDeclaration classDeclaration, ClassDeclaration extensionClass)
{
var methods = classDeclaration.Members
.OfType <MethodDeclaration>()
.Where(ContainsFileArgument)
.ToList();
foreach (var methodDeclaration in methods)
{
var method = methodDeclaration.Data["Method"] as Method;
if (method == null)
{
continue;
}
var m = GenerateMethod(extensionClass, method);
m.Modifiers |= Modifiers.Static;
m.Statements.Clear();
var extensionArgument = new MethodArgumentDeclaration(new TypeReference("IGitLabClient"), "client")
{
IsExtension = true
};
var invoke = new MethodInvokeExpression(extensionArgument.CreateMemberReferenceExpression(methodDeclaration.Name));
foreach (var arg in m.Arguments.ToList())
{
if (arg.Name == "encoding")
{
invoke.Arguments.Add(new LiteralExpression("base64"));
m.Arguments.Remove(arg);
}
else if (arg.Name == "content")
{
invoke.Arguments.Add(new TypeReference(typeof(Convert)).CreateInvokeMethodExpression(nameof(Convert.ToBase64String), arg));
arg.Type = typeof(byte[]);
}
else
{
invoke.Arguments.Add(arg);
}
}
m.Statements.Add(new ReturnStatement(invoke));
m.Name = m.Name.Replace(extensionClass.Name, "", StringComparison.OrdinalIgnoreCase);
m.Arguments.Insert(0, extensionArgument);
}
bool ContainsFileArgument(MethodDeclaration m)
{
return(m.Arguments.Any(a => a.Name == "content" && a.Type.ClrFullTypeName == typeof(string).FullName) &&
m.Arguments.Any(a => a.Name == "encoding" && a.Type.ClrFullTypeName == typeof(string).FullName));
}
}
public ArgumentReferenceExpression(MethodArgumentDeclaration argumentDeclaration)
{
_argumentDeclaration = argumentDeclaration;
}
private void GenerateMethodSignature(Method method, MethodDeclaration m, out Dictionary <MethodParameter, MethodArgumentDeclaration> arguments, out MethodArgumentDeclaration pageArgument, out MethodArgumentDeclaration requestOptionsArgument, out MethodArgumentDeclaration cancellationTokenArgument)
{
AddDocumentationComments(m, method.Documentation);
if (method.MethodType == MethodType.GetPaged)
{
m.ReturnType = new TypeReference(typeof(Task <>)).MakeGeneric(new TypeReference("Meziantou.GitLab.PagedResponse").MakeGeneric(method.ReturnType));
}
else
{
if (method.ReturnType != null)
{
if (method.ReturnType.IsCollection)
{
m.ReturnType = new TypeReference(typeof(Task <>)).MakeGeneric(new TypeReference(typeof(IReadOnlyList <>)).MakeGeneric(method.ReturnType));
}
else
{
m.ReturnType = new TypeReference(typeof(Task <>)).MakeGeneric(method.ReturnType);
}
}
else
{
m.ReturnType = new TypeReference(typeof(Task));
}
}
arguments = new Dictionary <MethodParameter, MethodArgumentDeclaration>();
foreach (var param in method.Parameters.OrderBy(p => p.IsOptional ? 1 : -1))
{
var argument = m.AddArgument(new MethodArgumentDeclaration(GetArgumentTypeRef(param.Type), param.MethodParameterName ?? ToArgumentName(param.Name)));
if (param.IsOptional)
{
argument.DefaultValue = new DefaultValueExpression(argument.Type.Clone());
}
arguments.Add(param, argument);
argument.SetData("Parameter", param);
AddDocumentationComments(argument, param.Documentation);
}
pageArgument = null;
if (method.MethodType == MethodType.GetPaged)
{
pageArgument = m.AddArgument(new MethodArgumentDeclaration(typeof(PageOptions), "pageOptions")
{
DefaultValue = new DefaultValueExpression(typeof(PageOptions))
});
AddDocumentationComments(pageArgument, new Documentation()
{
Summary = "The page index and page size"
});
}
requestOptionsArgument = m.AddArgument(new MethodArgumentDeclaration(ModelRef.RequestOptions, "requestOptions")
{
DefaultValue = new DefaultValueExpression(ModelRef.RequestOptions)
});
AddDocumentationComments(requestOptionsArgument, new Documentation()
{
Summary = "Options of the request"
});
cancellationTokenArgument = m.AddArgument(new MethodArgumentDeclaration(typeof(CancellationToken), "cancellationToken")
{
DefaultValue = new DefaultValueExpression(typeof(CancellationToken))
});
AddDocumentationComments(cancellationTokenArgument, new Documentation()
{
Summary = "A cancellation token that can be used by other objects or threads to receive notice of cancellation"
});
}
