/**
* Method for handling the declare parser function.
*
* @since 1.5.3
*
* @param Parser $parser
* @param PPFrame $frame
* @param array $args
*/
public static function render(Parser &$parser, PPFrame $frame, array $args)
{
if ($frame->isTemplate()) {
foreach ($args as $arg) {
if (trim($arg) !== '') {
$expanded = trim($frame->expand($arg));
$parts = explode('=', $expanded, 2);
if (count($parts) == 1) {
$propertystring = $expanded;
$argumentname = $expanded;
} else {
$propertystring = $parts[0];
$argumentname = $parts[1];
}
$property = SMWPropertyValue::makeUserProperty($propertystring);
$argument = $frame->getArgument($argumentname);
$valuestring = $frame->expand($argument);
if ($property->isValid()) {
$type = $property->getPropertyTypeID();
if ($type == '_wpg') {
$matches = array();
preg_match_all('/\\[\\[([^\\[\\]]*)\\]\\]/u', $valuestring, $matches);
$objects = $matches[1];
if (count($objects) == 0) {
if (trim($valuestring) !== '') {
SMWParseData::addProperty($propertystring, $valuestring, false, $parser, true);
}
} else {
foreach ($objects as $object) {
SMWParseData::addProperty($propertystring, $object, false, $parser, true);
}
}
} elseif (trim($valuestring) !== '') {
SMWParseData::addProperty($propertystring, $valuestring, false, $parser, true);
}
// $value = SMWDataValueFactory::newPropertyObjectValue( $property->getDataItem(), $valuestring );
// if (!$value->isValid()) continue;
}
}
}
} else {
// @todo Save as metadata
}
global $wgTitle;
if (!is_null($wgTitle) && $wgTitle->isSpecialPage()) {
global $wgOut;
SMWOutputs::commitToOutputPage($wgOut);
} else {
SMWOutputs::commitToParser($parser);
}
return '';
}
/**
* Triple brace replacement -- used for template arguments
* @private
*
* @param array $piece
* @param PPFrame $frame
*
* @return array
*/
public function argSubstitution($piece, $frame)
{
$error = false;
$parts = $piece['parts'];
$nameWithSpaces = $frame->expand($piece['title']);
$argName = trim($nameWithSpaces);
$object = false;
$text = $frame->getArgument($argName);
if ($text === false && $parts->getLength() > 0 && ($this->ot['html'] || $this->ot['pre'] || $this->ot['wiki'] && $frame->isTemplate())) {
# No match in frame, use the supplied default
$object = $parts->item(0)->getChildren();
}
if (!$this->incrementIncludeSize('arg', strlen($text))) {
$error = '<!-- WARNING: argument omitted, expansion size too large -->';
$this->limitationWarn('post-expand-template-argument');
}
if ($text === false && $object === false) {
# No match anywhere
$object = $frame->virtualBracketedImplode('{{{', '|', '}}}', $nameWithSpaces, $parts);
}
if ($error !== false) {
$text .= $error;
}
if ($object !== false) {
$ret = array('object' => $object);
} else {
$ret = array('text' => $text);
}
return $ret;
}
/**
* print an array.
* foreach element of the array, print 'subject' where all occurrences of 'search' is replaced with the element,
* and each element print-out is deliminated by 'delimiter'
* The subject can embed parser functions; wiki links; and templates.
* usage:
* {{#arrayprint:arrayid|delimiter|search|subject|options}}
* examples:
* {{#arrayprint:b}} -- simple
* {{#arrayprint:b|<br/>}} -- add change line
* {{#arrayprint:b|<br/>|@@@|[[@@@]]}} -- embed wiki links
* {{#arrayprint:b|<br/>|@@@|{{#set:prop=@@@}} }} -- embed parser function
* {{#arrayprint:b|<br/>|@@@|{{f.tag{{f.print.vbar}}prop{{f.print.vbar}}@@@}} }} -- embed template function
* {{#arrayprint:b|<br/>|@@@|[[name::@@@]]}} -- make SMW links
*/
static function pfObj_arrayprint(Parser &$parser, PPFrame $frame, $args)
{
global $egArraysCompatibilityMode, $egArraysExpansionEscapeTemplates;
// Get Parameters
$arrayId = isset($args[0]) ? trim($frame->expand($args[0])) : '';
$delimiter = isset($args[1]) ? trim($frame->expand($args[1])) : self::$mDefaultSep;
/*
* PPFrame::NO_ARGS and PPFrame::NO_TEMPLATES for expansion make a lot of sense here since the patterns getting replaced
* in $subject before $subject is being parsed. So any template or argument influence in the patterns wouldn't make any
* sense in any sane scenario.
*/
$search = isset($args[2]) ? trim($frame->expand($args[2], PPFrame::NO_ARGS | PPFrame::NO_TEMPLATES)) : null;
$subject = isset($args[3]) ? trim($frame->expand($args[3], PPFrame::NO_ARGS | PPFrame::NO_TEMPLATES)) : null;
// options array:
$options = isset($args[4]) ? self::parse_options($frame->expand($args[4])) : array();
// get array, null if non-existant:
$array = self::get($parser)->getArray($arrayId);
if ($array === null) {
// array we want to print doesn't exist!
if (!$egArraysCompatibilityMode) {
return '';
} else {
// COMPATIBILITY-MODE
return "undefined array: {$arrayId}";
}
}
// if there is no subject, there is no point in expanding. Faster!
if ($subject === null) {
if (!$egArraysCompatibilityMode && $egArraysExpansionEscapeTemplates !== null) {
// we can ignore options here, since if subject is null, options won't be set as well!
return trim(implode($delimiter, $array));
} else {
// COMPATIBILITY-MODE
// set search and subject so the old routine can be done
$search = $subject = '@@@@';
}
}
$rendered_values = array();
foreach ($array as $val) {
if (!$egArraysCompatibilityMode) {
// NO COMPATIBILITY-MODE
/**
* escape the array value so it won't destroy the users wiki markup expression.
*/
$val = self::escapeForExpansion($val);
}
// replace place holder with current value:
$rawResult = str_replace($search, $val, $subject);
/*
* $subjectd still is un-expanded (this allows to use some parser functions like
* {{FULLPAGENAME:@@@@}} directly without getting parsed before @@@@ is replaced.
* Expand it so we replace templates like {{!}} which we need for the final parse.
*/
$rawResult = $parser->preprocessToDom($rawResult, $frame->isTemplate() ? Parser::PTD_FOR_INCLUSION : 0);
$rawResult = trim($frame->expand($rawResult));
$rendered_values[] = $rawResult;
}
// follow special print options:
switch (self::array_value($options, 'print')) {
case 'pretty':
// pretty list print with ' and ' connecting the last two items
if ($delimiter === '') {
// '' as delimiter isn't pretty, so in this case we take the (languages) default
$output = self::arrayToText($rendered_values);
} else {
$output = self::arrayToText($rendered_values, $delimiter);
}
break;
default:
// normal print with one delimiter, might be the languages default
$output = implode($delimiter, $rendered_values);
break;
}
if ($egArraysCompatibilityMode || $egArraysExpansionEscapeTemplates === null) {
// COMPATIBLITY-MODE:
/*
* don't leave the final parse to Parser::braceSubstitution() since there are some special cases where it
* would produce unexpected output (it uses a new child frame and ignores whether the frame is a template!)
*/
$output = $parser->preprocessToDom($output, $frame->isTemplate() ? Parser::PTD_FOR_INCLUSION : 0);
$output = $frame->expand($output);
}
return trim($output);
}
/**
* Generic function handling '#forargs' and '#fornumargs' as one
*/
protected static function perform_forargs(Parser &$parser, PPFrame $frame, array $funcArgs, array $templateArgs, $prefix = '')
{
// if not called within template instance:
if (!$frame->isTemplate()) {
return '';
}
// name of the variable to store the argument name:
$keyVar = array_shift($funcArgs);
$keyVar = $keyVar !== null ? trim($frame->expand($keyVar)) : '';
// name of the variable to store the argument value:
$valVar = array_shift($funcArgs);
$valVar = $valVar !== null ? trim($frame->expand($valVar)) : '';
// unexpanded code:
$rawCode = array_shift($funcArgs);
$rawCode = $rawCode !== null ? $rawCode : '';
$output = '';
// if prefix contains numbers only or isn't set, get all arguments, otherwise just non-numeric
$tArgs = preg_match('/^([1-9][0-9]*)?$/', $prefix) > 0 ? $frame->getArguments() : $frame->getNamedArguments();
foreach ($templateArgs as $argName => $argVal) {
// if no filter or prefix in argument name:
if ($prefix !== '' && strpos($argName, $prefix) !== 0) {
continue;
}
if ($keyVar !== $valVar) {
// variable with the argument name without prefix as value:
self::setVariable($parser, $keyVar, substr($argName, strlen($prefix)));
}
// variable with the arguments value:
self::setVariable($parser, $valVar, $argVal);
// expand current run:
$output .= trim($frame->expand($rawCode));
}
return $output;
}
/**
* Define an hash filled with all given parameters of the current template.
* In case there are no parameters, the hash will be void.
*/
static function pfObj_parameterstohash(&$parser, PPFrame $frame, $args)
{
if (!isset($args[0])) {
return '';
}
$store = self::get($parser);
$hashId = trim($frame->expand($args[0]));
$store->setHash($hashId);
// create empty hash table
// in case the page is not used as template i.e. when displayed on its own
if (!$frame->isTemplate()) {
return '';
}
$templateArgs = $frame->getArguments();
foreach ($templateArgs as $argName => $argVal) {
// one hash value for each parameter
$store->setHashValue($hashId, $argName, $argVal);
}
return '';
}
