private void AddExecutingFunctions(FluentInterfaceFile builder)
{
builder.AddLineAfterBlankLine(2, "// Executing functions");
foreach (Method method in _project.ExecutingMethods)
{
builder.AddLineAfterBlankLine(2, $"public {method.ReturnDatatype.Name} {method.Signature}");
builder.AddLine(2, "{");
builder.AddLine(2, "}");
}
}
private static void AddRequiredUsingStatements(FluentInterfaceFile builder, List <string> namespaces)
{
foreach (string ns in namespaces.Distinct().OrderBy(n => n))
{
builder.AddLine(0, $"using {ns};");
}
if (namespaces.Any())
{
builder.AddBlankLine();
}
}
private List <FluentInterfaceFile> CreateInterfaceFiles(InterfaceLocation interfaceLocation)
{
List <FluentInterfaceFile> interfaces = new List <FluentInterfaceFile>();
foreach (InterfaceData interfaceData in _project.Interfaces)
{
FluentInterfaceFile builder =
new FluentInterfaceFile($"{interfaceData.Name}.{_project.OutputLanguage.FileExtension}");
if (interfaceLocation == InterfaceLocation.IndividualFiles)
{
AddRequiredUsingStatements(builder, interfaceData.NamespacesNeeded());
// Start namespace
builder.AddLine(0, $"namespace {_project.FactoryClassNamespace}");
builder.AddLine(0, "{");
}
builder.AddLine(1, $"public interface {interfaceData.Name}");
builder.AddLine(1, "{");
foreach (Method callableMethod in
interfaceData.CallableMethods.Where(cm => cm.Group.IsChainStartingMethod()))
{
InterfaceData returnInterface =
_project.Interfaces
.FirstOrDefault(i => i.CalledByMethods.Exists(cm => cm.Name == callableMethod.Name));
builder.AddLine(2, $"{returnInterface?.Name} {callableMethod.Signature};");
}
foreach (Method callableMethod in
interfaceData.CallableMethods
.Where(cm => cm.Group == Method.MethodGroup.Executing))
{
builder.AddLine(2, $"{callableMethod.ReturnDatatype.Name} {callableMethod.Signature};");
}
builder.AddLine(1, "}");
if (interfaceLocation == InterfaceLocation.IndividualFiles)
{
builder.AddLine(0, "}");
}
interfaces.Add(builder);
}
return(interfaces);
}
private void AddChainingFunctions(FluentInterfaceFile builder)
{
builder.AddLineAfterBlankLine(2, "// Chaining functions");
foreach (Method method in _project.ChainingMethods)
{
InterfaceData returnDataType = ReturnDataTypeForMethod(method);
if (returnDataType != null)
{
builder.AddLineAfterBlankLine(2, $"public {returnDataType.Name} {method.Signature}");
builder.AddLine(2, "{");
builder.AddLine(3, "return this;");
builder.AddLine(2, "}");
}
}
}
private void AddInstantiatingFunctions(FluentInterfaceFile builder)
{
builder.AddLine(2, "// Instantiating functions");
foreach (Method method in _project.InstantiatingMethods)
{
InterfaceData returnDataType = ReturnDataTypeForMethod(method);
if (returnDataType != null)
{
builder.AddLineAfterBlankLine(2, $"public static {returnDataType.Name} {method.Signature}");
builder.AddLine(2, "{");
builder.AddLine(3, $"return new {_project.FactoryClassName}();");
builder.AddLine(2, "}");
}
}
}
private void SaveFluentInterfaceInSingleFile_OnClick(object sender, RoutedEventArgs e)
{
FolderBrowserDialog dialog =
new FolderBrowserDialog
{
Description = Literals.SaveFluentInterfaceInSingleFile,
ShowNewFolderButton = true
};
if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
FluentInterfaceFile fluentInterfaceFile =
_projectEditorViewModel.FluentInterfaceInSingleFile();
File.WriteAllText(Path.Combine(dialog.SelectedPath, fluentInterfaceFile.Name), fluentInterfaceFile.FormattedText());
}
}
private FluentInterfaceFile CreateBuilderFile(InterfaceLocation interfaceLocation)
{
FluentInterfaceFile builder =
new FluentInterfaceFile($"{_project.FactoryClassName}.{_project.OutputLanguage.FileExtension}");
AddRequiredUsingStatements(builder, _project.NamespacesNeeded());
builder.AddLine(0, $"namespace {_project.FactoryClassNamespace}");
builder.AddLine(0, "{");
builder.AddLine(1, $"public class {_project.FactoryClassName} : {_project.InterfaceListAsCommaSeparatedString}");
builder.AddLine(1, "{");
AddInstantiatingFunctions(builder);
AddChainingFunctions(builder);
AddExecutingFunctions(builder);
// Close class
builder.AddLine(1, "}");
// Append interfaces, if single file output
if (interfaceLocation == InterfaceLocation.BuilderFile)
{
builder.AddLineAfterBlankLine(1, "// Interfaces");
foreach (FluentInterfaceFile interfaceFile in
CreateInterfaceFiles(InterfaceLocation.BuilderFile))
{
builder.AddLineAfterBlankLine(0, interfaceFile.FormattedText());
}
}
// Close namespace
builder.AddLine(0, "}");
return(builder);
}
public void Test_CreateEmailBuilderFluentInterfaceFiles()
{
ProjectEditorViewModel vm = CreateCSharpProjectEditorViewModel();
// Set project properties
vm.CurrentProject.Name = "Email";
vm.CurrentProject.FactoryClassNamespace = "Engine";
// Add instantiating method(s)
vm.MethodUnderEdit.Group = Method.MethodGroup.Instantiating;
vm.MethodUnderEdit.Name = "CreateEmailFrom";
vm.SetMethodParameterPropertiesTo("string", "emailAddress");
vm.AddNewMethod();
// Add chaining method(s)
vm.MethodUnderEdit.Group = Method.MethodGroup.Chaining;
vm.MethodUnderEdit.Name = "To";
vm.SetMethodParameterPropertiesTo("string", "emailAddress");
vm.AddNewMethod();
vm.MethodUnderEdit.Group = Method.MethodGroup.Chaining;
vm.MethodUnderEdit.Name = "Subject";
vm.SetMethodParameterPropertiesTo("string", "subject");
vm.AddNewMethod();
vm.MethodUnderEdit.Group = Method.MethodGroup.Chaining;
vm.MethodUnderEdit.Name = "Body";
vm.SetMethodParameterPropertiesTo("string", "body");
vm.AddNewMethod();
// Add executing method(s)
vm.MethodUnderEdit.Group = Method.MethodGroup.Executing;
vm.MethodUnderEdit.Name = "Send";
vm.MethodUnderEdit.ReturnDatatype = vm.DatatypeOf("void");
vm.AddNewMethod();
// Set callable methods
vm.SetCallableMethods("CreateEmailFrom", "To");
vm.SetCallableMethods("To", "To");
vm.SetCallableMethods("To", "Subject");
vm.SetCallableMethods("Subject", "Body");
vm.SetCallableMethods("Body", "Send");
vm.RefreshInterfaces();
// Name interfaces
vm.CurrentProject.Interfaces.Count.ShouldBe(4);
vm.SetInterfaceName("Chaining:To", "ICanSetTo");
vm.SetInterfaceName("Chaining:Subject|Chaining:To", "ICanSetToOrSubject");
vm.SetInterfaceName("Chaining:Body", "ICanSetBody");
vm.SetInterfaceName("Executing:Send", "ICanSend");
// Perform tests
vm.CurrentProject.OutputLanguage.Name.ShouldBe("C#");
vm.CurrentProject.FactoryClassName.ShouldBe("EmailBuilder");
vm.CurrentProject.InstantiatingMethods.Count.ShouldBe(1);
vm.CurrentProject.ChainingMethods.Count.ShouldBe(3);
vm.CurrentProject.ExecutingMethods.Count.ShouldBe(1);
IFluentInterfaceCreator creator =
FluentInterfaceCreatorFactory.GetFluentInterfaceFileCreator(vm.CurrentProject);
// Test single file matches expected output
FluentInterfaceFile singleFile = creator.CreateInSingleFile();
singleFile.Name.ShouldBe("EmailBuilder.cs");
singleFile.FormattedText().ShouldBe(TextIn("SingleFile.EmailBuilder.txt"));
// Test multiple file matches expected output
IEnumerable <FluentInterfaceFile> multipleFiles = creator.CreateInMultipleFiles().ToList();
multipleFiles.Count().ShouldBe(5);
multipleFiles.First(x => x.Name == "EmailBuilder.cs")
.FormattedText().ShouldBe(TextIn("MultipleFiles.EmailBuilder.txt"));
multipleFiles.First(x => x.Name == "ICanSetTo.cs")
.FormattedText().ShouldBe(TextIn("MultipleFiles.ICanSetTo.txt"));
multipleFiles.First(x => x.Name == "ICanSetToOrSubject.cs")
.FormattedText().ShouldBe(TextIn("MultipleFiles.ICanSetToOrSubject.txt"));
multipleFiles.First(x => x.Name == "ICanSetBody.cs")
.FormattedText().ShouldBe(TextIn("MultipleFiles.ICanSetBody.txt"));
multipleFiles.First(x => x.Name == "ICanSend.cs")
.FormattedText().ShouldBe(TextIn("MultipleFiles.ICanSend.txt"));
}
