Module:Wd

local p = {}

local aliasesP = { coord          = "P625", author         = "P50", publisher      = "P123", importedFrom   = "P143", statedIn       = "P248", publicationDate = "P577", startTime      = "P580", endTime        = "P582", retrieved      = "P813", referenceURL   = "P854", archiveURL     = "P1065", title          = "P1476", quote          = "P1683", shortName      = "P1813", language       = "P2439", archiveDate    = "P2960" }

local aliasesQ = { percentage             = "Q11229", prolepticJulianCalendar = "Q1985786" }

local parameters = { property = "%p", qualifier = "%q", reference = "%r", separator = "%s" }

local formats = { property             = "%p[%s][%r]", qualifier            = "%q[%s][%r]", reference            = "%r", propertyWithQualifier = "%p[ (%q) ][%s][%r]" }

local hookNames = { -- {level_1, level_2} [parameters.property] = {"getProperty"}, [parameters.qualifier] = {"getQualifiers", "getQualifier"}, [parameters.reference] = {"getReferences", "getReference"} }

local Config = {} Config.__index = Config

-- allows for recursive calls function Config.new local cfg = {} setmetatable(cfg, Config) cfg.separators = { -- use tables so that we can pass by reference ["sep"]  = {" "}, ["sep%s"] = {","}, ["sep%q"] = {", "}, ["sep%r"] = {""}, ["punc"] = {""} }	cfg.entity = nil cfg.propertyID = nil cfg.propertyValue = nil cfg.qualifierID = nil cfg.bestRank = true cfg.foundRank = 3 cfg.maxRank = nil cfg.minRank = nil cfg:setRankBoundaries("best") cfg.period = 0 cfg.mdyDate = false cfg.pageTitle = false cfg.langCode = mw.language.getContentLanguage.code cfg.langName = mw.language.fetchLanguageName(cfg.langCode, cfg.langCode) cfg.langObj = mw.language.new(cfg.langCode) cfg.states = {} cfg.curState = nil return cfg end

local State = {} State.__index = State

function State.new(cfg) local stt = {} setmetatable(stt, State) stt.conf = cfg stt.outPreferred = {} stt.outNormal = {} stt.outDeprecated = {} stt.parsedFormat = {} stt.separator = {} stt.movSeparator = {} stt.puncMark = {} stt.linked = false stt.rawValue = false stt.shortName = false stt.singleValue = false return stt end

function unknownDataTypeError(dataType) return "Unknown or unsupported datatype '" .. dataType .. "'. " end

function missingRequiredParameterError return "No required parameters defined, needing at least one. " end

function extraRequiredParameterError(param) return "Parameter '" .. param .. "' must be defined as optional. " end

function parseWikidataURL(url) local i, j	if url:match('^http[s]?://') then i, j = url:find("Q") if i then return url:sub(i) end end return nil end

function parseDate(dateStr, precision) precision = precision or "d" local i, j, index, ptr local parts = {nil, nil, nil} if dateStr == nil then return parts[1], parts[2], parts[3] -- year, month, day end -- 'T' for snak values, '/' for outputs with '/Julian' attached i, j = dateStr:find("[T/]") if i then dateStr = dateStr:sub(1, i-1) end local from = 1 if dateStr:sub(1,1) == "-" then -- this is a negative number, look further ahead from = 2 end index = 1 ptr = 1 i, j = dateStr:find("-", from) if i then -- year parts[index] = tonumber(mw.ustring.gsub(dateStr:sub(ptr, i-1), "^\+(.+)$", "%1"), 10) -- remove + sign if parts[index] == -0 then parts[index] = 0 end if precision == "y" then -- we're done return parts[1], parts[2], parts[3] -- year, month, day end index = index + 1 ptr = i + 1 i, j = dateStr:find("-", ptr) if i then -- month parts[index] = tonumber(dateStr:sub(ptr, i-1), 10) if precision == "m" then -- we're done return parts[1], parts[2], parts[3] -- year, month, day end index = index + 1 ptr = i + 1 end end if dateStr:sub(ptr) ~= "" then -- day if we have month, month if we have year, or year parts[index] = tonumber(dateStr:sub(ptr), 10) end return parts[1], parts[2], parts[3] -- year, month, day end

function convertUnit(unit, link) link = link or false local itemID, label, title if unit == "" or unit == "1" then return nil end itemID = parseWikidataURL(unit) if itemID then if itemID == aliasesQ.percentage then return "%" else label = mw.wikibase.label(itemID) title = nil if link or label == nil then title = mw.wikibase.sitelink(itemID) end if link then if title then return " " .. "" .. (label or title) .. "" end if not label then return " " .. "" .. itemID .. "" end end return " " .. (label or title or itemID) end end return " " .. unit end

function getOrdinalSuffix(num) if tostring(num):sub(-2,-2) == '1' then return "th" -- 10th, 11th, 12th, 13th, ... 19th end num = tostring(num):sub(-1) if num == '1' then return "st" elseif num == '2' then return "nd" elseif num == '3' then return "rd" else return "th" end end

function addDecimalMarks(n) local left,num,right = string.match(n,'^([^%d]*%d)(%d*)(.-)$') return left..(num:reverse:gsub('(%d%d%d)','%1,'):reverse)..right end

function convertRank(rank) if (rank == "preferred") then return 1 elseif (rank == "normal") then return 2 elseif (rank == "deprecated") then return 3 else return 4 -- default (in its literal sense) end end

function datePrecedesDate(aY, aM, aD, bY, bM, bD) if aY == nil or bY == nil then return nil end aM = aM or 1 aD = aD or 1 bM = bM or 1 bD = bD or 1 if aY < bY then return true end if aY > bY then return false end if aM < bM then return true end if aM > bM then return false end if aD < bD then return true end return false end

function alwaysTrue return true end

function parseFormat(str) local chr, esc, param, root, cur local params = {} local function newObject(array) local obj = {} -- new object obj.str = "" array[#array + 1] = obj -- array{object} obj.parent = array return obj end root = {} -- array root.req = {} cur = newObject(root) esc = false param = false for i = 1, #str do		chr = str:sub(i,i) if not esc then if chr == '\\' then esc = true elseif chr == '%' then cur = newObject(cur.parent) param = true else if chr == '[' then cur.child = {} -- new array cur.child.req = {} cur.child.parent = cur cur = newObject(cur.child) elseif chr == ']' then if cur.parent.parent then cur = newObject(cur.parent.parent.parent) end else cur.str = cur.str .. chr if param then cur.str = "%"..cur.str cur.param = true params[cur.str] = true cur.parent.req[cur.str] = true cur = newObject(cur.parent) end end param = false end else cur.str = cur.str .. chr esc = false if param then cur.str = "%"..cur.str cur.param = true params[cur.str] = true cur.parent.req[cur.str] = true cur = newObject(cur.parent) param = false end end end return root, params end

function getShortName(itemID) return p._property({itemID, aliasesP.shortName}) -- "property" is single end

function getLabel(ID) return p._label({ID}) end

function Config:getValue(snak, raw, link, short, anyLang) raw = raw or false link = link or false short = short or false anyLang = anyLang or false if snak.snaktype == 'value' then if snak.datavalue.type == 'string' then return snak.datavalue.value elseif snak.datavalue.type == 'monolingualtext' then if anyLang then return snak.datavalue.value['text'], snak.datavalue.value['language'] elseif snak.datavalue.value['language'] == self.langCode then return snak.datavalue.value['text'] else return nil end elseif snak.datavalue.type == 'quantity' then -- strip + signs from front local value = mw.ustring.gsub(snak.datavalue.value['amount'], "^\+(.+)$", "%1") if not raw then value = addDecimalMarks(value) local unit = convertUnit(snak.datavalue.value['unit'], link) if unit then value = value .. unit end end return value elseif snak.datavalue.type == 'time' then local y, m, d, p, yDiv, yRound, yFull, value, calendarID, dateStr local yFactor = 1 local sign = 1 local suffix = "" local mayAddCalendar = false local calendar = "" local precision = snak.datavalue.value['precision'] if precision == 11 then p = "d" elseif precision == 10 then p = "m" else p = "y" yFactor = 10^(9-precision) end y, m, d = parseDate(snak.datavalue.value['time'], p)			if y < 0 then sign = -1 y = y * sign end -- if precision is tens/hundreds/thousands/millions/billions of years if precision <= 8 then yDiv = y / yFactor -- if precision is tens/hundreds/thousands of years if precision >= 6 then mayAddCalendar = true if precision <= 7 then -- round centuries/millenniums up (e.g. 20th century or 3rd millennium) yRound = math.ceil(yDiv) if not raw then if precision == 6 then suffix = " millennium" else suffix = " century" end suffix = getOrdinalSuffix(yRound) .. suffix else -- if not verbose, take the first year of the century/millennium -- (e.g. 1901 for 20th century or 2001 for 3rd millennium) yRound = (yRound - 1) * yFactor + 1 end else -- precision == 8 -- round decades down (e.g. 2010s) yRound = math.floor(yDiv) * yFactor if not raw then suffix = "s" end end if raw and sign < 0 then -- if BCE then compensate for "counting backwards" -- (e.g. -2019 for 2010s BCE, -2000 for 20th century BCE or -3000 for 3rd millennium BCE) yRound = yRound + yFactor - 1 end else local yReFactor, yReDiv, yReRound -- round to nearest for tens of thousands of years or more yRound = math.floor(yDiv + 0.5) if yRound == 0 then if precision <= 2 and y ~= 0 then yReFactor = 1e6 yReDiv = y / yReFactor yReRound = math.floor(yReDiv + 0.5) if yReDiv == yReRound then -- change precision to millions of years only if we have a whole number of them precision = 3 yFactor = yReFactor yRound = yReRound end end if yRound == 0 then -- otherwise, take the unrounded (original) number of years precision = 5 yFactor = 1 yRound = y							mayAddCalendar = true end end if precision >= 1 and y ~= 0 then yFull = yRound * yFactor yReFactor = 1e9 yReDiv = yFull / yReFactor yReRound = math.floor(yReDiv + 0.5) if yReDiv == yReRound then -- change precision to billions of years if we're in that range precision = 0 yFactor = yReFactor yRound = yReRound else yReFactor = 1e6 yReDiv = yFull / yReFactor yReRound = math.floor(yReDiv + 0.5) if yReDiv == yReRound then -- change precision to millions of years if we're in that range precision = 3 yFactor = yReFactor yRound = yReRound end end end if not raw then if precision == 3 then suffix = " million years" elseif precision == 0 then suffix = " billion years" else yRound = yRound * yFactor if yRound == 1 then suffix = " year" else suffix = " years" end end else yRound = yRound * yFactor end end else yRound = y				mayAddCalendar = true end if mayAddCalendar then calendarID = parseWikidataURL(snak.datavalue.value['calendarmodel']) if calendarID and calendarID == aliasesQ.prolepticJulianCalendar then if not raw then if link then calendar = " (Julian)" else calendar = " (Julian)" end else calendar = "/Julian" end end end if not raw then local ce = nil if sign < 0 then ce = "BCE" elseif precision <= 5 then ce = "CE" end if ce then if link then ce = "" .. ce .. "" end suffix = suffix .. " " .. ce				end value = tostring(yRound) if m then dateStr = self.langObj:formatDate("F", "1-"..m.."-1") if d then if self.mdyDate then dateStr = dateStr .. " " .. d .. ","						else dateStr = d .. " " .. dateStr end end value = dateStr .. " " .. value end value = value .. suffix .. calendar else value = tostring(yRound * sign) if m then value = value .. "-" .. m					if d then value = value .. "-" .. d					end end value = value .. calendar end return value elseif snak.datavalue.type == 'globecoordinate' then -- logic from https://github.com/DataValues/Geo local precision, numDigits, strFormat, value, globe local latValue, latitude, latDegrees, latMinutes, latSeconds local latDirection = "N" local lonValue, longitude, lonDegrees, lonMinutes, lonSeconds local lonDirection = "E" local degSymbol = "°" local minSymbol = "'" local secSymbol = '"'			local partsGlue = ", "			if raw then				degSymbol = "/"				minSymbol = "/"				secSymbol = "/"				partsGlue = "/"			end			latitude = snak.datavalue.value['latitude']			longitude = snak.datavalue.value['longitude']			if latitude < 0 then				latDirection = "S"				latitude = math.abs(latitude)			end			if longitude < 0 then				lonDirection = "W"				longitude = math.abs(longitude)			end			precision = snak.datavalue.value['precision']			latitude = math.floor(latitude / precision + 0.5) * precision			longitude = math.floor(longitude / precision + 0.5) * precision			numDigits = math.ceil(-math.log10(3600 * precision))			if numDigits < 0 or numDigits == -0 then				numDigits = 0			end			strFormat = "%." .. numDigits .. "f"			-- use string.format to strip decimal point followed by a zero (.0) for whole numbers			latSeconds = tonumber(string.format(strFormat, math.floor(latitude * 3600 * 10^numDigits + 0.5) / 10^numDigits)) lonSeconds = tonumber(string.format(strFormat, math.floor(longitude * 3600 * 10^numDigits + 0.5) / 10^numDigits)) latMinutes = math.floor(latSeconds / 60) lonMinutes = math.floor(lonSeconds / 60) latSeconds = latSeconds - (latMinutes * 60) lonSeconds = lonSeconds - (lonMinutes * 60) latDegrees = math.floor(latMinutes / 60) lonDegrees = math.floor(lonMinutes / 60) latMinutes = latMinutes - (latDegrees * 60) lonMinutes = lonMinutes - (lonDegrees * 60) latValue = latDegrees .. degSymbol lonValue = lonDegrees .. degSymbol if precision < 1 then latValue = latValue .. latMinutes .. minSymbol lonValue = lonValue .. lonMinutes .. minSymbol end if precision < (1 / 60) then latSeconds = string.format(strFormat, latSeconds) lonSeconds = string.format(strFormat, lonSeconds) latValue = latValue .. latSeconds .. secSymbol lonValue = lonValue .. lonSeconds .. secSymbol end latValue = latValue .. latDirection lonValue = lonValue .. lonDirection value = latValue .. partsGlue .. lonValue if link then globe = parseWikidataURL(snak.datavalue.value['globe']) if globe then globe = mw.wikibase.label(globe):lower else globe = "earth" end value = ""..value.."" end return value elseif snak.datavalue.type == 'wikibase-entityid' then local value = "" local title = nil local itemID = "Q" .. snak.datavalue.value['numeric-id'] if raw then if link then return "" .. itemID .. "" else return itemID end end if short then value = getShortName(itemID) end if value == "" then value = mw.wikibase.label(itemID) end if link or value == nil then title = mw.wikibase.sitelink(itemID) end if link then if title then value = "" .. (value or title) .. "" elseif not value then value = "" .. itemID .. "" end elseif not value then value = (title or itemID) end return value else return unknownDataTypeError(snak.datavalue.type) end elseif snak.snaktype == 'somevalue' then if raw then return " " -- single space represents 'somevalue' else return "unknown" end elseif snak.snaktype == 'novalue' then if raw then return "" -- empty string represents 'novalue' else return "none" end else return nil end end

function Config:getSingleRawQualifier(claim, qualifierID) local qualifiers if claim.qualifiers then qualifiers = claim.qualifiers[qualifierID] end if qualifiers and qualifiers[1] then return self:getValue(qualifiers[1], true) -- raw = true else return nil end end

function Config:snakEqualsValue(snak, value) local snakValue = self:getValue(snak, true) -- raw = true if snakValue and snak.snaktype == 'value' and snak.datavalue.type == 'wikibase-entityid' then value = value:upper end return snakValue == value end

function Config:setRankBoundaries(rank) local rankPos self.foundRank = 3 -- must equal the lowest possible rank if (rank == "best") then self.bestRank = true return else self.bestRank = false end if (rank:sub(1,9) == "preferred") then rankPos = 1 elseif (rank:sub(1,6) == "normal") then rankPos = 2 elseif (rank:sub(1,10) == "deprecated") then rankPos = 3 end if (rank:sub(-1) == "+") then self.maxRank = 1 self.minRank = rankPos elseif (rank:sub(-1) == "-") then self.maxRank = rankPos self.minRank = 3 else self.maxRank = rankPos self.minRank = rankPos end end

function Config:processFlag(flag) if not flag then return false else flag = mw.text.trim(flag) end if flag == "linked" then self.curState.linked = true return true elseif flag == "raw" then self.curState.rawValue = true if self.curState == self.states[parameters.reference] then -- raw reference values end with periods and require a separator different from "" self.separators["sep%r"][1] = " " end return true elseif flag == "short" then self.curState.shortName = true return true elseif flag == "mdy" then self.mdyDate = true return true elseif flag == "best" or flag:match('^preferred[+-]?$') or flag:match('^normal[+-]?$') or flag:match('^deprecated[+-]?$') then self:setRankBoundaries(flag) return true elseif flag == "future" then self.period = 1 return true elseif flag == "current" then self.period = 2 return true elseif flag == "former" then self.period = 3 return true elseif flag == "" then -- ignore empty flags and carry on		return true else return false end end

function Config:processFlagOrCommand(flag) local param = "" if not flag then return false else flag = mw.text.trim(flag) end if flag == "property" or flag == "properties" then param = parameters.property elseif flag:match('^qualifier[s]?$') then param = parameters.qualifier elseif flag:match('^reference[s]?$') then param = parameters.reference else return self:processFlag(flag) end if self.states[param] then return false end -- create a new State for each command self.states[param] = State.new(self) -- use "%x" as the general parameter name self.states[param].parsedFormat = parseFormat("%x") -- will be overwritten for param=="%p" -- set the separator self.states[param].separator = self.separators["sep"..param] -- will be nil for param=="%p", which will be set separately if string.sub(flag, -1) ~= 's' then self.states[param].singleValue = true end self.curState = self.states[param] return true end

function Config:rankMatches(rankPos) if self.bestRank then return self.foundRank >= rankPos else return (self.maxRank <= rankPos and rankPos <= self.minRank) end end

function Config:timeMatches(claim) local startTime = nil local startTimeY = nil local startTimeM = nil local startTimeD = nil local endTime = nil local endTimeY = nil local endTimeM = nil local endTimeD = nil if self.period == 0 then -- any time return true end local now = os.date('!*t') startTime = self:getSingleRawQualifier(claim, aliasesP.startTime) if startTime and startTime ~= "" and startTime ~= " " then startTimeY, startTimeM, startTimeD = parseDate(startTime) end endTime = self:getSingleRawQualifier(claim, aliasesP.endTime) if endTime and endTime ~= "" and endTime ~= " " then endTimeY, endTimeM, endTimeD = parseDate(endTime) elseif endTime == " " then -- end time is 'unknown', assume it is somewhere in the past; -- we can do this by taking the current date as a placeholder for the end time endTimeY = now['year'] endTimeM = now['month'] endTimeD = now['day'] end if startTimeY ~= nil and endTimeY ~= nil and datePrecedesDate(endTimeY, endTimeM, endTimeD, startTimeY, startTimeM, startTimeD) then -- invalidate end time if it precedes start time endTimeY = nil endTimeM = nil endTimeD = nil end if self.period == 1 then -- future if startTimeY == nil or not datePrecedesDate(now['year'], now['month'], now['day'], startTimeY, startTimeM, startTimeD) then return false else return true end elseif self.period == 2 then -- current if (startTimeY ~= nil and datePrecedesDate(now['year'], now['month'], now['day'], startTimeY, startTimeM, startTimeD)) or		  (endTimeY ~= nil and not datePrecedesDate(now['year'], now['month'], now['day'], endTimeY, endTimeM, endTimeD)) then return false else return true end elseif self.period == 3 then -- former if endTimeY == nil or datePrecedesDate(now['year'], now['month'], now['day'], endTimeY, endTimeM, endTimeD) then return false else return true end end end

function State:claimMatches(claim) local matches, rankPos -- if a property value was given, check if it matches the claim's property value if self.conf.propertyValue then matches = self.conf:snakEqualsValue(claim.mainsnak, self.conf.propertyValue) else matches = true end -- check if the claim's rank and time period match rankPos = convertRank(claim.rank) matches = (matches and self.conf:rankMatches(rankPos) and self.conf:timeMatches(claim)) return matches, rankPos end

function State:appendOutput(result, rankPos) local done = false -- a rankPos should only apply to complete claims, not to its individual qualifiers or references; -- for the latter two, no rankPos should be given and their default rankPos must be the highest possible (i.e. 1) if rankPos then if (self.conf.bestRank or self.singleValue) and self.conf.foundRank > rankPos then self.conf.foundRank = rankPos -- found a better rank, reset worse rank outputs if self.conf.foundRank == 1 then self.outNormal = {} self.outDeprecated = {} elseif self.conf.foundRank == 2 then self.outDeprecated = {} end end else rankPos = 1 end if rankPos == 1 then self.outPreferred[#self.outPreferred + 1] = result if self.singleValue then done = true end elseif rankPos == 2 then self.outNormal[#self.outNormal + 1] = result if self.singleValue and not self.conf.bestRank and self.conf.maxRank == 2 then done = true end elseif rankPos == 3 then self.outDeprecated[#self.outDeprecated + 1] = result if self.singleValue and not self.conf.bestRank and self.conf.maxRank == 3 then done = true end end return done end

function State:out local out = "" local function walk(formatTable, result) local str = "" for i, v in pairs(formatTable.req) do			if not result[i] then -- we've got no result for a parameter that is required on this level, -- so skip this level (and its children) by returning an empty string return "" end end for i, v in ipairs(formatTable) do			if v.param then str = str .. result[v.str] else str = str .. v.str end if v.child then str = str .. walk(v.child, result) end end return str end local function prepend(results) local sep = "" local result, value -- iterate from back to front, so that we know when to add separators for i = #results, 1, -1 do			result = results[i] -- if there is already some output, then add the separators if out ~= "" then sep = self.separator[1] -- fixed separator result[parameters.separator] = self.movSeparator[1] -- movable separator else sep = "" result[parameters.separator] = self.puncMark[1] -- optional punctuation mark end value = walk(self.parsedFormat, result) if value ~= "" then out = value .. sep .. out end end end prepend(self.outDeprecated) prepend(self.outNormal) prepend(self.outPreferred) -- reset state before next iteration self.outDeprecated = {} self.outNormal = {} self.outPreferred = {} return out end

-- level 1 hook function State:getProperty(claim) return self.conf:getValue(claim.mainsnak, self.rawValue, self.linked, self.shortName) end

-- level 1 hook function State:getQualifiers(claim) local qualifiers if claim.qualifiers then qualifiers = claim.qualifiers[self.conf.qualifierID] end if qualifiers then -- iterate through claim's qualifier statements to collect their values return self.conf.states[parameters.qualifier]:iterate(qualifiers, {["%x"] = hookNames[parameters.qualifier][2], count = 1}) -- pass qualifier State with level 2 hook else return nil end end

-- level 2 hook function State:getQualifier(snak) return self.conf:getValue(snak, self.rawValue, self.linked, self.shortName) end

-- level 1 hook function State:getReferences(claim) if claim.references then -- iterate through claim's reference statements to collect their values return self.conf.states[parameters.reference]:iterate(claim.references, {["%x"] = hookNames[parameters.reference][2], count = 1}) -- pass reference State with level 2 hook else return nil end end

-- level 2 hook -- logic determined based on https://www.wikidata.org/wiki/Help:Sources function State:getReference(statement) local snakValue, lang, property local value = "" local snaks = {} local params = {} local leadParams = {} if statement.snaks then for i, v in pairs(statement.snaks) do			if v[1] then snaks[i] = v[1] end end if snaks[aliasesP.importedFrom] then snaks[aliasesP.importedFrom] = nil end if snaks[aliasesP.referenceURL] and snaks[aliasesP.title] then params["url"] = self.conf:getValue(snaks[aliasesP.referenceURL]) params["title"] = self.conf:getValue(snaks[aliasesP.title], false, false, false, true) -- anyLang = true if snaks[aliasesP.publicationDate] then params["date"]        = self.conf:getValue(snaks[aliasesP.publicationDate])                  end if snaks[aliasesP.retrieved]      then params["access-date"]  = self.conf:getValue(snaks[aliasesP.retrieved])                        end if snaks[aliasesP.archiveURL]     then params["archive-url"]  = self.conf:getValue(snaks[aliasesP.archiveURL])                       end if snaks[aliasesP.archiveDate]    then params["archive-date"] = self.conf:getValue(snaks[aliasesP.archiveDate])                      end if snaks[aliasesP.author]         then params["author"]       = self.conf:getValue(snaks[aliasesP.author])                           end if snaks[aliasesP.publisher]      then params["publisher"]    = self.conf:getValue(snaks[aliasesP.publisher])                        end if snaks[aliasesP.quote]          then params["quote"]        = self.conf:getValue(snaks[aliasesP.quote], false, false, false, true) end  -- anyLang = true if snaks[aliasesP.language] then snakValue = self.conf:getValue(snaks[aliasesP.language]) if self.conf.langName ~= snakValue then params["language"] = snakValue end end value = mw.getCurrentFrame:expandTemplate{title="cite_web", args=params} else for i, v in pairs(snaks) do				property = getLabel(i) if property ~= "" then snakValue, lang = self.conf:getValue(v, false, (i == aliasesP.statedIn), false, true) -- link = true/false, anyLang = true if lang and lang ~= self.conf.langCode then snakValue = "''" .. snakValue .. "'' (" .. mw.language.fetchLanguageName(lang, self.conf.langCode) .. ")" end if i == aliasesP.referenceURL or i == aliasesP.statedIn then leadParams[#leadParams + 1] = snakValue elseif i ~= aliasesP.language or self.conf.langName ~= snakValue then params[#params + 1] = property .. ": " .. snakValue end end end value = table.concat(leadParams, "; ") params = table.concat(params, "; ") if params ~= "" then if value ~= "" then value = value .. "; "				end value = value .. params end if value ~= "" then value = value .. "."			end end if value ~= "" then if not self.rawValue then -- add tags with the reference's hash as its name (to deduplicate references) value = mw.getCurrentFrame:extensionTag("ref", value, {name = statement.hash}) end else value = nil end end return value end

-- iterate through claims, claim's qualifiers or claim's references to collect values function State:iterate(statements, hooks, matchHook) matchHook = matchHook or alwaysTrue local done = false local matches = false local rankPos = nil local result, numValues, doAppend, gotRequired for i, v in ipairs(statements) do -- rankPos will be nil for non-claim statements (e.g. qualifiers, references, etc.), -- but let appendOutput handle that matches, rankPos = matchHook(self, v)		if matches then result = {count = 0} doAppend = true -- if we need to return a single value, check if we don't have one already if self.singleValue then if not rankPos or rankPos == 1 then numValues = #self.outPreferred elseif rankPos == 2 then numValues = #self.outNormal elseif rankPos == 3 then numValues = #self.outDeprecated end if numValues > 0 then doAppend = false end end if doAppend then local function walk(formatTable) local value for i2, v2 in pairs(formatTable.req) do						if not result[i2] and hooks[i2] then -- call a hook and add its return value to the result value = self[hooks[i2]](self, v)							if value then result[i2] = value result.count = result.count + 1 else return false -- we miss a required value for this level end end if result.count == hooks.count then -- we're done if all hooks have been called; -- returning at this point breaks the loop return true end end for i2, v2 in ipairs(formatTable) do						if result.count == hooks.count then -- we're done if all hooks have been called; -- returning at this point prevents further childs from being processed return true end if v2.child then walk(v2.child) end end return true end gotRequired = walk(self.parsedFormat) -- only append the result if we got values for all required parameters on the root level if gotRequired then done = self:appendOutput(result, rankPos) if done then break end end end end end return self:out end

function p.property(frame) return p._property(frame.args) end

function p._property(args) return execCommand(args, "property") end

function p.properties(frame) return p._properties(frame.args) end

function p._properties(args) return execCommand(args, "properties") end

function p.qualifier(frame) return p._qualifier(frame.args) end

function p._qualifier(args) return execCommand(args, "qualifier") end

function p.qualifiers(frame) return p._qualifiers(frame.args) end

function p._qualifiers(args) return execCommand(args, "qualifiers") end

function p.reference(frame) return p._reference(frame.args) end

function p._reference(args) return execCommand(args, "reference") end

function p.references(frame) return p._references(frame.args) end

function p._references(args) return execCommand(args, "references") end

function execCommand(args, funcName) _ = Config.new _:processFlagOrCommand(funcName) -- process first command (== function name) local parsedFormat, formatParams, claims local hooks = {count = 0} local nextArg = args[1] local nextIndex = 2 -- process flags and commands while _:processFlagOrCommand(nextArg) do		nextArg = args[nextIndex] nextIndex = nextIndex + 1 end if nextArg then nextArg = mw.text.trim(nextArg) else nextArg = "" end -- check for optional item ID	if nextArg:sub(1,1):upper == "Q" then _.entity = mw.wikibase.getEntity(nextArg) -- item ID given _.propertyID = mw.text.trim(args[nextIndex] or "") -- property ID		nextIndex = nextIndex + 1 else _.entity = mw.wikibase.getEntity -- no item ID given, use item connected to current page _.propertyID = nextArg -- property ID	end -- check if given property ID is an alias if aliasesP[_.propertyID] then _.propertyID = aliasesP[_.propertyID] end _.propertyID = _.propertyID:upper if _.states[parameters.qualifier] then -- do further processing if "qualifier(s)" command was given nextArg = args[nextIndex] nextIndex = nextIndex + 1 _.qualifierID = nextArg nextArg = mw.text.trim(args[nextIndex] or "") nextIndex = nextIndex + 1 if nextArg == "" then -- claim ID or literal value has NOT been given _.propertyValue = nil _.qualifierID = mw.text.trim(_.qualifierID or "") else -- claim ID or literal value has been given _.propertyValue = _.qualifierID -- cannot be nil when reached _.qualifierID = nextArg end -- check if given qualifier ID is an alias if aliasesP[_.qualifierID] then _.qualifierID = aliasesP[_.qualifierID] end _.qualifierID = _.qualifierID:upper elseif _.states[parameters.reference] then -- do further processing if "reference(s)" command was given nextArg = args[nextIndex] nextIndex = nextIndex + 1 _.propertyValue = nextArg -- claim ID or literal value (possibly nil) end -- check for special property value 'somevalue' or 'novalue' if _.propertyValue then if _.propertyValue ~= "" and mw.text.trim(_.propertyValue) == "" then _.propertyValue = " " -- single space represents 'somevalue', whereas empty string represents 'novalue' else _.propertyValue = mw.text.trim(_.propertyValue) end end -- parse the desired format, or choose an appropriate format if args["format"] then parsedFormat, formatParams = parseFormat(mw.text.trim(args["format"])) elseif _.states[parameters.qualifier] then if _.states[parameters.property] then parsedFormat, formatParams = parseFormat(formats.propertyWithQualifier) else parsedFormat, formatParams = parseFormat(formats.qualifier) end elseif _.states[parameters.property] then parsedFormat, formatParams = parseFormat(formats.property) else parsedFormat, formatParams = parseFormat(formats.reference) -- if only "reference(s)" has been given, make the emtpy string the default separator (except when raw) if not _.states[parameters.reference].rawValue then _.separators["sep"][1] = "" end end -- process overridden separator values; -- must come AFTER parsing the formats for i, v in pairs(_.separators) do		if args[i] then _.separators[i][1] = args[i] end end -- make sure that at least one required parameter has been defined if not next(parsedFormat.req) then return missingRequiredParameterError end -- make sure that the separator parameter "%s" is not amongst the required parameters if parsedFormat.req[parameters.separator] then return extraRequiredParameterError(parameters.separator) end -- define the hooks that should be called (getProperty, getQualifiers, getReferences); -- only define a hook if both its command ("propert(y|ies)", "qualifier(s)", "reference(s)") and its parameter ("%p", "%q", "%r") have been given for i, v in pairs(_.states) do		if formatParams[i] then hooks[i] = hookNames[i][1] hooks.count = hooks.count + 1 end end -- create a state for "properties" if it doesn't exist yet, which will be used as a base configuration for each claim iteration; -- must come AFTER defining the hooks if not _.states[parameters.property] then _.states[parameters.property] = State.new(_) end -- set the parsed format and the separators (and optional punctuation mark) _.states[parameters.property].parsedFormat = parsedFormat _.states[parameters.property].separator = _.separators["sep"] _.states[parameters.property].movSeparator = _.separators["sep"..parameters.separator] _.states[parameters.property].puncMark = _.separators["punc"] if _.entity and _.entity.claims then claims = _.entity.claims[_.propertyID] end if claims then -- iterate through the claims to collect values return _.states[parameters.property]:iterate(claims, hooks, State.claimMatches) -- pass property State with level 1 hooks and matchHook else return "" end end

function p.label(frame) return p._label(frame.args) end

function p._label(args, _) _ = _ or Config.new _.curState = State.new(_) local ID	local label = "" local title = nil local nextArg = args[1] local nextIndex = 2 while _:processFlag(nextArg) do		nextArg = args[nextIndex] nextIndex = nextIndex + 1 end if nextArg then nextArg = mw.text.trim(nextArg) else nextArg = "" end ID = nextArg if ID ~= "" then if aliasesP[ID] then ID = aliasesP[ID] end ID = ID:upper -- check if this is a valid ID, and if the number is not larger than max int (to prevent error) if not string.match(ID, '^[QP]%d+$') or tonumber(string.match(ID, '%d+')) > 2147483647 then return "" end if _.curState.rawValue then if mw.wikibase.getEntity(ID) or mw.wikibase.resolvePropertyId(ID) then if _.curState.linked then if ID:sub(1,1) == "P" then label = "" .. ID .. "" else label = "" .. ID .. "" end else label = ID				end end else if ID:sub(1,1) == "P" then if not _.pageTitle then label = mw.wikibase.label(ID) or "" if _.curState.linked and label ~= "" then label = "" .. label .. "" end end else if not _.pageTitle then if _.curState.shortName then label = getShortName(ID) end -- at this point, 'label' will be a string and not nil if label == "" then label = mw.wikibase.label(ID) end else -- set 'label' to nil so 'title' will always prevail label = nil end -- at this point, 'label' will be nil or a non-empty string if _.curState.linked or label == nil then title = mw.wikibase.sitelink(ID) end if _.curState.linked and title then label = "" .. (label or title) .. "" else label = label or title or "" end end end else if _.curState.rawValue then label = mw.wikibase.getEntityIdForCurrentPage or "" if _.curState.linked and label ~= "" then label = "" .. label .. "" end else if not _.pageTitle then label = mw.wikibase.label else -- set 'label' to nil so 'title' will always prevail label = nil end if _.curState.linked or label == nil then title = mw.title.getCurrentTitle.prefixedText end if _.curState.linked then label = "" .. (label or title) .. "" -- not much use since it links to the current page, but does add wiki mark-up else label = label or title end end end return label end

function p.title(frame) return p._title(frame.args) end

function p._title(args, _) _ = _ or Config.new _.pageTitle = true return p._label(args, _) end

-- main function that may be used by wrapper templates function p.main(frame) local f, args, i, v	frame = frame:getParent or frame f = mw.text.trim(frame.args[1] or "") assert(p[f], 'The function "' .. f .. '" does not exist') args = {} -- copy arguments from immutable to mutable table for i, v in pairs(frame.args) do		args[i] = v	end -- remove the function name from the list table.remove(args, 1) return p["_"..f](args) end

return p