Moduł:Wikidane/Tree
Wygląd
Zobacz podstrony tego modułu.
|
--------------------------------------------------------------------------------
-- NODE of data
--------------------------------------------------------------------------------
local nodeMetatable = {}
local nodeMethodtable = {}
nodeMetatable.__index = nodeMethodtable
nodeMethodtable.getLevel = function(me)
local result = 0
local parent = me.parent
while parent do
result = result + 1
parent = parent.parent
end
return result
end
nodeMethodtable.normalize = function(me)
local nodes = me.nodes
local i = 1
if #nodes <= 0 then
-- there are no children
return 0
end
local node = nodes[i]
i = i + 1
local deep = node:normalize()
while i <= #nodes do
local node2 = nodes[i]
i = i + 1
local deep2 = node2:normalize()
if deep < deep2 then
-- take longer path
node = node2
deep = deep2
end
end
-- use single parent
me.nodes = { node }
return 1 + deep
end
nodeMethodtable.getPath = function(me, accept, useroot)
local result = {}
if me.nodes[1] then
local node = useroot and me or me.nodes[1]
while node do
local name = node.name
if not accept(name) then
-- terminate sequence
break
end
table.insert(result, name)
node = node.nodes[1]
end
-- reverse result
local i = 1
local j = #result
while i < j do
local l = result[i]
local r = result[j]
result[i] = r
result[j] = l
i = i + 1
j = j - 1
end
end
return result
end
nodeMethodtable.add = function(me, node)
node.parent = me
table.insert(me.nodes, node)
end
nodeMethodtable.remove = function(me, node)
local nodes = {}
for i = 1, #me.nodes do
local item = me.nodes[i]
if item.name ~= node.name then
table.insert(nodes, item)
else
node.parent = nil
end
end
me.nodes = nodes
end
local function newNode(name)
local me = {}
me.name = name
me.nodes = {}
me.parent = nil
setmetatable(me, nodeMetatable)
return me
end
--------------------------------------------------------------------------------
-- TOOLS
--------------------------------------------------------------------------------
local getRequiredEntityId = function(frame, Q)
if Q then
return Q
end
local id = frame.args[1]
if id and (#id > 0) then
return id
end
local entity = mw.wikibase.getEntity()
if entity then
return entity.id
end
end
local wikidataLinkItem = function(q)
return "<span class=\"plainlinks wdlink\" title=\"edytuj dane z infoboxu w Wikidanych\">[https://www.wikidata.org/wiki/"..q.." •]</span>"
end
local defaultFormatItem = function(q)
local label = mw.wikibase.label(q)
local site = mw.wikibase.sitelink(q)
if site and label then
return site == label and ("[["..site.."]]") or ("[["..site.."|"..label.."]]")
elseif site then
return "[["..site.."]]"
elseif label then
return label
else
return q
end
end
local getBestStatements = function(entity, property)
if entity and entity.claims and entity.claims[property] then
local preferred = {}
local normal = {}
for _, v in ipairs(entity.claims[property]) do
if v.rank == "normal" then
table.insert(normal, v)
elseif v.rank == "preferred" then
table.insert(preferred, v)
end
end
if #preferred > 0 then
return preferred
elseif #normal > 0 then
return normal
end
end
end
local function isValueType(entity, type)
mw.logObject({ entity.id, type }, "isValueType")
local passed = {}
local statements = {}
local function loadBestStatements(e)
local best = getBestStatements(e, "P279") or {}
for _, v in ipairs(best) do
table.insert(statements, v)
end
end
passed[entity.id] = true
loadBestStatements(entity)
local i = 1
while i <= #statements do
local v = statements[i]
if v.mainsnak.datavalue then
local id = "Q"..v.mainsnak.datavalue.value["numeric-id"]
mw.logObject(id, "id")
if id == type then
mw.logObject(true, "return isValueType")
return true
end
if not passed[id] then
passed[id] = true
loadBestStatements(mw.wikibase.getEntity(id))
end
end
i = i + 1
end
mw.logObject(false, "return isValueType")
return false
end
--------------------------------------------------------------------------------
-- LIST FORMATTER
--------------------------------------------------------------------------------
local listFormatterMetatable = {}
local listFormatterMethodtable = {}
listFormatterMetatable.__index = listFormatterMethodtable
listFormatterMetatable.__tostring = function(me)
return me.builder and tostring(me.builder) or nil
end
listFormatterMethodtable.append = function(me, item)
me.builder = me.builder or mw.html.create("ul")
me.builder:tag("li"):wikitext(me.format(item))
return me
end
local listFormatter = function(formatItem)
me = {
format = formatItem or defaultFormatItem,
}
setmetatable(me, listFormatterMetatable)
return me
end
--------------------------------------------------------------------------------
-- TAXONOMY FORMATTER
--------------------------------------------------------------------------------
local taxonomyFormatterMetatable = {}
local taxonomyFormatterMethodtable = {}
taxonomyFormatterMetatable.__index = taxonomyFormatterMethodtable
taxonomyFormatterMetatable.__tostring = function(me)
return me.builder and table.concat(me.builder, "") or nil
end
taxonomyFormatterMethodtable.append = function(me, item)
if #me.builder == 0 then
table.insert(me.builder, "|-\n")
end
local formatDescription = function(site, label, latin)
if site and label and latin then
return "[["..site.."|"..label.."]] (''"..latin.."'')"
elseif site and latin then
return "[["..site.."|''"..latin.."'']]"
elseif site and label then
return "[["..site.."|"..label.."]]"
elseif site then
return "[["..site.."]]"
elseif label and latin then
return label.." (''"..latin.."'')"
elseif latin then
return "''"..latin.."''"
elseif label then
return label
end
end
local entity = mw.wikibase.getEntity(item)
local label = entity:getLabel()
local site = entity:getSitelink()
local ranks = getBestStatements(entity, "P105")
local names = getBestStatements(entity, "P225")
local taxonomicName = false
table.insert(me.builder, "!")
if ranks then
for _, rank in ipairs(ranks) do
if rank.mainsnak.snaktype == "value" then
if (rank.mainsnak.datatype == "wikibase-item")and (rank.mainsnak.datavalue.type == "wikibase-entityid") and (rank.mainsnak.datavalue.value["entity-type"] == "item") then
local rankid = "Q"..rank.mainsnak.datavalue.value["numeric-id"]
table.insert(me.builder, wikidataLinkItem(rankid))
local rankEntity = mw.wikibase.getEntity(rankid)
local rankSite = rankEntity:getSitelink()
local rankLabel = rankEntity:getLabel('pl')
local rankLatin = rankEntity:getLabel('la')
local ranktext = formatDescription(rankSite, rankLabel, rankLatin) or ""
table.insert(me.builder, ranktext)
break
end
end
end
end
table.insert(me.builder, "\n|")
if names then
for _, name in ipairs(names) do
if name.mainsnak.snaktype == "value" then
if (name.mainsnak.datatype == "string") and (name.mainsnak.datavalue.type == "string") then
taxonomicName = name.mainsnak.datavalue.value
break
end
end
end
end
if label == taxonomicName then
label = false
end
table.insert(me.builder, wikidataLinkItem(entity.id))
table.insert(me.builder, formatDescription(site, label, taxonomicName) or item)
table.insert(me.builder, "\n|-\n")
return me
end
local taxonomyFormatter = function()
me = {
builder = {}
}
setmetatable(me, taxonomyFormatterMetatable)
return me
end
--------------------------------------------------------------------------------
-- ADMINISTRATIVE DIVISION FORMATTER
--------------------------------------------------------------------------------
local administrativeDivisionFormatterMetatable = {}
local administrativeDivisionFormatterMethodtable = {}
administrativeDivisionFormatterMetatable.__index = administrativeDivisionFormatterMethodtable
administrativeDivisionFormatterMetatable.__tostring = function(me)
if me.usetop then
local suffix = #me.builder == 0 and "\n|-\n" or "\n"
table.insert(me.builder, 1, "|-\n!Państwo\n|"..defaultFormatItem(me.top[1])..suffix)
end
if me.bottom then
me:append(me.bottom)
end
return table.concat(me.builder, "")
end
local function acceptAdministrativeDivisionEntity(entity)
return isValueType(entity, "Q56061") -- administrative territorial entity
or isValueType(entity, "Q15617994") -- designation for an administrative territorial entity
or (entity.id == "Q1078001") -- territorial dispute
end
administrativeDivisionFormatterMethodtable.append = function(me, item)
if #me.builder == 0 then
table.insert(me.builder, "|-\n")
end
if item == me.bottom then
me.bottom = false;
end
if item == "Q1078001" then
table.insert(me.builder, "!")
table.insert(me.builder, wikidataLinkItem(item))
table.insert(me.builder, defaultFormatItem(item))
for i, v in ipairs(me.top) do
table.insert(me.builder, i > 1 and ", " or "\n|")
table.insert(me.builder, wikidataLinkItem(v))
table.insert(me.builder, defaultFormatItem(v))
end
table.insert(me.builder, "\n|-\n")
return me
end
if (#me.top == 1) and (item == me.top[1]) then
table.insert(me.builder, "!Państwo")
me.usetop = false
else
local entity = mw.wikibase.getEntity(item)
local itis = getBestStatements(entity, "P31")
table.insert(me.builder, "!")
if itis then
local more = false
for _, v in ipairs(itis) do
if v.mainsnak.snaktype == "value" then
if (v.mainsnak.datatype == "wikibase-item")and (v.mainsnak.datavalue.type == "wikibase-entityid") and (v.mainsnak.datavalue.value["entity-type"] == "item") then
local id = "Q"..v.mainsnak.datavalue.value["numeric-id"]
local e = mw.wikibase.getEntity(id)
if acceptAdministrativeDivisionEntity(e) then
if more then
table.insert(me.builder, ", ")
end
table.insert(me.builder, wikidataLinkItem(id))
table.insert(me.builder, defaultFormatItem(id))
more = true
end
end
end
end
end
end
table.insert(me.builder, "\n|")
table.insert(me.builder, wikidataLinkItem(item))
table.insert(me.builder, defaultFormatItem(item))
table.insert(me.builder, "\n|-\n")
return me
end
local administrativeDivisionFormatter = function(top, bottom)
me = {
usetop = #top == 1,
top = top,
bottom = bottom,
builder = {}
}
setmetatable(me, administrativeDivisionFormatterMetatable)
return me
end
--------------------------------------------------------------------------------
-- GENERATOR
--------------------------------------------------------------------------------
local generatorMetatable = {}
local generatorMethodtable = {}
generatorMetatable.__index = generatorMethodtable
generatorMethodtable.run = function(me, wgWikibaseItemId, builder)
me.types = {}
me.subclasses = {}
mw.log("LOADING DATA "..wgWikibaseItemId)
me:loadData(wgWikibaseItemId)
mw.log("BUILDING TREE "..wgWikibaseItemId)
local dictionary = {}
local root = newNode(wgWikibaseItemId)
dictionary[wgWikibaseItemId] = root
me:buildingTree(dictionary, root)
mw.log("LOOKING FOR PATH "..wgWikibaseItemId)
local deep = root:normalize()
local accept = function(item)
return not me.T.terminators[item];
end
local path = root:getPath(accept, me.T.showLeaf);
if #path then
mw.log("PREPARING LINKS AND LABELS "..wgWikibaseItemId)
for i = 1, #path do
if (i ~= 1) or not me.T.hideTerminators or not me.T.terminators[path[i]] then
builder:append(path[i])
end
end
local result = tostring(builder)
--mw.logObject(result, "showTree")
return result
end
end
generatorMethodtable.loadData = function(me, q)
if me.T[q] then
mw.log("loadData: cut searching "..q)
-- cut searching
return
end
local data = mw.wikibase.getEntity(q)
if not me.types[q] then
local ids = me:parseItemClaims(data.claims.P31, me.T.accept)
if ids then
me.types[q] = ids
for i = 1, #me.T.parentSources do
local p = me.T.parentSources[i]
me:LoadParentItems(q, mw.wikibase.getEntity(q))
end
end
end
end
generatorMethodtable.buildingTree = function(me, nodes, node)
local subclasses = me.subclasses[node.name]
if subclasses then
for i = 1, #subclasses do
local subclass = subclasses[i]
-- find parent
local n = node
local parent = false
while n do
if n.name == subclass then
parent = n
break
end
n = n.parent
end
if parent then
mw.log("there is cycle in the graph")
else
local available = nodes[subclass]
if available then
local alevel = available:getLevel()
local nlevel = node:getLevel()
if alevel <= nlevel then
-- the available node level path is shorter
-- move it to this location
available.parent:remove(available)
node:add(available)
else
-- the available node level path is same size or longer
-- as this is further class, it is ignored
end
else
local newnode = newNode(subclass)
nodes[subclass] = newnode
node:add(newnode)
me:buildingTree(nodes, newnode)
end
end
end
end
end
generatorMethodtable.LoadParentItems = function(me, q, data)
local accept = function() return true end
for i = 1, #me.T.parentSources do
local p = me.T.parentSources[i]
local ids = me:parseItemClaims(data.claims[p], accept)
if ids then
me.subclasses[q] = ids
for j = 1, #ids do
me:loadData(ids[j])
end
end
end
end
generatorMethodtable.parseItemClaims = function(me, items, check)
if not items or (#items <= 0) then
mw.log("parseItemClaims: no items")
return {}
end
mw.logObject(items, "parseItemClaims")
if #items > 1 then
local recent = false
local date = false
for _, v in ipairs(items) do
if v.qualifiers and v.qualifiers.P580 then
for _, d in ipairs(v.qualifiers.P580) do
if d.snaktype == "value" then
if not date or (date < d.datavalue.value.time) then
date = d.datavalue.value.time
recent = v
end
end
end
end
end
if date and recent then
mw.log(recemt, "recent")
items = { recent, }
end
end
local ids = {}
local j = 1
for i = 1, #items do
if items[i].mainsnak.datavalue then
local id = "Q"..items[i].mainsnak.datavalue.value["numeric-id"]
if check(id) then
ids[j] = id
j = j + 1
end
end
end
return #ids > 0 and ids or nil
end
local generator = function(T)
local me = {}
me.T = T;
setmetatable(me, generatorMetatable)
return me
end
return {
taxonomy = function(frame, Q)
local entityId = getRequiredEntityId(frame, Q)
if not entityId then
return
end
local acceptableTypes = {
Q16521 = true,
Q310890 = true,
Q713623 = true,
Q23038290 = true,
}
local params = {
parentSources = {
"P171",
},
accept = function(id)
return acceptableTypes[id]
end,
terminators = {
Q2382443 = true,
},
showLeaf = true,
}
return generator(params):run(entityId, taxonomyFormatter())
end,
administrativeDivision = function(frame, Q)
local entityId = getRequiredEntityId(frame, Q)
if not entityId then
return
end
local entity = mw.wikibase.getEntity(entityId)
local tops = getBestStatements(entity, "P17");
if tops then
local params = {
parentSources = {
"P131",
},
accept = function(id)
local entity = mw.wikibase.getEntity(id)
return entity and acceptAdministrativeDivisionEntity(entity)
end,
terminators = {},
showLeaf = true,
}
for _, v in ipairs(tops) do
if (v.mainsnak.snaktype == "value") and (v.mainsnak.datatype == "wikibase-item") and (v.mainsnak.datavalue.type == "wikibase-entityid") and (v.mainsnak.datavalue.value["entity-type"] == "item") then
local top = "Q"..v.mainsnak.datavalue.value["numeric-id"]
table.insert(params.terminators, top)
mw.logObject(params, top)
end
end
return generator(params):run(entityId, administrativeDivisionFormatter(params.terminators, entityId))
end
end,
classTree = function(frame, Q)
local entityId = getRequiredEntityId(frame, Q)
if not entityId then
return
end
local params = {
parentSources = mw.text.split( frame.args.parentSources, '%s' ),
terminators = {},
showLeaf = frame.args.showLeaf and true or false
}
local acceptableTypes = frame.args.acceptableTypes
if acceptableTypes and (#acceptableTypes > 0) and (acceptableTypes ~= "-") then
local accept = {}
for _, v in ipairs(mw.text.split( frame.args.acceptableTypes, '%s' )) do
accept[v] = true
end
params.accept = function(id) mw.logObject(accept[id], "classTree.accept["..id.."]") return accept[id] end
else
params.accept = function(id) return true end
end
local terminators = frame.args.terminators
if terminators and (#terminators > 0) then
for _, v in ipairs(mw.text.split( frame.args.terminators, '%s' )) do
params.terminators[v] = true
end
end
return generator(params):run(entityId, listFormatter())
end,
}