関南・東山地方Wiki

「モジュール:Wd」の版間の差分

モジュール 議論

モジュール:Wd (ソースを閲覧)

2021年6月22日 (火) 01:16時点における版

16,743 バイト追加 、 2021年6月22日 (火)
細
48版 をインポートしました
template>K-iczn
(en:Module:Wd 2017年5月10日 (水) 19:38(UTC)より)
細 (48版 をインポートしました)
 
(7人の利用者による、間の31版が非表示)
1行目: 1行目:
-- Original module located at [[:en:Module:Wd]].
-- Original module located at [[:en:Module:Wd]] and [[:en:Module:Wd/i18n]].


local p = {}
local p = {}
5行目: 5行目:
local i18n
local i18n


function loadSubmodules(frame)
local function loadI18n(aliasesP, frame)
-- internationalization
local title
 
if frame then
-- current module invoked by page/template, get its title from frame
title = frame:getTitle()
else
-- current module included by other module, get its title from ...
title = arg
end
 
if not i18n then
if not i18n then
if frame then
i18n = require(title .. "/i18n").init(aliasesP)
-- module invoked by page/template, get its title from frame
i18n = require(frame:getTitle().."/i18n")
else
-- module included by other module, get its title from ...
i18n = require(arg.."/i18n")
end
end
end
end
end
p.claimCommands = {
property  = "property",
properties = "properties",
qualifier  = "qualifier",
qualifiers = "qualifiers",
reference  = "reference",
references = "references"
}
p.generalCommands = {
label      = "label",
title      = "title",
description = "description",
alias      = "alias",
aliases    = "aliases",
badge      = "badge",
badges      = "badges"
}
p.flags = {
linked        = "linked",
short        = "short",
raw          = "raw",
multilanguage = "multilanguage",
unit          = "unit",
-------------
preferred    = "preferred",
normal        = "normal",
deprecated    = "deprecated",
best          = "best",
future        = "future",
current      = "current",
former        = "former",
edit          = "edit",
editAtEnd    = "edit@end",
mdy          = "mdy",
single        = "single",
sourced      = "sourced"
}
p.args = {
eid  = "eid",
page = "page",
date = "date"
}


local aliasesP = {
local aliasesP = {
coord           = "P625",
coord                   = "P625",
---------------
-----------------------
author         = "P50",
image                  = "P18",
publisher       = "P123",
author                 = "P50",
importedFrom   = "P143",
publisher               = "P123",
statedIn       = "P248",
importedFrom           = "P143",
publicationDate = "P577",
statedIn               = "P248",
startTime       = "P580",
pages                  = "P304",
endTime         = "P582",
language                = "P407",
retrieved       = "P813",
hasPart                = "P527",
referenceURL   = "P854",
publicationDate         = "P577",
archiveURL     = "P1065",
startTime               = "P580",
title           = "P1476",
endTime                 = "P582",
quote           = "P1683",
chapter                = "P792",
shortName       = "P1813",
retrieved               = "P813",
language        = "P2439",
referenceURL           = "P854",
archiveDate     = "P2960"
sectionVerseOrParagraph = "P958",
archiveURL             = "P1065",
title                   = "P1476",
formatterURL            = "P1630",
quote                   = "P1683",
shortName               = "P1813",
definingFormula        = "P2534",
archiveDate             = "P2960",
inferredFrom            = "P3452",
typeOfReference        = "P3865",
column                  = "P3903"
}
}


local aliasesQ = {
local aliasesQ = {
percentage              = "Q11229",
percentage              = "Q11229",
prolepticJulianCalendar = "Q1985786"
prolepticJulianCalendar = "Q1985786",
citeWeb                = "Q5637226",
citeQ                  = "Q22321052"
}
}


47行目: 108行目:
qualifier = "%q",
qualifier = "%q",
reference = "%r",
reference = "%r",
alias    = "%a",
badge    = "%b",
separator = "%s",
separator = "%s",
general  = "%x"
general  = "%x"
55行目: 118行目:
qualifier            = "%q[%s][%r]",
qualifier            = "%q[%s][%r]",
reference            = "%r",
reference            = "%r",
propertyWithQualifier = "%p[ <span style=\"font-size:smaller\">(%q)</span>][%s][%r]"
propertyWithQualifier = "%p[ <span style=\"font-size:85\\%\">(%q)</span>][%s][%r]",
alias                = "%a[%s]",
badge                = "%b[%s]"
}
}


62行目: 127行目:
[parameters.reference]        = {"getReferences", "getReference"},
[parameters.reference]        = {"getReferences", "getReference"},
[parameters.qualifier]        = {"getAllQualifiers"},
[parameters.qualifier]        = {"getAllQualifiers"},
[parameters.qualifier.."\\d"] = {"getQualifiers", "getQualifier"}
[parameters.qualifier.."\\d"] = {"getQualifiers", "getQualifier"},
[parameters.alias]            = {"getAlias"},
[parameters.badge]            = {"getBadge"}
}
}


73行目: 140行目:
["sep%r"]    = nil,  -- none
["sep%r"]    = nil,  -- none
["punc"]    = nil  -- none
["punc"]    = nil  -- none
}
local rankTable = {
["preferred"]  = 1,
["normal"]    = 2,
["deprecated"] = 3
}
}


local Config = {}
local Config = {}
Config.__index = Config


-- allows for recursive calls
-- allows for recursive calls
function Config.new()
function Config:new()
local cfg = {}
local cfg = {}
setmetatable(cfg, Config)
setmetatable(cfg, self)
self.__index = self
 
cfg.separators = {
cfg.separators = {
-- single value objects wrapped in arrays so that we can pass by reference
-- single value objects wrapped in arrays so that we can pass by reference
91行目: 164行目:
["punc"]  = {copyTable(defaultSeparators["punc"])}
["punc"]  = {copyTable(defaultSeparators["punc"])}
}
}
 
cfg.entity = nil
cfg.entity = nil
cfg.entityID = nil
cfg.propertyID = nil
cfg.propertyID = nil
cfg.propertyValue = nil
cfg.propertyValue = nil
cfg.qualifierIDs = {}
cfg.qualifierIDs = {}
cfg.qualifierIDsAndValues = {}
 
cfg.bestRank = true
cfg.bestRank = true
cfg.ranks = {true, true, false}  -- preferred = true, normal = true, deprecated = false
cfg.ranks = {true, true, false}  -- preferred = true, normal = true, deprecated = false
102行目: 177行目:
cfg.flagBest = false
cfg.flagBest = false
cfg.flagRank = false
cfg.flagRank = false
 
cfg.periods = {true, true, true}  -- future = true, current = true, former = true
cfg.periods = {true, true, true}  -- future = true, current = true, former = true
cfg.flagPeriod = false
cfg.flagPeriod = false
cfg.atDate = {parseDate(os.date('!%Y-%m-%d'))}  -- today as {year, month, day}
 
cfg.mdyDate = false
cfg.mdyDate = false
cfg.singleClaim = false
cfg.pageTitle = false
cfg.sourcedOnly = false
cfg.editable = false
cfg.editAtEnd = false
 
cfg.inSitelinks = false
 
cfg.langCode = mw.language.getContentLanguage().code
cfg.langCode = mw.language.getContentLanguage().code
cfg.langName = mw.language.fetchLanguageName(cfg.langCode, cfg.langCode)
cfg.langName = mw.language.fetchLanguageName(cfg.langCode, cfg.langCode)
cfg.langObj = mw.language.new(cfg.langCode)
cfg.langObj = mw.language.new(cfg.langCode)
 
cfg.siteID = mw.wikibase.getGlobalSiteId()
 
cfg.states = {}
cfg.states = {}
cfg.states.qualifiersCount = 0
cfg.states.qualifiersCount = 0
cfg.curState = nil
cfg.curState = nil
 
cfg.prefetchedRefs = nil
 
return cfg
return cfg
end
end


local State = {}
local State = {}
State.__index = State


function State.new(cfg)
function State:new(cfg, type)
local stt = {}
local stt = {}
setmetatable(stt, State)
setmetatable(stt, self)
self.__index = self
 
stt.conf = cfg
stt.conf = cfg
stt.type = type
 
stt.results = {}
stt.results = {}
 
stt.parsedFormat = {}
stt.parsedFormat = {}
stt.separator = {}
stt.separator = {}
stt.movSeparator = {}
stt.movSeparator = {}
stt.puncMark = {}
stt.puncMark = {}
 
stt.linked = false
stt.linked = false
stt.rawValue = false
stt.rawValue = false
stt.shortName = false
stt.shortName = false
stt.anyLanguage = false
stt.unitOnly = false
stt.singleValue = false
stt.singleValue = false
 
return stt
return stt
end
end


function applyStringParams(str, ...)
local function replaceAlias(id)
for i, v in ipairs(arg) do
if aliasesP[id] then
str = mw.ustring.gsub(str, "$"..i, v)
id = aliasesP[id]
end
end
 
return str
return id
end
end


function unknownDataTypeError(dataType)
local function errorText(code, param)
return applyStringParams(i18n['errors']['unknown-data-type'], dataType)
local text = i18n["errors"][code]
if param then text = mw.ustring.gsub(text, "$1", param) end
return text
end
end


function missingRequiredParameterError()
local function throwError(errorMessage, param)
return i18n['errors']['missing-required-parameter']
error(errorText(errorMessage, param))
end
end


function extraRequiredParameterError(param)
local function replaceDecimalMark(num)
return applyStringParams(i18n['errors']['extra-required-parameter'], param)
return mw.ustring.gsub(num, "[.]", i18n['numeric']['decimal-mark'], 1)
end
end


-- used to make frame.args mutable, to replace #frame.args (which is always 0)
local function padZeros(num, numDigits)
-- with the actual amount and to simply copy tables
local numZeros
function copyTable(tIn)
local negative = false
if not tIn then
 
return nil
if num < 0 then
negative = true
num = num * -1
end
end
 
local tOut = {}
num = tostring(num)
numZeros = numDigits - num:len()
for i, v in pairs(tIn) do
 
tOut[i] = v
for _ = 1, numZeros do
num = "0"..num
end
end
return tOut
end


-- used to merge output arrays together;
if negative then
-- note that it currently mutates the first input array
num = "-"..num
function mergeArrays(a1, a2)
for i = 1, #a2 do
a1[#a1 + 1] = a2[i]
end
end
 
return a1
return num
end
end


-- used to create the final output string when it's all done, so that for references the
local function replaceSpecialChar(chr)
-- function extensionTag("ref", ...) is only called when they really ended up in the final output
if chr == '_' then
function concatValues(valuesArray)
-- replace underscores with spaces
local outString = ""
return ' '
local j, skip
else
return chr
for i = 1, #valuesArray do
-- check if this is a reference
if valuesArray[i].refHash then
j = i - 1
skip = false
-- skip this reference if it is part of a continuous row of references that already contains the exact same reference
while valuesArray[j] and valuesArray[j].refHash do
if valuesArray[i].refHash == valuesArray[j].refHash then
skip = true
break
end
j = j - 1
end
if not skip then
-- add <ref> tag with the reference's hash as its name (to deduplicate references)
outString = outString .. mw.getCurrentFrame():extensionTag("ref", valuesArray[i][1], {name = "wikidata-" .. valuesArray[i].refHash})
end
else
outString = outString .. valuesArray[i][1]
end
end
end
return outString
end
end


function getHookName(param, index)
local function replaceSpecialChars(str)
if hookNames[param] then
local chr
return hookNames[param][index]
local esc = false
elseif string.len(param) > 2 then
local strOut = ""
return hookNames[string.sub(param, 1, 2).."\\d"][index]
 
else
for i = 1, #str do
return nil
chr = str:sub(i,i)
 
if not esc then
if chr == '\\' then
esc = true
else
strOut = strOut .. replaceSpecialChar(chr)
end
else
strOut = strOut .. chr
esc = false
end
end
end
return strOut
end
end


function parseWikidataURL(url)
local function buildWikilink(target, label)
local i, j
if not label or target == label then
return "[[" .. target .. "]]"
if url:match('^http[s]?://') then
else
i, j = url:find("Q")
return "[[" .. target .. "|" .. label .. "]]"
if i then
return url:sub(i)
end
end
end
return nil
end
end


function parseDate(dateStr, precision)
-- used to make frame.args mutable, to replace #frame.args (which is always 0)
precision = precision or "d"
-- with the actual amount and to simply copy tables
local i, j, index, ptr
function copyTable(tIn)
local parts = {nil, nil, nil}
if not tIn then
return nil
if dateStr == nil then
return parts[1], parts[2], parts[3]  -- year, month, day
end
end
 
-- 'T' for snak values, '/' for outputs with '/Julian' attached
local tOut = {}
i, j = dateStr:find("[T/]")
 
for i, v in pairs(tIn) do
if i then
tOut[i] = v
dateStr = dateStr:sub(1, i-1)
end
end
 
local from = 1
return tOut
end
if dateStr:sub(1,1) == "-" then
 
-- this is a negative number, look further ahead
-- used to merge output arrays together;
from = 2
-- note that it currently mutates the first input array
end
local function mergeArrays(a1, a2)
for i = 1, #a2 do
index = 1
a1[#a1 + 1] = a2[i]
ptr = 1
end
 
i, j = dateStr:find("-", from)
return a1
end
if i then
 
-- year
local function split(str, del)
parts[index] = tonumber(mw.ustring.gsub(dateStr:sub(ptr, i-1), "^\+(.+)$", "%1"), 10)  -- remove '+' sign (explicitly give base 10 to prevent error)
local out = {}
local i, j = str:find(del)
if parts[index] == -0 then
 
parts[index] = tonumber("0")  -- for some reason, 'parts[index] = 0' may actually store '-0', so parse from string instead
if i and j then
end
out[1] = str:sub(1, i - 1)
out[2] = str:sub(j + 1)
if precision == "y" then
else
-- we're done
out[1] = str
return parts[1], parts[2], parts[3]  -- year, month, day
end
end
 
return out
index = index + 1
end
ptr = i + 1
 
local function parseWikidataURL(url)
i, j = dateStr:find("-", ptr)
local id
 
if i then
if url:match('^http[s]?://') then
-- month
id = split(url, "Q")
parts[index] = tonumber(dateStr:sub(ptr, i-1), 10)
 
if id[2] then
if precision == "m" then
return "Q" .. id[2]
-- we're done
return parts[1], parts[2], parts[3]  -- year, month, day
end
index = index + 1
ptr = i + 1
end
end
end
end
 
if dateStr:sub(ptr) ~= "" then
return nil
-- 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
end


function convertUnit(unit, link)
function parseDate(dateStr, precision)
link = link or false
precision = precision or "d"
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 " " .. "[[" .. title .. "|" .. (label or title) .. "]]"
end
if not label then
return " " .. "[[d:" .. itemID .. "|" .. itemID .. "]]"
end
end
return " " .. (label or title or itemID)
end
end
return " " .. unit
end


function getOrdinalSuffix(num)
local i, j, index, ptr
return i18n.getOrdinalSuffix(num)
local parts = {nil, nil, nil}
end


function addDelimiters(num)
if dateStr == nil then
return i18n.addDelimiters(num)
return parts[1], parts[2], parts[3]  -- year, month, day
end
end


-- used for cleaner output when subst:ituting this module
-- 'T' for snak values, '/' for outputs with '/Julian' attached
function replaceHTMLSpaces(str)
i, j = dateStr:find("[T/]")
return mw.ustring.gsub(str, "&#32;", " ")
end


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


function datePrecedesDate(aY, aM, aD, bY, bM, bD)
local from = 1
if aY == nil or bY == nil then
 
return nil
if dateStr:sub(1,1) == "-" then
-- this is a negative number, look further ahead
from = 2
end
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()
index = 1
return true
ptr = 1
end
 
i, j = dateStr:find("-", from)
 
if i then
-- year
parts[index] = tonumber(mw.ustring.gsub(dateStr:sub(ptr, i-1), "^\+(.+)$", "%1"), 10)  -- remove '+' sign (explicitly give base 10 to prevent error)
 
if parts[index] == -0 then
parts[index] = tonumber("0")  -- for some reason, 'parts[index] = 0' may actually store '-0', so parse from string instead
end


-- The following function parses a format string.
if precision == "y" then
--
-- we're done
-- The example below shows how a parsed string is structured in memory.
return parts[1], parts[2], parts[3] -- year, month, day
-- Variables other than 'str' and 'child' are left out for clarity's sake.
end
--
 
-- Example:
index = index + 1
-- "A %p B [%s[%q1]] C [%r] D"
ptr = i + 1
--
 
-- Structure:
i, j = dateStr:find("-", ptr)
-- [
 
--  {
if i then
--    str = "A "
-- month
--  },
parts[index] = tonumber(dateStr:sub(ptr, i-1), 10)
--  {
 
--    str = "%p"
if precision == "m" then
--  },
-- we're done
--  {
return parts[1], parts[2], parts[3] -- year, month, day
--    str = " B ",
end
--     child =
 
--    [
index = index + 1
--      {
ptr = i + 1
--        str = "%s",
end
--        child =
end
--        [
 
--          {
if dateStr:sub(ptr) ~= "" then
--            str = "%q1"
-- 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
--  {
 
--    str = " C ",
local function datePrecedesDate(aY, aM, aD, bY, bM, bD)
--    child =
if aY == nil or bY == nil then
--    [
return nil
--      {
end
--        str = "%r"
aM = aM or 1
--       }
aD = aD or 1
--    ]
bM = bM or 1
--  },
bD = bD or 1
--  {
 
--    str = " D"
if aY < bY then
--   }
return true
-- ]
--
function parseFormat(str)
local chr, esc, param, root, cur, prev, new
local params = {}
local function newObject(array)
local obj = {}  -- new object
obj.str = ""
array[#array + 1] = obj  -- array{object}
obj.parent = array
return obj
end
end
 
local function endParam()
if aY > bY then
if param > 0 then
return false
if cur.str ~= "" then
cur.str = "%"..cur.str
cur.param = true
params[cur.str] = true
cur.parent.req[cur.str] = true
prev = cur
cur = newObject(cur.parent)
end
param = 0
end
end
end
root = {}  -- array
root.req = {}
cur = newObject(root)
prev = nil
esc = false
param = 0
for i = 1, #str do
chr = str:sub(i,i)
if not esc then
if chr == '\\' then
endParam()
esc = true
elseif chr == '%' then
endParam()
if cur.str ~= "" then
cur = newObject(cur.parent)
end
param = 2
elseif chr == '[' then
endParam()
if prev and cur.str == "" then
table.remove(cur.parent)
cur = prev
end
cur.child = {}  -- new array
cur.child.req = {}
cur.child.parent = cur
cur = newObject(cur.child)
elseif chr == ']' then
endParam()
if cur.parent.parent then
new = newObject(cur.parent.parent.parent)
if cur.str == "" then
table.remove(cur.parent)
end
cur = new
end
else
if param > 1 then
param = param - 1
elseif param == 1 then
if not string.match(chr, '%d') then
endParam()
end
end
cur.str = cur.str .. chr
end
else
cur.str = cur.str .. chr
esc = false
end
prev = nil
end
endParam()
return root, params
end


function sortOnRank(claims)
if aM < bM then
local rankPos
return true
local ranks = {{}, {}, {}, {}}  -- preferred, normal, deprecated, (default)
end
local sorted = {}
 
if aM > bM then
for i, v in ipairs(claims) do
return false
rankPos = convertRank(v.rank)
end
ranks[rankPos][#ranks[rankPos] + 1] = v
 
end
if aD < bD then
return true
sorted = ranks[1]
end
sorted = mergeArrays(sorted, ranks[2])
 
sorted = mergeArrays(sorted, ranks[3])
return false
end
return sorted
 
end
local function getHookName(param, index)
if hookNames[param] then
return hookNames[param][index]
elseif param:len() > 2 then
return hookNames[param:sub(1, 2).."\\d"][index]
else
return nil
end
end
 
local function alwaysTrue()
return true
end
 
-- The following function parses a format string.
--
-- The example below shows how a parsed string is structured in memory.
-- Variables other than 'str' and 'child' are left out for clarity's sake.
--
-- Example:
-- "A %p B [%s[%q1]] C [%r] D"
--
-- Structure:
-- [
--  {
--    str = "A "
--  },
--  {
--    str = "%p"
--  },
--  {
--    str = " B ",
--    child =
--    [
--      {
--         str = "%s",
--        child =
--        [
--          {
--            str = "%q1"
--          }
--        ]
--      }
--    ]
--  },
--  {
--    str = " C ",
--    child =
--    [
--      {
--        str = "%r"
--      }
--    ]
--  },
--  {
--    str = " D"
--  }
-- ]
--
local function parseFormat(str)
local chr, esc, param, root, cur, prev, new
local params = {}
 
local function newObject(array)
local obj = {}  -- new object
obj.str = ""


function getShortName(itemID)
array[#array + 1] = obj -- array{object}
if itemID then
obj.parent = array
return p._property({itemID, aliasesP.shortName}) -- "property" is single
else
return p._property({aliasesP.shortName})  -- "property" is single
end
end


function getLabel(ID)
return obj
if ID then
return p._label({ID})
else
return p._label({})
end
end
end


function Config:getValue(snak, raw, link, short, anyLang)
local function endParam()
raw = raw or false
if param > 0 then
link = link or false
if cur.str ~= "" then
short = short or false
cur.str = "%"..cur.str
anyLang = anyLang or false
cur.param = true
params[cur.str] = true
if snak.snaktype == 'value' then
cur.parent.req[cur.str] = true
if snak.datavalue.type == 'string' then
prev = cur
return snak.datavalue.value
cur = newObject(cur.parent)
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
end
elseif snak.datavalue.type == 'quantity' then
param = 0
-- strip + signs from front
end
local value = mw.ustring.gsub(snak.datavalue.value['amount'], "^\+(.+)$", "%1")
end
 
-- replace decimal mark based on locale
root = {}  -- array
value = mw.ustring.gsub(value, "[.]", i18n['numeric']['decimal-mark'], 1)
root.req = {}
cur = newObject(root)
if not raw then
prev = nil
value = addDelimiters(value)
 
local unit = convertUnit(snak.datavalue.value['unit'], link)
esc = false
if unit then
param = 0
value = value .. unit
 
end
for i = 1, #str do
end
chr = str:sub(i,i)
 
return value
if not esc then
elseif snak.datavalue.type == 'time' then
if chr == '\\' then
local y, m, d, p, yDiv, yRound, yFull, value, calendarID, dateStr
endParam()
local yFactor = 1
esc = true
local sign = 1
elseif chr == '%' then
local prefix = ""
endParam()
local suffix = ""
if cur.str ~= "" then
local mayAddCalendar = false
cur = newObject(cur.parent)
local calendar = ""
end
local precision = snak.datavalue.value['precision']
param = 2
elseif chr == '[' then
if precision == 11 then
endParam()
p = "d"
if prev and cur.str == "" then
elseif precision == 10 then
table.remove(cur.parent)
p = "m"
cur = prev
else
end
p = "y"
cur.child = {}  -- new array
yFactor = 10^(9-precision)
cur.child.req = {}
end
cur.child.parent = cur
cur = newObject(cur.child)
y, m, d = parseDate(snak.datavalue.value['time'], p)
elseif chr == ']' then
endParam()
if y < 0 then
if cur.parent.parent then
sign = -1
new = newObject(cur.parent.parent.parent)
y = y * sign
if cur.str == "" then
end
table.remove(cur.parent)
-- 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 = i18n['datetime']['suffixes']['millennium']
else
suffix = i18n['datetime']['suffixes']['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
prefix = i18n['datetime']['prefixes']['decade-period']
suffix = i18n['datetime']['suffixes']['decade-period']
end
end
end
cur = new
if raw and sign < 0 then
end
-- if BCE then compensate for "counting backwards"
else
-- (e.g. -2019 for 2010s BCE, -2000 for 20th century BCE or -3000 for 3rd millennium BCE)
if param > 1 then
yRound = yRound + yFactor - 1
param = param - 1
elseif param == 1 then
if not chr:match('%d') then
endParam()
end
end
else
end
local yReFactor, yReDiv, yReRound
 
cur.str = cur.str .. replaceSpecialChar(chr)
-- round to nearest for tens of thousands of years or more
end
yRound = math.floor(yDiv + 0.5)
else
cur.str = cur.str .. chr
if yRound == 0 then
esc = false
if precision <= 2 and y ~= 0 then
end
yReFactor = 1e6
 
yReDiv = y / yReFactor
prev = nil
yReRound = math.floor(yReDiv + 0.5)
end
 
if yReDiv == yReRound then
endParam()
-- change precision to millions of years only if we have a whole number of them
 
precision = 3
-- make sure that at least one required parameter has been defined
yFactor = yReFactor
if not next(root.req) then
yRound = yReRound
throwError("missing-required-parameter")
end
end
end
 
-- make sure that the separator parameter "%s" is not amongst the required parameters
if yRound == 0 then
if root.req[parameters.separator] then
-- otherwise, take the unrounded (original) number of years
throwError("extra-required-parameter", parameters.separator)
precision = 5
end
yFactor = 1
 
yRound = y
return root, params
mayAddCalendar = true
end
end
 
end
local function sortOnRank(claims)
local rankPos
if precision >= 1 and y ~= 0 then
local ranks = {{}, {}, {}, {}}  -- preferred, normal, deprecated, (default)
yFull = yRound * yFactor
local sorted = {}
 
yReFactor = 1e9
for _, v in ipairs(claims) do
yReDiv = yFull / yReFactor
rankPos = rankTable[v.rank] or 4
yReRound = math.floor(yReDiv + 0.5)
ranks[rankPos][#ranks[rankPos] + 1] = v
end
if yReDiv == yReRound then
 
-- change precision to billions of years if we're in that range
sorted = ranks[1]
precision = 0
sorted = mergeArrays(sorted, ranks[2])
yFactor = yReFactor
sorted = mergeArrays(sorted, ranks[3])
yRound = yReRound
 
else
return sorted
yReFactor = 1e6
end
yReDiv = yFull / yReFactor
 
yReRound = math.floor(yReDiv + 0.5)
-- if id == nil then item connected to current page is used
function Config:getLabel(id, raw, link, short)
if yReDiv == yReRound then
local label = nil
-- change precision to millions of years if we're in that range
local title = nil
precision = 3
local prefix= ""
yFactor = yReFactor
 
yRound = yReRound
if not id then
end
id = mw.wikibase.getEntityIdForCurrentPage()
end
 
end
if not id then
return ""
if not raw then
end
if precision == 3 then
end
suffix = i18n['datetime']['suffixes']['million-years']
 
elseif precision == 0 then
id = id:upper()  -- just to be sure
suffix = i18n['datetime']['suffixes']['billion-years']
 
else
if raw then
yRound = yRound * yFactor
-- check if given id actually exists
if yRound == 1 then
if mw.wikibase.isValidEntityId(id) and mw.wikibase.entityExists(id) then
suffix = i18n['datetime']['suffixes']['year']
label = id
else
 
suffix = i18n['datetime']['suffixes']['years']
if id:sub(1,1) == "P" then
end
prefix = "Property:"
end
end
else
end
yRound = yRound * yFactor
 
end
prefix = "d:" .. prefix
end
 
else
title = label  -- may be nil
yRound = y
else
mayAddCalendar = true
-- try short name first if requested
if short then
label = p._property{aliasesP.shortName, [p.args.eid] = id}  -- get short name
 
if label == "" then
label = nil
end
end
end
if mayAddCalendar then
 
calendarID = parseWikidataURL(snak.datavalue.value['calendarmodel'])
-- get label
if not label then
if calendarID and calendarID == aliasesQ.prolepticJulianCalendar then
label = mw.wikibase.getLabelByLang(id, self.langCode)
if not raw then
end
if link then
end
calendar = " ([["..i18n['datetime']['julian-calendar'].."|"..i18n['datetime']['julian'].."]])"
 
else
if not label then
calendar = " ("..i18n['datetime']['julian']..")"
label = ""
end
elseif link then
else
-- build a link if requested
calendar = "/"..i18n['datetime']['julian']
if not title then
end
if id:sub(1,1) == "Q" then
end
title = mw.wikibase.getSitelink(id)
elseif id:sub(1,1) == "P" then
-- properties have no sitelink, link to Wikidata instead
title = id
prefix = "d:Property:"
end
end
end
if not raw then
 
local ce = nil
if title then
label = buildWikilink(prefix .. title, label)
if sign < 0 then
end
ce = i18n['datetime']['BCE']
end
elseif precision <= 5 then
 
ce = i18n['datetime']['CE']
return label
end
end
 
if ce then
function Config:getEditIcon()
if link then
local value = ""
ce = "[[" .. i18n['datetime']['common-era'] .. "|" .. ce .. "]]"
local prefix = ""
end
local front = "&nbsp;"
suffix = suffix .. " " .. ce
local back = ""
end
 
if self.entityID:sub(1,1) == "P" then
value = tostring(yRound)
prefix = "Property:"
end
if m then
 
dateStr = self.langObj:formatDate("F", "1-"..m.."-1")
if self.editAtEnd then
front = '<span style="float:'
if d then
 
if self.mdyDate then
if self.langObj:isRTL() then
dateStr = dateStr .. " " .. d .. ","
front = front .. 'left'
else
else
dateStr = d .. " " .. dateStr
front = front .. 'right'
end
end
end
 
front = front .. '">'
value = dateStr .. " " .. value
back = '</span>'
end
 
value = "[[File:OOjs UI icon edit-ltr-progressive.svg|frameless|text-top|10px|alt=" .. i18n['info']['edit-on-wikidata'] .. "|link=https://www.wikidata.org/wiki/" .. prefix .. self.entityID .. "?uselang=" .. self.langCode
 
if self.propertyID then
value = value .. "#" .. self.propertyID
elseif self.inSitelinks then
value = value .. "#sitelinks-wikipedia"
end
 
value = value .. "|" .. i18n['info']['edit-on-wikidata'] .. "]]"
 
return front .. value .. back
end
 
-- used to create the final output string when it's all done, so that for references the
-- function extensionTag("ref", ...) is only called when they really ended up in the final output
function Config:concatValues(valuesArray)
local outString = ""
local j, skip
 
for i = 1, #valuesArray do
-- check if this is a reference
if valuesArray[i].refHash then
j = i - 1
skip = false
 
-- skip this reference if it is part of a continuous row of references that already contains the exact same reference
while valuesArray[j] and valuesArray[j].refHash do
if valuesArray[i].refHash == valuesArray[j].refHash then
skip = true
break
end
end
j = j - 1
value = prefix .. value .. suffix .. calendar
end
else
 
value = tostring(yRound * sign)
if not skip then
-- add <ref> tag with the reference's hash as its name (to deduplicate references)
if m then
outString = outString .. mw.getCurrentFrame():extensionTag("ref", valuesArray[i][1], {name = valuesArray[i].refHash})
value = value .. "-" .. m
if d then
value = value .. "-" .. d
end
end
value = value .. calendar
end
end
else
return value
outString = outString .. valuesArray[i][1]
elseif snak.datavalue.type == 'globecoordinate' then
end
-- logic from https://github.com/DataValues/Geo
end
 
local precision, numDigits, strFormat, value, globe
return outString
local latValue, latitude, latDegrees, latMinutes, latSeconds
end
local latDirection = i18n['coord']['latitude-north']
 
local lonValue, longitude, lonDegrees, lonMinutes, lonSeconds
function Config:convertUnit(unit, raw, link, short, unitOnly)
local lonDirection = i18n['coord']['longitude-east']
local space = " "
local label = ""
local degSymbol = i18n['coord']['degrees']
local itemID
local minSymbol = i18n['coord']['minutes']
 
local secSymbol = i18n['coord']['seconds']
if unit == "" or unit == "1" then
local separator = i18n['coord']['separator']
return nil
end
if raw then
 
degSymbol = "/"
if unitOnly then
minSymbol = "/"
space = ""
secSymbol = "/"
end
separator = "/"
 
end
itemID = parseWikidataURL(unit)
 
latitude = snak.datavalue.value['latitude']
if itemID then
longitude = snak.datavalue.value['longitude']
if itemID == aliasesQ.percentage then
return "%"
if latitude < 0 then
else
latDirection = i18n['coord']['latitude-south']
label = self:getLabel(itemID, raw, link, short)
latitude = math.abs(latitude)
 
end
if label ~= "" then
if longitude < 0 then
return space .. label
lonDirection = i18n['coord']['longitude-west']
longitude = math.abs(longitude)
end
end
end
precision = snak.datavalue.value['precision']
end
 
latitude = math.floor(latitude / precision + 0.5) * precision
return ""
longitude = math.floor(longitude / precision + 0.5) * precision
end
 
numDigits = math.ceil(-math.log10(3600 * precision))
function State:getValue(snak)
return self.conf:getValue(snak, self.rawValue, self.linked, self.shortName, self.anyLanguage, self.unitOnly, false, self.type:sub(1,2))
if numDigits < 0 or numDigits == -0 then
end
numDigits = tonumber("0")  -- for some reason, 'numDigits = 0' may actually store '-0', so parse from string instead
 
end
function Config:getValue(snak, raw, link, short, anyLang, unitOnly, noSpecial, type)
if snak.snaktype == 'value' then
strFormat = "%." .. numDigits .. "f"
local datatype = snak.datavalue.type
local subtype = snak.datatype
-- use string.format() to strip decimal point followed by a zero (.0) for whole numbers
local datavalue = snak.datavalue.value
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))
if datatype == 'string' then
if subtype == 'url' and link then
latMinutes = math.floor(latSeconds / 60)
-- create link explicitly
lonMinutes = math.floor(lonSeconds / 60)
if raw then
-- will render as a linked number like [1]
latSeconds = latSeconds - (latMinutes * 60)
return "[" .. datavalue .. "]"
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)
-- replace decimal marks based on locale
latSeconds = mw.ustring.gsub(latSeconds, "[.]", i18n['numeric']['decimal-mark'], 1)
lonSeconds = mw.ustring.gsub(lonSeconds, "[.]", i18n['numeric']['decimal-mark'], 1)
latValue = latValue .. latSeconds .. secSymbol
lonValue = lonValue .. lonSeconds .. secSymbol
end
latValue = latValue .. latDirection
lonValue = lonValue .. lonDirection
value = latValue .. separator .. lonValue
if link then
globe = parseWikidataURL(snak.datavalue.value['globe'])
if globe then
globe = mw.wikibase.getEntity(globe):getLabel("en"):lower()
else
else
globe = "earth"
return "[" .. datavalue .. " " .. datavalue .. "]"
end
end
elseif subtype == 'commonsMedia' then
value = "[https://tools.wmflabs.org/geohack/geohack.php?language="..self.langCode.."&params="..latitude.."_"..latDirection.."_"..longitude.."_"..lonDirection.."_globe:"..globe.." "..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
if link then
return "[[d:" .. itemID .. "|" .. itemID .. "]]"
return buildWikilink("c:File:" .. datavalue, datavalue)
elseif not raw then
return "[[File:" .. datavalue .. "]]"
else
return datavalue
end
elseif subtype == 'geo-shape' and link then
return buildWikilink("c:" .. datavalue, datavalue)
elseif subtype == 'math' and not raw then
local attribute = nil
 
if (type == parameters.property or (type == parameters.qualifier and self.propertyID == aliasesP.hasPart)) and snak.property == aliasesP.definingFormula then
attribute = {qid = self.entityID}
end
 
return mw.getCurrentFrame():extensionTag("math", datavalue, attribute)
elseif subtype == 'external-id' and link then
local url = p._property{aliasesP.formatterURL, [p.args.eid] = snak.property}  -- get formatter URL
 
if url ~= "" then
url = mw.ustring.gsub(url, "$1", datavalue)
return "[" .. url .. " " .. datavalue .. "]"
else
else
return itemID
return datavalue
end
end
else
return datavalue
end
end
elseif datatype == 'monolingualtext' then
if short then
if anyLang or datavalue['language'] == self.langCode then
value = getShortName(itemID)
return datavalue['text']
else
return nil
end
end
elseif datatype == 'quantity' then
if value == "" then
local value = ""
value = mw.wikibase.label(itemID)
local unit
 
if not unitOnly then
-- get value and strip + signs from front
value = mw.ustring.gsub(datavalue['amount'], "^\+(.+)$", "%1")
 
if raw then
return value
end
 
-- replace decimal mark based on locale
value = replaceDecimalMark(value)
 
-- add delimiters for readability
value = i18n.addDelimiters(value)
end
end
 
if link or value == nil then
unit = self:convertUnit(datavalue['unit'], raw, link, short, unitOnly)
title = mw.wikibase.sitelink(itemID)
 
end
if unit then
value = value .. unit
if link then
if title then
value = "[[" .. title .. "|" .. (value or title) .. "]]"
elseif not value then
value = "[[d:" .. itemID .. "|" .. itemID .. "]]"
end
elseif not value then
value = (title or itemID)
end
end
 
return value
return value
else
elseif datatype == 'time' then
return '<strong class="error">' .. unknownDataTypeError(snak.datavalue.type) .. '</strong>'
local y, m, d, p, yDiv, yRound, yFull, value, calendarID, dateStr
end
local yFactor = 1
elseif snak.snaktype == 'somevalue' then
local sign = 1
if raw then
local prefix = ""
return " " -- single space represents 'somevalue'
local suffix = ""
else
local mayAddCalendar = false
return i18n['values']['unknown']
local calendar = ""
end
local precision = datavalue['precision']
elseif snak.snaktype == 'novalue' then
 
if raw then
if precision == 11 then
return "" -- empty string represents 'novalue'
p = "d"
else
elseif precision == 10 then
return i18n['values']['none']
p = "m"
end
else
else
p = "y"
return nil
yFactor = 10^(9-precision)
end
end
end


function Config:getSingleRawQualifier(claim, qualifierID)
y, m, d = parseDate(datavalue['time'], p)
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)
if y < 0 then
local snakValue = self:getValue(snak, true)  -- raw = true
sign = -1
y = y * sign
if snakValue and snak.snaktype == 'value' and snak.datavalue.type == 'wikibase-entityid' then value = value:upper() end
end
 
return snakValue == value
-- if precision is tens/hundreds/thousands/millions/billions of years
end
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)


function Config:setRank(rank)
if not raw then
local rankPos
if precision == 6 then
suffix = i18n['datetime']['suffixes']['millennium']
if rank == "best" then
else
self.bestRank = true
suffix = i18n['datetime']['suffixes']['century']
self.flagBest = true  -- mark that 'best' flag was given
end
return
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
else
return
end
-- one of the rank flags was given, check if another one was given before
if not self.flagRank then
self.ranks = {false, false, false}  -- no other rank flag given before, so unset ranks
self.bestRank = self.flagBest      -- unsets bestRank only if 'best' flag was not given before
self.flagRank = true                -- mark that a rank flag was given
end
if rank:sub(-1) == "+" then
for i = rankPos, 1, -1 do
self.ranks[i] = true
end
elseif rank:sub(-1) == "-" then
for i = rankPos, #self.ranks do
self.ranks[i] = true
end
else
self.ranks[rankPos] = true
end
end


function Config:setPeriod(period)
suffix = i18n.getOrdinalSuffix(yRound) .. suffix
local periodPos
else
-- if not verbose, take the first year of the century/millennium
if period == "future" then
-- (e.g. 1901 for 20th century or 2001 for 3rd millennium)
periodPos = 1
yRound = (yRound - 1) * yFactor + 1
elseif period == "current" then
end
periodPos = 2
else
elseif period == "former" then
-- precision == 8
periodPos = 3
-- round decades down (e.g. 2010s)
else
yRound = math.floor(yDiv) * yFactor
return
end
-- one of the period flags was given, check if another one was given before
if not self.flagPeriod then
self.periods = {false, false, false}  -- no other period flag given before, so unset periods
self.flagPeriod = true                -- mark that a period flag was given
end
self.periods[periodPos] = true
end


function Config:processFlag(flag)
if not raw then
if not flag then
prefix = i18n['datetime']['prefixes']['decade-period']
return false
suffix = i18n['datetime']['suffixes']['decade-period']
else
end
flag = mw.text.trim(flag)
end
end
 
if raw and sign < 0 then
if flag == "linked" then
-- if BCE then compensate for "counting backwards"
self.curState.linked = true
-- (e.g. -2019 for 2010s BCE, -2000 for 20th century BCE or -3000 for 3rd millennium BCE)
return true
yRound = yRound + yFactor - 1
elseif flag == "raw" then
end
self.curState.rawValue = true
else
local yReFactor, yReDiv, yReRound
if self.curState == self.states[parameters.reference] then
 
-- raw reference values end with periods and require a separator (other than none)
-- round to nearest for tens of thousands of years or more
self.separators["sep%r"][1] = {" "}
yRound = math.floor(yDiv + 0.5)
end
 
if yRound == 0 then
return true
if precision <= 2 and y ~= 0 then
elseif flag == "short" then
yReFactor = 1e6
self.curState.shortName = true
yReDiv = y / yReFactor
return true
yReRound = math.floor(yReDiv + 0.5)
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:setRank(flag)
return true
elseif flag == "future" or flag == "current" or flag == "former" then
self:setPeriod(flag)
return true
elseif flag == "" then
-- ignore empty flags and carry on
return true
else
return false
end
end


function Config:processFlagOrCommand(flag)
if yReDiv == yReRound then
local param = ""
-- change precision to millions of years only if we have a whole number of them
precision = 3
if not flag then
yFactor = yReFactor
return false
yRound = yReRound
else
end
flag = mw.text.trim(flag)
end
end
 
if yRound == 0 then
if flag == "property" or flag == "properties" then
-- otherwise, take the unrounded (original) number of years
param = parameters.property
precision = 5
elseif flag:match('^qualifier[s]?$') then
yFactor = 1
self.states.qualifiersCount = self.states.qualifiersCount + 1
yRound = y
param = parameters.qualifier .. self.states.qualifiersCount
mayAddCalendar = true
self.separators["sep"..param] = {copyTable(defaultSeparators["sep%q\\d"])}
end
elseif flag:match('^reference[s]?$') then
end
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(parameters.general)  -- 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 precision >= 1 and y ~= 0 then
if self.bestRank then
yFull = yRound * yFactor
return (self.ranks[rankPos] and self.foundRank >= rankPos)
else
return self.ranks[rankPos]
end
end


function Config:timeMatches(claim)
yReFactor = 1e9
local startTime = nil
yReDiv = yFull / yReFactor
local startTimeY = nil
yReRound = math.floor(yReDiv + 0.5)
local startTimeM = nil
 
local startTimeD = nil
if yReDiv == yReRound then
local endTime = nil
-- change precision to billions of years if we're in that range
local endTimeY = nil
precision = 0
local endTimeM = nil
yFactor = yReFactor
local endTimeD = nil
yRound = yReRound
else
if self.periods[1] and self.periods[2] and self.periods[3] then
yReFactor = 1e6
-- any time
yReDiv = yFull / yReFactor
return true
yReRound = math.floor(yReDiv + 0.5)
end
 
if yReDiv == yReRound then
local now = os.date('!*t')
-- change precision to millions of years if we're in that range
precision = 3
startTime = self:getSingleRawQualifier(claim, aliasesP.startTime)
yFactor = yReFactor
if startTime and startTime ~= "" and startTime ~= " " then
yRound = yReRound
startTimeY, startTimeM, startTimeD = parseDate(startTime)
end
end
end
end
endTime = self:getSingleRawQualifier(claim, aliasesP.endTime)
 
if endTime and endTime ~= "" and endTime ~= " " then
if not raw then
endTimeY, endTimeM, endTimeD = parseDate(endTime)
if precision == 3 then
elseif endTime == " " then
suffix = i18n['datetime']['suffixes']['million-years']
-- end time is 'unknown', assume it is somewhere in the past;
elseif precision == 0 then
-- we can do this by taking the current date as a placeholder for the end time
suffix = i18n['datetime']['suffixes']['billion-years']
endTimeY = now['year']
else
endTimeM = now['month']
yRound = yRound * yFactor
endTimeD = now['day']
if yRound == 1 then
end
suffix = i18n['datetime']['suffixes']['year']
else
if startTimeY ~= nil and endTimeY ~= nil and datePrecedesDate(endTimeY, endTimeM, endTimeD, startTimeY, startTimeM, startTimeD) then
suffix = i18n['datetime']['suffixes']['years']
-- invalidate end time if it precedes start time
end
endTimeY = nil
end
endTimeM = nil
else
endTimeD = nil
yRound = yRound * yFactor
end
end
end
if self.periods[1] then
else
-- future
yRound = y
if startTimeY and datePrecedesDate(now['year'], now['month'], now['day'], startTimeY, startTimeM, startTimeD) then
mayAddCalendar = true
return true
end
end
end
if self.periods[2] then
-- current
if (startTimeY == nil or not datePrecedesDate(now['year'], now['month'], now['day'], startTimeY, startTimeM, startTimeD)) and
  (endTimeY == nil or datePrecedesDate(now['year'], now['month'], now['day'], endTimeY, endTimeM, endTimeD)) then
return true
end
end
if self.periods[3] then
-- former
if endTimeY and not datePrecedesDate(now['year'], now['month'], now['day'], endTimeY, endTimeM, endTimeD) then
return true
end
end
return false
end


function State:claimMatches(claim)
if mayAddCalendar then
local matches, rankPos
calendarID = parseWikidataURL(datavalue['calendarmodel'])
-- 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:out()
if calendarID and calendarID == aliasesQ.prolepticJulianCalendar then
local result  -- collection of arrays with value objects
if not raw then
local valuesArray  -- array with value objects
if link then
local sep = nil  -- value object
calendar = " ("..buildWikilink(i18n['datetime']['julian-calendar'], i18n['datetime']['julian'])..")"
local out = {}  -- array with value objects
else
calendar = " ("..i18n['datetime']['julian']..")"
local function walk(formatTable, result)
end
local valuesArray = {}  -- array with value objects
else
calendar = "/"..i18n['datetime']['julian']
for i, v in pairs(formatTable.req) do
end
if not result[i] or not result[i][1] then
end
-- 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 result
return {}
end
end
end
for i, v in ipairs(formatTable) do
if v.param then
valuesArray = mergeArrays(valuesArray, result[v.str])
elseif v.str ~= "" then
valuesArray[#valuesArray + 1] = {v.str}
end
if v.child then
valuesArray = mergeArrays(valuesArray, walk(v.child, result))
end
end
return valuesArray
end
-- iterate through the results from back to front, so that we know when to add separators
for i = #self.results, 1, -1 do
result = self.results[i]
-- if there is already some output, then add the separators
if #out > 0 then
sep = self.separator[1]  -- fixed separator
result[parameters.separator] = {self.movSeparator[1]}  -- movable separator
else
sep = nil
result[parameters.separator] = {self.puncMark[1]}  -- optional punctuation mark
end
valuesArray = walk(self.parsedFormat, result)
if #valuesArray > 0 then
if sep then
valuesArray[#valuesArray + 1] = sep
end
out = mergeArrays(valuesArray, out)
end
end
-- reset state before next iteration
self.results = {}
return out
end


-- level 1 hook
if not raw then
function State:getProperty(claim)
local ce = nil
local value = {self.conf:getValue(claim.mainsnak, self.rawValue, self.linked, self.shortName)}  -- create one value object
 
if sign < 0 then
if #value > 0 then
ce = i18n['datetime']['BCE']
return {value}  -- wrap the value object in an array and return it
elseif precision <= 5 then
else
ce = i18n['datetime']['CE']
return {}  -- return empty array if there was no value
end
end
 
end
if ce then
if link then
ce = buildWikilink(i18n['datetime']['common-era'], 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


-- level 1 hook
value = prefix .. value .. suffix .. calendar
function State:getQualifiers(claim, param)
else
local qualifiers
value = padZeros(yRound * sign, 4)
if claim.qualifiers then qualifiers = claim.qualifiers[self.conf.qualifierIDs[param]] end
if qualifiers then
-- iterate through claim's qualifier statements to collect their values;
-- return array with multiple value objects
return self.conf.states[param]:iterate(qualifiers, {[parameters.general] = hookNames[parameters.qualifier.."\\d"][2], count = 1})  -- pass qualifier State with level 2 hook
else
return {}  -- return empty array
end
end


-- level 2 hook
if m then
function State:getQualifier(snak)
value = value .. "-" .. padZeros(m, 2)
local value = {self.conf:getValue(snak, self.rawValue, self.linked, self.shortName)}  -- create one value object
 
if d then
if #value > 0 then
value = value .. "-" .. padZeros(d, 2)
return {value}  -- wrap the value object in an array and return it
end
else
end
return {}  -- return empty array if there was no value
end
end


-- level 1 hook
value = value .. calendar
function State:getAllQualifiers(claim, param, result, hooks)
local out = {}  -- array with value objects
local sep = self.conf.separators["sep"..parameters.qualifier][1]  -- value object
-- iterate through the output of the separate "qualifier(s)" commands
for i = 1, self.conf.states.qualifiersCount do
-- if a hook has not been called yet, call it now
if not result[parameters.qualifier..i] then
self:callHook(parameters.qualifier..i, hooks, claim, result)
end
-- if there is output for this particular "qualifier(s)" command, then add it
if result[parameters.qualifier..i] and result[parameters.qualifier..i][1] then
-- if there is already some output, then add the separator
if #out > 0 and sep then
out[#out + 1] = sep
end
end
out = mergeArrays(out, result[parameters.qualifier..i])
end
end
return out
end


-- level 1 hook
return value
function State:getReferences(claim)
elseif datatype == 'globecoordinate' then
if claim.references then
-- logic from https://github.com/DataValues/Geo (v4.0.1)
-- iterate through claim's reference statements to collect their values;
 
-- return array with multiple value objects
local precision, unitsPerDegree, numDigits, strFormat, value, globe
return self.conf.states[parameters.reference]:iterate(claim.references, {[parameters.general] = hookNames[parameters.reference][2], count = 1})  -- pass reference State with level 2 hook
local latitude, latConv, latValue, latLink
else
local longitude, lonConv, lonValue, lonLink
return {}  -- return empty array
local latDirection, latDirectionN, latDirectionS, latDirectionEN
end
local lonDirection, lonDirectionE, lonDirectionW, lonDirectionEN
end
local degSymbol, minSymbol, secSymbol, separator
 
local latDegrees = nil
local latMinutes = nil
local latSeconds = nil
local lonDegrees = nil
local lonMinutes = nil
local lonSeconds = nil
 
local latDegSym = ""
local latMinSym = ""
local latSecSym = ""
local lonDegSym = ""
local lonMinSym = ""
local lonSecSym = ""
 
local latDirectionEN_N = "N"
local latDirectionEN_S = "S"
local lonDirectionEN_E = "E"
local lonDirectionEN_W = "W"
 
if not raw then
latDirectionN = i18n['coord']['latitude-north']
latDirectionS = i18n['coord']['latitude-south']
lonDirectionE = i18n['coord']['longitude-east']
lonDirectionW = i18n['coord']['longitude-west']


-- level 2 hook
degSymbol = i18n['coord']['degrees']
-- logic determined based on https://www.wikidata.org/wiki/Help:Sources
minSymbol = i18n['coord']['minutes']
function State:getReference(statement)
secSymbol = i18n['coord']['seconds']
local snakValue, lang, property, url, title
separator = i18n['coord']['separator']
local value = ""
else
local ref = {}
latDirectionN = latDirectionEN_N
local snaks = {}
latDirectionS = latDirectionEN_S
local params = {}
lonDirectionE = lonDirectionEN_E
local leadParams = {}
lonDirectionW = lonDirectionEN_W
 
if statement.snaks then
degSymbol = "/"
for i, v in pairs(statement.snaks) do
minSymbol = "/"
if v[1] then
secSymbol = "/"
snaks[i] = v[1]
separator = "/"
end
end
end
 
latitude = datavalue['latitude']
-- don't include "imported from" that has been added by a bot
longitude = datavalue['longitude']
if snaks[aliasesP.importedFrom] then
 
snaks[aliasesP.importedFrom] = nil
if latitude < 0 then
end
latDirection = latDirectionS
latDirectionEN = latDirectionEN_S
-- use the general template for citing web references if both URL and title are present
latitude = math.abs(latitude)
if snaks[aliasesP.referenceURL] and snaks[aliasesP.title] and i18n['cite']['cite-web'] and i18n['cite']['cite-web'] ~= "" then
else
params[i18n['cite']['url']]  = self.conf:getValue(snaks[aliasesP.referenceURL])
latDirection = latDirectionN
params[i18n['cite']['title']] = self.conf:getValue(snaks[aliasesP.title], false, false, false, true)  -- anyLang = true
latDirectionEN = latDirectionEN_N
if snaks[aliasesP.publicationDate] then params[i18n['cite']['date']]        = self.conf:getValue(snaks[aliasesP.publicationDate])                  end
if snaks[aliasesP.retrieved]      then params[i18n['cite']['access-date']]  = self.conf:getValue(snaks[aliasesP.retrieved])                        end
if snaks[aliasesP.archiveURL]      then params[i18n['cite']['archive-url']]  = self.conf:getValue(snaks[aliasesP.archiveURL])                      end
if snaks[aliasesP.archiveDate]    then params[i18n['cite']['archive-date']] = self.conf:getValue(snaks[aliasesP.archiveDate])                     end
if snaks[aliasesP.author]          then params[i18n['cite']['author']]      = self.conf:getValue(snaks[aliasesP.author])                          end
if snaks[aliasesP.publisher]      then params[i18n['cite']['publisher']]    = self.conf:getValue(snaks[aliasesP.publisher])                        end
if snaks[aliasesP.quote]          then params[i18n['cite']['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[i18n['cite']['language']] = snakValue
end
end
end
 
if mw.isSubsting() then
if longitude < 0 then
for i, v in pairs(params) do
lonDirection = lonDirectionW
value = value .. "|" .. i .. "=" .. v
lonDirectionEN = lonDirectionEN_W
end
longitude = math.abs(longitude)
value = "{{" .. i18n['cite']['cite-web'] .. value .. "}}"
else
else
value = mw.getCurrentFrame():expandTemplate{title=i18n['cite']['cite-web'], args=params}
lonDirection = lonDirectionE
lonDirectionEN = lonDirectionEN_E
end
end
else
 
-- if no general template for citing web references was defined but URL and title are present, add these together
precision = datavalue['precision']
if snaks[aliasesP.referenceURL] and snaks[aliasesP.title] then
 
url  = self.conf:getValue(snaks[aliasesP.referenceURL])
if not precision or precision <= 0 then
title = self.conf:getValue(snaks[aliasesP.title], false, false, false, true)
precision = 1 / 3600  -- precision not set (correctly), set to arcsecond
leadParams[#leadParams + 1] = "[" .. url .. " " .. title .. "]"
-- set to nil so that they won't be added a second time
snaks[aliasesP.referenceURL] = nil
snaks[aliasesP.title] = nil
end
end
 
for i, v in pairs(snaks) do
-- remove insignificant detail
property = getLabel(i)
latitude = math.floor(latitude / precision + 0.5) * precision
longitude = math.floor(longitude / precision + 0.5) * precision
if property ~= "" then
 
snakValue, lang = self.conf:getValue(v, false, (i == aliasesP.statedIn), false, true)  -- link = true/false, anyLang = true
if precision >= 1 - (1 / 60) and precision < 1 then
precision = 1
if lang and lang ~= self.conf.langCode then
elseif precision >= (1 / 60) - (1 / 3600) and precision < (1 / 60) then
snakValue = "''" .. snakValue .. "'' (" .. mw.language.fetchLanguageName(lang, self.conf.langCode) .. ")"
precision = 1 / 60
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
end
 
value = table.concat(leadParams, "; ")
if precision >= 1 then
params = table.concat(params, "; ")
unitsPerDegree = 1
elseif precision >= (1 / 60) then
if params ~= "" then
unitsPerDegree = 60
if value ~= "" then
else
value = value .. "; "
unitsPerDegree = 3600
end
value = value .. params
end
end
 
if value ~= "" then
numDigits = math.ceil(-math.log10(unitsPerDegree * precision))
value = value .. "."
 
if numDigits <= 0 then
numDigits = tonumber("0")  -- for some reason, 'numDigits = 0' may actually store '-0', so parse from string instead
end
end
end
if value ~= "" then
ref = {value}  -- create one value object
if not self.rawValue then
-- this should become a <ref> tag, so safe the reference's hash for later
ref.refHash = statement.hash
end
ref = {ref}  -- wrap the value object in an array
end
end
return ref
end


function State:callHook(param, hooks, statement, result)
strFormat = "%." .. numDigits .. "f"
local valuesArray, refHash
 
if precision >= 1 then
-- call a parameter's hook if it has been defined and if it has not been called before
latDegrees = strFormat:format(latitude)
if not result[param] and hooks[param] then
lonDegrees = strFormat:format(longitude)
valuesArray = self[hooks[param]](self, statement, param, result, hooks) -- array with value objects
 
if not raw then
-- add to the result
latDegSym = replaceDecimalMark(latDegrees) .. degSymbol
if #valuesArray > 0 then
lonDegSym = replaceDecimalMark(lonDegrees) .. degSymbol
result[param] = valuesArray
else
result.count = result.count + 1
latDegSym = latDegrees .. degSymbol
else
lonDegSym = lonDegrees .. degSymbol
result[param] = {}  -- an empty array to indicate that we've tried this hook already
end
return true  -- miss == true
else
end
latConv = math.floor(latitude * unitsPerDegree * 10^numDigits + 0.5) / 10^numDigits
end
lonConv = math.floor(longitude * unitsPerDegree * 10^numDigits + 0.5) / 10^numDigits
 
return false
if precision >= (1 / 60) then
end
latMinutes = latConv
lonMinutes = lonConv
else
latSeconds = latConv
lonSeconds = lonConv
 
latMinutes = math.floor(latSeconds / 60)
lonMinutes = math.floor(lonSeconds / 60)
 
latSeconds = strFormat:format(latSeconds - (latMinutes * 60))
lonSeconds = strFormat:format(lonSeconds - (lonMinutes * 60))


-- iterate through claims, claim's qualifiers or claim's references to collect values
if not raw then
function State:iterate(statements, hooks, matchHook)
latSecSym = replaceDecimalMark(latSeconds) .. secSymbol
matchHook = matchHook or alwaysTrue
lonSecSym = replaceDecimalMark(lonSeconds) .. secSymbol
else
local matches = false
latSecSym = latSeconds .. secSymbol
local rankPos = nil
lonSecSym = lonSeconds .. secSymbol
local result, gotRequired
for i, v in ipairs(statements) do
-- rankPos will be nil for non-claim statements (e.g. qualifiers, references, etc.)
matches, rankPos = matchHook(self, v)
if matches then
result = {count = 0}  -- collection of arrays with value objects
local function walk(formatTable)
local miss
for i2, v2 in pairs(formatTable.req) do
-- call a hook, adding its return value to the result
miss = self:callHook(i2, hooks, v, result)
if miss then
-- we miss a required value for this level, so return false
return false
end
end
end
if result.count == hooks.count then
 
-- we're done if all hooks have been called;
latDegrees = math.floor(latMinutes / 60)
-- returning at this point breaks the loop
lonDegrees = math.floor(lonMinutes / 60)
return true
 
latDegSym = latDegrees .. degSymbol
lonDegSym = lonDegrees .. degSymbol
 
latMinutes = latMinutes - (latDegrees * 60)
lonMinutes = lonMinutes - (lonDegrees * 60)
 
if precision >= (1 / 60) then
latMinutes = strFormat:format(latMinutes)
lonMinutes = strFormat:format(lonMinutes)
 
if not raw then
latMinSym = replaceDecimalMark(latMinutes) .. minSymbol
lonMinSym = replaceDecimalMark(lonMinutes) .. minSymbol
else
latMinSym = latMinutes .. minSymbol
lonMinSym = lonMinutes .. minSymbol
end
end
else
latMinSym = latMinutes .. minSymbol
lonMinSym = lonMinutes .. minSymbol
end
end
end
for i2, v2 in ipairs(formatTable) do
 
if result.count == hooks.count then
latValue = latDegSym .. latMinSym .. latSecSym .. latDirection
-- we're done if all hooks have been called;
lonValue = lonDegSym .. lonMinSym .. lonSecSym .. lonDirection
-- returning at this point prevents further childs from being processed
 
return true
value = latValue .. separator .. lonValue
end
 
if link then
if v2.child then
globe = parseWikidataURL(datavalue['globe'])
walk(v2.child)
 
end
if globe then
globe = mw.wikibase.getLabelByLang(globe, "en"):lower()
else
globe = "earth"
end
end
 
return true
latLink = table.concat({latDegrees, latMinutes, latSeconds}, "_")
lonLink = table.concat({lonDegrees, lonMinutes, lonSeconds}, "_")
 
value = "[https://tools.wmflabs.org/geohack/geohack.php?language="..self.langCode.."&params="..latLink.."_"..latDirectionEN.."_"..lonLink.."_"..lonDirectionEN.."_globe:"..globe.." "..value.."]"
end
end
gotRequired = walk(self.parsedFormat)
 
return value
-- only append the result if we got values for all required parameters on the root level
elseif datatype == 'wikibase-entityid' then
if gotRequired then
local label
-- if we have a rankPos (only with matchHook() for complete claims), then update the foundRank
local itemID = datavalue['numeric-id']
if rankPos and self.conf.foundRank > rankPos then
 
self.conf.foundRank = rankPos
if subtype == 'wikibase-item' then
end
itemID = "Q" .. itemID
elseif subtype == 'wikibase-property' then
-- append the result
itemID = "P" .. itemID
self.results[#self.results + 1] = result
else
return '<strong class="error">' .. errorText('unknown-data-type', subtype) .. '</strong>'
-- break if we only need a single value
if self.singleValue then
break
end
end
end
end
end
return self:out()
end


function p.property(frame)
label = self:getLabel(itemID, raw, link, short)
loadSubmodules(frame)
return p._property(copyTable(frame.args))
end


function p._property(args)
if label == "" then
loadSubmodules()
label = nil
return execCommand(args, "property")
end
end


function p.properties(frame)
return label
loadSubmodules(frame)
else
return p._properties(copyTable(frame.args))
return '<strong class="error">' .. errorText('unknown-data-type', datatype) .. '</strong>'
end
end
 
elseif snak.snaktype == 'somevalue' and not noSpecial then
function p._properties(args)
if raw then
loadSubmodules()
return " "  -- single space represents 'somevalue'
return execCommand(args, "properties")
else
end
return i18n['values']['unknown']
 
end
function p.qualifier(frame)
elseif snak.snaktype == 'novalue' and not noSpecial then
loadSubmodules(frame)
if raw then
return p._qualifier(copyTable(frame.args))
return "" -- empty string represents 'novalue'
else
return i18n['values']['none']
end
else
return nil
end
end
end


function p._qualifier(args)
function Config:getSingleRawQualifier(claim, qualifierID)
loadSubmodules()
local qualifiers
return execCommand(args, "qualifier")
end


function p.qualifiers(frame)
if claim.qualifiers then qualifiers = claim.qualifiers[qualifierID] end
loadSubmodules(frame)
return p._qualifiers(copyTable(frame.args))
end


function p._qualifiers(args)
if qualifiers and qualifiers[1] then
loadSubmodules()
return self:getValue(qualifiers[1], true) -- raw = true
return execCommand(args, "qualifiers")
else
return nil
end
end
end


function p.reference(frame)
function Config:snakEqualsValue(snak, value)
loadSubmodules(frame)
local snakValue = self:getValue(snak, true) -- raw = true
return p._reference(copyTable(frame.args))
end


function p._reference(args)
if snakValue and snak.snaktype == 'value' and snak.datavalue.type == 'wikibase-entityid' then value = value:upper() end
loadSubmodules()
return execCommand(args, "reference")
end


function p.references(frame)
return snakValue == value
loadSubmodules(frame)
return p._references(copyTable(frame.args))
end
end


function p._references(args)
function Config:setRank(rank)
loadSubmodules()
local rankPos
return execCommand(args, "references")
end


function execCommand(args, funcName)
if rank == p.flags.best then
_ = Config.new()
self.bestRank = true
_:processFlagOrCommand(funcName)  -- process first command (== function name)
self.flagBest = true  -- mark that 'best' flag was given
return
local parsedFormat, formatParams, claims, sep
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
end
 
if nextArg then
if rank:sub(1,9) == p.flags.preferred then
nextArg = mw.text.trim(nextArg)
rankPos = 1
elseif rank:sub(1,6) == p.flags.normal then
rankPos = 2
elseif rank:sub(1,10) == p.flags.deprecated then
rankPos = 3
else
else
nextArg = ""
return
end
end
 
-- check for optional item ID
-- one of the rank flags was given, check if another one was given before
if nextArg:sub(1,1):upper() == "Q" then
if not self.flagRank then
_.entity = mw.wikibase.getEntity(nextArg) -- item ID given
self.ranks = {false, false, false} -- no other rank flag given before, so unset ranks
_.propertyID = mw.text.trim(args[nextIndex] or "")  -- property ID
self.bestRank = self.flagBest      -- unsets bestRank only if 'best' flag was not given before
nextIndex = nextIndex + 1
self.flagRank = true                -- mark that a rank flag was given
else
_.entity = mw.wikibase.getEntity()  -- no item ID given, use item connected to current page
_.propertyID = nextArg  -- property ID
end
end
 
-- check if given property ID is an alias
if rank:sub(-1) == "+" then
if aliasesP[_.propertyID] then
for i = rankPos, 1, -1 do
_.propertyID = aliasesP[_.propertyID]
self.ranks[i] = true
end
_.propertyID = _.propertyID:upper()
if _.states.qualifiersCount > 0 then
-- do further processing if "qualifier(s)" command was given
if #args - nextIndex + 1 > _.states.qualifiersCount then
-- claim ID or literal value has been given
nextArg = args[nextIndex]  -- don't trim because might be single space representing 'somevalue'
nextIndex = nextIndex + 1
_.propertyValue = nextArg
end
end
elseif rank:sub(-1) == "-" then
for i = 1, _.states.qualifiersCount do
for i = rankPos, #self.ranks do
nextArg = mw.text.trim(args[nextIndex] or "")  -- is a qualifierID
self.ranks[i] = true
nextIndex = nextIndex + 1
-- check if given qualifier ID is an alias
if aliasesP[nextArg] then
nextArg = aliasesP[nextArg]
end
_.qualifierIDs[parameters.qualifier..i] = nextArg:upper()
end
end
elseif _.states[parameters.reference] then
else
-- do further processing if "reference(s)" command was given
self.ranks[rankPos] = true
nextArg = args[nextIndex]
nextIndex = nextIndex + 1
_.propertyValue = nextArg  -- claim ID or literal value (possibly nil)
end
end
end
-- check for special property value 'somevalue' or 'novalue'
 
if _.propertyValue then
function Config:setPeriod(period)
if _.propertyValue ~= "" and mw.text.trim(_.propertyValue) == "" then
local periodPos
_.propertyValue = " "  -- single space represents 'somevalue', whereas empty string represents 'novalue'
 
else
if period == p.flags.future then
_.propertyValue = mw.text.trim(_.propertyValue)
periodPos = 1
end
elseif period == p.flags.current then
periodPos = 2
elseif period == p.flags.former then
periodPos = 3
else
return
end
end
 
-- parse the desired format, or choose an appropriate format
-- one of the period flags was given, check if another one was given before
if args["format"] then
if not self.flagPeriod then
parsedFormat, formatParams = parseFormat(replaceHTMLSpaces(mw.text.trim(args["format"])))
self.periods = {false, false, false}  -- no other period flag given before, so unset periods
elseif _.states.qualifiersCount > 0 then -- "qualifier(s)" command given
self.flagPeriod = true                -- mark that a period flag was given
if _.states[parameters.property] then  -- "propert(y|ies)" command given
end
parsedFormat, formatParams = parseFormat(formats.propertyWithQualifier)
 
else
self.periods[periodPos] = true
parsedFormat, formatParams = parseFormat(formats.qualifier)
end
 
function Config:qualifierMatches(claim, id, value)
local qualifiers
 
if claim.qualifiers then qualifiers = claim.qualifiers[id] end
if qualifiers then
for _, v in pairs(qualifiers) do
if self:snakEqualsValue(v, value) then
return true
end
end
end
elseif _.states[parameters.property] then  -- "propert(y|ies)" command given
elseif value == "" then
parsedFormat, formatParams = parseFormat(formats.property)
-- if the qualifier is not present then treat it the same as the special value 'novalue'
else  -- "reference(s)" command given
return true
parsedFormat, formatParams = parseFormat(formats.reference)
end
end
 
-- if a "qualifier(s)" command and no "propert(y|ies)" command has been given, make the movable separator a semicolon
return false
if _.states.qualifiersCount > 0 and not _.states[parameters.property] then
end
_.separators["sep"..parameters.separator][1] = {";"}
 
function Config:rankMatches(rankPos)
if self.bestRank then
return (self.ranks[rankPos] and self.foundRank >= rankPos)
else
return self.ranks[rankPos]
end
end
end
-- if only "reference(s)" has been given, set the default separator to none (except when raw)
 
if _.states[parameters.reference] and not _.states[parameters.property] and _.states.qualifiersCount == 0
function Config:timeMatches(claim)
  and not _.states[parameters.reference].rawValue then
local startTime = nil
_.separators["sep"][1] = nil
local startTimeY = nil
local startTimeM = nil
local startTimeD = nil
local endTime = nil
local endTimeY = nil
local endTimeM = nil
local endTimeD = nil
 
if self.periods[1] and self.periods[2] and self.periods[3] then
-- any time
return true
end
end
 
-- if exactly one "qualifier(s)" command has been given, make "sep%q" point to "sep%q1" to make them equivalent;
startTime = self:getSingleRawQualifier(claim, aliasesP.startTime)
-- must come BEFORE overriding the separator values
if startTime and startTime ~= "" and startTime ~= " " then
if _.states.qualifiersCount == 1 then
startTimeY, startTimeM, startTimeD = parseDate(startTime)
_.separators["sep"..parameters.qualifier] = _.separators["sep"..parameters.qualifier.."1"]
end
-- process overridden separator values;
-- must come AFTER parsing the formats
for i, v in pairs(_.separators) do
if args[i] then
sep = replaceHTMLSpaces(mw.text.trim(args[i]))
if sep ~= "" then
_.separators[i][1] = {sep}
else
_.separators[i][1] = nil
end
end
end
end
 
-- make sure that at least one required parameter has been defined
endTime = self:getSingleRawQualifier(claim, aliasesP.endTime)
if not next(parsedFormat.req) then
if endTime and endTime ~= "" and endTime ~= " " then
error(missingRequiredParameterError())
endTimeY, endTimeM, endTimeD = parseDate(endTime)
end
end
 
-- make sure that the separator parameter "%s" is not amongst the required parameters
if startTimeY ~= nil and endTimeY ~= nil and datePrecedesDate(endTimeY, endTimeM, endTimeD, startTimeY, startTimeM, startTimeD) then
if parsedFormat.req[parameters.separator] then
-- invalidate end time if it precedes start time
error(extraRequiredParameterError(parameters.separator))
endTimeY = nil
endTimeM = nil
endTimeD = nil
end
end
 
-- define the hooks that should be called (getProperty, getQualifiers, getReferences);
if self.periods[1] then
-- only define a hook if both its command ("propert(y|ies)", "reference(s)", "qualifier(s)") and its parameter ("%p", "%r", "%q1", "%q2", "%q3") have been given
-- future
for i, v in pairs(_.states) do
if startTimeY and datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], startTimeY, startTimeM, startTimeD) then
-- e.g. 'formatParams["%q1"] or formatParams["%q"]' to define hook even if "%q1" was not defined to be able to build a complete value for "%q"
return true
if formatParams[i] or formatParams[string.sub(i, 1, 2)] then
hooks[i] = getHookName(i, 1)
hooks.count = hooks.count + 1
end
end
end
end
 
-- the "%q" parameter is not attached to a state, but is a collection of the results of multiple states (attached to "%q1", "%q2", "%q3", ...);
if self.periods[2] then
-- so if this parameter is given then this hook must be defined separately, but only if at least one "qualifier(s)" command has been given
-- current
if formatParams[parameters.qualifier] and _.states.qualifiersCount > 0 then
if (startTimeY == nil or not datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], startTimeY, startTimeM, startTimeD)) and
hooks[parameters.qualifier] = getHookName(parameters.qualifier, 1)
  (endTimeY == nil or datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], endTimeY, endTimeM, endTimeD)) then
hooks.count = hooks.count + 1
return true
end
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;
if self.periods[3] then
-- must come AFTER defining the hooks
-- former
if not _.states[parameters.property] then
if endTimeY and not datePrecedesDate(self.atDate[1], self.atDate[2], self.atDate[3], endTimeY, endTimeM, endTimeD) then
_.states[parameters.property] = State.new(_)
return true
end
end
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
-- first sort the claims on rank to pre-define the order of output (preferred first, then normal, then deprecated)
claims = sortOnRank(claims)
-- then iterate through the claims to collect values
return concatValues(_.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 false
loadSubmodules(frame)
return p._label(copyTable(frame.args))
end
end


function p._label(args, _)
function Config:processFlag(flag)
_ = _ or Config.new()
if not flag then
_.curState = State.new(_)
return false
loadSubmodules()
local ID = nil
local label = ""
local title = nil
local nextArg = args[1]
local nextIndex = 2
while _:processFlag(nextArg) do
nextArg = args[nextIndex]
nextIndex = nextIndex + 1
end
end
 
if nextArg then
if flag == p.flags.linked then
ID = mw.text.trim(nextArg)
self.curState.linked = true
return true
if ID == "" then
elseif flag == p.flags.raw then
ID = nil
self.curState.rawValue = true
end
 
end
if self.curState == self.states[parameters.reference] then
-- raw reference values end with periods and require a separator (other than none)
if ID then
self.separators["sep%r"][1] = {" "}
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 and not _.pageTitle then
if mw.wikibase.getEntity(ID) or mw.wikibase.resolvePropertyId(ID) then
if _.curState.linked then
if ID:sub(1,1) == "P" then
label = "[[d:Property:" .. ID .. "|" .. ID .. "]]"
else
label = "[[d:" .. ID .. "|" .. ID .. "]]"
end
else
label = ID
end
end
return label
end
end
return true
elseif flag == p.flags.short then
self.curState.shortName = true
return true
elseif flag == p.flags.multilanguage then
self.curState.anyLanguage = true
return true
elseif flag == p.flags.unit then
self.curState.unitOnly = true
return true
elseif flag == p.flags.mdy then
self.mdyDate = true
return true
elseif flag == p.flags.single then
self.singleClaim = true
return true
elseif flag == p.flags.sourced then
self.sourcedOnly = true
return true
elseif flag == p.flags.edit then
self.editable = true
return true
elseif flag == p.flags.editAtEnd then
self.editable = true
self.editAtEnd = true
return true
elseif flag == p.flags.best or flag:match('^'..p.flags.preferred..'[+-]?$') or flag:match('^'..p.flags.normal..'[+-]?$') or flag:match('^'..p.flags.deprecated..'[+-]?$') then
self:setRank(flag)
return true
elseif flag == p.flags.future or flag == p.flags.current or flag == p.flags.former then
self:setPeriod(flag)
return true
elseif flag == "" then
-- ignore empty flags and carry on
return true
else
else
if _.curState.rawValue and not _.pageTitle then
return false
label = mw.wikibase.getEntityIdForCurrentPage() or ""
if _.curState.linked and label ~= "" then
label = "[[d:" .. label .. "|" .. label .. "]]"
end
return label
end
end
end
end
if ID and ID:sub(1,1) == "P" then
 
if not _.pageTitle then
function Config:processFlagOrCommand(flag)
label = mw.wikibase.label(ID) or ""
local param = ""
 
if _.curState.linked and label ~= "" then
if not flag then
label = "[[d:Property:" .. ID .. "|" .. label .. "]]"
return false
end
end
end
 
else
if flag == p.claimCommands.property or flag == p.claimCommands.properties then
if not _.pageTitle then
param = parameters.property
if _.curState.shortName then
elseif flag == p.claimCommands.qualifier or flag == p.claimCommands.qualifiers then
label = getShortName(ID)
self.states.qualifiersCount = self.states.qualifiersCount + 1
end
param = parameters.qualifier .. self.states.qualifiersCount
self.separators["sep"..param] = {copyTable(defaultSeparators["sep%q\\d"])}
-- at this point, 'label' will be a string and not nil
elseif flag == p.claimCommands.reference or flag == p.claimCommands.references then
param = parameters.reference
if label == "" then
else
label = mw.wikibase.label(ID)
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, param)
 
-- use "%x" as the general parameter name
self.states[param].parsedFormat = parseFormat(parameters.general)  -- 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 flag == p.claimCommands.property or flag == p.claimCommands.qualifier or flag == p.claimCommands.reference then
self.states[param].singleValue = true
end
 
self.curState = self.states[param]
 
return true
end
 
function Config:processSeparators(args)
local sep
 
for i, v in pairs(self.separators) do
if args[i] then
sep = replaceSpecialChars(args[i])
 
if sep ~= "" then
self.separators[i][1] = {sep}
else
self.separators[i][1] = nil
end
end
end
end
end
function Config:setFormatAndSeparators(state, parsedFormat)
state.parsedFormat = parsedFormat
state.separator = self.separators["sep"]
state.movSeparator = self.separators["sep"..parameters.separator]
state.puncMark = self.separators["punc"]
end
-- determines if a claim has references by prefetching them from the claim using getReferences,
-- which applies some filtering that determines if a reference is actually returned,
-- and caches the references for later use
function State:isSourced(claim)
self.conf.prefetchedRefs = self:getReferences(claim)
return (#self.conf.prefetchedRefs > 0)
end
function State:resetCaches()
-- any prefetched references of the previous claim must not be used
self.conf.prefetchedRefs = nil
end
function State:claimMatches(claim)
local matches, rankPos
-- first of all, reset any cached values used for the previous claim
self:resetCaches()
-- 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
-- if any qualifier values were given, check if each matches one of the claim's qualifier values
for i, v in pairs(self.conf.qualifierIDsAndValues) do
matches = (matches and self.conf:qualifierMatches(claim, i, v))
end
-- check if the claim's rank and time period match
rankPos = rankTable[claim.rank] or 4
matches = (matches and self.conf:rankMatches(rankPos) and self.conf:timeMatches(claim))
-- if only claims with references must be returned, check if this one has any
if self.conf.sourcedOnly then
matches = (matches and self:isSourced(claim))  -- prefetches and caches references
end
return matches, rankPos
end
function State:out()
local result  -- collection of arrays with value objects
local valuesArray  -- array with value objects
local sep = nil  -- value object
local out = {}  -- array with value objects
local function walk(formatTable, result)
local valuesArray = {}  -- array with value objects
for i, v in pairs(formatTable.req) do
if not result[i] or not result[i][1] 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 result
return {}
end
end
for _, v in ipairs(formatTable) do
if v.param then
valuesArray = mergeArrays(valuesArray, result[v.str])
elseif v.str ~= "" then
valuesArray[#valuesArray + 1] = {v.str}
end
if v.child then
valuesArray = mergeArrays(valuesArray, walk(v.child, result))
end
end
return valuesArray
end
-- iterate through the results from back to front, so that we know when to add separators
for i = #self.results, 1, -1 do
result = self.results[i]
-- if there is already some output, then add the separators
if #out > 0 then
sep = self.separator[1]  -- fixed separator
result[parameters.separator] = {self.movSeparator[1]}  -- movable separator
else
else
-- set 'label' to nil so 'title' will always prevail
sep = nil
label = nil
result[parameters.separator] = {self.puncMark[1]}  -- optional punctuation mark
end
end
 
-- at this point, 'label' will be nil or a non-empty string
valuesArray = walk(self.parsedFormat, result)
 
if _.curState.linked or label == nil then
if #valuesArray > 0 then
if ID then
if sep then
title = mw.wikibase.sitelink(ID)
valuesArray[#valuesArray + 1] = sep
else
end
title = mw.title.getCurrentTitle().prefixedText
 
end
out = mergeArrays(valuesArray, out)
end
end
end
if _.curState.linked and title then
 
label = "[[" .. title .. "|" .. (label or title) .. "]]"
-- reset state before next iteration
else
self.results = {}
label = label or title or ""
 
end
return out
end
end
 
return label
-- level 1 hook
end
function State:getProperty(claim)
 
local value = {self:getValue(claim.mainsnak)}  -- create one value object
function p.title(frame)
 
loadSubmodules(frame)
if #value > 0 then
return p._title(copyTable(frame.args))
return {value}  -- wrap the value object in an array and return it
end
else
 
return {}  -- return empty array if there was no value
function p._title(args, _)
end
_ = _ or Config.new()
end
_.pageTitle = true
 
-- loadSubmodules() will already be called by _label()
-- level 1 hook
return p._label(args, _)
function State:getQualifiers(claim, param)
end
local qualifiers
 
if claim.qualifiers then qualifiers = claim.qualifiers[self.conf.qualifierIDs[param]] end
if qualifiers then
-- iterate through claim's qualifier statements to collect their values;
-- return array with multiple value objects
return self.conf.states[param]:iterate(qualifiers, {[parameters.general] = hookNames[parameters.qualifier.."\\d"][2], count = 1})  -- pass qualifier state with level 2 hook
else
return {}  -- return empty array
end
end
 
-- level 2 hook
function State:getQualifier(snak)
local value = {self:getValue(snak)}  -- create one value object
 
if #value > 0 then
return {value}  -- wrap the value object in an array and return it
else
return {}  -- return empty array if there was no value
end
end
 
-- level 1 hook
function State:getAllQualifiers(claim, param, result, hooks)
local out = {}  -- array with value objects
local sep = self.conf.separators["sep"..parameters.qualifier][1]  -- value object
 
-- iterate through the output of the separate "qualifier(s)" commands
for i = 1, self.conf.states.qualifiersCount do
 
-- if a hook has not been called yet, call it now
if not result[parameters.qualifier..i] then
self:callHook(parameters.qualifier..i, hooks, claim, result)
end
 
-- if there is output for this particular "qualifier(s)" command, then add it
if result[parameters.qualifier..i] and result[parameters.qualifier..i][1] then
 
-- if there is already some output, then add the separator
if #out > 0 and sep then
out[#out + 1] = sep
end
 
out = mergeArrays(out, result[parameters.qualifier..i])
end
end
 
return out
end
 
-- level 1 hook
function State:getReferences(claim)
if self.conf.prefetchedRefs then
-- return references that have been prefetched by isSourced
return self.conf.prefetchedRefs
end
 
if claim.references then
-- iterate through claim's reference statements to collect their values;
-- return array with multiple value objects
return self.conf.states[parameters.reference]:iterate(claim.references, {[parameters.general] = hookNames[parameters.reference][2], count = 1})  -- pass reference state with level 2 hook
else
return {}  -- return empty array
end
end
 
-- level 2 hook
function State:getReference(statement)
local key, citeWeb, citeQ, label
local params = {}
local citeParams = {['web'] = {}, ['q'] = {}}
local citeMismatch = {}
local useCite = nil
local useParams = nil
local value = ""
local ref = {}
 
local version = 1  -- increment this each time the below logic is changed to avoid conflict errors
 
if statement.snaks then
-- don't include "imported from", which is added by a bot
if statement.snaks[aliasesP.importedFrom] then
statement.snaks[aliasesP.importedFrom] = nil
end
 
-- don't include "inferred from", which is added by a bot
if statement.snaks[aliasesP.inferredFrom] then
statement.snaks[aliasesP.inferredFrom] = nil
end
 
-- don't include "type of reference"
if statement.snaks[aliasesP.typeOfReference] then
statement.snaks[aliasesP.typeOfReference] = nil
end
 
-- don't include "image" to prevent littering
if statement.snaks[aliasesP.image] then
statement.snaks[aliasesP.image] = nil
end
 
-- don't include "language" if it is equal to the local one
if self:getReferenceDetail(statement.snaks, aliasesP.language) == self.conf.langName then
statement.snaks[aliasesP.language] = nil
end
 
-- retrieve all the parameters
for i in pairs(statement.snaks) do
label = ""
 
-- multiple authors may be given
if i == aliasesP.author then
params[i] = self:getReferenceDetails(statement.snaks, i, false, self.linked, true)  -- link = true/false, anyLang = true
else
params[i] = {self:getReferenceDetail(statement.snaks, i, false, (self.linked or (i == aliasesP.statedIn)) and (statement.snaks[i][1].datatype ~= 'url'), true)}  -- link = true/false, anyLang = true
end
 
if #params[i] == 0 then
params[i] = nil
else
if statement.snaks[i][1].datatype == 'external-id' then
key = "external-id"
label = self.conf:getLabel(i)
 
if label ~= "" then
label = label .. " "
end
else
key = i
end
 
-- add the parameter to each matching type of citation
for j in pairs(citeParams) do
-- do so if there was no mismatch with a previous parameter
if not citeMismatch[j] then
-- check if this parameter is not mismatching itself
if i18n['cite'][j][key] then
-- continue if an option is available in the corresponding cite template
if i18n['cite'][j][key] ~= "" then
citeParams[j][i18n['cite'][j][key]] = label .. params[i][1]
 
-- if there are multiple parameter values (authors), add those too
for k=2, #params[i] do
citeParams[j][i18n['cite'][j][key]..k] = label .. params[i][k]
end
end
else
citeMismatch[j] = true
end
end
end
end
end
 
-- get title of general template for citing web references
citeWeb = split(mw.wikibase.getSitelink(aliasesQ.citeWeb) or "", ":")[2]  -- split off namespace from front
 
-- get title of template that expands stated-in references into citations
citeQ = split(mw.wikibase.getSitelink(aliasesQ.citeQ) or "", ":")[2]  -- split off namespace from front
 
-- (1) use the general template for citing web references if there is a match and if at least both "reference URL" and "title" are present
if citeWeb and not citeMismatch['web'] and citeParams['web'][i18n['cite']['web'][aliasesP.referenceURL]] and citeParams['web'][i18n['cite']['web'][aliasesP.title]] then
useCite = citeWeb
useParams = citeParams['web']
 
-- (2) use the template that expands stated-in references into citations if there is a match and if at least "stated in" is present
elseif citeQ and not citeMismatch['q'] and citeParams['q'][i18n['cite']['q'][aliasesP.statedIn]] then
-- we need the raw "stated in" Q-identifier for the this template
citeParams['q'][i18n['cite']['q'][aliasesP.statedIn]] = self:getReferenceDetail(statement.snaks, aliasesP.statedIn, true)  -- raw = true
 
useCite = citeQ
useParams = citeParams['q']
end
 
if useCite and useParams then
-- if this module is being substituted then build a regular template call, otherwise expand the template
if mw.isSubsting() then
for i, v in pairs(useParams) do
value = value .. "|" .. i .. "=" .. v
end
 
value = "{{" .. useCite .. value .. "}}"
else
value = mw.getCurrentFrame():expandTemplate{title=useCite, args=useParams}
end
 
-- (3) else, do some default rendering of name-value pairs, but only if at least "stated in", "reference URL" or "title" is present
elseif params[aliasesP.statedIn] or params[aliasesP.referenceURL] or params[aliasesP.title] then
citeParams['default'] = {}
 
-- start by adding authors up front
if params[aliasesP.author] and #params[aliasesP.author] > 0 then
citeParams['default'][#citeParams['default'] + 1] = table.concat(params[aliasesP.author], " & ")
end
 
-- combine "reference URL" and "title" into one link if both are present
if params[aliasesP.referenceURL] and params[aliasesP.title] then
citeParams['default'][#citeParams['default'] + 1] = '[' .. params[aliasesP.referenceURL][1] .. ' "' .. params[aliasesP.title][1] .. '"]'
elseif params[aliasesP.referenceURL] then
citeParams['default'][#citeParams['default'] + 1] = params[aliasesP.referenceURL][1]
elseif params[aliasesP.title] then
citeParams['default'][#citeParams['default'] + 1] = '"' .. params[aliasesP.title][1] .. '"'
end
 
-- then add "stated in"
if params[aliasesP.statedIn] then
citeParams['default'][#citeParams['default'] + 1] = "''" .. params[aliasesP.statedIn][1] .. "''"
end
 
-- remove previously added parameters so that they won't be added a second time
params[aliasesP.author] = nil
params[aliasesP.referenceURL] = nil
params[aliasesP.title] = nil
params[aliasesP.statedIn] = nil
 
-- add the rest of the parameters
for i, v in pairs(params) do
i = self.conf:getLabel(i)
 
if i ~= "" then
citeParams['default'][#citeParams['default'] + 1] = i .. ": " .. v[1]
end
end
 
value = table.concat(citeParams['default'], "; ")
 
if value ~= "" then
value = value .. "."
end
end
 
if value ~= "" then
value = {value}  -- create one value object
 
if not self.rawValue then
-- this should become a <ref> tag, so save the reference's hash for later
value.refHash = "wikidata-" .. statement.hash .. "-v" .. (tonumber(i18n['cite']['version']) + version)
end
 
ref = {value}  -- wrap the value object in an array
end
end
 
return ref
end
 
-- gets a detail of one particular type for a reference
function State:getReferenceDetail(snaks, dType, raw, link, anyLang)
local switchLang = anyLang
local value = nil
 
if not snaks[dType] then
return nil
end
 
-- if anyLang, first try the local language and otherwise any language
repeat
for _, v in ipairs(snaks[dType]) do
value = self.conf:getValue(v, raw, link, false, anyLang and not switchLang, false, true)  -- noSpecial = true
 
if value then
break
end
end
 
if value or not anyLang then
break
end
 
switchLang = not switchLang
until anyLang and switchLang
 
return value
end
 
-- gets the details of one particular type for a reference
function State:getReferenceDetails(snaks, dType, raw, link, anyLang)
local values = {}
 
if not snaks[dType] then
return {}
end
 
for _, v in ipairs(snaks[dType]) do
-- if nil is returned then it will not be added to the table
values[#values + 1] = self.conf:getValue(v, raw, link, false, anyLang, false, true)  -- noSpecial = true
end
 
return values
end
 
-- level 1 hook
function State:getAlias(object)
local value = object.value
local title = nil
 
if value and self.linked then
if self.conf.entityID:sub(1,1) == "Q" then
title = mw.wikibase.getSitelink(self.conf.entityID)
elseif self.conf.entityID:sub(1,1) == "P" then
title = "d:Property:" .. self.conf.entityID
end
 
if title then
value = buildWikilink(title, value)
end
end
 
value = {value}  -- create one value object
 
if #value > 0 then
return {value}  -- wrap the value object in an array and return it
else
return {}  -- return empty array if there was no value
end
end
 
-- level 1 hook
function State:getBadge(value)
value = self.conf:getLabel(value, self.rawValue, self.linked, self.shortName)
 
if value == "" then
value = nil
end
 
value = {value}  -- create one value object
 
if #value > 0 then
return {value}  -- wrap the value object in an array and return it
else
return {}  -- return empty array if there was no value
end
end
 
function State:callHook(param, hooks, statement, result)
local valuesArray, refHash
 
-- call a parameter's hook if it has been defined and if it has not been called before
if not result[param] and hooks[param] then
valuesArray = self[hooks[param]](self, statement, param, result, hooks)  -- array with value objects
 
-- add to the result
if #valuesArray > 0 then
result[param] = valuesArray
result.count = result.count + 1
else
result[param] = {}  -- an empty array to indicate that we've tried this hook already
return true  -- miss == true
end
end
 
return false
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 matches = false
local rankPos = nil
local result, gotRequired
 
for _, v in ipairs(statements) do
-- rankPos will be nil for non-claim statements (e.g. qualifiers, references, etc.)
matches, rankPos = matchHook(self, v)
 
if matches then
result = {count = 0}  -- collection of arrays with value objects
 
local function walk(formatTable)
local miss
 
for i2, v2 in pairs(formatTable.req) do
-- call a hook, adding its return value to the result
miss = self:callHook(i2, hooks, v, result)
 
if miss then
-- we miss a required value for this level, so return false
return false
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 _, 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
-- if we have a rankPos (only with matchHook() for complete claims), then update the foundRank
if rankPos and self.conf.foundRank > rankPos then
self.conf.foundRank = rankPos
end
 
-- append the result
self.results[#self.results + 1] = result
 
-- break if we only need a single value
if self.singleValue then
break
end
end
end
end
 
return self:out()
end
 
local function getEntityId(arg, eid, page, allowOmitPropPrefix)
local id = nil
local prop = nil
 
if arg then
if arg:sub(1,1) == ":" then
page = arg
eid = nil
elseif arg:sub(1,1):upper() == "Q" or arg:sub(1,9):lower() == "property:" or allowOmitPropPrefix then
eid = arg
page = nil
else
prop = arg
end
end
 
if eid then
if eid:sub(1,9):lower() == "property:" then
id = replaceAlias(mw.text.trim(eid:sub(10)))
 
if id:sub(1,1):upper() ~= "P" then
id = ""
end
else
id = replaceAlias(eid)
end
elseif page then
if page:sub(1,1) == ":" then
page = mw.text.trim(page:sub(2))
end
 
id = mw.wikibase.getEntityIdForTitle(page) or ""
end
 
if not id then
id = mw.wikibase.getEntityIdForCurrentPage() or ""
end
 
id = id:upper()
 
if not mw.wikibase.isValidEntityId(id) then
id = ""
end
 
return id, prop
end
 
local function nextArg(args)
local arg = args[args.pointer]
 
if arg then
args.pointer = args.pointer + 1
return mw.text.trim(arg)
else
return nil
end
end
 
local function claimCommand(args, funcName)
local cfg = Config:new()
cfg:processFlagOrCommand(funcName)  -- process first command (== function name)
 
local lastArg, parsedFormat, formatParams, claims, value
local hooks = {count = 0}
 
-- set the date if given;
-- must come BEFORE processing the flags
if args[p.args.date] then
cfg.atDate = {parseDate(args[p.args.date])}
cfg.periods = {false, true, false}  -- change default time constraint to 'current'
end
 
-- process flags and commands
repeat
lastArg = nextArg(args)
until not cfg:processFlagOrCommand(lastArg)
 
-- get the entity ID from either the positional argument, the eid argument or the page argument
cfg.entityID, cfg.propertyID = getEntityId(lastArg, args[p.args.eid], args[p.args.page])
 
if cfg.entityID == "" then
return ""  -- we cannot continue without a valid entity ID
end
 
cfg.entity = mw.wikibase.getEntity(cfg.entityID)
 
if not cfg.propertyID then
cfg.propertyID = nextArg(args)
end
 
cfg.propertyID = replaceAlias(cfg.propertyID)
 
if not cfg.entity or not cfg.propertyID then
return ""  -- we cannot continue without an entity or a property ID
end
 
cfg.propertyID = cfg.propertyID:upper()
 
if not cfg.entity.claims or not cfg.entity.claims[cfg.propertyID] then
return ""  -- there is no use to continue without any claims
end
 
claims = cfg.entity.claims[cfg.propertyID]
 
if cfg.states.qualifiersCount > 0 then
-- do further processing if "qualifier(s)" command was given
 
if #args - args.pointer + 1 > cfg.states.qualifiersCount then
-- claim ID or literal value has been given
 
cfg.propertyValue = nextArg(args)
end
 
for i = 1, cfg.states.qualifiersCount do
-- check if given qualifier ID is an alias and add it
cfg.qualifierIDs[parameters.qualifier..i] = replaceAlias(nextArg(args) or ""):upper()
end
elseif cfg.states[parameters.reference] then
-- do further processing if "reference(s)" command was given
 
cfg.propertyValue = nextArg(args)
end
 
-- check for special property value 'somevalue' or 'novalue'
if cfg.propertyValue then
cfg.propertyValue = replaceSpecialChars(cfg.propertyValue)
 
if cfg.propertyValue ~= "" and mw.text.trim(cfg.propertyValue) == "" then
cfg.propertyValue = " "  -- single space represents 'somevalue', whereas empty string represents 'novalue'
else
cfg.propertyValue = mw.text.trim(cfg.propertyValue)
end
end
 
-- parse the desired format, or choose an appropriate format
if args["format"] then
parsedFormat, formatParams = parseFormat(args["format"])
elseif cfg.states.qualifiersCount > 0 then  -- "qualifier(s)" command given
if cfg.states[parameters.property] then  -- "propert(y|ies)" command given
parsedFormat, formatParams = parseFormat(formats.propertyWithQualifier)
else
parsedFormat, formatParams = parseFormat(formats.qualifier)
end
elseif cfg.states[parameters.property] then  -- "propert(y|ies)" command given
parsedFormat, formatParams = parseFormat(formats.property)
else  -- "reference(s)" command given
parsedFormat, formatParams = parseFormat(formats.reference)
end
 
-- if a "qualifier(s)" command and no "propert(y|ies)" command has been given, make the movable separator a semicolon
if cfg.states.qualifiersCount > 0 and not cfg.states[parameters.property] then
cfg.separators["sep"..parameters.separator][1] = {";"}
end
 
-- if only "reference(s)" has been given, set the default separator to none (except when raw)
if cfg.states[parameters.reference] and not cfg.states[parameters.property] and cfg.states.qualifiersCount == 0
  and not cfg.states[parameters.reference].rawValue then
cfg.separators["sep"][1] = nil
end
 
-- if exactly one "qualifier(s)" command has been given, make "sep%q" point to "sep%q1" to make them equivalent
if cfg.states.qualifiersCount == 1 then
cfg.separators["sep"..parameters.qualifier] = cfg.separators["sep"..parameters.qualifier.."1"]
end
 
-- process overridden separator values;
-- must come AFTER tweaking the default separators
cfg:processSeparators(args)
 
-- define the hooks that should be called (getProperty, getQualifiers, getReferences);
-- only define a hook if both its command ("propert(y|ies)", "reference(s)", "qualifier(s)") and its parameter ("%p", "%r", "%q1", "%q2", "%q3") have been given
for i, v in pairs(cfg.states) do
-- e.g. 'formatParams["%q1"] or formatParams["%q"]' to define hook even if "%q1" was not defined to be able to build a complete value for "%q"
if formatParams[i] or formatParams[i:sub(1, 2)] then
hooks[i] = getHookName(i, 1)
hooks.count = hooks.count + 1
end
end
 
-- the "%q" parameter is not attached to a state, but is a collection of the results of multiple states (attached to "%q1", "%q2", "%q3", ...);
-- so if this parameter is given then this hook must be defined separately, but only if at least one "qualifier(s)" command has been given
if formatParams[parameters.qualifier] and cfg.states.qualifiersCount > 0 then
hooks[parameters.qualifier] = getHookName(parameters.qualifier, 1)
hooks.count = hooks.count + 1
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 cfg.states[parameters.property] then
cfg.states[parameters.property] = State:new(cfg, parameters.property)
 
-- if the "single" flag has been given then this state should be equivalent to "property" (singular)
if cfg.singleClaim then
cfg.states[parameters.property].singleValue = true
end
end
 
-- if the "sourced" flag has been given then create a state for "reference" if it doesn't exist yet, using default values,
-- which must exist in order to be able to determine if a claim has any references;
-- must come AFTER defining the hooks
if cfg.sourcedOnly and not cfg.states[parameters.reference] then
cfg:processFlagOrCommand(p.claimCommands.reference)  -- use singular "reference" to minimize overhead
end
 
-- set the parsed format and the separators (and optional punctuation mark);
-- must come AFTER creating the additonal states
cfg:setFormatAndSeparators(cfg.states[parameters.property], parsedFormat)
 
-- process qualifier matching values, analogous to cfg.propertyValue
for i, v in pairs(args) do
i = tostring(i)
 
if i:match('^[Pp]%d+$') or aliasesP[i] then
v = replaceSpecialChars(v)
 
-- check for special qualifier value 'somevalue'
if v ~= "" and mw.text.trim(v) == "" then
v = " " -- single space represents 'somevalue'
end
 
cfg.qualifierIDsAndValues[replaceAlias(i):upper()] = v
end
end
 
-- first sort the claims on rank to pre-define the order of output (preferred first, then normal, then deprecated)
claims = sortOnRank(claims)
 
-- then iterate through the claims to collect values
value = cfg:concatValues(cfg.states[parameters.property]:iterate(claims, hooks, State.claimMatches))  -- pass property state with level 1 hooks and matchHook
 
-- if desired, add a clickable icon that may be used to edit the returned values on Wikidata
if cfg.editable and value ~= "" then
value = value .. cfg:getEditIcon()
end
 
return value
end
 
local function generalCommand(args, funcName)
local cfg = Config:new()
cfg.curState = State:new(cfg)
 
local lastArg
local value = nil
 
repeat
lastArg = nextArg(args)
until not cfg:processFlag(lastArg)
 
-- get the entity ID from either the positional argument, the eid argument or the page argument
cfg.entityID = getEntityId(lastArg, args[p.args.eid], args[p.args.page], true)
 
if cfg.entityID == "" or not mw.wikibase.entityExists(cfg.entityID) then
return ""  -- we cannot continue without an entity
end
 
-- serve according to the given command
if funcName == p.generalCommands.label then
value = cfg:getLabel(cfg.entityID, cfg.curState.rawValue, cfg.curState.linked, cfg.curState.shortName)
elseif funcName == p.generalCommands.title then
cfg.inSitelinks = true
 
if cfg.entityID:sub(1,1) == "Q" then
value = mw.wikibase.getSitelink(cfg.entityID)
end
 
if cfg.curState.linked and value then
value = buildWikilink(value)
end
elseif funcName == p.generalCommands.description then
value = mw.wikibase.getDescription(cfg.entityID)
else
local parsedFormat, formatParams
local hooks = {count = 0}
 
cfg.entity = mw.wikibase.getEntity(cfg.entityID)
 
if funcName == p.generalCommands.alias or funcName == p.generalCommands.badge then
cfg.curState.singleValue = true
end
 
if funcName == p.generalCommands.alias or funcName == p.generalCommands.aliases then
if not cfg.entity.aliases or not cfg.entity.aliases[cfg.langCode] then
return ""  -- there is no use to continue without any aliasses
end
 
local aliases = cfg.entity.aliases[cfg.langCode]
 
-- parse the desired format, or parse the default aliases format
if args["format"] then
parsedFormat, formatParams = parseFormat(args["format"])
else
parsedFormat, formatParams = parseFormat(formats.alias)
end
 
-- process overridden separator values;
-- must come AFTER tweaking the default separators
cfg:processSeparators(args)
 
-- define the hook that should be called (getAlias);
-- only define the hook if the parameter ("%a") has been given
if formatParams[parameters.alias] then
hooks[parameters.alias] = getHookName(parameters.alias, 1)
hooks.count = hooks.count + 1
end
 
-- set the parsed format and the separators (and optional punctuation mark)
cfg:setFormatAndSeparators(cfg.curState, parsedFormat)
 
-- iterate to collect values
value = cfg:concatValues(cfg.curState:iterate(aliases, hooks))
elseif funcName == p.generalCommands.badge or funcName == p.generalCommands.badges then
if not cfg.entity.sitelinks or not cfg.entity.sitelinks[cfg.siteID] or not cfg.entity.sitelinks[cfg.siteID].badges then
return ""  -- there is no use to continue without any badges
end
 
local badges = cfg.entity.sitelinks[cfg.siteID].badges
 
cfg.inSitelinks = true
 
-- parse the desired format, or parse the default aliases format
if args["format"] then
parsedFormat, formatParams = parseFormat(args["format"])
else
parsedFormat, formatParams = parseFormat(formats.badge)
end
 
-- process overridden separator values;
-- must come AFTER tweaking the default separators
cfg:processSeparators(args)
 
-- define the hook that should be called (getBadge);
-- only define the hook if the parameter ("%b") has been given
if formatParams[parameters.badge] then
hooks[parameters.badge] = getHookName(parameters.badge, 1)
hooks.count = hooks.count + 1
end
 
-- set the parsed format and the separators (and optional punctuation mark)
cfg:setFormatAndSeparators(cfg.curState, parsedFormat)
 
-- iterate to collect values
value = cfg:concatValues(cfg.curState:iterate(badges, hooks))
end
end
 
value = value or ""
 
if cfg.editable and value ~= "" then
-- if desired, add a clickable icon that may be used to edit the returned value on Wikidata
value = value .. cfg:getEditIcon()
end
 
return value
end
 
-- modules that include this module should call the functions with an underscore prepended, e.g.: p._property(args)
local function establishCommands(commandList, commandFunc)
for _, commandName in pairs(commandList) do
local function wikitextWrapper(frame)
local args = copyTable(frame.args)
args.pointer = 1
loadI18n(aliasesP, frame)
return commandFunc(args, commandName)
end
p[commandName] = wikitextWrapper
 
local function luaWrapper(args)
args = copyTable(args)
args.pointer = 1
loadI18n(aliasesP)
return commandFunc(args, commandName)
end
p["_" .. commandName] = luaWrapper
end
end
 
establishCommands(p.claimCommands, claimCommand)
establishCommands(p.generalCommands, generalCommand)
 
-- main function that is supposed to be used by wrapper templates
function p.main(frame)
if not mw.wikibase then return nil end
 
local f, args
 
loadI18n(aliasesP, frame)
 
-- get the parent frame to take the arguments that were passed to the wrapper template
frame = frame:getParent() or frame
 
if not frame.args[1] then
throwError("no-function-specified")
end
 
f = mw.text.trim(frame.args[1])
 
if f == "main" then
throwError("main-called-twice")
end
 
assert(p["_"..f], errorText('no-such-function', f))
 
-- copy arguments from immutable to mutable table
args = copyTable(frame.args)
 
-- remove the function name from the list
table.remove(args, 1)


-- main function that is supposed to be used by wrapper templates
function p.main(frame)
local f, args, i, v
loadSubmodules(frame)
-- get the parent frame to take the arguments that were passed to the wrapper template
frame = frame:getParent() or frame
if not frame.args[1] then
error(i18n["errors"]["no-function-specified"])
end
f = mw.text.trim(frame.args[1])
if f == "main" then
error(i18n["errors"]["main-called-twice"])
end
assert(p["_"..f], applyStringParams(i18n['errors']['no-such-function'], f))
-- copy arguments from immutable to mutable table
args = copyTable(frame.args)
-- remove the function name from the list
table.remove(args, 1)
return p["_"..f](args)
return p["_"..f](args)
end
end


return p
return p
「https://wiki.sakishima.net/特別:携帯機器差分/6738...6768」から取得