public void Can_Render_MarkdownPage_with_foreach()
{
var person = new Person
{
FirstName = "Demis",
LastName = "Bellot",
Links = new List<Link>
{
new Link { Name = "ServiceStack", Href = "http://www.servicestack.net" },
new Link { Name = "AjaxStack", Href = "http://www.ajaxstack.net" },
},
};
var markdownHtml = MarkdownFormat.Instance.Transform(dynamicListPageContent);
Console.WriteLine(markdownHtml);
var dynamicPage = new MarkdownPage(
dynamicListPagePath, "DynamicListTpl", dynamicListPageContent);
dynamicPage.Prepare();
Assert.That(dynamicPage.Blocks.Count, Is.EqualTo(9));
var expectedHtml = markdownHtml
.Replace("@model.FirstName", person.FirstName)
.Replace("@model.LastName", person.LastName);
var templateArgs = new Dictionary<string, object> { { "model", person } };
var templateOutput = dynamicPage.RenderToString(templateArgs);
Console.WriteLine("Template Output: " + templateOutput);
Assert.That(templateOutput, Is.EqualTo(expectedHtml));
}
public void Can_Render_MarkdownPage()
{
var person = new Person { FirstName = "Demis", LastName = "Bellot" };
var dynamicPage = new MarkdownPage(dynamicPageContent, "DynamicTpl", dynamicListPageContent);
dynamicPage.Prepare();
Assert.That(dynamicPage.Blocks.Count, Is.EqualTo(9));
var expectedHtml = MarkdownFormat.Instance.Transform(dynamicListPageContent)
.Replace("@model.FirstName", person.FirstName)
.Replace("@model.LastName", person.LastName);
var templateArgs = new Dictionary<string, object> { { "model", person } };
var templateOutput = dynamicPage.RenderToString(templateArgs);
Console.WriteLine("Template Output: " + templateOutput);
Assert.That(templateOutput, Is.EqualTo(expectedHtml));
}
private string RenderStaticPage(MarkdownPage markdownPage, bool renderHtml)
{
//TODO: Optimize if contains no dynamic elements
return RenderDynamicPage(markdownPage, new Dictionary<string, object>(), renderHtml, true);
}
private string RenderInTemplateIfAny(MarkdownPage markdownPage, Dictionary<string, object> scopeArgs, string pageHtml)
{
MarkdownTemplate markdownTemplate = null;
var directiveTemplatePath = markdownPage.DirectiveTemplatePath;
if (directiveTemplatePath != null)
{
if (!PageTemplates.TryGetValue(directiveTemplatePath, out markdownTemplate))
{
if (!File.Exists(directiveTemplatePath))
throw new FileNotFoundException("Could not find template: " + directiveTemplatePath);
var templateContents = File.ReadAllText(directiveTemplatePath);
markdownTemplate = AddTemplate(directiveTemplatePath, templateContents);
}
}
if (markdownTemplate == null)
{
var templatePath = markdownPage.TemplatePath;
if (templatePath == null) return pageHtml;
markdownTemplate = PageTemplates[templatePath];
}
if (scopeArgs != null)
scopeArgs[MarkdownTemplate.BodyPlaceHolder] = pageHtml;
var htmlPage = markdownTemplate.RenderToString(scopeArgs);
return htmlPage;
}
private string RenderDynamicPage(MarkdownPage markdownPage, string pageName, object model, bool renderHtml, bool renderTemplate)
{
if (markdownPage == null)
throw new InvalidDataException(ErrorPageNotFound.FormatWith(pageName));
var scopeArgs = new Dictionary<string, object> { { MarkdownPage.ModelName, model } };
return RenderDynamicPage(markdownPage, scopeArgs, renderHtml, renderTemplate);
}
public string RenderDynamicPage(MarkdownPage markdownPage, Dictionary<string, object> scopeArgs,
bool renderHtml, bool renderTemplate)
{
scopeArgs = scopeArgs ?? new Dictionary<string, object>();
var htmlPage = markdownPage.RenderToString(scopeArgs, renderHtml);
if (!renderTemplate) return htmlPage;
var html = RenderInTemplateIfAny(
markdownPage, scopeArgs, htmlPage);
return html;
}
public void ReloadModifiedPageAndTemplates(MarkdownPage markdownPage)
{
var lastWriteTime = File.GetLastWriteTime(markdownPage.FilePath);
if (lastWriteTime > markdownPage.LastModified)
{
markdownPage.Reload();
}
MarkdownTemplate template;
if (markdownPage.DirectiveTemplatePath != null
&& this.PageTemplates.TryGetValue(markdownPage.DirectiveTemplatePath, out template))
{
lastWriteTime = File.GetLastWriteTime(markdownPage.DirectiveTemplatePath);
if (lastWriteTime > template.LastModified)
ReloadTemplate(template);
}
if (markdownPage.TemplatePath != null
&& this.PageTemplates.TryGetValue(markdownPage.TemplatePath, out template))
{
lastWriteTime = File.GetLastWriteTime(markdownPage.TemplatePath);
if (lastWriteTime > template.LastModified)
ReloadTemplate(template);
}
}
public PageContext(MarkdownPage markdownPage, Dictionary <string, object> scopeArgs, bool renderHtml)
{
MarkdownPage = markdownPage;
ScopeArgs = scopeArgs ?? new Dictionary <string, object>();
RenderHtml = renderHtml;
}
public void AddPage(MarkdownPage page)
{
try
{
page.Prepare();
switch (page.PageType)
{
case MarkdownPageType.ViewPage:
ViewPages.Add(page.Name, page);
break;
case MarkdownPageType.SharedViewPage:
ViewSharedPages.Add(page.Name, page);
break;
case MarkdownPageType.ContentPage:
ContentPages.Add(page.FilePath.WithoutExtension(), page);
break;
}
}
catch (Exception ex)
{
Log.Error("AddViewPage() page.Prepare(): " + ex.Message, ex);
}
var templatePath = page.TemplatePath;
if (page.TemplatePath == null) return;
if (PageTemplates.ContainsKey(templatePath)) return;
AddTemplate(templatePath, File.ReadAllText(templatePath));
}
private string RenderStaticPage(MarkdownPage markdownPage, bool renderHtml)
{
var pageHtml = Transform(markdownPage.Contents, renderHtml);
return RenderInTemplateIfAny(markdownPage, null, pageHtml);
}
private string RenderStaticPage(MarkdownPage markdownPage)
{
var pageHtml = markdown.Transform(markdownPage.Contents);
var templatePath = markdownPage.GetTemplatePath();
return RenderInTemplateIfAny(templatePath, pageHtml);
}
private void AddPage(MarkdownPage page)
{
try
{
page.Prepare();
Pages.Add(page.Name, page);
}
catch (Exception ex)
{
log.Error("AddPage() page.Prepare(): " + ex.Message, ex);
}
var templatePath = page.GetTemplatePath();
if (!PageTemplates.ContainsKey(templatePath))
{
var templateFile = new FileInfo(templatePath);
if (!templateFile.Exists)
{
PageTemplates.Add(templateFile.FullName, null);
return;
}
var pageContents = File.ReadAllText(templatePath);
var template = new MarkdownTemplate(
templatePath, templateFile.Name, pageContents);
try
{
template.Prepare();
PageTemplates.Add(template.FilePath, template);
}
catch (Exception ex)
{
log.Error("AddPage() template.Prepare(): " + ex.Message, ex);
}
}
}
private string RenderDynamicPage(MarkdownPage markdownPage, object model, bool renderHtml, bool renderTemplate)
{
if (markdownPage == null)
throw new InvalidDataException(ErrorPageNotFound.FormatWith(markdownPage.Name));
var scopeArgs = new Dictionary<string, object> { { MarkdownPage.ModelName, model } };
var htmlPage = markdownPage.RenderToString(scopeArgs, renderHtml);
if (!renderTemplate) return htmlPage;
var html = RenderInTemplateIfAny(markdownPage.TemplatePath, htmlPage);
return html;
}
private void AddPage(MarkdownPage page)
{
try
{
page.Prepare();
switch (page.PageType)
{
case MarkdownPageType.ViewPage:
ViewPages.Add(page.Name, page);
break;
case MarkdownPageType.SharedViewPage:
ViewSharedPages.Add(page.Name, page);
break;
case MarkdownPageType.ContentPage:
ContentPages.Add(page.FilePath.WithoutExtension(), page);
break;
}
}
catch (Exception ex)
{
Log.Error("AddViewPage() page.Prepare(): " + ex.Message, ex);
}
var templatePath = page.TemplatePath;
if (page.TemplatePath == null) return;
if (PageTemplates.ContainsKey(templatePath)) return;
var templateName = Path.GetFileName(templatePath).WithoutExtension();
var pageContents = File.ReadAllText(templatePath);
var template = new MarkdownTemplate(templatePath, templateName, pageContents);
PageTemplates.Add(templatePath, template);
try
{
template.Prepare();
PageTemplates.Add(template.FilePath, template);
}
catch (Exception ex)
{
Log.Error("AddViewPage() template.Prepare(): " + ex.Message, ex);
}
}
public static string RenderToHtml(this MarkdownPage markdownPage, Dictionary <string, object> scopeArgs)
{
return(RenderToString(markdownPage, scopeArgs, true));
}
public bool ProcessMarkdownPage(IHttpRequest httpReq, MarkdownPage markdownPage, object dto, IHttpResponse httpRes)
{
httpRes.AddHeaderLastModified(markdownPage.GetLastModified());
var renderInTemplate = true;
var renderHtml = true;
string format;
if (httpReq != null && (format = httpReq.QueryString["format"]) != null)
{
renderHtml = !(format.StartsWithIgnoreCase("markdown")
|| format.StartsWithIgnoreCase("text")
|| format.StartsWithIgnoreCase("plain"));
renderInTemplate = !httpReq.GetFormatModifier().StartsWithIgnoreCase("bare");
}
if (!renderHtml)
{
httpRes.ContentType = ContentType.PlainText;
}
var markup = RenderDynamicPage(markdownPage, markdownPage.Name, dto, renderHtml, renderInTemplate);
httpRes.Write(markup);
return true;
}
private void Prepare(MarkdownPage markdownPage)
{
var rawMethodExpr = methodExpr.Replace("Html.", "");
if (rawMethodExpr == "Partial")
{
this.DependentPageName = this.Condition.ExtractContents("\"", "\"");
}
this.WriteRawHtml = rawMethodExpr == "Raw";
var parts = methodExpr.Split('.');
if (parts.Length > 2)
{
throw new ArgumentException("Unable to resolve method: " + methodExpr);
}
var usesBaseType = parts.Length == 1;
var typePropertyName = parts[0];
var methodName = usesBaseType ? parts[0] : parts[1];
Type type = null;
if (typePropertyName == "Html")
{
type = Common.ReflectionExtensions.IsGenericType(markdownPage.ExecutionContext.BaseType)
? typeof(HtmlHelper <>)
: typeof(HtmlHelper);
}
if (type == null)
{
type = usesBaseType
? markdownPage.ExecutionContext.BaseType
: markdownPage.Markdown.MarkdownGlobalHelpers.TryGetValue(typePropertyName, out type) ? type : null;
}
if (type == null)
{
throw new InvalidDataException(string.Format(
"Unable to resolve type '{0}'. Check type exists in Config.MarkdownBaseType or Page.Markdown.MarkdownGlobalHelpers",
typePropertyName));
}
var mi = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
if (mi == null)
{
mi = HtmlHelper.GetMethod(methodName);
if (mi == null)
{
throw new ArgumentException("Unable to resolve method '" + methodExpr + "' on type " + type.Name);
}
}
base.ReturnType = mi.ReturnType;
var isMemberExpr = Condition.IndexOf('(') != -1;
if (!isMemberExpr || this.WriteRawHtml)
{
base.Condition = methodExpr + "(" + Condition + ")";
}
}
public void RegisterMarkdownPage(MarkdownPage markdownPage)
{
AddPage(markdownPage);
}
public PageContext Create(MarkdownPage markdownPage, bool renderHtml)
{
return(new PageContext(markdownPage, ScopeArgs, renderHtml));
}
public void Does_transform_escaped_html_start_tags()
{
var markdownText =
@"#### Showing Results 1 - 5
^<div id=""searchresults"">
### Markdown > [About Docs](http://path.com/to/about)
^</div>
Text".NormalizeNewLines();
var expectedHtml =
@"<h4>Showing Results 1 - 5</h4>
<div id=""searchresults"">
<h3>Markdown > <a href=""http://path.com/to/about"">About Docs</a></h3>
</div>
<p>Text</p>
".NormalizeNewLines();
var textBlock = new TextBlock("");
var page = new MarkdownPage { Markdown = new MarkdownFormat() };
textBlock.DoFirstRun(new PageContext(page, null, true));
var html = textBlock.TransformHtml(markdownText);
Console.WriteLine(html);
Assert.That(html, Is.EqualTo(expectedHtml));
}