/// <summary>
/// Creates a new printable document
/// </summary>
/// <param name="title">The titel of the document</param>
/// <returns>Created document</returns>
public virtual T Create(string title)
{
IPrintableDocument document = _defaultDocumentBuilder.Build <T>();
document.Title = title;
return((T)document);
}
public void CreateOverview_WithTargetContainingXmlExampleHelp_ShouldCallCreationForNewChapterNamedExample()
{
string exampleStringContent = "<TestXml>Content</TestXml>";
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
Mock <IPrintableDocumentChapter> chapterMock = new Mock <IPrintableDocumentChapter>();
Mock <IPrintableDocumentCodeBlock> codeBlockMock = new Mock <IPrintableDocumentCodeBlock>();
Mock <ITestPrintable> testPrintableMock = new Mock <ITestPrintable>();
chapterMock.Setup(cm => cm.AddNewContent <IPrintableDocumentCodeBlock>()).Returns(codeBlockMock.Object);
testPrintableMock.Setup(tpm => tpm.AddNewChapter(It.Is <string>(s => s == "Example")))
.Returns(chapterMock.Object);
IMsBuildElementHelp elementHelpMock = MsBuildTestDataBuilder.Create <IMsBuildTarget>()
.SetName("TargetA")
.WithHelp()
.AddHelpParagraph("EXAMPLE", exampleStringContent)
.Build();
targetMock.Setup(tm => tm.Help).Returns(elementHelpMock);
Mock <PrintableDocument <ITestPrintable> > printableDocumentMock =
new Mock <PrintableDocument <ITestPrintable> >();
printableDocumentMock.Setup(pdm => pdm.Create(It.IsAny <string>())).Returns(testPrintableMock.Object);
TargetOverviewSiteGenerator <ITestPrintable> targetOverviewSiteGenerator =
new TargetOverviewSiteGenerator <ITestPrintable>(printableDocumentMock.Object);
IPrintableDocument printableDocument = targetOverviewSiteGenerator.CreateOverview(targetMock.Object);
testPrintableMock.Verify(tpm => tpm.AddNewChapter(It.Is <string>(s => s == "Example")), Times.Exactly(1));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="file">File object representing the msbuild project file</param>
/// <param name="documentBuilder">Factory for creating the output documentation file</param>
public ProjectOverviewGenerator(IFile file, IFormattableDocumentBuilder documentBuilder)
{
_printableDocumentBuilder = new PrintableDocument <T>(documentBuilder);
_msBuildProject = LoadMsBuildProject(file);
_outputDocument = CreateOutputDocument(file, _printableDocumentBuilder);
}
CreateOverview_WithOneProperlyNamedTarget_ShouldCallCreationOfNewDocumentWithTitleMatchingTheTargetName()
{
#region 1) Arrange
Mock <IMsBuildElementHelp> elementHelpMock = new Mock <IMsBuildElementHelp>();
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
targetMock.Setup(t => t.Name).Returns("TargetA");
targetMock.Setup(t => t.Help).Returns(elementHelpMock.Object);
Mock <IMarkdownDocument> markdownDocumentMock = new Mock <IMarkdownDocument>();
markdownDocumentMock.Setup(md => md.DefaultFileExtension).Returns("md");
Mock <PrintableDocument <IMarkdownDocument> > printableDocumentMock =
new Mock <PrintableDocument <IMarkdownDocument> >();
printableDocumentMock.Setup(pd => pd.Create(It.IsAny <string>()))
.Returns(markdownDocumentMock.Object);
TargetOverviewSiteGenerator <IMarkdownDocument> markdownTargetDocumentGenerator =
new TargetOverviewSiteGenerator <IMarkdownDocument>(printableDocumentMock.Object);
#endregion
// 2) Act
IPrintableDocument document = markdownTargetDocumentGenerator.CreateOverview(targetMock.Object);
// 3) Assert
printableDocumentMock.Verify(pd => pd.Create(
It.Is <string>(s => s.Equals("TargetA"))), Times.Exactly(1));
}
/// <summary>
/// Append a section to the documentation containing the targets error handling by using the
/// MsBuild Task "OnError". The task is read from the target content if exists.
/// </summary>
/// <param name="targetOverviewDocument">Document the section should be appended to.</param>
/// <param name="target">The target for which the section should be created.</param>
private void AppendErrorHandlingSection(IPrintableDocument targetOverviewDocument,
IMsBuildTarget target)
{
if (target.OnErrorTargets == null ||
target.OnErrorTargets?.Count == 0)
{
return;
}
IPrintableDocumentChapter errorHandlingChapter =
targetOverviewDocument.AddNewChapter("Error Handling");
IPrintableDocumentChapterStringContent chapterContent =
errorHandlingChapter.AddNewContent <IPrintableDocumentChapterStringContent>();
StringBuilder builder = new StringBuilder();
builder.AppendLine(
string.Format(CultureInfo.InvariantCulture,
"This chapter contains an description of the error handling of this target. All listed targets are executed after an error occured in the target {0}.",
target.Name)
);
builder.AppendLine();
foreach (var onErrorTarget in target.OnErrorTargets)
{
builder.AppendLine(string.Format(CultureInfo.InvariantCulture, " - {0}", onErrorTarget));
}
chapterContent.Content = builder.ToString();
}
/// <summary>
/// Append a section to the documentation containing the targets parameters by using the
/// xml based help. Therefore the help section "Parameter" is used.
/// </summary>
/// <param name="targetOverviewDocument">Document the section should be appended to.</param>
/// <param name="target">The target for which the section should be created.</param>
private void AppendParameterSection(IPrintableDocument targetOverviewDocument, IMsBuildTarget target)
{
if (!target.Help.ContainsSection(MsBuildHelpSections.Parameter,
StringComparison.OrdinalIgnoreCase))
{
return;
}
IPrintableDocumentChapter parameterChapter = targetOverviewDocument.AddNewChapter("Parameters");
foreach (IMsBuildElementHelpParagraph parameterHelpParagraph in
target.Help.LookUp(MsBuildHelpSections.Parameter, StringComparison.OrdinalIgnoreCase))
{
IPrintableDocumentParagraph parameterParagraph =
parameterChapter.AddNewParagraph(
string.Format(CultureInfo.InvariantCulture, "Parameter {0}",
parameterHelpParagraph.Additional)
);
IPrintableDocumentChapterStringContent parameterSectionBody =
parameterParagraph.AddNewContent <IPrintableDocumentChapterStringContent>();
parameterSectionBody.Content = parameterHelpParagraph.Content;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="project">MsBuild-Project file to generate the documentation for</param>
/// <param name="file">File object representing the msbuild project file</param>
/// <param name="printableDocument">Object representing output documentation file</param>
public ProjectOverviewGenerator(IMsBuildProject project, IFile file, PrintableDocument <T> printableDocument)
{
_msBuildProject = project;
_printableDocumentBuilder = printableDocument;
_outputDocument = CreateOutputDocument(file, _printableDocumentBuilder);
}
public void Build_WithInterfaceFormattableDocument_ShouldReturnInstanceOfTestPrintableDocument()
{
FormattableDocumentDefaultBuilder defaultBuilder = new FormattableDocumentDefaultBuilder();
IPrintableDocument returnType = defaultBuilder.Build <IPrintableDocument>();
Assert.IsInstanceOfType(returnType, typeof(TestPrintableDocument));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="project">MsBuild-Project file to generate the documentation for</param>
/// <param name="file">File object representing the msbuild project file</param>
public ProjectOverviewGenerator(IMsBuildProject project, IFile file)
{
_msBuildProject = project;
_printableDocumentBuilder = new PrintableDocument <T>(new FileWriter());
_outputDocument = CreateOutputDocument(file, _printableDocumentBuilder);
}
protected void Prepare(IPrintableDocument document)
{
if (document.PrintType == PrinterType.RDL)
{
Report report = GetReportFromFile(document.GetReportInfo());
report.RunGetData(document.GetReportInfo().Parameters);
reportPages.Add(report.BuildPages());
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="file">File object representing the msbuild project file</param>
public ProjectOverviewGenerator(IFile file)
{
var formattableDocumentBuilder = new PrintableDocument <T>();
_msBuildProject = LoadMsBuildProject(file);
_outputDocument = CreateOutputDocument(file, formattableDocumentBuilder);
_printableDocumentBuilder = formattableDocumentBuilder;
}
/// <summary>
/// Saves the created target documentation to the given output directory by creating
/// a sub directory named like the target.
/// </summary>
/// <param name="targetOutputPath">Directory in which the documentation should be stored in</param>
/// <param name="targetName">The name of the target</param>
/// <param name="targetDocument">The target documentation document</param>
/// <exception cref="IOException">The documentation could not be saved</exception>
private void SaveTargetDocumentation(string targetOutputPath,
string targetName, IPrintableDocument targetDocument)
{
if (!_printableDocument.Save(
Path.Combine(targetOutputPath, string.Format(CultureInfo.InvariantCulture, "{0}.{1}",
targetName, targetDocument.DefaultFileExtension)),
targetDocument))
{
throw new IOException("File could not be saved!");
}
}
CreateOverview_WithTargetContainingTwoParameterDescriptionsAsHelpContent_ShouldAppendTwoParameterSectionsWithParameterName()
{
#region 1) Arrange
string targetDescriptionText = "This is the target parameter";
IMsBuildElementHelp help = MsBuildTestDataBuilder.Create <IMsBuildTarget>()
.SetName("TargetA")
.WithHelp()
.AddHelpParagraph("PARAMETER", targetDescriptionText, "$(ParamPropertyOne)")
.AddHelpParagraph("PARAMETER", targetDescriptionText, "$(ParamPropertyTwo)")
.Build();
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
targetMock.Setup(t => t.Name).Returns("TargetA");
targetMock.Setup(t => t.Help).Returns(help);
Mock <IPrintableDocumentChapterStringContent> chapterContentMock =
new Mock <IPrintableDocumentChapterStringContent>();
chapterContentMock.SetupSet(cc => cc.Content = It.IsAny <string>()).Verifiable();
Mock <IPrintableDocumentParagraph> paragraphMock = new Mock <IPrintableDocumentParagraph>();
Mock <IPrintableDocumentChapter> chapterMock = new Mock <IPrintableDocumentChapter>();
chapterMock.Setup(c => c.AddNewParagraph(It.IsAny <string>())).Returns(paragraphMock.Object);
paragraphMock.Setup(p => p.AddNewContent <IPrintableDocumentChapterStringContent>())
.Returns(chapterContentMock.Object);
Mock <IMarkdownDocument> markdownDocumentMock = new Mock <IMarkdownDocument>();
markdownDocumentMock.Setup(md => md.DefaultFileExtension).Returns("md");
markdownDocumentMock.Setup(md => md.AddNewChapter(It.IsAny <string>())).Returns(chapterMock.Object);
Mock <PrintableDocument <IMarkdownDocument> > printableDocumentMock =
new Mock <PrintableDocument <IMarkdownDocument> >();
printableDocumentMock.Setup(pd => pd.Create(It.IsAny <string>()))
.Returns(markdownDocumentMock.Object);
TargetOverviewSiteGenerator <IMarkdownDocument> markdownTargetDocumentGenerator =
new TargetOverviewSiteGenerator <IMarkdownDocument>(printableDocumentMock.Object);
#endregion
// 2) Act
IPrintableDocument document = markdownTargetDocumentGenerator.CreateOverview(targetMock.Object);
// 3) Assert
chapterMock.Verify(
cm => cm.AddNewParagraph(It.Is <string>(s => s.Equals("Parameter $(ParamPropertyOne)"))),
Times.Exactly(1));
chapterMock.Verify(
cm => cm.AddNewParagraph(It.Is <string>(s => s.Equals("Parameter $(ParamPropertyTwo)"))),
Times.Exactly(1));
}
private PrintDocument GetPrintDocument()
{
IPrintableDocument printableDocument = m_contextRegistry.GetActiveContext <IPrintableDocument>();
PrintDocument result = printableDocument.GetPrintDocument();
if (result == null)
{
throw new InvalidOperationException("Printable documents must produce a PrintDocument");
}
return(result);
}
CreateOverview_WithTargetDependingOnTwoOtherTargets_ShouldAddBothTargetsToTheTableWithCorrectDependencyType()
{
IList <string> dependsOnTargetList = new List <string>()
{
"TargetB", "TargetC"
};
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
Mock <IPrintableDocumentChapter> chapterMock = new Mock <IPrintableDocumentChapter>();
Mock <IPrintableParagraphTable> tableMock = new Mock <IPrintableParagraphTable>();
Mock <ITestPrintable> testPrintableMock = new Mock <ITestPrintable>();
Mock <IMsBuildElementHelp> helpMock = new Mock <IMsBuildElementHelp>();
chapterMock.Setup(cm => cm.AddNewContent <IPrintableParagraphTable>()).Returns(tableMock.Object);
testPrintableMock.Setup(tpm => tpm.AddNewChapter(It.Is <string>(s => s == "Target Dependencies")))
.Returns(chapterMock.Object);
tableMock.Setup(tm => tm.WithHeaders(
It.Is <string>(s => s == "Target"),
It.Is <string>(s => s == "Dependency Type"),
It.Is <string>(s => s == "Dependency Description")))
.Returns(tableMock.Object);
targetMock.Setup(tm => tm.DependsOnTargets).Returns(dependsOnTargetList);
targetMock.Setup(tm => tm.Name).Returns("TargetA");
targetMock.Setup(tm => tm.Help).Returns(helpMock.Object);
targetMock.Setup(tm => tm.HasTargetDependencies).Returns(true);
targetMock.Setup(tm => tm.AfterTargets).Returns(new List <string>());
targetMock.Setup(tm => tm.BeforeTargets).Returns(new List <string>());
Mock <PrintableDocument <ITestPrintable> > printableDocumentMock =
new Mock <PrintableDocument <ITestPrintable> >();
printableDocumentMock.Setup(pdm => pdm.Create(It.IsAny <string>())).Returns(testPrintableMock.Object);
TargetOverviewSiteGenerator <ITestPrintable> targetOverviewSiteGenerator =
new TargetOverviewSiteGenerator <ITestPrintable>(printableDocumentMock.Object);
IPrintableDocument printableDocument = targetOverviewSiteGenerator.CreateOverview(targetMock.Object);
tableMock.Verify(tm => tm.WithRow(
It.Is <string>(s => s == "TargetB"),
It.Is <string>(s => s == "DependsOnTargets"),
It.IsAny <string>()),
Times.Exactly(1));
tableMock.Verify(tm => tm.WithRow(
It.Is <string>(s => s == "TargetC"),
It.Is <string>(s => s == "DependsOnTargets"),
It.IsAny <string>()),
Times.Exactly(1));
}
protected void Prepare(IPrintableDocument document)
{
if (document.PrintType == PrinterType.RDL)
{
var rdlDoc = document as IPrintableRDLDocument;
rdlDoc.Parameters = new Dictionary <object, object> {
{ "IsBatchPrint", true }
};
Report report = GetReportFromFileOrMemory(rdlDoc.GetReportInfo());
report.RunGetData(rdlDoc.GetReportInfo().Parameters);
reportPages.Add(report.BuildPages());
}
}
/// <summary>
/// Creates the documentation body content for the given MsBuild target
/// </summary>
/// <param name="target">The target for which the documentation should be generated.</param>
/// <returns>Document representing the generated documentation</returns>
public IPrintableDocument CreateOverview(IMsBuildTarget target)
{
IPrintableDocument targetOverviewDocument = _printableDocument.Create(target.Name);
AppendDescriptionSection(targetOverviewDocument, target);
AppendParameterSection(targetOverviewDocument, target);
AppendOutputSection(targetOverviewDocument, target);
AppendDependencySection(targetOverviewDocument, target);
AppendErrorHandlingSection(targetOverviewDocument, target);
AppendExampleSection(targetOverviewDocument, target);
return(targetOverviewDocument);
}
void IPrintService.PreviewDocument(IPrintableDocument document)
{
IUIService service = (IUIService) this._serviceProvider.GetService(typeof(IUIService));
PrintDocument document2 = document.CreatePrintDocument();
document2.DefaultPageSettings = this.PageSettings;
Microsoft.Matrix.Core.UserInterface.PrintPreviewDialog form = new Microsoft.Matrix.Core.UserInterface.PrintPreviewDialog(this._serviceProvider, document2);
if (service != null)
{
service.ShowDialog(form);
}
else
{
form.ShowDialog();
}
}
public void Save_WithPathFromPrintableDocument_CallFileWriterSaveWithCorrectPath()
{
var outPath = "/usr/desktop";
var fileWriterMock = new Mock <IFileWriter>();
var document =
new PrintableDocument <ITestPrintableDocument>(fileWriterMock.Object);
IPrintableDocument formattableDocument = document.Create("Title");
document.Save(outPath, formattableDocument);
fileWriterMock.Verify(fw => fw.WriteAllText(It.Is <string>(s => s.Equals(outPath)), It.IsAny <string>()));
}
/// <summary>
/// Creates the documentation for each of the given targets.
/// </summary>
/// <param name="outputPath">Directory in which the documentation is stored in</param>
/// <param name="targets">List of targets to create the documentation for</param>
private void CreateTargetDocumentation(string outputPath, IEnumerable <IMsBuildTarget> targets)
{
TargetOverviewSiteGenerator <T> targetOverviewDocumentationGenerator =
new TargetOverviewSiteGenerator <T>(_printableDocument);
string targetOutputPath = Path.Combine(outputPath, "Targets");
PrepareOutputDirectory(targetOutputPath);
Parallel.ForEach(targets, target =>
{
IPrintableDocument targetDocument = targetOverviewDocumentationGenerator.CreateOverview(target);
SaveTargetDocumentation(targetOutputPath, target.Name, targetDocument);
});
}
public void CreateOverview_WithTargetContainingDescriptionAsHelpContent_ShouldSetCorrectDescriptionContent()
{
#region 1) Arrange
string targetDescriptionText = "This is the target description";
IMsBuildElementHelp help = MsBuildTestDataBuilder.Create <IMsBuildTarget>()
.SetName("TargetA")
.WithHelp()
.AddHelpParagraph("DESCRIPTION", targetDescriptionText, "$(ParamPropertyOne)")
.Build();
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
targetMock.Setup(t => t.Name).Returns("TargetA");
targetMock.Setup(t => t.Help).Returns(help);
Mock <IPrintableDocumentChapterStringContent> chapterContentMock =
new Mock <IPrintableDocumentChapterStringContent>();
chapterContentMock.SetupSet(cc => cc.Content = It.IsAny <string>()).Verifiable();
Mock <IPrintableDocumentChapter> chapterMock = new Mock <IPrintableDocumentChapter>();
chapterMock.Setup(c => c.AddNewContent <IPrintableDocumentChapterStringContent>())
.Returns(chapterContentMock.Object);
Mock <IMarkdownDocument> markdownDocumentMock = new Mock <IMarkdownDocument>();
markdownDocumentMock.Setup(md => md.DefaultFileExtension).Returns("md");
markdownDocumentMock.Setup(md => md.AddNewChapter(It.IsAny <string>())).Returns(chapterMock.Object);
Mock <PrintableDocument <IMarkdownDocument> > printableDocumentMock =
new Mock <PrintableDocument <IMarkdownDocument> >();
printableDocumentMock.Setup(pd => pd.Create(It.IsAny <string>()))
.Returns(markdownDocumentMock.Object);
TargetOverviewSiteGenerator <IMarkdownDocument> markdownTargetDocumentGenerator =
new TargetOverviewSiteGenerator <IMarkdownDocument>(printableDocumentMock.Object);
#endregion
// 2) Act
IPrintableDocument document = markdownTargetDocumentGenerator.CreateOverview(targetMock.Object);
// 3) Assert
chapterContentMock.VerifySet(cc => cc.Content = It.Is <string>(
s => s.Trim().Equals(targetDescriptionText)));
}
/// <summary>
/// Append a section to the documentation containing the targets description by using
/// the xml based help. Therefore the help section "Description" is used.
/// </summary>
/// <param name="targetOverviewDocument">Document the section should be appended to.</param>
/// <param name="target">The target for which the section should be created.</param>
private void AppendDescriptionSection(IPrintableDocument targetOverviewDocument, IMsBuildTarget target)
{
if (!target.Help.ContainsSection(MsBuildHelpSections.Description, StringComparison.OrdinalIgnoreCase)
)
{
return;
}
string descriptionContent = target.Help.GetSectionContent(
MsBuildHelpSections.Description, StringComparison.OrdinalIgnoreCase
);
IPrintableDocumentChapter descriptionChapter = targetOverviewDocument.AddNewChapter("Description");
IPrintableDocumentChapterStringContent descriptionChapterContent =
descriptionChapter.AddNewContent <IPrintableDocumentChapterStringContent>();
descriptionChapterContent.Content = string.Join(Environment.NewLine, descriptionContent);
}
/// <summary>
/// Checks whether the client can do the command, if it handles it</summary>
/// <param name="commandTag">Command to be done</param>
/// <returns>True iff client can do the command</returns>
bool ICommandClient.CanDoCommand(object commandTag)
{
bool enabled = false;
if (commandTag is StandardCommand)
{
switch ((StandardCommand)commandTag)
{
case StandardCommand.PrintPreview:
case StandardCommand.PageSetup:
case StandardCommand.Print:
IPrintableDocument printableDocument = m_contextRegistry.GetActiveContext <IPrintableDocument>();
enabled = printableDocument != null;
break;
}
}
return(enabled);
}
CreateOverview_WithTargetContainingDescriptionAsHelpContent_ShouldCallCreationOfNewDocumentChapterNamedDescription()
{
#region 1) Arrange
IMsBuildElementHelp help = MsBuildTestDataBuilder.Create <IMsBuildTarget>()
.SetName("TargetA")
.WithHelp()
.AddHelpParagraph("DESCRIPTION", "This is a target description", "$(ParamPropertyOne)")
.Build();
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
targetMock.Setup(t => t.Name).Returns("TargetA");
targetMock.Setup(t => t.Help).Returns(help);
Mock <IPrintableDocumentChapterStringContent> chapterContentMock =
new Mock <IPrintableDocumentChapterStringContent>();
Mock <IPrintableDocumentChapter> chapterMock = new Mock <IPrintableDocumentChapter>();
chapterMock.Setup(c => c.AddNewContent <IPrintableDocumentChapterStringContent>())
.Returns(chapterContentMock.Object);
Mock <IMarkdownDocument> markdownDocumentMock = new Mock <IMarkdownDocument>();
markdownDocumentMock.Setup(md => md.DefaultFileExtension).Returns("md");
markdownDocumentMock.Setup(md => md.AddNewChapter(It.IsAny <string>())).Returns(chapterMock.Object);
Mock <PrintableDocument <IMarkdownDocument> > printableDocumentMock =
new Mock <PrintableDocument <IMarkdownDocument> >();
printableDocumentMock.Setup(pd => pd.Create(It.IsAny <string>()))
.Returns(markdownDocumentMock.Object);
TargetOverviewSiteGenerator <IMarkdownDocument> markdownTargetDocumentGenerator =
new TargetOverviewSiteGenerator <IMarkdownDocument>(printableDocumentMock.Object);
#endregion
// 2) Act
IPrintableDocument document = markdownTargetDocumentGenerator.CreateOverview(targetMock.Object);
// 3) Assert
markdownDocumentMock.Verify(md => md.AddNewChapter(
It.Is <string>(s => s.Equals("Description", StringComparison.OrdinalIgnoreCase))), Times.Exactly(1));
}
CreateOverview_WithTargetContainingErrorHandling_ShouldInitializeChapterContentContainingNameOfTheOnErrorTarget()
{
IList <string> onErrorTargets = new List <string>()
{
"OnErrorTarget"
};
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
Mock <IPrintableDocumentChapter> chapterMock = new Mock <IPrintableDocumentChapter>();
Mock <IPrintableDocumentChapterStringContent> chapterStringMock =
new Mock <IPrintableDocumentChapterStringContent>();
Mock <ITestPrintable> testPrintableMock = new Mock <ITestPrintable>();
Mock <IMsBuildElementHelp> helpMock = new Mock <IMsBuildElementHelp>();
chapterMock.Setup(cm => cm.AddNewContent <IPrintableDocumentChapterStringContent>())
.Returns(chapterStringMock.Object);
chapterStringMock.SetupAllProperties();
testPrintableMock.Setup(tpm => tpm.AddNewChapter(It.Is <string>(s => s == "Error Handling")))
.Returns(chapterMock.Object);
targetMock.Setup(tm => tm.Name).Returns("TargetA");
targetMock.Setup(tm => tm.Help).Returns(helpMock.Object);
targetMock.Setup(tm => tm.HasTargetDependencies).Returns(false);
targetMock.Setup(tm => tm.AfterTargets).Returns(new List <string>());
targetMock.Setup(tm => tm.BeforeTargets).Returns(new List <string>());
targetMock.Setup(tm => tm.DependsOnTargets).Returns(new List <string>());
targetMock.Setup(tm => tm.OnErrorTargets).Returns(onErrorTargets);
Mock <PrintableDocument <ITestPrintable> > printableDocumentMock =
new Mock <PrintableDocument <ITestPrintable> >();
printableDocumentMock.Setup(pdm => pdm.Create(It.IsAny <string>())).Returns(testPrintableMock.Object);
TargetOverviewSiteGenerator <ITestPrintable> targetOverviewSiteGenerator =
new TargetOverviewSiteGenerator <ITestPrintable>(printableDocumentMock.Object);
IPrintableDocument printableDocument = targetOverviewSiteGenerator.CreateOverview(targetMock.Object);
Assert.IsTrue(chapterStringMock.Object.Content.Contains("OnErrorTarget"));
}
/// <summary>
/// Append a section to the documentation containing the targets examples by using the
/// xml based help. Therefore all examples are appended a code block.
/// </summary>
/// <param name="targetOverviewDocument">Document the section should be appended to.</param>
/// <param name="target">The target for which the section should be created.</param>
private void AppendExampleSection(IPrintableDocument targetOverviewDocument,
IMsBuildTarget target)
{
if (target.Help.ContainsSection(MsBuildHelpSections.Example, StringComparison.OrdinalIgnoreCase) == false)
{
return;
}
foreach (IMsBuildElementHelpParagraph exampleHelpParagraph in target.Help.LookUp(
MsBuildHelpSections.Example, StringComparison.OrdinalIgnoreCase))
{
IPrintableDocumentChapter exampleChapter =
targetOverviewDocument.AddNewChapter(MsBuildHelpSections.Example);
IPrintableDocumentCodeBlock exampleCodeBlock =
exampleChapter.AddNewContent <IPrintableDocumentCodeBlock>();
var codeBlock = MsBuildElementHelpCodeBlockUtility.Parse(exampleHelpParagraph.Content);
exampleCodeBlock.AppendContentLine(codeBlock.Content);
exampleCodeBlock.SetLanguage(codeBlock.Language.ToString());
}
}
/// <summary>
/// Append a section to the documentation containing the targets outputs by using the
/// xml based help. Therefore the help section "Outputs" is used.
/// </summary>
/// <param name="targetOverviewDocument">Document the section should be appended to.</param>
/// <param name="target">The target for which the section should be created.</param>
private void AppendOutputSection(IPrintableDocument targetOverviewDocument, IMsBuildTarget target)
{
if (!target.Help.ContainsSection(MsBuildHelpSections.Outputs,
StringComparison.OrdinalIgnoreCase))
{
return;
}
foreach (IMsBuildElementHelpParagraph outputsHelpParagraph in
target.Help.LookUp(MsBuildHelpSections.Outputs, StringComparison.OrdinalIgnoreCase))
{
IPrintableDocumentChapter parameterChapter =
targetOverviewDocument.AddNewChapter(
string.Format(CultureInfo.InvariantCulture, "Outputs {0}",
outputsHelpParagraph.Additional)
);
IPrintableDocumentChapterStringContent outputsSectionBody =
parameterChapter.AddNewContent <IPrintableDocumentChapterStringContent>();
outputsSectionBody.Content = outputsHelpParagraph.Content;
}
}
CreateOverview_WithTargetContainingTwoXmlExampleHelps_ShouldAppendContentToBothCreatedPrintableCodeBlock()
{
string exampleStringContentOne = "<TestXml>Content</TestXml>";
string exampleStringContentTwo = "<TestXml>AnotherContent</TestXml>";
Mock <IMsBuildTarget> targetMock = new Mock <IMsBuildTarget>();
Mock <IPrintableDocumentChapter> chapterMock = new Mock <IPrintableDocumentChapter>();
Mock <IPrintableDocumentCodeBlock> codeBlockMock = new Mock <IPrintableDocumentCodeBlock>();
Mock <ITestPrintable> testPrintableMock = new Mock <ITestPrintable>();
chapterMock.Setup(cm => cm.AddNewContent <IPrintableDocumentCodeBlock>()).Returns(codeBlockMock.Object);
testPrintableMock.Setup(tpm => tpm.AddNewChapter(It.Is <string>(s => s == "Example")))
.Returns(chapterMock.Object);
IMsBuildElementHelp elementHelpMock = MsBuildTestDataBuilder.Create <IMsBuildTarget>()
.SetName("TargetA")
.WithHelp()
.AddHelpParagraph("EXAMPLE", exampleStringContentOne)
.AddHelpParagraph("EXAMPLE", exampleStringContentTwo)
.Build();
targetMock.Setup(tm => tm.Help).Returns(elementHelpMock);
Mock <PrintableDocument <ITestPrintable> > printableDocumentMock =
new Mock <PrintableDocument <ITestPrintable> >();
printableDocumentMock.Setup(pdm => pdm.Create(It.IsAny <string>())).Returns(testPrintableMock.Object);
TargetOverviewSiteGenerator <ITestPrintable> targetOverviewSiteGenerator =
new TargetOverviewSiteGenerator <ITestPrintable>(printableDocumentMock.Object);
IPrintableDocument printableDocument = targetOverviewSiteGenerator.CreateOverview(targetMock.Object);
codeBlockMock.Verify(cbm => cbm.AppendContentLine(It.IsAny <string>()), Times.Exactly(2));
codeBlockMock.Verify(cbm => cbm.AppendContentLine(exampleStringContentOne), Times.Once);
codeBlockMock.Verify(cbm => cbm.AppendContentLine(exampleStringContentTwo), Times.Once);
}
/// <summary>
/// Append a section to the documentation containing the targets dependencies by using the
/// MsBuild target attributes. Therefore all dependencies like "AfterTargets", "BeforeTargets"
/// and "DependsOnTargets" are appended as a paragraph table.
/// </summary>
/// <param name="targetOverviewDocument">Document the section should be appended to.</param>
/// <param name="target">The target for which the section should be created.</param>
private void AppendDependencySection(IPrintableDocument targetOverviewDocument,
IMsBuildTarget target)
{
if (target.HasTargetDependencies == false)
{
return;
}
IPrintableDocumentChapter dependencyChapter =
targetOverviewDocument.AddNewChapter("Target Dependencies");
IPrintableParagraphTable dependencyTable =
dependencyChapter.AddNewContent <IPrintableParagraphTable>()
.WithHeaders("Target", "Dependency Type", "Dependency Description");
foreach (var dependentOnTarget in target.DependsOnTargets)
{
dependencyTable.WithRow(dependentOnTarget, "DependsOnTargets",
string.Format(CultureInfo.InvariantCulture,
"Calls the target {0} before execution of {1}.", dependentOnTarget, target.Name));
}
foreach (var afterTarget in target.AfterTargets)
{
dependencyTable.WithRow(afterTarget, "AfterTargets",
string.Format(CultureInfo.InvariantCulture,
"Runs the target {0} after the execution of {1} has finished.", target.Name, afterTarget));
}
foreach (var beforeTargets in target.BeforeTargets)
{
dependencyTable.WithRow(beforeTargets, "BeforeTargets",
string.Format(CultureInfo.InvariantCulture,
"Runs the target {0} before the execution of {1} starts.", target.Name, beforeTargets));
}
}
void IDocumentManager.PrintPreviewDocument(IPrintableDocument document)
{
if (document == null)
{
throw new ArgumentNullException("document");
}
IPrintService service = (IPrintService) this._serviceProvider.GetService(typeof(IPrintService));
if (service != null)
{
service.PreviewDocument(document);
}
}
public static QSTDI.TdiTabBase GetPreviewTab(IPrintableDocument document)
{
return new QSReport.ReportViewDlg (document.GetReportInfoForPreview());
}
public static void Print(IPrintableDocument document)
{
PrintAll(new IPrintableDocument[]{ document });
}
void IPrintService.PrintDocument(IPrintableDocument document)
{
PrintDocument document2 = document.CreatePrintDocument();
document2.DefaultPageSettings = this.PageSettings;
PrintDialog dialog = new PrintDialog();
dialog.Document = document2;
if (dialog.ShowDialog() == DialogResult.OK)
{
document2.Print();
}
}
public void Print(IPrintableDocument document)
{
PrintAll(new IPrintableDocument[] { document });
}
/// <summary>
/// Saves the given document to the file system
/// </summary>
/// <param name="path">Name of the output file</param>
/// <param name="document">Document that should be saved</param>
/// <returns>True if the document could be saved</returns>
public virtual bool Save(string path, IPrintableDocument document)
{
return(_defaultFileWriter.WriteAllText(path, document.Print()));
}
