Extension:WSArrays
Cette extension n'est en ce moment pas activement maintenue ! Même si elle reste opérationnelle, les rapports de bogue ou les demandes de nouvelles fonctionnalités risquent de ne plus être pris en compte. |
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 | GitLab: Note: |
|
|
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
Fonction | Résultat |
---|---|
{{#caprint: foobar}} |
|
{{#caprint: foobar[0]}} |
|
{{#caprint: foobar[3]}} |
|
{{#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:
|
{{#caslice: boofar | foobar | -1 }} |
Cela donne le dernier élément du tableau : boofar:
|
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:
|
{{#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:
|
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"]}} |
|
{{#caadd: foobar[3][foo][bar][baz]|bex}} |
|
{{#caadd: foobar[0]|["abc","123"]}} |
|
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}} |
|
{{#casort: foobar|keysort,desc|foo}} |
|
{{#casort: foobar|shuffle}} |
|
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}} |
|
{{#capush: foobar[1]|bex}} |
|
{{#capush: foobar | (("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:
|
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:
|
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:
|
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 |
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1]<br/> | true }} |
What the bar is this quz |
{{#camap: foobar | @@@ | What the @@@[0] is this @@@[1] | <br/> | true }} |
What the bar is this quz |
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]}} |
|
Semantic MediaWiki
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"]);
Désactiver un tableau
Un tableau peut être désactivé ainsi :
$interface->on("foobar")->unsetArray();
Installation
- Téléchargez et placez le(s) fichier(s) dans un répertoire appelé
WSArrays
dans votre dossierextensions/
. - Ajoutez le code suivant à la fin de votre fichier LocalSettings.php :
wfLoadExtension( 'WSArrays' );
- Configurer si nécessaire.
- Fait – Accédez à Special:Version sur votre wiki pour vérifier que l'extension a bien été installée.
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
- Extension Arrays - permet de travailler avec des tableaux simples.