vendor/wikimedia/less.php/lib/Less/Tree/Import.php line 198

Open in your IDE?
  1. <?php
  3. /**
  4.  * CSS @import node
  5.  *
  6.  * The general strategy here is that we don't want to wait
  7.  * for the parsing to be completed, before we start importing
  8.  * the file. That's because in the context of a browser,
  9.  * most of the time will be spent waiting for the server to respond.
  10.  *
  11.  * On creation, we push the import path to our import queue, though
  12.  * `import,push`, we also pass it a callback, which it'll call once
  13.  * the file has been fetched, and parsed.
  14.  *
  15.  * @package Less
  16.  * @subpackage tree
  17.  */
  18. class Less_Tree_Import extends Less_Tree{
  20.     public $options;
  21.     public $index;
  22.     public $path;
  23.     public $features;
  24.     public $currentFileInfo;
  25.     public $css;
  26.     public $skip;
  27.     public $root;
  28.     public $type = 'Import';
  30.     public function __construct($path, $features, $options, $index, $currentFileInfo = null ){
  31.         $this->options = $options;
  32.         $this->index = $index;
  33.         $this->path = $path;
  34.         $this->features = $features;
  35.         $this->currentFileInfo = $currentFileInfo;
  37.         if( is_array($options) ){
  38.             $this->options += array('inline'=>false);
  40.             if( isset($this->options['less']) || $this->options['inline'] ){
  41.                 $this->css = !isset($this->options['less']) || !$this->options['less'] || $this->options['inline'];
  42.             } else {
  43.                 $pathValue = $this->getPath();
  44.                 if( $pathValue && preg_match('/css([\?;].*)?$/',$pathValue) ){
  45.                     $this->css = true;
  46.                 }
  47.             }
  48.         }
  49.     }
  51. //
  52. // The actual import node doesn't return anything, when converted to CSS.
  53. // The reason is that it's used at the evaluation stage, so that the rules
  54. // it imports can be treated like any other rules.
  55. //
  56. // In `eval`, we make sure all Import nodes get evaluated, recursively, so
  57. // we end up with a flat structure, which can easily be imported in the parent
  58. // ruleset.
  59. //
  61.     public function accept($visitor){
  63.         if( $this->features ){
  64.             $this->features = $visitor->visitObj($this->features);
  65.         }
  66.         $this->path = $visitor->visitObj($this->path);
  68.         if( !$this->options['inline'] && $this->root ){
  69.             $this->root = $visitor->visit($this->root);
  70.         }
  71.     }
  73.     /**
  74.      * @see Less_Tree::genCSS
  75.      */
  76.     public function genCSS( $output ){
  77.         if( $this->css ){
  79.             $output->add( '@import ', $this->currentFileInfo, $this->index );
  81.             $this->path->genCSS( $output );
  82.             if( $this->features ){
  83.                 $output->add( ' ' );
  84.                 $this->features->genCSS( $output );
  85.             }
  86.             $output->add( ';' );
  87.         }
  88.     }
  90.     public function toCSS(){
  91.         $features = $this->features ? ' ' . $this->features->toCSS() : '';
  93.         if ($this->css) {
  94.             return "@import " . $this->path->toCSS() . $features . ";\n";
  95.         } else {
  96.             return "";
  97.         }
  98.     }
  100.     /**
  101.      * @return string
  102.      */
  103.     public function getPath(){
  104.         if ($this->path instanceof Less_Tree_Quoted) {
  105.             $path = $this->path->value;
  106.             $path = ( isset($this->css) || preg_match('/(\.[a-z]*$)|([\?;].*)$/',$path)) ? $path : $path . '.less';
  107.         } else if ($this->path instanceof Less_Tree_URL) {
  108.             $path = $this->path->value->value;
  109.         }else{
  110.             return null;
  111.         }
  113.         //remove query string and fragment
  114.         return preg_replace('/[\?#][^\?]*$/','',$path);
  115.     }
  117.     public function compileForImport( $env ){
  118.         return new Less_Tree_Import( $this->path->compile($env), $this->features, $this->options, $this->index, $this->currentFileInfo);
  119.     }
  121.     public function compilePath($env) {
  122.         $path = $this->path->compile($env);
  123.         $rootpath = '';
  124.         if( $this->currentFileInfo && $this->currentFileInfo['rootpath'] ){
  125.             $rootpath = $this->currentFileInfo['rootpath'];
  126.         }
  129.         if( !($path instanceof Less_Tree_URL) ){
  130.             if( $rootpath ){
  131.                 $pathValue = $path->value;
  132.                 // Add the base path if the import is relative
  133.                 if( $pathValue && Less_Environment::isPathRelative($pathValue) ){
  134.                     $path->value = $this->currentFileInfo['uri_root'].$pathValue;
  135.                 }
  136.             }
  137.             $path->value = Less_Environment::normalizePath($path->value);
  138.         }
  142.         return $path;
  143.     }
  145.     public function compile( $env ){
  147.         $evald = $this->compileForImport($env);
  149.         //get path & uri
  150.         $path_and_uri = null;
  151.         if( is_callable(Less_Parser::$options['import_callback']) ){
  152.             $path_and_uri = call_user_func(Less_Parser::$options['import_callback'],$evald);
  153.         }
  155.         if( !$path_and_uri ){
  156.             $path_and_uri = $evald->PathAndUri();
  157.         }
  159.         if( $path_and_uri ){
  160.             list($full_path, $uri) = $path_and_uri;
  161.         }else{
  162.             $full_path = $uri = $evald->getPath();
  163.         }
  166.         //import once
  167.         if( $evald->skip( $full_path, $env) ){
  168.             return array();
  169.         }
  171.         if( $this->options['inline'] ){
  172.             //todo needs to reference css file not import
  173.             //$contents = new Less_Tree_Anonymous($this->root, 0, array('filename'=>$this->importedFilename), true );
  175.             Less_Parser::AddParsedFile($full_path);
  176.             $contents = new Less_Tree_Anonymous( file_get_contents($full_path), 0, array(), true );
  178.             if( $this->features ){
  179.                 return new Less_Tree_Media( array($contents), $this->features->value );
  180.             }
  182.             return array( $contents );
  183.         }
  185.         // optional (need to be before "CSS" to support optional CSS imports. CSS should be checked only if empty($this->currentFileInfo))
  186.         if( isset($this->options['optional']) && $this->options['optional'] && !file_exists($full_path) && (!$evald->css || !empty($this->currentFileInfo))) {
  187.             return array();
  188.         }
  191.         // css ?
  192.         if( $evald->css ){
  193.             $features = ( $evald->features ? $evald->features->compile($env) : null );
  194.             return new Less_Tree_Import( $this->compilePath( $env), $features, $this->options, $this->index);
  195.         }
  198.         return $this->ParseImport( $full_path, $uri, $env );
  199.     }
  202.     /**
  203.      * Using the import directories, get the full absolute path and uri of the import
  204.      *
  205.      * @param Less_Tree_Import $evald
  206.      */
  207.     public function PathAndUri(){
  209.         $evald_path = $this->getPath();
  211.         if( $evald_path ){
  213.             $import_dirs = array();
  215.             if( Less_Environment::isPathRelative($evald_path) ){
  216.                 //if the path is relative, the file should be in the current directory
  217.                 if ( $this->currentFileInfo ){
  218.                     $import_dirs[ $this->currentFileInfo['currentDirectory'] ] = $this->currentFileInfo['uri_root'];
  219.                 }
  221.             }else{
  222.                 //otherwise, the file should be relative to the server root
  223.                 if( $this->currentFileInfo ) {
  224.                     $import_dirs[ $this->currentFileInfo['entryPath'] ] = $this->currentFileInfo['entryUri'];
  225.                 }
  226.                 //if the user supplied entryPath isn't the actual root
  227.                 $import_dirs[ $_SERVER['DOCUMENT_ROOT'] ] = '';
  229.             }
  231.             // always look in user supplied import directories
  232.             $import_dirs = array_merge( $import_dirs, Less_Parser::$options['import_dirs'] );
  235.             foreach( $import_dirs as $rootpath => $rooturi){
  236.                 if( is_callable($rooturi) ){
  237.                     list($path, $uri) = call_user_func($rooturi, $evald_path);
  238.                     if( is_string($path) ){
  239.                         $full_path = $path;
  240.                         return array( $full_path, $uri );
  241.                     }
  242.                 }elseif( !empty($rootpath) ){
  244.                     $path = rtrim($rootpath,'/\\').'/'.ltrim($evald_path,'/\\');
  246.                     if( file_exists($path) ){
  247.                         $full_path = Less_Environment::normalizePath($path);
  248.                         $uri = Less_Environment::normalizePath(dirname($rooturi.$evald_path));
  249.                         return array( $full_path, $uri );
  250.                     } elseif( file_exists($path.'.less') ){
  251.                         $full_path = Less_Environment::normalizePath($path.'.less');
  252.                         $uri = Less_Environment::normalizePath(dirname($rooturi.$evald_path.'.less'));
  253.                         return array( $full_path, $uri );
  254.                     }
  255.                 }
  256.             }
  257.         }
  258.     }
  261.     /**
  262.      * Parse the import url and return the rules
  263.      *
  264.      * @return Less_Tree_Media|array
  265.      */
  266.     public function ParseImport( $full_path, $uri, $env ){
  268.         $import_env = clone $env;
  269.         if( (isset($this->options['reference']) && $this->options['reference']) || isset($this->currentFileInfo['reference']) ){
  270.             $import_env->currentFileInfo['reference'] = true;
  271.         }
  273.         if( (isset($this->options['multiple']) && $this->options['multiple']) ){
  274.             $import_env->importMultiple = true;
  275.         }
  277.         $parser = new Less_Parser($import_env);
  278.         $root = $parser->parseFile($full_path, $uri, true);
  281.         $ruleset = new Less_Tree_Ruleset(array(), $root->rules );
  282.         $ruleset->evalImports($import_env);
  284.         return $this->features ? new Less_Tree_Media($ruleset->rules, $this->features->value) : $ruleset->rules;
  285.     }
  288.     /**
  289.      * Should the import be skipped?
  290.      *
  291.      * @return boolean|null
  292.      */
  293.     private function Skip($path, $env){
  295.         $path = Less_Parser::AbsPath($path, true);
  297.         if( $path && Less_Parser::FileParsed($path) ){
  299.             if( isset($this->currentFileInfo['reference']) ){
  300.                 return true;
  301.             }
  303.             return !isset($this->options['multiple']) && !$env->importMultiple;
  304.         }
  306.     }
  307. }