PHP preprocessor Opcje

[hawk]

Chodzi mi po głowie taki "preprocesor" albo "kompilator" do php. Hmm, wyobraźcie sobie że macie jakiś obiektowy systemik - powiedzmy kilkanaście klas, w tym interfejsy (PHP5). I chciałoby się wypuszczając oficjalną wersję tego systemiku wrzucić to wszystko do jednego pliku, bo i tak te klasy się nazwajem potrzebują. A interfejsy w ogóle nie są potrzebne - tylko ułatwiają pisanie - i można je całkowicie usunąć.

I uruchamiałoby się taki preprocesor, który mergowałby pliki, usuwał (niepotrzebne już) instrukcje require_once(...) itd. Sprawa nie jest prosta, bo preprocesorowi trzeba jakoś powiedzieć, co ma do czego przerzucić, a co zostawić w spokoju. No i nie może on absolutnie pogubić się i wprowadzać do kodu nowe błędy.

Czy takie coś może istnieje? Czy to jest w ogóle dobry pomysł?

[bela]

Fajny przykład, i dobrze pasuje do dyskutowanego ostatnio autoloadera . Ja bym z tego oczywiście zrobił klasę. I zrobiłbym system pluginów do tej klasy, pobierających tekst pliku i zwracających przetworzony tekst pliku. Np. plugin usuwający komentarze, wycinający whitespace, itd. I takie pluginy można łączyć w łańcuszek - co po kolei ma być zrobione.

No ba, już jest gotowe

[PHP] pobierz, plaintext 
<?php
error_reporting(E_ALL);
class PreProcessor {
	private $plugins;
	private $config;
	private $fileContent;
	private $files;
	public function __construct() {
	}
 
	public function start () {
		$this->files = $this->getF($this->config);
		$this->loadFiles();
		$this->processPlugins();
	}
 
	private function getFiles($dir) {
		$aFiles = array();
		foreach($dir as $d) {
		$rd = new RecursiveIteratorIterator( new RecursiveDirectoryIterator( $d ), true );
			foreach ($rd as $file) {
				if(!$file->isDir() && end(explode('.', $file)) == &#092;"php\") {
					$aFiles[] = $file->getPathname();
				}
			}
		}
		return $aFiles;
	}
 
	public function setConfig($aConfig) {
		$this->config = $aConfig;
	}
 
	public function getConfig () {
		return $this->config;
	}
 
	public function setPlugins($aPlugins) {
		$this->plugins = $aPlugins;
	}
 
	public function getPlugins () {
		return $this->plugins;
	}
 
	private function getF($aF) {
		$rf = array_diff($this->getFiles($this->config['dirs']), $this->getFiles($this->config['disabled_dirs']));
		$rf = array_merge($rf, $this->config['files']);
		$rf = array_merge(array_diff($rf, $this->config['disabled_files']));
		return $rf;
	}
 
	private function processPlugins() {
		foreach($this->plugins as $k => $v) {
			$plugin = new $v;
			$this->fileContent = $plugin->process($this->fileContent);
		}
	}
 
	private function loadFiles() {
		foreach($this->files as $k => $v) {
			$this->fileContent[$v] = file_get_contents($v);
		}
	}
 
	private function getFileContent() {
		return $this->fileContent;
	}
 
	public function setFileContent($content) {
		$this->fileContent = $content;
	}
 
	public function save($dir = null) {
		foreach($this->fileContent as $k => $v) {
			file_put_contents($dir . $k, $v);
		}
	}
}
 
class comments {
	function __construct() {
	}
 
	function process($files) {
		foreach($files as $k => $v) {
			$files[$k] = php_strip_whitespace($k);
		}
		return $files;
	}
}
 
function dump($dump) {
	print('<pre>');
	var_dump($dump);
	print('</pre>');
}
 
$files = array(
	   'dirs' => array(''),
	   'disabled_dirs' => array(''),
	   'files' => array(''),
	   'disabled_files' => array(''),
);
 
$pre = new PreProcessor();
$pre->setConfig($files);
$pre->setPlugins(array('comments'));
$pre->start();
$pre->save('new/');
print 'Hehe, udalo sie preprocesorawac kod;)';
?>
[PHP] pobierz, plaintext 

Albo inny pomysł - łańcuch przetwarzania powinien mieć postać: input -> processing -> output. Tzn. niech będzie interfejs odpowiedzialny za dostarczanie contentu - np. pobierając z pliku, pobierając z listy plików, itd. Drugi interfejs/klasa to główne przetwarzanie i obróbka zagregowanego contentu. A na koniec interfejs zapisujący wynik obróbki. Taki pipeline pozwala na elastyczne dopasowywanie do potrzeb i dopisywanie nowej funkcjonalności.

Najlepiej byłoby opracować coś takiego i wydać razem z autoloaderem...

edit: Coraz bardziej podoba mi się pipeline. Można nawet pójść trochę w stronę Cocoona: zrobić sobie drzewko przetwarzania, gdzie na wejściu (liść) jest input, na wyjściu (korzeń) output, a w środku cokolwiek - agregacja, filtrowanie, wycinanie komentarzy, itd.

Możesz bardziej łopatologicznie napisać ;]