Module:Wd
Wellicht wilt u gebruikmaken van de gebruiksvriendelijke wrapper-sjabloon {{Wikidata}} in plaats van deze module direct aan te roepen.
Deze module is bedoeld om data van Wikidata op te halen met of zonder link naar het gekoppelde Wikipedia-artikel en met vele andere opties.
Gebruik
Let op: om resultaat te krijgen moet ook tenminste het "Label" in het Nederlands in Wikidata ingevuld zijn. (Het komt voor dat er in Wikidata alleen gegevens van een of meer andere talen zijn ingevuld.)
De algemene structuur van een aanroep van deze module is als volgt. Merk op dat de basisstructuur bestaat uit positionele commando's, opties en argumenten, welke allemaal een vaste positie hebben.
{{#invoke:wd|commando1|optie1a|optie1b|optie1c|commando2|optie2a|optie2b|optie2c|optie0a|optie0b|optie0c|arg1|arg2|arg3}}
Gebruik verschillende commando's om verschillende soorten waardes op te halen van Wikidata. Minstens één commando moet worden opgegeven en meerdere commando's kunnen worden gecombineerd in één aanroep zoals hierboven is getoond (in willekeurige volgorde, meer dan twee is ook mogelijk), maar dit geldt alleen voor commando's uit de bewering-klasse; aanroepen die een commando bevatten uit de algemeen-klasse kunnen geen ander commando bevatten. Elk commando kan worden gevolgd door een willekeurig aantal commando-opties, welke optioneel zijn en kunnen worden gebruikt om de uitvoer die gegenereerd wordt door dat commando aan te passen.
De commando's en hun opties kunnen worden gevolgd door een willekeurig aantal configuratie-opties, welke ook optioneel zijn en de selectie van data en het algemene gedrag van deze module beïnvloeden. De aanroep wordt afgesloten met de positionele argumenten, welke al dan niet verplicht zijn afhankelijk van het opgegeven commando of de opgegeven commando's. Er bestaan tevens een aantal benoemde argumenten, evenals een verzameling benoemde opties voor geavanceerd gebruik die gebruikt kunnen worden om de manier aan te passen waarop opgehaalde waardes in de uitvoer worden samengevoegd.
Deze module is ontworpen om de basisbehoeften van het ophalen van data van Wikidata te verschaffen, maar veel kan worden bereikt middels verschillende combinaties van aanroepen. Voor het gemak zouden zulke combinaties kunnen worden samengebonden in nieuwe sjablonen die aan een specifieke behoefte voldoen. Zie ook de sectie over veelvoorkomende toepassingen hieronder voor een aantal voorbeelden van nuttige "bouwstenen". Op een soortgelijke manier kan de functionaliteit van deze module worden uitgebreid door het maken van wrapper-sjablonen die gebruikmaken van het commando main dat wordt geboden door deze module.
Veelvoorkomende toepassingen
Hieronder volgt een lijst van veelvoorkomende toepassingen. In de toekomst zouden er voor meer gemak plaatsvervangende commando's kunnen worden geïmplementeerd die equivalent zijn aan deze aanroepen.
| Aanroep | Toepassing |
|---|---|
{{#invoke:wd|label|raw}}
|
Retourneert het Q-nummer van het Wikidata-item dat gekoppeld is aan de huidige pagina (bijvoorbeeld "Q55"). |
{{#if:{{#invoke:wd|label|raw}}|...}}
|
Voert een controle uit om te bepalen of de huidige pagina een Wikidata-item heeft.
Merk op dat deze bewering vertrouwt op een geretourneerde waarde die leeg dan wel niet leeg is en dat het belangrijk is om de optie |
Commando's
De commando's (commando1, commando2, ...) bepalen welke soorten waardes worden geretourneerd. Eén aanroep kan alleen commando's van een enkele klasse bevatten.
Bewering-klasse
De bewering-klasse-commando's kunnen worden gecombineerd, wat betekent dat meerdere commando's van verschillende types uit deze klasse tegelijkertijd kunnen worden opgegeven (zie hierboven voor gebruik).
Combineer meerdere commando's in één aanroep van deze module, in plaats van meerdere aanroepen van deze module te doen met elk één commando, om er zeker van te zijn dat alle geretourneerde stukken informatie bij elkaar horen (zie ook de onderstaande voorbeelden).
| Type | Commando | Retourneert | Basisgebruik | Beschrijving |
|---|---|---|---|---|
| I | property
|
eerste overeenkomst* | {{#invoke:wd|property|P1}}
|
Retourneert de opgevraagde eigenschap (property) – of lijst van eigenschappen (properties) – van de huidige item-entiteit of van een opgegeven entiteit.
Dit commando kan slechts één keer worden opgegeven in een aanroep. |
properties
|
alle overeenkomsten | {{#invoke:wd|properties|P1}}
| ||
| II | qualifier
|
eerste overeenkomst** | {{#invoke:wd|qualifier|P1|P2}}
|
Retourneert de opgevraagde kwalificatie (qualifier) – of lijst van kwalificaties (qualifiers) – van de opgegeven eigenschap (property) van de huidige item-entiteit of van een opgegeven entiteit.
In tegenstelling tot de andere bewering-klasse-commando's kan dit commando meerdere keren in één aanroep opgegeven worden om verschillende kwalificaties op te halen. |
qualifiers
|
alle overeenkomsten | {{#invoke:wd|qualifiers|P1|P2}}
| ||
| III | reference
|
eerste overeenkomst** | {{#invoke:wd|reference|P1}}
|
Retourneert een bron (reference) – of lijst van bronnen (references) – van de opgegeven eigenschap (property) van de huidige item-entiteit of van een opgegeven entiteit.***
Dit commando kan slechts één keer worden opgegeven in een aanroep. |
references
|
alle overeenkomsten | {{#invoke:wd|references|P1}}
| ||
| * Retourneert slechts een enkele waarde in plaats van meerdere (als meerdere beweringen overeenkomen). De geretourneerde waarde is de eerste overeenkomst die gevonden is uit de beweringen met de beste rang. | ||||
** Retourneert slechts een enkele waarde in plaats van meerdere voor elke overeenkomende bewering. Om in totaal hoogstens één waarde te krijgen in het geval het commando property niet ook gebruikt wordt, gebruik daarnaast de configuratie-optie single.
| ||||
| *** Alleen bronnen die geldig zijn volgens de Wikidata-richtlijnen voor bronnen worden geretourneerd (d.w.z. bronnen die ten minste de eigenschap Luafout op regel 1951: attempt to index field 'errors' (a nil value) (P248) of Luafout op regel 1951: attempt to index field 'errors' (a nil value) (P854) hebben). | ||||
Algemeen-klasse
De algemeen-klasse-commando's kunnen niet worden gecombineerd.
| Type | Commando | Retourneert | Basisgebruik | Beschrijving |
|---|---|---|---|---|
| I | label
|
{{#invoke:wd|label}}
|
Retourneert de label (label) van de huidige item-entiteit of van de opgegeven entiteit indien aanwezig. | |
| II | title
|
{{#invoke:wd|title}}
|
Retourneert de titel (title) van de pagina die gekoppeld is aan de huidige item-entiteit of aan de opgegeven entiteit indien zo'n pagina bestaat. | |
| III | description
|
{{#invoke:wd|description}}
|
Retourneert de beschrijving (description) van de huidige item-entiteit of van de opgegeven entiteit indien aanwezig. | |
| IV | alias
|
eerste overeenkomst* | {{#invoke:wd|alias}}
|
Retourneert een alias (alias) – of lijst van aliassen (aliases) – van de huidige item-entiteit of van de opgegeven entiteit indien aanwezig. |
aliases
|
alle overeenkomsten | {{#invoke:wd|aliases}}
| ||
| V | badge
|
eerste overeenkomst* | {{#invoke:wd|badge}}
|
Retourneert een badge (badge) – of lijst van badges (badges) – voor de pagina die gekoppeld is aan de huidige item-entiteit of aan de opgegeven entiteit indien zo'n pagina bestaat. |
badges
|
alle overeenkomsten | {{#invoke:wd|badges}}
| ||
| * Retourneert slechts een enkele waarde in plaats van meerdere (als meerdere waardes aanwezig zijn). | ||||
Hoofd-klasse
Het commando main wordt altijd in eenzaamheid gebruikt en neem geen opties of argumenten aan. Het maakt het mogelijk voor bovenliggende sjablonen om hun parameters aan deze module door te geven in de vorm van commando's.
| Commando | Basisgebruik | Beschrijving |
|---|---|---|
main |
{{#invoke:wd|main}} |
Bedoeld voor gebruik door wrapper-sjablonen (om deze module heen) om één of meerdere van bovenstaande commando's aan te roepen en hun bijbehorende uitvoer te retourneren.
De parameters die aan de wrapper-sjabloon worden gegeven zijn die, die zullen worden gebruikt door de module, bijvoorbeeld Derhalve zullen parameters die gezet zijn door de wrapper-sjabloon zelf worden verworpen, bijvoorbeeld |
Opties
De volgende opties zijn beschikbaar, die kunnen worden gebruikt om het gedrag van deze module aan te passen. De opties dienen opgegeven te worden na het (eerste) commando en voor de positionele argumenten. Voor het gemak zijn lege opties (d.w.z. ||) toegestaan, welke simpelweg zullen worden genegeerd.
Commando-opties
Deze opties (optie1*, optie2*, ...) zijn van toepassing op het commando dat ze direct voorgaat.
| Optie | Beschrijving |
|---|---|
raw
|
Retourneert de ruwe waarde indien toepasselijk.
Als deze optie wordt gebruikt met item- of property-datatypes, dan zal dit het Q-nummer of P-nummer retourneren in plaats van de gewone label. Voor hoeveelheid-datatypes zal deze optie alle meeteenheden afstrippen, tenzij ook de optie Als deze optie wordt gebruikt met tijd-datatypes, dan zal de geretourneerde datum in het formaat Als het wordt gebruikt met geografische coördinaten-datatypes, dan vervangt het de verschillende symbolen met schuine strepen naar voren in de geretourneerde waarde (bijvoorbeeld |
linked
|
Voegt een link toe naar het Wikipedia-artikel dat gekoppeld is aan de eigenschap (property) of kwalificatie (qualifier) als het bestaat. Ook meeteenheden die al dan niet worden toegevoegd aan waardes krijgen hiermee een link.
Als deze parameter wordt weggelaten, dan wordt de kale eigenschaps- of kwalificatiewaarde geretourneerd. |
short
|
[DUUR] Retourneert de Luafout op regel 1951: attempt to index field 'errors' (a nil value) (P1813) van elke geretourneerde entiteit als die beschikbaar is. Als dat niet het geval is, dan volgt het standaardgedrag waarbij de label van de entiteit wordt geretourneerd.
|
multilanguage
|
Retourneert waardes van het type enkeltalige tekst in welke beschikbare taal dan ook, niet alleen in de taal van de huidige wiki. |
unit
|
Retourneert alleen de meeteenheid van hoeveelheid-datatypes. |
Configuratie-opties
Deze opties (optie0*) zijn algemene configuratie-opties en kunnen overal na het eerste commando worden opgegeven (maar vóór de positionele argumenten).
| Optie | Beschrijving | Commando-klasse | |
|---|---|---|---|
| Combinatie van: | preferred
|
Stelt beperkingen aan de rang van de geselecteerde beweringen. De rangen zijn voorkeursrang (preferred), normale rang (normal) en afgekeurde rang (deprecated).
De eerste drie opties bepalen de rangen van de beweringen die zullen worden geselecteerd. Ze kunnen eventueel worden gevolgd door een Als de optie De standaard is Uitvoer is altijd gesorteerd van hoogste naar laagste rang (ongeacht of een van deze opties is opgegeven). |
bewering |
normal
| |||
deprecated
| |||
best
| |||
| Combinatie van: | future
|
Stelt beperkingen aan de geldigheid op basis van tijd van de geselecteerde beweringen: toekomstig (future), actueel (current) en voormalig (former). Gebruikt de bewerings kwalificaties (qualifiers) Luafout op regel 1951: attempt to index field 'errors' (a nil value) (P580) en Luafout op regel 1951: attempt to index field 'errors' (a nil value) (P582) om te bepalen of de bewering geldig is voor de geselecteerde tijdsperiode(s).
De standaard is |
bewering |
current
| |||
former
| |||
mdy
|
Retourneert datumwaardes in de volgorde maand-dag-jaar in plaats van dag-maand-jaar. | bewering | |
single
|
Retourneert slechts een enkele bewering in plaats van meerdere (als meerdere beweringen overeenkomen). Heeft geen effect als het commando property/properties is opgegeven, in welk geval deze optie overtollig zou zijn.
|
bewering | |
sourced
|
Retourneert alleen beweringen die minstens één geldige bron (reference) hebben. | bewering | |
| Een van: | edit
|
Voegt een klikbaar icoon toe na de uitvoer dat door lezers kan worden gebruikt om de geretourneerde bewering op Wikidata te bewerken.
Als |
bewering, algemeen |
edit@end
|
Argumenten
De argumenten bepalen waar alle geretourneerde waardes vandaan worden gehaald.
Positionele argumenten
De volgende tabel geeft een overzicht van de beschikbare positionele argumenten (arg*) in hun vaste volgorde. Voor elk commando is de toepasselijke set van argumenten gemarkeerd. Als meerdere commando's opgegeven zijn, dan is de toepasselijke set de vereniging van de individuele sets. Bijvoorbeeld, als de commando's properties en qualifiers opgegeven zijn, dan moeten ook minstens allebei de argumenten property_id en qualifier_id opgegeven worden.
Meer dan één qualifier/qualifiers-commando kan worden opgegeven. De volgorde waarin deze commando's met hun opties zijn opgegeven komt overeen met de volgorde waarin de bijbehorende qualifier_id-argumenten zijn opgegeven.
| (verplicht) | (optioneel) | (optioneel) | (verplicht) | (optioneel) | (verplicht) | (verplicht) | |||
{{#invoke:wd
|
commando's
|
opties
|
entiteit_id
|
property_id
|
ruwe_waarde
|
qualifier_id
|
qualifier_id
|
}}
| |
|---|---|---|---|---|---|---|---|---|---|
label, title,description,alias/aliases,badge/badges
|
|||||||||
property/properties
|
|||||||||
reference/references
|
|||||||||
qualifier/qualifiers
|
|||||||||
qualifier/qualifiers (optionele 2de, 3de, etc.)
| |||||||||
Hieronder volgt een beschrijving van alle positionele argumenten.
| Argument | Beschrijving |
|---|---|
entiteit_id
(optioneel) |
[DUUR] Q-nummer van de uit te lezen item-entiteit (bijvoorbeeld Q55), P-nummer (of een beschikbare alias) van de uit te lezen property-entiteit voorafgegaan door het voorvoegsel Property: (bijvoorbeeld Property:P38), of paginatitel van het Wikipedia-artikel waarvan de gekoppelde item-entiteit moet worden uitgelezen voorafgegaan door :, een voorgevoegde dubbele punt (bijvoorbeeld :Nederland).
In het geval van de algemeen-klasse-commando's mag het voorvoegsel Als deze parameter wordt weggelaten, dan zal de item-entiteit die is gekoppeld aan de huidige pagina worden gebruikt (behalve wanneer |
property_id
|
P-nummer (of een beschikbare alias) van de eigenschap (property) binnen de uit te lezen entiteit, zonder het voorvoegsel Property: (bijvoorbeeld P35).
|
ruwe_waarde
(optioneel) |
Ofwel het Q-nummer gelijk aan de waarde van de eigenschap (bijvoorbeeld Q29574) of een letterlijke waarde (d.w.z. tekenreeks of hoeveelheid etc., geen entiteitslabel) gelijk aan de ruwe waarde van de eigenschap van de uit te lezen bewering.
Datums als letterlijke waardes moeten worden gegeven in het formaat Geografische coördinaten als letterlijke waardes moeten worden gegeven met schuine strepen naar voren (d.w.z. Het speciale type 'geen waarde' kan worden opgegeven met de lege tekst (d.w.z. Om een letterlijk verticaal streepje Als deze parameter wordt weggelaten, dan zullen alle beweringen (die voldoen aan enige andere beperkingen) die vallen onder de opgegeven eigenschap worden uitgelezen. |
qualifier_id
|
P-nummer (of een beschikbare alias) van de kwalificatie (qualifier) binnen de uit te lezen entiteit, zonder het voorvoegsel Property: (bijvoorbeeld P580).
|
Benoemde argumenten
Hieronder volgt een beschrijving van alle benoemde argumenten, welke naam/waarde-paren zijn (d.w.z. |naam=waarde). Deze zijn allemaal optioneel en kunnen overal na het eerste commando worden opgegeven.
| Argument | Beschrijving | Commando-klasse |
|---|---|---|
eid=
|
[DUUR] Dit argument kan worden gebruikt om het Q-nummer (bijvoorbeeld |eid=Q55) of P-nummer (of een beschikbare alias) van de uit te lezen entiteit op te geven. Het biedt dezelfde functionaliteit als het positionele argument entiteit_id, met één verschil: als het argument is opgegeven maar met een lege waarde (d.w.z. |eid=), dan zal geen enkele entiteit worden uitgelezen in plaats van de item-entiteit die is gekoppeld aan de huidige pagina. Dit is nuttig in sommige gevallen waarin een variabele entiteit-ID wordt verwacht, maar waarbij de item-entiteit die is gekoppeld aan de huidige pagina niet standaard moet worden uitgelezen.
Tevens mag het voorvoegsel Dit argument heeft alleen effect als het positionele argument |
bewering, algemeen |
page=
|
[DUUR] Dit argument kan worden gebruikt om de paginatitel (bijvoorbeeld |page=Nederland) van het Wikipedia-artikel waarvan de gekoppelde item-entiteit moet worden uitgelezen op te geven. Het gedraagt zich net zoals het benoemde argument eid= en kan worden gebruikt in plaats van het positionele argument entiteit_id (merk op dat geen voorgevoegde dubbele punt, :, benodigd is). Als het argument is opgegeven maar met een lege waarde (d.w.z. |page=), dan zal geen enkele entiteit worden uitgelezen in plaats van de item-entiteit die is gekoppeld aan de huidige pagina.
Dit argument heeft alleen effect als het positionele argument |
bewering, algemeen |
date=
|
Dit argument kan worden gebruikt om een bepaalde datum in te stellen (bijvoorbeeld |date=1731-02-11) ten opzichte waarvan beweringen worden gezocht die overeenkomen met de gebruikte opties future, current en former, in plaats van ten opzichte van vandaag. Het stelt de standaard van deze opties in op current zodat standaard alleen beweringen die geldig waren op de opgegeven datum worden geretourneerd (op basis van de bewerings kwalificaties (qualifiers) Luafout op regel 1951: attempt to index field 'errors' (a nil value) (P580) en Luafout op regel 1951: attempt to index field 'errors' (a nil value) (P582)).
De datum moet worden opgegeven in het formaat |
bewering |
<kwalificatie>=
|
De <kwalificatie> is een placeholder voor een set van argumenten die bepalen welke beweringen uitgelezen moeten worden op basis van kwalificatiewaarde (qualifier-waarde), overeenkomstig met het paar positionele argumenten property_id en ruwe_waarde (die toegang bepalen op basis van eigenschapswaarde (property-waarde)).
Zodoende is Voorbeeld: Meerdere argumenten van dit type kunnen worden opgegeven om meerdere kwalificatiewaardes gelijktijdig overeen te laten komen voor elke bewering. |
bewering |
Eigenschapsaliassen
Eigenschapsaliassen (property-aliassen) zijn andere namen voor P-nummers die in plaats daarvan kunnen worden gebruikt. De volgende eigenschapsaliassen (die hoofdlettergevoelig zijn) zijn momenteel beschikbaar:
| Alias | vertaalt naar |
P-nummer |
|---|---|---|
| coord | → | P625 |
| image | → | P18 |
| author | → | P50 |
| publisher | → | P123 |
| importedFrom | → | P143 |
| logo | → | P154 |
| statedIn | → | P248 |
| pages | → | P304 |
| language | → | P407 |
| hasPart | → | P527 |
| publicationDate | → | P577 |
| startTime | → | P580 |
| endTime | → | P582 |
| chapter | → | P792 |
| retrieved | → | P813 |
| referenceURL | → | P854 |
| website | → | P856 |
| sectionVerseOrParagraph | → | P958 |
| archiveURL | → | P1065 |
| title | → | P1476 |
| formatterURL | → | P1630 |
| quote | → | P1683 |
| shortName | → | P1813 |
| definingFormula | → | P2534 |
| archiveDate | → | P2960 |
| inferredFrom | → | P3452 |
| typeOfReference | → | P3865 |
| column | → | P3903 |
Geavanceerd gebruik
De opmaak van de uitvoer van (een combinatie van) commando's die zowel een enkelvoudige als een meervoudige vorm hebben (bijvoorbeeld property/properties) kan worden aangepast door middel van een aantal benoemde opties, welke naam/waarde-paren zijn (d.w.z. |optie=waarde), die overal na het eerste commando opgegeven kunnen worden. De onderstaande tabel geeft een overzicht van de beschikbare benoemde opties.
Om een spatie aan het begin of eind van een waarde de plaatsen, gebruik een underscore _. Om een letterlijke underscore te krijgen, maskeer het door er een schuine streep naar achteren \ direct voor te plaatsen (d.w.z. \_); hetzelfde geldt voor een letterlijke schuine streep naar achteren (d.w.z. \\). Om een letterlijk verticaal streepje | te krijgen, gebruik {{!}} of |.
| Benoemde optie | Standaardwaarde | Standaardcriterium | Beschrijving | ||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
format=
|
%p[%s][%r]
|
als het commando property/properties was opgegeven en het commando qualifier/qualifiers niet was opgegeven
|
Het formaat van een enkele bewerking. De beschikbare parameters zijn als volgt.
Optionele parameters kunnen worden opgegeven door deze in te sluiten tussen vierkante haakjes: Om gebruik te maken van twee openende vierkante haakjes die elkaar direct volgen (d.w.z. Minstens één niet-optionele parameter moet worden opgegeven, terwijl de parameter Om een letterlijke | ||||||||||||||||
%q[%s][%r]
|
als het commando property/properties niet was opgegeven en het commando qualifier/qualifiers was opgegeven
| ||||||||||||||||||
%r
|
als alleen het commando reference/references was opgegeven
| ||||||||||||||||||
%p[ <span style="font-size:85\%">(%q)</span>][%s][%r]
|
als het commando property/properties was opgegeven en het commando qualifier/qualifiers was opgegeven
| ||||||||||||||||||
%a[%s]
|
als het commando alias/aliases was opgegeven
| ||||||||||||||||||
%b[%s]
|
als het commando badge/badges was opgegeven
| ||||||||||||||||||
sep=
|
_
|
standaard | Het vaste scheidingsteken tussen elk paar beweringen, aliassen of badges. | ||||||||||||||||
|
als alleen het commando reference/references was opgegeven zonder de optie raw
| ||||||||||||||||||
sep%s=
|
,
|
standaard | Het verplaatsbare scheidingsteken tussen elk paar beweringen, aliassen of badges. Dit zal de waarde zijn van de parameter %s die wordt ingevuld voor alle beweringen, aliassen of badges, behalve de laatste in de lijst (welke kan worden ingesteld met de optie punc).
| ||||||||||||||||
;
|
als het commando property/properties niet was opgegeven en het commando qualifier/qualifiers was opgegeven
| ||||||||||||||||||
sep%q1=, sep%q2=, sep%q3=, ...
|
,_
|
standaard | Het scheidingsteken tussen elk paar kwalificaties van een enkele bewering. Dit zijn de scheidingstekens tussen de waardes voor de parameters %q1, %q2, %q3, ...
Als slechts één | ||||||||||||||||
sep%q=
|
,_
|
als precies één qualifier/qualifiers-commando was opgegeven
|
Het scheidingsteken tussen elke set van kwalificaties van een enkele bewering. Dit is het scheidingsteken tussen de waardes voor de parameter %q.
Als slechts één | ||||||||||||||||
;_
|
als meer dan één qualifier/qualifiers-commando was opgegeven
| ||||||||||||||||||
sep%r=
|
|
standaard | Het scheidingsteken tussen elk paar bronnen van een enkele bewering. Dit is het scheidingsteken tussen de waardes voor de parameter %r.
| ||||||||||||||||
_
|
als de optie raw was opgegeven voor het commando reference/references
| ||||||||||||||||||
punc=
|
|
standaard | Een leesteken dat aan het einde van de uitvoer geplaatst wordt. Dit wordt geplaatst door er de parameter %s van de laatste bewering (of alias of badge) in de lijst mee in te vullen.
Dit maakt het mogelijk om bronnen van de laatste bewering achter het leesteken te plaatsen wanneer de uitvoer wordt gebruikt als onderdeel van een zin. | ||||||||||||||||
Voorbeelden
| Parameters en uitvoertypes | Voorbeeld | Beschrijving |
|---|---|---|
Q55 = "Nederland", P395 = "kentekenplaatcode"
[tekenreeks] |
{{#invoke:wd|property|Q55|P395}}
|
Haalt een tekenreekswaarde op. |
P395 = "kentekenplaatcode"
[tekenreeks] |
{{#invoke:wd|property|P395}}
|
Als de module is opgenomen in de pagina Nederland (die gekoppeld is aan Q55), dan kan de Q55 worden weggelaten.
|
Q55 = "Nederland", P395 = "kentekenplaatcode"
[tekenreeks] |
{{#invoke:wd|property|eid=Q55|P395}}
|
Een entiteit-ID kan ook worden opgegeven door middel van het argument eid=.
|
P395 = "kentekenplaatcode"
[tekenreeks] |
{{#invoke:wd|property|page=Nederland|P395}}
|
Een paginatitel kan worden opgegeven in plaats van een entiteit-ID door middel van het argument page=.
|
Q55 = "Nederland", P395 = "kentekenplaatcode"
[tekenreeks] |
{{#invoke:wd|property|edit|Q55|P395}}
|
Voegt een klikbaar icoon toe dat kan worden gebruikt om de geretourneerde waarde op Wikidata te bewerken. |
Q55 = "Nederland", P395 = "kentekenplaatcode"
[tekenreeks] |
{{#invoke:wd|property|edit@end|Q55|P395}}
|
Plaatst het bewerkingsicoon aan het einde van de regel. |
Q55 = "Nederland", P1082 = "inwonertal"
[hoeveelheid] |
{{#invoke:wd|property|normal+|Q55|P1082}}
|
Haalt een enkele eigenschapswaarde op van beweringen met een normale rang of hoger. |
Q55 = "Nederland", P1082 = "inwonertal"
[hoeveelheid] |
{{#invoke:wd|properties|normal+|Q55|P1082}}
|
Haalt meerdere eigenschapswaarde op van beweringen met een normale rang of hoger. |
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[hoeveelheid], [tijd] |
{{#invoke:wd|properties|qualifier|normal+|Q55|P1082|P585}}
|
Haalt een enkele kwalificatiewaarde op voor elke bewering, bovenop de eigenschapswaarde. |
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[hoeveelheid], [tijd], [bron] |
{{#invoke:wd|properties|qualifier|references|normal+|Q55|P1082|P585}}
|
Haalt bronnen op voor elke bewering. |
Q55 = "Nederland", P1082 = "inwonertal"
[hoeveelheid], [bron] |
Een totaal aantal van {{#invoke:wd|property|references|Q55|P1082}} mensen wonen in Nederland.
|
Haalt een eigenschap op met bijbehorende bronnen. |
Q55 = "Nederland", P1082 = "inwonertal"
[hoeveelheid], [bron] |
Nederland heeft een inwonertal van {{#invoke:wd|property|references|Q55|P1082|punc=.}}
|
Voegt een leesteken toe aan het einde van de uitvoer, vóór de bron. |
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[hoeveelheid], [tijd], [bron] |
<ul>{{#invoke:wd|properties|qualifier|references|normal+|Q55|P1082|P585|format=<li>%p[%r][<ul><li>%q</li></ul>]</li>}}</ul>
|
Retourneert de uitvoer in een aangepast formaat. |
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[tijd] |
{{#invoke:wd|qualifier|normal+|Q55|P1082|P585}}
|
Haalt een enkele kwalificatie op per bewering, standaard voor meerdere overeenkomende beweringen. |
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[tijd] |
{{#invoke:wd|qualifier|normal+|single|Q55|P1082|P585}}
|
Om een enkele kwalificatie op te halen voor slechts een enkele bewering, geef ook de optie single op zodat slechts een enkele bewering zal worden uitgelezen.
|
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[tijd] |
{{#invoke:wd|qualifier|Q55|P1082|17590672|P585}}
|
Haalt een kwalificatie op van beweringen waarvan de (ruwe) eigenschapswaarde overeenkomt met een opgegeven letterlijke waarde. |
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[tijd] |
{{#invoke:wd|qualifier|mdy|Q55|P1082|17590672|P585}}
|
Haalt datums op in de volgorde maand-dag-jaar. |
Q55 = "Nederland", P1082 = "inwonertal", P585 = "tijdstip"
[tijd] |
{{#invoke:wd|qualifier|raw|Q55|P1082|17590672|P585}}
|
Haalt een ruwe datumwaarde op. |
Q55 = "Nederland", P1082 = "inwonertal"
[bron] |
{{#invoke:wd|references|Q55|P1082|17590672}}
|
Haalt de bronnen op van een bepaalde bewering. |
Q55 = "Nederland", P1082 = "inwonertal"
[bron] |
{{#invoke:wd|references|raw|Q55|P1082|17590672}}
|
Haalt bronnen op van een bepaalde bewering in hun ruwe vorm. |
Q55 = "Nederland", P1081 = "Human Development Index"
[hoeveelheid], [bron] |
{{#invoke:wd|properties|references|normal+|Q55|P1081}}
|
Haalt eigenschappen op van elke bewering met alle eventuele bijbehorende bronnen. |
Q55 = "Nederland", P1081 = "Human Development Index"
[hoeveelheid], [bron] |
{{#invoke:wd|properties|references|normal+|sourced|Q55|P1081}}
|
Haalt alleen eigenschappen op van beweringen die minstens één bron hebben. |
Q55 = "Nederland", P2855 = "BTW-percentage", P518 = "van toepassing op deel"
[entiteitslabel] |
{{#invoke:wd|qualifier|Q55|P2855|P518}}
|
Haalt een enkele kwalificatiewaarde op (voor elke overeenkomende bewering). |
Q55 = "Nederland", P2855 = "BTW-percentage", P518 = "van toepassing op deel"
[entiteitslabel] |
{{#invoke:wd|qualifiers|Q55|P2855|P518}}
|
Haalt meerdere kwalificatiewaardes op (voor elke overeenkomende bewering). |
Q55 = "Nederland", P2855 = "BTW-percentage", P518 = "van toepassing op deel"
[hoeveelheid], [entiteitslabel] |
{{#invoke:wd|properties|qualifiers|Q55|P2855|P518}}
|
Haalt meerdere eigenschapswaardes op samen met meerdere kwalificatiewaardes. |
Q55 = "Nederland", P2855 = "BTW-percentage", P518 = "van toepassing op deel"
[hoeveelheid], [entiteitslabel] |
{{#invoke:wd|properties|qualifiers|Q55|P2855|P518|sep=_+_|sep%s=|sep%q=_/_}}
|
Retourneert de uitvoer met aangepaste scheidingstekens. |
Q55 = "Nederland", P35 = "staatshoofd", P580 = "begindatum", P582 = "einddatum"
[entiteitslabel], [tijd] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580|P582}}
|
Haalt twee verschillende kwalificatiewaardes op voor elke bewering. |
Q55 = "Nederland", P35 = "staatshoofd", P580 = "begindatum", P582 = "einddatum"
[entiteitslabel], [tijd] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580|P582|sep%q=_–_}}
|
Retourneert de uitvoer met een aangepast scheidingsteken. |
Q55 = "Nederland", P35 = "staatshoofd", P580 = "begindatum", P582 = "einddatum"
[entiteitslabel], [tijd] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580|P582|format=%p[ <span style="font-size:85\%">(%q1[ – %q2])</span>][%s][%r]}}
|
Retourneert de uitvoer in een aangepast formaat in plaats van met een aangepast scheidingsteken. |
Q55 = "Nederland", P35 = "staatshoofd", P580 = "begindatum", P582 = "einddatum"
[entiteitslabel], [tijd] |
{{#invoke:wd|properties|qualifier|qualifier|normal+|Q55|P35|P580|P582|format=%p[ <span style="font-size:85\%">([<![]--%q2]sinds [%q2--[]>]%q1[ – %q2])</span>][%s][%r]}}
|
Om tekst toe te voegen alleen wanneer een bepaalde waarde niet aanwezig is, zoals het toevoegen van het woord sinds indien er geen einddatum is, plaats deze tussen twee optionele blokken met HTML commentaar-tags en de betreffende parameter (dit voorkomt ook dat de tekst in de paginabron wordt opgenomen). |
Q55 = "Nederland", P35 = "staatshoofd", Q29574 = "Beatrix der Nederlanden", P580 = "begindatum", P582 = "einddatum"
[entiteitslabel], [tijd] |
{{#invoke:wd|properties|qualifier|raw|qualifier|normal+|Q55|P35|Q29574|P580|P582|format=%p[ <span style="font-size:85\%">(%q1[ – %q2])</span>][%s][%r]}}
|
Haalt een eigenschap met kwalificaties op van beweringen waarvan de eigenschap overeenkomt met een opgegeven Q-nummer, met een van de kwalificatiewaardes in ruwe vorm. |
Q55 = "Nederland", P38 = "valuta", P518 = "van toepassing op deel"
[entiteitslabel] |
{{#invoke:wd|properties|qualifiers|normal+|current|Q55|P38|P518}}
|
Haalt beweringen op die actueel zijn. |
Q55 = "Nederland", P38 = "valuta", P518 = "van toepassing op deel"
[entiteitslabel] |
{{#invoke:wd|properties|linked|qualifiers|normal+|current|Q55|P38|P518}} |
Haalt beweringen op met gelinkte eigenschapswaardes. |
Q55 = "Nederland", P38 = "valuta", P518 = "van toepassing op deel"
[entiteitslabel] |
{{#invoke:wd|properties|qualifiers|linked|normal+|current|Q55|P38|P518}}
|
Haalt beweringen op met gelinkte kwalificatiewaardes. |
Q55 = "Nederland", P38 = "valuta", P518 = "van toepassing op deel"
[entiteitslabel] |
{{#invoke:wd|properties|linked|short|qualifiers|linked|normal+|current|Q55|P38|P518}} |
Haalt beweringen op met gelinkte eigenschaps- en kwalificatiewaardes, met verkorte eigenschapswaardes waar beschikbaar. |
Q55 = "Nederland", P38 = "valuta", Q4917 = "US dollar", P518 = "van toepassing op deel"
[entiteitslabel] |
{{#invoke:wd|qualifiers|normal+|current|Q55|P38|Q4917|P518}}
|
Haalt kwalificaties op van beweringen waarvan de (ruwe) eigenschapswaarde overeenkomt met een opgegeven Q-nummer. |
Q55 = "Nederland", P38 = "valuta", P518 = "van toepassing op deel", Q27561 = "Caribisch Nederland"
[entiteitslabel] |
{{#invoke:wd|properties|normal+|current|Q55|P38|P518=Q27561}}
|
Haalt eigenschappen op van beweringen waarvan een (ruwe) kwalificatiewaarde overeenkomt met een opgegeven Q-nummer. |
Q55 = "Nederland", P38 = "valuta"
[entiteitslabel] |
{{#invoke:wd|properties|normal+|former|Q55|P38}}
|
Haalt beweringen op die voorheen geldig waren. |
Q55 = "Nederland", P38 = "valuta"
[entiteitslabel] |
{{#invoke:wd|properties|raw|normal+|former|Q55|P38}}
|
Haalt ruwe eigenschapswaardes op. |
Q55 = "Nederland", P38 = "valuta"
[entiteitslabel] |
{{#invoke:wd|properties|raw|linked|normal+|former|Q55|P38}}
|
Haalt ruwe eigenschapswaardes op die gelinkt zijn naar Wikidata. |
Q55 = "Nederland", P1549 = "demoniem"
[enkeltalige tekst] |
{{#invoke:wd|property|Q55|P1549}}
|
Haalt een waarde van het type enkeltalige tekst op in de taal van de huidige wiki. |
Q55 = "Nederland", P1549 = "demoniem", P407 = "taal van werk of naam", Q36846 = "Toki Pona"
[enkeltalige tekst] |
{{#invoke:wd|property|multilanguage|Q55|P1549|P407=Q36846}}
|
Haalt een waarde van het type enkeltalige tekst op in welke beschikbare taal dan ook. |
Q55 = "Nederland", P2884 = "netspanning"
[hoeveelheid] |
{{#invoke:wd|property|Q55|P2884}}
|
Haalt een hoeveelheidswaarde op met bijbehorende meeteenheid. |
Q55 = "Nederland", P2884 = "netspanning"
[hoeveelheid] |
{{#invoke:wd|property|linked|Q55|P2884}}
|
Haalt een hoeveelheidswaarde op met een gelinkte meeteenheid. |
Q55 = "Nederland", P2884 = "netspanning"
[hoeveelheid] |
{{#invoke:wd|property|raw|Q55|P2884}}
|
Haalt een ruwe hoeveelheidswaarde op. |
Q55 = "Nederland", P2884 = "netspanning"
[hoeveelheid] |
{{#invoke:wd|property|unit|Q55|P2884}}
|
Haalt alleen de meeteenheid op. |
Q55 = "Nederland", P2884 = "netspanning"
[quantity] |
{{#invoke:wd|property|unit|raw|Q55|P2884}}
|
Haalt de ruwe meeteenheid op. |
Q55 = "Nederland", P625 = "geografische locatie"
[geografische coördinaten] |
{{#invoke:wd|property|Q55|P625}}
|
Haalt een waarde van het type geografische coördinaten op. |
Q55 = "Nederland", P625 = "geografische locatie"
[geografische coördinaten] |
{{#invoke:wd|property|linked|Q55|P625}}
|
Haalt een gelinkte waarde van het type geografische coördinaten op. |
Q55 = "Nederland", P625 = "geografische locatie"
[geografische coördinaten] |
{{#invoke:wd|property|raw|Q55|P625}}
|
Haalt een ruwe waarde van het type geografische coördinaten op. |
Q55 = "Nederland", P625 = "geografische locatie"
[geografische coördinaten] |
{{#invoke:wd|property|Q55|coord}}
|
Een eigenschapsalias kan worden gebruikt in plaats van het P-nummer. |
Q55 = "Nederland", P41 = "vlagafbeelding"
[commons-media] |
{{#invoke:wd|property|linked|Q55|P41}}
|
Haalt de naam van een mediabestand op en voegt een link toe naar Commons. |
Q55 = "Nederland", P41 = "vlagafbeelding"
[commons-media] |
{{#invoke:wd|property|raw|Q55|P41|format=\[\[File:%p {{!}} thumb {{!}} left\]\]}}
|
Een mediabestand van Commons kan in de pagina worden opgenomen precies zoals het is door de opties linked en raw weg te laten, maar door de optie raw te gebruiken kan het op allerlei manieren worden opgemaakt.
|
Q55 = "Nederland", P41 = "vlagafbeelding"
[commons-media] |
{{#invoke:wd|property|raw|date=1700-05-06|Q55|P41|format=\[\[File:%p {{!}} thumb {{!}} left\]\]}}
|
Om de waarde van een eigenschap op te halen die geldig was op een bepaalde datum kan het argument date= worden gebruikt.
|
Q55 = "Nederland", P41 = "vlagafbeelding"
[commons-media] |
{{#invoke:wd|property|raw|date=1700-05-06|former|Q55|P41|format=\[\[File:%p {{!}} thumb {{!}} left\]\]}}
|
De opties voor geldigheid werken ten opzichte van de datum die is opgegeven met het argument date=.
|
Q915684 = "Lorentz–Lorenz-vergelijking", P2534 = "formule"
[wiskundig] |
{{#invoke:wd|property|Q915684|P2534}}
|
Haalt een wiskundige uitdrukking op. |
Q915684 = "Lorentz–Lorenz-vergelijking", P527 = "omvat deel", P416 = "symbool", P2534 = "formule"
[entiteitslabel], [tekenreeks], [wiskundig] |
<ul>{{#invoke:wd|properties|linked|qualifier|qualifier|Q915684|P527|P416|P2534|format=<li>%p[ (%q)]</li>}}</ul>
|
Wiskundige uitdrukkingen kunnen worden gecombineerd met gewone tekst, zoals gewoonlijk. |
Q6256 = "land", P3896 = "geografische vorm"
[geografische vorm] |
{{#invoke:wd|property|linked|Q6256|P3896}}
|
Haalt de databestandsnaam van een geografische vorm op en voegt een link toe naar Commons. |
Q4917 = "US dollar"
[entiteitslabel] |
{{#invoke:wd|label|Q4917}}
|
Haalt het label van een item op. |
Q4917 = "US dollar"
[entiteitslabel] |
{{#invoke:wd|label|short|linked|Q4917}}
|
Haalt het verkorte en gelinkte label van een item op. |
P38 = "valuta"
[entiteitslabel] |
{{#invoke:wd|label|P38}}
|
Haalt het label van een property op. |
P38 = "valuta"
[entiteitslabel] |
{{#invoke:wd|label|linked|P38}}
|
Haalt het label van een property op dat gelinkt is naar Wikidata. |
Q776 = "Utrecht"
[entiteitslabel] |
{{#invoke:wd|label|Q776}}
|
Haalt het label van een item op. |
Q776 = "Utrecht"
[entiteitslabel] |
{{#invoke:wd|label|linked|Q776}}
|
Haalt het gelinkte label van een item op. |
[entiteitslabel] |
{{#invoke:wd|label}}
|
Als de module is opgenomen in de pagina Utrecht (provincie) (die gekoppeld is aan Q776), dan kan de Q776 worden weggelaten.
|
[entiteitslabel] |
{{#invoke:wd|label|raw}}
|
Als slechts het commando label met de optie raw is opgegeven, dan wordt het Q-nummer van het item dat gekoppeld is aan de huidige pagina geretourneerd.
|
[entiteitslabel] |
{{#invoke:wd|label|raw|linked}}
|
Als daarnaast de optie linked is opgegeven, dan wordt het Q-nummer van het item dat gekoppeld is aan de huidige pagina gelinkt naar Wikidata.
|
Q776 = "Utrecht"
[paginatitel] |
{{#invoke:wd|title|Q776}}
|
Haalt de titel op van de pagina op de huidige wiki die gekoppeld is aan het opgegeven item. |
Q776 = "Utrecht"
[paginatitel] |
{{#invoke:wd|title|linked|Q776}} |
Haalt de gelinkte titel op van de pagina op de huidige wiki die gekoppeld is aan het opgegeven item. |
[paginatitel] |
{{#invoke:wd|title}}
|
Als de module is opgenomen in de pagina Utrecht (provincie) (die gekoppeld is aan Q776), dan kan de Q776 worden weggelaten.
|
Q55 = "Nederland"
[entiteitsbeschrijving] |
{{#invoke:wd|description|Q55}}
|
Haalt de beschrijving van een item op. |
[entiteitsbeschrijving] |
{{#invoke:wd|description}}
|
Als de module is opgenomen in de pagina Nederland (die gekoppeld is aan Q55), dan kan de Q55 worden weggelaten.
|
Q55 = "Nederland"
[entiteitsalias] |
{{#invoke:wd|alias|Q55}}
|
Haalt een van de aliassen van een item op. |
Q55 = "Nederland"
[entiteitsalias] |
{{#invoke:wd|aliases|Q55}}
|
Haalt alle aliassen van een item op. |
Q55 = "Nederland"
[entiteitsalias] |
{{#invoke:wd|alias|linked|Q55}}
|
Haalt een gelinkte alias van een item op. |
[entiteitsalias] |
{{#invoke:wd|alias}}
|
Als de module is opgenomen in de pagina Nederland (die gekoppeld is aan Q55), dan kan de Q55 worden weggelaten.
|
Q2 = "Aarde"
[pagina-badge] |
{{#invoke:wd|badges|Q2}}
|
Haalt de badges op voor de pagina op de huidige wiki die gekoppeld is aan het opgegeven item. |
Q2 = "Aarde"
[pagina-badge] |
{{#invoke:wd|badges|raw|Q2}}
|
Haalt de ruwe badges op voor de pagina op de huidige wiki die gekoppeld is aan het opgegeven item. |
[pagina-badge] |
{{#invoke:wd|badges}}
|
Als de module is opgenomen in de pagina Aarde (planeet) (die gekoppeld is aan Q2), dan kan de Q2 worden weggelaten.
|
Voorbeeldbronnen
Zie ook
- {{Wikidata}}, een gebruiksvriendelijke wrapper-sjabloon voor deze module.
-- Original module located at [[:en:Module:Wd]].
local p = {}
local arg = ...
local i18n
function loadSubmodules(frame)
-- internationalization
if not i18n then
if frame then
i18n = require(frame:getTitle().."/i18n")
else
i18n = require(arg.."/i18n")
end
end
end
local aliasesP = {
coord = "P625",
---------------
author = "P50",
publisher = "P123",
importedFrom = "P143",
statedIn = "P248",
publicationDate = "P577",
startTime = "P580",
endTime = "P582",
retrieved = "P813",
referenceURL = "P854",
archiveURL = "P1065",
title = "P1476",
quote = "P1683",
shortName = "P1813",
language = "P2439",
archiveDate = "P2960"
}
local aliasesQ = {
percentage = "Q11229",
prolepticJulianCalendar = "Q1985786"
}
local parameters = {
property = "%p",
qualifier = "%q",
reference = "%r",
separator = "%s",
general = "%x"
}
local formats = {
property = "%p[%s][%r]",
qualifier = "%q[%s][%r]",
reference = "%r",
propertyWithQualifier = "%p[ <span style=\"font-size:smaller\">(%q)</span>][%s][%r]"
}
local hookNames = { -- {level_1, level_2}
[parameters.property] = {"getProperty"},
[parameters.reference] = {"getReferences", "getReference"},
[parameters.qualifier] = {"getAllQualifiers"},
[parameters.qualifier.."\\d"] = {"getQualifiers", "getQualifier"}
}
-- default value objects, should NOT be mutated but instead copied
local defaultSeparators = {
["sep"] = {" "},
["sep%s"] = {","},
["sep%q"] = {"; "},
["sep%q\\d"] = {", "},
["sep%r"] = nil, -- none
["punc"] = nil -- none
}
local Config = {}
Config.__index = Config
-- allows for recursive calls
function Config.new()
local cfg = {}
setmetatable(cfg, Config)
cfg.separators = {
-- single value objects wrapped in arrays so that we can pass by reference
["sep"] = {copyTable(defaultSeparators["sep"])},
["sep%s"] = {copyTable(defaultSeparators["sep%s"])},
["sep%q"] = {copyTable(defaultSeparators["sep%q"])},
["sep%r"] = {copyTable(defaultSeparators["sep%r"])},
["punc"] = {copyTable(defaultSeparators["punc"])}
}
cfg.entity = nil
cfg.propertyID = nil
cfg.propertyValue = nil
cfg.qualifierIDs = {}
cfg.bestRank = true
cfg.ranks = {true, true, false} -- preferred = true, normal = true, deprecated = false
cfg.foundRank = #cfg.ranks
cfg.flagBest = false
cfg.flagRank = false
cfg.periods = {true, true, true} -- future = true, current = true, former = true
cfg.flagPeriod = false
cfg.mdyDate = false
cfg.pageTitle = false
cfg.langCode = mw.language.getContentLanguage().code
cfg.langName = mw.language.fetchLanguageName(cfg.langCode, cfg.langCode)
cfg.langObj = mw.language.new(cfg.langCode)
cfg.states = {}
cfg.states.qualifiersCount = 0
cfg.curState = nil
return cfg
end
local State = {}
State.__index = State
function State.new(cfg)
local stt = {}
setmetatable(stt, State)
stt.conf = cfg
stt.results = {}
stt.parsedFormat = {}
stt.separator = {}
stt.movSeparator = {}
stt.puncMark = {}
stt.linked = false
stt.rawValue = false
stt.shortName = false
stt.singleValue = false
return stt
end
function applyStringParams(str, ...)
for i, v in ipairs(arg) do
str = mw.ustring.gsub(str, "$"..i, v)
end
return str
end
function unknownDataTypeError(dataType)
return applyStringParams(i18n['errors']['unknown-data-type'], dataType)
end
function missingRequiredParameterError()
return i18n['errors']['missing-required-parameter']
end
function extraRequiredParameterError(param)
return applyStringParams(i18n['errors']['extra-required-parameter'], param)
end
-- used to make frame.args mutable, to replace #frame.args (which is always 0)
-- with the actual amount and to simply copy tables
function copyTable(tIn)
if not tIn then
return nil
end
local tOut = {}
for i, v in pairs(tIn) do
tOut[i] = v
end
return tOut
end
-- used to merge output arrays together;
-- note that it currently mutates the first input array
function mergeArrays(a1, a2)
for i = 1, #a2 do
a1[#a1 + 1] = a2[i]
end
return a1
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 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
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
return outString
end
function getHookName(param, index)
if hookNames[param] then
return hookNames[param][index]
elseif string.len(param) > 2 then
return hookNames[string.sub(param, 1, 2).."\\d"][index]
else
return nil
end
end
function parseWikidataURL(url)
local i, j
if url:match('^http[s]?://') then
i, j = url:find("Q")
if i then
return url:sub(i)
end
end
return nil
end
function parseDate(dateStr, precision)
precision = precision or "d"
local i, j, index, ptr
local parts = {nil, nil, nil}
if dateStr == nil then
return parts[1], parts[2], parts[3] -- year, month, day
end
-- 'T' for snak values, '/' for outputs with '/Julian' attached
i, j = dateStr:find("[T/]")
if i then
dateStr = dateStr:sub(1, i-1)
end
local from = 1
if dateStr:sub(1,1) == "-" then
-- this is a negative number, look further ahead
from = 2
end
index = 1
ptr = 1
i, j = dateStr:find("-", from)
if i then
-- year
parts[index] = tonumber(mw.ustring.gsub(dateStr:sub(ptr, i-1), "^\+(.+)$", "%1"), 10) -- remove '+' sign (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
if precision == "y" then
-- we're done
return parts[1], parts[2], parts[3] -- year, month, day
end
index = index + 1
ptr = i + 1
i, j = dateStr:find("-", ptr)
if i then
-- month
parts[index] = tonumber(dateStr:sub(ptr, i-1), 10)
if precision == "m" then
-- we're done
return parts[1], parts[2], parts[3] -- year, month, day
end
index = index + 1
ptr = i + 1
end
end
if dateStr:sub(ptr) ~= "" then
-- day if we have month, month if we have year, or year
parts[index] = tonumber(dateStr:sub(ptr), 10)
end
return parts[1], parts[2], parts[3] -- year, month, day
end
function convertUnit(unit, link)
link = link or false
local itemID, label, title
if unit == "" or unit == "1" then
return nil
end
itemID = parseWikidataURL(unit)
if itemID then
if itemID == aliasesQ.percentage then
return "%"
else
label = mw.wikibase.label(itemID)
title = nil
if link or label == nil then
title = mw.wikibase.sitelink(itemID)
end
if link then
if title then
return " " .. "[[" .. 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)
return i18n.getOrdinalSuffix(num)
end
function addDecimalMarks(num)
return i18n.addDecimalMarks(num)
end
-- used for cleaner output when subst:ituting this module
function replaceHTMLSpaces(str)
return mw.ustring.gsub(str, " ", " ")
end
function convertRank(rank)
if rank == "preferred" then
return 1
elseif rank == "normal" then
return 2
elseif rank == "deprecated" then
return 3
else
return 4 -- default (in its literal sense)
end
end
function datePrecedesDate(aY, aM, aD, bY, bM, bD)
if aY == nil or bY == nil then
return nil
end
aM = aM or 1
aD = aD or 1
bM = bM or 1
bD = bD or 1
if aY < bY then
return true
end
if aY > bY then
return false
end
if aM < bM then
return true
end
if aM > bM then
return false
end
if aD < bD then
return true
end
return false
end
function alwaysTrue()
return true
end
-- 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"
-- }
-- ]
--
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
local function endParam()
if param > 0 then
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
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)
local rankPos
local ranks = {{}, {}, {}, {}} -- preferred, normal, deprecated, (default)
local sorted = {}
for i, v in ipairs(claims) do
rankPos = convertRank(v.rank)
ranks[rankPos][#ranks[rankPos] + 1] = v
end
sorted = ranks[1]
sorted = mergeArrays(sorted, ranks[2])
sorted = mergeArrays(sorted, ranks[3])
return sorted
end
function getShortName(itemID)
if itemID then
return p._property({itemID, aliasesP.shortName}) -- "property" is single
else
return p._property({aliasesP.shortName}) -- "property" is single
end
end
function getLabel(ID)
if ID then
return p._label({ID})
else
return p._label({})
end
end
function Config:getValue(snak, raw, link, short, anyLang)
raw = raw or false
link = link or false
short = short or false
anyLang = anyLang or false
if snak.snaktype == 'value' then
if snak.datavalue.type == 'string' then
return snak.datavalue.value
elseif snak.datavalue.type == 'monolingualtext' then
if anyLang then
return snak.datavalue.value['text'], snak.datavalue.value['language']
elseif snak.datavalue.value['language'] == self.langCode then
return snak.datavalue.value['text']
else
return nil
end
elseif snak.datavalue.type == 'quantity' then
-- strip + signs from front
local value = mw.ustring.gsub(snak.datavalue.value['amount'], "^\+(.+)$", "%1")
if not raw then
value = addDecimalMarks(value)
local unit = convertUnit(snak.datavalue.value['unit'], link)
if unit then
value = value .. unit
end
end
return value
elseif snak.datavalue.type == 'time' then
local y, m, d, p, yDiv, yRound, yFull, value, calendarID, dateStr
local yFactor = 1
local sign = 1
local prefix = ""
local suffix = ""
local mayAddCalendar = false
local calendar = ""
local precision = snak.datavalue.value['precision']
if precision == 11 then
p = "d"
elseif precision == 10 then
p = "m"
else
p = "y"
yFactor = 10^(9-precision)
end
y, m, d = parseDate(snak.datavalue.value['time'], p)
if y < 0 then
sign = -1
y = y * sign
end
-- if precision is tens/hundreds/thousands/millions/billions of years
if precision <= 8 then
yDiv = y / yFactor
-- if precision is tens/hundreds/thousands of years
if precision >= 6 then
mayAddCalendar = true
if precision <= 7 then
-- round centuries/millenniums up (e.g. 20th century or 3rd millennium)
yRound = math.ceil(yDiv)
if not raw then
if precision == 6 then
suffix = 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
if raw and sign < 0 then
-- if BCE then compensate for "counting backwards"
-- (e.g. -2019 for 2010s BCE, -2000 for 20th century BCE or -3000 for 3rd millennium BCE)
yRound = yRound + yFactor - 1
end
else
local yReFactor, yReDiv, yReRound
-- round to nearest for tens of thousands of years or more
yRound = math.floor(yDiv + 0.5)
if yRound == 0 then
if precision <= 2 and y ~= 0 then
yReFactor = 1e6
yReDiv = y / yReFactor
yReRound = math.floor(yReDiv + 0.5)
if yReDiv == yReRound then
-- change precision to millions of years only if we have a whole number of them
precision = 3
yFactor = yReFactor
yRound = yReRound
end
end
if yRound == 0 then
-- otherwise, take the unrounded (original) number of years
precision = 5
yFactor = 1
yRound = y
mayAddCalendar = true
end
end
if precision >= 1 and y ~= 0 then
yFull = yRound * yFactor
yReFactor = 1e9
yReDiv = yFull / yReFactor
yReRound = math.floor(yReDiv + 0.5)
if yReDiv == yReRound then
-- change precision to billions of years if we're in that range
precision = 0
yFactor = yReFactor
yRound = yReRound
else
yReFactor = 1e6
yReDiv = yFull / yReFactor
yReRound = math.floor(yReDiv + 0.5)
if yReDiv == yReRound then
-- change precision to millions of years if we're in that range
precision = 3
yFactor = yReFactor
yRound = yReRound
end
end
end
if not raw then
if precision == 3 then
suffix = i18n['datetime']['suffixes']['million-years']
elseif precision == 0 then
suffix = i18n['datetime']['suffixes']['billion-years']
else
yRound = yRound * yFactor
if yRound == 1 then
suffix = i18n['datetime']['suffixes']['year']
else
suffix = i18n['datetime']['suffixes']['years']
end
end
else
yRound = yRound * yFactor
end
end
else
yRound = y
mayAddCalendar = true
end
if mayAddCalendar then
calendarID = parseWikidataURL(snak.datavalue.value['calendarmodel'])
if calendarID and calendarID == aliasesQ.prolepticJulianCalendar then
if not raw then
if link then
calendar = " ([["..i18n['datetime']['julian-calendar'].."|"..i18n['datetime']['julian'].."]])"
else
calendar = " ("..i18n['datetime']['julian']..")"
end
else
calendar = "/"..i18n['datetime']['julian']
end
end
end
if not raw then
local ce = nil
if sign < 0 then
ce = i18n['datetime']['BCE']
elseif precision <= 5 then
ce = i18n['datetime']['CE']
end
if ce then
if link then
ce = "[[" .. 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
value = prefix .. value .. suffix .. calendar
else
value = tostring(yRound * sign)
if m then
value = value .. "-" .. m
if d then
value = value .. "-" .. d
end
end
value = value .. calendar
end
return value
elseif snak.datavalue.type == 'globecoordinate' then
-- logic from https://github.com/DataValues/Geo
local precision, numDigits, strFormat, value, globe
local latValue, latitude, latDegrees, latMinutes, latSeconds
local latDirection = i18n['coord']['latitude-north']
local lonValue, longitude, lonDegrees, lonMinutes, lonSeconds
local lonDirection = i18n['coord']['longitude-east']
local degSymbol = i18n['coord']['degrees']
local minSymbol = i18n['coord']['minutes']
local secSymbol = i18n['coord']['seconds']
local separator = i18n['coord']['separator']
if raw then
degSymbol = "/"
minSymbol = "/"
secSymbol = "/"
separator = "/"
end
latitude = snak.datavalue.value['latitude']
longitude = snak.datavalue.value['longitude']
if latitude < 0 then
latDirection = i18n['coord']['latitude-south']
latitude = math.abs(latitude)
end
if longitude < 0 then
lonDirection = i18n['coord']['longitude-west']
longitude = math.abs(longitude)
end
precision = snak.datavalue.value['precision']
latitude = math.floor(latitude / precision + 0.5) * precision
longitude = math.floor(longitude / precision + 0.5) * precision
numDigits = math.ceil(-math.log10(3600 * precision))
if numDigits < 0 or numDigits == -0 then
numDigits = tonumber("0") -- for some reason, 'numDigits = 0' may actually store '-0', so parse from string instead
end
strFormat = "%." .. numDigits .. "f"
-- use string.format() to strip decimal point followed by a zero (.0) for whole numbers
latSeconds = tonumber(string.format(strFormat, math.floor(latitude * 3600 * 10^numDigits + 0.5) / 10^numDigits))
lonSeconds = tonumber(string.format(strFormat, math.floor(longitude * 3600 * 10^numDigits + 0.5) / 10^numDigits))
latMinutes = math.floor(latSeconds / 60)
lonMinutes = math.floor(lonSeconds / 60)
latSeconds = latSeconds - (latMinutes * 60)
lonSeconds = lonSeconds - (lonMinutes * 60)
latDegrees = math.floor(latMinutes / 60)
lonDegrees = math.floor(lonMinutes / 60)
latMinutes = latMinutes - (latDegrees * 60)
lonMinutes = lonMinutes - (lonDegrees * 60)
latValue = latDegrees .. degSymbol
lonValue = lonDegrees .. degSymbol
if precision < 1 then
latValue = latValue .. latMinutes .. minSymbol
lonValue = lonValue .. lonMinutes .. minSymbol
end
if precision < (1 / 60) then
latSeconds = string.format(strFormat, latSeconds)
lonSeconds = string.format(strFormat, lonSeconds)
latValue = latValue .. latSeconds .. secSymbol
lonValue = lonValue .. lonSeconds .. secSymbol
end
latValue = latValue .. latDirection
lonValue = lonValue .. lonDirection
value = latValue .. separator .. lonValue
if link then
globe = parseWikidataURL(snak.datavalue.value['globe'])
if globe then
globe = mw.wikibase.getEntity(globe):getLabel("en"):lower()
else
globe = "earth"
end
value = "[https://tools.wmflabs.org/geohack/geohack.php?language="..self.langCode.."¶ms="..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
return "[[d:" .. itemID .. "|" .. itemID .. "]]"
else
return itemID
end
end
if short then
value = getShortName(itemID)
end
if value == "" then
value = mw.wikibase.label(itemID)
end
if link or value == nil then
title = mw.wikibase.sitelink(itemID)
end
if link then
if title then
value = "[[" .. title .. "|" .. (value or title) .. "]]"
elseif not value then
value = "[[d:" .. itemID .. "|" .. itemID .. "]]"
end
elseif not value then
value = (title or itemID)
end
return value
else
return '<strong class="error">' .. unknownDataTypeError(snak.datavalue.type) .. '.</strong>'
end
elseif snak.snaktype == 'somevalue' then
if raw then
return " " -- single space represents 'somevalue'
else
return i18n['values']['unknown']
end
elseif snak.snaktype == 'novalue' then
if raw then
return "" -- empty string represents 'novalue'
else
return i18n['values']['none']
end
else
return nil
end
end
function Config:getSingleRawQualifier(claim, qualifierID)
local qualifiers
if claim.qualifiers then qualifiers = claim.qualifiers[qualifierID] end
if qualifiers and qualifiers[1] then
return self:getValue(qualifiers[1], true) -- raw = true
else
return nil
end
end
function Config:snakEqualsValue(snak, value)
local snakValue = self:getValue(snak, true) -- raw = true
if snakValue and snak.snaktype == 'value' and snak.datavalue.type == 'wikibase-entityid' then value = value:upper() end
return snakValue == value
end
function Config:setRank(rank)
local rankPos
if rank == "best" then
self.bestRank = true
self.flagBest = true -- mark that 'best' flag was given
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)
local periodPos
if period == "future" then
periodPos = 1
elseif period == "current" then
periodPos = 2
elseif period == "former" then
periodPos = 3
else
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 flag then
return false
else
flag = mw.text.trim(flag)
end
if flag == "linked" then
self.curState.linked = true
return true
elseif flag == "raw" then
self.curState.rawValue = true
if self.curState == self.states[parameters.reference] then
-- raw reference values end with periods and require a separator (other than none)
self.separators["sep%r"][1] = {" "}
end
return true
elseif flag == "short" then
self.curState.shortName = true
return true
elseif flag == "mdy" then
self.mdyDate = true
return true
elseif flag == "best" or flag:match('^preferred[+-]?$') or flag:match('^normal[+-]?$') or flag:match('^deprecated[+-]?$') then
self: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)
local param = ""
if not flag then
return false
else
flag = mw.text.trim(flag)
end
if flag == "property" or flag == "properties" then
param = parameters.property
elseif flag:match('^qualifier[s]?$') then
self.states.qualifiersCount = self.states.qualifiersCount + 1
param = parameters.qualifier .. self.states.qualifiersCount
self.separators["sep"..param] = {copyTable(defaultSeparators["sep%q\\d"])}
elseif flag:match('^reference[s]?$') then
param = parameters.reference
else
return self:processFlag(flag)
end
if self.states[param] then
return false
end
-- create a new State for each command
self.states[param] = State.new(self)
-- use "%x" as the general parameter name
self.states[param].parsedFormat = parseFormat(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 self.bestRank then
return (self.ranks[rankPos] and self.foundRank >= rankPos)
else
return self.ranks[rankPos]
end
end
function Config:timeMatches(claim)
local startTime = nil
local startTimeY = nil
local startTimeM = nil
local startTimeD = nil
local endTime = nil
local endTimeY = nil
local endTimeM = nil
local endTimeD = nil
if self.periods[1] and self.periods[2] and self.periods[3] then
-- any time
return true
end
local now = os.date('!*t')
startTime = self:getSingleRawQualifier(claim, aliasesP.startTime)
if startTime and startTime ~= "" and startTime ~= " " then
startTimeY, startTimeM, startTimeD = parseDate(startTime)
end
endTime = self:getSingleRawQualifier(claim, aliasesP.endTime)
if endTime and endTime ~= "" and endTime ~= " " then
endTimeY, endTimeM, endTimeD = parseDate(endTime)
elseif endTime == " " then
-- end time is 'unknown', assume it is somewhere in the past;
-- we can do this by taking the current date as a placeholder for the end time
endTimeY = now['year']
endTimeM = now['month']
endTimeD = now['day']
end
if startTimeY ~= nil and endTimeY ~= nil and datePrecedesDate(endTimeY, endTimeM, endTimeD, startTimeY, startTimeM, startTimeD) then
-- invalidate end time if it precedes start time
endTimeY = nil
endTimeM = nil
endTimeD = nil
end
if self.periods[1] then
-- future
if startTimeY and datePrecedesDate(now['year'], now['month'], now['day'], startTimeY, startTimeM, startTimeD) then
return true
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)
local matches, rankPos
-- if a property value was given, check if it matches the claim's property value
if self.conf.propertyValue then
matches = self.conf:snakEqualsValue(claim.mainsnak, self.conf.propertyValue)
else
matches = true
end
-- check if the claim's rank and time period match
rankPos = convertRank(claim.rank)
matches = (matches and self.conf:rankMatches(rankPos) and self.conf:timeMatches(claim))
return matches, rankPos
end
function State: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 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
function State:getProperty(claim)
local value = {self.conf:getValue(claim.mainsnak, self.rawValue, self.linked, self.shortName)} -- 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:getQualifiers(claim, param)
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.conf:getValue(snak, self.rawValue, self.linked, self.shortName)} -- 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 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
-- logic determined based on https://www.wikidata.org/wiki/Help:Sources
function State:getReference(statement)
local snakValue, lang, property, url, title
local value = ""
local ref = {}
local snaks = {}
local params = {}
local leadParams = {}
if statement.snaks then
for i, v in pairs(statement.snaks) do
if v[1] then
snaks[i] = v[1]
end
end
-- don't include "imported from" that has been added by a bot
if snaks[aliasesP.importedFrom] then
snaks[aliasesP.importedFrom] = nil
end
-- use the general template for citing web references if both URL and title are present
if snaks[aliasesP.referenceURL] and snaks[aliasesP.title] and i18n['cite']['cite-web'] and i18n['cite']['cite-web'] ~= "" then
params[i18n['cite']['url']] = self.conf:getValue(snaks[aliasesP.referenceURL])
params[i18n['cite']['title']] = self.conf:getValue(snaks[aliasesP.title], false, false, false, true) -- anyLang = true
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
if mw.isSubsting() then
for i, v in pairs(params) do
value = value .. "|" .. i .. "=" .. v
end
value = "{{" .. i18n['cite']['cite-web'] .. value .. "}}"
else
value = mw.getCurrentFrame():expandTemplate{title=i18n['cite']['cite-web'], args=params}
end
else
-- if no general template for citing web references was defined but URL and title are present, add these together
if snaks[aliasesP.referenceURL] and snaks[aliasesP.title] then
url = self.conf:getValue(snaks[aliasesP.referenceURL])
title = self.conf:getValue(snaks[aliasesP.title], false, false, false, true)
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
for i, v in pairs(snaks) do
property = getLabel(i)
if property ~= "" then
snakValue, lang = self.conf:getValue(v, false, (i == aliasesP.statedIn), false, true) -- link = true/false, anyLang = true
if lang and lang ~= self.conf.langCode then
snakValue = "''" .. snakValue .. "'' (" .. mw.language.fetchLanguageName(lang, self.conf.langCode) .. ")"
end
if i == aliasesP.referenceURL or i == aliasesP.statedIn then
leadParams[#leadParams + 1] = snakValue
elseif i ~= aliasesP.language or self.conf.langName ~= snakValue then
params[#params + 1] = property .. ": " .. snakValue
end
end
end
value = table.concat(leadParams, "; ")
params = table.concat(params, "; ")
if params ~= "" then
if value ~= "" then
value = value .. "; "
end
value = value .. params
end
if value ~= "" then
value = value .. "."
end
end
if value ~= "" then
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)
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 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
if result.count == hooks.count then
-- we're done if all hooks have been called;
-- returning at this point breaks the loop
return true
end
end
for i2, v2 in ipairs(formatTable) do
if result.count == hooks.count then
-- we're done if all hooks have been called;
-- returning at this point prevents further childs from being processed
return true
end
if v2.child then
walk(v2.child)
end
end
return true
end
gotRequired = walk(self.parsedFormat)
-- only append the result if we got values for all required parameters on the root level
if gotRequired then
-- 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
function p.property(frame)
loadSubmodules(frame)
return p._property(copyTable(frame.args))
end
function p._property(args)
loadSubmodules()
return execCommand(args, "property")
end
function p.properties(frame)
loadSubmodules(frame)
return p._properties(copyTable(frame.args))
end
function p._properties(args)
loadSubmodules()
return execCommand(args, "properties")
end
function p.qualifier(frame)
loadSubmodules(frame)
return p._qualifier(copyTable(frame.args))
end
function p._qualifier(args)
loadSubmodules()
return execCommand(args, "qualifier")
end
function p.qualifiers(frame)
loadSubmodules(frame)
return p._qualifiers(copyTable(frame.args))
end
function p._qualifiers(args)
loadSubmodules()
return execCommand(args, "qualifiers")
end
function p.reference(frame)
loadSubmodules(frame)
return p._reference(copyTable(frame.args))
end
function p._reference(args)
loadSubmodules()
return execCommand(args, "reference")
end
function p.references(frame)
loadSubmodules(frame)
return p._references(copyTable(frame.args))
end
function p._references(args)
loadSubmodules()
return execCommand(args, "references")
end
function execCommand(args, funcName)
_ = Config.new()
_:processFlagOrCommand(funcName) -- process first command (== function name)
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
if nextArg then
nextArg = mw.text.trim(nextArg)
else
nextArg = ""
end
-- check for optional item ID
if nextArg:sub(1,1):upper() == "Q" then
_.entity = mw.wikibase.getEntity(nextArg) -- item ID given
_.propertyID = mw.text.trim(args[nextIndex] or "") -- property ID
nextIndex = nextIndex + 1
else
_.entity = mw.wikibase.getEntity() -- no item ID given, use item connected to current page
_.propertyID = nextArg -- property ID
end
-- check if given property ID is an alias
if aliasesP[_.propertyID] then
_.propertyID = aliasesP[_.propertyID]
end
_.propertyID = _.propertyID:upper()
if _.states.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
for i = 1, _.states.qualifiersCount do
nextArg = mw.text.trim(args[nextIndex] or "") -- is a qualifierID
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
elseif _.states[parameters.reference] then
-- do further processing if "reference(s)" command was given
nextArg = args[nextIndex]
nextIndex = nextIndex + 1
_.propertyValue = nextArg -- claim ID or literal value (possibly nil)
end
-- check for special property value 'somevalue' or 'novalue'
if _.propertyValue then
if _.propertyValue ~= "" and mw.text.trim(_.propertyValue) == "" then
_.propertyValue = " " -- single space represents 'somevalue', whereas empty string represents 'novalue'
else
_.propertyValue = mw.text.trim(_.propertyValue)
end
end
-- parse the desired format, or choose an appropriate format
if args["format"] then
parsedFormat, formatParams = parseFormat(replaceHTMLSpaces(mw.text.trim(args["format"])))
elseif _.states.qualifiersCount > 0 then -- "qualifier(s)" command given
if _.states[parameters.property] then -- "propert(y|ies)" command given
parsedFormat, formatParams = parseFormat(formats.propertyWithQualifier)
else
parsedFormat, formatParams = parseFormat(formats.qualifier)
end
elseif _.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 _.states.qualifiersCount > 0 and not _.states[parameters.property] then
_.separators["sep"..parameters.separator][1] = {";"}
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
and not _.states[parameters.reference].rawValue then
_.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;
-- must come BEFORE overriding the separator values
if _.states.qualifiersCount == 1 then
_.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
-- make sure that at least one required parameter has been defined
if not next(parsedFormat.req) then
error(missingRequiredParameterError())
end
-- make sure that the separator parameter "%s" is not amongst the required parameters
if parsedFormat.req[parameters.separator] then
error(extraRequiredParameterError(parameters.separator))
end
-- define the hooks that should be called (getProperty, getQualifiers, getReferences);
-- only define a hook if both its command ("propert(y|ies)", "reference(s)", "qualifier(s)") and its parameter ("%p", "%r", "%q1", "%q2", "%q3") have been given
for i, v in pairs(_.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[string.sub(i, 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 _.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 _.states[parameters.property] then
_.states[parameters.property] = State.new(_)
end
-- set the parsed format and the separators (and optional punctuation mark)
_.states[parameters.property].parsedFormat = parsedFormat
_.states[parameters.property].separator = _.separators["sep"]
_.states[parameters.property].movSeparator = _.separators["sep"..parameters.separator]
_.states[parameters.property].puncMark = _.separators["punc"]
if _.entity and _.entity.claims then claims = _.entity.claims[_.propertyID] end
if claims then
-- 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)
loadSubmodules(frame)
return p._label(copyTable(frame.args))
end
function p._label(args, _)
_ = _ or Config.new()
_.curState = State.new(_)
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
if nextArg then
ID = mw.text.trim(nextArg)
if ID == "" then
ID = nil
end
end
if ID then
if aliasesP[ID] then
ID = aliasesP[ID]
end
ID = ID:upper()
-- check if this is a valid ID, and if the number is not larger than max int (to prevent error)
if not string.match(ID, '^[QP]%d+$') or tonumber(string.match(ID, '%d+')) > 2147483647 then
return ""
end
if _.curState.rawValue 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
else
if _.curState.rawValue and not _.pageTitle then
label = mw.wikibase.getEntityIdForCurrentPage() or ""
if _.curState.linked and label ~= "" then
label = "[[d:" .. label .. "|" .. label .. "]]"
end
return label
end
end
if ID and ID:sub(1,1) == "P" then
if not _.pageTitle then
label = mw.wikibase.label(ID) or ""
if _.curState.linked and label ~= "" then
label = "[[d:Property:" .. ID .. "|" .. label .. "]]"
end
end
else
if not _.pageTitle then
if _.curState.shortName then
label = getShortName(ID)
end
-- at this point, 'label' will be a string and not nil
if label == "" then
label = mw.wikibase.label(ID)
end
else
-- set 'label' to nil so 'title' will always prevail
label = nil
end
-- at this point, 'label' will be nil or a non-empty string
if _.curState.linked or label == nil then
if ID then
title = mw.wikibase.sitelink(ID)
else
title = mw.title.getCurrentTitle().prefixedText
end
end
if _.curState.linked and title then
label = "[[" .. title .. "|" .. (label or title) .. "]]"
else
label = label or title or ""
end
end
return label
end
function p.title(frame)
loadSubmodules(frame)
return p._title(copyTable(frame.args))
end
function p._title(args, _)
_ = _ or Config.new()
_.pageTitle = true
-- loadSubmodules() will already be called by _label()
return p._label(args, _)
end
-- 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)
end
return p