mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/Cite
synced 2024-09-27 04:07:11 +00:00
70e14ebaeb
This stores references in page_props during links update in compressed JSON form. If the size is too big, it's broken up in several parts to fit, which is very unlikely to occur more than once. When the data is retrieved from the db, it's always cached. If set in config, it's also saved in the cache on parse. If not, the cache is invalidated when references are modified. Uses cases include : section preview to also show refs defined elsewhere on the page (T124840) and MobileFrontend (T123328). For the later, this still needs API support (T123290). There's a soft dependency on the core change I0c73b3d181f32502da75687857ae9aeff731f559. Bug: T125329 Change-Id: I7b106254b8f264f93b0f0c9cfa89f65adeeea4f0
1383 lines
40 KiB
PHP
1383 lines
40 KiB
PHP
<?php
|
|
|
|
// @codingStandardsIgnoreStart
|
|
/**#@+
|
|
* A parser extension that adds two tags, <ref> and <references> for adding
|
|
* citations to pages
|
|
*
|
|
* @ingroup Extensions
|
|
*
|
|
* @link http://www.mediawiki.org/wiki/Extension:Cite/Cite.php Documentation
|
|
* @link http://www.w3.org/TR/html4/struct/text.html#edef-CITE <cite> definition in HTML
|
|
* @link http://www.w3.org/TR/2005/WD-xhtml2-20050527/mod-text.html#edef_text_cite <cite> definition in XHTML 2.0
|
|
*
|
|
* @bug 4579
|
|
*
|
|
* @author Ævar Arnfjörð Bjarmason <avarab@gmail.com>
|
|
* @copyright Copyright © 2005, Ævar Arnfjörð Bjarmason
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU General Public License 2.0 or later
|
|
*/
|
|
// @codingStandardsIgnoreEnd
|
|
|
|
/**
|
|
* WARNING: MediaWiki core hardcodes this class name to check if the
|
|
* Cite extension is installed. See T89151.
|
|
*/
|
|
class Cite {
|
|
|
|
/**
|
|
* @todo document
|
|
*/
|
|
const DEFAULT_GROUP = '';
|
|
|
|
/**
|
|
* Maximum storage capacity for pp_value field of page_props table
|
|
* @todo Find a way to retrieve this information from the DBAL
|
|
*/
|
|
const MAX_STORAGE_LENGTH = 65535; // Size of MySQL 'blob' field
|
|
|
|
/**
|
|
* Key used for storage in parser output's ExtensionData and ObjectCache
|
|
*/
|
|
const EXT_DATA_KEY = 'Cite:References';
|
|
|
|
/**
|
|
* Version number in case we change the data structure in the future
|
|
*/
|
|
const DATA_VERSION_NUMBER = 1;
|
|
|
|
/**
|
|
* Cache duration set when parsing a page with references
|
|
*/
|
|
const CACHE_DURATION_ONPARSE = 3600; // 1 hour
|
|
|
|
/**
|
|
* Cache duration set when fetching references from db
|
|
*/
|
|
const CACHE_DURATION_ONFETCH = 18000; // 5 hours
|
|
|
|
/**#@+
|
|
* @access private
|
|
*/
|
|
|
|
/**
|
|
* Datastructure representing <ref> input, in the format of:
|
|
* <code>
|
|
* array(
|
|
* 'user supplied' => array(
|
|
* 'text' => 'user supplied reference & key',
|
|
* 'count' => 1, // occurs twice
|
|
* 'number' => 1, // The first reference, we want
|
|
* // all occourances of it to
|
|
* // use the same number
|
|
* ),
|
|
* 0 => 'Anonymous reference',
|
|
* 1 => 'Another anonymous reference',
|
|
* 'some key' => array(
|
|
* 'text' => 'this one occurs once'
|
|
* 'count' => 0,
|
|
* 'number' => 4
|
|
* ),
|
|
* 3 => 'more stuff'
|
|
* );
|
|
* </code>
|
|
*
|
|
* This works because:
|
|
* * PHP's datastructures are guaranteed to be returned in the
|
|
* order that things are inserted into them (unless you mess
|
|
* with that)
|
|
* * User supplied keys can't be integers, therefore avoiding
|
|
* conflict with anonymous keys
|
|
*
|
|
* @var array
|
|
**/
|
|
public $mRefs = array();
|
|
|
|
/**
|
|
* Count for user displayed output (ref[1], ref[2], ...)
|
|
*
|
|
* @var int
|
|
*/
|
|
public $mOutCnt = 0;
|
|
public $mGroupCnt = array();
|
|
|
|
/**
|
|
* Counter to track the total number of (useful) calls to either the
|
|
* ref or references tag hook
|
|
*/
|
|
public $mCallCnt = 0;
|
|
|
|
/**
|
|
* The backlinks, in order, to pass as $3 to
|
|
* 'cite_references_link_many_format', defined in
|
|
* 'cite_references_link_many_format_backlink_labels
|
|
*
|
|
* @var array
|
|
*/
|
|
public $mBacklinkLabels;
|
|
|
|
/**
|
|
* The links to use per group, in order.
|
|
*
|
|
* @var array
|
|
*/
|
|
public $mLinkLabels = array();
|
|
|
|
/**
|
|
* @var Parser
|
|
*/
|
|
public $mParser;
|
|
|
|
/**
|
|
* True when the ParserAfterParse hook has been called.
|
|
* Used to avoid doing anything in ParserBeforeTidy.
|
|
*
|
|
* @var boolean
|
|
*/
|
|
public $mHaveAfterParse = false;
|
|
|
|
/**
|
|
* True when a <ref> tag is being processed.
|
|
* Used to avoid infinite recursion
|
|
*
|
|
* @var boolean
|
|
*/
|
|
public $mInCite = false;
|
|
|
|
/**
|
|
* True when a <references> tag is being processed.
|
|
* Used to detect the use of <references> to define refs
|
|
*
|
|
* @var boolean
|
|
*/
|
|
public $mInReferences = false;
|
|
|
|
/**
|
|
* Error stack used when defining refs in <references>
|
|
*
|
|
* @var array
|
|
*/
|
|
public $mReferencesErrors = array();
|
|
|
|
/**
|
|
* Group used when in <references> block
|
|
*
|
|
* @var string
|
|
*/
|
|
public $mReferencesGroup = '';
|
|
|
|
/**
|
|
* <ref> call stack
|
|
* Used to cleanup out of sequence ref calls created by #tag
|
|
* See description of function rollbackRef.
|
|
*
|
|
* @var array
|
|
*/
|
|
public $mRefCallStack = array();
|
|
|
|
/**
|
|
* @var bool
|
|
*/
|
|
private $mBumpRefData = false;
|
|
|
|
/**
|
|
* Did we install us into $wgHooks yet?
|
|
* @var Boolean
|
|
*/
|
|
static protected $hooksInstalled = false;
|
|
|
|
/**#@+ @access private */
|
|
|
|
/**
|
|
* Callback function for <ref>
|
|
*
|
|
* @param $str string Input
|
|
* @param $argv array Arguments
|
|
* @param $parser Parser
|
|
* @param $frame PPFrame
|
|
*
|
|
* @return string
|
|
*/
|
|
function ref( $str, $argv, $parser, $frame ) {
|
|
if ( $this->mInCite ) {
|
|
return htmlspecialchars( "<ref>$str</ref>" );
|
|
}
|
|
|
|
$this->mCallCnt++;
|
|
$this->mInCite = true;
|
|
|
|
$ret = $this->guardedRef( $str, $argv, $parser );
|
|
|
|
$this->mInCite = false;
|
|
|
|
$parserOutput = $parser->getOutput();
|
|
$parserOutput->addModules( 'ext.cite.a11y' );
|
|
$parserOutput->addModuleStyles( 'ext.cite.styles' );
|
|
|
|
if ( is_callable( array( $frame, 'setVolatile' ) ) ) {
|
|
$frame->setVolatile();
|
|
}
|
|
|
|
// new <ref> tag, we may need to bump the ref data counter
|
|
// to avoid overwriting a previous group
|
|
$this->mBumpRefData = true;
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* @param $str string Input
|
|
* @param $argv array Arguments
|
|
* @param $parser Parser
|
|
* @param $default_group string
|
|
* @return string
|
|
*/
|
|
function guardedRef( $str, $argv, $parser, $default_group = self::DEFAULT_GROUP ) {
|
|
$this->mParser = $parser;
|
|
|
|
# The key here is the "name" attribute.
|
|
list( $key, $group, $follow ) = $this->refArg( $argv );
|
|
|
|
# Split these into groups.
|
|
if ( $group === null ) {
|
|
if ( $this->mInReferences ) {
|
|
$group = $this->mReferencesGroup;
|
|
} else {
|
|
$group = $default_group;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This section deals with constructions of the form
|
|
*
|
|
* <references>
|
|
* <ref name="foo"> BAR </ref>
|
|
* </references>
|
|
*/
|
|
if ( $this->mInReferences ) {
|
|
if ( $group != $this->mReferencesGroup ) {
|
|
# <ref> and <references> have conflicting group attributes.
|
|
$this->mReferencesErrors[] =
|
|
$this->error( 'cite_error_references_group_mismatch', htmlspecialchars( $group ) );
|
|
} elseif ( $str !== '' ) {
|
|
if ( !isset( $this->mRefs[$group] ) ) {
|
|
# Called with group attribute not defined in text.
|
|
$this->mReferencesErrors[] =
|
|
$this->error( 'cite_error_references_missing_group', htmlspecialchars( $group ) );
|
|
} elseif ( $key === null || $key === '' ) {
|
|
# <ref> calls inside <references> must be named
|
|
$this->mReferencesErrors[] =
|
|
$this->error( 'cite_error_references_no_key' );
|
|
} elseif ( !isset( $this->mRefs[$group][$key] ) ) {
|
|
# Called with name attribute not defined in text.
|
|
$this->mReferencesErrors[] =
|
|
$this->error( 'cite_error_references_missing_key', $key );
|
|
} else {
|
|
if (
|
|
isset( $this->mRefs[$group][$key]['text'] ) &&
|
|
$str !== $this->mRefs[$group][$key]['text']
|
|
) {
|
|
// two refs with same key and different content
|
|
// add error message to the original ref
|
|
$this->mRefs[$group][$key]['text'] .= ' ' . $this->error(
|
|
'cite_error_references_duplicate_key', $key, 'noparse'
|
|
);
|
|
} else {
|
|
# Assign the text to corresponding ref
|
|
$this->mRefs[$group][$key]['text'] = $str;
|
|
}
|
|
}
|
|
} else {
|
|
# <ref> called in <references> has no content.
|
|
$this->mReferencesErrors[] =
|
|
$this->error( 'cite_error_empty_references_define', $key );
|
|
}
|
|
return '';
|
|
}
|
|
|
|
if ( $str === '' ) {
|
|
# <ref ...></ref>. This construct is invalid if
|
|
# it's a contentful ref, but OK if it's a named duplicate and should
|
|
# be equivalent <ref ... />, for compatability with #tag.
|
|
if ( $key == false ) {
|
|
$this->mRefCallStack[] = false;
|
|
|
|
return $this->error( 'cite_error_ref_no_input' );
|
|
} else {
|
|
$str = null;
|
|
}
|
|
}
|
|
|
|
if ( $key === false ) {
|
|
# TODO: Comment this case; what does this condition mean?
|
|
$this->mRefCallStack[] = false;
|
|
return $this->error( 'cite_error_ref_too_many_keys' );
|
|
}
|
|
|
|
if ( $str === null && $key === null ) {
|
|
# Something like <ref />; this makes no sense.
|
|
$this->mRefCallStack[] = false;
|
|
return $this->error( 'cite_error_ref_no_key' );
|
|
}
|
|
|
|
if ( preg_match( '/^[0-9]+$/', $key ) || preg_match( '/^[0-9]+$/', $follow ) ) {
|
|
# Numeric names mess up the resulting id's, potentially produ-
|
|
# cing duplicate id's in the XHTML. The Right Thing To Do
|
|
# would be to mangle them, but it's not really high-priority
|
|
# (and would produce weird id's anyway).
|
|
|
|
$this->mRefCallStack[] = false;
|
|
return $this->error( 'cite_error_ref_numeric_key' );
|
|
}
|
|
|
|
if ( preg_match(
|
|
'/<ref\b[^<]*?>/',
|
|
preg_replace( '#<([^ ]+?).*?>.*?</\\1 *>|<!--.*?-->#', '', $str )
|
|
) ) {
|
|
# (bug T8199) This most likely implies that someone left off the
|
|
# closing </ref> tag, which will cause the entire article to be
|
|
# eaten up until the next <ref>. So we bail out early instead.
|
|
# The fancy regex above first tries chopping out anything that
|
|
# looks like a comment or SGML tag, which is a crude way to avoid
|
|
# false alarms for <nowiki>, <pre>, etc.
|
|
|
|
# Possible improvement: print the warning, followed by the contents
|
|
# of the <ref> tag. This way no part of the article will be eaten
|
|
# even temporarily.
|
|
|
|
$this->mRefCallStack[] = false;
|
|
return $this->error( 'cite_error_included_ref' );
|
|
}
|
|
|
|
if ( is_string( $key ) || is_string( $str ) ) {
|
|
# We don't care about the content: if the key exists, the ref
|
|
# is presumptively valid. Either it stores a new ref, or re-
|
|
# fers to an existing one. If it refers to a nonexistent ref,
|
|
# we'll figure that out later. Likewise it's definitely valid
|
|
# if there's any content, regardless of key.
|
|
|
|
return $this->stack( $str, $key, $group, $follow, $argv );
|
|
}
|
|
|
|
# Not clear how we could get here, but something is probably
|
|
# wrong with the types. Let's fail fast.
|
|
throw new Exception( 'Invalid $str and/or $key: ' . serialize( array( $str, $key ) ) );
|
|
}
|
|
|
|
/**
|
|
* Parse the arguments to the <ref> tag
|
|
*
|
|
* "name" : Key of the reference.
|
|
* "group" : Group to which it belongs. Needs to be passed to <references /> too.
|
|
* "follow" : If the current reference is the continuation of another, key of that reference.
|
|
*
|
|
*
|
|
* @param $argv array The argument vector
|
|
* @return mixed false on invalid input, a string on valid
|
|
* input and null on no input
|
|
*/
|
|
function refArg( $argv ) {
|
|
global $wgAllowCiteGroups;
|
|
$cnt = count( $argv );
|
|
$group = null;
|
|
$key = null;
|
|
$follow = null;
|
|
|
|
if ( $cnt > 2 ) {
|
|
// There should only be one key or follow parameter, and one group parameter
|
|
// FIXME : this looks inconsistent, it should probably return a tuple
|
|
return false;
|
|
} elseif ( $cnt >= 1 ) {
|
|
if ( isset( $argv['name'] ) && isset( $argv['follow'] ) ) {
|
|
return array( false, false, false );
|
|
}
|
|
if ( isset( $argv['name'] ) ) {
|
|
// Key given.
|
|
$key = Sanitizer::escapeId( $argv['name'], 'noninitial' );
|
|
unset( $argv['name'] );
|
|
--$cnt;
|
|
}
|
|
if ( isset( $argv['follow'] ) ) {
|
|
// Follow given.
|
|
$follow = Sanitizer::escapeId( $argv['follow'], 'noninitial' );
|
|
unset( $argv['follow'] );
|
|
--$cnt;
|
|
}
|
|
if ( isset( $argv['group'] ) ) {
|
|
if ( !$wgAllowCiteGroups ) {
|
|
// remove when groups are fully tested.
|
|
return array( false );
|
|
}
|
|
// Group given.
|
|
$group = $argv['group'];
|
|
unset( $argv['group'] );
|
|
--$cnt;
|
|
}
|
|
|
|
if ( $cnt === 0 ) {
|
|
return array( $key, $group, $follow );
|
|
} else {
|
|
// Invalid key
|
|
return array( false, false, false );
|
|
}
|
|
} else {
|
|
// No key
|
|
return array( null, $group, false );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Populate $this->mRefs based on input and arguments to <ref>
|
|
*
|
|
* @param $str string Input from the <ref> tag
|
|
* @param $key mixed Argument to the <ref> tag as returned by $this->refArg()
|
|
* @param $group
|
|
* @param $follow
|
|
* @param $call
|
|
*
|
|
* @return string
|
|
*/
|
|
function stack( $str, $key = null, $group, $follow, $call ) {
|
|
if ( !isset( $this->mRefs[$group] ) ) {
|
|
$this->mRefs[$group] = array();
|
|
}
|
|
if ( !isset( $this->mGroupCnt[$group] ) ) {
|
|
$this->mGroupCnt[$group] = 0;
|
|
}
|
|
if ( $follow != null ) {
|
|
if ( isset( $this->mRefs[$group][$follow] ) && is_array( $this->mRefs[$group][$follow] ) ) {
|
|
// add text to the note that is being followed
|
|
$this->mRefs[$group][$follow]['text'] .= ' ' . $str;
|
|
} else {
|
|
// insert part of note at the beginning of the group
|
|
$groupsCount = count( $this->mRefs[$group] );
|
|
for ( $k = 0; $k < $groupsCount; $k++ ) {
|
|
if ( !isset( $this->mRefs[$group][$k]['follow'] ) ) {
|
|
break;
|
|
}
|
|
}
|
|
array_splice( $this->mRefs[$group], $k, 0,
|
|
array( array( 'count' => - 1,
|
|
'text' => $str,
|
|
'key' => ++$this->mOutCnt ,
|
|
'follow' => $follow ) ) );
|
|
array_splice( $this->mRefCallStack, $k, 0,
|
|
array( array( 'new', $call, $str, $key, $group, $this->mOutCnt ) ) );
|
|
}
|
|
// return an empty string : this is not a reference
|
|
return '';
|
|
}
|
|
|
|
if ( $key === null ) {
|
|
// No key
|
|
// $this->mRefs[$group][] = $str;
|
|
$this->mRefs[$group][] = array( 'count' => - 1, 'text' => $str, 'key' => ++$this->mOutCnt );
|
|
$this->mRefCallStack[] = array( 'new', $call, $str, $key, $group, $this->mOutCnt );
|
|
|
|
return $this->linkRef( $group, $this->mOutCnt );
|
|
}
|
|
if ( !is_string( $key ) ) {
|
|
throw new Exception( 'Invalid stack key: ' . serialize( $key ) );
|
|
}
|
|
|
|
// Valid key
|
|
if ( !isset( $this->mRefs[$group][$key] ) || !is_array( $this->mRefs[$group][$key] ) ) {
|
|
// First occurrence
|
|
$this->mRefs[$group][$key] = array(
|
|
'text' => $str,
|
|
'count' => 0,
|
|
'key' => ++$this->mOutCnt,
|
|
'number' => ++$this->mGroupCnt[$group]
|
|
);
|
|
$this->mRefCallStack[] = array( 'new', $call, $str, $key, $group, $this->mOutCnt );
|
|
|
|
return $this->linkRef(
|
|
$group,
|
|
$key,
|
|
$this->mRefs[$group][$key]['key'] . "-" . $this->mRefs[$group][$key]['count'],
|
|
$this->mRefs[$group][$key]['number'],
|
|
"-" . $this->mRefs[$group][$key]['key']
|
|
);
|
|
}
|
|
|
|
// We've been here before
|
|
if ( $this->mRefs[$group][$key]['text'] === null && $str !== '' ) {
|
|
// If no text found before, use this text
|
|
$this->mRefs[$group][$key]['text'] = $str;
|
|
$this->mRefCallStack[] = array( 'assign', $call, $str, $key, $group,
|
|
$this->mRefs[$group][$key]['key'] );
|
|
} else {
|
|
if ( $str != null && $str !== '' && $str !== $this->mRefs[$group][$key]['text'] ) {
|
|
// two refs with same key and different content
|
|
// add error message to the original ref
|
|
$this->mRefs[$group][$key]['text'] .= ' ' . $this->error(
|
|
'cite_error_references_duplicate_key', $key, 'noparse'
|
|
);
|
|
}
|
|
$this->mRefCallStack[] = array( 'increment', $call, $str, $key, $group,
|
|
$this->mRefs[$group][$key]['key'] );
|
|
}
|
|
return $this->linkRef(
|
|
$group,
|
|
$key,
|
|
$this->mRefs[$group][$key]['key'] . "-" . ++$this->mRefs[$group][$key]['count'],
|
|
$this->mRefs[$group][$key]['number'],
|
|
"-" . $this->mRefs[$group][$key]['key']
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Partially undoes the effect of calls to stack()
|
|
*
|
|
* Called by guardedReferences()
|
|
*
|
|
* The option to define <ref> within <references> makes the
|
|
* behavior of <ref> context dependent. This is normally fine
|
|
* but certain operations (especially #tag) lead to out-of-order
|
|
* parser evaluation with the <ref> tags being processed before
|
|
* their containing <reference> element is read. This leads to
|
|
* stack corruption that this function works to fix.
|
|
*
|
|
* This function is not a total rollback since some internal
|
|
* counters remain incremented. Doing so prevents accidentally
|
|
* corrupting certain links.
|
|
*
|
|
* @param $type
|
|
* @param $key
|
|
* @param $group
|
|
* @param $index
|
|
*/
|
|
function rollbackRef( $type, $key, $group, $index ) {
|
|
if ( !isset( $this->mRefs[$group] ) ) {
|
|
return;
|
|
}
|
|
|
|
if ( $key === null ) {
|
|
foreach ( $this->mRefs[$group] as $k => $v ) {
|
|
if ( $this->mRefs[$group][$k]['key'] === $index ) {
|
|
$key = $k;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Sanity checks that specified element exists.
|
|
if ( $key === null ) {
|
|
return;
|
|
}
|
|
if ( !isset( $this->mRefs[$group][$key] ) ) {
|
|
return;
|
|
}
|
|
if ( $this->mRefs[$group][$key]['key'] != $index ) {
|
|
return;
|
|
}
|
|
|
|
switch ( $type ) {
|
|
case 'new':
|
|
# Rollback the addition of new elements to the stack.
|
|
unset( $this->mRefs[$group][$key] );
|
|
if ( $this->mRefs[$group] === array() ) {
|
|
unset( $this->mRefs[$group] );
|
|
unset( $this->mGroupCnt[$group] );
|
|
}
|
|
break;
|
|
case 'assign':
|
|
# Rollback assignment of text to pre-existing elements.
|
|
$this->mRefs[$group][$key]['text'] = null;
|
|
# continue without break
|
|
case 'increment':
|
|
# Rollback increase in named ref occurrences.
|
|
$this->mRefs[$group][$key]['count']--;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Callback function for <references>
|
|
*
|
|
* @param $str string Input
|
|
* @param $argv array Arguments
|
|
* @param $parser Parser
|
|
* @param $frame PPFrame
|
|
*
|
|
* @return string
|
|
*/
|
|
function references( $str, $argv, $parser, $frame ) {
|
|
if ( $this->mInCite || $this->mInReferences ) {
|
|
if ( is_null( $str ) ) {
|
|
return htmlspecialchars( "<references/>" );
|
|
}
|
|
return htmlspecialchars( "<references>$str</references>" );
|
|
}
|
|
$this->mCallCnt++;
|
|
$this->mInReferences = true;
|
|
$ret = $this->guardedReferences( $str, $argv, $parser );
|
|
$this->mInReferences = false;
|
|
if ( is_callable( array( $frame, 'setVolatile' ) ) ) {
|
|
$frame->setVolatile();
|
|
}
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* @param $str string
|
|
* @param $argv array
|
|
* @param $parser Parser
|
|
* @param $group string
|
|
* @return string
|
|
*/
|
|
function guardedReferences( $str, $argv, $parser, $group = self::DEFAULT_GROUP ) {
|
|
global $wgAllowCiteGroups;
|
|
|
|
$this->mParser = $parser;
|
|
|
|
if ( isset( $argv['group'] ) && $wgAllowCiteGroups ) {
|
|
$group = $argv['group'];
|
|
unset( $argv['group'] );
|
|
}
|
|
|
|
if ( strval( $str ) !== '' ) {
|
|
$this->mReferencesGroup = $group;
|
|
|
|
# Detect whether we were sent already rendered <ref>s.
|
|
# Mostly a side effect of using #tag to call references.
|
|
# The following assumes that the parsed <ref>s sent within
|
|
# the <references> block were the most recent calls to
|
|
# <ref>. This assumption is true for all known use cases,
|
|
# but not strictly enforced by the parser. It is possible
|
|
# that some unusual combination of #tag, <references> and
|
|
# conditional parser functions could be created that would
|
|
# lead to malformed references here.
|
|
$count = substr_count( $str, Parser::MARKER_PREFIX . "-ref-" );
|
|
$redoStack = array();
|
|
|
|
# Undo effects of calling <ref> while unaware of containing <references>
|
|
for ( $i = 1; $i <= $count; $i++ ) {
|
|
if ( !$this->mRefCallStack ) {
|
|
break;
|
|
}
|
|
|
|
$call = array_pop( $this->mRefCallStack );
|
|
$redoStack[] = $call;
|
|
if ( $call !== false ) {
|
|
list( $type, $ref_argv, $ref_str,
|
|
$ref_key, $ref_group, $ref_index ) = $call;
|
|
$this->rollbackRef( $type, $ref_key, $ref_group, $ref_index );
|
|
}
|
|
}
|
|
|
|
# Rerun <ref> call now that mInReferences is set.
|
|
for ( $i = count( $redoStack ) - 1; $i >= 0; $i-- ) {
|
|
$call = $redoStack[$i];
|
|
if ( $call !== false ) {
|
|
list( $type, $ref_argv, $ref_str,
|
|
$ref_key, $ref_group, $ref_index ) = $call;
|
|
$this->guardedRef( $ref_str, $ref_argv, $parser );
|
|
}
|
|
}
|
|
|
|
# Parse $str to process any unparsed <ref> tags.
|
|
$parser->recursiveTagParse( $str );
|
|
|
|
# Reset call stack
|
|
$this->mRefCallStack = array();
|
|
}
|
|
|
|
if ( $argv && $wgAllowCiteGroups ) {
|
|
return $this->error( 'cite_error_references_invalid_parameters_group' );
|
|
}
|
|
if ( $argv ) {
|
|
return $this->error( 'cite_error_references_invalid_parameters' );
|
|
}
|
|
|
|
$s = $this->referencesFormat( $group );
|
|
if ( $parser->getOptions()->getIsSectionPreview() ) {
|
|
return $s;
|
|
}
|
|
|
|
# Append errors generated while processing <references>
|
|
if ( $this->mReferencesErrors ) {
|
|
$s .= "\n" . implode( "<br />\n", $this->mReferencesErrors );
|
|
$this->mReferencesErrors = array();
|
|
}
|
|
return $s;
|
|
}
|
|
|
|
/**
|
|
* Make output to be returned from the references() function
|
|
*
|
|
* @param $group
|
|
*
|
|
* @return string XHTML ready for output
|
|
*/
|
|
function referencesFormat( $group ) {
|
|
if ( !$this->mRefs || !isset( $this->mRefs[$group] ) ) {
|
|
return '';
|
|
}
|
|
|
|
wfProfileIn( __METHOD__ . '-entries' );
|
|
$ent = array();
|
|
foreach ( $this->mRefs[$group] as $k => $v ) {
|
|
$ent[] = $this->referencesFormatEntry( $k, $v );
|
|
}
|
|
|
|
$prefix = wfMessage( 'cite_references_prefix' )->inContentLanguage()->plain();
|
|
$suffix = wfMessage( 'cite_references_suffix' )->inContentLanguage()->plain();
|
|
$content = implode( "\n", $ent );
|
|
|
|
// Prepare the parser input.
|
|
// We add new lines between the pieces to avoid a confused tidy (bug 13073).
|
|
$parserInput = $prefix . "\n" . $content . "\n" . $suffix;
|
|
|
|
// Let's try to cache it.
|
|
global $wgMemc;
|
|
$cacheKey = wfMemcKey( 'citeref', md5( $parserInput ), $this->mParser->Title()->getArticleID() );
|
|
|
|
wfProfileOut( __METHOD__ . '-entries' );
|
|
|
|
global $wgCiteCacheReferences;
|
|
$data = false;
|
|
if ( $wgCiteCacheReferences ) {
|
|
wfProfileIn( __METHOD__ . '-cache-get' );
|
|
$data = $wgMemc->get( $cacheKey );
|
|
wfProfileOut( __METHOD__ . '-cache-get' );
|
|
}
|
|
|
|
if ( !$data || !$this->mParser->isValidHalfParsedText( $data ) ) {
|
|
wfProfileIn( __METHOD__ . '-parse' );
|
|
|
|
// Live hack: parse() adds two newlines on WM, can't reproduce it locally -ævar
|
|
$ret = rtrim( $this->mParser->recursiveTagParse( $parserInput ), "\n" );
|
|
|
|
if ( $wgCiteCacheReferences ) {
|
|
$serData = $this->mParser->serializeHalfParsedText( $ret );
|
|
$wgMemc->set( $cacheKey, $serData, 86400 );
|
|
}
|
|
|
|
wfProfileOut( __METHOD__ . '-parse' );
|
|
} else {
|
|
$ret = $this->mParser->unserializeHalfParsedText( $data );
|
|
}
|
|
|
|
if ( !$this->mParser->getOptions()->getIsPreview() ) {
|
|
// save references data for later use by LinksUpdate hooks
|
|
$this->saveReferencesData( $group );
|
|
}
|
|
|
|
// done, clean up so we can reuse the group
|
|
unset( $this->mRefs[$group] );
|
|
unset( $this->mGroupCnt[$group] );
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Format a single entry for the referencesFormat() function
|
|
*
|
|
* @param string $key The key of the reference
|
|
* @param mixed $val The value of the reference, string for anonymous
|
|
* references, array for user-suppplied
|
|
* @return string Wikitext
|
|
*/
|
|
function referencesFormatEntry( $key, $val ) {
|
|
// Anonymous reference
|
|
if ( !is_array( $val ) ) {
|
|
return wfMessage(
|
|
'cite_references_link_one',
|
|
$this->referencesKey( $key ),
|
|
$this->refKey( $key ),
|
|
$this->referenceText( $key, $val )
|
|
)->inContentLanguage()->plain();
|
|
}
|
|
$text = $this->referenceText( $key, $val['text'] );
|
|
if ( isset( $val['follow'] ) ) {
|
|
return wfMessage(
|
|
'cite_references_no_link',
|
|
$this->referencesKey( $val['follow'] ),
|
|
$text
|
|
)->inContentLanguage()->plain();
|
|
} elseif ( !isset( $val['text'] ) ) {
|
|
return wfMessage(
|
|
'cite_references_link_one',
|
|
$this->referencesKey( $key ),
|
|
$this->refKey( $key, $val['count'] ),
|
|
$text
|
|
)->inContentLanguage()->plain();
|
|
}
|
|
|
|
if ( $val['count'] < 0 ) {
|
|
return wfMessage(
|
|
'cite_references_link_one',
|
|
$this->referencesKey( $val['key'] ),
|
|
# $this->refKey( $val['key'], $val['count'] ),
|
|
$this->refKey( $val['key'] ),
|
|
$text
|
|
)->inContentLanguage()->plain();
|
|
// Standalone named reference, I want to format this like an
|
|
// anonymous reference because displaying "1. 1.1 Ref text" is
|
|
// overkill and users frequently use named references when they
|
|
// don't need them for convenience
|
|
} elseif ( $val['count'] === 0 ) {
|
|
return wfMessage(
|
|
'cite_references_link_one',
|
|
$this->referencesKey( $key . "-" . $val['key'] ),
|
|
# $this->refKey( $key, $val['count'] ),
|
|
$this->refKey( $key, $val['key'] . "-" . $val['count'] ),
|
|
$text
|
|
)->inContentLanguage()->plain();
|
|
// Named references with >1 occurrences
|
|
} else {
|
|
$links = array();
|
|
// for group handling, we have an extra key here.
|
|
for ( $i = 0; $i <= $val['count']; ++$i ) {
|
|
$links[] = wfMessage(
|
|
'cite_references_link_many_format',
|
|
$this->refKey( $key, $val['key'] . "-$i" ),
|
|
$this->referencesFormatEntryNumericBacklinkLabel( $val['number'], $i, $val['count'] ),
|
|
$this->referencesFormatEntryAlternateBacklinkLabel( $i )
|
|
)->inContentLanguage()->plain();
|
|
}
|
|
|
|
$list = $this->listToText( $links );
|
|
|
|
return wfMessage( 'cite_references_link_many',
|
|
$this->referencesKey( $key . "-" . $val['key'] ),
|
|
$list,
|
|
$text
|
|
)->inContentLanguage()->plain();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns formatted reference text
|
|
* @param String $key
|
|
* @param String $text
|
|
* @return String
|
|
*/
|
|
function referenceText( $key, $text ) {
|
|
if ( !isset( $text ) || $text === '' ) {
|
|
return $this->error( 'cite_error_references_no_text', $key, 'noparse' );
|
|
}
|
|
return '<span class="reference-text">' . rtrim( $text, "\n" ) . "</span>\n";
|
|
}
|
|
|
|
/**
|
|
* Generate a numeric backlink given a base number and an
|
|
* offset, e.g. $base = 1, $offset = 2; = 1.2
|
|
* Since bug #5525, it correctly does 1.9 -> 1.10 as well as 1.099 -> 1.100
|
|
*
|
|
* @static
|
|
*
|
|
* @param int $base The base
|
|
* @param int $offset The offset
|
|
* @param int $max Maximum value expected.
|
|
* @return string
|
|
*/
|
|
function referencesFormatEntryNumericBacklinkLabel( $base, $offset, $max ) {
|
|
global $wgContLang;
|
|
$scope = strlen( $max );
|
|
$ret = $wgContLang->formatNum(
|
|
sprintf( "%s.%0{$scope}s", $base, $offset )
|
|
);
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Generate a custom format backlink given an offset, e.g.
|
|
* $offset = 2; = c if $this->mBacklinkLabels = array( 'a',
|
|
* 'b', 'c', ...). Return an error if the offset > the # of
|
|
* array items
|
|
*
|
|
* @param int $offset The offset
|
|
*
|
|
* @return string
|
|
*/
|
|
function referencesFormatEntryAlternateBacklinkLabel( $offset ) {
|
|
if ( !isset( $this->mBacklinkLabels ) ) {
|
|
$this->genBacklinkLabels();
|
|
}
|
|
if ( isset( $this->mBacklinkLabels[$offset] ) ) {
|
|
return $this->mBacklinkLabels[$offset];
|
|
} else {
|
|
// Feed me!
|
|
return $this->error( 'cite_error_references_no_backlink_label', null, 'noparse' );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate a custom format link for a group given an offset, e.g.
|
|
* the second <ref group="foo"> is b if $this->mLinkLabels["foo"] =
|
|
* array( 'a', 'b', 'c', ...).
|
|
* Return an error if the offset > the # of array items
|
|
*
|
|
* @param int $offset The offset
|
|
* @param string $group The group name
|
|
* @param string $label The text to use if there's no message for them.
|
|
*
|
|
* @return string
|
|
*/
|
|
function getLinkLabel( $offset, $group, $label ) {
|
|
$message = "cite_link_label_group-$group";
|
|
if ( !isset( $this->mLinkLabels[$group] ) ) {
|
|
$this->genLinkLabels( $group, $message );
|
|
}
|
|
if ( $this->mLinkLabels[$group] === false ) {
|
|
// Use normal representation, ie. "$group 1", "$group 2"...
|
|
return $label;
|
|
}
|
|
|
|
if ( isset( $this->mLinkLabels[$group][$offset - 1] ) ) {
|
|
return $this->mLinkLabels[$group][$offset - 1];
|
|
} else {
|
|
// Feed me!
|
|
return $this->error( 'cite_error_no_link_label_group', array( $group, $message ), 'noparse' );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return an id for use in wikitext output based on a key and
|
|
* optionally the number of it, used in <references>, not <ref>
|
|
* (since otherwise it would link to itself)
|
|
*
|
|
* @static
|
|
*
|
|
* @param string $key The key
|
|
* @param int $num The number of the key
|
|
* @return string A key for use in wikitext
|
|
*/
|
|
function refKey( $key, $num = null ) {
|
|
$prefix = wfMessage( 'cite_reference_link_prefix' )->inContentLanguage()->text();
|
|
$suffix = wfMessage( 'cite_reference_link_suffix' )->inContentLanguage()->text();
|
|
if ( isset( $num ) ) {
|
|
$key = wfMessage( 'cite_reference_link_key_with_num', $key, $num )
|
|
->inContentLanguage()->plain();
|
|
}
|
|
|
|
return "$prefix$key$suffix";
|
|
}
|
|
|
|
/**
|
|
* Return an id for use in wikitext output based on a key and
|
|
* optionally the number of it, used in <ref>, not <references>
|
|
* (since otherwise it would link to itself)
|
|
*
|
|
* @static
|
|
*
|
|
* @param string $key The key
|
|
* @param int $num The number of the key
|
|
* @return string A key for use in wikitext
|
|
*/
|
|
function referencesKey( $key, $num = null ) {
|
|
$prefix = wfMessage( 'cite_references_link_prefix' )->inContentLanguage()->text();
|
|
$suffix = wfMessage( 'cite_references_link_suffix' )->inContentLanguage()->text();
|
|
if ( isset( $num ) ) {
|
|
$key = wfMessage( 'cite_reference_link_key_with_num', $key, $num )
|
|
->inContentLanguage()->plain();
|
|
}
|
|
|
|
return "$prefix$key$suffix";
|
|
}
|
|
|
|
/**
|
|
* Generate a link (<sup ...) for the <ref> element from a key
|
|
* and return XHTML ready for output
|
|
*
|
|
* @param $group
|
|
* @param $key string The key for the link
|
|
* @param $count int The index of the key, used for distinguishing
|
|
* multiple occurrences of the same key
|
|
* @param $label int The label to use for the link, I want to
|
|
* use the same label for all occourances of
|
|
* the same named reference.
|
|
* @param $subkey string
|
|
*
|
|
* @return string
|
|
*/
|
|
function linkRef( $group, $key, $count = null, $label = null, $subkey = '' ) {
|
|
global $wgContLang;
|
|
$label = is_null( $label ) ? ++$this->mGroupCnt[$group] : $label;
|
|
|
|
return
|
|
$this->mParser->recursiveTagParse(
|
|
wfMessage(
|
|
'cite_reference_link',
|
|
$this->refKey( $key, $count ),
|
|
$this->referencesKey( $key . $subkey ),
|
|
$this->getLinkLabel( $label, $group,
|
|
( ( $group === self::DEFAULT_GROUP ) ? '' : "$group " ) . $wgContLang->formatNum( $label ) )
|
|
)->inContentLanguage()->plain()
|
|
);
|
|
}
|
|
|
|
/**
|
|
* This does approximately the same thing as
|
|
* Language::listToText() but due to this being used for a
|
|
* slightly different purpose (people might not want , as the
|
|
* first separator and not 'and' as the second, and this has to
|
|
* use messages from the content language) I'm rolling my own.
|
|
*
|
|
* @static
|
|
*
|
|
* @param array $arr The array to format
|
|
* @return string
|
|
*/
|
|
function listToText( $arr ) {
|
|
$cnt = count( $arr );
|
|
|
|
$sep = wfMessage( 'cite_references_link_many_sep' )->inContentLanguage()->plain();
|
|
$and = wfMessage( 'cite_references_link_many_and' )->inContentLanguage()->plain();
|
|
|
|
if ( $cnt === 1 ) {
|
|
// Enforce always returning a string
|
|
return (string)$arr[0];
|
|
} else {
|
|
$t = array_slice( $arr, 0, $cnt - 1 );
|
|
return implode( $sep, $t ) . $and . $arr[$cnt - 1];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generate the labels to pass to the
|
|
* 'cite_references_link_many_format' message, the format is an
|
|
* arbitrary number of tokens separated by [\t\n ]
|
|
*/
|
|
function genBacklinkLabels() {
|
|
$text = wfMessage( 'cite_references_link_many_format_backlink_labels' )
|
|
->inContentLanguage()->plain();
|
|
$this->mBacklinkLabels = preg_split( '#[\n\t ]#', $text );
|
|
}
|
|
|
|
/**
|
|
* Generate the labels to pass to the
|
|
* 'cite_reference_link' message instead of numbers, the format is an
|
|
* arbitrary number of tokens separated by [\t\n ]
|
|
*
|
|
* @param $group
|
|
* @param $message
|
|
*/
|
|
function genLinkLabels( $group, $message ) {
|
|
$text = false;
|
|
$msg = wfMessage( $message )->inContentLanguage();
|
|
if ( $msg->exists() ) {
|
|
$text = $msg->plain();
|
|
}
|
|
$this->mLinkLabels[$group] = ( !$text ) ? false : preg_split( '#[\n\t ]#', $text );
|
|
}
|
|
|
|
/**
|
|
* Gets run when Parser::clearState() gets run, since we don't
|
|
* want the counts to transcend pages and other instances
|
|
*
|
|
* @param $parser Parser
|
|
*
|
|
* @return bool
|
|
*/
|
|
function clearState( &$parser ) {
|
|
if ( $parser->extCite !== $this ) {
|
|
return $parser->extCite->clearState( $parser );
|
|
}
|
|
|
|
# Don't clear state when we're in the middle of parsing
|
|
# a <ref> tag
|
|
if ( $this->mInCite || $this->mInReferences ) {
|
|
return true;
|
|
}
|
|
|
|
$this->mGroupCnt = array();
|
|
$this->mOutCnt = 0;
|
|
$this->mCallCnt = 0;
|
|
$this->mRefs = array();
|
|
$this->mReferencesErrors = array();
|
|
$this->mRefCallStack = array();
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Gets run when the parser is cloned.
|
|
*
|
|
* @param $parser Parser
|
|
*
|
|
* @return bool
|
|
*/
|
|
function cloneState( $parser ) {
|
|
if ( $parser->extCite !== $this ) {
|
|
return $parser->extCite->cloneState( $parser );
|
|
}
|
|
|
|
$parser->extCite = clone $this;
|
|
$parser->setHook( 'ref', array( $parser->extCite, 'ref' ) );
|
|
$parser->setHook( 'references', array( $parser->extCite, 'references' ) );
|
|
|
|
// Clear the state, making sure it will actually work.
|
|
$parser->extCite->mInCite = false;
|
|
$parser->extCite->mInReferences = false;
|
|
$parser->extCite->clearState( $parser );
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Called at the end of page processing to append a default references
|
|
* section, if refs were used without a main references tag. If there are references
|
|
* in a custom group, and there is no references tag for it, show an error
|
|
* message for that group.
|
|
* If we are processing a section preview, this adds the missing
|
|
* references tags and does not add the errors.
|
|
*
|
|
* @param $afterParse bool true if called from the ParserAfterParse hook
|
|
* @param $parser Parser
|
|
* @param $text string
|
|
*
|
|
* @return bool
|
|
*/
|
|
function checkRefsNoReferences( $afterParse, &$parser, &$text ) {
|
|
if ( is_null( $parser->extCite ) ) {
|
|
return true;
|
|
}
|
|
if ( $parser->extCite !== $this ) {
|
|
return $parser->extCite->checkRefsNoReferences( $afterParse, $parser, $text );
|
|
}
|
|
|
|
if ( $afterParse ) {
|
|
$this->mHaveAfterParse = true;
|
|
} elseif ( $this->mHaveAfterParse ) {
|
|
return true;
|
|
}
|
|
|
|
if ( !$parser->getOptions()->getIsPreview() ) {
|
|
// save references data for later use by LinksUpdate hooks
|
|
if ( $this->mRefs && isset( $this->mRefs[self::DEFAULT_GROUP] ) ) {
|
|
$this->saveReferencesData();
|
|
}
|
|
$isSectionPreview = false;
|
|
} else {
|
|
$isSectionPreview = $parser->getOptions()->getIsSectionPreview();
|
|
}
|
|
|
|
$s = '';
|
|
foreach ( $this->mRefs as $group => $refs ) {
|
|
if ( !$refs ) {
|
|
continue;
|
|
}
|
|
if ( $group === self::DEFAULT_GROUP || $isSectionPreview ) {
|
|
$s .= $this->referencesFormat( $group );
|
|
} else {
|
|
$s .= "\n<br />" .
|
|
$this->error( 'cite_error_group_refs_without_references', htmlspecialchars( $group ) );
|
|
}
|
|
}
|
|
if ( $isSectionPreview && $s !== '' ) {
|
|
$text .= "\n"
|
|
. '<span class="mw-ext-cite-cite_section_preview_references" >'
|
|
. "<h2>" . wfMessage( 'cite_section_preview_references' )->escaped() . "</h2>"
|
|
. $s
|
|
. '</span>';
|
|
} else {
|
|
$text .= $s;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Saves references in parser extension data
|
|
* This is called by each <references/> tag, and by checkRefsNoReferences
|
|
* Assumes $this->mRefs[$group] is set
|
|
*
|
|
* @param $group
|
|
*/
|
|
private function saveReferencesData( $group = self::DEFAULT_GROUP ) {
|
|
global $wgCiteStoreReferencesData;
|
|
if ( !$wgCiteStoreReferencesData ) {
|
|
return;
|
|
}
|
|
$savedRefs = $this->mParser->getOutput()->getExtensionData( self::EXT_DATA_KEY );
|
|
if ( $savedRefs === null ) {
|
|
// Initialize array structure
|
|
$savedRefs = array(
|
|
'refs' => array(),
|
|
'version' => self::DATA_VERSION_NUMBER,
|
|
);
|
|
}
|
|
if ( $this->mBumpRefData ) {
|
|
// This handles pages with multiple <references/> tags with <ref> tags in between.
|
|
// On those, a group can appear several times, so we need to avoid overwriting
|
|
// a previous appearance.
|
|
$savedRefs['refs'][] = array();
|
|
$this->mBumpRefData = false;
|
|
}
|
|
$n = count( $savedRefs['refs'] ) - 1;
|
|
// save group
|
|
$savedRefs['refs'][$n][$group] = $this->mRefs[$group];
|
|
|
|
$this->mParser->getOutput()->setExtensionData( self::EXT_DATA_KEY, $savedRefs );
|
|
}
|
|
|
|
/**
|
|
* Hook for the InlineEditor extension.
|
|
* If any ref or reference reference tag is in the text,
|
|
* the entire page should be reparsed, so we return false in that case.
|
|
*
|
|
* @param $output
|
|
*
|
|
* @return bool
|
|
*/
|
|
function checkAnyCalls( &$output ) {
|
|
global $wgParser;
|
|
/* InlineEditor always uses $wgParser */
|
|
return ( $wgParser->extCite->mCallCnt <= 0 );
|
|
}
|
|
|
|
/**
|
|
* Initialize the parser hooks
|
|
*
|
|
* @param $parser Parser
|
|
*
|
|
* @return bool
|
|
*/
|
|
static function setHooks( $parser ) {
|
|
global $wgHooks;
|
|
|
|
$parser->extCite = new self();
|
|
|
|
if ( !Cite::$hooksInstalled ) {
|
|
$wgHooks['ParserClearState'][] = array( $parser->extCite, 'clearState' );
|
|
$wgHooks['ParserCloned'][] = array( $parser->extCite, 'cloneState' );
|
|
$wgHooks['ParserAfterParse'][] = array( $parser->extCite, 'checkRefsNoReferences', true );
|
|
$wgHooks['ParserBeforeTidy'][] = array( $parser->extCite, 'checkRefsNoReferences', false );
|
|
$wgHooks['InlineEditorPartialAfterParse'][] = array( $parser->extCite, 'checkAnyCalls' );
|
|
Cite::$hooksInstalled = true;
|
|
}
|
|
$parser->setHook( 'ref', array( $parser->extCite, 'ref' ) );
|
|
$parser->setHook( 'references', array( $parser->extCite, 'references' ) );
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Return an error message based on an error ID
|
|
*
|
|
* @param string $key Message name for the error
|
|
* @param string $param Parameter to pass to the message
|
|
* @param string $parse Whether to parse the message ('parse') or not ('noparse')
|
|
* @return string XHTML or wikitext ready for output
|
|
*/
|
|
function error( $key, $param = null, $parse = 'parse' ) {
|
|
$decreaseToWarning = false;
|
|
if (
|
|
$this->mParser->getOptions()->getIsSectionPreview() &&
|
|
$key === 'cite_error_references_no_text'
|
|
) {
|
|
// ref may be defined somewhere else on the page so use distinct message
|
|
// and be less intrusive than in a real error
|
|
$key = 'cite_warning_sectionpreview_no_text';
|
|
$decreaseToWarning = true;
|
|
}
|
|
# We rely on the fact that PHP is okay with passing unused argu-
|
|
# ments to functions. If $1 is not used in the message, wfMessage will
|
|
# just ignore the extra parameter.
|
|
# For ease of debugging and because errors are rare, we
|
|
# use the user language and split the parser cache.
|
|
$lang = $this->mParser->getOptions()->getUserLangObj();
|
|
$msg = wfMessage(
|
|
$decreaseToWarning ? 'cite_warning' : 'cite_error',
|
|
wfMessage( $key, $param )->inLanguage( $lang )->plain()
|
|
)
|
|
->inLanguage( $lang )
|
|
->plain();
|
|
|
|
if ( $decreaseToWarning ) {
|
|
$ret = '<span class="warning mw-ext-cite-warning">' . $msg . '</span>';
|
|
} else {
|
|
$this->mParser->addTrackingCategory( 'cite-tracking-category-cite-error' );
|
|
|
|
$ret = '<strong class="error mw-ext-cite-error">' . $msg . '</strong>';
|
|
}
|
|
|
|
if ( $parse === 'parse' ) {
|
|
$ret = $this->mParser->recursiveTagParse( $ret );
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**
|
|
* Fetch references stored for the given title in page_props
|
|
* For performance, results are cached
|
|
*
|
|
* @param Title $title
|
|
* @return array|false
|
|
*/
|
|
public static function getStoredReferences( Title $title ) {
|
|
global $wgCiteStoreReferencesData;
|
|
if ( !$wgCiteStoreReferencesData ) {
|
|
return false;
|
|
}
|
|
$cache = ObjectCache::getMainWANInstance();
|
|
$key = $cache->makeKey( self::EXT_DATA_KEY, $title->getArticleID() );
|
|
return $cache->getWithSetCallback(
|
|
$key,
|
|
self::CACHE_DURATION_ONFETCH,
|
|
function ( $oldValue, &$ttl, array &$setOpts ) use ( $title ) {
|
|
$dbr = wfGetDB( DB_SLAVE );
|
|
$setOpts += Database::getCacheSetOptions( $dbr );
|
|
return self::recursiveFetchRefsFromDB( $title, $dbr );
|
|
},
|
|
array(
|
|
'checkKeys' => array( $key ),
|
|
'lockTSE' => 30,
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Reconstructs compressed json by successively retrieving the properties references-1, -2, etc
|
|
* It attempts the next step when a decoding error occurs.
|
|
* Returns json_decoded uncompressed string, with validation of json
|
|
*
|
|
* @param Title $title
|
|
* @param DatabaseBase $dbr
|
|
* @param string $string
|
|
* @param int $i
|
|
* @return array|false
|
|
*/
|
|
private static function recursiveFetchRefsFromDB( Title $title, DatabaseBase $dbr,
|
|
$string = '', $i = 1 ) {
|
|
$id = $title->getArticleID();
|
|
$result = $dbr->selectField(
|
|
'page_props',
|
|
'pp_value',
|
|
array(
|
|
'pp_page' => $id,
|
|
'pp_propname' => 'references-' . $i
|
|
),
|
|
__METHOD__
|
|
);
|
|
if ( $result !== false ) {
|
|
$string .= $result;
|
|
$decodedString = gzdecode( $string );
|
|
if ( $decodedString !== false ) {
|
|
$json = json_decode( $decodedString, true );
|
|
if ( json_last_error() === JSON_ERROR_NONE ) {
|
|
return $json;
|
|
}
|
|
// corrupted json ?
|
|
// shouldn't happen since when string is truncated, gzdecode should fail
|
|
wfDebug( "Corrupted json detected when retrieving stored references for title id $id" );
|
|
}
|
|
// if gzdecode fails, try to fetch next references- property value
|
|
return self::recursiveFetchRefsFromDB( $title, $dbr, $string, ++$i );
|
|
|
|
} else {
|
|
// no refs stored in page_props at this index
|
|
if ( $i > 1 ) {
|
|
// shouldn't happen
|
|
wfDebug( "Failed to retrieve stored references for title id $id" );
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**#@-*/
|
|
}
|