mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/Cite
synced 2024-09-24 10:48:58 +00:00
3f30e08d77
This reverts commits944b245428andfa7be37d15. These resulted in too many new exciting behaviors for the improvement of nested refs behavior to be worth it. We should try again later. Also, use Parser::MARKER_PREFIX instead of $parser->uniqPrefix() which has been deprecated in the meantime by 12571bde. Fixes T101390, fixes T100477. Reopens T22707, reopens T18330. Bug: T100477 Bug: T101390 Change-Id: I1a71854cf24e85697ab171be43eeec9054bc504c
1158 lines
33 KiB
PHP
1158 lines
33 KiB
PHP
<?php
|
|
|
|
/**#@+
|
|
* 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
|
|
*/
|
|
|
|
/**
|
|
* WARNING: MediaWiki core hardcodes this class name to check if the
|
|
* Cite extension is installed. See T89151.
|
|
*/
|
|
class Cite {
|
|
|
|
/**
|
|
* @todo document
|
|
*/
|
|
const DEFAULT_GROUP = '';
|
|
|
|
/**#@+
|
|
* @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();
|
|
|
|
/**
|
|
* 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();
|
|
}
|
|
|
|
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 {
|
|
# 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 6199) 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'] = $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 );
|
|
} elseif ( is_string( $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']
|
|
);
|
|
} else {
|
|
// 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 {
|
|
$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']
|
|
);
|
|
}
|
|
} else {
|
|
throw new Exception( 'Invalid stack key: ' . serialize( $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 ( count( $this->mRefs[$group] ) == 0 ) {
|
|
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/>" );
|
|
} else {
|
|
return htmlspecialchars( "<references>$str</references>" );
|
|
}
|
|
} else {
|
|
$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
|
|
$count = substr_count( $str, Parser::MARKER_PREFIX . "-ref-" );
|
|
for ( $i = 1; $i <= $count; $i++ ) {
|
|
if ( count( $this->mRefCallStack ) < 1 ) {
|
|
break;
|
|
}
|
|
|
|
# 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.
|
|
$call = array_pop( $this->mRefCallStack );
|
|
if ( $call !== false ) {
|
|
list( $type, $ref_argv, $ref_str,
|
|
$ref_key, $ref_group, $ref_index ) = $call;
|
|
|
|
# Undo effects of calling <ref> while unaware of containing <references>
|
|
$this->rollbackRef( $type, $ref_key, $ref_group, $ref_index );
|
|
|
|
# Rerun <ref> call now that mInReferences is set.
|
|
$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 ( count( $argv ) && $wgAllowCiteGroups ) {
|
|
return $this->error( 'cite_error_references_invalid_parameters_group' );
|
|
} elseif ( count( $argv ) ) {
|
|
return $this->error( 'cite_error_references_invalid_parameters' );
|
|
} else {
|
|
$s = $this->referencesFormat( $group );
|
|
if ( $parser->getOptions()->getIsSectionPreview() ) {
|
|
return $s;
|
|
}
|
|
|
|
# Append errors generated while processing <references>
|
|
if ( count( $this->mReferencesErrors ) > 0 ) {
|
|
$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 ( ( count( $this->mRefs ) == 0 ) || ( empty( $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 );
|
|
}
|
|
|
|
// 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 an error if refs were
|
|
* used without a references tag.
|
|
*
|
|
* @param $afterParse bool true if called from the ParserAfterParse hook
|
|
* @param $parser Parser
|
|
* @param $text string
|
|
*
|
|
* @return bool
|
|
*/
|
|
function checkRefsNoReferences( $afterParse, &$parser, &$text ) {
|
|
if ( $parser->extCite !== $this ) {
|
|
return $parser->extCite->checkRefsNoReferences( $afterParse, $parser, $text );
|
|
}
|
|
|
|
if ( $afterParse ) {
|
|
$this->mHaveAfterParse = true;
|
|
} elseif ( $this->mHaveAfterParse ) {
|
|
return true;
|
|
}
|
|
|
|
if ( $parser->getOptions()->getIsSectionPreview() ) {
|
|
return true;
|
|
}
|
|
|
|
foreach ( $this->mRefs as $group => $refs ) {
|
|
if ( count( $refs ) == 0 ) {
|
|
continue;
|
|
}
|
|
if ( $group == self::DEFAULT_GROUP ) {
|
|
$text .= $this->referencesFormat( $group, '', '' );
|
|
} else {
|
|
$text .= "\n<br />" .
|
|
$this->error( 'cite_error_group_refs_without_references', htmlspecialchars( $group ) );
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 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' ) {
|
|
# 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.
|
|
$msg = wfMessage( 'cite_error', wfMessage( $key, $param )->inContentLanguage()->plain() )
|
|
->inContentLanguage()
|
|
->plain();
|
|
|
|
$ret = '<strong class="error mw-ext-cite-error">' . $msg . '</strong>';
|
|
|
|
if ( $parse == 'parse' ) {
|
|
$ret = $this->mParser->recursiveTagParse( $ret );
|
|
}
|
|
|
|
return $ret;
|
|
}
|
|
|
|
/**#@-*/
|
|
}
|