path: root/scripts/metadata.lua

local path = require 'pandoc.path'

function pandoc.List:flatten()
    local result = pandoc.List()

    for i = 1, #self do result:extend(self[i]) end

    return result
end

function pandoc.List:flatMap(fn)
    local mapped = self:map(fn)
    local result = pandoc.List()

    for i = 1, #mapped do result:extend(mapped[i]) end

    return result
end

function pandoc.List:take(n)
    if n >= #self then return self end

    local result = pandoc.List()

    for i = 1, n do result:insert(self[i]) end

    return result
end

function dump(o)
    if type(o) == 'table' then
        local s = '{ '
        for k, v in pairs(o) do
            if type(k) ~= 'number' then k = '"' .. k .. '"' end
            s = s .. '[' .. k .. '] = ' .. dump(v) .. ','
        end
        return s .. '} '
    else
        return tostring(o)
    end
end

function page_sort(order)
    return function(p1, p2)
        if p1.position then
            if p2.position then
                return tonumber(p1.position) < tonumber(p2.position)
            else
                return true
            end
        elseif p2.position then
            return false
        elseif order == "date_desc" then
            if p1.last_update then
                if p2.last_update then
                    return p1.last_update.yyyy_mm_dd > p2.last_update.yyyy_mm_dd
                else
                    return true
                end
            else
                return false
            end
        else
            return p1.title:upper() < p2.title:upper()
        end
    end
end

function slug(str)
    return str:lower():gsub("[^ a-z]", ""):gsub("[ ]+", "-")
end

function format_date(date)
    if not date then return date end

    date = pandoc.utils.normalize_date(pandoc.utils.stringify(date))
    local year, month, day = date:match("(%d%d%d%d)-(%d%d)-(%d%d)")
    if not year then return nil end

    local time = os.time({ year = tonumber(year), month = tonumber(month), day = tonumber(day) })
    return {
        yyyy_mm_dd = os.date("%F", time),
        yyyy = os.date("%Y", time),
        mm = os.date("%m", time),
        dd = os.date("%d", time),
        rfc3339 = os.date("%FT%T+00:00", time),
        long = os.date("%B %d, %Y", time),
        short = os.date("%b %d, %Y", time),
    }
end

function make_absolute(rel, base)
    return path.is_absolute(rel) and rel or path.join({ path.directory(base), rel })
end

function resolve_url(site_url, ref_file, target_file)
    target_file = target_file:gsub("/index%.html$", "/")

    local ref_base_dir = path.directory(ref_file)
    local abs = target_file
    local rel = path.make_relative(abs, ref_base_dir, true)
    local full = (abs:sub(1, 1) == "/" and (site_url .. abs)) or abs

    return { abs = abs, rel = rel, full = full }
end

function resolve_layout(depth)
    local layout = "categorized_list"

    if depth == 0 then
        layout = "page"
    elseif depth == 1 then
        layout = "list"
    end

    return layout
end

function prep_layout(layout)
    layout = pandoc.utils.stringify(layout)
    return { id = layout, ["is_" .. layout] = true }
end

function resolve_namespace(namespace)
    namespace = pandoc.utils.stringify(namespace)

    local root = "index"
    if namespace ~= "" then root = namespace:gsub("^/([^/]*).*$", "%1") end

    return { root = { id = root, ["is_" .. root] = true }, full = namespace }
end

function prep_menu(active_id, main_menu)
    local active_item = nil
    local items = pandoc.List()

    for i = 1, #main_menu do
        local item = main_menu[i]
        local active = pandoc.utils.stringify(item.id) == active_id
        item.active = active
        if active then active_item = item end
        if not item.hidden or item.active then items:insert(item) end
    end

    return { items = items, active = active_item }
end

function process_pages(global, order, pages_by_id)
    if not pages_by_id then return nil end

    local pages_all = pandoc.List()
    local pages_date_desc = pandoc.List()

    for _, page in pairs(pages_by_id) do
        local p = process(global, page)
        if not p.unlisted then
            pages_all:insert(p)
            if p.last_update then pages_date_desc:insert(p) end
        end
    end

    pages_all:sort(page_sort(order))
    pages_date_desc:sort(page_sort("date_desc"))

    local pages_data = { all = pages_all, date_desc = pages_date_desc, by_id = pages_by_id }

    return pages_data
end

function find_depth(pages)
    local depth = 0

    if pages then
        for i = 1, #pages.all do
            local p = pages.all[i]
            local d = tonumber(p.depth)
            if d > depth then depth = d end
        end

        depth = depth + 1
    end

    return depth
end

function d1_page_to_list_item(meta, p)
    return {
        title = p.title,
        subtitle = p.subtitle,
        date = meta.list_order == "date_desc" and p.date,
        last_update = meta.list_order == "date_desc" and p.last_update,
        schema_type = p.schema_type,
        position = p.position,
        url = p.url,
        rel = p.rel,
        slug = p.slug,
        thumbnail = p.thumbnail,
        icon = p.icon or meta.icon,
        post_icon = p.post_icon or meta.list_post_icon,
        indicator = meta.list_read_indicators,
    }
end

function d2_page_to_list_item(meta, cat, p, set_cat_title)
    return {
        title = p.title,
        subtitle = p.subtitle,
        category = set_cat_title and cat.title,
        date = cat.list_order == "date_desc" and p.date,
        last_update = cat.list_order == "date_desc" and p.last_update,
        schema_type = p.schema_type,
        position = p.position,
        url = p.url,
        rel = p.rel,
        slug = p.slug,
        thumbnail = p.thumbnail,
        icon = p.icon or cat.icon,
        post_icon = p.post_icon or cat.list_post_icon or meta.list_post_icon,
        indicator = cat.list_read_indicators,
    }
end

function cat_to_list_cat(cat, allItems)
    local limit = cat.list_limit or 9999
    local items = allItems:take(limit)
    local omitted = #allItems - #items

    return {
        title = cat.title,
        description = (cat.description and pandoc.MetaBlocks(pandoc.Para(cat.description))) or
            (not cat.no_description and cat.content),
        last_update = cat.last_update,
        schema_type = cat.schema_type,
        url = cat.url,
        slug = cat.slug,
        layout = cat.list_layout,
        items = items,
        total = tostring(#allItems),
        omitted = omitted ~= 0 and tostring(omitted),
    }
end

function generate_list(meta)
    if meta.depth < 1 then return nil end

    if meta.depth == 1 then
        return meta.pages.all:map(function(p) return d1_page_to_list_item(meta, p) end)
    end

    if meta.depth == 2 then
        return meta.pages.all
            :map(function(cat)
                local allItems = ((cat.pages and cat.pages.all) or pandoc.List())
                    :map(function(p) return d2_page_to_list_item(meta, cat, p, false) end)

                return cat_to_list_cat(cat, allItems)
            end)
            :filter(function(cat) return #cat.items ~= 0 end)
    end

    if meta.depth == 3 then
        return meta.pages.all
            :map(function(cat)
                local allItems = (cat.pages and cat.pages.all or pandoc.List()):flatMap(function(c)
                    if not c.pages or not cat.list_flatten then
                        return pandoc.List({ d1_page_to_list_item(cat, c) })
                    else
                        return c.pages.all:map(function(p) return d2_page_to_list_item(cat, c, p, true) end)
                    end
                end)
                allItems:sort(page_sort(cat.list_order))

                return cat_to_list_cat(cat, allItems)
            end)
            :filter(function(cat) return #cat.items ~= 0 end)
    end
end

function process(global, meta)
    meta.namespace = resolve_namespace(meta.namespace)
    meta.file_out = pandoc.utils.stringify(meta.file_out):gsub("^out", "")
    meta.redirect = meta.url and true
    meta.url = meta.url and pandoc.utils.stringify(meta.url)
    meta.url = resolve_url(global.site.url, global.file_out, meta.url or meta.file_out)
    meta.title = (meta.title and pandoc.utils.stringify(meta.title)) or ""
    meta.slug = slug(meta.title)
    meta.schema_type = (meta.schema_type and pandoc.utils.stringify(meta.schema_type)) or "CreativeWork"
    if meta.list_order then meta.list_order = pandoc.utils.stringify(meta.list_order) end
    meta.list_layout = meta.list_layout and prep_layout(meta.list_layout)
    if meta.list_limit then meta.list_limit = tonumber(pandoc.utils.stringify(meta.list_limit)) end
    if meta.position then meta.position = pandoc.utils.stringify(meta.position) end

    if meta.feed then
        if meta.file_out:match(".html$") then
            meta.feed = {
                url = resolve_url(global.site.url, global.file_out, meta.file_out:gsub(".html$", ".xml")),
            }
        else
            meta.page = {
                url = resolve_url(global.site.url, global.file_out, meta.file_out:gsub(".xml$", ".html")),
            }
        end
    end

    if meta.thumbnail then
        meta.thumbnail = make_absolute("thumbnail." .. pandoc.utils.stringify(meta.thumbnail),
            meta.file_out)
        meta.thumbnail = resolve_url(global.site.url, global.file_out, meta.thumbnail)
    end

    if meta.menus and meta.menus.main then
        meta.menus.main = prep_menu(meta.namespace.root.id, meta.menus.main)
    end

    meta.pages = process_pages(global, meta.list_order, meta.pages)
    meta.depth = find_depth(meta.pages)
    meta.layout = prep_layout(meta.layout or (meta.redirect and "redirect") or resolve_layout(meta.depth))

    if meta.last_update then
        meta.last_update = format_date(meta.last_update)
    elseif meta.pages and #meta.pages.date_desc ~= 0 then
        meta.last_update = meta.pages.date_desc[1].last_update
    elseif meta.date then
        meta.last_update = format_date(meta.date)
    end

    if meta.date then
        meta.date = format_date(meta.date)
    elseif meta.last_update then
        meta.date = meta.last_update
    end

    meta.list = generate_list(meta)

    return meta
end

function Meta(meta)
    meta.site.url = pandoc.utils.stringify(meta.site.url):gsub("/$", "")

    return process(meta, meta)
end