css inheritance

.tablo
{
   font-size:12px;
   color:yellow;
}

.turetilmis-tablo
{
   based-on:'.tablo';  /* bu satırda .tablo stilinden türediğimiz belirttik */
   font-size:13px; /*  overriding (: */
   background-color:blue;  /*  diğer propertylere ek olarak bir de background-color ekledik*/
}
.turetilmis-diger-tablo
{
   based-on:'.turetilmis-tablo';  /* turetilmis-tablo stilinin tüm elemanlarını getirdik */
   background-color:red;  /*background-color değerini override edip polimorphizm sağladık(: */
   border:1px solid;  /*ek bir ozellik daha */
}

.turetilmis-tablo
{
   color:yellow;
   font-size:13px;
   background-color:blue;
}
.turetilmis-diger-tablo
{
   color:yellow;
   font-size:13px;
   background-color:red;
   border:1px solid;
}

<?php
    include 'D3Css.php';
    header("Content-Type: text/plain");
    $css = new D3Css('inheritance.css',true,'.');
    $css->compressed=false; 
    echo $css;
?>

<?php
    /**
    * @name D3Css Css Inheritance and compressor.
    * @version 1.1
    * @author Tufan Baris YILDIRIM
    * @link http://www.tufyta.com/css-inheritance
    * ---------------------------------------------------
    * v1.1
    * -----
    *  -  cache mechanism added.
    *       - class can run without original file if output is cached.
    * v1.0
    * -----
    * This class can rewrite your css files and evulate inheritance.
    */
    class D3Css
    {
        /**
        * output will be one-line if compressed is true
        *
        * @var mixed
        */
        public  $compressed = true;
        /**
        * set cache folder for  write css output.
        *
        * @var mixed;
        */
        public  $cache_folder;
 
        /**
        * Cache file name
        *
        * @var mixed
        */
        public  $cache_file;
        /**
        * css file
        *
        * @var mixed
        */
        public $file;
        /**
        * Selector with properties.
        *
        * @var mixed
        */
        private $blocks = array();
        /**
        * Keep Selector Referances
        *
        * @var mixed
        */
        private $referances = array();
 
        /**
        * constructor method
        * Create an D3Css object by given file url or css string
        *
        * @param mixed $file_or_css_string
        * @param mixed $file
        * @return D3Css
        */
        public function __construct($file_or_css_string,$file=false,$cache_folder=null)
        {
 
            if ($file)
            {
                (is_file($file_or_css_string) || is_file($this->cache_file = $cache_folder.'/'.md5($file_or_css_string).'.css')) || trigger_error($file_or_css_string.' file not found.!');
                $this->file = $file_or_css_string;
            }
 
            if (isset($cache_folder))
            {
                if (!is_dir($cache_folder))
                    trigger_error($cache_folder.' is not a dir. ',E_USER_ERROR);
                else
                    $this->cache_folder = $cache_folder;
            }
            else
            {
                // get file conent if file is true else parse given string directly
                $this->parse_blocks($file ? file_get_contents($file_or_css_string) : $file_or_css_string);
            }
        }
 
        /**
        * @name Css Cleaner
        * @since 1.0
        * Remove
        *   - Multiline Comments
        *   - Single line comments
        *   - redudent characters,spaces and newlines.
        * @param mixed $css
        * @return mixed
        */
        private function clean_css($css)
        {
            // remove comments
            $css = preg_replace('/(\/\*.*?\*\/|\n|\t|\/\/.*?\n)/sim','', $css);
 
            // remove redudent characters and newlines.
            $css = preg_replace('/\s?(,|{|:){1}\s?/sim','\\1', $css);
 
            return $css;
        }
 
        /**
        * @name Main Parser Method
        * @since 1.0
        * Parce blocks , generate $blocks and $referances array.
        * @param mixed $string
        */
        private function parse_blocks($string)
        {
            preg_match_all('/(?<selectors>[^\{\}]+)\{(?<declerations>[^\{\}]+)\}/im',$this->clean_css($string),$matches);
 
            // delete unnecessary elements
            $matches = array('selectors' => $matches['selectors'],'declerations' => $matches['declerations']);
 
            // delete css string
            unset($string);
 
            $blocks = array();
 
            foreach( $matches['selectors'] as $index => $selector )
            {
                // $blocks[$selector=trim($selector)] =  $matches['declerations'][$index];
                preg_match_all('/(?<properties>[^:]+)(\s*):(?<values>[^;]+);?/im',$matches['declerations'][$index],$submatches);
 
                $blocks[$selector=trim($selector)] = array_combine(
                $properties = array_values(array_map('trim',$submatches['properties'])),
                array_values(array_map('trim',$submatches['values']))
                );
 
                // Referances avaliabilty.
                if(in_array('based-on',$properties))
                {
                    if(!in_array($base_class_name = str_replace("'",'',$blocks[$selector]['based-on']),$avaliable_classes = array_keys($blocks))
                    && !in_array($base_class_name,$avaliable_referances = array_keys($referances))) // checking referances for full inheritance yeah.
 
                        trigger_error('classes can not be declared before their base classes (may be Circular Referance)',E_USER_ERROR);
 
                    elseif (is_array($base_class=$blocks[$base_class_name]) || is_array($base_class = $referances[$base_class_name]))
                    {
                        // evulating inheritance  and overriting
                        $blocks[$selector] = array_merge($base_class,$blocks[$selector]);
                    }
 
                    // delete based-on property from class
                    unset($blocks[$selector]['based-on']);
                }
 
                // Delete submatches after use.
                unset($submatches);
 
                // Extract Referances. ex:  [&amp;body] and [&amp;td] will be referanced to  [body,td]
                if(count($selectors=explode(',',$selector))>1)
                {
                    foreach ( $selectors as $subselector )
                    {
                        $referances[trim($subselector)] = &$blocks[$selector];
                    }
                }
 
                // unset element after parse
                unset( $matches['selectors'][$index] ,$matches['declerations'][$index]);
            }
 
            $this->blocks=$blocks;
            $this->referances=$referances;
        }
 
        /**
        * @name Property Imploder.
        * @since 1.0
        * @param mixed $value
        * @param mixed $property
        */
        private function implode_properties(&$value,$property)
        {
            // Implote properties add tab if compressed false.
            $value = ($this->compressed ? '':"\t") . $property . ':' . $value . ';';
        }
 
        /**
        * Block Imploder
        * @since 1.0
        * @param mixed $properties
        * @param mixed $block_name
        */
        private function implode_blocks(&$properties,$block_name)
        {
            $concanated = "";
 
            if(is_array($properties))
            {
                // Implode all properties as  property_name : value;
                array_walk($properties,array(&$this,'implode_properties'));
                // Implode blocks after their properties imploded
                $concanated = implode(!$this->compressed ? "\r\n" : '',$properties);
            }
 
            // add newlines if compressed false.
            if ($this->compressed)
                $properties = $block_name . '{' . $concanated . '}';
            else
                $properties = $block_name . " {\r\n" . $concanated . "\r\n}\r\n";
        }
 
        /**
        * @name Output writer
        * @since 1.0
        * Write or return output css code blocks
        * @param mixed $return
        * @return string
        */
        public function output($return=false)
        {
            if (!isset($this->cache_folder))
            {
                $blocks = $this->blocks;
                if (array_walk($blocks,array(&$this,'implode_blocks')))
                {
                    $output = implode($this->compressed ? ' ':"\r\n",$blocks);
                }
                else
                {
                    trigger_error('output failed.!',E_USER_ERROR);
                }
                unset($blocks);
            }
            else
            {
                if(is_file($this->cache_file))
                {
                    $output = file_get_contents($this->cache_file);
                }
                elseif(is_file($this->file))
                {
                    $this->__construct($this->file,true);
 
                    $cf = $this->cache_folder;
                    $this->cache_folder=null;
                    file_put_contents($this->cache_file,$output = $this->output(true));
                    $this->cache_folder = $cf;
 
                }
                else
                {
                    trigger_error('Cache cannot be created.',E_USER_ERROR);
                }
            }
 
            if ($return)
                return $output;
            else
                echo $output;
        }
 
        /**
        * @name String Caster.
        * @since 1.0
        */
        public function __toString()
        {
            return $this->output(true);
        }
 
        /**
        * @name Destructor
        * @since 1.0
        * Unset used vars
        */
        public function __descructor()
        {
            unset($this->blocks,$this->referances);
        }
 
    }
?>