SpamRegexBatch.php

Go to the documentation of this file.

<?php
 
class SpamRegexBatch {
    private static function buildRegexes( $lines, BaseBlacklist $blacklist, $batchSize = 4096 ) {
        # Make regex
        # It's faster using the S modifier even though it will usually only be run once
        // $regex = 'https?://+[a-z0-9_\-.]*(' . implode( '|', $lines ) . ')';
        // return '/' . str_replace( '/', '\/', preg_replace('|\\\*/|', '/', $regex) ) . '/Sim';
        $regexes = [];
        $regexStart = $blacklist->getRegexStart();
        $regexEnd = $blacklist->getRegexEnd( $batchSize );
        $build = false;
        foreach ( $lines as $line ) {
            if ( substr( $line, -1, 1 ) == "\\" ) {
                // Final \ will break silently on the batched regexes.
                // Skip it here to avoid breaking the next line;
                // warnings from getBadLines() will still trigger on
                // edit to keep new ones from floating in.
                continue;
            }
            // FIXME: not very robust size check, but should work. :)
            if ( $build === false ) {
                $build = $line;
            } elseif ( strlen( $build ) + strlen( $line ) > $batchSize ) {
                $regexes[] = $regexStart .
                    str_replace( '/', '\/', preg_replace( '|\\\*/|u', '/', $build ) ) .
                    $regexEnd;
                $build = $line;
            } else {
                $build .= '|';
                $build .= $line;
            }
        }
        if ( $build !== false ) {
            $regexes[] = $regexStart .
                str_replace( '/', '\/', preg_replace( '|\\\*/|u', '/', $build ) ) .
                $regexEnd;
        }
        return $regexes;
    }
 
    private static function validateRegexes( $regexes ) {
        foreach ( $regexes as $regex ) {
            Wikimedia\suppressWarnings();
            // @phan-suppress-next-line PhanParamSuspiciousOrder False positive
            $ok = preg_match( $regex, '' );
            Wikimedia\restoreWarnings();
 
            if ( $ok === false ) {
                return false;
            }
        }
        return true;
    }
 
    private static function stripLines( $lines ) {
        return array_filter(
            array_map( 'trim',
                preg_replace( '/#.*$/', '',
                    $lines ) ) );
    }
 
    private static function buildSafeRegexes( $lines, BaseBlacklist $blacklist, $fileName = false ) {
        $lines = self::stripLines( $lines );
        $regexes = self::buildRegexes( $lines, $blacklist );
        if ( self::validateRegexes( $regexes ) ) {
            return $regexes;
        } else {
            // _Something_ broke... rebuild line-by-line; it'll be
            // slower if there's a lot of blacklist lines, but one
            // broken line won't take out hundreds of its brothers.
            if ( $fileName ) {
                wfDebugLog( 'SpamBlacklist', "Spam blacklist warning: bogus line in $fileName\n" );
            }
            return self::buildRegexes( $lines, $blacklist, 0 );
        }
    }
 
    public static function getBadLines( $lines, BaseBlacklist $blacklist ) {
        $lines = self::stripLines( $lines );
 
        $badLines = [];
        foreach ( $lines as $line ) {
            if ( substr( $line, -1, 1 ) == "\\" ) {
                // Final \ will break silently on the batched regexes.
                $badLines[] = $line;
            }
        }
 
        $regexes = self::buildRegexes( $lines, $blacklist );
        if ( self::validateRegexes( $regexes ) ) {
            // No other problems!
            return $badLines;
        }
 
        // Something failed in the batch, so check them one by one.
        foreach ( $lines as $line ) {
            $regexes = self::buildRegexes( [ $line ], $blacklist );
            if ( !self::validateRegexes( $regexes ) ) {
                $badLines[] = $line;
            }
        }
        return $badLines;
    }
 
    public static function regexesFromText( $source, BaseBlacklist $blacklist, $fileName = false ) {
        $lines = explode( "\n", $source );
        return self::buildSafeRegexes( $lines, $blacklist, $fileName );
    }
 
    public static function regexesFromMessage( $message, BaseBlacklist $blacklist ) {
        $source = wfMessage( $message )->inContentLanguage();
        if ( !$source->isDisabled() ) {
            return self::regexesFromText( $source->plain(), $blacklist );
        } else {
            return [];
        }
    }
}