public string RenderClassDeclaration(ClassInterfaceDeclaration classDeclaration = null)
{
var stringTemplate = _cSharpCommonGroupFile.GetInstanceOf(StgCSharpCommon.ClassDeclaration.Name);
stringTemplate.Add(StgCSharpCommon.ClassDeclaration.Params.Attributes, classDeclaration.Attributes);
stringTemplate.Add(StgCSharpCommon.ClassDeclaration.Params.Modifiers, classDeclaration.Modifiers);
stringTemplate.Add(StgCSharpCommon.ClassDeclaration.Params.Identifier, classDeclaration.Identifier);
stringTemplate.Add(StgCSharpCommon.ClassDeclaration.Params.TypeParameters, classDeclaration.TypeParameters);
stringTemplate.Add(StgCSharpCommon.ClassDeclaration.Params.Base, classDeclaration.Base);
stringTemplate.Add(StgCSharpCommon.ClassDeclaration.Params.Body, classDeclaration.Body);
return(stringTemplate.Render());
}
public string RenderServiceNamespaceDeclaration(
string serviceNamespace = null,
ClassInterfaceDeclaration service = null)
{
var stringTemplate = _serviceCommandGroupFile.GetInstanceOf(
StgServiceCommand.ServiceNamespaceDeclaration.Name);
stringTemplate.Add(
StgServiceCommand.ServiceNamespaceDeclaration.Params.ServiceNamespace, serviceNamespace);
stringTemplate.Add(StgServiceCommand.ServiceNamespaceDeclaration.Params.ServiceDeclaration, service);
return(stringTemplate.Render());
}
public string RenderServiceFile(
List <string> usingDirectives,
string serviceNamespace,
ClassInterfaceDeclaration serviceDeclaration)
{
var stringTemplate = _serviceCommandGroupFile.GetInstanceOf(StgServiceCommand.ServiceFile.Name);
stringTemplate.Add(StgServiceCommand.ServiceFile.Params.ServiceNamespace, serviceNamespace);
stringTemplate.Add(StgServiceCommand.ServiceFile.Params.UsingDirectives, usingDirectives);
stringTemplate.Add(StgServiceCommand.ServiceFile.Params.ServiceDeclaration, serviceDeclaration);
return(stringTemplate.Render());
}
public string GenerateClassInterfaceDeclaration(
ClassInterfaceDeclaration classInterfaceDeclaration,
int tabLevels = 0,
string tabString = null)
{
if (classInterfaceDeclaration is null)
{
return(string.Empty);
}
return("\r\n\r\n" +
_stringUtilService.TabString(
classInterfaceDeclaration.IsInterface
? _cSharpCommonStgService.RenderInterfaceDeclaration(classInterfaceDeclaration)
: _cSharpCommonStgService.RenderClassDeclaration(classInterfaceDeclaration),
tabLevels,
tabString));
}
public override object VisitClass_declaration([NotNull] CSharpParser.Class_declarationContext context)
{
bool matchNames = context.identifier().GetText() == ServiceClassName;
bool isTypeParamsMatch = true;
var typeParams = context?.type_parameter_list()?.type_parameter();
if (!(typeParams is null && (TypeParameters is null || TypeParameters.Count == 0)))
{
if ((typeParams?.Length ?? 0) != (TypeParameters?.Count ?? 0))
{
isTypeParamsMatch = false;
}
else
{
for (int i = 0; i < typeParams.Length; ++i)
{
if (typeParams[i].identifier().GetText() != TypeParameters[i].TypeParam)
{
isTypeParamsMatch = false;
break;
}
}
}
}
if (matchNames && isTypeParamsMatch)
{
HasServiceClass = true;
Results.ServiceNamespace = string.Join(".", _currentNamespace.ToArray().Reverse());
var classDeclaration = new ClassInterfaceDeclaration()
{
IsInterface = false,
Attributes = _cSharpParserService.GetTextWithWhitespace(Tokens, context?.attributes()),
Identifier = ServiceClassName
};
//Results.ClassInterfaceDeclarations.Add(className, classDeclaration);
Results.ServiceDeclaration = classDeclaration;
if (context?.PARTIAL()?.GetText() != null)
{
classDeclaration.Modifiers.Add(context.PARTIAL().GetText());
}
if (context?.class_modifier() != null)
{
foreach (var modifier in context.class_modifier())
{
classDeclaration.Modifiers.Add(modifier.GetText());
}
}
var typeParameters = context?.type_parameter_list()?.type_parameter();
var constraintsClauses =
context?.type_parameter_constraints_clauses()?.type_parameter_constraints_clause();
classDeclaration.TypeParameters =
_cSharpParserService.ParseTypeParameterList(Tokens, typeParameters, constraintsClauses);
var baseClassType = _cSharpParserService.GetTextWithWhitespaceMinifiedLite(
Tokens, context?.class_base()?.class_type());
var interfaceTypes = context?.class_base()?.interface_type_list()?.interface_type();
if (interfaceTypes != null || baseClassType != null)
{
classDeclaration.Base = new ClassInterfaceBase();
if (baseClassType != null)
{
classDeclaration.Base.ClassType = baseClassType;
}
if (interfaceTypes != null)
{
foreach (var interfaceType in interfaceTypes)
{
classDeclaration.Base.InterfaceTypeList.Add(
_cSharpParserService.GetTextWithWhitespaceMinifiedLite(Tokens, interfaceType));
}
}
}
var memberDeclarations = context?.class_body()?.class_member_declarations()?.class_member_declaration();
if (memberDeclarations != null)
{
foreach (var memberDeclaration in memberDeclarations)
{
bool isPublic = false;
var classMethodDeclaration = memberDeclaration?.method_declaration();
var classPropertyDeclaration = memberDeclaration?.property_declaration();
if (classMethodDeclaration != null)
{
var methodDeclaration = new MethodDeclaration()
{
Attributes = _cSharpParserService.GetTextWithWhitespace(
Tokens, classMethodDeclaration?.method_header()?.attributes()),
ReturnType = _cSharpParserService.GetTextWithWhitespaceMinifiedLite(
Tokens, classMethodDeclaration.method_header().return_type()),
Identifier = classMethodDeclaration.method_header().member_name().GetText(),
Body = _cSharpParserService.GetTextWithWhitespaceUntab(
Tokens, classMethodDeclaration.method_body())
};
var methodModifiers = classMethodDeclaration?.method_header()?.method_modifier();
if (methodModifiers != null)
{
foreach (var methodMod in methodModifiers)
{
if (methodMod.GetText() == Keywords.Public)
{
isPublic = true;
}
methodDeclaration.Modifiers.Add(methodMod.GetText());
}
}
if (!isPublic)
{
continue;
}
var formalParameterList = classMethodDeclaration?.method_header()?.formal_parameter_list();
methodDeclaration.FormalParameterList =
_cSharpParserService.ParseFormalParameterList(Tokens, formalParameterList);
var methodTypeParameters =
classMethodDeclaration?.method_header()?.type_parameter_list()?.type_parameter();
var methodConstraintsClauses = classMethodDeclaration
?.method_header()
?.type_parameter_constraints_clauses()
?.type_parameter_constraints_clause();
methodDeclaration.TypeParameters = _cSharpParserService
.ParseTypeParameterList(Tokens, methodTypeParameters, methodConstraintsClauses);
classDeclaration.Body.MethodDeclarations.Add(methodDeclaration);
}
else if (classPropertyDeclaration != null)
{
var propertyDeclaration = new PropertyDeclaration()
{
Attributes = _cSharpParserService.GetTextWithWhitespace(
Tokens, classPropertyDeclaration?.attributes()),
Type = _cSharpParserService.GetTextWithWhitespaceMinifiedLite(
Tokens, classPropertyDeclaration.type_()),
Identifier = classPropertyDeclaration.member_name().GetText(),
Body = new PropertyBody()
{
Text = _cSharpParserService.GetTextWithWhitespaceUntab(
Tokens, classPropertyDeclaration.property_body()),
HasGetAccessor = classPropertyDeclaration.property_body().expression() != null
| classPropertyDeclaration.property_body()
?.accessor_declarations()
?.get_accessor_declaration() != null,
HasSetAccessor = classPropertyDeclaration.property_body()
?.accessor_declarations()
?.set_accessor_declaration() != null
}
};
var propertyModifiers = classPropertyDeclaration?.property_modifier();
if (propertyModifiers != null)
{
foreach (var propModifier in propertyModifiers)
{
if (propModifier.GetText() == Keywords.Public)
{
isPublic = true;
}
propertyDeclaration.Modifiers.Add(propModifier.GetText());
}
}
if (!isPublic)
{
continue;
}
classDeclaration.Body.PropertyDeclarations.Add(propertyDeclaration);
}
}
}
}
VisitChildren(context);
return(null);
}
private void ConsolidateServiceClassAndInterface(
SourceOfTruth sourceOfTruth,
string serviceClassName,
string serviceInterfaceName,
List <TypeParameter> typeParameters,
List <InjectedService> injectedServices,
string serviceClassFilePath,
string serviceInterfaceFilePath,
string serviceNamespace,
string outServiceClassFilePath,
string outServiceInterfaceFilePath)
{
var usingDirectives = new HashSet <string>();
var fieldDeclarations = new List <FieldDeclaration>();
var ctorParameters = new FormalParameterList();
var fixedParams = ctorParameters.FixedParameters;
var ctorBody = new ConstructorBody();
var statements = ctorBody.Statements;
var appendBody = new ClassInterfaceBody()
{
FieldDeclarations = fieldDeclarations,
ConstructorDeclaration = new ConstructorDeclaration()
{
FormalParameterList = ctorParameters,
Body = ctorBody
}
};
if (injectedServices != null && injectedServices.Count > 0)
{
foreach (var injectedService in injectedServices)
{
var injectedServiceIdentifier = injectedService.ServiceIdentifier
?? Regex.Replace(
Regex.Replace(
injectedService.Type,
@"^I?([A-Z])",
"$1"),
@"^[A-Z]",
m => m.ToString().ToLower());
if (!Regex.Match(serviceNamespace, "^" + Regex.Escape(injectedService.Namespace)).Success)
{
usingDirectives.Add(injectedService.Namespace);
}
fieldDeclarations.Add(
new FieldDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Private,
Keywords.Readonly
},
Type = injectedService.Type,
VariableDeclarator = new VariableDeclarator()
{
Identifier = "_" + injectedServiceIdentifier
}
});
fixedParams.Add(
new FixedParameter()
{
Type = injectedService.Type,
Identifier = injectedServiceIdentifier
});
statements.Add(
new Statement()
{
SimpleAssignment = new SimpleAssignment()
{
LeftHandSide = "_" + injectedServiceIdentifier,
RightHandSide = injectedServiceIdentifier
}
});
}
}
CSharpParserWrapper serviceClassParser = null;
CSharpParserWrapper serviceInterfaceParser = null;
ServiceFile classScraperResults = null;
ServiceFile interfaceScraperResults = null;
//Check if <service> class file exists:
if (File.Exists(serviceClassFilePath))
{
_logger.LogDebug("Service class file found. Pulling data from service class.");
// Else:
// Parse <service> class file
// Extract list of existing public method signatures
serviceClassParser = new CSharpParserWrapper(GetPathFromWrittenTo(serviceClassFilePath));
classScraperResults = _serviceCommandService.ScrapeServiceClass(
serviceClassParser,
serviceClassName,
serviceNamespace,
typeParameters);
}
else
{
_logger.LogDebug($"No service class file found at {serviceClassFilePath}.");
}
//Check if <service> interface file exists:
if (File.Exists(serviceInterfaceFilePath))
{
_logger.LogDebug("Service interface file found. Pulling data from service interface.");
// Else:
// Parse <service> interface file
// Extract list of existing method signatures
serviceInterfaceParser = new CSharpParserWrapper(GetPathFromWrittenTo(serviceInterfaceFilePath));
interfaceScraperResults = _serviceCommandService.ScrapeServiceInterface(
serviceInterfaceParser,
serviceInterfaceName,
serviceNamespace,
typeParameters);
}
else
{
_logger.LogDebug($"No service interface file found at {serviceInterfaceFilePath}.");
}
if (classScraperResults is null && interfaceScraperResults is null)
{
_logger.LogDebug("Creating new service class and interface and writing them to file.");
// Create <service> class file
// Create serviceClass StringTemplate with empty class body
var classDeclaration = new ClassInterfaceDeclaration()
{
IsInterface = false,
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceClassName,
TypeParameters = typeParameters.Copy(),
Base = new ClassInterfaceBase()
{
InterfaceTypeList = new List <string>()
{
serviceInterfaceName + _cSharpCommonStgService.RenderTypeParamList(typeParameters.Copy())
}
},
Body = new ClassInterfaceBody()
{
FieldDeclarations = fieldDeclarations,
ConstructorDeclaration = new ConstructorDeclaration()
{
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceClassName,
FormalParameterList = ctorParameters,
Body = ctorBody
}
}
};
UpdateWrittenTo(serviceClassFilePath, outServiceClassFilePath);
_ioUtilService.WriteStringToFile(
_serviceCommandStgService.RenderServiceFile(
usingDirectives: usingDirectives.ToList(),
serviceNamespace: serviceNamespace,
service: classDeclaration),
outServiceClassFilePath);
// Create <service> interface file
// Create serviceInterface StringTemplate with empty interface body
var interfaceDeclaration = new ClassInterfaceDeclaration()
{
IsInterface = true,
Modifiers = new List <string>()
{
Keywords.Public
},
Identifier = serviceInterfaceName,
TypeParameters = typeParameters.Copy()
};
UpdateWrittenTo(serviceInterfaceFilePath, outServiceInterfaceFilePath);
_ioUtilService.WriteStringToFile(
_serviceCommandStgService.RenderServiceFile(
serviceNamespace: serviceNamespace,
service: interfaceDeclaration),
outServiceInterfaceFilePath);
}
public override object VisitInterface_declaration([NotNull] CSharpParser.Interface_declarationContext context)
{
bool matchNames = context.identifier().GetText() == ServiceInterfaceName;
bool isTypeParamsMatch = true;
var variantTypeParameters = context?.variant_type_parameter_list()?.variant_type_parameter();
if (!(variantTypeParameters is null && (TypeParameters is null || TypeParameters.Count == 0)))
{
if ((variantTypeParameters?.Length ?? 0) != (TypeParameters?.Count ?? 0))
{
isTypeParamsMatch = false;
}
else
{
for (int i = 0; i < variantTypeParameters.Length; ++i)
{
if (variantTypeParameters[i].identifier().GetText() != TypeParameters[i].TypeParam)
{
isTypeParamsMatch = false;
break;
}
}
}
}
if (matchNames && isTypeParamsMatch)
{
HasServiceInterface = true;
Results.ServiceNamespace = string.Join(".", _currentNamespace.ToArray().Reverse());
var interfaceDeclaration = new ClassInterfaceDeclaration()
{
IsInterface = true,
Attributes = _cSharpParserService.GetTextWithWhitespace(Tokens, context?.attributes()),
Identifier = ServiceInterfaceName
};
//Results.ClassInterfaceDeclarations.Add(interfaceName, interfaceDeclaration);
Results.ServiceDeclaration = interfaceDeclaration;
if (context?.PARTIAL()?.GetText() != null)
{
interfaceDeclaration.Modifiers.Add(context.PARTIAL().GetText());
}
if (context?.interface_modifier() != null)
{
foreach (var modifier in context.interface_modifier())
{
interfaceDeclaration.Modifiers.Add(modifier.GetText());
}
}
var constraintsClauses =
context?.type_parameter_constraints_clauses()?.type_parameter_constraints_clause();
interfaceDeclaration.TypeParameters =
_cSharpParserService.ParseVariantTypeParameterList(
Tokens, variantTypeParameters, constraintsClauses);
var interfaceTypes = context?.interface_base()?.interface_type_list()?.interface_type();
if (interfaceTypes != null)
{
interfaceDeclaration.Base = new ClassInterfaceBase();
foreach (var interfaceType in interfaceTypes)
{
interfaceDeclaration.Base.InterfaceTypeList.Add(
_cSharpParserService.GetTextWithWhitespaceMinifiedLite(Tokens, interfaceType));
}
}
var memberDeclarations = context?.interface_body()?.interface_member_declaration();
if (memberDeclarations != null)
{
foreach (var memberDeclaration in memberDeclarations)
{
var interfaceMethodDeclaration = memberDeclaration?.interface_method_declaration();
var interfacePropertyDeclaration = memberDeclaration?.interface_property_declaration();
if (interfaceMethodDeclaration != null)
{
var methodDeclaration = new MethodDeclaration()
{
Attributes = _cSharpParserService.GetTextWithWhitespace(
Tokens, interfaceMethodDeclaration?.attributes()),
ReturnType = _cSharpParserService.GetTextWithWhitespaceMinifiedLite(
Tokens, interfaceMethodDeclaration.return_type()),
Identifier = interfaceMethodDeclaration.identifier().GetText()
};
if (interfaceMethodDeclaration?.NEW()?.GetText() != null)
{
methodDeclaration.Modifiers.Add(interfaceMethodDeclaration.NEW().GetText());
}
var formalParameterList = interfaceMethodDeclaration?.formal_parameter_list();
methodDeclaration.FormalParameterList =
_cSharpParserService.ParseFormalParameterList(Tokens, formalParameterList);
var methodTypeParameters =
interfaceMethodDeclaration?.type_parameter_list()?.type_parameter();
var methodConstraintsClauses = interfaceMethodDeclaration
?.type_parameter_constraints_clauses()
?.type_parameter_constraints_clause();
methodDeclaration.TypeParameters = _cSharpParserService
.ParseTypeParameterList(Tokens, methodTypeParameters, methodConstraintsClauses);
interfaceDeclaration.Body.MethodDeclarations.Add(methodDeclaration);
}
else if (interfacePropertyDeclaration != null)
{
var propertyDeclaration = new PropertyDeclaration()
{
Attributes = _cSharpParserService.GetTextWithWhitespace(
Tokens, interfacePropertyDeclaration?.attributes()),
Type = _cSharpParserService.GetTextWithWhitespaceMinifiedLite(
Tokens, interfacePropertyDeclaration.type_()),
Identifier = interfacePropertyDeclaration.identifier().GetText(),
Body = new PropertyBody()
{
Text = _cSharpParserService.GetTextWithWhitespaceUntab(
Tokens, interfacePropertyDeclaration.interface_accessors()),
HasGetAccessor = interfacePropertyDeclaration.interface_accessors()
.interface_get_accessor() != null,
HasSetAccessor = interfacePropertyDeclaration.interface_accessors()
.interface_set_accessor() != null
}
};
if (interfacePropertyDeclaration?.NEW() != null)
{
propertyDeclaration.Modifiers.Add(interfacePropertyDeclaration?.NEW()?.GetText());
}
interfaceDeclaration.Body.PropertyDeclarations.Add(propertyDeclaration);
}
}
}
}
VisitChildren(context);
return(null);
}
