ResourceLoaderImage.php

Go to the documentation of this file.

<?php
use MediaWiki\Shell\Shell;
 
class ResourceLoaderImage {
 
    protected static $fileTypes = [
        'svg' => 'image/svg+xml',
        'png' => 'image/png',
        'gif' => 'image/gif',
        'jpg' => 'image/jpg',
    ];
 
    private $name;
    private $module;
    private $descriptor;
    private $basePath;
    private $variants;
    private $defaultColor;
    private $extension;
 
    public function __construct( $name, $module, $descriptor, $basePath, $variants,
        $defaultColor = null
    ) {
        $this->name = $name;
        $this->module = $module;
        $this->descriptor = $descriptor;
        $this->basePath = $basePath;
        $this->variants = $variants;
        $this->defaultColor = $defaultColor;
 
        // Expand shorthands:
        // [ "en,de,fr" => "foo.svg" ]
        // → [ "en" => "foo.svg", "de" => "foo.svg", "fr" => "foo.svg" ]
        if ( is_array( $this->descriptor ) && isset( $this->descriptor['lang'] ) ) {
            foreach ( array_keys( $this->descriptor['lang'] ) as $langList ) {
                if ( strpos( $langList, ',' ) !== false ) {
                    $this->descriptor['lang'] += array_fill_keys(
                        explode( ',', $langList ),
                        $this->descriptor['lang'][$langList]
                    );
                    unset( $this->descriptor['lang'][$langList] );
                }
            }
        }
        // Remove 'deprecated' key
        if ( is_array( $this->descriptor ) ) {
            unset( $this->descriptor['deprecated'] );
        }
 
        // Ensure that all files have common extension.
        $extensions = [];
        $descriptor = is_array( $this->descriptor ) ? $this->descriptor : [ $this->descriptor ];
        array_walk_recursive( $descriptor, function ( $path ) use ( &$extensions ) {
            $extensions[] = pathinfo( $this->getLocalPath( $path ), PATHINFO_EXTENSION );
        } );
        $extensions = array_unique( $extensions );
        if ( count( $extensions ) !== 1 ) {
            throw new InvalidArgumentException(
                "File type for different image files of '$name' not the same in module '$module'"
            );
        }
        $ext = $extensions[0];
        if ( !isset( self::$fileTypes[$ext] ) ) {
            throw new InvalidArgumentException(
                "Invalid file type for image files of '$name' (valid: svg, png, gif, jpg) in module '$module'"
            );
        }
        $this->extension = $ext;
    }
 
    public function getName() {
        return $this->name;
    }
 
    public function getModule() {
        return $this->module;
    }
 
    public function getVariants() {
        return array_keys( $this->variants );
    }
 
    public function getPath( ResourceLoaderContext $context ) {
        $desc = $this->descriptor;
        if ( !is_array( $desc ) ) {
            return $this->getLocalPath( $desc );
        }
        if ( isset( $desc['lang'] ) ) {
            $contextLang = $context->getLanguage();
            if ( isset( $desc['lang'][$contextLang] ) ) {
                return $this->getLocalPath( $desc['lang'][$contextLang] );
            }
            $fallbacks = Language::getFallbacksFor( $contextLang, Language::STRICT_FALLBACKS );
            foreach ( $fallbacks as $lang ) {
                if ( isset( $desc['lang'][$lang] ) ) {
                    return $this->getLocalPath( $desc['lang'][$lang] );
                }
            }
        }
        if ( isset( $desc[$context->getDirection()] ) ) {
            return $this->getLocalPath( $desc[$context->getDirection()] );
        }
        if ( isset( $desc['default'] ) ) {
            return $this->getLocalPath( $desc['default'] );
        } else {
            throw new MWException( 'No matching path found' );
        }
    }
 
    protected function getLocalPath( $path ) {
        if ( $path instanceof ResourceLoaderFilePath ) {
            return $path->getLocalPath();
        }
 
        return "{$this->basePath}/$path";
    }
 
    public function getExtension( $format = 'original' ) {
        if ( $format === 'rasterized' && $this->extension === 'svg' ) {
            return 'png';
        }
        return $this->extension;
    }
 
    public function getMimeType( $format = 'original' ) {
        $ext = $this->getExtension( $format );
        return self::$fileTypes[$ext];
    }
 
    public function getUrl( ResourceLoaderContext $context, $script, $variant, $format ) {
        $query = [
            'modules' => $this->getModule(),
            'image' => $this->getName(),
            'variant' => $variant,
            'format' => $format,
        ];
        if ( $this->varyOnLanguage() ) {
            $query['lang'] = $context->getLanguage();
        }
        // The following parameters are at the end to keep the original order of the parameters.
        $query['skin'] = $context->getSkin();
        $rl = $context->getResourceLoader();
        $query['version'] = $rl->makeVersionQuery( $context, [ $this->getModule() ] );
 
        return wfAppendQuery( $script, $query );
    }
 
    public function getDataUri( ResourceLoaderContext $context, $variant, $format ) {
        $type = $this->getMimeType( $format );
        $contents = $this->getImageData( $context, $variant, $format );
        return CSSMin::encodeStringAsDataURI( $contents, $type );
    }
 
    public function getImageData( ResourceLoaderContext $context, $variant = false, $format = false ) {
        if ( $variant === false ) {
            $variant = $context->getVariant();
        }
        if ( $format === false ) {
            $format = $context->getFormat();
        }
 
        $path = $this->getPath( $context );
        if ( !file_exists( $path ) ) {
            throw new MWException( "File '$path' does not exist" );
        }
 
        if ( $this->getExtension() !== 'svg' ) {
            return file_get_contents( $path );
        }
 
        if ( $variant && isset( $this->variants[$variant] ) ) {
            $data = $this->variantize( $this->variants[$variant], $context );
        } else {
            $defaultColor = $this->defaultColor;
            $data = $defaultColor ?
                $this->variantize( [ 'color' => $defaultColor ], $context ) :
                file_get_contents( $path );
        }
 
        if ( $format === 'rasterized' ) {
            $data = $this->rasterize( $data );
            if ( !$data ) {
                wfDebugLog( 'ResourceLoaderImage', __METHOD__ . " failed to rasterize for $path" );
            }
        }
 
        return $data;
    }
 
    public function sendResponseHeaders( ResourceLoaderContext $context ) {
        $format = $context->getFormat();
        $mime = $this->getMimeType( $format );
        $filename = $this->getName() . '.' . $this->getExtension( $format );
 
        header( 'Content-Type: ' . $mime );
        header( 'Content-Disposition: ' .
            FileBackend::makeContentDisposition( 'inline', $filename ) );
    }
 
    protected function variantize( $variantConf, ResourceLoaderContext $context ) {
        $dom = new DOMDocument;
        $dom->loadXML( file_get_contents( $this->getPath( $context ) ) );
        $root = $dom->documentElement;
        $titleNode = null;
        $wrapper = $dom->createElementNS( 'http://www.w3.org/2000/svg', 'g' );
        // Reattach all direct children of the `<svg>` root node to the `<g>` wrapper
        while ( $root->firstChild ) {
            $node = $root->firstChild;
            // @phan-suppress-next-line PhanUndeclaredProperty False positive
            if ( !$titleNode && $node->nodeType === XML_ELEMENT_NODE && $node->tagName === 'title' ) {
                // Remember the first encountered `<title>` node
                $titleNode = $node;
            }
            $wrapper->appendChild( $node );
        }
        if ( $titleNode ) {
            // Reattach the `<title>` node to the `<svg>` root node rather than the `<g>` wrapper
            $root->appendChild( $titleNode );
        }
        $root->appendChild( $wrapper );
        $wrapper->setAttribute( 'fill', $variantConf['color'] );
        return $dom->saveXML();
    }
 
    protected function massageSvgPathdata( $svg ) {
        $dom = new DOMDocument;
        $dom->loadXML( $svg );
        foreach ( $dom->getElementsByTagName( 'path' ) as $node ) {
            $pathData = $node->getAttribute( 'd' );
            // Make sure there is at least one space between numbers, and that leading zero is not omitted.
            // rsvg has issues with syntax like "M-1-2" and "M.445.483" and especially "M-.445-.483".
            $pathData = preg_replace( '/(-?)(\d*\.\d+|\d+)/', ' ${1}0$2 ', $pathData );
            // Strip unnecessary leading zeroes for prettiness, not strictly necessary
            $pathData = preg_replace( '/([ -])0(\d)/', '$1$2', $pathData );
            $node->setAttribute( 'd', $pathData );
        }
        return $dom->saveXML();
    }
 
    protected function rasterize( $svg ) {
        global $wgSVGConverter, $wgSVGConverterPath;
 
        $svg = $this->massageSvgPathdata( $svg );
 
        // Sometimes this might be 'rsvg-secure'. Long as it's rsvg.
        if ( strpos( $wgSVGConverter, 'rsvg' ) === 0 ) {
            $command = 'rsvg-convert';
            if ( $wgSVGConverterPath ) {
                $command = Shell::escape( "$wgSVGConverterPath/" ) . $command;
            }
 
            $process = proc_open(
                $command,
                [ 0 => [ 'pipe', 'r' ], 1 => [ 'pipe', 'w' ] ],
                $pipes
            );
 
            if ( is_resource( $process ) ) {
                fwrite( $pipes[0], $svg );
                fclose( $pipes[0] );
                $png = stream_get_contents( $pipes[1] );
                fclose( $pipes[1] );
                proc_close( $process );
 
                return $png ?: false;
            }
            return false;
 
        } else {
            // Write input to and read output from a temporary file
            $tempFilenameSvg = tempnam( wfTempDir(), 'ResourceLoaderImage' );
            $tempFilenamePng = tempnam( wfTempDir(), 'ResourceLoaderImage' );
 
            file_put_contents( $tempFilenameSvg, $svg );
 
            $svgReader = new SVGReader( $tempFilenameSvg );
            $metadata = $svgReader->getMetadata();
            if ( !isset( $metadata['width'] ) || !isset( $metadata['height'] ) ) {
                unlink( $tempFilenameSvg );
                return false;
            }
 
            $handler = new SvgHandler;
            $res = $handler->rasterize(
                $tempFilenameSvg,
                $tempFilenamePng,
                $metadata['width'],
                $metadata['height']
            );
            unlink( $tempFilenameSvg );
 
            $png = null;
            if ( $res === true ) {
                $png = file_get_contents( $tempFilenamePng );
                unlink( $tempFilenamePng );
            }
 
            return $png ?: false;
        }
    }
 
    private function varyOnLanguage() {
        return is_array( $this->descriptor ) && (
            isset( $this->descriptor['ltr'] ) ||
            isset( $this->descriptor['rtl'] ) ||
            isset( $this->descriptor['lang'] ) );
    }
}