Extension:WSArrays

This page is a translated version of the page Extension:WSArrays and the translation is 100% complete.
Avertissement Avertissement : Cette extension n'est pas compatible avec les plans de parallélisation de l'analyse syntaxique, comme prévu par l'utilisation de Parsoid . Par conséquent, l'avenir de cette extension est incertain et il est probable qu'elle deviendra incompatible avec l'analyseur standard MediaWiki dans quelques années. Pour d'autres informations, voir tâche T250963 et No support for sequential, in-order processing of extension tags .
Manuel des extensions MediaWiki
WSArrays
État de la version : non-maintenu
Implémentation Fonction d'analyseur
Description Ajoute des fonctions d'analyse pour permettre la création et l'utilisation des tableaux associatifs et multidimensionnels.
Auteur(s) Wikibase Solutions
Dernière version 5.5.4 (2022-09-12)
MediaWiki 1.31+
PHP 5.3+
Modifie la base
de données
Non
Licence Licence publique générale GNU v2.0 ou supérieur
Téléchargement
  • $wfSkipVersionControl
  • $wfEnableResultPrinter
Téléchargements trimestriels 0

L'extension WSArrays (ou ComplexArrays) crée un ensemble supplémentaire de fonctions d'analyse qui utilisent les tableaux multidimensionnels et les tableaux associatifs.

Fonctions

Cette extension définit plus de 20 fonctions d'analyse :

Nom de la fonction Alias
#complexarraydefine #cadefine
#complexarrayprint #caprint
#complexarraypush #capush
#complexarraysize #casize
#complexarrayaddvalue #caaddvalue, #caadd, #caaddv, #caset
#complexarrayreset #careset, #caclear
#complexarraysort #casort
#complexarraymap #camap
#complexarraymaptemplate #camaptemplate, #camapt, #catemplate
#complexarrayextract #caextract
#complexarrayunique #caunique
#complexarraymerge #camerge
#complexarraypusharray #capusharray
#complexarrayslice #caslice
#complexarraysearch #casearch
#complexarraysearcharray #casearcharray, #casearcha
#complexarraydefinedarrays #cadefinedarrays, #cadefined, #cad
#complexarrayarraymap #caamap, #camapa
#complexarrayparent #caparent, #capapa, #camama
#complexarrayunset #caunset, #caremove
#complexarraydiff #cadiff

Construction de tableaux

complexarraydefine

Cette fonction crée un nouveau tableau identifié par key.

Syntaxe

{{#complexarraydefine:key|array|delimiter|noparse}}

Explications

  • key (obligatoire) — nom du tableau
  • array (obligatoire) — tableau en WSON, ou en utilisant un délimiteur.
  • delimiter (optionnel, valeur par défaut : ,) — délimiteur utilisé pour définir un tableau simple.
  • noparse (optionnel) — arguments pour dire à l'analyseur syntaxique quoi rechercher dans array (voir Utiliser l'anayseur).

Exemples

Définir un tableau multidimensionnel appelé baz
{{#cadefine:baz|(("foo":(("bar":"baz"))))}}
Définir un tableau simple appelé bex (notez que parfois WSArrays ne reconnaît pas correctement les tableaux séparés par delimiter ; essayez d'ajouter un délimiteur au lieu d'utiliser le paramètre par défaut ,)
{{#cadefine:bex|foo; bar; baz|;}}

complexarraydefinedarrays

Cette fonction de débogage crée un nouveau tableau contenant les clés de tous les tableaux actuellement définis.

Syntaxe

{{#complexarraydefinedarrays: key}}

Explications

  • key (obligatoire) — nom du tableau qui contiendra les clés des tableaux définis actuellement

Utiliser les tableaux

Extraction

complexarrayprint

Cette fonction imprime les valeurs du tableau dans un format personnalisé.

Syntaxe
{{#complexarrayprint:key|options|noparse}}

Explication
  • key (obligatoire) — nom du (sous-) tableau à imprimer
  • options (optionnel):
    • markup — imprimer le résultat en WSON.
  • noparse (optionnel) — initialiser à true pour dire à l'analyseur de ne pas traiter la sortie selon la syntaxe wiki.

Exemples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
  • 3
    • baz: {{SomeTemplate|Test}}. ?UNIQ347fb3f0c7f3d9c-5
Si vous avez défini le tableau avec noparse, le comportement est différent.
Fonction Résultat
{{#caprint: foobar}}
  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
  • 3
    • baz: Test. {{SomeTemplate|Test}}
{{#caprint: foobar[0]}}
  • foo: bar
  • baz: quz
{{#caprint: foobar[3]}}
  • Test. {{SomeTemplate|Test}}
{{#caprint: foobar[0][foo]}}
bar

complexarraysize

Cette fonction d'analyse renvoie la taille d'un (sous-) tableau.

Syntax
{{#complexarraysize:key|options}}
Explanation
  • key (obligatoire) — nom du (sous-) tableau
  • options (optionnel) :
    • top — ne comptez que le nombre d'éléments dans le tableau principal (et non pas récursivement).

Exemples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
Fonction Résultat
{{#casize: foobar}}
9
{{#casize: foobar[1]}}
2
{{#casize: foobar|top}}
3

complexarrayslice

Cette fonction d'analyse peut extraire une tranche de tableau.

Syntax
{{#complexarrayslice:new_key|key|offset|length}}
Explanation
  • new_key (obligatoire) — nom du tableau à créer
  • key (obligatoire) — nom du tableau à segmenter
  • offset (obligatoire) — Avec un décalage positif le nouveau tableau commencera à cet index dans le premier tableau. Si le décalage est négatif, il est compté à partir de la fin du premier tableau.
  • length (optionnel) — longueur du nouveau tableau.

Exemples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar
  • 2
    • boo: bar
    • far: quz
  • 3
    • foo: quux
    • bar: bar
Fonction Résultat
{{#caslice: boofar | foobar | 2 | 1 }}

Ceci rend le troisième élément du tableau

boofar:

  • 0
    • boo: bar
    • far: quz
{{#caslice: boofar | foobar | -1 }}

Cela donne le dernier élément du tableau :

boofar:

  • 0
    • foo: quux
    • bar: bar

complexarraysearch

Cette fonction d'analyse sémantique recherche un mot clé dans un tableau et renvoie la clé correspondant à cette valeur. Renvoie 0 si rien n'est trouvé.

Syntaxe
{{#complexarraysearch:key|keyword}}

Explications
  • key (obligatoire) — nom du tableau dans lequel se fera la recherche
  • keyword (obligatoire) — mot-clé à rechercher.
Examples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar
  • 2
    • boo: bar
    • far: quz
  • 3
    • foo: quux
    • bar: bar
Fonction Résultat
{{#casearch: foobar | quux }}
WSArray[3][foo]
{{#casearch: foobar | bar }}
WSArray[0][foo]

complexarraysearcharray

Cette fonction d'analyse syntaxique recherche un mot clé dans un tableau et crée un nouveau tableau avec les clés en cas de correspondance. S'il n'y a pas de correspondance, elle renvoie 0.

Syntax
{{#complexarraysearcharray:new_key|key|keyword}}
Explanation
  • new_key (obligatoire) — nom du tableau à créer contenant toutes les clés
  • key (obligatoire) — nom du tableau dans lequel se fera la recherche
  • keyword (obligatoire) — mot clé à rechercher.
Examples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar
  • 2
    • boo: bar
    • far: quz
  • 3
    • foo: quux
    • bar: bar
Fonction Résultat
{{#casearcha: boofar | foobar | bar }}

boofar:

  • foobar[0][foo]
  • foobar[1][baz]
  • foobar[1][foo]
  • foobar[2][boo]
  • foobar[3][bar]
{{#casearcha: boofar | foobar | quux }}

boofar:

foobar[3][foo]

Alteration

complexarrayunset

Cette fonction désactive la clé fournie.

Syntax
{{#complexarrayunset: key }}
Explanation
  • key (obligatoire) — clé à désactiver
Examples

On dispose d'un tableau foobar :

  • foo
    • bar
    • qux
  • baz
Fonction Résultat
{{#caunset: foobar[foo][1] }}

foobar:

  • foo
    • bar
  • baz

complexarrayaddvalue

Cette fonction d'analyse syntaxique ajoute une valeur ou un sous-tableau à un tableau existant, ou remplace un sous-tableau existant par cette valeur.

Syntax
{{#complexarrayaddvalue:key|value}}
Explanation
  • key (obligatoire) — nom du sous-tableau à créer
  • value (obligatoire) — une valeur en texte simple ou un sous-tableau dans n'importe quel langage de balisage pris en charge.
Examples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
Fonction Résultat
{{#caadd: foobar[0][bex]|["abc","123"]}}
  • 0
    • foo: bar
    • baz: quz
    • bex
      • abc
      • 123
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
{{#caadd: foobar[3][foo][bar][baz]|bex}}
  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
  • 3
    • foo
      • bar
        • baz: bex
{{#caadd: foobar[0]|["abc","123"]}}
  • 0
    • abc
    • 123
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar

complexarrayreset

Cette fonction d'analyse syntaxique réinitialise un ou tous les tableaux.

Syntax
{{#complexarrayreset:key}}
Explanation
  • key (optionnel) — nom du tableau à désactiver et si ce nom est à vide alors tous les tableaux seront désactivés.

complexarraysort

Cette fonction d'analyse syntaxique trie un tableau.

Syntax
{{#complexarraysort:key|options|sortingkey}}
Explanation
  • key (obligatoire) — tableau à trier
  • options (optionnel) :
    • multisort —tri multisort du tableau
    • asort — tri asort du tableau
    • arsort — tri arsort du tableau
    • krsort — tri krsort du tableau
    • natcasesort — tri natcasesort du tableau
    • natsort — tri natsort du tableau
    • rsort — tri rsort du tableau
    • shuffle — mélange le tableau
    • keysort — trier un tableau à deux dimensions en fonction des valeurs d'une clé du deuxième tableau. Vous pouvez modifier l'ordre à descendant en ajoutant ,desc dans les options (donc keysort,desc).
  • sortingkey (optionnel, nécessaire quand keysort est utilisé) — clé pour trier le tableau quand keysort est utilisé.

Voir la documentation PHP pour les algorithmes de tri.

Examples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
Fonction Résultat
{{#casort: foobar|keysort|foo}}
  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar
  • 2
    • foo: quz
    • baz: bar
{{#casort: foobar|keysort,desc|foo}}
  • 0
    • foo: quz
    • baz: bar
  • 1
    • foo: bar
    • baz: quz
  • 2
    • baz: bar
    • foo: bar
{{#casort: foobar|shuffle}}
  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar

complexarrayunique

Cette fonction d'analyse supprime les clés et les valeurs dupliquées d'un tableau.

Syntax
{{#complexarrayunique:key}}

Explications
  • key (obligatoire) — nom du tableau.

Interaction

complexarraypush

Cette fonction d'analyse rajoute une nouvelle valeur ou un sous-tableau à la fin d'un (sous-) tableau existant.

Syntaxe
{{#complexarraypush:key|value|noparse}}

Explications
  • key (obligatoire) — nom du (sous-) tableau
  • value (obligatoire) — valeur en texte simple ou dans un des langages de balisage pris en charge.
  • noparse (optionnel) — arguments pour dire à l'analyseur ce qu'il faut rechercher dans subject (voir l'utilisation de l'analyseur).

Exemples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
Fonction Résultat
{{#capush: foobar|bex}}
  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
  • 2
    • baz: bar
    • foo: bar
  • test
{{#capush: foobar[1]|bex}}
  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
    • bex
  • 2
    • baz: bar
    • foo: bar
{{#capush: foobar | (("bex":"baz")) }}
  • 0
    • foo: bar
    • baz: quz
  • 1
    • foo: quz
    • baz: bar
    • bex
  • 2
    • baz: bar
    • foo: bar
  • 3
    • bex: baz

complexarrayextract

Cette fonction d'analyse crée un nouveau tableau à partir d'un sous-tableau.

Syntaxe
{{#complexarrayextract: new_key | subarray }}

Explication
  • new_key (obligatoire) — nom du tableau à créer
  • subarray (obligatoire) — sous-tableau à extraire.

Exemples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar
Function Result
{{#caextract: boofar | foobar[0] }}

boofar:

  • 0
    • foo: bar
    • baz: quz

complexarraymerge

Cette fonction d'analyse crée un nouveau tableau en fusionnant deux ou plusieurs tableaux.

Syntaxe
{{#complexarraymerge: new_key | key1 | key2 | ... | keyn | options }}

Explication
  • new_key (obligatoire) — nom du tableau à créer
  • key1 (obligatoire) — nom du premier tableau
  • key2 (obligatoire) — nom du deuxième tableau
  • ...
  • keyn (optionnel) — nom du nième tableau
  • options
    • recursive — fusion récursive

Exemples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar

et un tableau boofar :

  • 0
    • boo: bar
    • far: quz
  • 1
    • foo: quux
    • bar: bar
Fonction Résultat
{{#camerge: farboo | foobar | boofar}}

farboo:

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar
  • 2
    • boo: bar
    • far: quz
  • 3
    • foo: quux
    • bar: bar

complexarraydiff

Cette fonction d'analyse calcule la différence entre deux ou plusieurs tableaux et range le résultat dans un nouveau tableau. Il encode la fonction PHP array_diff_assoc() pour la protéger.

Syntaxe
{{#complexarraydiff: new_key | key1 | key2 | ... | keyn }}

Explications
  • new_key (obligatoire) — nom du tableau à créer
  • key1 (obligatoire) — nom du premier tableau
  • key2 (obligatoire) — nom du deuxième tableau
  • ...
  • keyn (optionnel) — nom du nième tableau

complexarraypusharray

Cette fonction d'analyse crée un nouveau tableau en ajoutant un ou plusieurs tableaux à la fin d'un premier tableau.

Syntaxe
{{#complexarraypusharray:new_key|key1|key2|...|keyn}}

Explications
  • new_key (obligatoire) — nom du tableau à créer
  • key1 (obligatoire) — nom du premier tableau
  • key2 (obligatoire) — nom du deuxième tableau
  • ...
  • keyn (optionnel) — nom du nième tableau

Exemples

On dispose d'un tableau foobar :

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar

et un tableau boofar :

  • 0
    • boo: bar
    • far: quz
  • 1
    • foo: quux
    • bar: bar
Fonction Résultat
{{#capusharray: farboo | foobar | boofar}}

farboo:

  • 0
    • 0
      • foo: bar
      • baz: quz
    • 1
      • baz: bar
      • foo: bar
  • 1
    • 0
      • boo: bar
      • far: quz
    • 1
      • foo: quux
      • bar: bar

Itération

complexarraymap

Cette fonction d'analyseur fait une itération sur un tableau et associe chaque valeurs à une clé.

Syntaxe
{{#complexarraymap:key|mapping_key|subject|delimiter|show}}

Explication
  • key (obligatoire) — nom du tableau à analyser pour extraire les clés
  • mapping_key (obligatoire) — mot clé à remplacer dans le sujet
  • subject (obligatoire) — chaîne sur laquelle se fera l'analyse des correspondances
  • delimiter (optionnel) — délimiteur ajouté à chaque ligne sauf la dernière
  • show (optionnel) — initialiser à true pour afficher la clé de correspondance lorsqu'aucune valeur de chaîne n'existe pour cette clé.

Exemples

On dispose d'un tableau foobar :

  • 0
    • bar
    • quz
  • 1
    • bar
    • bar
  • 2
    • bar
    • quz
  • 3
    • quux
Fonction Résultat
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1]<br/> }}

What the bar is this quz
What the bar is this bar
What the bar is this quz
What the quux is this

{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1]<br/> | true }}

What the bar is this quz
What the bar is this bar
What the bar is this quz
What the quux is this @@@[1]

{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1] | <br/> | true }}

What the bar is this quz
What the bar is this bar
What the bar is this quz
What the quux is this @@@[1]

complexarraymaptemplate

Cette fonction d'analyse associe le contenu d'un tableau dans un modèle.

Syntaxe
{{#complexarraymaptemplate:key|template}}

Explication
  • key (obligatoire) — nom du tableau à analyser
  • template (obligatoire) — nom du modèle a associer au tableau

Exemples

Nous avons respectivement un tableau appelé foobar, un tableau appelé boofar et un tableau appelé bazbar :

foobar:

  • 0
    • foo: bar
    • baz: quz
  • 1
    • baz: bar
    • foo: bar
  • 2
    • foo: quz
    • baz: bar
    • bar
      • bex
      • box

boofar:

  • foobar
  • bazbar
  • boofar

bazbar:

  • foo: bar
  • boo: far
Fonction Résultat
{{#catemplate: foobar|Template}}
{{Template|foo=bar|baz=quz}}
{{Template|baz=bar|foo=bar}}
{{Template|foo=quz|baz=bar|bar=["bex","box"]}}
{{#catemplate: boofar|Template}}
{{Template|foobar|bazbar|boofar}}
{{#catemplate: bazbar|Template}}
{{Template|foo=bar|boo=far}}

Anonymous

Ces fonctions utilisent des tableaux anonymes. La fonction gère à la fois la définition et la sortie du tableau. Vous n'avez pas besoin de définir un tableau à l'avance.

complexarrayarraymap

Cette fonction d'analyse est très similaire à #complexarraymapcomplexarraymap, mais l'entrée et la sortie sont gérées dans la même fonction (ce qui la rend anonyme).

Syntaxe
{{#complexarrayarraymap: value | delimiter | variable | formula | new_delimiter }}

Explication
  • value (obligatoire) — valeur à segmenter
  • delimiter (obligatoire) — délimiteur à utiliser pour la segmentation
  • variable (obligatoire) — chaîne à remplacer dans formula
  • formula (obligatoire) — chaîne où variable est à remplacer
  • new_delimiter (obligatoire) — délimiteur entre les résultats.

Exemples
Fonction Résultat
{{#caamap: a, b, c | , | @@ | Current variable: @@ | !<br/>}}
Current variable: a!<br/>
Current variable: b!<br/>
Current variable: c
{{#caamap: a; b; c | ; | ! | Just ! test | <br/>}}
Just a test<br/>
Just b test<br/>
Just c test

complexarrayparent

Cette fonction renvoie la clé du parent de la clé donnée.

Syntaxe
{{#complexarrayparent: key }}

Explication
  • key (obligatoire) — clé à partir de laquelle la clé parent doit être renvoyée

Exemples
Fonction Résultats
{{#caparent: foobar[0][1][test] }}
foobar[0][1]

Opérateur Wairudokado

L'opérateur Wairudokado (en japonais: ワイルドカード, prononcé Wairudokādo, signifiant joker; en hommage à l'opérateur de résolution de vue de PHP) est un opérateur puissant qui donne aux utilisateurs la possibilité d'utiliser les jokers pour manipuler ou imprimer les sous-tableaux.


Exemple

Cet opérateur peut être utilisé sur chaque fonction d'analyseur qui prend en charge les sous-tableaux (comme #complexarrayprint). Supposons que nous disposions du tableau foobar :

  • 0
    • name: Foo
  • 1
    • name: Bar
  • 2
    • name: Baz
  • 3
    • name: Bex

Et nous voulions imprimer chaque valeur de name. Nous pouvons utiliser un #complexarraymap pour faire une itération sur l'ensemble et imprimer chaque valeur séparément, mais nous pouvons également utiliser un opérateur Wairudokado dans la fonction #complexarrayprint.

Function Result
{{#caprint: foobar[*][name]}}
  • Foo
  • Bar
  • Baz
  • Bex
Lorsqu'un opérateur Wairudokado est à la fin du pointeur, il est ignoré. Les opérateurs séquentiels Wairudokado sont interprétés comme un seul.

Semantic MediaWiki

Cette impression de résultats nécessite Semantic MediaWiki 3.0 ou supérieur.

Cette extension présente un nouveau format pour afficher les résultats Semantic MediaWiki. Pour le nouveau format, utiliser format=complexarray. Parce que l'impression du résultat définit un nouveau complexarray, vous devez fournir un nom pour ce tableau en utilisant name=<name>; si name est laissé vide, l'impression du résultat imprimera le tableau en tant que WSON.

Variables sémantiques

Une liste de variables sémantiques est incluse dans complexarray lorsque vous demandez une liste de pages. Les variables suivantes sont incluses :

catitle
titre de la page
cafullurl
URL complète de la page
canamespace
espace de noms dans lequel la page existe
caexists
indique si la page existe ou non (0/1)
cadisplaytitle
displaytitle de la page

Paramètres supplémentaires

WSArrays définit deux nouveaux paramètres :

name
nom du tableau à créer
simple
option pour masquer les variables sémantiques des résultats des pages ainsi que pour cacher les préfixes mailto: sur les résultats des courriels (valeurs : yes / no, par défaut : yes)

Voir les tableaux complexes comme des tables

Si Semantic MediaWiki génère une table lorsque le format est complexarray, vous devez d'abord vérifier si vous avez initialisé $wfEnableResultPrinter à true. Si c'est le cas et que cela ne fonctionne toujours pas, WSArrays n'a peut-être pas pu créer un lien symbolique du dossier SemanticMediaWiki au dossier WSArrays. Ce lien peut être créé manuellement en copiant le fichier ComplexArrayPrinter.php du dossier racine de l'extension vers SemanticMediaWiki/src/Query/ResultPrinters.

Ecrire des extensions

Alors que WSArrays fournit de nombreuses fonctions pour manipuler et afficher des tableaux, parfois elles ne suffisent pas. Pour cette raison, nous fournissons une interface pour étendre facilement la fonctionnalité des WSArrays avec de nouvelles fonctions d'analyse.

Les extensions sont rangées dans le dossier extensions/. Chaque extension est implémentée comme une classe dérivée de Extension.php. Le nom du fichier dans lequel cette classe sera trouvée doit être le même que le nom de la classe elle-même (sensible à la casse). Par exemple pour la classe ExampleClass on aura ExampleClass.php. La classe doit implémenter au moins les méthodes suivantes :

<?php

class ExampleClass extends Extension {
    /**
     * Renvoie le nom de cette fonction d'analyseur.
     *
     * @return string
     */
    public function getName() {
        return 'exampleclass';
    }

    /**
     * Doit renvoyer un tableau contenant des alias de cette fonction d'analyse.
     *
     * @return array
     */
    public function getAliases() {
        return [
            'caexample',
            'caexampleclass'
        ];
    }

    /** 
     * Doit retourner soit 'sfh' soit 'normal'. 
     * Lorsque 'sfh' est renvoyé, la fonction setFunctionHook est appelée par Parser::SFH_OBJECT_ARGS
     * en tant que paramètre, permettant une intégration plus profonde avec l'analyseur.
     *
     * @return string
     */
    public function getType() {
        return 'sfh';
    }

    /**
     * Cette fonction est appelée par l'analyseur.
     *
     * @return mixed
     */
    public static function getResult( Parser $parser, $arg1, $arg2, ...) {
        return 'Foobar';
    }
}

?>

Renvoyer le résultat

getResult() est exécuté par l'accroche de l'analyseur. Vous pouvez lire ici comment écrire des fonctions d'analyseur. La documentation ci-dessous est spécifique à WSArrays.

Gérer les tableaux

Tous les tableaux de WSArrays doivent être stockés en tant qu'objet ComplexArray. Si vous voulez manipuler un tableau existant, vous devez convertir l'objet ComplexArray en array, manipuler le tableau, puis le convertir à nouveau en objet ComplexArray.

public static function getResult( Parser $parser, $arg1, $arg2, $arg3 ) {
    // $arg1 contient le nom d'un tableau existant
    // getArray() renvoie le tableau.
    $array = WSArrays::$arrays[$arg1]->getArray();

    // Utiliser le tableau...

    // Les tableaux sont stockés dans la variable $arrays de la classe WSArrays.
    // Si vous ne sauvegardez pas le tableau en tant que ''ComplexArray'', les fonctions d'analyse existantes ne fonctionneront pas avec ce tableau.
    WSArrays::$arrays[$arg1] = new ComplexArray( $array );

    return null;
}

ou en utilisant SFH_OBJECT_ARGS :

public static function getResult( Parser $parser, $frame, $args ) {
    // Convertir le premier élément du tableau $args en chaîne.
    // Omettre PPFrame::NO_ARGS | PPFrame::NO_TEMPLATES si vous avez besoin que l'analyseur traite d'abord les arguments.
    // Vous pouvez aussi utiliser GlobalFunctions::getSFHValue() et GlobalFunctions::rawValue().
    if ( isset( $args[0] ) ) {
        $arg1 = trim( $frame->expand( $args[0], PPFrame::NO_ARGS | PPFrame::NO_TEMPLATES ) );
    }

    // $arg1 contient le nom d'un tableau existant.
    $array = WSArrays::$arrays[$arg1]->getArray();

    // Traiter le tableau...

    // Les tableaux sont rangés dans la variable $arrays, située dans la classe WSArrays.
    // Si vous ne sauvegardez pas le tableau en tant que ''ComplexArray'', les fonctions d'analyse existantes ne fonctionneront pas avec ce tableau.
    WSArrays::$arrays[$arg1] = new ComplexArray($array);

    return null;
}

Enregistrer l'extension

Pour activer l'extension, vous devez ajouter le nom de l'extension et les alias dans WSArrays.i18n.php.

Ajoutez ceci à $magicWords['en'] :

'<extensionname>' => [ 0, '<extensionname>' ],
'<alias1>' => [ 0, '<alias1>' ],
'<alias2>' => [ 0, '<alias2>' ],
...

Usage de l'analyseur

WSArrays utilise l'analyseur de différentes manières. Pour utiliser WSArrays au maximum, il est important de le savoir. Ceci ne s'applique qu'aux fonctions d'analyse suivantes :

Comment WSArrays utilise l'analyseur

WSArrays gère l'analyseur en utilisant SFH_OBJECT_ARGS. De cette façon, les arguments de l'analyseur sont passés comme des objets PPNode au lieu de texte simple. Cela permet l'expansion conditionnelle de l'arbre d'analyse (voir doc.wikimedia.org pour plus d'informations). En utilisant SFH_OBJECT_ARGS nous pouvons dire à l'analyseur de ne pas traiter les éléments et de renvoyer le texte brut fourni par l'utilisateur, que nous pouvons ensuite analyser dans WSArrays.

Comment contrôler l'utilisation

Différentes personnes ont des besoins différents, c'est pourquoi nous vous permettons de contrôler l'utilisation de l'analyseur. Une fois de plus, cette documentation ne s'applique qu'aux fonctions d'analyseur listées ci-dessus.

Par défaut, toutes les entrées sont automatiquement analysées par l'analyseur syntaxique avant d'être transférées à WSArrays (sauf pour 'map' dans #complexarraymap et #complexarrayprint). Cela vous permet d'utiliser les paramètres du modèle ainsi que les mots magiques et les modèles lors de la manipulation ou la définition des tableaux. Mais ce n'est pas toujours ce que vous voulez. Par exemple, quand vous voulez utiliser un modèle très complexe à l'intérieur d'un tableau, et que vous ne voulez pas tout casser lorsque vous utilisez #complexarrayprint dessus, vous pouvez dire à WSArrays de ne pas analyser l'entrée. Si vous imprimez ensuite le tableau, le modèle est imprimé comme s'il était inclus entre des balises nowiki.

Qu'adviendra-t-il si on souhaite faire l'analyse syntaxique du modèle ultérieurement ?

Ne pas analyser entièrement le modèle est probablement ce que vous ne voulez pas. WSArrays indique à l'analyseur de traiter l'élément quand c'est nécessaire, par exemple lorsqu'il est utilisé sur une carte ou lorsqu'on l'imprime comme une valeur.

Arguments

Vous pouvez inclure les arguments suivants en tant que liste séparée par des virgules dans le paramètre noparse de toute fonction applicable.

Argument Résultat
NO_IGNORE Inclure la constante PPFrame::NO_IGNORE dans l'expansion du texte.
NO_ARGS Inclure la constante PPFrame::NO_ARGS dans l'expansion du texte.
NO_TEMPLATES Inclure la constante PPFrame::NO_TEMPLATES dans l'expansion du texte pour indiquer à l'analyseur de ne pas traiter les modèles.
NO_TAGS Inclure la constante PPFrame::NO_TAGS dans l'expansion du texte pour indiquer à l'analyseur de ne pas traiter les balises.

Utiliser WSArrays dans d'autres extensions

WSArrays fournit une interface pour utiliser, manipuler et créer facilement des tableaux à partir de toute extension du wiki.

Initialisation

Pour utiliser l'interface, inclure ainsi la classe ComplexArrayWrapper dans votre extension :

include_once "/dir/to/ComplexArrayWrapper.php";

$interface = new ComplexArrayWrapper();

Obtenir le contenu d'un tableau

Le contenu du tableau foobar peut être obtenu ainsi :

$array = $interface->on("foobar")->get();

Obtenir le contenu d'un sous-tableau

Le contenu de foobar[Foo][Bar] peut être obtenu ainsi :

$array = $interface->on("foobar")->in(["Foo", "Bar"])->get();

Modifier le contenu d'un tableau

Le contenu de l'ensemble foobar peut être modifié ainsi :

$interface->on("foobar")->set(["foo", "bar" => ["baz", "bar"]]);

Le contenu d'une valeur spécifique ou d'un sous-ensemble peut également être modifié ainsi :

$interface->on("foobar")->in(["Foo", "Bar"])->set("Specific value");

// ou

$interface->on("foobar")->in(["Foo", "Bar"])->set(["sub", "array"]);
Si le tableau ou le sous-tableau n'existent pas, ils sont créés automatiquement. C'est aussi la manière préférée de créer un nouveau tableau.

Désactiver un tableau

Un tableau peut être désactivé ainsi :

$interface->on("foobar")->unsetArray();

Installation

Configuration

WSArrays possède quelques paramètres de configuration.

$wfSkipVersionControl
option pour sauter le contrôle de version et de forcer l'initialisation de WSArrays, accepte un booléen (valeur par défaut : false). Ceci peut bloquer votre wiki.
$wfEnableResultPrinter
Option pour activer l'imprimante des résultats Semantic MediaWiki, accepte un booléen (valeur par défaut: false). En initialisant ceci à true, si vous n'avez pas correctement installé l'imprimante de résultat (voir #Installation) votre wiki ne fonctionnera pas.

Voir aussi