Jako że web developer goni za nowościami, przyszedł czas na upgrade serwerów testowych (przed wdrożeniem na produkcję). Czy zwykła zmiana wersji mogła odbyć się bez problemów ? Oczywiście że nie. To akurat wie każdy.

Korzystamy dla przechowywania sesji Memcached. Po pierwsze w miarę szybkie i ładnie działa, po drugie sesja jest wsþółdzielona pomiędzy sporo serwerów. Oczywiście logowanie przez SSL’a przestało działać.

Więc w pierwszej kolejności pretensje poszły do naszej aplikacji „Znowu coś zjebaliście !”, później memcache i na koniec serwer. A nie winne były ustawienia PHP. Jeśli posiadacie serwer oparty na Debianie lub jego potomków, sprawdźcie czy macie zainstalowane rozszerzenie Suhosin, a jeśli tak to czy poniższe zmienne macie tak ustawione.

suhosin.session.encrypt = off
suhosin.session.cryptua = off

To magiczne rozszerzenie ma skłonności to innego sposobu zapisywania danych w naszej sesji. Jest to string base64 po rozkodwaniu którego znajdujemy jakiś bliżej nie określony zapis binarny. Którego nie mamy jak rozkodować. Sytuacja jest o tyle dziwna, że ta sama domena z SSL’em i bez są traktowane jak by były osobno ale nie. Sesje pomiędzy tak parą domen są osobne. Każda zapisuje się oddzielnie, pod tym samym session_id. Oczywiście parametry sesji są ustawione tak żeby domeny wspólnie korzystały z sesji. Niestety nie udało mi się rozkodować tego co sesja zapisuje. Może jeszcze znajdę chwile to postaram się zrozumieć to zjawisko. W każdym bądź razie. Rozszerzenie wyłączyć lub zmienić ustawienia i problemy znikają.

W dniach od 21 do 23 maja odbył się pierwszy zlot/konferencja miłośników i entuzjastów PHP i dźwięcznej nazwie PHPCon. Szczerze mówiąc czułem się tam dość dziwacznie ponieważ nie posiadam laptopa, a tym bardziej MacBooka czy iPada. I ponadto potrafię znaleźć temat inny do rozmowy niż programowanie, globalna walka z bugami oraz obiektowo strukturalne skomplikowanie kodu.
Musze szczerze przyznać że większość wykładów była ciekawa. Oczywiście zdarzyły się wpadki (pozdrowienia dla Pana z firmy Microsoft) lub bardzo nudne wykłady. Ale ogólną ocenę wystawiam na cztery z dużym plusem. Samych wykładów nie chce oceniać bo każdy szukał tam czegoś innego, jedni się reklamowali, a inni przedstawiali swoją wiedzę w ciekawy sposób.
Wielkie ukłony w stroną organizatorów którzy stanęli powyżej postawionego sobie zadania, organizując w całości tak świetną imprezę. Mam nadzieje że w przyszłym roku również Oni popełnią kolejną edycje, przygotują ponownie ciekawe wykłady i zachęcą ludzi do przyjazdu.
Może następnym razem jakiś wykład o wydajności, skalowalności ? Może jeśli nie słuchać to samemu wyłożyć ? Może przygotować ankietę „Jakie wykłady chcielibyście usłyszeć?”.
Zdjęcia oraz materiały z prezentacji będziecie mogli pościągać z oficjalnej strony PHPCon jak tylko się pojawią.

Trudno mi powiedzieć co to takiego jest, albo raczej jak to nazwać. Kto używa Linuksa spotyka czasami się z wersją instalatora w postaci pliku .sh który dużo waży jest skryptem ale z sporym bagażem. Wszystko ładnie po otwarciu pliku widoczny jest rzeczywiście skrypt shell’a, ale jeśli przewiniemy wystarczająco nisko zobaczymy tam „krzaczki” czyli dane do rozpakowania.
No więc tak właśnie mechanizm stworzyłem na własny i przy okazji służbowy użytek.

Sama zasada działania jest prosta. Uruchamiany jest skrypt który Odczytuje sam siebie i rozpakowuje sam siebie. Niby nic trudnego, kwestia tylko przesunąć wskaźnik do miejsca gdzie zaczynają się dane do rozpakowania a kończy skrypt. Jedyne co trzeba zrobić to stworzyć taki plik. A do tego tez napiszemy automacik. Lubie automatyzować co tylko się da bo tak się żyje prościej (czasami)
Jako że wykorzystamy do tego rozszerzenie zlib możemy pakować pliki jeden za drugim, nie kompresujemy dużej ilości plików tylko każdy po kolei. Struktura pliku będzie wyglądać następująco:
Skrypt >> ([10 bajtowy nagłówek z liczba określającą długość skompresowanego pliku] >> [skompresowany plik z pełną ścieżka i nazwą pliku] ) x Dowolną ilość razy >> [end] (znacznik kończący).
Sam sens jest dość prosty. Najlepsze jest to że wielkość pliku nie wpłynie na ilość „pochłoniętej” pamięci, ponieważ na końcu skryptu „zabijamy” interpreter poprzez die() i zamykamy interpreter poprzez ?>.
W pierwszym nagłówku można by się postarać o bardziej finezyjną formę ale w chwili obecnej chodzi mi raczej o prostotę rozwiązania. w pierwszych 10 bajtach jest jawna, nieskompresowana liczba, która określa jak ile należy przeczytać aby pobrać cały plik i go rozpakować. Nagłówek pliku jest dopełniany pustymi miejscami do 10 znaków. Po tych znakach od razu rozpoczyna się skompresowany plik. Po zakończeniu pliku Rozpoczyna się kolejny 10 bajtowy nagłówek a po nich kolejny plik i tak dopóki zamiast 10 bajtowego nagłówka pojawi się string „[end]” oznaczający po prostu koniec pliku.
Aby wszystko działało musimy mieć dwa pliki wykonujące oraz katalog w którym znajdują się pliki do zainstalowania. Pierwszy plik wykonujący to skrypt rozpakowujący, ale bez danych o plikach. Taki powiedzmy szablon. który zostanie skopiowany, zmodyfikowany o pewna wartość a następnie dodany do niego „bagaż”.
Drugi plik to ów automacik który wykona za nas całą brudną robotę pakowania i modyfikacji szablonu. Pierwszym krokiem jest oczywiście skopiowanie szablonu, obliczenie jego długości „na pusto” i zmodyfikowanie go tak, aby wiedział od którego miejsca zaczyna się pierwszy nagłówek.
W szablonie zostawimy taka linijke

$seek = $xx;

Wstawione zmienna $xx jest unikalna i pojawia się tylko raz. Użyłem zmiennej a nie unikalnego „dziwnego” string’a aby edytor PHP nie pokazywał mi błędu. Wygodniej się wtedy pracuje. Oczywiście jeśli wielkość szablonu jest różny niż 3 cyfrowa liczba, to należy tą liczbę zmodyfikować, aby po dodaniu pokazywała na dobre miejsce. Dlaczego 3 cyfrowa ? Bo zastępuje ona 3 znakowy string oznaczający zmienną.

$desc = './init.php';
$size = filesize($desc);
if( strlen( (string)$size ) != 3 )  {
	$size =  $size + (strlen( (string)$size ) - 3);
}
file_put_contents($desc, str_replace('$xx', $size, file_get_contents($desc) ) );

Po zmodyfikowaniu szablonu, rozpoczynamy kompresje i doklejanie danych.

$content = gzcompress($filename.'__++__'.file_get_contents( $filename() ), 9 ); 
// __++__ służy jako unikalny znak rozdzielający ścieżke pliku od jego zawartości
$size = (strlen($content));
$size = str_pad($size, 10);
file_put_contents($desc, $size.$content, FILE_APPEND );
 
file_put_contents($desc, str_pad('[end]', 10), FILE_APPEND );
chmod($desc, 0755);

Oczywiście unikalny string „__++__” można zastąpić innym lub też zmodyfikować nagłówek tak, aby pomieścił długość danych oraz nazwę pliku. Można by też to skompresować dla mniejszej ilości danych ale należy tak dobrać tak długość nagłówka aby na pewno pomieścił wszystkie dane. Co oczywiście przy dłuższych nazwach plików lub ogólnie dłuższych ścieżkach może komplikować sprawę.
Może kiedyś zmodyfikuje żeby było bardziej pro
To na tyle jesli chodzi o kompresje, zakończenie pliku oraz ustawienie prac do wykonania. Wszystko później ubierzemy w jakiś ładny Iteratorek Rekursywny po katalogu do tego jakaś pętelka i już jesteśmy w domu. Działające pliki oczywiście na samym dole wpisu.

A jak działa sam szablon ? To proste. Odczytuje wartość przesunięcia i zmienia pozycje wskaźnika do pliku i odczytuje 10 bajtów nagłówka.

$seek = 786; //przykładowa wartość 
$end = false; //flaga dla ostatniego pliku
$gz = fopen(".$argv[0].", "r"); //wywolanie pliku z lini polecen przekazuje nazwe pliku w 0 elemencie tablicy $argv
fseek($gz, $seek); //przesuwamy wskaźnik
$size = trim( fread($gz, 10) ); //czytamy 10 bajtów nagłówka
if( $size == '[end]') {	$end = true; continue; 	} //szukanie znacznika koncowego
$seek += 10; // przesuwamy wartość o wielkość nagłówka

Po wykonaniu tego kodu mamy już ilość danych do przeczytania oraz zmienna gdzie mamy wartosc do jakiej mamy przesunąć wskaźnik aby trafił na początek danych pliku.

No więc czas odczytać zawartość pliku oraz jego nazwę, zapisać na dysk i tak dalej.

fseek($gz, $seek); //przesuwamy wskaźnik za nagłówek
$file = gzuncompress( fread($gz, $size) ); //odczytujemy dane i odrazu dekompresujemy
list($filename, $content) = explode('__++__', $file); //rozdzielamy nazwe pliku i dane
//sprawdzamy czy ewentualny katalog do pliku istnieje jesli nie to będziemy go tworzyć
$dir = dirname($filename);
if( !file_exists( $dir ) ) {
	mkdir($dir, 0755, true);
	echo "Directory $dir ... created\n";
}
//sprawdzamy czy sam plik istnieje
if( file_exists($filename) ) {
	echo "Error ! $filename allready exists !\n";
} else {
	file_put_contents($filename, $content);
	echo "$filename ... created\n";
}
//przesuwamy wartość o wielkość odczytywanych danych, co powinno wskazywać na nagłówek następnego pliku
$seek += $size;

I kolejny raz wystarczy ubrać wszystko w pętelke i wszystko będzie działać ładnie.

W obu skryptach można pokusić się o wiele udoskonaleń. Poprawić nagłówki aby trzymały, wielkość, nazwę pliku, jego uprawnienia. Dodatkowo szablon może sprawdzać wersje PHP czy posiada rozszerzenie „zlib„. W szale nudów można by stworzyć ładny wygląd przy rozpakowywaniu, jakiś progress bar albo nawet wizualizacje pod konsolą Linuksa w dodatku ncurses.
Można stworzyć samo wyzwalacz po rozpakowaniu, powiedzmy ładujący baze danych czy cokolwiek innego.

Modyfikacje pozostawiam czytelnikom którzy przypadkiem trafili na tą stronę i się zgubili i trafili na koniec tego posta. Swoje modyfikacje zaprezentuje pewnie w późniejszym czasie.
Poniżej w pełni działający szablon oraz „kompresor”.

Skrypt „Kompresora” (używam Linuksa więc dlatego ta pierwsza linijka, to tak jak by ktoś nie rozumiał)

#!/usr/bin/php
<?php
$source = './szablon.php';
$desc = './setup.php';
$path = './script_dir/';
if( file_exists($desc) ) {
	unlink($desc);
}
copy($source, $desc);
 
$size = filesize($desc);
if( strlen( (string)$size ) != 3 )  {
	$size =  $size + (strlen( (string)$size ) - 3);
}
file_put_contents($desc, str_replace('$xx', $size, file_get_contents($desc) ) );
 
 
$dir = new RecursiveIteratorIterator( new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST );
 
foreach( $dir as $file ) {
	if( !$file->isDir() ) {
		$filename = str_replace( $path, './', $file->getPath().'/'.$file->getFilename() );
		echo  $filename." ... ";
 
		$content = gzcompress($filename.'__++__'.file_get_contents( $file->getPath().'/'.$file->getFilename() ), 9 );
		$size = (strlen($content));
		$size = str_pad($size, 10);
 
		file_put_contents($desc, $size.$content, FILE_APPEND );
 
		echo " done\n";
	}
}
file_put_contents($desc, str_pad('[end]', 10), FILE_APPEND );
chmod($desc, 0755);
?>

Plik Szablonu

#!/usr/bin/php
<?php
 
$seek = $xx;
$end = false;
$gz = fopen(".$argv[0].", "r");
while( !$end ) {
	fseek($gz, $seek);
	$size = trim( fread($gz, 10) );
	if( $size == '[end]') {	$end = true; continue; 	}
	$seek += 10;
	fseek($gz, $seek);
	$file = gzuncompress( fread($gz, $size) );
	list($filename, $content) = explode('__++__', $file);
	$dir = dirname($filename);
	if( !file_exists( $dir ) ) {
		mkdir($dir, 0755, true);
		echo "Directory $dir ... created\n";
	}
	if( file_exists($filename) ) {
		echo "Error ! $filename allready exists !\n";
	} else {
		$content = str_replace('${nazwa_projektu}', $projekt, $content);
		file_put_contents($filename, $content);
		echo "$filename ... created\n";
	}
 
	$seek += $size;
}
gzclose($gz);
echo "Finish !\n";
die();
//pamietajcie zostawić enter na końcu szablonu !!!
?>

Na pewno sporo osób próbowało swoich sił w stworzeniu skryptu do zliczania odwiedzin na stronie na podstawie logów z Apache’a. W sumie nic trudnego, schemat logów jest w miarę prosty, odczytać i po sprawie. A jak wygląda sprawa przy plikach wielkości setek megabajtów lub gigabajtów ? Trzeba sprytnie to odczytywać linia po linii, przeanalizować i wywalić z pamięci. A jak mamy dwa lub więcej rdzeni w procesorze, to może by tak parę linii na raz analizować ?
Sama zasada jest dość prosta. Odczytujemy mały blok pliku i wyszukujemy gdzie jest znak końca linii. Jeśli nie znajdujemy to doczytujemy jeszcze kawałek. Jeśli już znaleźliśmy to odcinamy nasz kawałek i po sprawie. Przy wyszukiwaniu usuwamy wszystkie znaki powrotu karetki, jak by się znalazł jakiś plik z „enterami” z Windowsa.

$tresc = ''; //definiujemy zmienna 
$uchwyt = fopen('pliczek.log', "rb");
$tresc .= fread($uchwyt, 300 ); //dopisujemy do zmiennej kawałek pliku
$tresc = str_replace("\r",'',$tresc);
if( strpos( $tresc, chr(10) ) === false ) {
    //doczytujemy jeszcze kawalek i jeszcze raz szukamy i tak aż znajdziemy
} else {
    $strpos = strpos( $tresc, chr(10) ); //znajdujemy pozycje entera
    $linia = substr($tresc, 0, $strpos); //odcinamy interesujący nas odcinek
    $tresc = substr($tresc, $strpos+1, strlen($tresc) ); //i usuwamy odcięty kawałek od pobranej treści wraz z enterem i zostawiamy do następnego odczytu
   funkcjaAnalizujaca( $linia ); //możemy coś zwracać lub nie, to jest obojętne.
}

Oczywiście to trzeba ładnie ubrać w pętelkę gdzie będziemy się kręcić aż otrzymamy EOF (End Of File). Oczywiście można to wszystko ubrać w klasę, konfigurowalne zmienne, w dodatkowe zabawki typu zliczanie ilości linii, statystyka czasów analizy poszczególnych linii i inne wesołe rzeczy. Wszystkie takie rzeczy możecie podejrzeć w skrypcie który ja przygotowałem dla własnych celów, gdzie większość tych rzeczy jest już dodana.

Teraz apropo jednoczesnym przetwarzaniu więcej niż jednej linii jednocześnie. Niestety muszę zmartwić wielu z was, działa to jedynie pod systemami *unix oraz jedynie pod konsolą czyli wywoływane z linii poleceń. Windows oraz mod-php dla apache odpadają. To już jest ograniczenie od strony php. Będziemy korzystać z modułu Process Control, który nie jest domyślnie kompilowany do PHP. Żeby nie było nieścisłości to nie jest wielowątkowość ale fork czyli rozwidlenie procesu. Główny skrypt który jest rodzicem, tworzy dziecko które jest jego kopią. U nas tylko dzieci będą analizować pojedyncze linie logów, a rodzic będzie starał się nad tym „przedszkolem” zapanować. Zasady działania forków nie będę tłumaczył, jest Manual, jest Wikipedia no i Google.
Wiec ustalamy sobie maksymalną ilość dzieci. Niestety w zależności od sprzętu możecie zrobić ich więcej lub mniej. Musicie po testować różne ustawienia. Więc przykładowo będziemy pracowali z czwórką dzieci. Jako że procesy się nie komunikują między sobą wykorzystamy funkcję, która obsługuje otrzymane sygnały (pcntl_signal) a dokładniej chodzi nam o sygnał zakończenia procesu dziecka czyli SIGCHLD. Przy tworzeniu dziecka powiększamy licznik o 1 a gdy otrzymamy sygnał zamknięcia pomniejszamy. W ten sposób jesteśmy w stanie jakoś zapanować nad tym wszystkim. a oto przykład (brany gdzieś z manuala ale ten jest w miarę przejrzysty):

$child = 0;
$max=3;
function sig_handler($signo) {
    global $child; //zmienna która trzyma ilość "wyprodukowanych" dzieci
    switch ($signo) {
        case SIGCHLD:
            --$child;
            break;
        //tutaj możemy obsługiwać inne sygnały jak na przykład zamkniecie głównego skryptu, lub dowolnie wybrane przez nas sygnały
    }
}
 
pcntl_signal(SIGCHLD, "sig_handler");
 
for( $a=0; $a < 20; $a++ ) {
	$child++;
	$pid=pcntl_fork();
 
	if ($pid == -1) {
		die("Nie mozna zrobić dziecka");
	} elseif ($pid) {
 
		if ( $child >= $max ) {
			echo "Za dużo dzieci w przedszkolu \n";
			pcntl_wait($status);
		}
	} else {
		sleep( rand(1,10) );
		file_put_contents('./file.log', $a.'.', FILE_APPEND );  //zadanie do wykonania
		//dla przykładu wykonujemy zapis do pliku dla każdego dzieciaka, żeby pokazać że to naprawdę działa
		// a sleep pokaże ze czasami w różnych kolejnościach będzie to wykonywane, ze względu na rożny czas wykonania zadania
 
		exit;
	}
}

Tyle mechanizmu, który czyta plik. Jeśli chodzi o analizę pliku to już zależy co my tam robimy. Jako że kiedyś przymierzałem się do jakiegoś dużego analizatora to wykombinowałem takie małe wyrażenie regularne. Znając życie albo posiada błędy albo można go jeszcze zoptymalizować. Może i kiedyś przy tym usiądę ale chyba nie dziś. A oto ten malutki tasiemiec.

preg_match('/(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}) ([^\s]+) ([^\s]+) \[(\d{2}\/[a-zA-Z]{3}\/\d{4}:\d{2}:\d{2}:\d{2} [+|-]\d{4})\] "(?:(POST|GET|PUT|DELETE|CONNECT|OPTIONS|HEAD|TRACE) ((?:http:\/\/|\/)?[^\s]*(?:\/[^\/\s]*)?) (HTTP\/\d\.\d))" ([1-5]\d{2}) (-|\d+) "([^"]*)" "([^"]*)"/', $linia, $match);
list($calosc, $ip, $niemampojecia, $http_user, $data, $method, $url, $http_protocol, $http_code, $transfer, $referrer, $user_agent) = $match;

Oczywiście można to po swojemu wykorzystać. Ja osobiście, najczęściej zliczam wykorzystany transfer przez daną domenę. A jeśli chcecie zobaczyć jak tą całą opowieść ubrałem w skrypt to zapraszam do ściągnięcia pliku gdzie jest spakowany skrypt główny oraz przykładowe rozszerzenie do analizy logów ‘Combined’ z Apache.
Należy pamiętać, że skrypt który zlicza transfer z logów, nie powinien działać w trybie „pseudo-wielowątkowy”, ponieważ transfer jest zliczany w pamięci php, czyli jest zapisany w zmiennych. Jeśli ktoś ma ochotę to może przerobić tak skrypt aby zliczał transfer w pliku, w bazie danych lub innym zewnętrznym nośniku.

Z nudów człowiek robi dziwne rzeczy. Jedną z nich jest parser dla plików CSS. Początkowo miał być to tokenizer który pozwoliłby na tworzenie różnego rodzaju narzędzi operujących na stylach CSS. Niestety po zapoznaniu się dokładnie ze strukturą CSS w wersji 2.1 odkładam ten plan na bliżej nie określoną przyszłość. Ale na pewno napisze, bo może być to ciekawe doświadczenie.

Po co mi ten skrypt ? Bo czasami jak otrzymam od kogoś kawałek szablonu ze skryptami. To wygląda to jak pole po bitwie lub niekończące się tasiemce. Często w pracy grafik przysyła nam szablony pocięte do tego CSS gdzie każda klasa szablonu jest napisana w jednej linii, a do tego bardzo długiej. Ja preferuje zupełnie odmienny styl.

Na początek musimy przeanalizować plik CSS. Wykorzystamy do tego proste wyrażenia regularne, które rozpoznają nam poszczególne części. Musimy rozpoznać 3 podstawowe rzeczy: Nazwę klasy wraz z jej ‘ciałem’, następnie z ów ciała musimy wyciągnąć atrybuty i ich wartości. Trzecią i ostatnią rzeczą są komentarze, które z mojego punktu widzenia są w ogóle niepotrzebne więc w tej wersji są po prostu usuwane.

/* wyrazenie regularne do wyszukiwania klas */
$patern_main = '~([\.|#]?[^{]*)[\s]*\{([^}]*)\}~i';
/* wyrazenie regularne do wyszukiwania atrybutow w klasach */
$patern_css = '~([^\:\;\s]+)\s*:\s*([^\;\s]+)~i';
/* wyrazenie regularne do wyszukania i usuniecia komentarzy */
$patern_comments = '~\/\*[^*]*\*+([^/*][^*]*\*+)*\/~i';

Cała reszta jest już prosta. W pierwszej kolejności usuwamy wszystkie znaki nowej linii oraz tabulatory, a następnie pozbywamy się wszystkich komentarzy. czyli:

$css = file_get_contents('/sciezka/do/pliku.css');
$css = str_replace(array("\n", "\r", "\t"), '', $css );
/* usuwanie komentarzy */
$css = preg_replace($patern_comments, '', $css);

Tak obrobiony styl będziemy teraz przeszukiwać, korzystając z wyrażeń regularnych.

/* wyszukiwanie klas */
preg_match_all($patern_main, $css, $match);
 
$css_array = array();
foreach (array_keys($match[0]) as $key) {
	$css_match = array(); //czyscimy tablice w przypadku pustej klasy
	$css_body = trim( $match[2][ $key ] );
	if( $css_body != '' ) { //jesli definicja klasy jest pusta to ja opuszczamy
		preg_match_all($patern_css, $css_body, $css_match);
		$css_array[ trim( $match[1][ $key ] ) ] = array_combine($css_match[1], $css_match[2]);
	} else {
		$css_array[ trim( $match[1][ $key ] ) ] = array();
	}
}

W ten sposób mamy już „rozłożony” styl CSS na czynniki pierwsze. Można by się pokusić oczywiście o sprawdzanie poprawności poszczególnych elementów i ich wartości. Ale sądzę że jest to raczej czysta formalność stworzyć słownik atrybutów oraz ich dopuszczalnych wartości.
Drugim pomysłem może być powiedzmy analiza i wyszukanie powtarzających się klas lub też wielokrotne powtarzanie tych samych atrybutów wraz z wartościami w różnych klasach. Ale podejrzewam, że będzie to materiał na inny wpis.

Teraz może poukładamy wszystkie klasy na dwa sposoby, „tasiemiec” oraz „drzewko”. Żeby wyjaśnić różnice pokaże przykładzie.

body { background-color: white; margin: 0px; padding: 0px; }
/*lub*/
body { 
	background-color: white; 
	margin: 0px; 
	padding: 0px; 
}

Poniżej układamy CSS’a jeśli chcemy tasiemce zmienne $nl i $tab pozostawiamy puste lub też pozostawiamy tak jak teraz i mamy drzewka.

$nl = "\n";
$tab = "\t";
$string = '';
foreach( $css_array as $klasa => $body ) {
	$string .= $klasa.' {'.$nl;
	foreach( $body as $att => $value ) {
		$string .= $tab."$att: $value;".$nl;
	}
	$string .= "}\n";
}

Oczywiście kod ma parę niedociągnięć. Nie obsługuje takich tagów jak import, charset ale może to kiedy indziej.
Czy komuś się to przyda nie wiem, jak w tytule był robiony w chwili wolnego czasu. Będzie chociaż troche ładnie poukładane.

Kod poskładany w całość:

<?php
$file = '/sciezka/do/pliku.css';
$css = file_get_contents($file);
$css = str_replace(array("\n", "\r", "\t"), '', $css );
 
/* wyrazenie regularne do wyszukiwania klas */
$patern_main = '~([\.|#]?[^{]*)[\s]*\{([^}]*)\}~i';
/* wyrazenie regularne do wyszukiwania atrybutow w klasach */
$patern_css = '~([^\:\;\s]+)\s*:\s*([^\;\s]+)~i';
/* wyrazenie regularne do wyszukania i usuniecia komentarzy */
$patern_comments = '~\/\*[^*]*\*+([^/*][^*]*\*+)*\/~i';
 
/* usuwanie komentarzy */
$css = preg_replace($patern_comments, '', $css);
 
/* wyszukiwanie klas */
preg_match_all($patern_main, $css, $match);
 
$css_array = array();
foreach (array_keys($match[0]) as $key) {
	$css_match = array(); //czyscimy tablice w przypadku pustej klasy
	$css_body = trim( $match[2][ $key ] );
	if( $css_body != '' ) { //jesli definicja klasy jest pusta to ja opuszczamy
		preg_match_all($patern_css, $css_body, $css_match);
		$css_array[ trim( $match[1][ $key ] ) ] = array_combine($css_match[1], $css_match[2]);
	} else {
		$css_array[ trim( $match[1][ $key ] ) ] = array();
	}
}
$nl = "\n";
$tab = "\t";
$string = '';
foreach( $css_array as $klasa => $body ) {
	$string .= $klasa.' {'.$nl;
	foreach( $body as $att => $value ) {
		$string .= $tab."$att: $value;".$nl;
	}
	$string .= "}\n";
}
?>

Autoload w PHP istnieje od wersji 5.0. Bardzo przydatna „magiczna” funkcja, która potrafi zaoszczędzić trochę zasobów serwera. Ładuje pliki z klasą jedynie w czasie gdy jest ona potrzebna. Rozwiązań jest za pewne wiele, niektórzy przeszukują za każdym razem system plików za nazwą klasy, a niektórzy tworzą specjalne konstrukcje katalogów. Są też rozwiązania ze stworzeniem tablicy z nazwami klas i ścieżką do plików.
I to rozwiązanie jest moim zdaniem najbardziej efektywne. Jedynym problemem jest tworzenie takiego pliku z tablicami. Oczywiście możemy ręcznie tworzyć tablice, to jest wersja dla najtwardszych. Innym sposobem jest oczywiście stworzenie prostego narzędzie do tworzenia takiej tablicy.

Pierwsza rzecz to musimy wyszukać wszystkie pliki jakie chcemy przeszukać.

<?php
$path = './';
$dir = new RecursiveIteratorIterator(
    new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST
);
 
foreach($dir as $file) {
    //przetwarzanie plików
}
?>

To nam pomoże przeszukać wszystkie pliki php w danym katalogu oraz jego podkatalogach. Jeśli ktoś używa na przykład skryptu Smarty, to pojawia się dużo plików php które napewno nie posiadają żadnej klasy lub też katalogi .svn posiadające dużo plików, gdzie nie znajdziemy niczego nam potrzebnego. Przydało by się to odfiltrować. Np przykład tak:

<?php
if( $file->isFile() 
    and end( explode( '.', $file->getFilename() ) ) == 'php' 
    and strpos($file->getFilename(), '%') === false 
    and strpos( $file->getPath().'/'.$file->getFilename(), '.svn') === false ) {
    //dalsze przetwarzanie plików
}
?>

Pre-kompilowane szablony smarty posiadają znaki ‘%’ więc takie pliki możemy odrzucić. Możemy się pokusić o odrzucenie plików z katalogu gdzie zapisywane są pliki smarty, ale w przypadku zmiany nazwy katalogu, trzeba by było modyfikować skrypt. Wszystkie pliki które posiadają w ścieżce fragment ‘.svn’ także będziemy odrzucać, ponieważ na pewno tam nic nie znajdziemy.

Teraz przystąpimy do samego wyszukiwania klas w plikach. Skorzystamy z wbudowanej funkcji w token_get_all, która częściowo przetworzy nam kod PHP na poziom leksykalny, co znacząco ułatwi nam wyszukiwanie potrzebnych nam rzeczy. Zasadę może pokaże na przykładzie:

<?php
 
# przykładowa klasa
# <?php
# class NazwaKlasy {
#     //tresc klasy
# }

var_dump( token_get_all( "<?php\n class NazwaKlasy {\n //treść klasy\n }") );
?>

Wynikiem będzie wyświetlenie tablicy 2 wymiarowej. W tym konkretnym przykładzie będzie posiadała ona 11 elementów na pierwszym poziomie. Każdy taki element opisuje pojedynczą jednostkę leksykalną. Listę takich jednostek znajdziecie w dokumentacji PHP. Jak znaleźć nazwę klasy. Każdy znaleziony element jest albo string’iem dla znaków takich jak ( ‘{‘, ‘}’, ‘;’, ‘.’, ‘>’, itp.) lub tablicą 3 elementów. Pojedyncze znaki nas nie interesują, więc szukamy tablic. A dokładniej ułożenia kolejnych 3 elementów. Pierwsze to słowo kluczowe ‘class’ (token T_CLASS), następnie odstęp (white space, token T_WHITESPACE) a na końcu ciąg znaków ( token T_STRING ). I właśnie ten ostatni element w połączeniu z nazwą i ścieżką pliku potrzebny. Więc przetworzenie pliku będzie wyglądać mniej więcej tak:

$tokens = token_get_all( file_get_contents( $file->getPath().'/'.$file->getFilename() ) ); //odczytujemy plik i przetwarzamy
$count = count($tokens); //zliczamy ilość elementów, poprostu optymalizacja dla pętli
for($a=0; $a<$count;$a++ ) {
    if( is_numeric( $tokens[$a][0] ) ) { //sprawdzamy czy element jest opisany tablicą
        if( $tokens[$a][0] == T_CLASS and $tokens[$a+1][0] == T_WHITESPACE and $tokens[$a+2][0] == T_STRING ) { //spełnienie warunku dla kolejnych trzech elementów
            if( isset( $klasy[ trim( $tokens[$a+2][1] ) ] ) ) { //sprawdzenie czy nie istnieją duplikaty klas.
                $double[] = array( trim( $tokens[$a+2][1] ), $file->getPath().'/'.$file->getFilename() );
            } else {
                $klasy[ trim( $tokens[$a+2][1] ) ] = $file; //tworzenie tablicy ze ścieżkami do plików oraz nazwami klas
            }
        }
    }
}

Teraz pozostaje nam tylko otrzymaną tablice zapisać do pliku php. Co chyba nikomu nie sprawi problemu:

<?php
file_put_contents('autoload.array.php', "<?php\n");
foreach( $klasy as $class => $file ) {
	//zapisujemy skrócone ścieżki od aktualnego katalogu w górę
	file_put_contents('autoload.array.php', '$autoload[\''.$class.'\'] = \''.str_replace( getcwd(), '.', realpath($file) ).'\';'."\n", FILE_APPEND);
}
?>

W całości będzie to wyglądać mniej więcej tak:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<?php
set_time_limit(0);
$klasa = array();
$path = './';
$dir = new RecursiveIteratorIterator(
    new RecursiveDirectoryIterator($path), RecursiveIteratorIterator::SELF_FIRST
);
 
//przetwarzanie plików
foreach($dir as $file) {
	if( $file->isFile() and end( explode( '.', $file->getFilename() ) ) == 'php' and strpos($file->getFilename(), '%') === false and strpos( $file->getPath().'/'.$file->getFilename(), '.svn') === false) {
        $tokens = token_get_all( file_get_contents( $file->getPath().'/'.$file->getFilename() ) );
        $count = count($tokens);
        for($a=0; $a<$count;$a++ ) {
            if( is_numeric( $tokens[$a][0] ) ) {
                if( $tokens[$a][0] == T_CLASS and $tokens[$a+1][0] == T_WHITESPACE and $tokens[$a+2][0] == T_STRING ) {
                    if( isset( $klasy[ trim( $tokens[$a+2][1] ) ] ) ) {
                        $double[] = array( trim( $tokens[$a+2][1] ), $file->getPath().'/'.$file->getFilename() );
                    } else {
                        $klasy[ trim( $tokens[$a+2][1] ) ] = $file;
                    }
                }
            }
        }
	}
}
 
//budowanie pliku z tablicą
file_put_contents('autoload.array.php', "<?php\n");
foreach( $klasy as $class => $file ) {
	file_put_contents('autoload.array.php', '$autoload[\''.$class.'\'] = \''.str_replace( getcwd(), '.', realpath($file)).'\';'."\n", FILE_APPEND);
}
?>

Na początku przydaje się dodać set_time_limit() na zero ponieważ przy dużych plikach oraz przy dużej ich ilości cała operacja może chwilkę potrwać. Należy pamiętać, że po dodaniu nowej klasy, przydałoby się uruchomić skrypt ponownie, aby dodał nową klase do tablicy.
Teraz pozostaje nam stworzyć jedynie funkcje __autoload, która będzie korzystać z naszej tablicy.

1
2
3
4
5
6
7
8
9
10
11

$autoload = array();
function __autoload($class_name) {
	static $autoload;
	include_once( './autoload.array.php' );
 
	if( isset( $autoload[ $class_name ] ) ) {
		include_once($autoload[ $class_name ]);
		return true;
	}
	return false;
}

I mamy gotową całą funkcjonalność autoload. Możemy ją poszerzyć o zliczanie ilości plików lub klas, czas wykonywania lub inne mniej lub bardziej przydatne informacje. Wszystko zależy od waszych potrzeb.

Jak każdy programista przychodzi czas na to by ułatwić sobie pracę, piszemy dziesiątki albo i setki małych lub większych narzędzi. W 90% przypadków używamy ‘echo’ lub ‘print’ zamiast systemu szablonów i jest to chyba dość oczywiste. Najnormalniej w świecie jest to zbędne i szkoda na to czasu.
Ale czemu rezygnować z jakiegoś ładnego formatu, zaznaczenia ważnych rzeczy lub błędów które pojawiły się podczas pracy. W HTML’u nie jest to trudne, użycie stylu nadanie mu koloru czcionki i po sprawie. Sprawa może wyglądać trochę gorzej jeśli (np. tak jak ja) robicie małe skrypty odpalane pod konsolą Linuksa. Tak zazwyczaj tekst jest zawsze biały, a tło czarne. Kolorowanie tekstu pod konsolą jest stosunkowo proste. Trzeba jedynie pamiętać o tym, aby po wyświetleniu treści przywrócić kolor do swojej pierwotnej postaci.

Format kolorowania tekstu jest dość prosty, składa się ze znaku specjalnego ESCAPE, oraz definicji kolorów. Aby otrzymać znać ESCAPE użyjemy jego zapisu ósemkowego (Wartość \033, zapisana jako ‘\033‘), zupełnie tak samo jak w konsoli Linuksa oraz funkcji echo. Nastepnie po znaku ‘[‘ może występować do trzech wartości określających fomat tekstu, wszystkie oddzielane od siebie znakiem średnika ‘;’. Cały kod zakańczamy literą ‘m’. W całości kod tworzony jest na takiej zasadzie.

\033[kod_formatujący;kod_koloru;kod_tłam

przykład: \033[1;31mCzerwony gruby napis\033[0m
otrzymamy taką treść Czerwony gruby napis
Oczywiście nie musimy na końcu dawać kodu ‘\033[0m’ ale cała konsola będzie wyświetlać jedynie czerwoną pogrubioną czcionkę do czasu aż zostanie ona zamknięta lub otrzyma kod resetujący ustawienia.
Poniżej podaje listę kodów które można wykorzystać do formatowania konsoli.
Kody formatujące

• 0 – resetuje wszystkie ustawienia
• 1 – pogrubiona
• 2 – przyciemniona czcionka
• 4 – podkreślona
• 5 – mrugająca
• 7 – zamienia miejscami kolor czcionki i tła

Kody kolorów czcionki

• 30 – czarny
• 31 – czerwony
• 32 – zielony
• 33 – brązowy
• 34 – niebieski
• 35 – magenta
• 36 – turkusowy
• 37 – biały

Kody kolorów tła

• 40 – czarny
• 41 – czerwony
• 42 – zielony
• 43 – brązowy
• 44 – niebieski
• 45 – magenta
• 46 – turkusowy
• 47 – biały

Poniżej podaje przykład jak zastosować to praktycznie w kodzie PHP. Szczerze mówiąc jest to jedynie wycinek który wykorzystuje w swoich klasach, można to oczywiście zamienić na normalną funkcję. Używana przeze mnie metoda używana jest aby wyświetlać pokolorowaną treść w konsoli oraz w przeglądarce. Równie dobrze można by zdefiniować wszystkie kolory tła i format czcionek, ale podejrzewam, że każdy może to zmodyfikować w swoim zakresie.

Przykładowa klasa Display której sam używam.

bibliografia:
http://www.newlinuxuser.com/linux-console-codes/
http://www.linux.gr/cgi-bin/man2html?console_codes+4
oraz wielkie Google