PHP Less_Parser::SetImportDirs方法代码示例

 /**
  * Filters an asset after it has been loaded.
  *
  * @param  \Assetic\Asset\AssetInterface  $asset
  * @return void
  */
 public function filterLoad(AssetInterface $asset)
 {
     $max_nesting_level = ini_get('xdebug.max_nesting_level');
     $memory_limit = ini_get('memory_limit');
     if ($max_nesting_level && $max_nesting_level < 200) {
         ini_set('xdebug.max_nesting_level', 200);
     }
     if ($memory_limit && $memory_limit < 256) {
         ini_set('memory_limit', '256M');
     }
     $root = $asset->getSourceRoot();
     $path = $asset->getSourcePath();
     $dirs = array();
     $lc = new \Less_Parser(array('compress' => true));
     if ($root && $path) {
         $dirs[] = dirname($root . '/' . $path);
     }
     foreach ($this->loadPaths as $loadPath) {
         $dirs[] = $loadPath;
     }
     $lc->SetImportDirs($dirs);
     $url = parse_url($this->getRequest()->getUriForPath(''));
     $absolutePath = str_replace(public_path(), '', $root);
     if (isset($url['path'])) {
         $absolutePath = $url['path'] . $absolutePath;
     }
     $lc->parseFile($root . '/' . $path, $absolutePath);
     $asset->setContent($lc->getCss());
 }

 public function Compile($less_files, $out_name, $modify_vars = [], $bootstrap_less = "mixins", $mediawiki_less = "mixins")
 {
     $lessphp = new \Less_Parser($this->cache_dir);
     switch ($bootstrap_less) {
         case "mixins":
             $lessphp->parseFile($this->bootstrap_dir . "/variables.less", "");
             $lessphp->parseFile(__DIR__ . "/custom_variables.less", "");
             $lessphp->parseFile($this->bootstrap_mixin, $this->bootstrap_mixin_url);
             break;
         case "full":
             $lessphp->SetImportDirs([$this->bootstrap_dir]);
             $lessphp->parseFile(__DIR__ . "/bootstrap.less", "");
             break;
         case "off":
             break;
     }
     switch ($mediawiki_less) {
         case "mixins":
             $lessphp->parseFile($this->mediawiki_mixin, $this->mediawiki_mixin_url);
             break;
         case "off":
             break;
     }
     foreach ($less_files as $less => $url) {
         $lessphp->parseFile($less, $url);
     }
     if ($modify_vars) {
         $lessphp->ModifyVars($modify_vars);
     }
     $css = $lessphp->getCss();
     file_put_contents($out_name, $css);
 }

 public function compileFile($fname, $outFname = null)
 {
     if (!is_readable($fname)) {
         throw new Exception('load error: failed to find ' . $fname);
     }
     $pi = pathinfo($fname);
     $oldImport = $this->importDir;
     $this->importDir = (array) $this->importDir;
     $this->importDir[] = realpath($pi['dirname']) . '/';
     $this->allParsedFiles = array();
     $this->addParsedFile($fname);
     $parser = new Less_Parser(array('sourceMap' => $this->sourceMap));
     $parser->SetImportDirs($this->getImportDirs());
     if (count($this->registeredVars)) {
         $parser->ModifyVars($this->registeredVars);
     }
     foreach ($this->libFunctions as $name => $func) {
         $parser->registerFunction($name, $func);
     }
     $parser->parseFile($fname);
     $out = $parser->getCss();
     $parsed = Less_Parser::AllParsedFiles();
     foreach ($parsed as $file) {
         $this->addParsedFile($file);
     }
     $this->importDir = $oldImport;
     if ($outFname !== null) {
         return file_put_contents($outFname, $out);
     }
     return $out;
 }

 public static function Cache(&$less_files, $parser_options = array())
 {
     //prepare the processor
     if (!class_exists('Less_Parser')) {
         include_once 'Less.php';
     }
     $parser = new Less_Parser($parser_options);
     $parser->SetCacheDir(self::$cache_dir);
     $parser->SetImportDirs(self::$import_dirs);
     // combine files
     try {
         foreach ($less_files as $file_path => $uri_or_less) {
             //treat as less markup if there are newline characters
             if (strpos($uri_or_less, "\n") !== false) {
                 $parser->Parse($uri_or_less);
                 continue;
             }
             $parser->ParseFile($file_path, $uri_or_less);
         }
         $compiled = $parser->getCss();
     } catch (Exception $e) {
         self::$error = $e;
         return false;
     }
     $less_files = $parser->allParsedFiles();
     return $compiled;
 }

 public function compile($source, $pathname)
 {
     $less = new \Less_Parser();
     $less->SetImportDirs(array(dirname($pathname) => './'));
     $less->parse($source);
     return $less->getCss();
 }

 /**
  * @param string $themeName
  * @param string $lessFile
  * @return string
  */
 public function compileFile($themeName, $lessFile)
 {
     $model = Model::instance();
     $theme = $model->getTheme($themeName);
     $options = $theme->getOptionsAsArray();
     $configModel = ConfigModel::instance();
     $config = $configModel->getAllConfigValues($themeName);
     $less = "@import '{$lessFile}';";
     $less .= $this->generateLessVariables($options, $config);
     $css = '';
     try {
         require_once ipFile('Ip/Lib/less.php/Less.php');
         $themeDir = ipFile('Theme/' . $themeName . '/assets/');
         $ipContentDir = ipFile('Ip/Internal/Core/assets/ipContent/');
         // creating new context to pass theme assets directory dynamically to a static callback function
         $context = $this;
         $callback = function ($parseFile) use($context, $themeDir) {
             return $context->overrideImportDirectory($themeDir, $parseFile);
         };
         $parserOptions = array('import_callback' => $callback, 'cache_dir' => ipFile('file/tmp/less/'), 'relativeUrls' => false, 'sourceMap' => true);
         $parser = new \Less_Parser($parserOptions);
         $directories = array($themeDir => '', $ipContentDir => '');
         $parser->SetImportDirs($directories);
         $parser->parse($less);
         $css = $parser->getCss();
         $css = "/* Edit {$lessFile}, not this file. */" . "\n" . $css;
     } catch (\Exception $e) {
         ipLog()->error('Less compilation error: Theme - ' . $e->getMessage());
     }
     return $css;
 }

 function compile_botstrap_less_adm($theme, $input, $output = '', $compress = false)
 {
     global $cfg;
     $output = empty($output) ? $input : $output;
     $output = $cfg['themes_dir'] . '/admin/' . $theme . '/css/' . $output . '.css';
     $input = $cfg['themes_dir'] . '/admin/' . $theme . '/less/' . $input . '.less';
     if (file_exists($output) && file_exists($input)) {
         $filetimecss = filemtime($output);
         $filetimeless = filemtime($input);
         //	cot_print('css', cot_date('datetime_full', $filetimecss), 'less', cot_date('datetime_full', $filetimeless), cot_date('datetime_full'), $filetimecss > $filetimeless);
         if ($filetimecss > $filetimeless) {
             return false;
         } else {
             unlink($output);
             //	cot_print("deleted");
         }
     }
     $options = array('relativeUrls' => false);
     if ($compress) {
         $options['compress'] = true;
     }
     $parser = new Less_Parser($options);
     $parser->SetImportDirs(array($cfg['themes_dir'] . '/admin/' . $theme . '/less' => $cfg['themes_dir'] . '/admin/' . $theme . '/less', $cfg['plugins_dir'] . "/bootstrap/bootstrap/less" => $cfg['plugins_dir'] . "/bootstrap/bootstrap/less"));
     $parser->parseFile($input);
     $css = $parser->getCss();
     if (!file_exists($cfg['themes_dir'] . '/admin/' . $theme . '/css')) {
         mkdir($cfg['themes_dir'] . '/admin/' . $theme . '/css');
     }
     file_put_contents($output, $css);
     return true;
 }

 public static function compile($source, $path, $todir, $importdirs)
 {
     $parser = new Less_Parser();
     $parser->SetImportDirs($importdirs);
     $parser->parse($source, CANVASLess::relativePath($todir, dirname($path)) . basename($path));
     $output = $parser->getCss();
     return $output;
 }

 public static function compile($source, $importdirs)
 {
     $parser = new Less_Parser();
     $parser->SetImportDirs($importdirs);
     $parser->parse($source);
     $output = $parser->getCss();
     return $output;
 }

 /**
  * {@inheritdoc}
  */
 public function setImportPath($fullPath, $relPath = null)
 {
     $this->_initCompiler();
     $relPath = $relPath ?: $this->_options->get('root_url');
     if (!FS::isDir($fullPath)) {
         throw new Exception('Undefined import path: ' . $fullPath);
     }
     $importPaths = \Less_Parser::$options['import_dirs'];
     $importPaths[$fullPath] = $relPath;
     $this->_compiler->SetImportDirs($importPaths);
 }

 /**
  * {@inheritdoc}
  */
 public function compile($path, $relativePath)
 {
     $this->parsedFiles = array();
     $parser = new \Less_Parser(array('compress' => true));
     if (!empty($this->importDirs)) {
         $parser->SetImportDirs($this->importDirs);
     }
     $parser->parseFile($path);
     $parser->ModifyVars($this->variables);
     $css = $parser->getCss();
     $this->parsedFiles = $parser->allParsedFiles();
     return $css;
 }

 public function register()
 {
     Event::listen('watcher:check', function ($options) {
         $timestamp = strtotime($options->timestamp);
         $reload = false;
         if (isset($options->less_process) && is_array($options->less_process) && $timestamp) {
             $lessCompiler = new \Less_Parser();
             if (isset($options->less_importdirs) && is_array($options->less_importdirs)) {
                 $importDirs = array();
                 foreach ($options->less_importdirs as $importdir) {
                     $importdir = realpath(base_path($importdir));
                     if (is_dir($importdir)) {
                         $importDirs[] = $importdir;
                         foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($importdir)) as $x) {
                             if (!$x->isDir() && $x->getCTime() > $timestamp) {
                                 $reload = true;
                             }
                         }
                     }
                 }
                 $lessCompiler->SetImportDirs($importDirs);
             }
             foreach ($options->less_process as $source => $output) {
                 $source = realpath(base_path($source));
                 $output = realpath(base_path($output));
                 if (!$output) {
                     $output = base_path($output);
                 }
                 if (is_file($source)) {
                     if ($reload) {
                         touch($source);
                     }
                     if (filemtime($source) > $timestamp || $reload) {
                         try {
                             $lessCompiler->parseFile($source, '/');
                             $css = $lessCompiler->getCss();
                             if ($css) {
                                 file_put_contents($output, $css);
                             }
                         } catch (Exception $e) {
                         }
                     }
                 }
             }
         }
     });
 }

 /**
  * @return Less_Parser
  */
 protected function _initProcessor()
 {
     // lazy load
     if (!class_exists('Less_Parser')) {
         require_once dirname(__FILE__) . '/class.less.gpeasy.php';
     }
     $options = array('compress' => true, 'strictUnits' => false, 'strictMath' => false, 'numPrecision' => 4, 'cache_method' => false);
     if ($this->_isDebug()) {
         $options['compress'] = false;
     }
     $less = new Less_Parser($options);
     // set paths
     $less->SetImportDirs(array($this->_tpl->lessFull => $this->_tpl->baseurl));
     // add custom vars
     $less->ModifyVars(array());
     return $less;
 }

 /**
  * less compiler
  * @link https://github.com/oyejorge/less.php
  *
  * @param string $file
  * @return string
  */
 protected function less($file)
 {
     if (!class_exists('\\Less_Parser')) {
         return Result::errorMissingPackage($this, 'Less_Parser', 'oyejorge/less.php');
     }
     $lessCode = file_get_contents($file);
     $parser = new \Less_Parser();
     $parser->SetOptions($this->compilerOptions);
     if (isset($this->compilerOptions['importDirs'])) {
         $importDirs = [];
         foreach ($this->compilerOptions['importDirs'] as $dir) {
             $importDirs[$dir] = $dir;
         }
         $parser->SetImportDirs($importDirs);
     }
     $parser->parse($lessCode);
     return $parser->getCss();
 }

 /**
  * @return Less_Parser
  */
 protected function _initProcessor()
 {
     // lazy load
     if (!class_exists('Less_Parser')) {
         require_once dirname(__FILE__) . '/class.less.gpeasy.php';
     }
     $options = array('compress' => 1, 'strictUnits' => 0, 'strictMath' => 0, 'relativeUrls' => 1, 'numPrecision' => 4, 'cache_method' => 0, 'sourceMap' => 0);
     if ($this->_isDebug()) {
         $options['compress'] = 0;
         $options['sourceMap'] = 1;
         $options['sourceMapRootpath'] = $this->_tpl->less;
         $options['sourceMapBasepath'] = $path = JPath::clean($this->_tpl->lessFull, '/');
     }
     $less = new Less_Parser($options);
     // set paths
     $less->SetImportDirs(array($this->_tpl->lessFull => $this->_tpl->less));
     // add custom vars
     $less->ModifyVars($this->_getCustomVars());
     return $less;
 }