public SpecAdded AddSpec(string path, string name) { return(_lock.Read(() => { if (!_hierarchy.Suites.Has(path)) { return null; } var suite = _hierarchy.Suites[path]; var folder = suite.Folder; var specification = new Specification { name = name }; var specFileName = Specification.DetermineFilename(name); var file = folder.AppendPath(specFileName); _watcher.WriteFiles(() => { MarkdownWriter.WriteToFile(specification, file); }); specification.Filename = file; _hierarchy.Specifications[specification.id] = specification; suite.AddSpec(specification); return new SpecAdded(_hierarchy.Top, specification); })); }
public override void WriteTo(MarkdownWriter writer) { if (content is string s) { writer.WriteTaskItem(s); } else { foreach (MElement element in Elements()) { writer.WriteStartTaskItem(); if (element is MTaskItem item) { item.WriteContentTo(writer); } else { writer.Write(element); } writer.WriteEndTaskItem(); } writer.WriteLine(); } }
public void SaveSpecification(string id, Specification specification) { try { _lock.Read(() => { if (!_hierarchy.Specifications.Has(id)) { return(true); } _hierarchy.Replace(specification, DateTime.UtcNow); _watcher.WriteFiles(() => { MarkdownWriter.WriteToFile(specification, specification.Filename); }); return(true); }); } catch (Exception e) { Logger.Error("Error trying to save specification " + id, e); } }
public static string ToStringAndClear(this MarkdownWriter mb) { string s = mb.ToString(); ((MarkdownStringWriter)mb).GetStringBuilder().Clear(); return(s); }
public void Save(TextWriter writer, MarkdownFormat format = null) { using (MarkdownWriter mw = MarkdownWriter.Create(writer, MarkdownWriterSettings.From(format))) { Save(mw); } }
public override async Task Generate(DirectoryInfo directory, ProgrammableBlockApi api) { var fileName = Path.Combine(directory.FullName, "Namespace-Index.md"); using (var file = File.CreateText(fileName)) { var writer = new MarkdownWriter(file); await writer.BeginParagraphAsync(); await writer.WriteAsync($"← {MarkdownInline.HRef("Index", "Api-Index")}"); await writer.EndParagraphAsync(); await writer.WriteHeaderAsync(3, "Assemblies"); await writer.BeginParagraphAsync(); await writer.WriteLineAsync("These are the game assemblies used by programmable block scripts."); await writer.WriteLineAsync(); foreach (var assembly in api.Entries.Select(e => e.AssemblyName).Distinct().OrderBy(n => n)) await writer.WriteLineAsync($"{assembly}.dll "); await writer.EndParagraphAsync(); await writer.WriteHeaderAsync(3, "Types"); await writer.BeginParagraphAsync(); await writer.WriteAsync("This index contains all types and members available to ingame scripting - with exception to the .NET types, because including those would have made the listing far too big. There will be links to Microsoft's own documentation for those types where appropriate."); await writer.EndParagraphAsync(); foreach (var blockGroup in api.Entries.Where(e => e.Member is Type).GroupBy(e => e.Member.GetNamespace()).OrderBy(g => g.Key)) { await writer.WriteHeaderAsync(3, blockGroup.Key); await writer.BeginParagraphAsync(); foreach (var type in blockGroup.OrderBy(e => e.ToString(ApiEntryStringFlags.ShortDisplayName | ApiEntryStringFlags.DeclaringTypes))) await writer.WriteLineAsync(MemberGenerator.LinkTo(WebUtility.HtmlEncode(type.ToString(ApiEntryStringFlags.ShortDisplayName | ApiEntryStringFlags.DeclaringTypes)), type)); await writer.EndParagraphAsync(); } await writer.FlushAsync(); } }
/// <summary> /// Parses the inheritance chain into text. /// </summary> /// <param name="inheritance">The inheritance chain.</param> /// <returns>The parsed inheritance.</returns> public static string ParseInheritance( IList <TypeRef> inheritance) { var first = true; var sb = new StringBuilder("Inheritance"); foreach (TypeRef i in inheritance) { if (first) { first = false; } else { sb.Append("→"); } if (i == inheritance[^ 1]) { sb.Append($" **{MarkdownWriter.Normalize(i.FriendlyName)}**"); continue; } sb.Append(Writer.WriteLink(i)); } return(sb.ToString()); }
public void Save(Stream stream, MarkdownFormat format = null) { using (MarkdownWriter mw = MarkdownWriter.Create(stream, MarkdownWriterSettings.From(format))) { Save(mw); } }
public override void Render(PageTree parent, MarkdownWriter writer) { writer.WriteHeader(1, Title); writer.WriteParagraph(Docs?.Summary ?? "_(No Description)_"); writer.WriteHeader(2, "Signature"); writer.WriteCodeBlock("csharp", DocUtilities.GetPropertySignature(_property, true, true, true)); }
public void change_a_file() { var file = ClassUnderTest.Hierarchy.Specifications["general1"].Filename; var old = MarkdownReader.ReadFromFile(file); old.Lifecycle = Lifecycle.Regression; MarkdownWriter.WriteToFile(old, file); ClassUnderTest.Changed(file); var newNode = ClassUnderTest.Hierarchy.Specifications["general1"]; newNode.ShouldNotBeTheSameAs(old); newNode.Lifecycle.ShouldBe(Lifecycle.Regression); ClassUnderTest.Hierarchy.Suites["General"] .Specifications.ShouldContain(newNode); var sent = MockFor <IClientConnector>().ReceivedCalls().First().GetArguments().First().As <SpecData>(); sent.ShouldNotBeNull(); sent.data.ShouldBe(newNode); sent.id.ShouldBe("general1"); }
public override void WriteTo(MarkdownWriter writer) { if (content is string s) { writer.WriteOrderedItem(NumberingBase, s); } else { int number = NumberingBase; foreach (MElement element in Elements()) { writer.WriteStartOrderedItem(number); if (element is MOrderedItem item) { item.WriteContentTo(writer); } else { writer.Write(element); } writer.WriteEndOrderedItem(); number++; } writer.WriteLine(); } }
async Task GenerateNamespaceDoc(DirectoryInfo directory, IGrouping <string, ApiEntry> ns) { var fileName = Path.Combine(directory.FullName, ToMdFileName(ns.Key)); using (var file = File.CreateText(fileName)) { var writer = new MarkdownWriter(file); await writer.BeginParagraphAsync(); await writer.WriteAsync($"← {MarkdownInline.HRef("Index", "Api-Index")} ← {MarkdownInline.HRef("Namespace Index", "Namespace-Index")}"); await writer.EndParagraphAsync(); await writer.WriteHeaderAsync(1, ns.Key); await writer.BeginParagraphAsync(); foreach (var typeGroup in ns.GroupBy(e => e.DeclaringEntry ?? e).OrderBy(g => g.Key.FullName)) { await writer.WriteLineAsync(MarkdownInline.Strong(MemberGenerator.LinkTo(typeGroup.Key.Name, typeGroup.Key))); } await writer.EndParagraphAsync(); await writer.FlushAsync(); } }
public static void MarkdownWriter_WriteImage_Throws() { MarkdownWriter mw = CreateWriter(); Assert.Throws <ArgumentNullException>(() => mw.WriteImage(text: null, url: "Url")); Assert.Throws <ArgumentNullException>(() => mw.WriteImage(text: "Text", url: null)); }
public MarkdownDocumentationWriter( DocumentationModel documentationModel, DocumentationUrlProvider urlProvider, DocumentationOptions options = null, DocumentationResources resources = null) : base(documentationModel, urlProvider, options, resources) { _writer = MarkdownWriter.Create(new StringBuilder()); }
public static void MarkdownWriter_WriteInlineCode3() { MarkdownWriter mw = CreateWriter(); mw.WriteInlineCode("`` ``` ``"); Assert.Equal("` `` ``` `` `", mw.ToStringAndClear()); }
public static void MarkdownWriter_WriteHorizontalRule_Throws(int count) { MarkdownWriter mw = CreateWriter(); Assert.Throws <ArgumentOutOfRangeException>(() => mw.WriteHorizontalRule(style: HorizontalRuleStyle.Asterisk, count: count, separator: "")); Assert.Throws <ArgumentOutOfRangeException>(() => mw.WriteHorizontalRule(style: HorizontalRuleStyle.Hyphen, count: count, separator: "")); Assert.Throws <ArgumentOutOfRangeException>(() => mw.WriteHorizontalRule(style: HorizontalRuleStyle.Underscore, count: count, separator: "")); }
public static void MarkdownWriter_WriteHeading_UnderlineH2(HeadingOptions?options) { MarkdownWriter mw = CreateBuilderWithHeadingOptions(options); mw.WriteHeading2(Value); Assert.Equal(ValueEscaped + NewLine + new string('-', ValueEscaped.Length) + NewLine, mw.ToStringAndClear()); }
public static void MarkdownWriter_WriteHeading(int level) { MarkdownWriter mw = CreateWriter(new MarkdownFormat(headingOptions: HeadingOptions.None)); mw.WriteHeading(level, Value); Assert.Equal($"{new string('#', level)} {ValueEscaped}{NewLine}", mw.ToStringAndClear()); }
public static void MarkdownWriter_WriteHeading6(HeadingOptions?options) { MarkdownWriter mw = CreateBuilderWithHeadingOptions(options); mw.WriteHeading6(Value); Assert.Equal($"###### {ValueEscaped}{NewLine2}", mw.ToStringAndClear()); }
public static void MarkdownWriter_WriteBlockQuote(string text1, string text2) { MarkdownWriter mw = CreateWriter(); mw.WriteBlockQuote(text1); Assert.Equal(text2, mw.ToStringAndClear()); }
public SymbolDefinitionMarkdownWriter( MarkdownWriter writer, SymbolFilterOptions filter = null, DefinitionListFormat format = null, SymbolDocumentationProvider documentationProvider = null) : base(filter, format, documentationProvider) { _writer = writer; }
/// <inheritdoc /> public override bool FinalizeAnalysis() { MarkdownWriter.SetRootFolder(OutputFolder); MarkdownWriter.SetRootLink(RootLink); MarkdownWriter.SetModuleList(ModuleList); MarkdownWriter.WriteWorkspace(DocWorkspace); return(base.FinalizeAnalysis()); }
public void Save(MarkdownWriter writer) { if (writer == null) { throw new ArgumentNullException(nameof(writer)); } WriteTo(writer); }
private static void WriteFootNote(MarkdownWriter mw) { mw.WriteLine(); mw.WriteStartItalic(); mw.WriteString("(Generated with "); mw.WriteLink("DotMarkdown", "http://github.com/JosefPihrt/DotMarkdown"); mw.WriteString(")"); mw.WriteEndItalic(); }
public SymbolDefinitionMarkdownWriter( MarkdownWriter writer, SymbolFilterOptions filter = null, DefinitionListFormat format = null, SymbolDocumentationProvider documentationProvider = null, INamedTypeSymbol hierarchyRoot = null) : base(filter, format, documentationProvider, hierarchyRoot) { _writer = writer; }
public static void MarkdownWriter_Write_Italic(string syntax, EmphasisStyle?italicStyle) { const string x = Chars; const string y = CharsEscaped; MarkdownWriter mw = CreateBuilderWithItalicStyle(italicStyle); mw.Write(Italic(x)); Assert.Equal(syntax + y + syntax, mw.ToStringAndClear()); }
async Task WriteMembers(ProgrammableBlockApi api, ApiEntry entry, MarkdownWriter writer) { var memberEntries = AllInheritedEntriesOf(entry).ToList(); await WriteTable("Fields", memberEntries.Where(m => m.Member is FieldInfo), api, entry, writer); await WriteTable("Events", memberEntries.Where(m => m.Member is EventInfo), api, entry, writer); await WriteTable("Properties", memberEntries.Where(m => m.Member is PropertyInfo), api, entry, writer); await WriteTable("Constructors", memberEntries.Where(m => m.Member is ConstructorInfo), api, entry, writer); await WriteTable("Methods", memberEntries.Where(m => m.Member is MethodInfo), api, entry, writer); }
public static void MarkdownWriter_Write_Strikethrough() { const string x = Chars; const string y = CharsEscaped; MarkdownWriter mw = CreateWriter(); mw.Write(Strikethrough(x)); Assert.Equal("~~" + y + "~~", mw.ToStringAndClear()); }
public Task DescribeAsync(ISyncService sync, MarkdownWriter writer) { var models = GetFiles(sync.FileSystem) .Select(x => (x, sync.Read <AssetsModel>(x, log))); writer.Paragraph($"{models.SelectMany(x => x.Item2.Assets).Count()} asset(s)."); return(Task.CompletedTask); }
public override async Task WriteMarkdown(XmlDocWriteContext context, MarkdownWriter writer) { await writer.BeginParagraphAsync(); foreach (var node in Content) { await node.WriteMarkdown(context, writer); } await writer.EndParagraphAsync(); }