Zgod­nie z zapo­wie­dzią, dzisiaj będziemy imple­men­to­wać moduły, które coś z poda­nym tekstem robią. Do tego celu głów­nie używać będziemy wyra­żeń regularnych.

1. Na pierw­szy ogień pójdzie popra­wiacz spacji. Jak często trafiają się wam doku­menty forma­to­wane za pomocą 20 spacji? Za pomocą tego cuda wywa­limy wszystko co ma powy­żej dwóch za koleją.

class SpaceFixer implements TextJob {
   public function process($string) {
      $string = trim($string);
      $string = preg_replace('/\s{2,}/' , ' ' , $string);
      return $string;
   }
}

Zasada dzia­ła­nia prosta: najpierw wyrzuć wszel­kie spacje przed i za strin­giem, a następ­nie poszu­kaj dwie lub więcej spacji za koleją i zamień je na pojedyncze.

2. Teraz coś sporo trud­niej­szego: doda­wacz twar­dych spacji do spój­ni­ków. Zasada dzia­ła­nia taka: znajdź mi spację, poje­dyn­czy znak, znowu spację i jeden lub więcej znaków (np. jedze­nie_i_picie).

class AddNbsps implements TextJob {
   public function process($string) {
      $output = ''; // inicjalizujemy pustą zmienną, zostało mi to po Javie
      foreach ($this->splitStringsByTagChar($string) as $split) {
         $output .= substr($split , 0 , 1) == '<' ? $split : $this->fixLine($split);
      }
      return $output;
   }
   private function splitStringsByTagChar($string) {
      return preg_split('/(<.+?>)/', $string, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
   }
   private function fixLine($line) {
      return preg_replace('/(\s{1}[-\("\w]{1})\s{1}([-\)"\w]+)/' , '$1&nbsp;$2' , $line);
   }
}

Jak widać trochę się pokom­pli­ko­wało. Po co nam te dodat­kowe funk­cje? Ano po to żeby nie popsuły się nasze HTMLowe tagi. Funk­cja splitStringsByTagChar nieza­chłan­nie szuka czegoś co przy­po­mina sekwen­cję <coś> i szat­kuje nam ciąg do tablicy.

Opera­tor trój­ar­gu­men­towy po fore­ach spraw­dza czy element tablicy zaczyna się od znaku < . Jeżeli tak, to zosta­wia go w spokoju, a jak nie, to kieruje do prze­róbki do fixLine. Można zauwa­żyć, że oprócz klasy znaków \w (alfa­nu­me­ryczne i _) doda­łem również ” ( ). Po prze­ana­li­zo­wa­niu kilku tekstów stwier­dzi­łem, że tak lepiej działa (a mogłoby pewnie lepiej gdybym poświę­cił na to jesz­cze trochę czasu).

3. Wyszu­ki­wacz linków.

class AddLinks implements TextJob {
   public function process($string) {
      return preg_replace('`(?<!href="|src=")((https?://|www\.)[\w{1,}./?=#&]+)`i' , '<a href="$1">$1</a>' , $string);
   }
}

Tutaj można zauwa­żyć dziwną konstruk­cję (?<! Jest to aser­cja wsteczna. Działa tak: znajdź mi ciąg znaków zaczy­na­jący się od http:// lub www., a jak znaj­dziesz, to sprawdź czy czasami przed znale­zio­nym ciągiem nie ma konstruk­cji z aser­cji. Po co to? Do wykry­cia, czy link znaj­duje się już w tagu <a href=” lub <img src=”, a więc czy nie popsu­jemy kodu html. Do tego mógł­bym równie dobrze użyć funk­cji szat­ku­ją­cej z poprzed­niego modułu, ale chcia­łem żeby było trudniej :-)

Jak tego wszyst­kiego używać? Dosyć prosto: w atry­bu­tach poda­jemy moduły, które nas inte­re­sują i poda­jemy tekst:

$jakisTekst = 'Ala ma kota, a kot ma HIV';
$txtProcesser = TextProcesser::getInstance(array('SpaceFixer','AddNbsps','AddLinks'));
$processedTxt = $txtProcesser->processJobs($jakisTekst);

Tekst będzie prze­twa­rzany w poda­nej kolej­no­ści. Fajne, co?
[czeka na oklaski]

Dzisiaj będzie wpis o ułatwia­niu życia użyt­kow­ni­kom paneli admi­ni­stra­cyj­nych. Chodzi tutaj o sytu­ację, gdy użyt­kow­nik naszej strony wkleja byle jak jakiś tekst z Worda do TinyMCE, a następ­nie dziwi się, że na stro­nie wycho­dzi kaszana.

Parę rzeczy da się popra­wić z auto­matu poprzez prze­two­rze­nie przez proce­sor tekstu. Skąd taki wziąć? A napi­szemy sobie sami.

W tym wpisie stwo­rzymy „rusz­to­wa­nie”, a w następ­nej części parę modu­łów robią­cych jakieś konkretne rzeczy.

Pierw­sze czego potrze­bu­jemy to inter­fejs poje­dyn­czego modułu prze­twa­rza­ją­cego tekst. Będzie banal­nie prosty: metoda process pobiera stringa i zwraca prze­two­rzo­nego stringa.

interface TextJob {
   public function process($string);
}

Dalej piszemy klasę proce­sora tekstu.

class TextProcesser {
   private $jobsToDo = array();
   private function __construct() {}
   public static function getInstance($params = array()) {
      $textProcesser = new TextProcesser();
      foreach ($params as $param) {
         try {
            if (!class_exists($param)) throw new Exception('Klasa ' . $param . ' nie istnieje!');
            $param = new $param;
            if (!($param instanceof TextJob)) throw new Exception('Klasa ' . $param . ' nie obsluguje interfejsu TextJob!');
         } catch (Exception $e) {
            echo $e->getMessage();
            die();
         }
         $textProcesser->addJob($param);
      }
      return $textProcesser;
   }
 
   private function addJob(TextJob $tj) {
      $this->jobsToDo[] = $tj;
   }
 
   public function processJobs($string) {
      foreach ($this->jobsToDo as $job) {
         $string = $job->process($string);
      }
      return $string;
   }
}

Po kolei:

1. Zmienna $jobsToDo trzyma tablicę prac do wykonania.
2. Klasy nie będziemy tworzyć poprzez konstruk­tor, dlatego został zmie­niony na prywatny.
3. Statyczna metoda getInstance tworzy obiekt proce­sora i przy okazji spraw­dza czy podana tablica $params zawiera istnie­jące klasy i czy imple­men­tują one inter­fejs TextJob.
4. Metoda addJob dodaje kolejną pracę do wyko­na­nia do kolejki.
5. processJobs wyko­nuje właściwą robotę — pobiera stringa do prze­two­rze­nia i w kolej­no­ści doda­nia prac prze­twa­rza go.

Co mamy do tej pory? Klasę, do której możemy doda­wać tyle konkret­nych zadań ile chcemy, o ile tylko imple­men­tują inter­fejs TextJob. W następ­nej części będziemy wyrzu­cać zbędne spacje, doda­wać twarde spacje i szukać linków.