LinksUpdateHookHandler.php

Go to the documentation of this file.

<?php
 
namespace PageImages\Hooks;
 
use DerivativeContext;
use Exception;
use File;
use FormatMetadata;
use Http;
use LinksUpdate;
use PageImages;
use Title;
use Revision;
 
class LinksUpdateHookHandler {
 
    public static function onLinksUpdate( LinksUpdate $linksUpdate ) {
        $handler = new self();
        $handler->doLinksUpdate( $linksUpdate );
    }
 
    public function getPageImageCandidates( LinksUpdate $linksUpdate ) {
        global $wgPageImagesLeadSectionOnly;
        $po = false;
 
        if ( $wgPageImagesLeadSectionOnly ) {
            $rev = $linksUpdate->getRevision();
            if ( !$rev ) {
                // Use READ_LATEST (T221763)
                $rev = Revision::newFromTitle( $linksUpdate->getTitle(), 0,
                    Revision::READ_LATEST );
            }
            if ( $rev ) {
                $content = $rev->getContent();
                if ( $content ) {
                    $section = $content->getSection( 0 );
 
                    // Certain content types e.g. AbstractContent return null if sections do not apply
                    if ( $section ) {
                        $po = $section->getParserOutput( $linksUpdate->getTitle() );
                    }
                }
            }
        } else {
            $po = $linksUpdate->getParserOutput();
        }
 
        return $po ? $po->getExtensionData( 'pageImages' ) : [];
    }
 
    public function doLinksUpdate( LinksUpdate $linksUpdate ) {
        $images = $this->getPageImageCandidates( $linksUpdate );
 
        if ( $images === null ) {
            return;
        }
 
        $scores = [];
        $counter = 0;
 
        foreach ( $images as $image ) {
            $fileName = $image['filename'];
 
            if ( !isset( $scores[$fileName] ) ) {
                $scores[$fileName] = -1;
            }
 
            $scores[$fileName] = max( $scores[$fileName], $this->getScore( $image, $counter++ ) );
        }
 
        $image = false;
        $free_image = false;
 
        foreach ( $scores as $name => $score ) {
            if ( $score > 0 ) {
                if ( !$image || $score > $scores[$image] ) {
                    $image = $name;
                }
                if ( ( !$free_image || $score > $scores[$free_image] ) && $this->isImageFree( $name ) ) {
                    $free_image = $name;
                }
            }
        }
 
        if ( $free_image ) {
            $linksUpdate->mProperties[PageImages::getPropName( true )] = $free_image;
        }
 
        // Only store the image if it's not free. Free image (if any) has already been stored above.
        if ( $image && $image !== $free_image ) {
            $linksUpdate->mProperties[PageImages::getPropName( false )] = $image;
        }
    }
 
    protected function getScore( array $image, $position ) {
        global $wgPageImagesScores;
 
        if ( isset( $image['handler'] ) ) {
            // Standalone image
            $score = $this->scoreFromTable( $image['handler']['width'], $wgPageImagesScores['width'] );
        } else {
            // From gallery
            $score = $this->scoreFromTable( $image['fullwidth'], $wgPageImagesScores['galleryImageWidth'] );
        }
 
        if ( isset( $wgPageImagesScores['position'][$position] ) ) {
            $score += $wgPageImagesScores['position'][$position];
        }
 
        $ratio = intval( $this->getRatio( $image ) * 10 );
        $score += $this->scoreFromTable( $ratio, $wgPageImagesScores['ratio'] );
 
        $blacklist = $this->getBlacklist();
        if ( isset( $blacklist[$image['filename']] ) ) {
            $score = -1000;
        }
 
        return $score;
    }
 
    protected function scoreFromTable( $value, array $scores ) {
        $lastScore = 0;
 
        // The loop stops at the *first* match, and therefore *requires* the input array keys to be
        // in increasing order.
        ksort( $scores, SORT_NUMERIC );
        foreach ( $scores as $upperBoundary => $score ) {
            $lastScore = $score;
 
            if ( $value <= $upperBoundary ) {
                break;
            }
        }
 
        if ( !is_numeric( $lastScore ) ) {
            wfLogWarning( 'The PageImagesScores setting must only contain numeric values!' );
        }
 
        return (float)$lastScore;
    }
 
    protected function isImageFree( $fileName ) {
        $file = wfFindFile( $fileName );
        if ( $file ) {
            // Process copyright metadata from CommonsMetadata, if present.
            // Image is considered free if the value is '0' or unset.
            return empty( $this->fetchFileMetadata( $file )['NonFree']['value'] );
        }
        return true;
    }
 
    protected function fetchFileMetadata( $file ) {
        $format = new FormatMetadata;
        $context = new DerivativeContext( $format->getContext() );
        // we don't care about the language, and specifying singleLanguage is slightly faster
        $format->setSingleLanguage( true );
        // we don't care about the language, so avoid splitting the cache by selecting English
        $context->setLanguage( 'en' );
        $format->setContext( $context );
        return $format->fetchExtendedMetadata( $file );
    }
 
    protected function getRatio( array $image ) {
        $width = $image['fullwidth'];
        $height = $image['fullheight'];
 
        if ( !$width || !$height ) {
            return 0;
        }
 
        return $width / $height;
    }
 
    protected function getBlacklist() {
        global $wgPageImagesBlacklist, $wgPageImagesBlacklistExpiry, $wgMemc;
        static $list = false;
 
        if ( $list !== false ) {
            return $list;
        }
 
        $key = wfMemcKey( 'pageimages', 'blacklist' );
        $list = $wgMemc->get( $key );
        if ( $list !== false ) {
            return $list;
        }
 
        wfDebug( __METHOD__ . "(): cache miss\n" );
        $list = [];
 
        foreach ( $wgPageImagesBlacklist as $source ) {
            switch ( $source['type'] ) {
                case 'db':
                    $list = array_merge( $list, $this->getDbBlacklist( $source['db'], $source['page'] ) );
                    break;
                case 'url':
                    $list = array_merge( $list, $this->getUrlBlacklist( $source['url'] ) );
                    break;
                default:
                    throw new Exception(
                        __METHOD__ . "(): unrecognized image blacklist type '{$source['type']}'" );
            }
        }
 
        $list = array_flip( $list );
        $wgMemc->set( $key, $list, $wgPageImagesBlacklistExpiry );
        return $list;
    }
 
    private function getDbBlacklist( $dbName, $page ) {
        $dbr = wfGetDB( DB_REPLICA, [], $dbName );
        $title = Title::newFromText( $page );
        $list = [];
 
        $id = $dbr->selectField(
            'page',
            'page_id',
            [ 'page_namespace' => $title->getNamespace(), 'page_title' => $title->getDBkey() ],
            __METHOD__
        );
 
        if ( $id ) {
            $res = $dbr->select( 'pagelinks',
                'pl_title',
                [ 'pl_from' => $id, 'pl_namespace' => NS_FILE ],
                __METHOD__
            );
            foreach ( $res as $row ) {
                $list[] = $row->pl_title;
            }
        }
 
        return $list;
    }
 
    private function getUrlBlacklist( $url ) {
        global $wgFileExtensions;
 
        $list = [];
        $text = Http::get( $url, [ 'timeout' => 3 ], __METHOD__ );
        $regex = '/\[\[:([^|\#]*?\.(?:' . implode( '|', $wgFileExtensions ) . '))/i';
 
        if ( $text && preg_match_all( $regex, $text, $matches ) ) {
            foreach ( $matches[1] as $s ) {
                $t = Title::makeTitleSafe( NS_FILE, $s );
 
                if ( $t ) {
                    $list[] = $t->getDBkey();
                }
            }
        }
 
        return $list;
    }
 
}