Żółty Kapłan: 1 wersja

2025-12-07T22:28:36Z

1 wersja

← poprzednia wersja		Wersja z 00:28, 8 gru 2025
(Brak różnic)

wpl>Nux: revert, return printlog 🙈

2025-04-12T14:11:53Z

revert, return printlog 🙈

Nowa strona

require ("strict")

local res = mw.loadData('Moduł:Navbox/res')

local p = {}
local priv = {} -- private functions scope
-- expose private for easy testing/debugging
p.__priv = priv

function priv.encodeClass(name)
local t = mw.getContentLanguage():lcfirst(name)
local s = mw.ustring.gsub(t, ".", { ['ł'] = 'l', ['Ł'] = 'L', ['_'] = ' '}) -- wstępne zmiany ł->l i _-> spacja
local p = mw.ustring.gsub(s, "%p+", "-") -- znaczki nieliterowe na minusy
local q = mw.ustring.gsub(p, "%s+", "_") -- odstępy na podkreślenia
local r = mw.ustring.toNFD(q) -- wyodrębnij diakrytyki
local e = string.gsub(r,"[\127-\255]+",'') -- usuń to czego nie ma w ASCII
return e
end

function priv.getPrinter(name)
local printer = res.printers[name]
return printer and require(printer) or nil
end

function priv.printSubTree(container, tree, currentPrinter, printlog)

local function printList(container, node, collapsibleContent)
local mwCCC = collapsibleContent and 'mw-collapsible-content' or nil
if #node <= 0 then
if printlog then
printlog.printedLeafs = (printlog.printedLeafs or 0) + 1
end
local leaf
if (currentPrinter.leaf == 'table') and mwCCC then
-- zwijanie tabelki i skórka timeless się gryzą
leaf = container:tag('div')
:addClass(mwCCC)
:tag(currentPrinter.leaf)
elseif currentPrinter.leaf then
leaf = container:tag(currentPrinter.leaf)
:addClass(mwCCC)
else
leaf = container
:addClass(mwCCC)
end
if currentPrinter.update then currentPrinter.update(leaf, true, node, printlog) end
leaf
:addClass(node.odd())
:addClass(node.even())
:newline()
:wikitext(node.get(res.arg.list.name))
:newline()
else
local subprinter = priv.getPrinter(node.peek(res.arg.list.name))
if subprinter then
node.use(res.arg.list.name)
else
subprinter = priv.getPrinter(true)
end
local subtag = subprinter.root or subprinter.leaf or 'div'
local subtree = ((subtag == 'table') and mwCCC)
and container:tag('div'):addClass(mwCCC):tag(subtag) -- zwijanie tabelki i skórka timeless się gryzą
or container:tag(subtag):addClass(mwCCC)
if currentPrinter.update then currentPrinter.update(subtree, false, node, printlog) end
priv.printSubTree(subtree, node, subprinter, printlog)
end
end

currentPrinter.print(container, tree, printList, printlog)
end

function priv.argsService(templateContext)
local args = {}

local function add(k, v, prefix)
if v and #v > 0 then
args[k] = v
end
end

local peekName = function(name)
if not args[name] and templateContext and templateContext.aliases then
local alias = templateContext.aliases[name]
if alias and args[alias] then
return alias
end
end

return name
end

local function peek(name)
return args[peekName(name)]
end

local function get(name)
return peek(peekName(name)) or (res.aux.missingArgNamePrefix..name..res.aux.missingArgNameSuffix)
end

local function dump()
return mw.text.jsonEncode(args)
end

return {
add = add,
peek = peek,
use = peek,
get = get,
dump = dump,
}
end

function priv.loadArgsTree(args, printlog, templateContext)

local dynamicArgs = {}
for k, v in pairs(res.arg) do
if templateContext and templateContext.aliases then
local alias = templateContext.aliases[v.name]
if v.dynamic and alias then dynamicArgs[alias] = v.dynamic end
end
if v.dynamic then dynamicArgs[v.name] = v.dynamic end
end

local splitArgName = function(name)
if type(name) ~= "string" then
--mw.logObject(name, "to nie jest tekst")
return false, nil
end

local prefix, suffix = mw.ustring.match(name, "^(.-)([1-9][%.0-9]*)$")
if not prefix or not dynamicArgs[prefix] then
--mw.logObject(name, "wzór nie pasuje lub nierozpoznany")
return false, nil
end

local keys = mw.text.split(suffix,'.',true)
for i = 1, #keys do
keys[i] = tonumber(keys[i])
if not keys[i] or (keys[i] == 0) then
--mw.logObject({name, keys, i, keys[i]}, "wzór ma błędy")
return false, nil
end
end

return prefix, keys
end

local updateIndex = function(node, k)
node.index = node.index or {}
for i, v in ipairs(node.index) do
if v == k then
return
end
end

table.insert(node.index, k)
table.sort(node.index)
end

local argsTree = not printlog
and priv.argsService(templateContext)
or require('Moduł:Navbox/diag').argsService(templateContext)
local argsTree_add = argsTree.add
argsTree.add = nil
local argsTree_tree = nil

local tree = function()
if not argsTree_tree or (#argsTree_tree <= 0) then
return nil
end

local function createNode(v)

local peekName = function(name)
if not v.address then
return nil
end

if argsTree.peek(name..v.address) then
return name..v.address
end

if templateContext and templateContext.aliases then
local alias = templateContext.aliases[name]
if alias and peek(alias..v.address) then
return alias..v.address
end
end

return nil
end

local node = {
address = function() return v.address and "a"..string.gsub(v.address, '%.', '_') or nil end,
peek = function(name)
return peekName(name)
and argsTree.peek(peekName(name))
or (templateContext and templateContext.defaults and templateContext.defaults[name])
end,
use = function(name) return peekName(name) and argsTree.use(peekName(name)) or nil end,
get = function(name) return peekName(name) and argsTree.get(peekName(name)) or nil end,
odd = function() return v.odd and res.class.odd or nil end,
even = function() return v.even and res.class.even or nil end,
}

local function calculateTest()
local pattern = mw.loadData("Moduł:Navbox/title").wikilinkPattern
local s1 = argsTree.peek(res.arg.group.name..v.address)
if s1 and mw.ustring.match(s1, pattern) then return true end
local s2 = argsTree.peek(res.arg.list.name..v.address)
if s2 and mw.ustring.match(s2, pattern) then return true end
for i, n in ipairs(node) do
if n.test(pattern) then return true end
end
return false
end

local testCache

node.test = function()
if testCache == nil then
testCache = calculateTest()
end

return testCache
end

return node
end

local function buildTree(buffer, tree)
for i, v in ipairs(tree.index) do
local data = tree[v]
local node = createNode(data)
table.insert(buffer, node)
if data.index then
buildTree(node, data)
end
end
end

local rootNode = createNode({})
buildTree(rootNode, argsTree_tree)
return rootNode
end

local function analyzeArg(k, v, prefix, keys)
argsTree_add(k, v, prefix)
if prefix and v and (#v > 0) then
argsTree_tree = argsTree_tree or {}
local node = argsTree_tree
for i = 1, #keys do
local k = keys[i]
local child = node[k]
updateIndex(node, k)
if not child then
child = {
address = node.address and (node.address..'.'..tostring(k)) or tostring(k),
}
node[k] = child
end

node = child
end
end
end

for k, v in pairs(args) do
local prefix, keys = splitArgName(k)
local json, subargs
if (prefix == res.arg.list.name) and v and (#v > 0) then
json, subargs = pcall(mw.text.jsonDecode, v)
end
if json then
--analyzeArg(k, '* szablon *', prefix, keys)
for vk, vv in pairs(subargs) do
local vprefix, vkeys = splitArgName(vk)
if not vprefix and (vk == res.arg.list.name) then
vprefix = vk
vkeys = {}
end
if vprefix and prefix then
local newKeys = {}
for j, u in ipairs(keys) do table.insert(newKeys, u) end
for j, u in ipairs(vkeys) do table.insert(newKeys, u) end
local n = {}
for j, u in ipairs(newKeys) do table.insert(n, tostring(u)) end
local name = vprefix..table.concat(n, '.')
analyzeArg(name, vv, vprefix, newKeys)
end
end
else
analyzeArg(k, v, prefix, keys)
end
end

if templateContext and priv.getPrinter(templateContext.list) then
analyzeArg(res.arg.list.name, templateContext.list, nil, nil)
end

if argsTree_tree then
local tree = argsTree_tree

local function loadLeafNodes(tree, buffer, level)
if not tree.index then
table.insert(buffer, tree)
else
local n = level
for i, v in ipairs(tree.index) do
local k = loadLeafNodes(tree[v], buffer, level + 1)
if k > n then
n = k
end
end

level = n
end

return level
end

local buffer = {}
local levels = loadLeafNodes(tree, buffer, 0)
for i, v in ipairs(buffer) do
v.odd = (i % 2) == 1
v.even = (i % 2) == 0
end

if printlog then
printlog.levels = levels
printlog.leafs = #buffer
end
end

argsTree.tree = tree

--mw.logObject(printlog, 'printlog')
--mw.logObject(argsTree, 'argsTree')
return argsTree
end

function priv.drawMiniNavBar(container, title, tags)
local pde = container:tag('ul')
:addClass('tnavbar')
:addClass('noprint')
:addClass('plainlinks')
:addClass('hlist')
-- p
local p = pde:tag('li'):wikitext("[[", title.nsText, ':', title.text, '|')
p:tag('span'):attr('title', res.navbar.p):wikitext(tags.p)
p:wikitext(']]')
-- d
if not title.isTalkPage then
local tt = title.talkPageTitle
local d = pde:tag('li'):wikitext("[[", tt.nsText, ':', tt.text, '|')
d:tag('span'):attr('title', res.navbar.d):wikitext(tags.d)
d:wikitext(']]')
end
-- e
pde:tag('li')
:attr('title', res.navbar.e)
:wikitext('[', title:fullUrl("action=edit"), ' ', tags.e, ']')
-- U
if mw.title.equals(title, mw.title.getCurrentTitle()) and (title.namespace == 10) then
local fullpagenamee = mw.uri.encode(title.fullText, "WIKI")
pde:tag('li')
:attr('title', res.navbar.U)
:wikitext('[https://tools.wmflabs.org/templatetransclusioncheck/index.php?lang=pl&name=', fullpagenamee, ' ', tags.U, ']')
end
end

function priv.splitCustomClasses(customClasses, navboxName)
if not customClasses then
return {}
end

local result = {}
local cc = mw.text.split(customClasses,"%s+")
for i, v in ipairs(cc) do
result[v] = res.validExtraClasses[v] ~= nil
end

-- pionowy szablon tylko na początku artykułu
if result.pionowy and navboxName then
local title = mw.title.getCurrentTitle()
if title and title.namespace == 0 then
local content = title:getContent()
if content then
local navboxStart = mw.ustring.find(content, "{{%s*"..mw.ustring.gsub( navboxName, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" ).."%s*}}")
if navboxStart then
local firstSectionStart = mw.ustring.find(content, "\n==.-==[ \t]*\n")
if firstSectionStart and (firstSectionStart < navboxStart) then
mw.logObject(result, "splitCustomClasses KASUJĘ pionowy bo nie jest na początku artykułu")
result.pionowy = false
end
end
end
end
end

return result
end

function priv.makeContainer(args, title, contentTag, printlog)
local templateClassName = (title and (title.namespace > 0) and not title.isTalkPage)
and priv.encodeClass(title.namespace == 10 and title.text or title.fullText)
or nil
local builder = mw.html.create('div')
:addClass(res.class.navbox)
:addClass('do-not-make-smaller')
local classes = priv.splitCustomClasses(args.use(res.arg.class.name), args.peek(res.arg.name.name))
for c, valid in pairs(classes) do
builder:addClass((valid and res.validExtraClasses[c]) and c or nil)
end
if title and mw.title.equals(title, mw.title.getCurrentTitle()) or (classes[templateClassName] ~= nil) then
builder:addClass(templateClassName and res.class.name..templateClassName or nil)
end
builder:wikitext(mw.getCurrentFrame():extensionTag( 'templatestyles', '', {src = "Szablon:Navbox/styles.css"}))
local privateCSS = false
if classes[templateClassName] ~= nil then
privateCSS = tostring(title.fullText.."/styles.css")
builder:wikitext(mw.getCurrentFrame():extensionTag( 'templatestyles', '', {src = privateCSS}))
end
if not classes.pionowy then
builder:addClass('mw-collapsible'):attr('data-expandtext', res.aux.expandText):attr('data-collapsetext', res.aux.collapseText)

local collapse = function()
if mw.title.getCurrentTitle().namespace == 0 then
return 'mw-collapsed'
end

if args.peek(res.arg.collapsible.name) == res.arg.collapsible.collapsed then
return 'mw-collapsed'
end

if mw.title.getCurrentTitle().namespace ~= 10 then
return 'autocollapse'
end

return nil
end

if title then
builder:addClass(not mw.title.equals(title, mw.title.getCurrentTitle()) and collapse() or nil)
priv.drawMiniNavBar(builder, title, res.navbar.mini)
else
builder
:addClass(mw.title.getCurrentTitle().namespace ~= 10 and collapse() or nil)
:tag('span'):addClass(res.navbar.fake)
end
end
builder:tag('div')
:addClass(res.class.caption)
:wikitext(args.get(res.arg.title.name))
local content
if not args.peek(res.arg.above.name) and not args.peek(res.arg.below.name) and not args.peek(res.arg.before.name) and not args.peek(res.arg.after.name) and not classes.pionowy then
if contentTag == 'table' then -- zwijanie tabeli gryzie się ze skórką timeless
content = builder:tag('div')
:addClass('mw-collapsible-content')
:tag(contentTag)
else
content = builder:tag(contentTag)
:addClass('mw-collapsible-content')
end
elseif not args.peek(res.arg.above.name) and not args.peek(res.arg.below.name) and not classes.pionowy then
local flex = builder:tag('div')
:addClass('mw-collapsible-content')
:addClass(res.class.flex)
if args.peek(res.arg.before.name) then flex:tag('div'):addClass(res.class.before):newline():wikitext(args.get(res.arg.before.name)):newline() end
content = flex:tag(contentTag)
if args.peek(res.arg.after.name) then flex:tag('div'):addClass(res.class.after):newline():wikitext(args.get(res.arg.after.name)):newline() end
else
local content1 = builder:tag('div')
:addClass('mw-collapsible-content')
if args.peek(res.arg.above.name) then content1:tag('div'):addClass(res.class.hlist):addClass(res.class.above):newline():wikitext(args.get(res.arg.above.name)):newline() end
local flex = (not classes.pionowy and ((args.peek(res.arg.before.name) or args.peek(res.arg.after.name)))) and content1:tag('div'):addClass(res.class.flex) or content1
if args.peek(res.arg.before.name) then flex:tag('div'):addClass(res.class.before):newline():wikitext(args.get(res.arg.before.name)):newline() end
content = flex:tag(contentTag)
if args.peek(res.arg.after.name) then flex:tag('div'):addClass(res.class.after):newline():wikitext(args.get(res.arg.after.name)):newline() end
if (title and classes.pionowy) or args.peek(res.arg.below.name) then
local below = content1:tag('div'):addClass(res.class.hlist):addClass(res.class.below)
if args.peek(res.arg.below.name) then
below:newline():wikitext(args.get(res.arg.below.name)):newline()
end
if title and classes.pionowy then
if args.peek(res.arg.below.name) then
below:wikitext("----"):newline()
end
priv.drawMiniNavBar(below, title, res.navbar.short)
end
end
end

content:addClass(res.class.main)
for c, valid in pairs(classes) do
content:addClass((valid and not res.validExtraClasses[c]) and c or nil)
end

if printlog then
printlog.pionowy = classes.pionowy
printlog.templateClassName = templateClassName
printlog.privateCSS = privateCSS
for c, valid in pairs(classes) do
if not valid and (c ~= templateClassName) then
local u = printlog.unknownClasses or {}
table.insert(u, c)
printlog.unknownClasses = u
end
end
end

return builder, content
end

function priv.createNavbox(args, title, printlog)
local rootPrinter = priv.getPrinter(args.peek(res.arg.list.name))
if rootPrinter then
args.use(res.arg.list.name)
end
local rootTree = args.tree()
local rootTag = 'div'
if rootTree then
rootPrinter = rootPrinter or priv.getPrinter(true)
rootTag = rootPrinter and (rootPrinter.root or rootPrinter.leaf) or 'div'
end
local builder, content = priv.makeContainer(args, title, rootTag, printlog)
if rootTree then
priv.printSubTree(content, rootTree, rootPrinter or priv.getPrinter(true), printlog)
elseif not rootPrinter and args.peek(res.arg.list.name) then
if printlog then printlog.notree = true end
content
:newline()
:wikitext(args.get(res.arg.list.name))
:newline()
else
if printlog then printlog.example = true end
local exampleTree = {{
address = function() return res.class.address.."1" end,
peek = function(name) return nil end,
use = function(name) return nil end,
get = function(name) return args.get(name.."1") end,
odd = function(name) return nil end,
even = function(name) return nil end,
}}
priv.printSubTree(content, exampleTree, rootPrinter or priv.getPrinter(true), printlog)
end

return not printlog and tostring(builder) or require('Moduł:Navbox/diag').diagnosticView(builder, args, printlog)
end

function p.Navbox(frame)
local title = mw.title.new(frame:getParent():getTitle())
local printlog = mw.title.equals(title,mw.title.getCurrentTitle()) and {} or nil
local args = priv.loadArgsTree(frame.args, printlog)
return priv.createNavbox(args, title, printlog)
end

function p.Template(frame)
local rawArgs = frame:getParent().args

local title = frame:getParent():getTitle()
mw.log('\n== '..title..' ==\n')
local name = rawArgs[res.arg.name.name]
local titleObject = (name and (#name > 0)) and mw.title.new(name, "Template") or nil

local printlog = priv.verifyTemplateTitle(title, name, titleObject)
return priv.Template(rawArgs, frame.args.context, titleObject, printlog)
end

function priv.verifyTemplateTitle(title, name, expectedTitle)
-- specjalne traktowanie nazwy
local printlog = false
if expectedTitle then
local currentTitle = mw.title.getCurrentTitle()
if (currentTitle.namespace == expectedTitle.namespace)
and (currentTitle.namespace ~= 0) -- bez artykułów
and (currentTitle.namespace ~= 2) -- bez brudnopisów
and not currentTitle.isTalkPage
and (currentTitle.subpageText ~= res.aux.docSubpageText) -- bez opisów
and (not expectedTitle.exists or not require('Moduł:Navbox/diag').verifyTemplateName(currentTitle, expectedTitle, title)) then
printlog = {}
printlog.badName = true
elseif mw.title.equals(currentTitle, expectedTitle) then
printlog = {}
end
elseif name and (#name > 0) then
-- tutaj nie ma żadnych możliwości sprawdzenia czy to jest szablon
-- czy jego transkluzja
local currentTitle = mw.title.getCurrentTitle()
if (currentTitle.namespace ~= 0) and not currentTitle.isTalkSpace then
printlog = {}
printlog.badName = true
end
end
return printlog
end

function priv.Template(rawArgs, context, titleObject, printlog)

local status, templateContext = pcall(mw.text.jsonDecode, context or '[]')
if not status then
-- mw.logObject(context, templateContext)
templateContext = {}
end
-- mw.logObject(templateContext, 'templateContext')

local args = priv.loadArgsTree(rawArgs, printlog, templateContext)
if args.peek(res.arg.name.name) then args.use(res.arg.name.name) end
--mw.logObject(mw.text.jsonDecode(args.dump()), 'args.dump()')
if printlog and templateContext.list then
printlog.useTemplateCategories = true
end

local navbox = args.peek(res.arg.name.name)
or args.peek(res.arg.title.name)
or args.peek(res.arg.class.name)
or args.peek(res.arg.above.name)
or args.peek(res.arg.below.name)
or args.peek(res.arg.before.name)
or args.peek(res.arg.after.name)
if navbox then
-- mw.log("----> createNavbox")
return priv.createNavbox(args, titleObject, printlog)
end

-- mw.log("----> dump")
return args.dump()
end

return p

Moduł:Navbox - Historia wersji

Żółty Kapłan: 1 wersja

wpl>Nux: revert, return printlog 🙈