ResourceLoaderImage.php

Go to the documentation of this file.

<?php
class ResourceLoaderImage {
 
    protected static $fileTypes = [
        'svg' => 'image/svg+xml',
        'png' => 'image/png',
        'gif' => 'image/gif',
        'jpg' => 'image/jpg',
    ];
 
    public function __construct( $name, $module, $descriptor, $basePath, $variants ) {
        $this->name = $name;
        $this->module = $module;
        $this->descriptor = $descriptor;
        $this->basePath = $basePath;
        $this->variants = $variants;
 
        // 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] );
                }
            }
        }
 
        // Ensure that all files have common extension.
        $extensions = [];
        $descriptor = (array)$descriptor;
        array_walk_recursive( $descriptor, function ( $path ) use ( &$extensions ) {
            $extensions[] = pathinfo( $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"
            );
        }
        $ext = $extensions[0];
        if ( !isset( self::$fileTypes[$ext] ) ) {
            throw new InvalidArgumentException(
                "Invalid file type for image files of '$name' (valid: svg, png, gif, jpg)"
            );
        }
        $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_string( $desc ) ) {
            return $this->basePath . '/' . $desc;
        } elseif ( isset( $desc['lang'][$context->getLanguage()] ) ) {
            return $this->basePath . '/' . $desc['lang'][$context->getLanguage()];
        } elseif ( isset( $desc[$context->getDirection()] ) ) {
            return $this->basePath . '/' . $desc[$context->getDirection()];
        } else {
            return $this->basePath . '/' . $desc['default'];
        }
    }
 
    public function getExtension( $format = 'original' ) {
        if ( $format === 'rasterized' && $this->extension === 'svg' ) {
            return 'png';
        } else {
            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,
            'lang' => $context->getLanguage(),
            'version' => $context->getVersion(),
        ];
 
        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 {
            $data = 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;
        $wrapper = $dom->createElement( 'g' );
        while ( $root->firstChild ) {
            $wrapper->appendChild( $root->firstChild );
        }
        $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 = wfEscapeShellArg( "$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 );
 
            $metadata = SVGMetadataExtractor::getMetadata( $tempFilenameSvg );
            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;
        }
    }
}