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();
}
