internal static void AddError(
string error,
MarkdownProcessingContext context)
{
Console.ForegroundColor = ConsoleColor.Red;
context.Errors.Add(error);
context.Console.Out.WriteLine(error);
}
private static void VerifyAnnotationReferences(
AnnotatedCodeBlock annotatedCodeBlock,
IDirectoryAccessor markdownFileDir,
IConsole console,
MarkdownProcessingContext context)
{
Console.ResetColor();
console.Out.WriteLine(" Checking Markdown...");
var diagnostics = annotatedCodeBlock.Diagnostics.ToArray();
var hasDiagnostics = diagnostics.Any();
if (hasDiagnostics)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
}
if (annotatedCodeBlock.Annotations is LocalCodeBlockAnnotations annotations)
{
var file = annotations?.SourceFile ?? annotations?.DestinationFile;
var fullyQualifiedPath = file != null
? markdownFileDir.GetFullyQualifiedPath(file).FullName
: "UNKNOWN";
var project = annotatedCodeBlock.ProjectOrPackageName() ?? "UNKNOWN";
var symbol = hasDiagnostics
? "X"
: "✓";
var error = $" {symbol} Line {annotatedCodeBlock.Line + 1}:\t{fullyQualifiedPath} (in project {project})";
if (hasDiagnostics)
{
context.Errors.Add(error);
}
console.Out.WriteLine(error);
}
foreach (var diagnostic in diagnostics)
{
console.Out.WriteLine($"\t\t{diagnostic}");
}
}
private static string WriteTargetFile(
string content,
RelativeFilePath relativePath,
PublishOptions publishOptions,
MarkdownProcessingContext context,
PublishFormat format)
{
context.Project
.DirectoryAccessor
.EnsureDirectoryExists(relativePath);
var targetPath = publishOptions
.TargetDirectory
.GetFullyQualifiedPath(relativePath).FullName;
if (format == PublishFormat.HTML)
{
targetPath = Path.ChangeExtension(targetPath, ".html");
}
context.WriteFile(targetPath, content);
return(targetPath);
}
public static async Task <int> Do(
PublishOptions publishOptions,
IConsole console,
StartupOptions startupOptions = null,
MarkdownProcessingContext context = null)
{
context ??= new MarkdownProcessingContext(
publishOptions.RootDirectory,
startupOptions,
console: console);
var verifyResult = await VerifyCommand.Do(
publishOptions,
console,
startupOptions,
context);
if (verifyResult != 0)
{
return(verifyResult);
}
var targetIsSubDirectoryOfSource =
publishOptions.TargetDirectory
.IsSubDirectoryOf(publishOptions.RootDirectory);
foreach (var markdownFile in context.Project.GetAllMarkdownFiles())
{
var fullSourcePath = publishOptions.RootDirectory.GetFullyQualifiedPath(markdownFile.Path);
if (targetIsSubDirectoryOfSource &&
fullSourcePath.IsChildOf(publishOptions.TargetDirectory))
{
continue;
}
var sessions = await markdownFile.GetSessions();
var outputsBySessionName = new Dictionary <string, string>();
foreach (var session in sessions)
{
if (session.CodeBlocks.Any(b => b.Annotations is OutputBlockAnnotations))
{
var workspace = await session.GetWorkspaceAsync();
var runArgs =
session.CodeBlocks
.Select(c => c.Annotations)
.OfType <CodeBlockAnnotations>()
.Select(a => a.RunArgs)
.FirstOrDefault();
var request = new WorkspaceRequest(
workspace,
runArgs: runArgs);
var result = await context.WorkspaceServer.Run(request);
if (result.Succeeded)
{
var output = result.Output.Count > 0
? string.Join("\n", result.Output)
: result.Exception;
outputsBySessionName.Add(
session.Name,
output);
}
else
{
context.Errors.Add(
$"Running session {session.Name} failed:\n" + result.Exception);
}
}
}
var document = ParseMarkdownDocument(markdownFile);
var rendered = await Render(
publishOptions.Format,
document,
outputsBySessionName);
var targetPath = WriteTargetFile(
rendered,
markdownFile.Path,
publishOptions,
context,
publishOptions.Format);
console.Out.WriteLine($"Published '{fullSourcePath}' to {targetPath}");
}
return(0);
}
public static async Task <int> Do(
VerifyOptions verifyOptions,
IConsole console,
StartupOptions startupOptions = null,
MarkdownProcessingContext context = null)
{
context ??= new MarkdownProcessingContext(
verifyOptions.RootDirectory,
startupOptions,
console: console);
var markdownFiles = context.Project.GetAllMarkdownFiles().ToArray();
console.Out.WriteLine("Verifying...");
if (markdownFiles.Length == 0)
{
console.Error.WriteLine($"No markdown files found under {context.RootDirectory.GetFullyQualifiedRoot()}");
return(-1);
}
foreach (var markdownFile in markdownFiles)
{
var fullName = context.RootDirectory.GetFullyQualifiedPath(markdownFile.Path).FullName;
var markdownFileDir = context.RootDirectory.GetDirectoryAccessorForRelativePath(markdownFile.Path.Directory);
console.Out.WriteLine();
console.Out.WriteLine(fullName);
console.Out.WriteLine(new string('-', fullName.Length));
foreach (var session in await markdownFile.GetSessions())
{
var sessionProjectOrPackageNames =
session
.CodeBlocks
.Where(a => a.Annotations is CodeBlockAnnotations)
.Select(block => block.ProjectOrPackageName())
.Distinct();
if (sessionProjectOrPackageNames.Count() != 1)
{
var error = $"Session cannot span projects or packages: --session {session.Name}";
AddError(error, context);
continue;
}
foreach (var block in session.CodeBlocks)
{
VerifyAnnotationReferences(
block,
markdownFileDir,
console,
context);
}
Console.ResetColor();
if (!session.CodeBlocks.Any(block => block.Diagnostics.Any()))
{
await Compile(
session,
context);
}
Console.ResetColor();
}
}
if (context.Errors.Count > 0)
{
Console.ForegroundColor = ConsoleColor.Red;
}
else
{
Console.ForegroundColor = ConsoleColor.Green;
}
console.Out.WriteLine($"\nFound {context.Errors.Count} error(s)");
Console.ResetColor();
return(context.Errors.Count == 0
? 0
: 1);
}
internal static async Task Compile(
Session session,
MarkdownProcessingContext context)
{
var region = session.CodeBlocks
.Select(b => b.Annotations)
.OfType <CodeBlockAnnotations>()
.Select(a => a.Region)
.Distinct()
.First();
var description = session.CodeBlocks.Count == 1 || string.IsNullOrWhiteSpace(session.Name)
? $"region \"{region}\""
: $"session \"{session.Name}\"";
context.Console.Out.WriteLine($"\n Compiling samples for {description}\n");
var workspace = await session.GetWorkspaceAsync();
if (!session.IsProjectCompatibleWithLanguage)
{
var error = $" Build failed as project {session.ProjectOrPackageName} is not compatible with language {session.Language}";
AddError(error, context);
}
var result = await context.WorkspaceServer.Compile(new WorkspaceRequest(workspace));
var projectDiagnostics = result.GetFeature <ProjectDiagnostics>()
.Where(e => e.Severity == DiagnosticSeverity.Error)
.ToArray();
if (projectDiagnostics.Any())
{
var error = new StringBuilder();
error.AppendLine($" Build failed for project {session.ProjectOrPackageName}");
foreach (var diagnostic in projectDiagnostics)
{
error.AppendLine($"\t\t{diagnostic.Location}: {diagnostic.Message}");
}
AddError(error.ToString(), context);
}
else
{
var symbol = !result.Succeeded
? "X"
: "✓";
if (result.Succeeded)
{
Console.ForegroundColor = ConsoleColor.Green;
context.Console.Out.WriteLine($" {symbol} No errors found within samples for {description}");
}
else
{
var error = new StringBuilder();
error.AppendLine($" {symbol} Errors found within samples for {description}");
foreach (var diagnostic in result.GetFeature <Diagnostics>())
{
error.AppendLine($"\t\t{diagnostic.Message}");
}
AddError(error.ToString(), context);
}
}
}
