watch-less

#!/usr/bin/env php
<?php

define('DS', DIRECTORY_SEPARATOR);

class LessWatcher
{

    private $srcDir;
    private $destDir;
    private $outputExtension;
    private $compiled;
    private $configs;
    private $isAll;
    private $configPaths;
    private $errors = array();

    public function __construct()
    {
        $opts = getopt('a', array('all', 'src:', 'dest:', 'ext:'));

        //get the options data and store them
        $this->srcDir = rtrim($opts['src'], DS);
        $this->destDir = rtrim($opts['dest'], DS);
        $this->outputExtension = array_key_exists('ext', $opts) ? $opts['ext'] : '.css';
        $this->isAll = array_key_exists('a', $opts) || array_key_exists('all', $opts);

        $this->writeln();
        $this->writeln('Watching ' . $this->srcDir . '...', 'white', 'blue');
        
        $this->configs = array();
        $this->configPaths = array();
        $this->processConfig($this->srcDir, $this->destDir);

        $this->watch();
    }

    /**
     * watch the folder for change
     */
    public function watch()
    {
        if (count($this->configs)) {
            foreach ($this->configs as $config)
            {
                $this->compiled = array();
                $this->processDirectory($this->srcDir, $this->destDir . DS . $config);
            }
        } else
        {
            $this->compiled = array();
            $this->processDirectory($this->srcDir, $this->destDir);
        }
        

        usleep(500 * 1000);

        if (!$this->isAll)
        {
            $this->watch();
        }
    }

    /**
     * get the config names
     */
    public function processConfig($srcDir, $destDir)
    {
        $srcf = $this->getSubdir($srcDir, "config");
        if (!isset($srcf))
        {
            $this->writeln('No config folder in your source', 'white', 'red');
            return;
        }

        $dirs = $this->getConfigSettings();
        foreach ($dirs as $d)
        {
            $configPath = $srcf->getPathname() . DS . $d . ".less";
            if (!file_exists($configPath)) continue;
            $this->writeln($d . " less config file found");

            $destf = $this->getSubdir($destDir, $d);
            if (!isset($destf))
            {
                $this->writeln($d . ' directory is not present in your destination directory', 'white', 'red');
                continue;
            }
            $this->configs[] = $d;
            $this->configPaths[] = $configPath;
        }
    }

    /**
     * check if a directory $dirName exist in the $currentDir directory and return it if it's the case.
     */
    public function getSubdir($currentDir, $dirName)
    {
        $iterator = new \DirectoryIterator($currentDir);
        foreach ($iterator as $f)
        {
            if ($f->isDot()) continue;
            if (!$f->isDir()) continue;
            if ($f->getFilename() == $dirName )
            {
                return $f;
            }
        }
    }

    /**
     * extract config directory names from the config.ini file
     */
    public function getConfigSettings()
    {
        $file="config.ini";
        if (file_exists($file) && is_readable($file))
        {
            $settings = parse_ini_file($file);
            return explode(",",$settings["dirs"]);
        }
    }

    /**
     * Import the config file from $configPath in the given less $file.
     */
    public function addConfig($file, $configPath)
    {
        $contents = '@import "' . $configPath . '";' . file_get_contents($file);
        file_put_contents($file, $contents);
        return $file;
    }

    /**
     * get the needed config name from the $path string.
     * return an empty string if no config name has been found
     */
    public function getConfigFromPath($path)
    {
        foreach ($this->configs as $config)
        {
            if (strpos("x" . $path, $config . '/') !== false)
            {
                return $config;
            }
        }
        return "";
    }

    /**
     * process every file in $srcDir.
     * it has been given to $destDir the same arborescence than the $srcDir
     */
    public function processDirectory($srcDir, $destDir)
    {
        $iterator = new \DirectoryIterator($srcDir);
        foreach ($iterator as $f)
        {
            $filename = $f->getFilename();
            if (in_array($filename, array('.', '..')))
            {
                continue;
            }
            $path = $f->getPathname();
            $destPath = $destDir . DS . $filename;
            if ($f->isDir())
            {
                $this->processDirectory($path, $destPath);
                continue;
            }
            $this->processFile($path, $destPath);
        }
    }

    /**
     * check if everything's ok for compiling
     */
    public function processFile($srcFile, $destFile)
    {
        // don't compile the config file
        if (strpos("x".$srcFile, "config") !== false)
        {
            return;
        }

        // only compile less file
        if (substr($srcFile, -5) !== '.less')
        {
            return;
        }
        $destFile = substr($destFile, 0, -5) . $this->outputExtension;
        if (is_file($destFile))
        {
            $destFile = realpath($destFile);
        }
        $content = file_get_contents($srcFile);
        if (preg_match_all('/@import +[\'"]([^\'"]+)[\'"];/', $content,
            $matches))
        {
            for ($i = 0, $cn = count($matches[0]); $i < $cn; $i++)
            {
                $importFile = realpath(dirname($srcFile) . DS
                    . $matches[1][$i]);
                if (!$importFile)
                {
                    continue;
                }
                $this->processFile($importFile, dirname($destFile)
                    . DS . $matches[1][$i]);
            }
        }

        // don't compile a file already compiled (usefull for import file)
        if (in_array($srcFile, $this->compiled))
        {
            return;
        }

        $destDir = dirname($destFile);

        if (!is_dir($destDir))
        {
            mkdir($destDir, 0, true);
        }

        // compile file only if it has been modified
        if (!$this->isAll)
        {
            if (is_file($destFile) && filemtime($destFile) >= filemtime($srcFile))
            {
                return;
            }
        }

        $config = $this->getConfigFromPath($destFile);
        if (strlen($config)) {
            $configPath = $this->configPaths[array_search($config, $this->configs)];

            //use a temp file to compile
            $tmpSrcFile = substr($srcFile, 0, -5) . ".tmp.less";
            if (!copy($srcFile, $tmpSrcFile) && !file_exists($tmpSrcFile))
            {
                $this->writeln('Failed to create ' . $srcFile . ' temp file', 'white', 'red');
                return;
            }

            $tmpSrcFile = $this->addConfig($tmpSrcFile, $configPath);
            $this->compileFile($tmpSrcFile, $destFile);
            unlink($tmpSrcFile);
        } else {
            $this->compileFile($srcFile, $destFile);
        }
        $this->compiled[] = $srcFile;
    }

    /**
     * Compile the file using lessc
     */
    public function compileFile($srcFile, $destFile)
    {
        exec('lessc --yui-compress ' . $srcFile . ' ' . $destFile . ' 2>&1',
            $output, $return);

        $output = implode("\n", $output);
        if (preg_match('/(.*Error:.*)/', $output, $matches))
        {
            if (isset($this->errors[$srcFile])
                && $this->errors[$srcFile] === $output)
            {
                return;
            }
            $this->writeln('[' . date('H:i:s') . '] '
                . $this->removeColor($matches[1]), 'white', 'red');
            $this->errors[$srcFile] = $output;
            return;
        }

        if (isset($this->errors[$srcFile]))
        {
            unset($this->errors[$srcFile]);
        }

        $this->writeln('compile time !', 'red');
        $this->writeln('[' . date('H:i:s') . '] '
            . substr($srcFile, strlen($this->srcDir) + 1) . ' -> '
            . substr($destFile, strlen($this->destDir) + 1), 'green');
    }

    public function write($str, $fgColor = null, $bgColor = null)
    {
        echo $this->colorize($str, $fgColor, $bgColor);
    }

    public function writeln($str = '', $fgColor = null, $bgColor = null)
    {
        $this->write($str, $fgColor, $bgColor);
        echo "\n";
    }

    public function colorize($str, $fgColor = null, $bgColor = null)
    {
        $colors = array(
            'fg' => array(
                'black' => '0;30',
                'dark_gray' => '1;30',
                'blue' => '0;34',
                'light_blue' => '1;34',
                'green' => '0;32',
                'light_green' => '1;32',
                'cyan' => '0;36',
                'light_cyan' => '1;36',
                'red' => '0;31',
                'light_red' => '1;31',
                'purple' => '0;35',
                'light_purple' => '1;35',
                'brown' => '0;33',
                'yellow' => '1;33',
                'light_gray' => '0;37',
                'white' => '1;37'
            ),
            'bg' => array(
                'black' => '40',
                'red' => '41',
                'green' => '42',
                'yellow' => '43',
                'blue' => '44',
                'magenta' => '45',
                'cyan' => '46',
                'light_gray' => '47'
            )
        );

        $colored = '';

        if ($fgColor && isset($colors['fg'][$fgColor]))
        {
            $colored .= "\033[" . $colors['fg'][$fgColor] . "m";
        }

        if ($bgColor && isset($colors['bg'][$bgColor]))
        {
            $colored .= "\033[" . $colors['bg'][$bgColor] . "m";
        }

        $colored .=  $str . "\033[0m";
        return $colored;
    }

    public function removeColor($str)
    {
        return preg_replace('/\033\[[0-9;]+m/', '', $str);
    }

}

new LessWatcher();