public override void Transform(ExtensionHtmlRenderer extensionHtmlRenderer, SnippetBlock block, Snippet astNode)
{
string fullFilePath = IO.Path.Combine(_renderSettings.SourceFolder.Absolute.FullPath, astNode.FileName);
string content = IO.File.ReadAllText(fullFilePath);
MarkdownDocument document = Markdown.Parse(content, extensionHtmlRenderer.Pipeline);
MarkdownDocument blockToInsert = GetByHeadingName(document, astNode.HeadingName);
int contextLevel = block.GetHeadingLevel();
int levelDiff = 0;
int blockToInsertLevel = blockToInsert.GetHeadingLevel();
switch (astNode.InsertionMechanism)
{
case InsertionMechanism.AsSibling: levelDiff = contextLevel - blockToInsertLevel; break;
case InsertionMechanism.AsChild: levelDiff = contextLevel - blockToInsertLevel + 1; break;
case InsertionMechanism.H1: levelDiff = 1 - blockToInsertLevel; break;
case InsertionMechanism.H2: levelDiff = 2 - blockToInsertLevel; break;
case InsertionMechanism.H3: levelDiff = 3 - blockToInsertLevel; break;
case InsertionMechanism.H4: levelDiff = 4 - blockToInsertLevel; break;
case InsertionMechanism.H5: levelDiff = 5 - blockToInsertLevel; break;
case InsertionMechanism.H6: levelDiff = 6 - blockToInsertLevel; break;
}
// what to do with child headings past 6? Bound to 6?
blockToInsert.IncreaseHeadingLevel(levelDiff);
Replace(block, blockToInsert);
}
public override void Render(ExtensionHtmlRenderer renderer, GitHistory gitHistory, IFormatState formatState)
{
var repo = new Repository(@"c:\users\ruudp\desktop\markdig");
//var commits = repo.Commits.QueryBy("README.md").ToList();
var sb = new StringBuilder();
sb.AppendLine("<table>");
sb.AppendLine("<thead>");
sb.AppendLine("<tr>");
foreach (var field in gitHistory.Fields)
{
sb.AppendLine($@"<td>{field.Name}</td>");
}
sb.AppendLine("</tr>");
sb.AppendLine("</thead>");
foreach (var tag in repo.Tags)
{
sb.AppendLine("<tr>");
Commit commit = tag.Target as Commit;
foreach (var field in gitHistory.Fields)
{
var text = field.GetTagText(tag);
sb.AppendLine($@"<td>{text}</td>");
}
var sha = new string(commit.Sha.Take(7).ToArray());
sb.AppendLine("</tr>");
}
sb.AppendLine("</table>");
renderer.Write(sb.ToString());
}
public override void Transform(ExtensionHtmlRenderer extensionHtmlRenderer, ObjectTextBlock block, ObjectText astNode)
{
var pb = new MarkdownPipelineBuilder()
.UseSoftlineBreakAsHardlineBreak()
.UseAdvancedExtensions();
var pipeline = pb.Build();
var path = new Path(astNode.PackageName);
var elements = _provider.GetElements(path, recursive: false);
var sb = new StringBuilder();
var headingLevel = block.GetHeadingLevel();
void transform(MarkdownDocument md)
{
md.IncreaseHeadingLevel(1);
}
foreach (var element in elements)
{
sb.AppendLine($@"# {element.Name}");
var notes = Helper.Converter(element.Notes, transform, pipeline);
sb.AppendLine(element.Notes);
}
var document = Markdown.Parse(sb.ToString(), pipeline);
document.IncreaseHeadingLevel(headingLevel);
Replace(block, document);
}
public override void Render(ExtensionHtmlRenderer renderer, MsSqlTable msSqlTable, IFormatState formatState)
{
var table = GetTable(msSqlTable.Name);
var sb = new StringBuilder();
sb.AppendLine($@"<table class='sql-table'>");
sb.AppendLine($@"<thead>");
sb.AppendLine($@"<tr><th colspan='2'>{msSqlTable.Name}</th></tr>");
sb.AppendLine($@"</thead>");
sb.AppendLine($@"<tbody class='sql-fields'>");
foreach (var field in table.Fields)
{
sb.AppendLine($@"<tr>");
if (field.IsNullable || field.IsPrimaryKey)
{
string nullable = field.IsNullable ? "*" : "";
string primaryKey = field.IsPrimaryKey ? "PK" : "";
sb.AppendLine($@"<td>{nullable}{primaryKey}</td>");
}
else
{
sb.AppendLine($@"<td></td>");
}
sb.AppendLine($@"<td>{field.ToText()}</td></tr>");
}
sb.AppendLine($@"</tbody>");
sb.AppendLine($@"<tbody class='sql-foreign-keys-header'>");
sb.AppendLine($@"<tr><td colspan='2'>Foreign keys</td></tr>");
sb.AppendLine($@"</tbody'>");
sb.AppendLine($@"<tbody class='sql-foreign-keys'>");
foreach (var fk in table.ForeignKeys)
{
sb.AppendLine($@"<tr><td></td><td>{fk.Name} {fk.Table}.{fk.Column} ↔ {fk.ReferencedTable}.{fk.ReferencedColumn}</td></tr>");
}
sb.AppendLine($@"</tbody>");
sb.AppendLine($@"<tbody class='sql-indexes-header'>");
sb.AppendLine($@"<tr><td colspan='2'>Indexes</td></tr>");
sb.AppendLine($@"</tbody'>");
sb.AppendLine($@"<tbody class='sql-indexes'>");
foreach (var index in table.Indexes)
{
sb.AppendLine($@"<tr><td></td><td>{index.Name}({index.IndexType})</td></tr>");
}
sb.AppendLine($@"</tbody>");
//sb.AppendLine($@"<tbody>");
//sb.AppendLine($@"<tr><td>{table.PrimaryKey.Name}({table.PrimaryKey.Type})</td></tr>");
//sb.AppendLine($@"</tbody>");
sb.AppendLine("</table>");
renderer.Write(sb.ToString());
}
public override void Render(ExtensionHtmlRenderer renderer, RequirementsTableName table, IFormatState formatState)
{
var package = _provider.GetElementsByPackage(new Path(table.Name));
if (package != null)
{
var sb = new StringBuilder();
Format(package, sb, formatState.HeadingLevel);
renderer.Write(sb.ToString());
}
}
public void Transform(ExtensionHtmlRenderer extensionHtmlRenderer, FencedCodeBlock block, object astNode)
{
NestedBlock nestedBlock = astNode as NestedBlock;
// 1. parse markdown
// 2. normalize markdown headings
// 3. replace fencedblock with markdown node
var node = Markdown.Parse(nestedBlock.Markdown);
var index = block.Parent.IndexOf(block);
block.Parent.Insert(index, node);
block.Parent.RemoveAt(index + 1);
}
public override void Render(ExtensionHtmlRenderer renderer, PanZoomImage panZoomImage, IFormatState formatState)
{
var bytes = System.IO.File.ReadAllBytes(panZoomImage.Uri);
var base64 = Convert.ToBase64String(bytes);
string html = $@"
<div>
<img src='data:image/png;base64,{base64}' id='{_id}'>
</div>
<script>
var panzoomEl{_id} = document.getElementById('{_id}');
var panzoom{_id} = panzoom(panzoomEl{_id}, {{ bounds: true }});
</script>" ;
_id++;
renderer.Write(html);
}
public override void Render(ExtensionHtmlRenderer renderer, Diagram diagram, IFormatState formatState)
{
if (diagram.Path != null)
{
var path = new Path(diagram.Path);
RenderDiagram(path, renderer);
}
if (diagram.PackagePath != null)
{
var path = new Path(diagram.PackagePath);
var paths = _provider.GetDiagramPaths(path);
foreach (var diagramPath in paths)
{
RenderDiagram(diagramPath, renderer);
}
}
}
public override void Render(ExtensionHtmlRenderer renderer, ExcelTableSelection excelSelection, IFormatState formatState)
{
var excelTable = new ExcelTable {
Rows = new List <Row>()
};
using (var stream = IO.File.Open(excelSelection.FileName, IO.FileMode.Open, IO.FileAccess.Read))
{
using (var reader = ExcelReaderFactory.CreateReader(stream))
{
DataSet result = reader.AsDataSet();
DataTable sheet = result.Tables[excelSelection.Sheet];
CellReference from = CellReference.Parse(excelSelection.CellsFrom);
CellReference to = CellReference.Parse(excelSelection.CellsTo);
for (int i = from.Row - 1; i <= to.Row - 1; i++)
{
//var row = sheet.Rows[i];
var row = new Row {
Cells = new List <string>()
};
for (int j = from.Column; j <= to.Column; j++)
{
var value = sheet.Rows[i].ItemArray[j].ToString();
row.Cells.Add(value);
}
excelTable.Rows.Add(row);
}
// The result of each spreadsheet is in result.Tables
}
}
var sb = new StringBuilder();
sb.AppendLine("<table class='excel-table'>");
foreach (var row in excelTable.Rows)
{
sb.AppendLine("<tr>");
foreach (var column in row.Cells)
{
sb.AppendLine($@"<td>{column}</td>");
}
sb.AppendLine("</tr>");
}
sb.AppendLine("</table>");
renderer.Write(sb.ToString());
}
public override void Transform(
ExtensionHtmlRenderer renderer,
TableOfContentBlock block,
TableOfContent astNode)
{
List <Heading> headings = renderer.ContainerBlock.GetHeadings();
var sb = new StringBuilder();
sb.AppendLine("# Table of Content");
foreach (var heading in headings)
{
var tabs = new string('\t', heading.Level - 1);
sb.AppendLine(tabs + "- " + heading.Title);
}
MarkdownDocument document = Markdown.Parse(sb.ToString());
Replace(block, document);
}
public override void Render(ExtensionHtmlRenderer renderer, Diagram diagram, IFormatState formatState)
{
var(element, elementsEnumerable) = _provider.GetBpmnElements(new Path(diagram.Name));
var elements = elementsEnumerable.ToList();
elements.Sort(new BpmnElement.AliasComparer());
var sb = new StringBuilder();
sb.AppendLine($@"<h1>{element.Name}</h1>");
foreach (var e in elements)
{
string name = string.IsNullOrEmpty(e.Name) ? e.Alias : e.Name;
sb.AppendLine($@"<h2>{name}</h2>");
sb.AppendLine($@"<p>Lane: {e.Lane}</p>");
sb.AppendLine($@"<p>Description:<br>");
sb.AppendLine($@"{e.Notes}</p>");
}
renderer.Write(sb.ToString());
}
public override void Transform(ExtensionHtmlRenderer extensionHtmlRenderer, XmlSnippetBlock block, XmlSnippet astNode)
{
// get xml content using xpath
// create new xml fcb with xml content
// replace
var xmlFile = new File(_renderSettings.SourceFolder, astNode.File);
XDocument document = XDocument.Load(xmlFile.AbsolutePath);
IEnumerable <XElement> queried = document.Root.XPathSelectElements(astNode.Xpath);
var sb = new StringBuilder();
sb.AppendLine("```xml");
foreach (var element in queried)
{
sb.AppendLine(element.ToString());
}
sb.AppendLine("```");
MarkdownDocument markdownDocument = Markdown.Parse(sb.ToString());
Replace(block, markdownDocument);
}
public override void Render(ExtensionHtmlRenderer renderer, TableOfContent model, IFormatState formatState)
{
List <Heading> headings = renderer.ContainerBlock.GetHeadings();
var sb = new StringBuilder();
sb.AppendLine("<nav>");
sb.AppendLine("<div class='title'>Contents</div>");
foreach (var heading in headings)
{
var id = HtmlHelper.Unescape(heading.HeadingBlock.GetAttributes().Id);
sb.AppendLine($@"<a href='#{id}' class='nav-level-{heading.Level}'>{heading.Title}</a>");
}
sb.AppendLine("</nav>");
renderer.Write(sb.ToString());
var dynamicCss = GenerateCss(model);
if (dynamicCss != null)
{
renderer.RegisterDynamicCss(dynamicCss);
}
}
public override void Transform(ExtensionHtmlRenderer extensionHtmlRenderer, WorkflowNotesBlock block, Diagram diagram)
{
var(element, elementsEnumerable) = _provider.GetBpmnElements(new EaProvider.Path(diagram.Name));
var elements = elementsEnumerable.ToList();
elements.Sort(new BpmnElement.AliasComparer());
var sb = new StringBuilder();
sb.AppendLine($@"# {element.Name}");
var converter = new Html2Markdown.Converter();
foreach (BpmnElement e in elements)
{
string name = string.IsNullOrEmpty(e.Name) ? e.Alias : e.Name;
string notes = converter.Convert(e.Notes);
MarkdownDocument notesMd = Markdown.Parse(notes);
notesMd.IncreaseHeadingLevel(2);
string normalizedNotes = null;
using (var writer = new StringWriter())
{
var pipeline = new MarkdownPipelineBuilder().Build();
pipeline.Extensions.AddIfNotAlready <SoftlineBreakAsHardlineExtension>();
var renderer = new NormalizeRenderer(writer);
pipeline.Setup(renderer);
renderer.Render(notesMd);
writer.Flush();
normalizedNotes = writer.ToString();
}
sb.AppendLine($@"## {name}");
sb.AppendLine($@"Lane: {e.Lane}");
sb.AppendLine();
sb.AppendLine($@"Description:");
sb.AppendLine(normalizedNotes);
}
MarkdownDocument document = Markdown.Parse(sb.ToString());
Replace(block, document);
}
private static void RegisterBlocks(ExtensionHtmlRenderer renderer)
{
renderer.RegisterBlock <FolderFromDiskBlock, FolderFromDiskExtension>();
renderer.RegisterBlock <FolderListBlock, FolderListExtension>();
renderer.RegisterBlock <NestedBlockBlock, NestedBlockExtension>();
renderer.RegisterBlock <SnippetBlock, SnippetExtension>();
renderer.RegisterBlock <PanZoomImageBlock, PanZoomImageExtension>();
renderer.RegisterBlock <ExcelTableBlock, ExcelTableExtension>();
renderer.RegisterBlock <MsSqlTableBlock, MsSqlTableExtension>();
renderer.RegisterBlock <GitHistoryBlock, GitHistoryExtension>();
renderer.RegisterBlock <GitGraphBlock, GitGraphExtension>();
renderer.RegisterBlock <WorkflowNotesBlock, WorkflowNotesExtension>();
renderer.RegisterBlock <BpmnGraphBlock, BpmnGraphExtension>();
renderer.RegisterBlock <DiagramBlock, DiagramImageExtension>();
renderer.RegisterBlock <TableNotesBlock, TableNotesExtension>();
renderer.RegisterBlock <ObjectTextBlock, ObjectTextExtension>();
renderer.RegisterBlock <DatamodelApiBlock, DatamodelApiExtension>();
renderer.RegisterBlock <TableOfContentBlock, TableOfContentExtension>();
//renderer.RegisterBlock<NoteParagraphBlock, NoteExtension>();
renderer.RegisterBlock <XmlSnippetBlock, XmlSnippetExtension>();
renderer.RegisterInline <KeyboardKeysInline, KeyboardKeysExtension>();
}
private void RenderDiagram(Path diagramPath, ExtensionHtmlRenderer renderer)
{
var folder = _renderSettings.ImageFolder;
File file = _provider.GetDiagramFile(diagramPath, folder);
if (IO.File.Exists(file.AbsolutePath))
{
if (_renderSettings.EmbedImages)
{
var bytes = IO.File.ReadAllBytes(file.AbsolutePath);
var base64 = Convert.ToBase64String(bytes);
renderer.Write($@"<img src='data:image/png;base64,{base64}' />");
}
else
{
renderer.Write($@"<img src='{file.RelativePath}' />");
}
}
else
{
renderer.Write($@"<p>something went wrong retrieving the image [{diagramPath}]</p>");
}
}
public override void Render(ExtensionHtmlRenderer renderer, BpmnGraph bpmnGraph, IFormatState formatState)
{
var sb = new StringBuilder();
var bpmnXml = IO.File.ReadAllText(bpmnGraph.FileUri);
// Loading BPMN xml from filesystem results in a CORS error
sb.AppendLine($@"
<div class='box' style='height: {bpmnGraph.Height};'>
<div class='row content' id='canvas' ></div>
</div>
<script>
var nav = document.getElementById('nav');
var bpmnViewer = new BpmnJS({{ container: '#canvas' }});
bpmnViewer.importXML(`{bpmnXml}`, function(err) {{
if (err) {{
return console.error('could not import BPMN 2.0 diagram', err);
}}
//var canvas = bpmnViewer.get('canvas');
//canvas.zoom('fit-height');
}});
</script>" );
renderer.Write(sb.ToString());
}
public override void Render(ExtensionHtmlRenderer renderer, KeyboardKeys keyboardKeys, IFormatState formatState)
{
var html = string.Join(string.Empty, keyboardKeys.Keys.Select(k => $@"<kbd>{k}</kbd>"));
renderer.Write(html);
}
public override void Render(ExtensionHtmlRenderer renderer, FM.Folder model, IFormatState formatState)
{
void write(string value) => renderer.Write(value);
Output(model, 1, write);
}
public void Render(ExtensionHtmlRenderer renderer, Note model, IFormatState formatState)
{
renderer.RegisterDynamicCss(Css.First());
}
public override void Render(ExtensionHtmlRenderer renderer, DatamodelApi model, IFormatState formatState)
{
var file = new File(_renderSettings.SourceFolder, model.FileName ?? "schema.json");
//if (file.Exists() && !_renderSettings.ForceRefreshData)
//{
// return;
//}
bool IncludeTable(Element e)
{
if (e.Stereotype != "table" && e.Type != "Enumeration")
{
return(false);
}
return(e.TaggedValue("IsMigrationApi"));
}
bool IncludeEnum(Element e)
{
return(e.Type == "Enumeration" && e.TaggedValue("IsMigrationApi"));
}
var path = new Path(model.PackagePath);
var tables = _eaProvider
.GetElements(path, IncludeTable, "DataModelApiTables", true);
var schema = new JSchema
{
SchemaVersion = new Uri("http://json-schema.org/draft-07/schema#"),
Type = JSchemaType.Object,
Title = "SOSPES Permit datamodel migration API",
};
var enums = new Dictionary <string, IList <JToken> >();
var requiredTables = new List <string>();
IEnumerable <Element> enumElements = null;
if (model.EnumsPackagePath != null)
{
var enumPath = new Path(model.EnumsPackagePath);
enumElements = _eaProvider.GetElements(enumPath, IncludeEnum, "DataModelApiEnums", true);
}
else
{
enumElements = tables.Where(t => t.Type == "Enumeration");
}
foreach (var table in enumElements)
{
var values = new List <JToken>();
foreach (var enumValue in table.Attributes)
{
values.Add(enumValue.Name);
}
foreach (var enumValue in table.Attributes)
{
values.Add(enumValue.DefaultValue);
}
enums.Add(table.Name, values);
}
foreach (var table in tables.Where(t => t.Type != "Enumeration"))
{
var tableArraySchema = new JSchema
{
Type = JSchemaType.Array
};
void transform(MarkdownDocument md)
{
md.IncreaseHeadingLevel(3);
}
var sanitizedNotes = table.Notes.Replace("\\r\\n", "\n");
var notes = Helper.Converter2(table.Notes, transform, renderer.Pipeline);
var tableSchema = new JSchema
{
Description = notes,
Title = table.Name,
Type = JSchemaType.Object,
Format = "Date-time",
};
tableArraySchema.Items.Add(tableSchema);
var required = new List <string>();
//
foreach (var attribute in table.Attributes)
{
if (!attribute.TaggedValue("IsMigrationApi"))
{
continue;
}
bool isEnum = attribute.Name.EndsWith("EnumId");
var(schemaType, format) = ToJsonType(attribute);
var columnSchema = new JSchema
{
Type = isEnum ? JSchemaType.Integer | JSchemaType.String : schemaType,
Description = attribute.Notes,
Format = format
};
if (isEnum)
{
string enumName = attribute.Name.Replace("EnumId", string.Empty);
IList <JToken> @enum = enums[enumName];
foreach (var enumValue in @enum)
{
columnSchema.Enum.Add(enumValue);
}
//var enumValueComments = new JSchema
//{
//};
//JToken derpy = "";
//enumValueComments.Properties.Add("enumValueName", (JToken)"");
//columnSchema.Properties.Add("meta:enum", enumValueComments);
}
if (attribute.Length != 0)
{
columnSchema.MaximumLength = attribute.Length;
}
if (!attribute.Nullable)
{
required.Add(attribute.Name);
}
tableSchema.Properties.Add(attribute.Name, columnSchema);
}
if (table.TaggedValue("IncludeCreatedDateTimeInMigrationApi"))
{
var createdDateTime = new JSchema
{
Type = JSchemaType.String,
Description = "Creation DateTime"
};
tableSchema.Properties.Add("CreatedDateTime", createdDateTime);
}
required.ForEach(r => tableSchema.Required.Add(r));
schema.Properties.Add(table.Name + "List", tableArraySchema);
requiredTables.Add(table.Name);
}
requiredTables.ForEach(rt => schema.Required.Add(rt));
renderer.Write(schema.ToString());
using (System.IO.StreamWriter textWriter = System.IO.File.CreateText(file.AbsolutePath))
using (var jsonWriter = new JsonTextWriter(textWriter))
{
jsonWriter.Formatting = Formatting.Indented;
schema.WriteTo(jsonWriter);
jsonWriter.Flush();
}
}
public override void Render(ExtensionHtmlRenderer renderer, GitGraph gitGraph, IFormatState formatState)
{
// first commit should have a branch name
var script = new StringBuilder();
var branches = new HashSet <BranchName>();
string currentBranch = null;
foreach (var commit in gitGraph.Commits)
{
if (!branches.Contains(commit.BranchName))
{
branches.Add(commit.BranchName);
var branch = commit.BranchName.Name;
currentBranch = branch;
script.AppendLine($"const {branch} = gitGraph.branch('{branch}');");
}
if (commit.Branch != null && !branches.Contains(commit.Branch))
{
branches.Add(commit.Branch);
var branch = commit.Branch.Name;
currentBranch = branch;
script.AppendLine($"const {branch} = gitGraph.branch('{branch}');");
}
string authorText = null;
if (commit.Author == null)
{
authorText = "null";
}
else if (commit.Author != null && commit.Author.Email == null)
{
authorText = $@"'{commit.Author.Name}'";
}
else if (commit.Author != null && commit.Author.Email == null)
{
authorText = $@"'{commit.Author.Name} <{commit.Author.Email}>'";
}
string author = null;
if (!string.IsNullOrEmpty(authorText))
{
author = $@"author: {authorText}";
}
string tag = null;
if (commit.Tag != null)
{
script.AppendLine($@"{currentBranch}.tag('{commit.Tag.Name}')");
}
var subject = $@"subject: '{commit.Title}'";
string commitArgs = null;
if (author != null)
{
commitArgs = $@"{{{subject}, {author}}}";
}
else
{
commitArgs = $@"{{{subject}}}";
}
script.AppendLine($"{commit.BranchName.Name}.commit({commitArgs});");
if (commit.Merge != null)
{
script.AppendLine($"{commit.Merge.Name}.merge('{commit.BranchName.Name}');");
}
}
var sb = new StringBuilder();
sb.Append($@"
<div>
<div id='derpy'></div>
<script type='text/javascript'>
const graphContainer = document.getElementById('derpy');
const gitGraph = GitgraphJS.createGitgraph(graphContainer);
{script.ToString()}
</script>
</div>");
renderer.Write(sb.ToString());
}
private static void File(string fullFilePath, Container container, RenderSettings settings)
{
string body = null;
string summaries = null;
string cssHeader = null;
string jsHeader = null;
var sourceFolder = new AbsoluteFolder(Path.GetDirectoryName(fullFilePath));
if (settings == null)
{
settings = RenderSettings.DefaultWiki(sourceFolder);
}
using (var scope = ThreadScopedLifestyle.BeginScope(container))
using (var writer = new StringWriter())
{
MarkdownPipeline pipeline = CreatePipeline(container);
var markdown = System.IO.File.ReadAllText(fullFilePath);
var markdownDocument = Markdown.Parse(markdown, pipeline);
var renderer = new ExtensionHtmlRenderer(writer, markdownDocument, settings, pipeline);
renderer.RegisterDynamicCss(new Code("markdown-extensions", "0.0.1", () =>
Assembly.GetExecutingAssembly().GetFileContent("vscode-markdown.css")));
pipeline.Setup(renderer);
RegisterBlocks(renderer);
renderer.Parse(container);
renderer.Validate(container);
renderer.Transform();
renderer.Render(markdownDocument);
var fileName = Path.GetFileName(fullFilePath);
renderer.RenderMarkdown(fileName, markdownDocument);
writer.Flush();
body = writer.ToString();
using (var summaryWriter = new StringWriter())
{
// a bit of a hack to use different writer for summaries
renderer.Writer = summaryWriter;
renderer.RenderSummaries(markdownDocument);
summaryWriter.Flush();
summaries = summaryWriter.ToString();
}
cssHeader = renderer.RenderCssHeader();
jsHeader = renderer.RenderJavascriptHeader();
}
var document = $@"
<html>
<head>
{jsHeader}
{cssHeader}
</head>
<body>
{summaries}
<main>
{body}
</main>
</body>
</html>" ;
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fullFilePath);
var file = new File(settings.OutputFolder, fileNameWithoutExtension + ".html");
System.IO.File.WriteAllText(file.AbsolutePath, document);
}
private static void AggregateCheatSheet(Container container)
{
Dictionary <string, string> cheatSheetByExtensionName = container
.GetAllInstances <IExtensionInfo>()
.ToDictionary(x => x.Name, x => x.CheatSheet);
var sb = new StringBuilder();
int i = 1;
var body = new StringBuilder();
string cssHeader = null;
string javascriptHeader = null;
using (ThreadScopedLifestyle.BeginScope(container))
{
foreach (var entry in cheatSheetByExtensionName)
{
var markdown = entry.Value;
var writer = new StringWriter();
var pipeline = CreatePipeline(container);
var document = Markdown.Parse(markdown, pipeline);
var renderer = new ExtensionHtmlRenderer(writer, document, new RenderSettings(), pipeline);
pipeline.Setup(renderer);
RegisterBlocks(renderer);
renderer.Parse(container);
// validate errors
renderer.Transform();
// run validations
renderer.Render(document);
writer.Flush();
cssHeader = renderer.RenderCssHeader();
javascriptHeader = renderer.RenderJavascriptHeader();
string isChecked = i == 1 ? "checked" : "";
string name = entry.Key;
string md = entry.Value;
string html = writer.ToString();
var tab = $@"
<section>
<input type='radio' name='sections' id='option{i}' {isChecked}>
<label for='option{i}'>{name}</label>
<article>{html}</article>
</section>" ;
body.AppendLine(tab);
i += 1;
}
}
var htmlDocument = $@"
<html>
<head>
{javascriptHeader}
{cssHeader}
</head>
<body>
<div class='tabordion'>
{body}
</div>
</body>
</html>" ;
System.IO.File.WriteAllText("CheatSheet.html", htmlDocument);
}
public override void Transform(ExtensionHtmlRenderer extensionHtmlRenderer, TableNotesBlock block, TableNotes tableNotes)
{
IEnumerable <Element> tables = null;
if (tableNotes.PackagePath != null)
{
var package = _provider.GetElementsByPackage(tableNotes.PackagePath);
tables = package
.GetElementsRecursively()
.Where(e => TableNotes.Include(tableNotes, e));
}
else
{
//tables = _provider
// .GetElements(e => e.Stereotype == "table")
// .Where(e => TableNotes.Include(tableNotes, e));
throw new NotImplementedException();
}
var all = new StringBuilder();
void transform(MarkdownDocument md)
{
md.IncreaseHeadingLevel(1);
}
foreach (var table in tables)
{
var sb = new StringBuilder();
sb.AppendLine($@"## {table.Name}");
bool hasTableNotes = false;
if (!string.IsNullOrEmpty(table.Notes))
{
hasTableNotes = true;
var notes = Helper.Converter(table.Notes, transform, extensionHtmlRenderer.Pipeline);
sb.AppendLine(notes);
}
bool hasFieldNotes = false;
sb.AppendLine($@"### Properties");
foreach (var taggedValue in table.TaggedValues)
{
if (string.IsNullOrEmpty(taggedValue.Value))
{
continue;
}
sb.AppendLine($@"- **{taggedValue.Key}**: {taggedValue.Value}");
}
sb.AppendLine($@"### Attributes");
foreach (var attribute in table.Attributes)
{
if (string.IsNullOrEmpty(attribute.Notes))
{
continue;
}
hasFieldNotes = true;
var notes = Helper.Converter(attribute.Notes, transform, extensionHtmlRenderer.Pipeline);
sb.AppendLine($@"#### {attribute.Name}");
sb.AppendLine(notes);
}
bool hasNotes = hasTableNotes || hasFieldNotes;
if (hasNotes)
{
all.Append(sb);
}
}
MarkdownDocument document = Markdown.Parse(all.ToString(), extensionHtmlRenderer.Pipeline);
Replace(block, document);
}
