includes/parser/StripState.php

   1 <?php
   2
   3 /**
   4  * @todo document, briefly.
   5  * @ingroup Parser
   6  */
   7 class StripState {
   8         protected $prefix;
   9         protected $data;
  10         protected $regex;
  11
  12         protected $tempType, $tempMergePrefix;
  13
  14         function __construct( $prefix ) {
  15                 $this->prefix = $prefix;
  16                 $this->data = array(
  17                         'nowiki' => array(),
  18                         'general' => array()
  19                 );
  20                 $this->regex = "/{$this->prefix}([^\x7f]+)" . Parser::MARKER_SUFFIX . '/';
  21         }
  22
  23         /**
  24          * Add a nowiki strip item
  25          * @param $marker
  26          * @param $value
  27          */
  28         function addNoWiki( $marker, $value ) {
  29                 $this->addItem( 'nowiki', $marker, $value );
  30         }
  31
  32         /**
  33          * @param $marker
  34          * @param $value
  35          */
  36         function addGeneral( $marker, $value ) {
  37                 $this->addItem( 'general', $marker, $value );
  38         }
  39
  40         /**
  41          * @throws MWException
  42          * @param $type
  43          * @param $marker
  44          * @param $value
  45          */
  46         protected function addItem( $type, $marker, $value ) {
  47                 if ( !preg_match( $this->regex, $marker, $m ) ) {
  48                         throw new MWException( "Invalid marker: $marker" );
  49                 }
  50
  51                 $this->data[$type][$m[1]] = $value;
  52         }
  53
  54         /**
  55          * @param $text
  56          * @return mixed
  57          */
  58         function unstripGeneral( $text ) {
  59                 return $this->unstripType( 'general', $text );
  60         }
  61
  62         /**
  63          * @param $text
  64          * @return mixed
  65          */
  66         function unstripNoWiki( $text ) {
  67                 return $this->unstripType( 'nowiki', $text );
  68         }
  69
  70         /**
  71          * @param  $text
  72          * @return mixed
  73          */
  74         function unstripBoth( $text ) {
  75                 $text = $this->unstripType( 'general', $text );
  76                 $text = $this->unstripType( 'nowiki', $text );
  77                 return $text;
  78         }
  79
  80         /**
  81          * @param $type
  82          * @param $text
  83          * @return mixed
  84          */
  85         protected function unstripType( $type, $text ) {
  86                 // Shortcut
  87                 if ( !count( $this->data[$type] ) ) {
  88                         return $text;
  89                 }
  90
  91                 wfProfileIn( __METHOD__ );
  92                 $this->tempType = $type;
  93                 do {
  94                         $oldText = $text;
  95                         $text = preg_replace_callback( $this->regex, array( $this, 'unstripCallback' ), $text );
  96                 } while ( $text !== $oldText );
  97                 $this->tempType = null;
  98                 wfProfileOut( __METHOD__ );
  99                 return $text;
 100         }
 101
 102         /**
 103          * @param $m array
 104          * @return array
 105          */
 106         protected function unstripCallback( $m ) {
 107                 if ( isset( $this->data[$this->tempType][$m[1]] ) ) {
 108                         return $this->data[$this->tempType][$m[1]];
 109                 } else {
 110                         if( preg_match( $this->regex, $m[0] ) ) {
 111                                 return "<strong class='error'>".htmlspecialchars( wfMsg( "stripstate-error" ) )."</strong>";
 112                         }
 113                         return $m[0];
 114                 }
 115         }
 116
 117         /**
 118          * Get a StripState object which is sufficient to unstrip the given text.
 119          * It will contain the minimum subset of strip items necessary.
 120          *
 121          * @param $text string
 122          *
 123          * @return StripState
 124          */
 125         function getSubState( $text ) {
 126                 $subState = new StripState( $this->prefix );
 127                 $pos = 0;
 128                 while ( true ) {
 129                         $startPos = strpos( $text, $this->prefix, $pos );
 130                         $endPos = strpos( $text, Parser::MARKER_SUFFIX, $pos );
 131                         if ( $startPos === false || $endPos === false ) {
 132                                 break;
 133                         }
 134
 135                         $endPos += strlen( Parser::MARKER_SUFFIX );
 136                         $marker = substr( $text, $startPos, $endPos - $startPos );
 137                         if ( !preg_match( $this->regex, $marker, $m ) ) {
 138                                 continue;
 139                         }
 140
 141                         $key = $m[1];
 142                         if ( isset( $this->data['nowiki'][$key] ) ) {
 143                                 $subState->data['nowiki'][$key] = $this->data['nowiki'][$key];
 144                         } elseif ( isset( $this->data['general'][$key] ) ) {
 145                                 $subState->data['general'][$key] = $this->data['general'][$key];
 146                         }
 147                         $pos = $endPos;
 148                 }
 149                 return $subState;
 150         }
 151
 152         /**
 153          * Merge another StripState object into this one. The strip marker keys
 154          * will not be preserved. The strings in the $texts array will have their
 155          * strip markers rewritten, the resulting array of strings will be returned.
 156          *
 157          * @param $otherState StripState
 158          * @param $texts Array
 159          * @return Array
 160          */
 161         function merge( $otherState, $texts ) {
 162                 $mergePrefix = Parser::getRandomString();
 163
 164                 foreach ( $otherState->data as $type => $items ) {
 165                         foreach ( $items as $key => $value ) {
 166                                 $this->data[$type]["$mergePrefix-$key"] = $value;
 167                         }
 168                 }
 169
 170                 $this->tempMergePrefix = $mergePrefix;
 171                 $texts = preg_replace_callback( $otherState->regex, array( $this, 'mergeCallback' ), $texts );
 172                 $this->tempMergePrefix = null;
 173                 return $texts;
 174         }
 175
 176         protected function mergeCallback( $m ) {
 177                 $key = $m[1];
 178                 return "{$this->prefix}{$this->tempMergePrefix}-$key" . Parser::MARKER_SUFFIX;
 179         }
 180 }
 181