public void Does_handle_foreach_when_enumerable_is_empty_first_time() { var content = (string)dynamicListPageContent.Clone(); var markdownPage = new MarkdownPage(new MarkdownFormat(), dynamicListPagePath, "", content); markdownPage.Compile(); var model = new Person { Links = new List<Link>() }; var scopeArgs = new Dictionary<string, object> { { "Model", model } }; markdownPage.RenderToHtml(scopeArgs); // First time the list is empty var expected = "A new list item"; model.Links.Add(new Link { Name = expected } ); var html = markdownPage.RenderToHtml(scopeArgs); // Second time the list has 1 item Console.WriteLine(html); Assert.That(html, Contains.Substring(expected)); }
/// <summary>Initialises this object.</summary> /// /// <param name="markdownPage">The markdown page.</param> /// <param name="scopeArgs"> The scope arguments.</param> /// <param name="renderHtml"> true to render HTML.</param> /// <param name="viewData"> Information describing the view.</param> /// <param name="htmlHelper"> The HTML helper.</param> public void Init(MarkdownPage markdownPage, Dictionary<string, object> scopeArgs, bool renderHtml, ViewDataDictionary viewData, HtmlHelper htmlHelper) { Init(null, null, markdownPage.Markdown, viewData, htmlHelper); this.RenderHtml = renderHtml; this.MarkdownPage = markdownPage; this.ScopeArgs = scopeArgs; }
/// <summary>A MarkdownFormat extension method that adds a file and page to 'markdownPage'.</summary> /// /// <param name="markdown"> The markdown to act on.</param> /// <param name="markdownPage">The markdown page.</param> public static void AddFileAndPage(this MarkdownFormat markdown, MarkdownPage markdownPage) { var pathProvider = (InMemoryVirtualPathProvider)markdown.VirtualPathProvider; pathProvider.AddFile(markdownPage.FilePath, markdownPage.Contents); markdown.AddPage(markdownPage); }
/// <summary>Renders the dynamic page.</summary> /// /// <param name="markdownPage"> The markdown page.</param> /// <param name="scopeArgs"> The scope arguments.</param> /// <param name="renderHtml"> true to render HTML.</param> /// <param name="renderTemplate">true to render template.</param> /// <param name="templatePath"> Full pathname of the template file.</param> /// /// <returns>A string.</returns> public string RenderDynamicPage(MarkdownPage markdownPage, Dictionary<string, object> scopeArgs, bool renderHtml, bool renderTemplate, string templatePath = null) { scopeArgs = scopeArgs ?? new Dictionary<string, object>(); var htmlPage = markdownPage.RenderToString(scopeArgs, renderHtml); if (!renderTemplate) return htmlPage; var html = RenderInTemplateIfAny( markdownPage, scopeArgs, htmlPage, templatePath); return html; }
private string RenderDynamicPage(MarkdownPage markdownPage, string pageName, object model, bool renderHtml, bool renderTemplate, string templatePath = null) { if (markdownPage == null) throw new InvalidDataException(ErrorPageNotFound.FormatWith(pageName)); var scopeArgs = new Dictionary<string, object> { { MarkdownPage.ModelName, model } }; return RenderDynamicPage(markdownPage, scopeArgs, renderHtml, renderTemplate, templatePath); }
private string RenderInTemplateIfAny(MarkdownPage markdownPage, Dictionary<string, object> scopeArgs, string pageHtml, string templatePath = null) { MarkdownTemplate markdownTemplate = null; if (templatePath != null) MasterPageTemplates.TryGetValue(templatePath, out markdownTemplate); var directiveTemplate = markdownPage.DirectiveTemplate; if (markdownTemplate == null && directiveTemplate != null) { if (!MasterPageTemplates.TryGetValue(directiveTemplate, out markdownTemplate)) { var templateInSharedPath = "{0}/{1}.shtml".Fmt(SharedDir, directiveTemplate); if (!MasterPageTemplates.TryGetValue(templateInSharedPath, out markdownTemplate)) { var virtualFile = VirtualPathProvider.GetFile(directiveTemplate); if (virtualFile == null) throw new FileNotFoundException("Could not find template: " + directiveTemplate); var templateContents = GetPageContents(virtualFile); markdownTemplate = AddTemplate(directiveTemplate, templateContents); } } } if (markdownTemplate == null) { if (markdownPage.Template != null) MasterPageTemplates.TryGetValue(markdownPage.Template, out markdownTemplate); if (markdownTemplate == null && templatePath == null) MasterPageTemplates.TryGetValue(DefaultTemplate, out markdownTemplate); if (markdownTemplate == null) { if (templatePath == null) return pageHtml; throw new Exception("No template found for page: " + markdownPage.FilePath); } } if (scopeArgs != null) scopeArgs[MarkdownTemplate.BodyPlaceHolder] = pageHtml; var htmlPage = markdownTemplate.RenderToString(scopeArgs); return htmlPage; }
/// <summary> /// Creates the specified markdown page. /// </summary> /// <param name="markdownPage">The markdown page.</param> /// <param name="renderHtml">if set to <c>true</c> [render HTML].</param> /// <returns></returns> 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)); }
/// <summary>Adds a page.</summary> /// /// <param name="page">The page.</param> public void AddPage(MarkdownPage page) { try { page.Compile(); AddViewPage(page); } catch (Exception ex) { Log.Error("AddViewPage() page.Prepare(): " + ex.Message, ex); } try { var templatePath = page.Template; if (page.Template == null) return; if (MasterPageTemplates.ContainsKey(templatePath)) return; var templateFile = VirtualPathProvider.GetFile(templatePath); var templateContents = GetPageContents(templateFile); AddTemplate(templatePath, templateContents); } catch (Exception ex) { Log.Error("Error compiling template " + page.Template + ": " + ex.Message, ex); } }
/// <summary>Registers the markdown page described by markdownPage.</summary> /// /// <param name="markdownPage">The markdown page.</param> public void RegisterMarkdownPage(MarkdownPage markdownPage) { AddPage(markdownPage); }
private IVirtualFile GetLatestPage(MarkdownPage markdownPage) { var file = VirtualPathProvider.GetFile(markdownPage.FilePath); return file; }
private MarkdownPage ReloadIfNeeded(MarkdownPage markdownPage) { if (markdownPage == null || !WatchForModifiedPages) return markdownPage; if (markdownPage.FilePath != null) { var latestPage = GetLatestPage(markdownPage); if (latestPage == null) return markdownPage; if (latestPage.LastModified > markdownPage.LastModified) { markdownPage.Reload(GetPageContents(latestPage), latestPage.LastModified); } } return markdownPage; }
/// <summary>Reload modified page and templates.</summary> /// /// <param name="markdownPage">The markdown page.</param> public void ReloadModifiedPageAndTemplates(MarkdownPage markdownPage) { if (markdownPage == null || !WatchForModifiedPages) return; ReloadIfNeeded(markdownPage); IVirtualFile latestPage; MarkdownTemplate template; if (markdownPage.DirectiveTemplate != null && this.MasterPageTemplates.TryGetValue(markdownPage.DirectiveTemplate, out template)) { latestPage = GetLatestPage(markdownPage.DirectiveTemplate); if (latestPage.LastModified > template.LastModified) template.Reload(GetPageContents(latestPage), latestPage.LastModified); } if (markdownPage.Template != null && this.MasterPageTemplates.TryGetValue(markdownPage.Template, out template)) { latestPage = GetLatestPage(template); if (latestPage.LastModified > template.LastModified) template.Reload(GetPageContents(latestPage), latestPage.LastModified); } }
/// <summary>Process the markdown page.</summary> /// /// <param name="httpReq"> The HTTP request.</param> /// <param name="markdownPage">The markdown page.</param> /// <param name="dto"> The dto.</param> /// <param name="httpRes"> The HTTP resource.</param> /// /// <returns>true if it succeeds, false if it fails.</returns> 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 template = httpReq.GetTemplate(); var markup = RenderDynamicPage(markdownPage, markdownPage.Name, dto, renderHtml, renderInTemplate, template); var markupBytes = markup.ToUtf8Bytes(); httpRes.OutputStream.Write(markupBytes, 0, markupBytes.Length); return true; }
/// <summary> /// Renders to HTML. /// </summary> /// <param name="markdownPage">The markdown page.</param> /// <param name="scopeArgs">The scope arguments.</param> /// <returns></returns> public static string RenderToHtml(this MarkdownPage markdownPage, Dictionary <string, object> scopeArgs) { return(RenderToString(markdownPage, scopeArgs, true)); }
/// <summary> /// Initializes a new instance of the <see cref="PageContext"/> class. /// </summary> /// <param name="markdownPage">The markdown page.</param> /// <param name="scopeArgs">The scope arguments.</param> /// <param name="renderHtml">if set to <c>true</c> [render HTML].</param> public PageContext(MarkdownPage markdownPage, Dictionary<string, object> scopeArgs, bool renderHtml) { MarkdownPage = markdownPage; ScopeArgs = scopeArgs ?? new Dictionary<string, object>(); RenderHtml = renderHtml; }
/// <summary> /// Creates the specified markdown page. /// </summary> /// <param name="markdownPage">The markdown page.</param> /// <param name="renderHtml">if set to <c>true</c> [render HTML].</param> /// <returns></returns> public PageContext Create(MarkdownPage markdownPage, bool renderHtml) { return new PageContext(markdownPage, ScopeArgs, renderHtml); }
private void AddViewPage(MarkdownPage page) { 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().TrimStart(DirSeps), page); break; } }
private string RenderStaticPage(MarkdownPage markdownPage, bool renderHtml) { //TODO: Optimize if contains no dynamic elements return RenderDynamicPage(markdownPage, new Dictionary<string, object>(), renderHtml, true); }
/// <summary> /// Initializes a new instance of the <see cref="PageContext"/> class. /// </summary> /// <param name="markdownPage">The markdown page.</param> /// <param name="scopeArgs">The scope arguments.</param> /// <param name="renderHtml">if set to <c>true</c> [render HTML].</param> public PageContext(MarkdownPage markdownPage, Dictionary <string, object> scopeArgs, bool renderHtml) { MarkdownPage = markdownPage; ScopeArgs = scopeArgs ?? new Dictionary <string, object>(); RenderHtml = renderHtml; }