/**
* Parse this node.
* If the node is a CSS import return the CSS import rule.
* Else returns the rendered tree for the file.
* @param SassContext $context the context in which this node is parsed
* @return array the parsed node
*/
public function parse($context)
{
$imported = array();
foreach ($this->files as $file) {
if (preg_match(self::MATCH_CSS, $file, $matches)) {
if (isset($matches[2]) && $matches[2] == 'url') {
$file = $matches[1];
} else {
$file = "url('{$file}')";
}
return array(new SassString("@import {$file};"), new SassString("\n"));
}
$file = trim($file, '\'"');
$files = SassFile::get_file($file, $this->parser);
$tree = array();
if ($files) {
if ($this->token->level > 0) {
$tree = $this->parent;
while (get_class($tree) != 'SassRuleNode' && get_class($tree) != 'SassRootNode' && isset($tree->parent)) {
$tree = $tree->parent;
}
$tree = clone $tree;
$tree->children = array();
} else {
$tree = new SassRootNode($this->parser);
$tree->extend_parent = $this->parent;
}
foreach ($files as $subfile) {
if (preg_match(self::MATCH_CSS, $subfile)) {
$tree->addChild(new SassString("@import url('{$subfile}');"));
} else {
$this->parser->filename = $subfile;
$subtree = SassFile::get_tree($subfile, $this->parser);
foreach ($subtree->getChildren() as $child) {
$tree->addChild($child);
}
}
}
}
if (!empty($tree)) {
# parent may be either SassRootNode (returns an object) or SassRuleNode (returns an array of nodes)
# so we parse then try get the children.
$parsed = $tree->parse($context);
if (!is_array($parsed) && isset($parsed->children)) {
$parsed = $parsed->children;
}
if (is_array($parsed)) {
$imported = array_merge($imported, $parsed);
}
}
}
return $imported;
}
/**
* Parse this node.
* If a CSS import returns the import rule.
* Else returns the rendered tree for the file.
* @param SassContext the context in which this node is parsed
* @return array the parsed node
*/
public function parse($context)
{
if (preg_match(self::MATCH_CSS, $this->uri)) {
return "@import {$this->uri}";
} else {
$tree = SassFile::getTree(SassFile::getFile($this->uri, $this->options), $this->options);
if (empty($tree)) {
throw new SassImportNodeException("Unable to create document tree for {$this->uri}");
} else {
return $tree->parse($context)->children;
}
}
}
/**
* Get imported files
*
* @param SassParser $parser The current parser
*
* @return String[] All imported files
*/
public function getFiles($parser)
{
$files = array();
foreach ($this->files as $file) {
if (preg_match(self::MATCH_CSS, $file, $matches)) {
if (isset($matches[2]) && $matches[2] == 'url') {
$file = $matches[1];
} else {
$file = "url('{$file}')";
}
return array(new SassString("@import {$file};"), new SassString("\n"));
}
$file = trim($file, '\'"');
$files = array_merge(SassFile::get_file($file, $parser), $files);
}
return $files;
}
/**
* Parse this node.
* If the node is a CSS import return the CSS import rule.
* Else returns the rendered tree for the file.
*
* @param
* SassContext the context in which this node is parsed
* @return array the parsed node
*/
public function parse($context)
{
$imported = array();
foreach ($this->files as $file) {
if (preg_match(self::MATCH_CSS, $file)) {
return "@import {$file}";
} else {
$file = trim($file, '\'"');
$tree = SassFile::getTree(SassFile::getFile($file, $this->parser), $this->parser);
if (empty($tree)) {
throw new SassImportNodeException('Unable to create document tree for {file}', array('{file}' => $file), $this);
} else {
$imported = array_merge($imported, $tree->parse($context)->children);
}
}
}
return $imported;
}
/**
* Parse a sass file or Sass source code and
* returns the document tree that can then be rendered.
* The file will be searched for in the directories specified by the
* load_paths option.
* @param string name of source file or Sass source
* @return SassRootNode Root node of document tree
*/
public function parse($source, $isFile = true)
{
# Richard Lyon - 2011-10-25 - ignore unfound files
# Richard Lyon - 2011-10-25 - add multiple files to load functions
if (!$source) {
return $this->toTree($source);
}
if (is_array($source)) {
$return = null;
foreach ($source as $key => $value) {
if (is_numeric($key)) {
$code = $value;
$type = true;
} else {
$code = $key;
$type = $value;
}
if ($return === null) {
$return = $this->parse($code, $type);
} else {
$newNode = $this->parse($code, $type);
foreach ($newNode->children as $children) {
array_push($return->children, $children);
}
}
}
return $return;
}
if ($isFile && ($files = SassFile::get_file($source, $this))) {
$files_source = '';
foreach ($files as $file) {
$this->filename = $file;
$this->syntax = substr(strrchr($file, '.'), 1);
if ($this->syntax == SassFile::CSS) {
$this->property_syntax = "css";
} elseif (!$this->property_syntax && $this->syntax == SassFile::SCSS) {
$this->property_syntax = "scss";
}
if ($this->syntax !== SassFile::SASS && $this->syntax !== SassFile::SCSS && $this->syntax !== SassFile::CSS) {
if ($this->debug) {
throw new SassException('Invalid {what}', array('{what}' => 'syntax option'));
}
return FALSE;
}
$files_source .= SassFile::get_file_contents($this->filename, $this);
}
return $this->toTree($files_source);
} else {
return $this->toTree($source);
}
}
public static function compassUrl($path, $only_path = false, $web_path = true)
{
$opath = $path;
if (!($path = SassFile::get_file($path, SassParser::$instance, false))) {
throw new Exception('File not found: ' . $opath);
}
$path = $path[0];
if ($web_path) {
$webroot = realpath($_SERVER['DOCUMENT_ROOT']);
$path = str_replace($webroot, '', $path);
}
if ($only_path) {
return new SassString($path);
}
return new SassString("url('{$path}')");
}
/**
* Parse a sass file or Sass source code and
* returns the document tree that can then be rendered.
* The file will be searched for in the directories specified by the
* load_paths option.
* @param string name of source file or Sass source
* @return SassRootNode Root node of document tree
*/
public function parse($source, $isFile = true)
{
# Richard Lyon - 2011-10-25 - ignore unfound files
# Richard Lyon - 2011-10-25 - add multiple files to load functions
if (!$source) {
return $this->toTree($source);
}
if (is_array($source)) {
$return = array();
foreach ($source as $source_file) {
$return = array_merge($return, $this->parse($source_file, TRUE));
}
return $return;
}
if ($isFile && ($files = SassFile::get_file($source, $this))) {
$files_source = '';
foreach ($files as $file) {
$this->filename = $file;
$this->syntax = substr(strrchr($file, '.'), 1);
if ($this->syntax == SassFile::CSS) {
$this->property_syntax = "css";
} elseif (!$this->property_syntax && $this->syntax == SassFile::SCSS) {
$this->property_syntax = "scss";
}
if ($this->syntax !== SassFile::SASS && $this->syntax !== SassFile::SCSS && $this->syntax !== SassFile::CSS) {
if ($this->debug) {
throw new SassException('Invalid {what}', array('{what}' => 'syntax option'));
}
return FALSE;
}
$files_source .= SassFile::get_file_contents($this->filename, $this);
}
return $this->toTree($files_source);
} else {
return $this->toTree($source);
}
}
/**
* Parse a sass file or Sass source code and
* returns the document tree that can then be rendered.
* The file will be searched for in the directories specified by the
* load_paths option.
* If caching is enabled a cached version will be used if possible or the
* compiled version cached if not.
* @param string name of source file or Sass source
* @return SassRootNode Root node of document tree
*/
public function parse($source, $isFile = true)
{
if ($isFile) {
$this->filename = SassFile::getFile($source, $this);
if ($isFile) {
$this->syntax = substr($this->filename, -4);
} elseif ($this->syntax !== SassFile::SASS && $this->syntax !== SassFile::SCSS) {
throw new SassException('Invalid {what}', array('{what}' => 'syntax option'));
}
if ($this->cache) {
$cached = SassFile::getCachedFile($this->filename, $this->cache_location);
if ($cached !== false) {
return $cached;
}
}
$tree = $this->toTree(file_get_contents($this->filename));
if ($this->cache) {
SassFile::setCachedFile($tree, $this->filename, $this->cache_location);
}
return $tree;
} else {
return $this->toTree($source);
}
}
/**
* Parse a sass file or Sass source code and
* returns the document tree that can then be rendered.
* The file will be searched for in the directories specified by the
* load_paths option.
* If caching is enabled a cached version will be used if possible or the
* compiled version cached if not.
* @param string name of source file or Sass source
* @return SassRootNode Root node of document tree
*/
public function parse($source, $isFile = true)
{
if ($isFile) {
$filename = SassFile::getFile($source, $this->options);
$this->options['file']['dirname'] = dirname($filename);
$this->options['file']['basename'] = basename($filename);
if ($this->options['cache']) {
$cached = SassFile::getCachedFile($filename, $this->options);
if ($cached !== false) {
return $cached;
}
}
$tree = $this->toTree(file($filename, FILE_IGNORE_NEW_LINES));
if ($this->options['cache']) {
SassFile::setCachedFile($tree, $filename, $this->options);
}
return $tree;
} else {
return $this->toTree(explode("\n", $source));
}
}
