public static void AddFileAndPage(this MarkdownFormat markdown, MarkdownPage markdownPage)
{
var pathProvider = (InMemoryVirtualPathProvider)markdown.VirtualPathProvider;
pathProvider.AddFile(markdownPage.FilePath, markdownPage.Contents);
markdown.AddPage(markdownPage);
}
public void SetUp()
{
ServiceStackHost.Instance.VirtualFileSources = pathProvider = new InMemoryVirtualPathProvider(new BasicAppHost());
markdownFormat = new MarkdownFormat {
VirtualPathProvider = pathProvider,
};
}
public static void AddFileAndTemplate(this MarkdownFormat markdown, string filePath, string contents)
{
var pathProvider = (InMemoryVirtualPathProvider)markdown.VirtualPathProvider;
pathProvider.AddFile(filePath, contents);
markdown.AddTemplate(filePath, contents);
}
public void OnBeforeEachTest()
{
markdownFormat = new MarkdownFormat
{
VirtualPathProvider = new FileSystemVirtualPathProvider(new BasicAppHost(), "~/".MapProjectPath()),
};
}
public static void MarkdownFormat_OperatorEquals()
{
MarkdownFormat format = CreateMarkdownFormat();
MarkdownFormat format2 = format;
Assert.True(format == format2);
}
public static void MarkdownFormat_OperatorNotEquals()
{
MarkdownFormat format = CreateMarkdownFormat();
MarkdownFormat format2 = format.Modify();
Assert.True(format != format2);
}
public static void MarkdownFormat_NotEquals()
{
MarkdownFormat format = CreateMarkdownFormat();
MarkdownFormat format2 = format.Modify();
Assert.False(format.Equals((object)format2));
}
public static void MarkdownFormat_GetHashCode_NotEqual()
{
MarkdownFormat format = CreateMarkdownFormat();
MarkdownFormat format2 = format.Modify();
Assert.NotEqual(format.GetHashCode(), format2.GetHashCode());
}
public string ToMarkdownString()
{
var text = Value.GroupBy(x => x.CreatedBy)
.Select(y =>
{
var createdByes = Value.Select(x => x.CreatedBy).ToArray();
var mergedAtes = Value.Select(x => x.MergedAt.Value.ToLocalTime().ToString("d")).ToArray();
var branchNames = Value.Select(x => x.BranchName).ToArray();
var repositoryNames = Value.Select(x => x.RepositoryName).ToArray();
var created = new MarkdownFormat("CreatedBy", Value.Select(x => x.CreatedBy).ToArray());
var mergedAt = new MarkdownFormat("MergedAt", Value.Select(x => x.MergedAt.Value.ToLocalTime().ToString("d")).ToArray());
var branchName = new MarkdownFormat("BranchName", Value.Select(x => x.BranchName).ToArray());
var repositoryName = new MarkdownFormat("RepositoryName", Value.Select(x => x.RepositoryName).ToArray());
var values = created.Values
.Zip(mergedAt.Values, (c, m) => $"| {c} | {m}")
.Zip(branchName.Values, (x, b) => $"{x} | {b}")
.Zip(repositoryName.Values, (x, r) => $"{x} | {r} |");
var result = $@"| {created.Column} | {mergedAt.Column} | {branchName.Column} | {repositoryName.Column} |
| {created.TableSpacer} | {mergedAt.TableSpacer} | {branchName.TableSpacer} | {repositoryName.TableSpacer} |
{values.Select(x => x).ToJoinedString(Environment.NewLine)}";
return(result);
})
.ToArray();
return(text.ToJoinedString(Environment.NewLine));
}
public void OnBeforeEachTest()
{
markdownFormat = new MarkdownFormat();
templateArgs = new Dictionary <string, object> {
{ MarkdownPage.ModelName, person }
};
}
public override void ProcessRequest(IHttpRequest httpReq, IHttpResponse httpRes, string operationName)
{
if (MarkdownFormat == null)
{
MarkdownFormat = MarkdownFormat.Instance;
}
var contentPage = MarkdownPage ?? MarkdownFormat.FindByPathInfo(PathInfo);
if (contentPage == null)
{
httpRes.StatusCode = (int)HttpStatusCode.NotFound;
httpRes.EndHttpRequest();
return;
}
MarkdownFormat.ReloadModifiedPageAndTemplates(contentPage);
if (httpReq.DidReturn304NotModified(contentPage.GetLastModified(), httpRes))
{
return;
}
MarkdownFormat.ProcessMarkdownPage(httpReq, contentPage, null, httpRes);
}
public void SetUp()
{
HostContext.AppHost.VirtualFileSources = pathProvider = new MemoryVirtualFiles();
markdownFormat = new MarkdownFormat
{
VirtualPathProvider = pathProvider,
};
}
public void OnBeforeEachTest()
{
appHost = new AppHost();
markdownFormat = new MarkdownFormat {
VirtualPathProvider = appHost.VirtualPathProvider
};
markdownFormat.Register(appHost);
}
public void SetUp()
{
EndpointHost.VirtualPathProvider = pathProvider = new InMemoryVirtualPathProvider(new BasicAppHost());
markdownFormat = new MarkdownFormat
{
VirtualPathProvider = pathProvider,
};
}
public MarkdownPage(MarkdownFormat markdown, string fullPath, string name, string contents, MarkdownPageType pageType)
: this()
{
Markdown = markdown;
FilePath = fullPath;
Name = name;
Contents = contents;
PageType = pageType;
}
public void SetUp()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
EndpointHost.VirtualPathProvider = pathProvider = new InMemoryVirtualPathProvider(new BasicAppHost());
markdownFormat = new MarkdownFormat {
VirtualPathProvider = pathProvider,
};
}
public MarkdownPage(MarkdownFormat markdown, string fullPath, string name, string contents, MarkdownPageType pageType)
: this()
{
Markdown = markdown;
FilePath = fullPath;
Name = name;
Contents = contents;
PageType = pageType;
}
/// <summary>Creates a new MarkdownFormat.</summary>
///
/// <param name="pageTemplate">The page template.</param>
///
/// <returns>A MarkdownFormat.</returns>
public MarkdownFormat Create(string pageTemplate)
{
var markdownFormat = new MarkdownFormat();
markdownFormat.AddPage(
new MarkdownPage(markdownFormat, "/path/to/tpl", PageName, pageTemplate));
return(markdownFormat);
}
public void OnBeforeEachTest()
{
markdownFormat = new MarkdownFormat {
VirtualPathProvider = new InMemoryVirtualPathProvider(new BasicAppHost())
};
templateArgs = new Dictionary <string, object> {
{ MarkdownPage.ModelName, person }
};
}
public void OnBeforeEachTest()
{
Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-US");
appHost = new AppHost();
markdownFormat = new MarkdownFormat {
VirtualPathProvider = appHost.VirtualPathProvider
};
markdownFormat.Register(appHost);
}
public void TestFixtureSetUp()
{
var json = "~/AppData/ALFKI.json".MapProjectPath().ReadAllText();
response = JsonSerializer.DeserializeFromString <CustomerDetailsResponse>(json);
appHost = new BasicAppHost
{
WebHostPhysicalPath = "~".MapProjectPath(),
Plugins = { new MarkdownFormat() },
}.Init();
markdownFormat = appHost.GetPlugin <MarkdownFormat>();
}
public MarkdownFormat Create(string websiteTemplate, string pageTemplate)
{
var markdownFormat = new MarkdownFormat();
markdownFormat.AddTemplate("/path/to/websitetpl", websiteTemplate);
markdownFormat.AddPage(
new MarkdownPage(markdownFormat, "/path/to/tpl", PageName, pageTemplate)
{
TemplatePath = "/path/to/websitetpl",
});
return(markdownFormat);
}
public static void MarkdownFormat_Constructor_HorizontalRule()
{
const HorizontalRuleStyle style = HorizontalRuleStyle.Hyphen;
const int count = 3;
const string space = " ";
var horizontalRule = new HorizontalRuleFormat(style, count, space);
var format = new MarkdownFormat(horizontalRuleFormat: horizontalRule);
Assert.Equal(style, format.HorizontalRuleFormat.Style);
Assert.Equal(count, format.HorizontalRuleFormat.Count);
Assert.Equal(space, format.HorizontalRuleFormat.Separator);
}
public void TestFixtureSetUp()
{
var json = "~/AppData/ALFKI.json".MapProjectPath().ReadAllText();
response = JsonSerializer.DeserializeFromString <CustomerDetailsResponse>(json);
appHost = new BasicAppHost
{
ConfigFilter = config => {
//Files aren't copied, set RootDirectory to ProjectPath instead.
config.WebHostPhysicalPath = "~".MapProjectPath();
}
}.Init();
markdownFormat = appHost.GetPlugin <MarkdownFormat>();
}
public static MarkdownFormat Modify(this MarkdownFormat x)
{
return(new MarkdownFormat(
x.BoldStyle.Modify(),
x.ItalicStyle.Modify(),
x.BulletListStyle.Modify(),
x.OrderedListStyle.Modify(),
x.HeadingStyle.Modify(),
x.HeadingOptions.Modify(),
x.TableOptions.Modify(),
x.CodeFenceStyle.Modify(),
x.CodeBlockOptions.Modify(),
x.CharEntityFormat.Modify(),
horizontalRuleFormat: x.HorizontalRuleFormat.Modify()));
}
/// <summary>Creates a new MarkdownFormat.</summary>
///
/// <param name="websiteTemplate">The website template.</param>
/// <param name="pageTemplate"> The page template.</param>
///
/// <returns>A MarkdownFormat.</returns>
public MarkdownFormat Create(string websiteTemplate, string pageTemplate)
{
var markdownFormat = new MarkdownFormat {
VirtualPathProvider = new InMemoryVirtualPathProvider(new BasicAppHost())
};
markdownFormat.AddFileAndTemplate("websiteTemplate", websiteTemplate);
markdownFormat.AddPage(
new MarkdownPage(markdownFormat, "/path/to/tpl", PageName, pageTemplate)
{
Template = "websiteTemplate",
});
return(markdownFormat);
}
static void OnPostprocessAllAssets(string[] imported, string[] deleted, string[] moved, string[] movedFromAssetPaths)
{
if (imported.Any(s => s.Contains("AppHost")))
{
if (EditorApplication.isCompiling)
{
var startHosts = MonoBehaviour.FindObjectsOfType(typeof(StartHostBehavior));
foreach (var startHost in startHosts)
{
var monoScript = MonoScript.FromMonoBehaviour(startHost as MonoBehaviour);
if (typeof(StartHostBehavior).IsAssignableFrom(monoScript.GetClass()))
{
Debug.Log(monoScript.ToJsv());
var host = startHost as StartHost;
var hostPath = Path.Combine(
Directory.GetCurrentDirectory(), host.webrootPath);
var mf = new MarkdownFormat
{
VirtualPathProvider = new FileSystemVirtualPathProvider(
new TestAppHost(), hostPath)
};
var mp = mf.FindMarkdownPages("/");
var output = new Dictionary <string, string>();
foreach (var markdownPage in mp)
{
markdownPage.Compile();
//var view = new Dictionary<string, object>() {{ "examples", examples }};
output.Add(markdownPage.FilePath, markdownPage.RenderToString(new Dictionary <string, object>()
{
}, true));
}
Debug.Log(hostPath);
foreach (var outputPage in output)
{
var outputPath = hostPath + outputPage.Key.Replace('/', '\\') + ".html";
Debug.Log(outputPath);
using (var outputStream = File.Create(outputPath))
{
outputStream.Write(outputPage.Value);
}
}
}
}
}
}
}
public static string CreateRefactoringMarkdown(RefactoringDescriptor refactoring)
{
var format = new MarkdownFormat(tableOptions: MarkdownFormat.Default.TableOptions | TableOptions.FormatContent);
MDocument document = Document(
Heading2(refactoring.Title),
Table(TableRow("Property", "Value"),
TableRow("Id", refactoring.Id),
TableRow("Title", refactoring.Title),
TableRow("Syntax", string.Join(", ", refactoring.Syntaxes.Select(f => f.Name))),
(!string.IsNullOrEmpty(refactoring.Span)) ? TableRow("Span", refactoring.Span) : null,
TableRow("Enabled by Default", CheckboxOrHyphen(refactoring.IsEnabledByDefault))),
Heading3("Usage"),
GetRefactoringSamples(refactoring),
Link("full list of refactorings", "Refactorings.md"));
return(document.ToString(format));
}
public static string CreateAnalyzerMarkdown(AnalyzerDescriptor analyzer)
{
var format = new MarkdownFormat(tableOptions: MarkdownFormat.Default.TableOptions | TableOptions.FormatContent);
MDocument document = Document(
Heading1($"{((analyzer.IsObsolete) ? "[deprecated] " : "")}{analyzer.Id}: {analyzer.Title.TrimEnd('.')}"),
Table(
TableRow("Property", "Value"),
TableRow("Id", analyzer.Id),
TableRow("Category", analyzer.Category),
TableRow("Default Severity", analyzer.DefaultSeverity),
TableRow("Enabled by Default", CheckboxOrHyphen(analyzer.IsEnabledByDefault)),
TableRow("Supports Fade-Out", CheckboxOrHyphen(analyzer.SupportsFadeOut)),
TableRow("Supports Fade-Out Analyzer", CheckboxOrHyphen(analyzer.SupportsFadeOutAnalyzer))),
(!string.IsNullOrEmpty(analyzer.Summary)) ? Raw(analyzer.Summary) : null,
Samples(),
GetLinks(analyzer.Links),
Heading2("How to Suppress"),
Heading3("SuppressMessageAttribute"),
FencedCodeBlock($"[assembly: SuppressMessage(\"{analyzer.Category}\", \"{analyzer.Id}:{analyzer.Title}\", Justification = \"<Pending>\")]", LanguageIdentifiers.CSharp),
Heading3("#pragma"),
FencedCodeBlock($"#pragma warning disable {analyzer.Id} // {analyzer.Title}\r\n#pragma warning restore {analyzer.Id} // {analyzer.Title}", LanguageIdentifiers.CSharp),
Heading3("Ruleset"),
BulletItem(Link("How to configure rule set", "../HowToConfigureAnalyzers.md")));
document.AddFootnote();
return(document.ToString(format));
IEnumerable <MElement> Samples()
{
IReadOnlyList <SampleDescriptor> samples = analyzer.Samples;
if (samples.Count > 0)
{
yield return(Heading2((samples.Count == 1) ? "Example" : "Examples"));
foreach (MElement item in GetSamples(samples, Heading3("Code with Diagnostic"), Heading3("Code with Fix")))
{
yield return(item);
}
}
}
}
public string Parse <TModel>(string markdownTemplate, TModel model, bool isHtml = true)
{
if (string.IsNullOrWhiteSpace(markdownTemplate))
{
return(string.Empty);
}
var file = Path.GetTempFileName();
lock (SyncLock)
{
File.WriteAllText(file, markdownTemplate);
}
var fi = new FileInfo(file);
if (fi.Length == 0)
{
fi.Delete();
return(string.Empty);
}
var mdFormat = new MarkdownFormat();
var mdPage = new MarkdownPage(mdFormat, file, "_markdown_", markdownTemplate);
mdFormat.AddPage(mdPage);
// attach view model
var scopeArgs = new Dictionary <string, object> {
{ MarkdownPage.ModelName, model }
};
var result = mdFormat.RenderDynamicPage(mdPage, scopeArgs, isHtml, false);
// clean up temp file
fi.Delete();
return(result);
}
public override void ProcessRequest(IRequest httpReq, IResponse httpRes, string operationName)
{
HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes);
if (httpRes.IsClosed)
{
return;
}
if (MarkdownFormat == null)
{
MarkdownFormat = MarkdownFormat.Instance;
}
var contentPage = MarkdownPage ?? MarkdownFormat.FindByPathInfo(PathInfo);
if (contentPage == null)
{
httpRes.StatusCode = (int)HttpStatusCode.NotFound;
httpRes.EndHttpHandlerRequest();
return;
}
MarkdownFormat.ReloadModifiedPageAndTemplates(contentPage);
if (httpReq.DidReturn304NotModified(contentPage.GetLastModified(), httpRes))
{
return;
}
var model = Model;
if (model == null)
{
httpReq.Items.TryGetValue("Model", out model);
}
MarkdownFormat.ProcessMarkdownPage(httpReq, contentPage, model, httpRes.OutputStream);
}
public MarkdownPage(MarkdownFormat markdown, string fullPath, string name, string contents)
: this(markdown, fullPath, name, contents, MarkdownPageType.ViewPage)
{
}
