StringUtils.php

Go to the documentation of this file.

<?php
class StringUtils {
        static function hungryDelimiterReplace( $startDelim, $endDelim, $replace, $subject ) {
                $segments = explode( $startDelim, $subject );
                $output = array_shift( $segments );
                foreach ( $segments as $s ) {
                        $endDelimPos = strpos( $s, $endDelim );
                        if ( $endDelimPos === false ) {
                                $output .= $startDelim . $s;
                        } else {
                                $output .= $replace . substr( $s, $endDelimPos + strlen( $endDelim ) );
                        }
                }
                return $output;
        }

        static function delimiterReplaceCallback( $startDelim, $endDelim, $callback, $subject, $flags = '' ) {
                $inputPos = 0;
                $outputPos = 0;
                $output = '';
                $foundStart = false;
                $encStart = preg_quote( $startDelim, '!' );
                $encEnd = preg_quote( $endDelim, '!' );
                $strcmp = strpos( $flags, 'i' ) === false ? 'strcmp' : 'strcasecmp';
                $endLength = strlen( $endDelim );
                $m = array();

                while ( $inputPos < strlen( $subject ) &&
                  preg_match( "!($encStart)|($encEnd)!S$flags", $subject, $m, PREG_OFFSET_CAPTURE, $inputPos ) )
                {
                        $tokenOffset = $m[0][1];
                        if ( $m[1][0] != '' ) {
                                if ( $foundStart &&
                                  $strcmp( $endDelim, substr( $subject, $tokenOffset, $endLength ) ) == 0 )
                                {
                                        # An end match is present at the same location
                                        $tokenType = 'end';
                                        $tokenLength = $endLength;
                                } else {
                                        $tokenType = 'start';
                                        $tokenLength = strlen( $m[0][0] );
                                }
                        } elseif ( $m[2][0] != '' ) {
                                $tokenType = 'end';
                                $tokenLength = strlen( $m[0][0] );
                        } else {
                                throw new MWException( 'Invalid delimiter given to ' . __METHOD__ );
                        }

                        if ( $tokenType == 'start' ) {
                                # Only move the start position if we haven't already found a start
                                # This means that START START END matches outer pair
                                if ( !$foundStart ) {
                                        # Found start
                                        $inputPos = $tokenOffset + $tokenLength;
                                        # Write out the non-matching section
                                        $output .= substr( $subject, $outputPos, $tokenOffset - $outputPos );
                                        $outputPos = $tokenOffset;
                                        $contentPos = $inputPos;
                                        $foundStart = true;
                                } else {
                                        # Move the input position past the *first character* of START,
                                        # to protect against missing END when it overlaps with START
                                        $inputPos = $tokenOffset + 1;
                                }
                        } elseif ( $tokenType == 'end' ) {
                                if ( $foundStart ) {
                                        # Found match
                                        $output .= call_user_func( $callback, array(
                                                substr( $subject, $outputPos, $tokenOffset + $tokenLength - $outputPos ),
                                                substr( $subject, $contentPos, $tokenOffset - $contentPos )
                                        ));
                                        $foundStart = false;
                                } else {
                                        # Non-matching end, write it out
                                        $output .= substr( $subject, $inputPos, $tokenOffset + $tokenLength - $outputPos );
                                }
                                $inputPos = $outputPos = $tokenOffset + $tokenLength;
                        } else {
                                throw new MWException( 'Invalid delimiter given to ' . __METHOD__ );
                        }
                }
                if ( $outputPos < strlen( $subject ) ) {
                        $output .= substr( $subject, $outputPos );
                }
                return $output;
        }

        static function delimiterReplace( $startDelim, $endDelim, $replace, $subject, $flags = '' ) {
                $replacer = new RegexlikeReplacer( $replace );
                return self::delimiterReplaceCallback( $startDelim, $endDelim,
                        $replacer->cb(), $subject, $flags );
        }

        static function explodeMarkup( $separator, $text ) {
                $placeholder = "\x00";

                // Remove placeholder instances
                $text = str_replace( $placeholder, '', $text );

                // Replace instances of the separator inside HTML-like tags with the placeholder
                $replacer = new DoubleReplacer( $separator, $placeholder );
                $cleaned = StringUtils::delimiterReplaceCallback( '<', '>', $replacer->cb(), $text );

                // Explode, then put the replaced separators back in
                $items = explode( $separator, $cleaned );
                foreach( $items as $i => $str ) {
                        $items[$i] = str_replace( $placeholder, $separator, $str );
                }

                return $items;
        }

        static function escapeRegexReplacement( $string ) {
                $string = str_replace( '\\', '\\\\', $string );
                $string = str_replace( '$', '\\$', $string );
                return $string;
        }

        static function explode( $separator, $subject ) {
                if ( substr_count( $subject, $separator ) > 1000 ) {
                        return new ExplodeIterator( $separator, $subject );
                } else {
                        return new ArrayIterator( explode( $separator, $subject ) );
                }
        }
}

class Replacer {
        function cb() {
                return array( &$this, 'replace' );
        }
}

class RegexlikeReplacer extends Replacer {
        var $r;
        function __construct( $r ) {
                $this->r = $r;
        }

        function replace( $matches ) {
                $pairs = array();
                foreach ( $matches as $i => $match ) {
                        $pairs["\$$i"] = $match;
                }
                return strtr( $this->r, $pairs );
        }

}

class DoubleReplacer extends Replacer {
        function __construct( $from, $to, $index = 0 ) {
                $this->from = $from;
                $this->to = $to;
                $this->index = $index;
        }

        function replace( $matches ) {
                return str_replace( $this->from, $this->to, $matches[$this->index] );
        }
}

class HashtableReplacer extends Replacer {
        var $table, $index;

        function __construct( $table, $index = 0 ) {
                $this->table = $table;
                $this->index = $index;
        }

        function replace( $matches ) {
                return $this->table[$matches[$this->index]];
        }
}

class ReplacementArray {
        /*mostly private*/ var $data = false;
        /*mostly private*/ var $fss = false;

        function __construct( $data = array() ) {
                $this->data = $data;
        }

        function __sleep() {
                return array( 'data' );
        }

        function __wakeup() {
                $this->fss = false;
        }

        function setArray( $data ) {
                $this->data = $data;
                $this->fss = false;
        }

        function getArray() {
                return $this->data;
        }

        function setPair( $from, $to ) {
                $this->data[$from] = $to;
                $this->fss = false;
        }

        function mergeArray( $data ) {
                $this->data = array_merge( $this->data, $data );
                $this->fss = false;
        }

        function merge( $other ) {
                $this->data = array_merge( $this->data, $other->data );
                $this->fss = false;
        }

        function removePair( $from ) {
                unset($this->data[$from]);
                $this->fss = false;
        }

        function removeArray( $data ) {
                foreach( $data as $from => $to )
                        $this->removePair( $from );
                $this->fss = false;
        }

        function replace( $subject ) {
                if ( function_exists( 'fss_prep_replace' ) ) {
                        wfProfileIn( __METHOD__.'-fss' );
                        if ( $this->fss === false ) {
                                $this->fss = fss_prep_replace( $this->data );
                        }
                        $result = fss_exec_replace( $this->fss, $subject );
                        wfProfileOut( __METHOD__.'-fss' );
                } else {
                        wfProfileIn( __METHOD__.'-strtr' );
                        $result = strtr( $subject, $this->data );
                        wfProfileOut( __METHOD__.'-strtr' );
                }
                return $result;
        }
}

class ExplodeIterator implements Iterator {
        // The subject string
        var $subject, $subjectLength;

        // The delimiter
        var $delim, $delimLength;

        // The position of the start of the line
        var $curPos;

        // The position after the end of the next delimiter
        var $endPos;

        // The current token
        var $current;

        function __construct( $delim, $s ) {
                $this->subject = $s;
                $this->delim = $delim;

                // Micro-optimisation (theoretical)
                $this->subjectLength = strlen( $s );
                $this->delimLength = strlen( $delim );

                $this->rewind();
        }

        function rewind() {
                $this->curPos = 0;
                $this->endPos = strpos( $this->subject, $this->delim );
                $this->refreshCurrent();
        }


        function refreshCurrent() {
                if ( $this->curPos === false ) {
                        $this->current = false;
                } elseif ( $this->curPos >= $this->subjectLength ) {
                        $this->current = '';
                } elseif ( $this->endPos === false ) {
                        $this->current = substr( $this->subject, $this->curPos );
                } else {
                        $this->current = substr( $this->subject, $this->curPos, $this->endPos - $this->curPos );
                }
        }

        function current() {
                return $this->current;
        }

        function key() {
                return $this->curPos;
        }

        function next() {
                if ( $this->endPos === false ) {
                        $this->curPos = false;
                } else {
                        $this->curPos = $this->endPos + $this->delimLength;
                        if ( $this->curPos >= $this->subjectLength ) {
                                $this->endPos = false;
                        } else {
                                $this->endPos = strpos( $this->subject, $this->delim, $this->curPos );
                        }
                }
                $this->refreshCurrent();
                return $this->current;
        }

        function valid() {
                return $this->curPos !== false;
        }
}