/// <summary>
/// Extension method that determines if the source code has a target namespace as a using statement.
/// </summary>
/// <param name="source">The source code to search through.</param>
/// <param name="nameSpace">The namespace to search for in the using statements.</param>
/// <param name="alias">Optional parameter that captures the alias of the namespace used in the using statement.</param>
/// <returns>Flag that determines if it has the using statement.</returns>
public static bool HasUsingStatement(this CsSource source, string nameSpace, string alias = null)
{
if (source == null)
{
return(false);
}
if (string.IsNullOrEmpty(nameSpace))
{
return(false);
}
var result = alias == null?source.NamespaceReferences.Any(ns => ns.ReferenceNamespace == nameSpace)
: source.NamespaceReferences.Any(ns => (ns.ReferenceNamespace == nameSpace) & (ns.Alias == alias));
return(result);
}
/// <summary>
/// Extension method that will add a using statement to target source code. If the using statement already exists it will simply return the existing source.
/// </summary>
/// <param name="source">The source code to update.</param>
/// <param name="nameSpace">The namespace to be added to the using statement.</param>
/// <param name="alias">Optional parameter to set if you want an alias assigned to the namespace.</param>
/// <returns>The updated source code or the original source code if no changes were necessary.</returns>
public static async Task <CsSource> AddUsingStatementAsync(this CsSource source, string nameSpace, string alias = null)
{
// ReSharper disable once ExpressionIsAlwaysNull
if (source == null)
{
return(source);
}
if (string.IsNullOrEmpty(nameSpace))
{
return(source);
}
if (source.HasUsingStatement(nameSpace, alias))
{
return(source);
}
SourceFormatter usingFormatter = new SourceFormatter();
usingFormatter.AppendCodeLine(0, alias == null ? $"using {nameSpace};" : $"using {alias} = {nameSpace};");
string usingStatement = usingFormatter.ReturnSource();
CsSource result = null;
if (source.NamespaceReferences.Any())
{
var lastUsingStatement = source.NamespaceReferences.Last();
result = await lastUsingStatement.AddAfterAsync(usingStatement);
}
else
{
result = await source.AddToBeginningAsync(usingStatement);
}
return(result);
}
public static async Task <CsSource> AddMissingNamespaces(this CsSource source, IEnumerable <CsMember> members, string excludeNamespace = null)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (!source.IsLoaded)
{
return(source);
}
if (members == null)
{
return(source);
}
if (!members.Any())
{
return(source);
}
List <string> namespaces = new List <string>();
CsSource result = source;
foreach (var member in members)
{
switch (member.MemberType)
{
case CsMemberType.Event:
if (!(member is CsEvent eventModel))
{
continue;
}
if (!eventModel.IsLoaded)
{
continue;
}
namespaces.AddUniqueNamespace(eventModel.EventType, excludeNamespace);
if (eventModel.HasAttributes)
{
namespaces.AddAttributeNamespaces(eventModel.Attributes, excludeNamespace);
}
break;
case CsMemberType.Field:
if (!(member is CsField fieldModel))
{
continue;
}
if (!fieldModel.IsLoaded)
{
continue;
}
namespaces.AddUniqueNamespace(fieldModel.DataType, excludeNamespace);
if (fieldModel.HasAttributes)
{
namespaces.AddAttributeNamespaces(fieldModel.Attributes, excludeNamespace);
}
break;
case CsMemberType.Method:
if (!(member is CsMethod methodModel))
{
continue;
}
if (!methodModel.IsLoaded)
{
continue;
}
if (!methodModel.IsVoid)
{
namespaces.AddUniqueNamespace(methodModel.ReturnType, excludeNamespace);
}
if (methodModel.HasAttributes)
{
namespaces.AddAttributeNamespaces(methodModel.Attributes, excludeNamespace);
}
if (methodModel.HasParameters)
{
foreach (var methodModelParameter in methodModel.Parameters)
{
namespaces.AddUniqueNamespace(methodModelParameter.ParameterType, excludeNamespace);
if (methodModelParameter.HasAttributes)
{
namespaces.AddAttributeNamespaces(methodModelParameter.Attributes, excludeNamespace);
}
}
}
break;
case CsMemberType.Property:
if (!(member is CsProperty propertyModel))
{
continue;
}
if (!propertyModel.IsLoaded)
{
continue;
}
namespaces.AddUniqueNamespace(propertyModel.PropertyType, excludeNamespace);
if (propertyModel.HasAttributes)
{
namespaces.AddAttributeNamespaces(propertyModel.Attributes, excludeNamespace);
}
break;
}
}
if (!namespaces.Any())
{
return(result);
}
foreach (var nameSpace in namespaces)
{
result = await result.AddUsingStatementAsync(nameSpace);
}
return(result);
}
