StringMatcher.php

Go to the documentation of this file.

<?php
interface StringMangler {
    public static function EmptyMatcher();

    public function setConf( $configuration );

    public function match( $string );

    public function mangle( $data );

    public function unMangle( $data );
}

class StringMatcher implements StringMangler {
    protected $sPrefix = '';
    protected $aExact = array();
    protected $aPrefix = array();
    protected $aRegex = array();

    public static function EmptyMatcher() {
        return new StringMatcher;
    }

    public function __construct( $prefix = '', $patterns = array() ) {
        $this->sPrefix = $prefix;
        $this->init( $patterns );
    }

    protected static function getValidKeyChars() {
        static $valid = null;
        if ( $valid === null ) {
            global $wgLegalTitleChars;
            $valid = strtr( $wgLegalTitleChars, array(
                '=' => '', // equals sign, which is itself usef for escaping
                '&' => '', // ampersand, for entities
                '%' => '', // percent sign, which is used in URL encoding
            ) );
        }

        return $valid;
    }

    public function setConf( $conf ) {
        $this->sPrefix = $conf['prefix'];
        $this->init( $conf['patterns'] );
    }

    protected function init( array $strings ) {
        foreach ( $strings as $string ) {
            $pos = strpos( $string, '*' );
            if ( $pos === false ) {
                $this->aExact[] = $string;
            } elseif ( $pos + 1 === strlen( $string ) ) {
                $prefix = substr( $string, 0, -1 );
                $this->aPrefix[$prefix] = strlen( $prefix );
            } else {
                $string = str_replace( '\\*', '.+', preg_quote( $string ) );
                $this->aRegex[] = "/^$string$/";
            }
        }
    }

    public function match( $string ) {
        if ( in_array( $string, $this->aExact ) ) {
            return true;
        }

        foreach ( $this->aPrefix as $prefix => $len ) {
            if ( strncmp( $string, $prefix, $len ) === 0 ) {
                return true;
            }
        }

        foreach ( $this->aRegex as $regex ) {
            if ( preg_match( $regex, $string ) ) {
                return true;
            }
        }

        return false;
    }

    public function mangle( $data ) {
        if ( is_array( $data ) ) {
            return $this->mangleArray( $data );
        } elseif ( is_string( $data ) ) {
            return $this->mangleString( $data );
        } elseif ( $data === null ) {
            return $data;
        } else {
            throw new MWException( __METHOD__ . ": Unsupported datatype" );
        }
    }

    public function unMangle( $data ) {
        if ( is_array( $data ) ) {
            return $this->mangleArray( $data, true );
        } elseif ( is_string( $data ) ) {
            return $this->mangleString( $data, true );
        } elseif ( $data === null ) {
            return $data;
        } else {
            throw new MWException( __METHOD__ . ": Unsupported datatype" );
        }
    }

    protected function mangleString( $string, $reverse = false ) {
        if ( $reverse ) {
            return $this->unMangleString( $string );
        }

        if ( $this->match( $string ) ) {
            $string = $this->sPrefix . $string;
        }

        // Apply a "quoted-printable"-like escaping
        $valid = self::getValidKeyChars();
        $escapedString = preg_replace_callback( "/[^$valid]/",
            function ( $match ) {
                return '=' . sprintf( '%02X', ord( $match[0] ) );
            },
            $string
        );

        return $escapedString;
    }

    protected function unMangleString( $string ) {
        // Unescape the "quoted-printable"-like escaping,
        // which is applied in mangleString.
        $unescapedString = preg_replace_callback( "/=([A-F0-9]{2})/",
            function ( $match ) {
                return chr( hexdec( $match[0] ) );
            },
            $string
        );

        if ( strncmp( $unescapedString, $this->sPrefix, strlen( $this->sPrefix ) ) === 0 ) {
            return substr( $unescapedString, strlen( $this->sPrefix ) );
        } else {
            return $unescapedString;
        }
    }

    protected function mangleArray( array $array, $reverse = false ) {
        $temp = array();

        if ( isset( $array[0] ) ) {
            foreach ( $array as $key => &$value ) {
                $value = $this->mangleString( $value, $reverse );
                $temp[$key] = $value; // Assign a reference
            }
        } else {
            foreach ( $array as $key => &$value ) {
                $key = $this->mangleString( $key, $reverse );
                $temp[$key] = $value; // Assign a reference
            }
        }

        return $temp;
    }
}