/// <summary>
/// Process the generator.
/// </summary>
/// <param name="projectFile">The project file to work from.</param>
public void Generate(string projectFile)
{
this.logger.LogInformation($"Loading {Path.GetFileName(projectFile)}...");
var projectFolder = Path.GetDirectoryName(projectFile);
// First we need to register the project.
var project = this.workspace.RegisterProject(projectFile);
// Register the pattern interface.
var patternInterfaceDeclaration = this.workspace.RegisterFile("./Patterns/Itf/IModelPattern.cs")
.Declarations.Single() as IInterfaceDeclaration;
// Register the pattern implementation.
var patternImplementationDeclaration = this.workspace.RegisterFile("./Patterns/Impl/ModelPattern.cs")
.Declarations.Single() as IGenericDeclaration <SyntaxNode>;
// Load the project and its project dependencies. (Note that for now we only load the sources.
// The binary assembly dependencies are not taken into account)
var resolver = this.workspace.DeepLoad();
// Get the base interface in order to find all extended interfaces that need to be implemented.
var modelBaseInterface = resolver.Find("SoloX.GeneratorTools.Core.CSharp.Examples.Core.IModelBase").Single() as IGenericDeclaration <SyntaxNode>;
// Setup a locator that will tell the location where the generated classes must be written.
var locator = new RelativeLocator(projectFolder, project.RootNameSpace, suffix: "Impl");
// Create the Implementation Generator with a file generator, the locator and the pattern interface/class.
var generator = new ImplementationGenerator(
new FileGenerator(".generated.cs"),
locator,
patternInterfaceDeclaration,
patternImplementationDeclaration);
// Loop on all interface extending the base interface.
foreach (var modelInterface in modelBaseInterface.ExtendedBy.Where(d => d != patternInterfaceDeclaration))
{
this.logger.LogInformation(modelInterface.FullName);
var implName = GeneratorHelper.ComputeClassName(modelInterface.Name);
// Create the property writer what will use all properties from the model interface to generate
// and write the corresponding code depending on the given patterns.
var propertyWriter = new PropertyWriter(
patternInterfaceDeclaration.Properties.Single(),
modelInterface.Properties);
// Setup some basic text replacement writer.
var itfNameWriter = new StringReplaceWriter(patternInterfaceDeclaration.Name, modelInterface.Name);
var implNameWriter = new StringReplaceWriter(patternImplementationDeclaration.Name, implName);
// Create the writer selector.
var writerSelector = new WriterSelector(propertyWriter, itfNameWriter, implNameWriter);
// And generate the class implementation.
generator.Generate(writerSelector, (IInterfaceDeclaration)modelInterface, implName);
}
}
public void BasicWriterSelectorTest(bool w1, bool w2, bool expected)
{
var nw1 = SetupNodeWriter(w1, "1");
var nw2 = SetupNodeWriter(w2, "2");
var writerSelector = new WriterSelector(nw1, nw2);
var resText = string.Empty;
var res = writerSelector.SelectAndProcessWriter(null, (s) => resText = s);
Assert.Equal(expected, res);
if (w1)
{
Assert.Equal("1", resText);
}
else if (w2)
{
Assert.Equal("2", resText);
}
else
{
Assert.Equal(string.Empty, resText);
}
}
public void EmptyWriterSelectorTest()
{
var writerSelector = new WriterSelector();
Assert.False(writerSelector.SelectAndProcessWriter(null, (s) => { }));
}
