Manual:Funciones de análisis sintáctico

From MediaWiki.org
Jump to navigation Jump to search
This page is a translated version of the page Manual:Parser functions and the translation is 72% complete.
Outdated translations are marked like this.
Other languages:
Bahasa Indonesia • ‎Deutsch • ‎English • ‎Tiếng Việt • ‎dansk • ‎español • ‎français • ‎polski • ‎português do Brasil • ‎русский • ‎ไทย • ‎中文 • ‎日本語 • ‎한국어
OOjs UI icon puzzle-ltr.svg Extensiones: Desarrollo Tag extensions Funciones de análisis sintáctico Hooks Páginas especiales Apariencias Palabras mágicas API Content models
MediaWiki extensions

Las funciones de análisis sintáctico (en inglés, parser functions), agregadas en MediaWiki 1.7, son un tipo de extensiones que están integradas estrechamente con el analizador sintáctico. La expresión parser function no debe confundirse con Extensión:ParserFunctions , que son una colección de funciones sencillas de análisis sintáctico. (Ver Ayuda:Extensión:ParserFunctions para información sobre estas.)

Descripción

Mientras que una extensión de marcado está concebida para tomar texto sin procesar y devolver HTML al navegador, una función de análisis puede «interactuar» con otros elementos wiki de la página. Por ejemplo, la salida de una función de análisis se podría usar como parámetro de una plantilla o en la construcción de un enlace.

La sintaxis típica de una función de análisis es:

{{ #functionname: param1 | param2 | param3 }}

Para más información, consulta la documentación de Parser::setFunctionHook ( $id, $callback, $flags = 0 ). Según esta documentación,

The callback function should have the form:
function myParserFunction( &$parser, $arg1, $arg2, $arg3 ) { ... }
O con SFH_OBJECT_ARGS:
function myParserFunction( $parser, $frame, $args ) { ... }"

Crear una función de análisis es ligeramente más complejo que crear una nueva etiqueta porque el nombre de la función debe ser una palabra mágica, una palabra clave que sea compatible con el uso de alias y localización.

Ejemplo simple

A continuación hay un ejemplo de una extensión que crea una función de análisis.

El registro va a extension.json; el código, a includes/ExampleExtension.php:

{
	"name": "ExampleExtension",
	"author": "Me",
	"version": "1.0.0",
	"url": "https://www.mediawiki.org/wiki/Extension:ExampleExtension",
	"descriptionmsg": "exampleextension-desc",
	"license-name": "GPL-2.0-or-later",
	"type": "parserhook",
	"MessagesDirs": {
		"ExampleExtension": [
			"i18n"
		]
	},
	"AutoloadClasses": {
		"ExampleExtensionHooks": "src/ExampleExtensionHooks.php"
	},
	"ExtensionMessagesFiles": {
		"ExampleExtensionMagic": "ExampleExtension.i18n.php"
	},
	"Hooks": {
		"ParserFirstCallInit": "ExampleExtensionHooks::onParserFirstCallInit"
	},
	"manifest_version": 1
}
<?php
class ExampleExtensionHooks {
   // Register any render callbacks with the parser
   public static function onParserFirstCallInit( Parser $parser ) {

      // Create a function hook associating the "example" magic word with renderExample()
      $parser->setFunctionHook( 'example', [ self::class, 'renderExample' ] );
   }

   // Muestra la salida de {{#example:}}.
   public static function renderExample( Parser $parser, $param1 = '', $param2 = '', $param3 = '' ) {

      // Los parámetros de entrada son wikitexto con las plantillas expandidas.
      // La salida también debería estar en forma de wikitexto.
      $output = "param1 is $param1 and param2 is $param2 and param3 is $param3";

      return $output;
   }
}

Otro archivo, ExampleExtension.i18n.php, deberá contener:

<?php
/**
 * @license GPL-2.0-or-later
 * @author Your Name (YourUserName)
 */

$magicWords = [];

/** English
 * @author Your Name (YourUserName)
 */
$magicWords['en'] = [
   'example' => [ 0, 'example' ],
];

Con esta extensión activada,

  • {{#example: hello | hi | hey}}

produce:

  • param1 is hello and param2 is hi and param3 is hey
Este arreglo magicWords no es opcional. Si se omite, la función de análisis sencillamente no funcionará; el {{#example: hello | hi}} se mostrará como si la extensión no estuviera instalada.

Funciones más largas

For longer functions, you may want to split the hook functions out to a _body.php or .hooks.php file and make them static functions of a class. Then you can load the class with $wgAutoloadClasses and call the static functions in the hooks; e.g.:

Agrega esto en tu archivo extension.json:

"Hooks": {
	"ParserFirstCallInit": "ExampleExtensionHooks::onParserFirstCallInit"
},
"AutoloadClasses": {
	"ExampleExtensionHooks": "src/ExampleExtensionHooks.php"
}

Luego agrega esto en tu archivo src/ExampleExtensionHooks.php:

class ExampleExtensionHooks {
      public static function onParserFirstCallInit( Parser $parser ) {
           $parser->setFunctionHook( 'example', [ self::class, 'renderExample' ] );
      }
}

Caching

Al igual que con extensiones de marcado, se puede usar $parser->disableCache() para deshabilitar la caché para extensiones dinámicas. This has a significant negative impact on performance, so only use when necessary.

Interfaz del analizador

Control del análisis sintáctico de la salida

Para que el wikitexto devuelto por tu función de análisis esté completamente analizado (incluyendo las expansiones de plantillas), define la opción noparse como falsa en la salida.

return [ $output, 'noparse' => false ];

Parece ser que el valor predeterminado para noparse cambió de falso a verdadero, al menos en algunos casos, en algún momento en torno a la versión 1.12.

En cambio, para que tu función de análisis devuelva HTML no analizado, en lugar de wikitexto, usa lo siguiente:

return [ $output, 'noparse' => true, 'isHTML' => true ];

Sin embargo,

This is {{#example:hello | hi | hey }} a test.

producirá algo así:

This is

param1 is hello and param2 is hi and param3 is hey a test.

Esto se debe a un caso de programación en duro por el que se le prefija un doble retorno de carro, \n\n, a la salida de las funciones de análisis. Para evitar esto y asegurar que el código HTML se muestre en la misma línea que el texto circundante, puedes usar esto:

return $parser->insertStripItem( $output, $parser->mStripState );

Nombramiento

Por defecto, MW añade una almohadilla («#») al nombre de cada función de análisis. Para suprimir este añadido (y obtener una función de análisis sin el prefijo «#»), debes incluir la constante SFH_NO_HASH en el argumento opcional de banderas en setFunctionHook, como se describe más adelante.

Al elegir un nombre sin almohadilla prefijada, ten en cuenta que ya no es posible transcluir una página con un nombre que empiece por ese nombre de función seguido del carácter dos puntos. En particular, evita nombres de función iguales al nombre de un espacio de nombres. En caso de que la transclusión interwiki [1] esté habilitada, también debes evitar los nombres de función iguales a un prefijo interwiki.

The setFunctionHook hook

Para más información sobre la interfaz del analizador, consulta la documentación de setFunctionHook en includes/Parser.php. Aquí se muestra una copia (posiblemente obsoleta) de estos comentarios:

function setFunctionHook( $id, $callback, $flags = 0 ) Parámetros:

  • string $id - el identificador de la palabra mágica
  • mixed $callback - The callback function (and object) to use
  • integer $flags - Optional, set it to the SFH_NO_HASH constant to call the function without "#".

Return value: The old callback function for this name, if any

Create a function, e.g., {{#sum:1|2|3}}. The callback function should have the form:

function myParserFunction( $parser, $arg1, $arg2, $arg3 ) { ... }

The callback may either return the text result of the function, or an array with the text in element 0, and a number of flags in the other elements. The names of the flags are specified in the keys. Valid flags are:

found 
El texto devuelto es válido, deja de procesar la plantilla. Esto está activado por defecto.
nowiki 
El marcado wiki en el valor de retorno debe escaparse
noparse 
Las etiquetas HTML inseguras no se deben suprimir, etc.
noargs 
No reemplaces argumentos entre triples llaves en el valor de retorno
isHTML 
El valor devuelto está en HTML, protégelo contra transformaciones a wikitexto

Parámetros nombrados

Las funciones de análisis no permiten el uso de parámetros nombrados de la manera en que lo hacen las plantillas y extensiones de marcado, pero a veces puede ser útil imitarlos. Los usuarios a menudo están acostumbrados a usar barras verticales ( | ) para separar argumentos, así que está bien poder hacerlo también en el contexto de las funciones de análisis. He aquí un ejemplo sencillo de cómo conseguirlo:

function ExampleExtensionRenderParserFunction( &$parser ) {
	// Suppose the user invoked the parser function like so:
	// {{#myparserfunction: foo=bar | apple=orange | banana }}

	$options = extractOptions( array_slice( func_get_args(), 1 ) );

	// Now you've got an array that looks like this:
	// [foo] => 'bar'
	// [apple] => 'orange'
	// [banana] => true
	// Continue writing your code...
}

/**
 * Converts an array of values in form [0] => "name=value"
 * into a real associative array in form [name] => value
 * If no = is provided, true is assumed like this: [name] => true
 *
 * @param array string $options
 * @return array $results
 */
function extractOptions( array $options ) {
	$results = [];
	foreach ( $options as $option ) {
		$pair = array_map( 'trim', explode( '=', $option, 2 ) );
		if ( count( $pair ) === 2 ) {
			$results[ $pair[0] ] = $pair[1];
		}
		if ( count( $pair ) === 1 ) {
			$results[ $pair[0] ] = true;
		}
	}
	return $results;
}

Véase también