Moduł:Navbox/diag
Przejdź do nawigacji
Przejdź do wyszukiwania
Dokumentacja dla tego modułu może zostać utworzona pod nazwą Moduł:Navbox/diag/opis
Błąd skryptu: Błąd Lua: Nie można utworzyć procesu: proc_open(/dev/null): failed to open stream: Operation not permitted
local res = mw.loadData('Moduł:Navbox/res')
local function fullMatch ( str )
return '^'..mw.ustring.gsub( str, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" )..'$'
end
local function templateMatch ( name )
local title = mw.title.new(name)
local text = title.namespace ~= 10 and name or title.text
return "{{%s*"..mw.ustring.gsub( text, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" ).."[%s|]"
end
local function loadKeys ( tab )
local result = {}
for k, v in pairs(tab) do
table.insert(result, k)
end
return result
end
local function copySequenceExcept(tab, unwanted)
local skip = {}
if unwanted then
for i, v in ipairs(unwanted) do
skip[v] = true
end
end
local result = {}
for i, v in ipairs(tab) do
if not skip[v] then
table.insert(result, v)
end
end
return result
end
local FindPositionsInReverseOrder = function(text, plainPattern)
local result = {}
if #plainPattern > 0 then
local init = 1
while init do
init = string.find(text, plainPattern, init, true)
if init then
table.insert(result, 1, init)
init = init + #plainPattern
end
end
end
return result
end
local RemoveInPlace = function(text, start, len)
local before = start > 1 and string.sub(text, 1, start-1) or ""
local stop = start + len
local after = stop <= #text and string.sub(text, stop) or ""
return before..string.rep("_", len)..after
end
local diag = {
classStats = "navbox-statistics",
categoryCSS = "[[Kategoria:Szablony nawigacyjne ze stylami]]",
categoryProblems = "[[Kategoria:Szablony nawigacyjne – spisy do sprawdzenia]]",
categorySuspected = "[[Kategoria:Szablony nawigacyjne – spisy podejrzane]]",
categoryWikilinks0 = "[[Kategoria:Szablony nawigacyjne – spisy bez linków]]",
categoryWikilinks1 = "[[Kategoria:Szablony nawigacyjne – tylko 1 link]]",
categoryWikilinks2 = "[[Kategoria:Szablony nawigacyjne – tylko 2 linki]]",
categoryWikilinks3 = "[[Kategoria:Szablony nawigacyjne – tylko 3 linki]]",
categoryWikilinks4 = "[[Kategoria:Szablony nawigacyjne – tylko 4 linki]]",
categoryLargeList = "[[Kategoria:Szablony nawigacyjne – ponad 500 pozycji]]",
categoryUnknownArgs = "[[Kategoria:Szablony nawigacyjne – nieznane parametry]]",
categoryManyColumns = "[[Kategoria:Szablony nawigacyjne – dużo kolumn]]",
categoryVertical = "[[Kategoria:Szablony nawigacyjne – pionowe]]",
categoryBadName = "[[Kategoria:Szablony nawigacyjne ze złym parametrem nazwa]]",
categoryNavboxInside = "[[Kategoria:Szablony nawigacyjne – zagnieżdżone]]",
categoryAnonymousLists = "[[Kategoria:Szablony nawigacyjne – nieopisane spisy]]",
categoryCheckWikicode = "[[Kategoria:Szablony nawigacyjne – wikikod do sprawdzenia]]",
categoryUnusedArgs = "[[Kategoria:Szablony nawigacyjne – nieużywane parametry]]",
categoryUnverifiedArgs = "[[Kategoria:Szablony nawigacyjne – nieprawidłowe parametry]]",
categoryMissingArgs = "[[Kategoria:Szablony nawigacyjne – brakujące parametry]]",
categoryEmptyArgs = "[[Kategoria:Szablony nawigacyjne – puste parametry]]",
categoryMissingWikilink = "[[Kategoria:Szablony nawigacyjne – spis bez linków]]",
listItem = "^[%*#:]",
wikilink = "%[%[ *%S[^\r\n]- *%]%]",
problemIndicator = '<sup class="problemy-w-navbox problemy">?</sup>',
suspectedIndicator = '<sup class="suspected problemy">!</sup>',
navboxInside = '^<([a-z]+) class="navbox ',
-- wzory wyrażeń regularnych
verificators = {
["nazwa"] = {
inverted = true,
patterns = {
"[%c#%[%]%{%}|<>_\127]", -- niedozwolone znaki
"^:", -- artykuły?
"^%.$",
"^%.%.$",
"^%./",
"^%.%./",
"/%./",
"/%.%./",
"/%.$",
"/%.%.$",
"~~+",
},
},
["tytuł"] = {
inverted = true,
patterns = {
-- pliki
"%[%[ *[Pp][Ll][Ii][Kk] *:.-%]%]",
"%[%[ *[Ff][Ii][Ll][Ee] *:.-%]%]",
-- listy
"^[%*#:]",
"\n[%*#:]",
},
},
["klasa"] = {
inverted = false,
patterns = {
"^[%w%-_ ]+$",
},
},
["lista"] = {
inverted = false,
patterns = {
"^[%*#:]",
"\n[%*#:]",
},
},
["tekst lub lista"] = {
inverted = false,
patterns = {
"%S", -- cokolwiek byle nie pusto
},
},
["grafika"] = {
inverted = false,
patterns = {
"%[%[ *[Pp][Ll][Ii][Kk] *:.-%]%]",
"%[%[ *[Ff][Ii][Ll][Ee] *:.-%]%]",
"%[%[ *[Gg][Rr][Aa][Ff][Ii][Kk][Aa] *:.-%]%]",
},
},
["zwijanie"] = {
inverted = false,
patterns = {
fullMatch(res.arg.collapsible.collapsed),
fullMatch(res.arg.collapsible.expanded),
fullMatch(res.arg.collapsible.auto),
fullMatch(res.arg.collapsible.disabled),
},
},
},
statsMessage = "Pozycje linkujące: $1, specjalne: $2, problemy$3: $4, '''RAZEM: $5'''",
suspectedMessage = " (podejrzane$1: $2)",
templateCats = {
args = { "kategoria", "kategoria2", "kategoria3", "kategoria4", "kategoria5", "kategoria6", },
ns = "Kategoria",
prefix = "Szablony nawigacyjne - ",
default = "Kategoria:Szablony nawigacyjne",
disabled = "nie",
},
sourceCatsPatterns = {
"%[%[ *[Kk][Aa][Tt][Ee][Gg][Oo][Rr][Ii][Aa] *: *([^|%[%]]-) *|[^|%[%]]-%]%]",
"%[%[ *[Kk][Aa][Tt][Ee][Gg][Oo][Rr][Ii][Aa] *: *([^|%[%]]-) *%]%]",
"%[%[ *[Cc][Aa][Tt][Ee][Gg][Oo][Rr][Yy] *: *([^|%[%]]-) *|[^|%[%]]-%]%]",
"%[%[ *[Cc][Aa][Tt][Ee][Gg][Oo][Rr][Yy] *: *([^|%[%]]-) *%]%]",
},
brPattern = "<[bB][Rr] ?/?>",
suspectedText = {
'•', '•', '•', '•',
'·', '·', '·', '·',
'∙', '∙', '∙',
},
brackets = {
pattern = "[%(%)%[%]]",
['('] = ')',
['['] = ']',
[')'] = '(',
[']'] = '[',
}
}
local function printStatistics(builder, diagItems)
local wikilinks = 0
local nowikis = 0
local problems = 0
local suspected = 0
for k, v in pairs(diagItems) do
wikilinks = wikilinks + v.wikilinks
nowikis = nowikis + v.nowikis
problems = problems + v.problems
suspected = suspected + v.suspected
end
--local lang = mw.getContentLanguage()
local message = mw.message.newRawMessage(diag.statsMessage)
:numParams(wikilinks, nowikis)
:rawParams(diag.problemIndicator)
:numParams(problems, wikilinks + nowikis + problems)
local report = builder:tag('div')
:addClass(diag.classStats)
:wikitext(message:plain())
if suspected > 0 then
local message = mw.message.newRawMessage(diag.suspectedMessage)
:rawParams(diag.suspectedIndicator)
:numParams(suspected)
report:wikitext(message:plain())
end
report:wikitext(problems > 0 and diag.categoryProblems or nil)
report:wikitext(suspected > 0 and diag.categorySuspected or nil)
if wikilinks == 0 then
report:wikitext(diag.categoryWikilinks0)
elseif wikilinks == 1 then
report:wikitext(diag.categoryWikilinks1)
elseif wikilinks == 2 then
report:wikitext(diag.categoryWikilinks2)
elseif wikilinks == 3 then
report:wikitext(diag.categoryWikilinks3)
elseif wikilinks == 4 then
report:wikitext(diag.categoryWikilinks4)
elseif (wikilinks + nowikis + problems) > 500 then
report:wikitext(diag.categoryLargeList)
end
end
local function printListWithoutWikilinks(report, diagItems)
local nowikilinks = {}
for k, v in pairs(diagItems) do
if (v.wikilinks <= 0) and mw.ustring.match(k, '^'..res.arg.list.name..'%d') then
table.insert(nowikilinks, k)
end
end
if #nowikilinks > 0 then
report:newline():wikitext("; brak wikilinków: ", #nowikilinks, diag.categoryMissingWikilink)
for i, v in ipairs(nowikilinks) do
report:newline():wikitext(":* ", v)
end
end
end
local function printNested(report, diagItems)
--mw.logObject(diagItems, "nested")
local nested = {}
for k, v in pairs(diagItems) do
if v.inside then
table.insert(nested, k)
end
end
if #nested > 0 then
report:newline():wikitext("; zagnieżdżone szablony nawigacyjne: ", #nested, diag.categoryNavboxInside)
for i, v in ipairs(nested) do
report:newline():wikitext(":* ", v)
end
end
end
local function printWikicodeAnalyze(report)
local contents = mw.title.getCurrentTitle():getContent()
--mw.logObject(contents, 'contents')
local text = contents or "" -- pusty tekst jeśli nie ma strony
-- gumkowanie
text = string.gsub(text, "<!%-%-.-%-%->", '')
text = string.gsub(text, "<nowiki>.-</nowiki>", '')
text = string.gsub(text, "<math>.-</math>", '')
text = string.gsub(text, "<pre>.-</pre>", '')
text = string.gsub(text, "<noinclude>.-</noinclude>", '')
text = string.gsub(text, "<includeonly>(.-)</includeonly>", '%1')
--mw.logObject(text, 'text')
local cleanContents = text
-- wikilinki iteracyjnie od końca
for _, startPos in ipairs(FindPositionsInReverseOrder(text, "[[")) do
local endPos = string.find(text, "]]", startPos, true)
if endPos then
local eol = string.find(text, "\n", startPos, true)
if eol and (eol < endPos) then
endPos = nil
end
end
local len = endPos and (endPos - startPos + 2) or 2
text = RemoveInPlace(text, startPos, len)
end
local paramPos = {}
local templPos = {}
local ob = string.byte('{')
local cb = string.byte('}')
for _, startPos in ipairs(FindPositionsInReverseOrder(text, "{{")) do
local endPos = string.find(text, "}}", startPos, true)
local len = endPos and (endPos - startPos + 2) or 2
local sPos = startPos
if (startPos > 1) and ((startPos + len) <= #text) and (string.byte(text, startPos + 2) == ob) and (string.byte(text, startPos + len) == cb) then
-- parametr szablonu
len = len + 1
paramPos[startPos] = len
elseif len ~= 2 then
templPos[startPos] = len
end
-- usuń szablony zawarte wewnątrz znaleziska
local inside = {}
local ePos = sPos + len
for s, l in pairs(templPos) do
local e = s + l
if (s > sPos) and (s < ePos) and (e > sPos) and (e < ePos) then
table.insert(inside, s)
end
end
for i, v in ipairs(inside) do
templPos[v] = nil
end
-- zarejestruj pozycję znaleziska
text = RemoveInPlace(text, sPos, len)
end
local notFound = 10000000000
local params = {}
for k, v in pairs(paramPos) do
local e1 = string.find(cleanContents, "|", k, true) or notFound
local e2 = string.find(cleanContents, "\n", k, true) or notFound
local e3 = string.find(cleanContents, "}}}", k, true) or notFound
local e = math.min(e1, e2, e3)
assert(e < notFound)
assert(e > (k + 2))
local paramname = mw.text.trim(string.sub(cleanContents, k + 3, e - 1))
params[paramname] = true
end
local paramnames = loadKeys(params)
local templates = {}
for k, v in pairs(templPos) do
local e1 = string.find(cleanContents, "|", k, true) or notFound
local e2 = string.find(cleanContents, "\n", k, true) or notFound
local e3 = string.find(cleanContents, "}}", k, true) or notFound
local e = math.min(e1, e2, e3)
local p1 = false
if (e3 < notFound) and (e1 < e3) then
local e11 = string.find(cleanContents, "|", e1 + 1, true) or e3
p1 = mw.text.trim(string.sub(cleanContents, e1+1, e11-1))
end
assert(e < notFound)
assert(e > (k + 2))
local templateName = mw.text.trim(string.sub(cleanContents, k + 2, e - 1))
local invokeName = mw.ustring.match(templateName, "^#invoke:%s*(.+)$")
if invokeName and p1 then
templateName = "#invoke:"..mw.title.new(invokeName, "Module").text..'|'..p1
end
table.insert(templates, {
start = k,
len = v,
name = templateName,
})
end
report:newline():wikitext("; definicja szablonu")
if #templates == 1 then
local template = templates[1]
report:newline():wikitext(":"):tag('code'):wikitext(template.name)
if template.start > 1 then
local before = mw.text.nowiki(mw.text.trim(string.sub(cleanContents, 1, template.start - 1)))
if #before > 0 then
report:newline():wikitext(": znaleziono treść przed szablonem")
:newline():wikitext(":*"):tag('code'):wikitext(before)
else
report:newline():wikitext(": znaleziono odstęp przed szablonem")
end
report:wikitext(diag.categoryCheckWikicode)
end
local endPos = template.start + template.len
--mw.logObject(endPos, 'endPos')
--mw.logObject(#cleanContents, '#cleanContents')
if (endPos == #cleanContents) and (string.sub(cleanContents, endPos, endPos) == '\n') then
report:newline():wikitext(": znaleziono znak nowej linii za szablonem")
elseif endPos <= #cleanContents then
local after = mw.text.nowiki(mw.text.trim(string.sub(cleanContents, endPos)))
if #after > 0 then
report:newline():wikitext(": znaleziono treść za szablonem")
:newline():wikitext(":*"):tag('code'):wikitext(after)
else
report:newline():wikitext(": znaleziono odstęp za szablonem")
end
report:wikitext(diag.categoryCheckWikicode)
end
elseif #templates < 1 then
local text = mw.text.trim(cleanContents)
if #text > 0 then
report:newline():wikitext(": znaleziono jakąś treść zamiast szablonu")
else
report:newline():wikitext(": nie znaleziono żadnego szablonu")
end
report:wikitext(diag.categoryCheckWikicode)
else
report:newline():wikitext(": znaleziono wywołanie wielu szablonów", diag.categoryCheckWikicode)
for i, t in ipairs(templates) do
report:newline():wikitext(":*"):tag('code'):wikitext(t.name)
end
end
if #paramnames > 0 then
report:newline():wikitext("; wykryto parametry")
for i, v in ipairs(paramnames) do
report:newline():wikitext(':'):tag('code'):wikitext(v)
end
end
end
local function printTemplateCategories(report, categories)
local pagename = mw.title.getCurrentTitle().text
report:newline():wikitext("; zadeklarowane kategorie: ")
if categories == false then
report:wikitext("''wyłączone''")
else
local count = 0
for k, v in pairs(categories) do
count = count + 1
end
if count <= 0 then
report:wikitext("''brak''", '[[', diag.templateCats.default, '|', pagename, ']]')
else
report:wikitext(count)
local nameIndex = mw.ustring.len(diag.templateCats.ns)
+ mw.ustring.len(diag.templateCats.prefix)
+ 2
for v, s in pairs(categories) do
report:newline():wikitext(':*', mw.ustring.sub(v, nameIndex), '[[', v, '|', s, ' ]]')
if #s == 0 then
report:wikitext(' '):tag('small'):wikitext('(pusty klucz)')
elseif s ~= pagename then
report:wikitext(' '):tag('small'):wikitext('(klucz: ', s, ')')
end
end
end
end
end
local function printSourceCategories(report)
local function print(description, content)
if not content then
return
end
local categories = {}
for i, pattern in ipairs(diag.sourceCatsPatterns) do
for c in mw.ustring.gmatch(content, pattern) do
local title = mw.title.makeTitle(diag.templateCats.ns, c)
if title then
table.insert(categories, title.text)
end
end
end
report:newline():wikitext("; ", description, " : ", #categories)
for i, v in ipairs(categories) do report:newline():wikitext(':*', v) end
end
local content = mw.title.getCurrentTitle():getContent() or ""
print('kategorie w kodzie', content)
local docTitle = mw.title.getCurrentTitle():subPageTitle(res.aux.docSubpageText)
if docTitle and docTitle.exists then
print('kategorie w dokumentacji', docTitle:getContent())
end
local otherDoc = mw.ustring.match(content, "{{ *[Dd]okumentacja *| *([^|%[%]]-/opis) *}}")
if otherDoc then
local otherDocTitle = mw.title.new(otherDoc)
if otherDocTitle then
print('kategorie w dołączonej dokumentacji', otherDocTitle:getContent())
end
end
end
local function printLogSummary(report, printlog)
if printlog.levels then
report:newline():wikitext("; głębokość drzewa :", printlog.levels)
end
if printlog.leafs then
report:newline():wikitext("; liczba liści :", printlog.leafs)
end
if printlog.notree then
report:newline():wikitext("; drzewo : ''nie''")
end
if printlog.example then
report:newline():wikitext("; przykład : ''tak''")
end
if printlog.pionowy then
report:wikitext(diag.categoryVertical)
end
if printlog.cols then
report:newline():wikitext("; liczba kolumn :", printlog.cols)
if printlog.cols > 3 then
report:wikitext(diag.categoryManyColumns)
end
end
if printlog.allCols then
report:newline():wikitext("; liczba wszystkich komórek kolumnowych :", printlog.allCols)
end
if printlog.templateClassName then
report:newline():wikitext("; prywatny CSS")
report:newline():wikitext(": ", printlog.templateClassName)
if printlog.privateCSS then
report:newline():wikitext(": [[", printlog.privateCSS, "|styles.css]]", diag.categoryCSS)
end
end
if printlog.unknownClasses then
report:newline():wikitext("; nieużywane klasy", diag.categoryUnknownArgs)
for i, v in ipairs(printlog.unknownClasses) do
report:newline():wikitext(": ", #v <= 0 and "''pusta''" or v)
end
end
end
local function printEmptyArguments(report, argsTree)
local result = {}
for k, v in pairs(argsTree.args) do
if not v.value or (#v.value <= 0) then
table.insert(result, k)
end
end
if #result <= 0 then
return
end
report:newline():wikitext("; puste pola", diag.categoryEmptyArgs)
for i, v in ipairs(result) do
report:newline():wikitext(": ", v)
end
end
local function printUnverifiedArguments(report, argsTree)
local result = {}
for k, v in pairs(argsTree.args) do
if argsTree.used[k] and not v.verified then
table.insert(result, k)
end
end
if #result <= 0 then
return
end
report:newline():wikitext("; nieprawidłowe pola", diag.categoryUnverifiedArgs)
for i, v in ipairs(result) do
report:newline():wikitext(": ", v)
end
end
local function printUnknownArguments(report, argsTree)
local result = {}
for k, v in pairs(argsTree.args) do
if not v.recognized and not v.obsolete and not argsTree.used[k] then
table.insert(result, k)
end
end
if #result <= 0 then
return
end
report:newline():wikitext("; nieznane pola", diag.categoryUnknownArgs)
for i, v in ipairs(result) do
report:newline():wikitext(": ", v)
end
end
local function printUnusedArguments(report, argsTree)
local result = {}
local cat = false
for k, v in pairs(argsTree.args) do
if (#v.value > 0) and not argsTree.used[k] and (v.recognized or v.obsolete) then
cat = k ~= res.arg.collapsible.name -- omiń ponad 10k wywołań
table.insert(result, k)
end
end
if #result <= 0 then
return
end
report:newline():wikitext("; nieużywane pola", cat and diag.categoryUnusedArgs or '')
for i, v in ipairs(result) do
report:newline():wikitext(": ", v)
end
end
local function printMissingArguments(report, missing)
local result = {}
for k, v in pairs(missing) do
table.insert(result, k)
end
if #result <= 0 then
return
end
report:newline():wikitext("; brakujące pola", diag.categoryMissingArgs)
for i, v in ipairs(result) do
report:newline():wikitext(": ", v)
end
end
local function printTestListDescriptions(report, tree)
local direct = {}
local parent = {}
local function argName(node)
local address = string.sub(node.address(), 2)
return res.arg.list.name..string.gsub(address, '_', '.')
end
local function parseNode(node)
if #node <= 0 then
-- liści nie obrabiamy
return
end
local suspected = {}
for i, n in ipairs(node) do
if not n.peek(res.arg.group.name) and n.peek(res.arg.list.name) then
table.insert(suspected, i)
end
end
if #suspected > 1 then
for i, v in ipairs(suspected) do
table.insert(direct, argName(node[v]))
end
elseif (#suspected > 0) and node.address() and not node.peek(res.arg.group.name) then
table.insert(parent, argName(node[suspected[1]]))
end
for i, n in ipairs(node) do
parseNode(n)
end
end
parseNode(tree)
if (#direct <= 0) and (#parent <= 0) then
return
end
if #direct > 0 then
report:newline():wikitext("; nieopisany spis w grupie", diag.categoryAnonymousLists)
for i, v in ipairs(direct) do
report:newline():wikitext(": ", v)
end
end
if #parent > 0 then
report:newline():wikitext("; zagnieżdżony nieopisany spis", diag.categoryAnonymousLists)
for i, v in ipairs(parent) do
report:newline():wikitext(": ", v)
end
end
end
local function formatArgs(args)
local padindex = '................................................'
local orders = {
["nazwa"] = { p = 'A', s = '1', n = ' ', },
["tytuł"] = { p = 'A', s = '2', n = ' ', },
["klasa"] = { p = 'A', s = '3', n = ' ', },
["góra"] = { p = 'B', s = '1', n = '\n', },
["przed"] = { p = 'C', s = '1', n = ' ', },
["po"] = { p = 'C', s = '2', n = ' ', },
["grafika"] = { p = 'C', s = '3', n = ' ', },
["opis"] = { p = 'D', s = '1', n = ' ', },
["zwijanie"] = { p = 'D', s = '2', n = ' ', },
["spis"] = { p = 'D', s = '3', n = '\n', },
["dół"] = { p = 'E', s = '1', n = '\n', },
[false] = { p = 'Z', s = '1', n = ' ', },
}
local list = {}
local i = 0
for k, v in pairs(args) do
i = i + 1
local prefix, suffix = mw.ustring.match(k, "^(.-)([1-9][%.0-9]*)$")
if not prefix then
prefix = k
suffix = padindex
else
suffix = string.sub(suffix..padindex, 1, #padindex)
end
local ord = orders[prefix] or orders[false]
local item = {
o = string.format('%s-%s-%s-%08d', ord.p, suffix, ord.s, i),
k = k,
v = v,
n = ord.n,
}
table.insert(list, item)
end
table.sort(list, function(a,b) return a.o < b.o end)
local result = {}
for i, v in ipairs(list) do
table.insert(result, '| '..v.k..' ='..v.n..v.v..(v.n == '\n' and v.n or ''))
end
return table.concat(result, '\n')
end
local function verify(argInfo)
local verificator = diag.verificators[argInfo.recognized]
if verificator then
argInfo.verified = verificator.inverted
for i, v in ipairs(verificator.patterns) do
if mw.ustring.match(argInfo.value, v) then
argInfo.verified = not verificator.inverted
break
end
end
end
end
local function testBrackets(text)
local stack = {}
for b in mw.ustring.gmatch(text, diag.brackets.pattern) do
if (b == '(') or (b == '[') then
table.insert(stack, b)
elseif (b == ')') or (b == ']') then
if (#stack > 0) and stack[#stack] == diag.brackets[b] then
table.remove(stack, #stack)
else
return false -- brak otwartego nawiasu
end
end
end
return #stack == 0 -- oczekiwane zamknięte wszystkie nawiasy
end
local function check(text, br)
local lines = mw.text.split(text, '\n', true)
local wikilinks = 0
local nowikis = 0
local problems = 0
local suspected = 0
local result = {}
for i, v in ipairs(lines) do
local t = v
if not mw.ustring.match(v, diag.listItem) then
-- to nie jest wikilista
elseif mw.ustring.match(v, diag.wikilink) then
wikilinks = wikilinks + 1
elseif string.match(v,'\127') then
-- nowiki, ref, etc
nowikis = nowikis + 1
else
problems = problems + 1
t = v..diag.problemIndicator
end
if br and mw.ustring.match(v, diag.brPattern) then
suspected = suspected + 1
t = t..diag.suspectedIndicator
elseif not testBrackets(v) then
suspected = suspected + 1
t = t..diag.suspectedIndicator
else
-- zamieniam wikilinki na tekst do testowania
local s, c = string.gsub(v, "%[%[.-|(.-)%]%]", "%1") -- nie patrz w linki
local s, c = string.gsub(s, "%[%[[^|\n%[%]]+%]%]", "ok") -- lub zamień je na dobry tekst
for i, p in ipairs(diag.suspectedText) do
if mw.ustring.match(s, p, 1, true) then
suspected = suspected + 1
t = t..diag.suspectedIndicator
break
end
end
end
table.insert(result, t)
end
return {
value = table.concat(result,'\n'),
wikilinks = wikilinks,
nowikis = nowikis,
problems = problems,
suspected = suspected,
inside = string.match(lines[1], diag.navboxInside) and true or false,
}
end
local function argsService(templateContext)
local argsTree = {
args = {},
missing = {},
used = {},
diag = {},
}
local staticArgs = {}
local dynamicArgs = {}
for k, v in pairs(res.arg) do
if templateContext and templateContext.aliases then
local alias = templateContext.aliases[v.name]
if v.static and alias then staticArgs[alias] = v.static end
if v.dynamic and alias then dynamicArgs[alias] = v.dynamic end
end
if v.static then staticArgs[v.name] = v.static end
if v.dynamic then dynamicArgs[v.name] = v.dynamic end
if v.template and templateContext then staticArgs[v.name] = v.template end
end
local function add(k, v, prefix)
--mw.logObject({k, v, prefix}, "analyzeArg")
local argInfo = {
value = v,
recognized = staticArgs[k] or (prefix and dynamicArgs[prefix])
}
if argInfo.recognized then
verify(argInfo)
elseif templateContext and templateContext.obsolete then
argInfo.obsolete = prefix and templateContext.obsolete[prefix]
or (templateContext.obsolete[k] == false)
end
argsTree.args[k] = argInfo
--mw.logObject(argInfo, k)
end
local peekName = function(name)
if (not argsTree.args[name] or (#argsTree.args[name].value <= 0)) and templateContext and templateContext.aliases then
local alias = templateContext.aliases[name]
if alias and argsTree.args[alias] and (#argsTree.args[alias].value > 0) then
return alias
end
end
return name
end
local function peek(name)
--mw.logObject(name, "peek")
local name = peekName(name)
local arg = argsTree.args[name]
return (arg and (#arg.value > 0)) and arg.value or nil
end
local function use(name)
local name = peekName(name)
local arg = argsTree.args[name]
local result = arg and arg.value or nil
--mw.logObject({name, result}, "use")
argsTree.used[name] = (argsTree.used[name] or 0) + 1
return result
end
local function get(name)
local name = peekName(name)
local result = use(name)
if result == nil then
argsTree.missing[name] = (argsTree.missing[name] or 0) + 1
result = res.aux.missingArgNamePrefix..name..res.aux.missingArgNameSuffix
elseif not argsTree.diag[name] then
local br = mw.ustring.match(name, '^'..res.arg.list.name..'%d')
argsTree.diag[name] = check(result, br)
result = argsTree.diag[name].value
end
--mw.logObject({name, result}, "get")
return result
end
local function dump()
local buffer = {}
for k, v in pairs(argsTree.args) do
buffer[k] = v.value
end
return mw.text.jsonEncode(buffer)
end
local function loadTemplateCategories()
local pagename = mw.title.getCurrentTitle().text
local map = {}
for i, argName in ipairs(diag.templateCats.args) do
if i > 1 then -- piersza inaczej
local catName = peek(argName)
if catName and (#catName > 0) then
local name, sort = mw.ustring.match(catName, "^(.-)%s*|%s*(.*)$")
if not name then
name = catName
sort = pagename
end
local categoryTitle = mw.title.makeTitle(diag.templateCats.ns, diag.templateCats.prefix..name)
if categoryTitle and (#categoryTitle.fragment <= 0) and not map[categoryTitle.fullText] then
use(argName)
argsTree.args[argName].verified = true
map[categoryTitle.fullText] = sort
end
end
end
end
local cat1arg = diag.templateCats.args[1]
local cat1 = peek(cat1arg)
if cat1 == diag.templateCats.disabled then
use(cat1arg)
argsTree.args[cat1arg].verified = true
for k, v in pairs(map) do
return map
end
return false
end
if cat1 and (#cat1 > 0) then
local name, sort = mw.ustring.match(cat1, "^(.-)%s*|%s*(.*)$")
if not name then
name = cat1
sort = pagename
end
local categoryTitle = mw.title.makeTitle(diag.templateCats.ns, diag.templateCats.prefix..name)
if categoryTitle and (#categoryTitle.fragment <= 0) and not map[categoryTitle.fullText] then
use(cat1arg)
argsTree.args[cat1arg].verified = true
map[categoryTitle.fullText] = sort
end
end
return map
end
local function diagnosticView (builder, printlog, tree)
printStatistics(builder, argsTree.diag)
local summaryReport = mw.html.create('div')
:addClass('navbox-summary')
:addClass("mw-collapsible mw-collapsed")
summaryReport:tag('div')
:addClass('title')
:wikitext('Informacje diagnostyczne')
local report = summaryReport:tag('div')
--:addClass('hlist')
:addClass('mw-collapsible-content')
if printlog.badName then
report:wikitext(diag.categoryBadName)
end
printWikicodeAnalyze(report)
if printlog.useTemplateCategories then
printTemplateCategories(report, loadTemplateCategories())
end
printSourceCategories(report)
report:newline():wikitext('----')
printLogSummary(report, printlog)
report:newline():wikitext('----')
printListWithoutWikilinks(report, argsTree.diag)
printEmptyArguments(report, argsTree)
printUnverifiedArguments(report, argsTree)
printUnusedArguments(report, argsTree)
printUnknownArguments(report, argsTree)
printMissingArguments(report, argsTree.missing)
printNested(report, argsTree.diag)
if tree then
printTestListDescriptions(report, tree)
end
local argsReport = ''
local formattedArgs = formatArgs(mw.text.jsonDecode(dump()))
if formattedArgs and (#formattedArgs > 0) then
local report = mw.html.create('div')
:addClass('navbox-summary')
:addClass("mw-collapsible mw-collapsed")
report:tag('div')
:addClass('title')
:wikitext('Kanoniczne zestawienie parametrów')
local content = mw.getCurrentFrame():extensionTag('pre', formattedArgs, {class='mw-collapsible-content'})
report:wikitext(content)
argsReport = tostring(report)
end
local navbox = tostring(builder)
local details = tostring(summaryReport)
local catReport = ''
local function hideCategories()
local currentTitle = mw.title.getCurrentTitle()
if currentTitle.isTalkPage then
return true
elseif currentTitle.namespace ~= 2 then
return false
else -- Wikipedysta - może programista?
local navboxDeveloper = mw.title.makeTitle(2, currentTitle.rootText..'/navbox-developer')
return not navboxDeveloper or not navboxDeveloper.exists
end
end
if hideCategories() then
local categories = {}
local function extractCategories(text)
local function foundCat(category)
table.insert(categories, category)
return ''
end
local t1, c1 = mw.ustring.gsub(text, diag.sourceCatsPatterns[1], foundCat)
local t2, c2 = mw.ustring.gsub(t1, diag.sourceCatsPatterns[2], foundCat)
return t2
end
navbox = extractCategories(navbox)
details = extractCategories(details)
if #categories > 0 then
local report = mw.html.create('div')
:addClass('navbox-summary')
:addClass("mw-collapsible mw-collapsed")
report:tag('div')
:addClass('title')
:wikitext('Kategorie')
local content = report:tag('div')
:addClass('mw-collapsible-content')
for i, v in ipairs(categories) do
content:newline():wikitext('*', '[[:Kategoria:', v, ']]')
end
content:newline()
catReport = tostring(report)
end
end
local result = navbox..details..argsReport..catReport
return result
end
return {
add = add,
peek = peek,
use = use,
get = get,
dump = dump,
diagnosticView = diagnosticView,
}
end
return {
argsService = argsService,
diagnosticView = function(builder, args, printlog)
return args.diagnosticView(builder, printlog, args.tree and args.tree() or nil)
end,
verifyTemplateName = function(currentTitle, expectedTitle, templateName)
local content = currentTitle:getContent()
if not content then
mw.log("Navbox:verifyTemplateName: brak zawartości strony")
return false
end
mw.logObject(templateName, "Navbox:verifyTemplateName: templateName")
local navboxTemplate = templateMatch(templateName)
mw.logObject(navboxTemplate, "Navbox:verifyTemplateName: navboxTemplate")
local s, e = mw.ustring.find(content, navboxTemplate, 1)
if not s then
mw.log("Navbox:verifyTemplateName: myślę, że jest ok, bo tu nie widzę kodu szablonu nawigacyjnego")
return true
end
local exists1 = function(pattern)
local s, e = mw.ustring.find(content, pattern, s)
if not s then
return 0
end
local s, e = mw.ustring.find(content, pattern, e)
if not s then
return 1
end
return 2
end
if 1 == exists1("|%s*nazwa%s*=%s*{{%s*#invoke:Navbox%s*|%s*Name%s*}}%s*[|}]") then
mw.log("Navbox:verifyTemplateName: myślę, że jest ok, automatyczna nazwa jest tylko raz -> true")
return true
end
mw.logObject(expectedTitle, "Navbox:verifyTemplateName: zadeklarowana nazwa w szablonie")
mw.logObject(currentTitle, "Navbox:verifyTemplateName: obrabiana strona")
-- w naszym szablonie oczekuję jednej nazwy
-- w przeciwnym razie nie oczekuję żadnej nazwy
local expectedCount = mw.title.equals(currentTitle, expectedTitle) and 1 or 0
mw.logObject(expectedCount, "Navbox:verifyTemplateName: oczekiwana liczba wystąpień podanej nazwy w szablonie")
local name = mw.ustring.gsub(expectedTitle.text, "([%(%)%.%%%+%-%*%?%[%^%$%]])", "%%%1" );
local pattern = ((expectedTitle.namespace == 10) or (0 < exists1("|%s*przestrzeń%s*=%s*"..expectedTitle.nsText.."%s*[|}]")))
and ("|%s*nazwa%s*=%s*"..name.."%s*[|}]") -- zwykła nazwa (w szablonie lub jawnie zadeklarowanej przestrzeni)
or ("|%s*nazwa%s*=%s*"..expectedTitle.nsText..":"..name.."%s*[|}]") -- pełna nazwa (w szablonie w innej przestrzeni)
mw.logObject(pattern, "Navbox:verifyTemplateName: szukam nazwy w szablonie według wzoru")
local count = exists1(pattern)
mw.logObject(count, "Navbox:verifyTemplateName: liczba wyników wyszukiwania")
return expectedCount == count
end,
}