Xml.php

Go to the documentation of this file.

<?php
class Xml {
    public static function element( $element, $attribs = null, $contents = '',
        $allowShortTag = true
    ) {
        $out = '<' . $element;
        if ( !is_null( $attribs ) ) {
            $out .= self::expandAttributes( $attribs );
        }
        if ( is_null( $contents ) ) {
            $out .= '>';
        } else {
            if ( $allowShortTag && $contents === '' ) {
                $out .= ' />';
            } else {
                $out .= '>' . htmlspecialchars( $contents ) . "</$element>";
            }
        }
        return $out;
    }

    public static function expandAttributes( $attribs ) {
        $out = '';
        if ( is_null( $attribs ) ) {
            return null;
        } elseif ( is_array( $attribs ) ) {
            foreach ( $attribs as $name => $val ) {
                $out .= " {$name}=\"" . Sanitizer::encodeAttribute( $val ) . '"';
            }
            return $out;
        } else {
            throw new MWException( 'Expected attribute array, got something else in ' . __METHOD__ );
        }
    }

    public static function elementClean( $element, $attribs = [], $contents = '' ) {
        global $wgContLang;
        if ( $attribs ) {
            $attribs = array_map( [ 'UtfNormal\Validator', 'cleanUp' ], $attribs );
        }
        if ( $contents ) {
            $contents = $wgContLang->normalize( $contents );
        }
        return self::element( $element, $attribs, $contents );
    }

    public static function openElement( $element, $attribs = null ) {
        return '<' . $element . self::expandAttributes( $attribs ) . '>';
    }

    public static function closeElement( $element ) {
        return "</$element>";
    }

    public static function tags( $element, $attribs = null, $contents ) {
        return self::openElement( $element, $attribs ) . $contents . "</$element>";
    }

    public static function monthSelector( $selected = '', $allmonths = null, $id = 'month' ) {
        global $wgLang;
        $options = [];
        $data = new XmlSelect( 'month', $id, $selected );
        if ( is_null( $selected ) ) {
            $selected = '';
        }
        if ( !is_null( $allmonths ) ) {
            $options[wfMessage( 'monthsall' )->text()] = $allmonths;
        }
        for ( $i = 1; $i < 13; $i++ ) {
            $options[$wgLang->getMonthName( $i )] = $i;
        }
        $data->addOptions( $options );
        $data->setAttribute( 'class', 'mw-month-selector' );
        return $data->getHTML();
    }

    public static function dateMenu( $year, $month ) {
        # Offset overrides year/month selection
        if ( $month && $month !== -1 ) {
            $encMonth = intval( $month );
        } else {
            $encMonth = '';
        }
        if ( $year ) {
            $encYear = intval( $year );
        } elseif ( $encMonth ) {
            $timestamp = MWTimestamp::getInstance();
            $thisMonth = intval( $timestamp->format( 'n' ) );
            $thisYear = intval( $timestamp->format( 'Y' ) );
            if ( intval( $encMonth ) > $thisMonth ) {
                $thisYear--;
            }
            $encYear = $thisYear;
        } else {
            $encYear = '';
        }
        $inputAttribs = [ 'id' => 'year', 'maxlength' => 4, 'size' => 7 ];
        return self::label( wfMessage( 'year' )->text(), 'year' ) . ' ' .
            Html::input( 'year', $encYear, 'number', $inputAttribs ) . ' ' .
            self::label( wfMessage( 'month' )->text(), 'month' ) . ' ' .
            self::monthSelector( $encMonth, -1 );
    }

    public static function languageSelector( $selected, $customisedOnly = true,
        $inLanguage = null, $overrideAttrs = [], Message $msg = null
    ) {
        global $wgLanguageCode;

        $include = $customisedOnly ? 'mwfile' : 'mw';
        $languages = Language::fetchLanguageNames( $inLanguage, $include );

        // Make sure the site language is in the list;
        // a custom language code might not have a defined name...
        if ( !array_key_exists( $wgLanguageCode, $languages ) ) {
            $languages[$wgLanguageCode] = $wgLanguageCode;
        }

        ksort( $languages );

        $selected = isset( $languages[$selected] ) ? $selected : $wgLanguageCode;
        $options = "\n";
        foreach ( $languages as $code => $name ) {
            $options .= Xml::option( "$code - $name", $code, $code == $selected ) . "\n";
        }

        $attrs = [ 'id' => 'wpUserLanguage', 'name' => 'wpUserLanguage' ];
        $attrs = array_merge( $attrs, $overrideAttrs );

        if ( $msg === null ) {
            $msg = wfMessage( 'yourlanguage' );
        }
        return [
            Xml::label( $msg->text(), $attrs['id'] ),
            Xml::tags( 'select', $attrs, $options )
        ];

    }

    public static function span( $text, $class, $attribs = [] ) {
        return self::element( 'span', [ 'class' => $class ] + $attribs, $text );
    }

    public static function wrapClass( $text, $class, $tag = 'span', $attribs = [] ) {
        return self::tags( $tag, [ 'class' => $class ] + $attribs, $text );
    }

    public static function input( $name, $size = false, $value = false, $attribs = [] ) {
        $attributes = [ 'name' => $name ];

        if ( $size ) {
            $attributes['size'] = $size;
        }

        if ( $value !== false ) { // maybe 0
            $attributes['value'] = $value;
        }

        return self::element( 'input',
            Html::getTextInputAttributes( $attributes + $attribs ) );
    }

    public static function password( $name, $size = false, $value = false,
        $attribs = []
    ) {
        return self::input( $name, $size, $value,
            array_merge( $attribs, [ 'type' => 'password' ] ) );
    }

    public static function attrib( $name, $present = true ) {
        return $present ? [ $name => $name ] : [];
    }

    public static function check( $name, $checked = false, $attribs = [] ) {
        return self::element( 'input', array_merge(
            [
                'name' => $name,
                'type' => 'checkbox',
                'value' => 1 ],
            self::attrib( 'checked', $checked ),
            $attribs ) );
    }

    public static function radio( $name, $value, $checked = false, $attribs = [] ) {
        return self::element( 'input', [
            'name' => $name,
            'type' => 'radio',
            'value' => $value ] + self::attrib( 'checked', $checked ) + $attribs );
    }

    public static function label( $label, $id, $attribs = [] ) {
        $a = [ 'for' => $id ];

        foreach ( [ 'class', 'title' ] as $attr ) {
            if ( isset( $attribs[$attr] ) ) {
                $a[$attr] = $attribs[$attr];
            }
        }

        return self::element( 'label', $a, $label );
    }

    public static function inputLabel( $label, $name, $id, $size = false,
        $value = false, $attribs = []
    ) {
        list( $label, $input ) = self::inputLabelSep( $label, $name, $id, $size, $value, $attribs );
        return $label . '&#160;' . $input;
    }

    public static function inputLabelSep( $label, $name, $id, $size = false,
        $value = false, $attribs = []
    ) {
        return [
            Xml::label( $label, $id, $attribs ),
            self::input( $name, $size, $value, [ 'id' => $id ] + $attribs )
        ];
    }

    public static function checkLabel( $label, $name, $id, $checked = false, $attribs = [] ) {
        global $wgUseMediaWikiUIEverywhere;
        $chkLabel = self::check( $name, $checked, [ 'id' => $id ] + $attribs ) .
            '&#160;' .
            self::label( $label, $id, $attribs );

        if ( $wgUseMediaWikiUIEverywhere ) {
            $chkLabel = self::openElement( 'div', [ 'class' => 'mw-ui-checkbox' ] ) .
                $chkLabel . self::closeElement( 'div' );
        }
        return $chkLabel;
    }

    public static function radioLabel( $label, $name, $value, $id,
        $checked = false, $attribs = []
    ) {
        return self::radio( $name, $value, $checked, [ 'id' => $id ] + $attribs ) .
            '&#160;' .
            self::label( $label, $id, $attribs );
    }

    public static function submitButton( $value, $attribs = [] ) {
        global $wgUseMediaWikiUIEverywhere;
        $baseAttrs = [
            'type' => 'submit',
            'value' => $value,
        ];
        // Done conditionally for time being as it is possible
        // some submit forms
        // might need to be mw-ui-destructive (e.g. delete a page)
        if ( $wgUseMediaWikiUIEverywhere ) {
            $baseAttrs['class'] = 'mw-ui-button mw-ui-constructive';
        }
        // Any custom attributes will take precendence of anything in baseAttrs e.g. override the class
        $attribs = $attribs + $baseAttrs;
        return Html::element( 'input', $attribs );
    }

    public static function option( $text, $value = null, $selected = false,
            $attribs = [] ) {
        if ( !is_null( $value ) ) {
            $attribs['value'] = $value;
        }
        if ( $selected ) {
            $attribs['selected'] = 'selected';
        }
        return Html::element( 'option', $attribs, $text );
    }

    public static function listDropDown( $name = '', $list = '', $other = '',
        $selected = '', $class = '', $tabindex = null
    ) {
        $optgroup = false;

        $options = self::option( $other, 'other', $selected === 'other' );

        foreach ( explode( "\n", $list ) as $option ) {
            $value = trim( $option );
            if ( $value == '' ) {
                continue;
            } elseif ( substr( $value, 0, 1 ) == '*' && substr( $value, 1, 1 ) != '*' ) {
                // A new group is starting ...
                $value = trim( substr( $value, 1 ) );
                if ( $optgroup ) {
                    $options .= self::closeElement( 'optgroup' );
                }
                $options .= self::openElement( 'optgroup', [ 'label' => $value ] );
                $optgroup = true;
            } elseif ( substr( $value, 0, 2 ) == '**' ) {
                // groupmember
                $value = trim( substr( $value, 2 ) );
                $options .= self::option( $value, $value, $selected === $value );
            } else {
                // groupless reason list
                if ( $optgroup ) {
                    $options .= self::closeElement( 'optgroup' );
                }
                $options .= self::option( $value, $value, $selected === $value );
                $optgroup = false;
            }
        }

        if ( $optgroup ) {
            $options .= self::closeElement( 'optgroup' );
        }

        $attribs = [];

        if ( $name ) {
            $attribs['id'] = $name;
            $attribs['name'] = $name;
        }

        if ( $class ) {
            $attribs['class'] = $class;
        }

        if ( $tabindex ) {
            $attribs['tabindex'] = $tabindex;
        }

        return Xml::openElement( 'select', $attribs )
            . "\n"
            . $options
            . "\n"
            . Xml::closeElement( 'select' );
    }

    public static function fieldset( $legend = false, $content = false, $attribs = [] ) {
        $s = Xml::openElement( 'fieldset', $attribs ) . "\n";

        if ( $legend ) {
            $s .= Xml::element( 'legend', null, $legend ) . "\n";
        }

        if ( $content !== false ) {
            $s .= $content . "\n";
            $s .= Xml::closeElement( 'fieldset' ) . "\n";
        }

        return $s;
    }

    public static function textarea( $name, $content, $cols = 40, $rows = 5, $attribs = [] ) {
        return self::element( 'textarea',
                    Html::getTextInputAttributes(
                        [
                            'name' => $name,
                            'id' => $name,
                            'cols' => $cols,
                            'rows' => $rows
                        ] + $attribs
                    ),
                    $content, false );
    }

    public static function escapeJsString( $string ) {
        // See ECMA 262 section 7.8.4 for string literal format
        $pairs = [
            "\\" => "\\\\",
            "\"" => "\\\"",
            '\'' => '\\\'',
            "\n" => "\\n",
            "\r" => "\\r",

            # To avoid closing the element or CDATA section
            "<" => "\\x3c",
            ">" => "\\x3e",

            # To avoid any complaints about bad entity refs
            "&" => "\\x26",

            # Work around https://bugzilla.mozilla.org/show_bug.cgi?id=274152
            # Encode certain Unicode formatting chars so affected
            # versions of Gecko don't misinterpret our strings;
            # this is a common problem with Farsi text.
            "\xe2\x80\x8c" => "\\u200c", // ZERO WIDTH NON-JOINER
            "\xe2\x80\x8d" => "\\u200d", // ZERO WIDTH JOINER
        ];

        return strtr( $string, $pairs );
    }

    public static function encodeJsVar( $value, $pretty = false ) {
        if ( $value instanceof XmlJsCode ) {
            return $value->value;
        }
        return FormatJson::encode( $value, $pretty, FormatJson::UTF8_OK );
    }

    public static function encodeJsCall( $name, $args, $pretty = false ) {
        foreach ( $args as &$arg ) {
            $arg = Xml::encodeJsVar( $arg, $pretty );
            if ( $arg === false ) {
                return false;
            }
        }

        return "$name(" . ( $pretty
            ? ( ' ' . implode( ', ', $args ) . ' ' )
            : implode( ',', $args )
        ) . ");";
    }

    private static function isWellFormed( $text ) {
        $parser = xml_parser_create( "UTF-8" );

        # case folding violates XML standard, turn it off
        xml_parser_set_option( $parser, XML_OPTION_CASE_FOLDING, false );

        if ( !xml_parse( $parser, $text, true ) ) {
            // $err = xml_error_string( xml_get_error_code( $parser ) );
            // $position = xml_get_current_byte_index( $parser );
            // $fragment = $this->extractFragment( $html, $position );
            // $this->mXmlError = "$err at byte $position:\n$fragment";
            xml_parser_free( $parser );
            return false;
        }

        xml_parser_free( $parser );

        return true;
    }

    public static function isWellFormedXmlFragment( $text ) {
        $html =
            Sanitizer::hackDocType() .
            '<html>' .
            $text .
            '</html>';

        return Xml::isWellFormed( $html );
    }

    public static function escapeTagsOnly( $in ) {
        return str_replace(
            [ '"', '>', '<' ],
            [ '&quot;', '&gt;', '&lt;' ],
            $in );
    }

    public static function buildForm( $fields, $submitLabel = null, $submitAttribs = [] ) {
        $form = '';
        $form .= "<table><tbody>";

        foreach ( $fields as $labelmsg => $input ) {
            $id = "mw-$labelmsg";
            $form .= Xml::openElement( 'tr', [ 'id' => $id ] );

            // TODO use a <label> here for accessibility purposes - will need
            // to either not use a table to build the form, or find the ID of
            // the input somehow.

            $form .= Xml::tags( 'td', [ 'class' => 'mw-label' ], wfMessage( $labelmsg )->parse() );
            $form .= Xml::openElement( 'td', [ 'class' => 'mw-input' ] )
                . $input . Xml::closeElement( 'td' );
            $form .= Xml::closeElement( 'tr' );
        }

        if ( $submitLabel ) {
            $form .= Xml::openElement( 'tr' );
            $form .= Xml::tags( 'td', [], '' );
            $form .= Xml::openElement( 'td', [ 'class' => 'mw-submit' ] )
                . Xml::submitButton( wfMessage( $submitLabel )->text(), $submitAttribs )
                . Xml::closeElement( 'td' );
            $form .= Xml::closeElement( 'tr' );
        }

        $form .= "</tbody></table>";

        return $form;
    }

    public static function buildTable( $rows, $attribs = [], $headers = null ) {
        $s = Xml::openElement( 'table', $attribs );

        if ( is_array( $headers ) ) {
            $s .= Xml::openElement( 'thead', $attribs );

            foreach ( $headers as $id => $header ) {
                $attribs = [];

                if ( is_string( $id ) ) {
                    $attribs['id'] = $id;
                }

                $s .= Xml::element( 'th', $attribs, $header );
            }
            $s .= Xml::closeElement( 'thead' );
        }

        foreach ( $rows as $id => $row ) {
            $attribs = [];

            if ( is_string( $id ) ) {
                $attribs['id'] = $id;
            }

            $s .= Xml::buildTableRow( $attribs, $row );
        }

        $s .= Xml::closeElement( 'table' );

        return $s;
    }

    public static function buildTableRow( $attribs, $cells ) {
        $s = Xml::openElement( 'tr', $attribs );

        foreach ( $cells as $id => $cell ) {
            $attribs = [];

            if ( is_string( $id ) ) {
                $attribs['id'] = $id;
            }

            $s .= Xml::element( 'td', $attribs, $cell );
        }

        $s .= Xml::closeElement( 'tr' );

        return $s;
    }
}

class XmlJsCode {
    public $value;

    function __construct( $value ) {
        $this->value = $value;
    }
}