ferron

page.lua (4913B)

---

 -- page.lua
 local page = {}
 local pagemeta = {
   __call = function(self, key, vars)
     print(key)
   end
 }
 
 local inspect = require 'inspect'
 local lfs = require 'lfs'
 local json = require 'dkjson'
 local markdown = require 'discount'
 local fl = require 'ferron.utilities.file-utils'
 local tb = require 'ferron.utilities.table-utils'
 local tp = require 'ferron.utilities.template-utils'
 local feed = require 'ferron.feed'
 
 local function sortentries(entries_tb, list_mt)
   local list_length = list_mt.length or nil
   local entries_count = list_length and 0 or nil
 
   if entries_count then
     for k, v in tb.sortdescendingpairs(entries_tb) do
       if entries_count < list_length then
         table.insert(list_mt['entries'], v)
 
         entries_count = entries_count + 1
       end
     end
   else
     for k, v in tb.sortdescendingpairs(entries_tb) do
       table.insert(list_mt['entries'], v)
     end
   end
 
   return list_mt['entries']
 end
 
 local function setentries(directory, list_mt, sitedata)
   local entries_tb = {}
 
   tb.each(
     function(entry)
       local entry_metadatas  = fl.getpageconf(entry)
       local entry_key = entry_metadatas.date .. 'T' .. entry_metadatas.datetime .. ':' .. fl.getrelpath(fl.removeextension(entry), sitedata.content)
 
       entries_tb[entry_key] = Ferron.site.pagestable[entry_key]
     end,
     tb.filter(fl.isNotIndex, tb.from(fl.getdirtree(directory)))
   )
 
   sortentries(entries_tb, list_mt)
 
   return list_mt['entries']
 end
 
 local function setpagetable(meta, relpath)
   local pagekey = meta.date .. 'T' .. meta.datetime .. ':' .. relpath
 
   Ferron.site.pagestable[pagekey] = meta
 
   return
 end
 
 local function setpagemodel(page, sitedata)
   return {
     content = markdown(fl.pullfilecontent(page)),
     navigation = sitedata.navigation,
     permalink = fl.getpermalink(page, sitedata),
     rellink = fl.getrellink(page, sitedata.content),
     site = sitedata.config,
     id = fl.setpageid(page, sitedata),
     entries = {},
     updated = os.date('%Y-%m-%dT%H:%M:%S', lfs.attributes(page).modification),
     lastupdated = os.date('%Y-%m-%dT%H:%M:%S', fl.getlastupdateddate(sitedata.nodes))
   }
 end
 
 function page.render(page, sitedata)
   local pathRel = fl.getrelpath(fl.removeextension(page), sitedata.content)
   local pathToHtml = fl.sethtmlpath(fl.getrelpath(fl.getdirname(page), sitedata.content), sitedata.html)
   local metaTable = setmetatable(
     setpagemodel(page, sitedata), {__index = fl.getpageconf(page)}
   )
   local shortlinks_db
   local shortlinks_tb
 
   -- If draft is set to true
   -- Don't render the page
   if metaTable.draft then
     print(metaTable.draft, metaTable.title)
     return
   end
 
   -- If in among navigation location values the permalink exists
   -- Then set current parameter to true
   -- Else set it to false
   tb.each(
     function(i)
       if i.location == metaTable.permalink then
         i.current = true
       else
         i.current = false
       end
     end,
     metaTable.navigation
   )
 
   -- Populate Ferron.site.pagestable{}
   if fl.isNotIndex(page) then
     setpagetable(metaTable, pathRel)
   end
 
   -- If exists set the shortlink
   if fl.isNotIndex(page) then
     shortlinks_db = fl.isFile(sitedata.data .. '/shortlinks.json')
     shortlinks_tb = (shortlinks_db ~= false and json.decode(fl.pullfilecontent(shortlinks_db)) or nil)
 
     if shortlinks_tb and shortlinks_db then
       metaTable.shortlink = (shortlinks_tb[metaTable.rellink] and shortlinks_tb[metaTable.rellink] or nil)
     end
   end
 
   -- For index page set and get entries
   if fl.isIndex(page) and metaTable.listchildnodes ~= false then
     setentries(fl.getdirname(page), metaTable, sitedata)
   end
 
   -- If the ancestors of the page dosen't exists make it
   if not fl.isDirectory(pathToHtml) then
     fl.mkdir(pathToHtml)
   end
 
   -- For each index page create syndication feeds
   if fl.isIndex(page) and metaTable.feed ~= false then
     feed.makefeed(metaTable, pathToHtml)
   end
 
   -- Build and push the HTML page
   fl.pushfilecontent(
     pathToHtml .. fl.getplainname(page) .. '.html',
     tp.rendertemplate(
       tp.selecttemplate(fl.isIndex(page), metaTable.template, sitedata.templates),
       metaTable
     )
   )
 
   return fl.isFile(pathToHtml .. fl.getplainname(page) .. '.html')
     and print(pathToHtml .. fl.getplainname(page) .. '.html')
 end
 
 function page.makepages(sitedata)
   local singlepages = tb.filter(fl.isNotIndex, tb.from(fl.getdirtree(fl.isDirectory(sitedata.content))))
   local indexpages = tb.filter(fl.isIndex, tb.from(fl.getdirtree(fl.isDirectory(sitedata.content))))
 
   -- Render single pages
   tb.each(function(p) page.render(p, sitedata) end, singlepages)
 
   -- Render index pages
   tb.each(function(p) page.render(p, sitedata) end, indexpages)
 
   print('==========')
   print('§ ' .. tb.length(Ferron.site.pagestable) .. ' HTML pages have been created.')
   print('==========')
 
   return
 end
 
 return setmetatable(page, pagemeta)