PHP caching without headaches

This is a caching mechanism I made just as a preliminary test, but it's planned to make it into the next release of Apex, my framework, once it is properly tested. This class is set to replace virtually all other caching mechanisms currently in the distribution.

It supports function-return caching and HTML-fragment caching.

It is a single object with 2 methods, accessed statically, that is roughly 20% the size of my current caching code. Hope you find it useful, but if there are any issues or bugs, I'd love to hear about them.

Usage:

Creating and accessing a cache

$q = cache::make('my_cache', 5, function(){
    print 'This is cached for 5 minutes';
    return 'So it this';
}); // will immediately print 'This is cached'.

print $q; // will print 'So is this'.

Destroying a cache on-the-fly (prematurely)

// function 'destroy()' supports wildcards
cache::destroy('my_cache');

Full code

class cache {
    /**
     * $cache_folder is the path to the cache folder.
     * All cache files and folders will be created inside this folder
     *
     * You may set this value from the outside to change the path:
     * cache::$cache_folder - 'some/other/cache/folder';
     * */
    public static $cache_folder = 'cache/';

        /**
         * $last_action is defaulted at NULL.
         * Every time the caching mechanism is used, this value is updated
         * to the last action taken by the cache:: class
         * These values may be either of the 2 class constants:
         * USE_CACHED_FILE or CACHE_FILE_NOW
         * */
        public static $last_action = null;

        const USE_CACHED_FILE = 1;
        const CACHE_FILE_NOW = 2;

        /**
         * This function is accesesed statically
         * cache::make( $name, $expires, $function );
         *
         * $name
         * =====
         * $name refers to the filename of the cache you're currently
         * making, it may be something like user_12_messages or
         * all_members or any string that may be used as a filename.
         * You may set this to a path, ie: users/12/messages
         *
         * $expires
         * ========
         * Number of minutes that the store will keep the cache alive, once
         * this time is exceeded, the mechanism will re-cache your code.
         *
         * $function
         * =========
         * This argument is a closure function containing whatever it is
         * you want to cache The caching mechanism will cache both
         * the function return and any echos and prints to the buffer,
         * so it may be used to cache both data and html.
         *
         * Example
         * =======
         * $q = cahce::make('my_cache', 5, function(){
         *     print 'This is cached';
         *     return 'So it this';
         * }); // will immediately print 'This is cached'.
         *
         * print $q; // will print 'So is this'.
         * 
         * */
        static function make($name, $expires, $function){

            $cache_path = self::$cache_folder.$name.'.json';

            $action = self::USE_CACHED_FILE;


            if(!file_exists(dirname($cache_path))){
                    mkdir(dirname($cache_path), 0777, true);
                }

            if(!file_exists($cache_path)){
                $action = self::CACHE_FILE_NOW;
            }elseif( (time()-filemtime($cache_path))>$expires*60 && $expires!=0 ){
                $action = self::CACHE_FILE_NOW;
            }

            switch($action){
                case self::USE_CACHED_FILE:
                    $cache = json_decode(file_get_contents($cache_path));
                    break;
                case self::CACHE_FILE_NOW:
                    ob_start();
                    $cache = array($function(), ob_get_clean());

                    $fp = fopen($cache_path, "c");
                    if (flock($fp, LOCK_EX) ){
                        // File locked and ready
                        fwrite($fp, json_encode($cache));
                        flock($fp, LOCK_UN);
                    } 
                    fclose($fp);

                    break;
            }

            self::$last_action = $action;
            echo $cache[1];
            return $cache[0];
        }

        /**
         * This function is used to prematurely destroy an existing cache.
         * cache::destroy($name);
         *
         * $name
         * =====
         * The name (or full path) of the cache to be destroyed.
         * The name mey contain the "*" wildcard.
         *
         * Example
         * =======
         * cache::destroy('side_navigation');
         *
         * or
         *
         * cache::destroy('user_*_notifications');
         *
         * or even
         *
         * cache::destroy('user/*');
         * */
        static function destroy($name){
            if(strpos($name,'*')==-1){
                @unlink(CACHE_FOLDER.'/'.$name);
            }else{
                foreach (glob(CACHE_FOLDER.'/'.$name) as $filename) {
                    @unlink($filename);
                }
            }
        }
    }
    ```