only parse and load config once to construct Demo Page (#68)

Author: johnnychen94

src/types/card.jl

@@ -47,13 +47,16 @@ function is_democard(file)
     end
 end
 
-function load_config(card::T, key) where T <: AbstractDemoCard
-    config = parse(card)
+function load_config(card::T, key; config=Dict()) where T <: AbstractDemoCard
+    isempty(config) && (config = parse(card))
 
     if key == "cover"
         haskey(config, key) || return nothing
 
         cover_path = config[key]
+        if !is_remote_url(cover_path)
+            cover_path = replace(cover_path, r"[/\\]" => Base.Filesystem.path_separator) # windows compatibility
+        end
         return cover_path
     elseif key == "id"
         haskey(config, key) || return get_default_id(card)

src/types/julia.jl

@@ -80,16 +80,17 @@ function JuliaDemoCard(path::String)::JuliaDemoCard
     # first consturct an incomplete democard, and then load the config
     card = JuliaDemoCard(path, "", "", "", "", "", DateTime(0), JULIA_COMPAT, false)
 
-    card.cover = load_config(card, "cover")
-    card.title = load_config(card, "title")
-    card.date = load_config(card, "date")
-    card.author = load_config(card, "author")
-    card.julia = load_config(card, "julia")
+    config = parse(card)
+    card.cover = load_config(card, "cover"; config=config)
+    card.title = load_config(card, "title"; config=config)
+    card.date = load_config(card, "date"; config=config)
+    card.author = load_config(card, "author"; config=config)
+    card.julia = load_config(card, "julia"; config=config)
     # default id requires a title
-    card.id    = load_config(card, "id")
+    card.id    = load_config(card, "id"; config=config)
     # default description requires a title
-    card.description = load_config(card, "description")
-    card.hidden = load_config(card, "hidden")
+    card.description = load_config(card, "description"; config=config)
+    card.hidden = load_config(card, "hidden"; config=config)
     return card
 end
 

src/types/markdown.jl

@@ -73,21 +73,22 @@ function MarkdownDemoCard(path::String)::MarkdownDemoCard
     # first consturct an incomplete democard, and then load the config
     card = MarkdownDemoCard(path, "", "", "", "", "", DateTime(0), false)
 
-    card.cover = load_config(card, "cover")
-    card.title = load_config(card, "title")
-    card.date = load_config(card, "date")
-    card.author = load_config(card, "author")
+    config = parse(card)
+    card.cover = load_config(card, "cover"; config=config)
+    card.title = load_config(card, "title"; config=config)
+    card.date = load_config(card, "date"; config=config)
+    card.author = load_config(card, "author"; config=config)
 
     # Unlike JuliaDemoCard, Markdown card doesn't accept `julia` compat field. This is because we
     # generally don't know the markdown processing backend. It might be Documenter, but who knows.
     # More generally, any badges can just be manually added by demo writter, if they want.
     # `date` and `author` fields are added just for convinience.
 
     # default id requires a title
-    card.id    = load_config(card, "id")
+    card.id    = load_config(card, "id"; config=config)
     # default description requires a title
-    card.description = load_config(card, "description")
-    card.hidden = load_config(card, "hidden")
+    card.description = load_config(card, "description"; config=config)
+    card.hidden = load_config(card, "hidden"; config=config)
     return card
 end
 

src/types/page.jl

@@ -113,32 +113,45 @@ function DemoPage(root::String)::DemoPage
         msg = "can not find a valid page structure in page dir \"$root\"\nit should have at least one folder as section inside it"
         throw(ArgumentError(msg))
     end
-    
+
+    json_path = joinpath(root, config_filename)
+    json_config = isfile(json_path) ? JSON.parsefile(json_path) : Dict()
+
+    template_file = joinpath(root, get(json_config, "template", template_filename))
+    config = parse(Val(:Markdown), template_file)
+    config = merge(json_config, config) # template has higher priority over config file
+
     sections = map(DemoSection, section_paths)
     page = DemoPage(root, sections, "", nothing, "")
-    page.theme = load_config(page, "theme")
+    page.theme = load_config(page, "theme"; config=config)
 
-    section_paths = joinpath.(root, load_config(page, "order"))
-    ordered_sections = map(DemoSection, section_paths) # TODO: technically, we don't need to regenerate sections here
+    section_orders = load_config(page, "order"; config=config)
+    section_orders = map(sections) do sec
+        findfirst(x-> x == basename(sec.root), section_orders)
+    end
+    ordered_sections = sections[section_orders]
 
-    title = load_config(page, "title")
+    title = load_config(page, "title"; config=config)
     page.sections = ordered_sections
     page.title = title
 
     # default template requires a title
-    template = load_config(page, "template")
+    template = load_config(page, "template"; config=config)
     page.template = template
 
     return page
 end
 
-function load_config(page::DemoPage, key)
-    json_path = joinpath(page.root, config_filename)
-    json_config = isfile(json_path) ? JSON.parsefile(json_path) : Dict()
+function load_config(page::DemoPage, key; config=Dict())
+    if isempty(config)
+        json_path = joinpath(page.root, config_filename)
+        json_config = isfile(json_path) ? JSON.parsefile(json_path) : Dict()
 
-    template_file = joinpath(page.root, get(json_config, "template", template_filename))
-    config = parse(Val(:Markdown), template_file)
-    config = merge(json_config, config) # template has higher priority over config file
+        template_file = joinpath(page.root, get(json_config, "template", template_filename))
+        config = parse(Val(:Markdown), template_file)
+        config = merge(json_config, config) # template has higher priority over config file
+    end
+    # config could still be an empty dictionary
 
     if key == "order"
         haskey(config, key) || return get_default_order(page)

src/types/section.jl

@@ -71,7 +71,7 @@ See also: [`MarkdownDemoCard`](@ref DemoCards.MarkdownDemoCard), [`DemoPage`](@r
 """
 struct DemoSection
     root::String
-    cards::Vector # Why would `Vector{<:AbstractDemoCard}` fail here?
+    cards::Vector
     subsections::Vector{DemoSection}
     title::String
     description::String
@@ -91,15 +91,16 @@ function DemoSection(root::String)::DemoSection
         throw(ArgumentError("section folder $(root) should only hold either cards or subsections"))
     end
 
-    # first consturct an incomplete section
-    # then load the config and reconstruct a new one
+    config_file = joinpath(root, config_filename)
+    config = isfile(config_file) ? JSON.parsefile(config_file) : Dict()
+
     section = DemoSection(root,
                           map(democard, card_paths),
                           map(DemoSection, section_paths),
                           "",
                           "")
 
-    ordered_paths = joinpath.(root, load_config(section, "order"))
+    ordered_paths = joinpath.(root, load_config(section, "order"; config=config))
     if !isempty(section.cards)
         cards = map(democard, ordered_paths)
         subsections = []
@@ -108,15 +109,18 @@ function DemoSection(root::String)::DemoSection
         subsections = map(DemoSection, ordered_paths)
     end
 
-    title = load_config(section, "title")
-    description = load_config(section, "description")
+    title = load_config(section, "title"; config=config)
+    description = load_config(section, "description"; config=config)
     DemoSection(root, cards, subsections, title, description)
 end
 
 
-function load_config(sec::DemoSection, key)
-    path = joinpath(sec.root, config_filename)
-    config = isfile(path) ? JSON.parsefile(path) : Dict()
+function load_config(sec::DemoSection, key; config=Dict())
+    if isempty(config)
+        config_file = joinpath(sec.root, config_filename)
+        config = isfile(config_file) ? JSON.parsefile(config_file) : Dict()
+    end
+    # config could still be an empty dictionary
 
     if key == "order"
         haskey(config, key) || return get_default_order(sec)

src/utils.jl

@@ -196,13 +196,6 @@ function parse(T::Val, card::AbstractDemoCard)
         merge!(config, YAML.load(join(frontmatter, "\n")))
     end
 
-    if haskey(config, "cover")
-        if !is_remote_url(config["cover"])
-            config["cover"] = replace(config["cover"],
-                                    r"[/\\]" => Base.Filesystem.path_separator) # windows compatibility
-        end
-    end
-
     return config
 end
 parse(card::JuliaDemoCard) = parse(Val(:Julia), card)