src/bolt/browser/assets.php

<?php

namespace bolt\browser;
use \b;

use Assetic\FilterManager;
use Assetic\AssetManager;
use Assetic\Asset\AssetCollection;
use Assetic\Asset\FileAsset;
use Assetic\Asset\GlobAsset;
use Assetic\Asset\HttpAsset;
use Assetic\Asset\StringAsset;

// filters
use Assetic\Filter\CssRewriteFilter;

class assets implements \bolt\plugin\singleton {
    use \bolt\plugin\traits\singleton;

    public static $route = '/a/{path}';

    private $_manager = false;
    private $_dir = [];
    private $_filters = ['*' => []];

    private $_output = [
        'script' => [],
        'style' => []
    ];


    public function __construct($config=[]) {

        // dirs
        $this->_dir = b::param('dir', [], $config);

        // manager
        $this->_manager = new AssetManager();

    }

    public function add($type, $config=false) {
        if (is_array($type) AND !$config) {
            foreach ($type as $item) {
                $this->add($item[0], $item[1]);
            }
            return $this;
        }

        $o = $type == 'script' ? new assets\script($this) : new assets\style($this);

        if (is_string($config)) {
            $o->setPath($config);
        }
        else if (is_array($config)) {
            foreach ($config as $k => $v) {
                call_user_func([$o, "set{$k}"], $v);
            }
        }
        $this->_output[$type][] = $o;
        return $o;
    }

    public function out($group, $type=false) {
        $tag = [];

        if (!$type OR $type == 'script') {
            foreach ($this->_output['script'] as $script) {
                if ($script->inGroup($group)) {
                    $tag[] = $script->out();
                }
            }
        }

        if (!$type OR $type == 'style') {
            foreach ($this->_output['style'] as $leaf) {
                if ($leaf->inGroup($group)) {
                    $tag[] = $leaf->out();
                }
            }
        }

        return implode("\n", $tag);

    }

    public function filter($ext, $filter=null, $useInDev=true) {
        if (is_array($ext)) {
            array_map(function(){ call_user_func_array([$this, 'filter'], func_get_args()); }, $ext);
            return $this;
        }
        $class = "\\Assetic\\Filter\\{$filter}Filter";

        if (!array_key_exists($ext, $this->_filters)) {
            $this->_filters[$ext] = [];
        }

        if (class_exists($class, true)) {
            $this->_filters[$ext][] = [$class, $useInDev];
        }
    }

    public function getFilters() {
        return $this->_filters;
    }

    public function stylesheet($leafs) {
        if (is_string($leafs)) { $leafs = [$leafs]; }

        $output = [];

        foreach ($leafs as $leaf) {
            // find this file
            $file = $this->find($leaf);

            if ($file) {
                foreach ($this->getCompressedFileTree($file) as $f) {
                    if (substr($f, 0, 4) === 'http') {
                        $output[] = $f;
                    }
                    else {

                    }
                }
                $output[] = str_replace("{path}", ltrim(str_replace($file[0], '', $file[1]),'/')."?filterOnly=true", self::$route);
            }
            else {
                $output[] = $leaf;
            }
        }

        return implode("\n", array_map(function($href) {
            return '<link rel="stylesheet" href="'.$href.'" type="text/css">';
        }, $output));

    }

    public function addDir($paths=[]) {
        $this->_dir = array_replace($this->_dir, $paths);
        return $this;
    }

    public function getDirs() {
        return $this->_dir;
    }

    public function find($find, $root=false) {
        if (substr($find,0,4) === 'http') {return [null, $find];}

        foreach (array_merge([$root], $this->_dir) as $path) {
            $_ = b::path($path, $find);
            if (file_exists($_)) {
                return [$path, $_];
            }
        }
        return false;
    }

    public function getFile($path) {
        if (strtolower(substr($path, 0, 4)) === 'http') {
            $f = new HttpAsset($path);
            $f->load();
        }
        else {
            $f =  new FileAsset($path);
            $f->load();
        }
        return $f;
    }

    public function processFile($path, $config=[]) {
        $rel = b::param('rel', false, $config);
        $url = b::param('url', false, $config);
        $useGlobalFilters = b::param('useGlobalFilters', true, $config);

        // get the file
        $file = $this->getFile($path);

        $root = pathinfo($path)['dirname'];
        $ext = pathinfo($path)['extension'];

        // get it's tree
        $content = $file->getContent();

        if (empty($content)) { return $content; }

        $inc = [];

        // parse the string
        $found = $this->parseString($content, $root);

        if (b::param('filterOnly', false, $config) === 'true') {
            $found = ['filter' => $found['filter']];
        }

        $tree = $this->getCombinedTree($found, $ext);

        $reduce = function($items, $reduce) {
            $resp = [];
            foreach ($items as $key => $files) {
                $resp[] = $key;
                $resp += $reduce($files, $reduce);
            }
            return $resp;
        };

        // loop through each file and append
        foreach (array_unique($reduce($tree, $reduce)) as $f) {
            if ($f === $path) {continue;}
            $inc[] = $this->processFile($f);
        }

        $source = false;
        $sourcePath = false;
        $targetPath = false;

        if ($url) {
            $parts = parse_url($url);
            $source = "{$parts['scheme']}://{$parts['host']}";
            $targetPath = trim($parts['path'], '/');
            $sourcePath = $targetPath .'/'.trim($rel,'/');
        }

        $inc[] = $content;

        $a = new StringAsset(implode("\n", $inc), [], $source, $sourcePath);

        if ($targetPath) {
            $a->setTargetPath($targetPath);
        }

        // use filters
        if ($useGlobalFilters !== false) {
            if (array_key_exists($ext, $this->_filters)) {
                foreach ($this->_filters[$ext] as $filter) {
                    if ($filter[1] === false AND b::env() === 'dev') {continue;}
                    $a->ensureFilter(new $filter[0]());
                }
            }
            foreach ($this->_filters['*'] as $filter) {
                if ($filter[1] === false AND b::env() === 'dev') {continue;}
                $a->ensureFilter(new $filter[0]());
            }
        }

        $a->ensureFilter(new CssRewriteFilter());


        return trim($a->dump());
    }

    public function parseString($str, $root=false) {

        $find = [
            'file' => '#\$file ([^\n]+)#',
            'glob' => '#\$glob ([^\n]+)#',
            'dir' => '#\$dir ([^\n]+)#',
            'filter' => '#\$filter ([^\n]+)#'
        ];

        $found = [];

        // parse the string
        foreach ($find as $type => $pat) {
            $found[$type] = [];
            if (preg_match_all($pat, $str, $matches, PREG_SET_ORDER)) {
                foreach ($matches as $match) {
                    $found[$type] = array_merge($found[$type], array_map(function($item){
                        return $item;
                    }, explode(' ', trim($match[1], ''))));
                }
            }
        }

        // make full paths
        foreach (['file', 'dir'] as $type) {
            foreach ($found[$type] as $i => $path) {
                if (($file = $this->find($path, $root)) != false) {
                    $found[$type][$i] = $file[1];
                }
                else {
                    unset($found[$type][$i]);
                }
            }
        }

        // make sure we have a valid filter
        array_filter($found['filter'], function($name){
            return class_exists("\\Assetic\\Filter\\{$name}Filter", true);
        });

        return $found;
    }

    public function getCombinedTree($found, $ext) {
        $tree = [];

        // file
        if (isset($found['file'])) {
            foreach ($found['file'] as $path) {
                $file = $this->getFile($path);
                $tree[$path] = $this->processFileTree($file, $ext);
            }
        }

        if (isset($found['dir'])) {
            foreach ($found['dir'] as $path) {
                $tree += $this->processDirTree($path, $ext);
            }
        }

        return $tree;
    }

    public function processFileTree($file, $ext) {
        $str = $file->getContent();

        // parse the str
        $found = $this->parseString($str);

        return $this->getCombinedTree($found, $ext);

    }

    public function getCompressedFileTree($file) {
        $root = $file[0];
        $ext = pathinfo($file[1])['extension'];
        $ref = $this->getFile($file[1]);
        $inc = [];

        // parse the string
        $found = $this->parseString($ref->getContent(), $root);

        $tree = $this->getCombinedTree($found, $ext);

        $reduce = function($items, $reduce) {
            $resp = [];
            foreach ($items as $key => $files) {
                $resp[] = $key;
                $resp += $reduce($files, $reduce);
            }
            return $resp;
        };

        // loop through each file and append
        foreach (array_unique($reduce($tree, $reduce)) as $f) {
            if ($f === $file[1]) {continue;}
            $inc[] = $f;
        }


        return $inc;

    }

    public function processDirTree($path, $ext) {
        $files = b::getRegexFiles($path, "^.+\.{$ext}$");
        $tree = [];
        foreach ($files as $file) {
            $tree[$file] = $this->processFileTree($this->getFile($file), $ext);
        }
        return $tree;
    }

}