imported>Primefac: Primefac moved page Module:NLG to Module:Sandbox/Jeblad/NLG without leaving a redirect: per TFD

2019-11-17T04:05:22Z

Primefac moved page Module:NLG to Module:Sandbox/Jeblad/NLG without leaving a redirect: per TFD

New page

local nlg = {}

--- Create the intersection of two tag sets
local function intersection( a, b )
local check = {}
for _,v in ipairs(a) do
check[v] = true
end
local found = {}
for _,v in ipairs(b) do
if check[v] then
found[1+#found] = v
end
end
return found
end

local classes = {}
-- this should probably in a separate module
local layout = {
['lead-in'] = 0,
['history'] = 50,
['geography'] = 60,
['politics'] = 70,
['early-life'] = 30,
['death'] = 40,
['legacy'] = 50,
['bibliography'] = 60,
['notes'] = 70,
['footnotes'] = 70,
['references'] = 80,
['literature'] = 90,
['external-links'] = 100,
}

local function createFromClass(t)
return classes[t.class] and classes[t.class](t)
end

local function createFromWeight(t)
local max = -100
local constructor = nil
local class = nil
for _,v in pairs(classes) do
local weight = v.weight(t)
if weight>max then
max = weight
constructor = v
end
end
return constructor and constructor(t)
end

local function create(t)
return createFromClass(t) or createFromWeight(t)
end

--- Table acting as a baseclass for Plan
local Plan = {}
Plan.__index = Plan

classes.plan = Plan

setmetatable(Plan, {
__call = function(cls, ...)
local self = setmetatable({}, cls)
self:_init(...)
return self
end,
})

--- Initialiser for the Plan class
-- @param t table holding additional data
function Plan:_init( t )
self._data = t
self._active = true
self._position = 0
if self._data.class == nil then
self._class = self:class()
end
end

--- Get nudge
-- @return number
function Plan:nudge()
for k,v in pairs(layout) do
return self._class or self._data.class or 'plan'
end
return
end

--- Get class
-- @return string
function Plan:class()
return self._class or self._data.class or 'plan'
end

--- Is status active?
-- @return boolean
function Plan:isActive()
return self._active
end

--- Activate status
-- @return boolean
function Plan:activate()
self._active = true
return self._active
end

--- Deactivate status
-- @return boolean
function Plan:deactivate()
self._active = false
return self._active
end

--- Weight of the given class viewed as a possible Plan instance
-- @param t table holding data used during test
function Plan.weight( t )
local weight = 0
if not t then
return weight
end
weight = weight + (t.class == 'plan' and 100 or 0)
weight = weight + (t.tags and 10 or 0)
weight = weight + (t.preconditions and 10 or 0)
weight = weight + (t.postconditions and 10 or 0)
return weight
end

--- Get the spawned tags by optionally filtering out a subset
-- @param id(s) from the tagset
-- @return table of Tags, otherwise empty table
function Plan:tags(...)
local args = {...}
if #args == 0 then
return self._data.tags or {}
else
return intersection({...}, self._data.tags)
end
end

--- Get the preconditions
-- @return table of Expressions, otherwise empty table
function Plan:preconditions()
return self._data.preconditions or {}
end

--- Get the postconditions
-- @return table of Expressions, otherwise empty table
function Plan:postconditions()
return self._data.postconditions or {}
end

--- Table acting as a subclass for Document
local Document = {}
Document.__index = Document

classes.document = Document

setmetatable(Document, {
__index = Plan,
__call = function (cls, ...)
local self = setmetatable({}, cls)
self:_init(...)
return self
end,
})

--- Initialiser for the Document class
-- @param t table holding additional data
function Document:_init( t )
Plan._init(self, t)
end

--- Get class
-- @return string
function Document:class()
return self._class or self._data.class or 'document'
end

--- Weight of the given class viewed as a possible Document instance
-- @param t table holding data used during test
function Document.weight( t )
local weight = 0
if not t then
return weight
end
weight = weight + 0.9*Plan.weight(t)
weight = weight + (t.class == 'document' and 100 or 0)
weight = weight + (t.constituent and 10 or 0)
weight = weight + (t.title and 10 or 0)
return weight
end

--- Get the title
-- @return any if found, otherwise nil
function Document:title()
return self._data.title
end

--- Get the constituents
-- @return table of Plan, otherwise empty table
function Document:constituents()
return self._data.constituents or {}
end

--- Get the activeConstituents
-- @return table of Plan, otherwise empty table
function Document:constituents()
local found = {}
for _,v in ipairs(self._data.constituents or {}) do
found[1+#found] = v
end
return found
end

--- Table acting as a subclass for Constituent
local Constituent = {}
Constituent.__index = Constituent

classes.constituent = Constituent

setmetatable(Constituent, {
__index = Plan,
__call = function (cls, ...)
local self = setmetatable({}, cls)
self:_init(...)
return self
end,
})

--- Initialiser for the Constituent class
-- @param t table holding additional data
function Constituent:_init( t )
Plan._init(self, t)
end

--- Get class
-- @return string
function Constituent:class()
return self._class or self._data.class or 'constituent'
end

--- Weight of the given class viewed as a possible Constituent instance
-- @param t table holding data used during test
function Constituent.weight( t )
local weight = 0
if not t then
return weight
end
weight = weight + 0.9*Plan.weight(t)
weight = weight + (t.class == 'constituent' and 100 or 0)
weight = weight + (t.nucleus and 10 or 0)
weight = weight + (t.satelite and 10 or 0)
weight = weight + (t.constituents and 10 or 0)
weight = weight + (t.relation and 10 or 0)
return weight
end

if 1 or _G['_BDD'] then
nlg['filter'] = filter
nlg['create'] = create
nlg['createFromClass'] = createFromClass
nlg['createFromWeight'] = createFromWeight
nlg['Plan'] = Plan
nlg['Document'] = Document
nlg['Constituent'] = Constituent
end

nlg.load = function(...)
local constituents = {}
for _,v in ipairs({...}) do
local data = nil
local title = 'Module:NLG/' .. v
if pcall(function() data = mw.loadData( title ) end) and data then
for _,w in ipairs(data) do
constituents[1+#constituents] = create(w)
end
end
end
local root = Document({
['class'] = 'document',
['constituents'] = constituents
})
return root
end

return nlg

Module:Sandbox/Jeblad/NLG - Revision history

imported>Primefac: Primefac moved page Module:NLG to Module:Sandbox/Jeblad/NLG without leaving a redirect: per TFD