Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00% covered (danger)
0.00%
0 / 1
88.89% covered (warning)
88.89%
8 / 9
CRAP
99.02% covered (success)
99.02%
101 / 102
ReferencesFormatter
0.00% covered (danger)
0.00%
0 / 1
88.89% covered (warning)
88.89%
8 / 9
35
99.02% covered (success)
99.02%
101 / 102
 __construct
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
4 / 4
 formatReferences
0.00% covered (danger)
0.00%
0 / 1
4.02
90.00% covered (success)
90.00%
9 / 10
 formatRefsList
100.00% covered (success)
100.00%
1 / 1
10
100.00% covered (success)
100.00%
23 / 23
 closeIndention
100.00% covered (success)
100.00%
1 / 1
3
100.00% covered (success)
100.00%
3 / 3
 formatListItem
100.00% covered (success)
100.00%
1 / 1
8
100.00% covered (success)
100.00%
39 / 39
 referenceText
100.00% covered (success)
100.00%
1 / 1
4
100.00% covered (success)
100.00%
6 / 6
 referencesFormatEntryNumericBacklinkLabel
100.00% covered (success)
100.00%
1 / 1
1
100.00% covered (success)
100.00%
4 / 4
 referencesFormatEntryAlternateBacklinkLabel
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
7 / 7
 listToText
100.00% covered (success)
100.00%
1 / 1
2
100.00% covered (success)
100.00%
6 / 6
<?php
namespace Cite;
use Html;
use Parser;
/**
 * @license GPL-2.0-or-later
 */
class ReferencesFormatter {
    /**
     * The backlinks, in order, to pass as $3 to
     * 'cite_references_link_many_format', defined in
     * 'cite_references_link_many_format_backlink_labels
     *
     * @var string[]|null
     */
    private $backlinkLabels = null;
    /**
     * @var ErrorReporter
     */
    private $errorReporter;
    /**
     * @var AnchorFormatter
     */
    private $anchorFormatter;
    /**
     * @var ReferenceMessageLocalizer
     */
    private $messageLocalizer;
    /**
     * @param ErrorReporter $errorReporter
     * @param AnchorFormatter $anchorFormatter
     * @param ReferenceMessageLocalizer $messageLocalizer
     */
    public function __construct(
        ErrorReporter $errorReporter,
        AnchorFormatter $anchorFormatter,
        ReferenceMessageLocalizer $messageLocalizer
    ) {
        $this->errorReporter = $errorReporter;
        $this->anchorFormatter = $anchorFormatter;
        $this->messageLocalizer = $messageLocalizer;
    }
    /**
     * @param Parser $parser
     * @param array[] $groupRefs
     * @param bool $responsive
     * @param bool $isSectionPreview
     *
     * @return string HTML
     */
    public function formatReferences(
        Parser $parser,
        array $groupRefs,
        bool $responsive,
        bool $isSectionPreview
    ): string {
        if ( !$groupRefs ) {
            return '';
        }
        $wikitext = $this->formatRefsList( $parser, $groupRefs, $isSectionPreview );
        // Live hack: parse() adds two newlines on WM, can't reproduce it locally -ævar
        $html = rtrim( $parser->recursiveTagParse( $wikitext ), "\n" );
        if ( $responsive ) {
            $wrapClasses = [ 'mw-references-wrap' ];
            if ( count( $groupRefs ) > 10 ) {
                $wrapClasses[] = 'mw-references-columns';
            }
            // Use a DIV wrap because column-count on a list directly is broken in Chrome.
            // See https://bugs.chromium.org/p/chromium/issues/detail?id=498730.
            return Html::rawElement( 'div', [ 'class' => $wrapClasses ], $html );
        }
        return $html;
    }
    /**
     * @param Parser $parser
     * @param array[] $groupRefs
     * @param bool $isSectionPreview
     *
     * @return string Wikitext
     */
    private function formatRefsList(
        Parser $parser,
        array $groupRefs,
        bool $isSectionPreview
    ): string {
        // After sorting the list, we can assume that references are in the same order as their
        // numbering.  Subreferences will come immediately after their parent.
        uasort(
            $groupRefs,
            static function ( array $a, array $b ): int {
                $cmp = ( $a['number'] ?? 0 ) - ( $b['number'] ?? 0 );
                return $cmp ?: ( $a['extendsIndex'] ?? 0 ) - ( $b['extendsIndex'] ?? 0 );
            }
        );
        // Add new lines between the list items (ref entries) to avoid confusing tidy (T15073).
        // Note: This builds a string of wikitext, not html.
        $parserInput = "\n";
        /** @var string|bool $indented */
        $indented = false;
        foreach ( $groupRefs as $key => $value ) {
            // Make sure the parent is not a subreference.
            // FIXME: Move to a validation function.
            if ( isset( $value['extends'] ) &&
                isset( $groupRefs[$value['extends']]['extends'] )
            ) {
                $value['text'] = ( $value['text'] ?? '' ) . ' ' .
                    $this->errorReporter->plain( $parser, 'cite_error_ref_nested_extends',
                        $value['extends'], $groupRefs[$value['extends']]['extends'] );
            }
            if ( !$indented && isset( $value['extends'] ) ) {
                // The nested <ol> must be inside the parent's <li>
                if ( preg_match( '#</li>\s*$#D', $parserInput, $matches, PREG_OFFSET_CAPTURE ) ) {
                    $parserInput = substr( $parserInput, 0, $matches[0][1] );
                }
                $parserInput .= Html::openElement( 'ol', [ 'class' => 'mw-extended-references' ] );
                $indented = $matches[0][0] ?? true;
            } elseif ( $indented && !isset( $value['extends'] ) ) {
                $parserInput .= $this->closeIndention( $indented );
                $indented = false;
            }
            $parserInput .= $this->formatListItem( $parser, $key, $value, $isSectionPreview ) . "\n";
        }
        $parserInput .= $this->closeIndention( $indented );
        return Html::rawElement( 'ol', [ 'class' => 'references' ], $parserInput );
    }
    /**
     * @param string|bool $closingLi
     *
     * @return string
     */
    private function closeIndention( $closingLi ): string {
        if ( !$closingLi ) {
            return '';
        }
        return Html::closeElement( 'ol' ) . ( is_string( $closingLi ) ? $closingLi : '' );
    }
    /**
     * @param Parser $parser
     * @param string|int $key The key of the reference
     * @param array $val A single reference as documented at {@see ReferenceStack::$refs}
     * @param bool $isSectionPreview
     *
     * @return string Wikitext, wrapped in a single <li> element
     */
    private function formatListItem(
        Parser $parser, $key, array $val, bool $isSectionPreview
    ): string {
        $text = $this->referenceText( $parser, $key, $val['text'] ?? null, $isSectionPreview );
        $error = '';
        $extraAttributes = '';
        if ( isset( $val['dir'] ) ) {
            $dir = strtolower( $val['dir'] );
            $extraAttributes = Html::expandAttributes( [ 'class' => 'mw-cite-dir-' . $dir ] );
        }
        // Special case for an incomplete follow="…". This is valid e.g. in the Page:… namespace on
        // Wikisource. Note this returns a <p>, not an <li> as expected!
        if ( isset( $val['follow'] ) ) {
            return $this->messageLocalizer->msg(
                'cite_references_no_link',
                $this->anchorFormatter->getReferencesKey( $val['follow'] ),
                $text
            )->plain();
        }
        // This counts the number of reuses. 0 means the reference appears only 1 time.
        if ( isset( $val['count'] ) && $val['count'] < 1 ) {
            // Anonymous, auto-numbered references can't be reused and get marked with a -1.
            if ( $val['count'] < 0 ) {
                $id = $val['key'];
                $backlinkId = $this->anchorFormatter->refKey( $val['key'] );
            } else {
                $id = $key . '-' . $val['key'];
                $backlinkId = $this->anchorFormatter->refKey( $key, $val['key'] . '-' . $val['count'] );
            }
            return $this->messageLocalizer->msg(
                'cite_references_link_one',
                $this->anchorFormatter->getReferencesKey( $id ),
                $backlinkId,
                $text . $error,
                $extraAttributes
            )->plain();
        }
        // Named references with >1 occurrences
        $backlinks = [];
        // There is no count in case of a section preview
        for ( $i = 0; $i <= ( $val['count'] ?? -1 ); $i++ ) {
            $backlinks[] = $this->messageLocalizer->msg(
                'cite_references_link_many_format',
                $this->anchorFormatter->refKey( $key, $val['key'] . '-' . $i ),
                $this->referencesFormatEntryNumericBacklinkLabel(
                    $val['number'] .
                        ( isset( $val['extendsIndex'] ) ? '.' . $val['extendsIndex'] : '' ),
                    $i,
                    $val['count']
                ),
                $this->referencesFormatEntryAlternateBacklinkLabel( $parser, $i )
            )->plain();
        }
        return $this->messageLocalizer->msg(
            'cite_references_link_many',
            $this->anchorFormatter->getReferencesKey( $key . '-' . ( $val['key'] ?? '' ) ),
            $this->listToText( $backlinks ),
            $text . $error,
            $extraAttributes
        )->plain();
    }
    /**
     * @param Parser $parser
     * @param string|int $key
     * @param ?string $text
     * @param bool $isSectionPreview
     *
     * @return string
     */
    private function referenceText(
        Parser $parser, $key, ?string $text, bool $isSectionPreview
    ): string {
        if ( $text === null ) {
            return $this->errorReporter->plain( $parser,
                $isSectionPreview
                    ? 'cite_warning_sectionpreview_no_text'
                    : 'cite_error_references_no_text', $key );
        }
        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
     *
     * @param int|string $base
     * @param int $offset
     * @param int $max Maximum value expected.
     *
     * @return string
     */
    private function referencesFormatEntryNumericBacklinkLabel(
        $base,
        int $offset,
        int $max
    ): string {
        return $this->messageLocalizer->localizeDigits( $base ) .
            $this->messageLocalizer->localizeSeparators( '.' ) .
            $this->messageLocalizer->localizeDigits(
                str_pad( (string)$offset, strlen( (string)$max ), '0', STR_PAD_LEFT )
            );
    }
    /**
     * Generate a custom format backlink given an offset, e.g.
     * $offset = 2; = c if $this->mBacklinkLabels = [ 'a',
     * 'b', 'c', ...]. Return an error if the offset > the # of
     * array items
     *
     * @param Parser $parser
     * @param int $offset
     *
     * @return string
     */
    private function referencesFormatEntryAlternateBacklinkLabel(
        Parser $parser, int $offset
    ): string {
        if ( $this->backlinkLabels === null ) {
            $this->backlinkLabels = preg_split(
                '/\s+/',
                $this->messageLocalizer->msg( 'cite_references_link_many_format_backlink_labels' )
                    ->plain()
            );
        }
        return $this->backlinkLabels[$offset]
            ?? $this->errorReporter->plain( $parser, 'cite_error_references_no_backlink_label' );
    }
    /**
     * 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.
     *
     * @param string[] $arr The array to format
     *
     * @return string
     */
    private function listToText( array $arr ): string {
        $lastElement = array_pop( $arr );
        if ( $arr === [] ) {
            return (string)$lastElement;
        }
        $sep = $this->messageLocalizer->msg( 'cite_references_link_many_sep' )->plain();
        $and = $this->messageLocalizer->msg( 'cite_references_link_many_and' )->plain();
        return implode( $sep, $arr ) . $and . $lastElement;
    }
}