AutoloadGenerator.php

Go to the documentation of this file.

<?php
 
class AutoloadGenerator {
    const FILETYPE_JSON = 'json';
    const FILETYPE_PHP = 'php';
 
    protected $basepath;
 
    protected $collector;
 
    protected $classes = [];
 
    protected $variableName = 'wgAutoloadClasses';
 
    protected $overrides = [];
 
    public function __construct( $basepath, $flags = [] ) {
        if ( !is_array( $flags ) ) {
            $flags = [ $flags ];
        }
        $this->basepath = self::normalizePathSeparator( realpath( $basepath ) );
        $this->collector = new ClassCollector;
        if ( in_array( 'local', $flags ) ) {
            $this->variableName = 'wgAutoloadLocalClasses';
        }
    }
 
    public function forceClassPath( $fqcn, $inputPath ) {
        $path = self::normalizePathSeparator( realpath( $inputPath ) );
        if ( !$path ) {
            throw new \Exception( "Invalid path: $inputPath" );
        }
        $len = strlen( $this->basepath );
        if ( substr( $path, 0, $len ) !== $this->basepath ) {
            throw new \Exception( "Path is not within basepath: $inputPath" );
        }
        $shortpath = substr( $path, $len );
        $this->overrides[$fqcn] = $shortpath;
    }
 
    public function readFile( $inputPath ) {
        // NOTE: do NOT expand $inputPath using realpath(). It is perfectly
        // reasonable for LocalSettings.php and similiar files to be symlinks
        // to files that are outside of $this->basepath.
        $inputPath = self::normalizePathSeparator( $inputPath );
        $len = strlen( $this->basepath );
        if ( substr( $inputPath, 0, $len ) !== $this->basepath ) {
            throw new \Exception( "Path is not within basepath: $inputPath" );
        }
        $result = $this->collector->getClasses(
            file_get_contents( $inputPath )
        );
        if ( $result ) {
            $shortpath = substr( $inputPath, $len );
            $this->classes[$shortpath] = $result;
        }
    }
 
    public function readDir( $dir ) {
        $it = new RecursiveDirectoryIterator(
            self::normalizePathSeparator( realpath( $dir ) ) );
        $it = new RecursiveIteratorIterator( $it );
 
        foreach ( $it as $path => $file ) {
            $ext = pathinfo( $path, PATHINFO_EXTENSION );
            // some older files in mw use .inc
            if ( $ext === 'php' || $ext === 'inc' ) {
                $this->readFile( $path );
            }
        }
    }
 
    protected function generateJsonAutoload( $filename ) {
        $key = 'AutoloadClasses';
        $json = FormatJson::decode( file_get_contents( $filename ), true );
        unset( $json[$key] );
        // Inverting the key-value pairs so that they become of the
        // format class-name : path when they get converted into json.
        foreach ( $this->classes as $path => $contained ) {
            foreach ( $contained as $fqcn ) {
                // Using substr to remove the leading '/'
                $json[$key][$fqcn] = substr( $path, 1 );
            }
        }
        foreach ( $this->overrides as $path => $fqcn ) {
            // Using substr to remove the leading '/'
            $json[$key][$fqcn] = substr( $path, 1 );
        }
 
        // Sorting the list of autoload classes.
        ksort( $json[$key] );
 
        // Return the whole JSON file
        return FormatJson::encode( $json, "\t", FormatJson::ALL_OK ) . "\n";
    }
 
    protected function generatePHPAutoload( $commandName, $filename ) {
        // No existing JSON file found; update/generate PHP file
        $content = [];
 
        // We need to generate a line each rather than exporting the
        // full array so __DIR__ can be prepended to all the paths
        $format = "%s => __DIR__ . %s,";
        foreach ( $this->classes as $path => $contained ) {
            $exportedPath = var_export( $path, true );
            foreach ( $contained as $fqcn ) {
                $content[$fqcn] = sprintf(
                    $format,
                    var_export( $fqcn, true ),
                    $exportedPath
                );
            }
        }
 
        foreach ( $this->overrides as $fqcn => $path ) {
            $content[$fqcn] = sprintf(
                $format,
                var_export( $fqcn, true ),
                var_export( $path, true )
            );
        }
 
        // sort for stable output
        ksort( $content );
 
        // extensions using this generator are appending to the existing
        // autoload.
        if ( $this->variableName === 'wgAutoloadClasses' ) {
            $op = '+=';
        } else {
            $op = '=';
        }
 
        $output = implode( "\n\t", $content );
        return
            <<<EOD
<?php
// This file is generated by $commandName, do not adjust manually
// @codingStandardsIgnoreFile
global \${$this->variableName};
 
\${$this->variableName} {$op} [
    {$output}
];
 
EOD;
    }
 
    public function getAutoload( $commandName = 'AutoloadGenerator' ) {
        // We need to check whether an extenson.json or skin.json exists or not, and
        // incase it doesn't, update the autoload.php file.
 
        $fileinfo = $this->getTargetFileinfo();
 
        if ( $fileinfo['type'] === self::FILETYPE_JSON ) {
            return $this->generateJsonAutoload( $fileinfo['filename'] );
        } else {
            return $this->generatePHPAutoload( $commandName, $fileinfo['filename'] );
        }
    }
 
    public function getTargetFileinfo() {
        $fileinfo = [
            'filename' => $this->basepath . '/autoload.php',
            'type' => self::FILETYPE_PHP
        ];
        if ( file_exists( $this->basepath . '/extension.json' ) ) {
            $fileinfo = [
                'filename' => $this->basepath . '/extension.json',
                'type' => self::FILETYPE_JSON
            ];
        } elseif ( file_exists( $this->basepath . '/skin.json' ) ) {
            $fileinfo = [
                'filename' => $this->basepath . '/skin.json',
                'type' => self::FILETYPE_JSON
            ];
        }
 
        return $fileinfo;
    }
 
    protected static function normalizePathSeparator( $path ) {
        return str_replace( '\\', '/', $path );
    }
 
    public function initMediaWikiDefault() {
        foreach ( [ 'includes', 'languages', 'maintenance', 'mw-config' ] as $dir ) {
            $this->readDir( $this->basepath . '/' . $dir );
        }
        foreach ( glob( $this->basepath . '/*.php' ) as $file ) {
            $this->readFile( $file );
        }
    }
}
 
class ClassCollector {
 
    protected $namespace = '';
 
    protected $classes;
 
    protected $startToken;
 
    protected $tokens;
 
    protected $alias;
 
    public function getClasses( $code ) {
        $this->namespace = '';
        $this->classes = [];
        $this->startToken = null;
        $this->alias = null;
        $this->tokens = [];
 
        foreach ( token_get_all( $code ) as $token ) {
            if ( $this->startToken === null ) {
                $this->tryBeginExpect( $token );
            } else {
                $this->tryEndExpect( $token );
            }
        }
 
        return $this->classes;
    }
 
    protected function tryBeginExpect( $token ) {
        if ( is_string( $token ) ) {
            return;
        }
        // Note: When changing class name discovery logic,
        // AutoLoaderTest.php may also need to be updated.
        switch ( $token[0] ) {
        case T_NAMESPACE:
        case T_CLASS:
        case T_INTERFACE:
        case T_TRAIT:
        case T_DOUBLE_COLON:
            $this->startToken = $token;
            break;
        case T_STRING:
            if ( $token[1] === 'class_alias' ) {
                $this->startToken = $token;
                $this->alias = [];
            }
        }
    }
 
    protected function tryEndExpect( $token ) {
        switch ( $this->startToken[0] ) {
        case T_DOUBLE_COLON:
            // Skip over T_CLASS after T_DOUBLE_COLON because this is something like
            // "self::static" which accesses the class name. It doens't define a new class.
            $this->startToken = null;
            break;
        case T_NAMESPACE:
            if ( $token === ';' || $token === '{' ) {
                $this->namespace = $this->implodeTokens() . '\\';
            } else {
                $this->tokens[] = $token;
            }
            break;
 
        case T_STRING:
            if ( $this->alias !== null ) {
                // Flow 1 - Two string literals:
                // - T_STRING  class_alias
                // - '('
                // - T_CONSTANT_ENCAPSED_STRING 'TargetClass'
                // - ','
                // - T_WHITESPACE
                // - T_CONSTANT_ENCAPSED_STRING 'AliasName'
                // - ')'
                // Flow 2 - Use of ::class syntax for first parameter
                // - T_STRING  class_alias
                // - '('
                // - T_STRING TargetClass
                // - T_DOUBLE_COLON ::
                // - T_CLASS class
                // - ','
                // - T_WHITESPACE
                // - T_CONSTANT_ENCAPSED_STRING 'AliasName'
                // - ')'
                if ( $token === '(' ) {
                    // Start of a function call to class_alias()
                    $this->alias = [ 'target' => false, 'name' => false ];
                } elseif ( $token === ',' ) {
                    // Record that we're past the first parameter
                    if ( $this->alias['target'] === false ) {
                        $this->alias['target'] = true;
                    }
                } elseif ( is_array( $token ) && $token[0] === T_CONSTANT_ENCAPSED_STRING ) {
                    if ( $this->alias['target'] === true ) {
                        // We already saw a first argument, this must be the second.
                        // Strip quotes from the string literal.
                        $this->alias['name'] = substr( $token[1], 1, -1 );
                    }
                } elseif ( $token === ')' ) {
                    // End of function call
                    $this->classes[] = $this->alias['name'];
                    $this->alias = null;
                    $this->startToken = null;
                } elseif ( !is_array( $token ) || (
                    $token[0] !== T_STRING &&
                    $token[0] !== T_DOUBLE_COLON &&
                    $token[0] !== T_CLASS &&
                    $token[0] !== T_WHITESPACE
                ) ) {
                    // Ignore this call to class_alias() - compat/Timestamp.php
                    $this->alias = null;
                    $this->startToken = null;
                }
            }
            break;
 
        case T_CLASS:
        case T_INTERFACE:
        case T_TRAIT:
            $this->tokens[] = $token;
            if ( is_array( $token ) && $token[0] === T_STRING ) {
                $this->classes[] = $this->namespace . $this->implodeTokens();
            }
        }
    }
 
    protected function implodeTokens() {
        $content = [];
        foreach ( $this->tokens as $token ) {
            $content[] = is_string( $token ) ? $token : $token[1];
        }
 
        $this->tokens = [];
        $this->startToken = null;
 
        return trim( implode( '', $content ), " \n\t" );
    }
}