.
7 | *
8 | * is comma+space separated
9 | * is available to the rest of the script following evaluation
10 | * and has the value that terminated the loop.
11 | *
12 | * @author Pavol (Lopo) Hluchy
13 | * @copyright Copyright (c) 2011 Lopo
14 | * @license http://www.gnu.org/licenses/gpl.html GNU General Public License Version 3
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 |
19 | /**
20 | * SassEachNode class.
21 | * Represents a Sass @each loop.
22 | * @package PHamlP
23 | * @subpackage Sass.tree
24 | */
25 | class SassEachNode extends SassNode
26 | {
27 | const MATCH = '/@each\s+[!\$](.+?)in\s+(.+)$/i';
28 |
29 | const VARIABLE = 1;
30 | const IN = 2;
31 |
32 | /**
33 | * @var string variable name for the loop
34 | */
35 | private $variable;
36 | /**
37 | * @var string expression that provides the loop values
38 | */
39 | private $in;
40 |
41 | /**
42 | * SassEachNode constructor.
43 | * @param object $token source token
44 | * @return SassEachNode
45 | */
46 | public function __construct($token)
47 | {
48 | parent::__construct($token);
49 | if (!preg_match(self::MATCH, $token->source, $matches)) {
50 | throw new SassEachNodeException('Invalid @each directive', $this);
51 | } else {
52 | $this->variable = trim($matches[self::VARIABLE]);
53 | $this->in = $matches[self::IN];
54 | }
55 | }
56 |
57 | /**
58 | * Parse this node.
59 | * @param SassContext $context the context in which this node is parsed
60 | * @return array parsed child nodes
61 | */
62 | public function parse($context)
63 | {
64 | $children = array();
65 |
66 | if ($this->variable && $this->in) {
67 | $context = new SassContext($context);
68 |
69 | list($in, $sep) = SassList::_parse_list($this->in, 'auto', true, $context);
70 | foreach ($in as $var) {
71 | $context->setVariable($this->variable, $var);
72 | $children = array_merge($children, $this->parseChildren($context));
73 | }
74 | }
75 | $context->merge();
76 |
77 | return $children;
78 | }
79 | }
80 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassElseNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassElseNode class.
14 | * Represents Sass Else If and Else statements.
15 | * Else If and Else statement nodes are chained below the If statement node.
16 | * @package PHamlP
17 | * @subpackage Sass.tree
18 | */
19 | class SassElseNode extends SassIfNode
20 | {
21 | /**
22 | * SassElseNode constructor.
23 | * @param object $token source token
24 | * @return SassElseNode
25 | */
26 | public function __construct($token)
27 | {
28 | parent::__construct($token, false);
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassExtendNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassExtendNode class.
14 | * Represents a Sass @debug or @warn directive.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassExtendNode extends SassNode
19 | {
20 | const IDENTIFIER = '@';
21 | const MATCH = '/^@extend\s+(.+)/i';
22 | const VALUE = 1;
23 |
24 | /**
25 | * @var string the directive
26 | */
27 | private $value;
28 |
29 | /**
30 | * SassExtendNode.
31 | * @param object $token source token
32 | * @return SassExtendNode
33 | */
34 | public function __construct($token)
35 | {
36 | parent::__construct($token);
37 | preg_match(self::MATCH, $token->source, $matches);
38 | $this->value = $matches[self::VALUE];
39 | }
40 |
41 | /**
42 | * Parse this node.
43 | * @return array An empty array
44 | */
45 | public function parse($context)
46 | {
47 | # resolve selectors in relation to variables
48 | # allows extend inside nested loops.
49 | $this->root->extend($this->value, $this->parent->resolveSelectors($context));
50 |
51 | return array();
52 | }
53 | }
54 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassForNode.php:
--------------------------------------------------------------------------------
1 | @for from to|through [ step ]
.
9 | *
10 | * can be less or greater than .
11 | * If the step clause is ommitted the = 1.
12 | * is available to the rest of the script following evaluation
13 | * and has the value that terminated the loop.
14 | *
15 | * @author Chris Yates
16 | * @copyright Copyright (c) 2010 PBM Web Development
17 | * @license http://phamlp.googlecode.com/files/license.txt
18 | * @package PHamlP
19 | * @subpackage Sass.tree
20 | */
21 |
22 | /**
23 | * SassForNode class.
24 | * Represents a Sass @for loop.
25 | * @package PHamlP
26 | * @subpackage Sass.tree
27 | */
28 | class SassForNode extends SassNode
29 | {
30 | const MATCH = '/@for\s+[!\$](\w+)\s+from\s+(.+?)\s+(through|to)\s+(.+?)(?:\s+step\s+(.+))?$/i';
31 |
32 | const VARIABLE = 1;
33 | const FROM = 2;
34 | const INCLUSIVE = 3;
35 | const TO = 4;
36 | const STEP = 5;
37 | const IS_INCLUSIVE = 'through';
38 |
39 | /**
40 | * @var string variable name for the loop
41 | */
42 | private $variable;
43 | /**
44 | * @var string expression that provides the loop start value
45 | */
46 | private $from;
47 | /**
48 | * @var string expression that provides the loop end value
49 | */
50 | private $to;
51 | /**
52 | * @var boolean whether the loop end value is inclusive
53 | */
54 | private $inclusive;
55 | /**
56 | * @var string expression that provides the amount by which the loop variable
57 | * changes on each iteration
58 | */
59 | private $step;
60 |
61 | /**
62 | * SassForNode constructor.
63 | * @param object $token source token
64 | * @return SassForNode
65 | */
66 | public function __construct($token)
67 | {
68 | parent::__construct($token);
69 | if (!preg_match(self::MATCH, $token->source, $matches)) {
70 | throw new SassForNodeException('Invalid @for directive', $this);
71 | }
72 | $this->variable = $matches[self::VARIABLE];
73 | $this->from = $matches[self::FROM];
74 | $this->to = $matches[self::TO];
75 | $this->inclusive = ($matches[self::INCLUSIVE] === SassForNode::IS_INCLUSIVE);
76 | $this->step = (empty($matches[self::STEP]) ? 1 : $matches[self::STEP]);
77 | }
78 |
79 | /**
80 | * Parse this node.
81 | * @param SassContext $context the context in which this node is parsed
82 | * @return array parsed child nodes
83 | */
84 | public function parse($context)
85 | {
86 | $children = array();
87 | $from = (float) $this->evaluate($this->from, $context)->value;
88 | $to = (float) $this->evaluate($this->to, $context)->value;
89 | $step = (float) $this->evaluate($this->step, $context)->value * ($to > $from ? 1 : -1);
90 |
91 | if ($this->inclusive) {
92 | $to += ($from < $to ? 1 : -1);
93 | }
94 |
95 | $context = new SassContext($context);
96 | for ($i = $from; ($from < $to ? $i < $to : $i > $to); $i = $i + $step) {
97 | $context->setVariable($this->variable, new SassNumber($i));
98 | $children = array_merge($children, $this->parseChildren($context));
99 | }
100 |
101 | return $children;
102 | }
103 | }
104 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassFunctionDefinitionNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassFunctionDefinitionNode class.
14 | * Represents a Function definition.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassFunctionDefinitionNode extends SassNode
19 | {
20 | const NODE_IDENTIFIER = FALSE;
21 | const MATCH = '/^@function\s+([_\-\w]+)\s*(?:\((.*?)\))?\s*$/im';
22 | const IDENTIFIER = 1;
23 | const NAME = 1;
24 | const ARGUMENTS = 2;
25 |
26 | /**
27 | * @var string name of the function
28 | */
29 | private $name;
30 | /**
31 | * @var array arguments for the function as name=>value pairs were value is the
32 | * default value or null for required arguments
33 | */
34 | private $args = array();
35 |
36 | public $parent;
37 |
38 | /**
39 | * SassFunctionDefinitionNode constructor.
40 | * @param object $token source token
41 | * @return SassFunctionDefinitionNode
42 | */
43 | public function __construct($token)
44 | {
45 | // if ($token->level !== 0) {
46 | // throw new SassFunctionDefinitionNodeException('Functions can only be defined at root level', $token);
47 | // }
48 | parent::__construct($token);
49 | preg_match(self::MATCH, $token->source, $matches);
50 | if (empty($matches)) {
51 | throw new SassFunctionDefinitionNodeException('Invalid Function', $token);
52 | }
53 | $this->name = $matches[self::NAME];
54 | $this->name = preg_replace('/[^a-z0-9_]/', '_', strtolower($this->name));
55 | if (isset($matches[self::ARGUMENTS])) {
56 | if (strlen(trim($matches[self::ARGUMENTS]))) {
57 | foreach (explode(',', $matches[self::ARGUMENTS]) as $arg) {
58 | $arg = explode(($matches[self::IDENTIFIER] === self::NODE_IDENTIFIER ? '=' : ':'), trim($arg));
59 | $this->args[substr(trim($arg[0]), 1)] = (count($arg) == 2 ? trim($arg[1]) : null);
60 | } // foreach
61 | }
62 | }
63 | }
64 |
65 | /**
66 | * Parse this node.
67 | * Add this function to the current context.
68 | * @param SassContext $context the context in which this node is parsed
69 | * @return array the parsed node - an empty array
70 | */
71 | public function parse($context)
72 | {
73 | $context->addFunction($this->name, $this);
74 |
75 | return array();
76 | }
77 |
78 | /**
79 | * Returns the arguments with default values for this function
80 | * @return array the arguments with default values for this function
81 | */
82 | public function getArgs()
83 | {
84 | return $this->args;
85 | }
86 |
87 | /**
88 | * Returns a value indicating if the token represents this type of node.
89 | * @param object $token token
90 | * @return boolean true if the token represents this type of node, false if not
91 | */
92 | public static function isa($token)
93 | {
94 | return $token->source[0] === self::NODE_IDENTIFIER;
95 | }
96 |
97 | /**
98 | * Evalutes the function in the given context, with the provided arguments
99 | * @param SassContext - the parent context
100 | * @param array - the list of provided variables
101 | * @throws SassReturn - if the @return is fired then this is thrown to break early
102 | * @return SassBoolean(false) - if no @return was fired, return false
103 | */
104 | public function execute($pcontext, $provided)
105 | {
106 | list($arguments, $context) = SassScriptFunction::fill_parameters($this->args, $provided, $pcontext, $this);
107 | $context->setVariables($arguments);
108 |
109 | $children = array();
110 | try {
111 | foreach ($this->children as $child) {
112 | $child->parent = $this;
113 | $children = array_merge($children, $child->parse($context));
114 | }
115 | } catch (SassReturn $e) {
116 | return $e->value;
117 | }
118 |
119 | return new SassBoolean('false');
120 | }
121 | }
122 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassIfNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassIfNode class.
14 | * Represents Sass If, Else If and Else statements.
15 | * Else If and Else statement nodes are chained below the If statement node.
16 | * @package PHamlP
17 | * @subpackage Sass.tree
18 | */
19 | class SassIfNode extends SassNode
20 | {
21 | const MATCH_IF = '/^@if\s*(.+)$/i';
22 | const MATCH_ELSE = '/@else(\s*if\s*(.+))?/i';
23 | const IF_EXPRESSION = 1;
24 | const ELSE_IF = 1;
25 | const ELSE_EXPRESSION = 2;
26 | /**
27 | * @var SassIfNode the next else node.
28 | */
29 | private $else;
30 | /**
31 | * @var string expression to evaluate
32 | */
33 | private $expression;
34 |
35 | /**
36 | * SassIfNode constructor.
37 | * @param object $token source token
38 | * @param boolean $if true for an "if" node, false for an "else if | else" node
39 | * @return SassIfNode
40 | */
41 | public function __construct($token, $if=true)
42 | {
43 | parent::__construct($token);
44 | if ($if) {
45 | preg_match(self::MATCH_IF, $token->source, $matches);
46 | $this->expression = $matches[SassIfNode::IF_EXPRESSION];
47 | } else {
48 | preg_match(self::MATCH_ELSE, $token->source, $matches);
49 | $this->expression = (sizeof($matches)==1 ? null : $matches[SassIfNode::ELSE_EXPRESSION]);
50 | }
51 | }
52 |
53 | /**
54 | * Adds an "else" statement to this node.
55 | * @param SassIfNode "else" statement node to add
56 | * @return SassIfNode this node
57 | */
58 | public function addElse($node)
59 | {
60 | if ($this->else === null) {
61 | $node->parent = $this;
62 | $node->root = $this->root;
63 | $this->else = $node;
64 | } else {
65 | $this->else->addElse($node);
66 | }
67 |
68 | return $this;
69 | }
70 |
71 | /**
72 | * Parse this node.
73 | * @param SassContext $context the context in which this node is parsed
74 | * @return array parsed child nodes
75 | */
76 | public function parse($context)
77 | {
78 | if ($this->isElse() || $this->evaluate($this->expression, $context)->toBoolean()) {
79 | $children = $this->parseChildren($context);
80 | } elseif (!empty($this->else)) {
81 | $children = $this->else->parse($context);
82 | } else {
83 | $children = array();
84 | }
85 |
86 | return $children;
87 | }
88 |
89 | /**
90 | * Returns a value indicating if this node is an "else" node.
91 | * @return true if this node is an "else" node, false if this node is an "if"
92 | * or "else if" node
93 | */
94 | private function isElse()
95 | {
96 | return ($this->expression=='');
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassImportNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassImportNode class.
14 | * Represents a CSS Import.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassImportNode extends SassNode
19 | {
20 | const IDENTIFIER = '@';
21 | const MATCH = '/^@import\s+(.+)/i';
22 | const MATCH_CSS = '/^((url)\((.+)\)|.+" \w+|http|.+\.css$)/im';
23 | const FILES = 1;
24 |
25 | /**
26 | * @var array files to import
27 | */
28 | private $files = array();
29 |
30 | /**
31 | * SassImportNode.
32 | * @param object $token source token
33 | * @return SassImportNode
34 | */
35 | public function __construct($token, $parent)
36 | {
37 | parent::__construct($token);
38 | $this->parent = $parent;
39 | preg_match(self::MATCH, $token->source, $matches);
40 |
41 | foreach (SassList::_build_list($matches[self::FILES]) as $file) {
42 | $this->files[] = trim($file, '"\'; ');
43 | }
44 | }
45 |
46 | /**
47 | * Parse this node.
48 | * If the node is a CSS import return the CSS import rule.
49 | * Else returns the rendered tree for the file.
50 | * @param SassContext $context the context in which this node is parsed
51 | * @return array the parsed node
52 | */
53 | public function parse($context)
54 | {
55 | $imported = array();
56 | foreach ($this->files as $file) {
57 | if (preg_match(self::MATCH_CSS, $file, $matches)) {
58 | if (isset($matches[2]) && $matches[2] == 'url') {
59 | $file = $matches[1];
60 | } else {
61 | $file = "url('$file')";
62 | }
63 |
64 | return array(new SassString("@import $file;"), new SassString("\n"));
65 | }
66 | $file = trim($file, '\'"');
67 | $files = SassFile::get_file($file, $this->parser);
68 | $tree = array();
69 | if ($files) {
70 | if ($this->token->level > 0) {
71 | $tree = $this->parent;
72 | while (get_class($tree) != 'SassRuleNode' && get_class($tree) != 'SassRootNode' && isset($tree->parent)) {
73 | $tree = $tree->parent;
74 | }
75 | $tree = clone $tree;
76 | $tree->children = array();
77 | } else {
78 | $tree = new SassRootNode($this->parser);
79 | $tree->extend_parent = $this->parent;
80 | }
81 |
82 | foreach ($files as $subfile) {
83 | if (preg_match(self::MATCH_CSS, $subfile)) {
84 | $tree->addChild(new SassString("@import url('$subfile');"));
85 | } else {
86 | $this->parser->filename = $subfile;
87 | $subtree = SassFile::get_tree($subfile, $this->parser);
88 | foreach ($subtree->getChildren() as $child) {
89 | $tree->addChild($child);
90 | }
91 | }
92 | }
93 | }
94 | if (!empty($tree)) {
95 | # parent may be either SassRootNode (returns an object) or SassRuleNode (returns an array of nodes)
96 | # so we parse then try get the children.
97 | $parsed = $tree->parse($context);
98 | if (!is_array($parsed) && isset($parsed->children)) {
99 | $parsed = $parsed->children;
100 | }
101 | if (is_array($parsed)) {
102 | $imported = array_merge($imported, $parsed);
103 | }
104 | }
105 | }
106 |
107 | return $imported;
108 | }
109 | }
110 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassMediaNode.php:
--------------------------------------------------------------------------------
1 | source, $matches);
54 | $this->token = $token;
55 | $this->media = $matches[self::MEDIA];
56 | }
57 |
58 | /**
59 | * Parse this node.
60 | * This raises an error.
61 | * @return array An empty array
62 | */
63 | public function parse($context)
64 | {
65 | // If we are in a loop, function or mixin then the parent isn't what should
66 | // go inside the media node. Walk up the parent tree to find the rule node
67 | // to put inside the media node or the root node if the media node should be
68 | // at the root.
69 | $parent = $this->parent;
70 | while (!($parent instanceOf SassRuleNode) && !($parent instanceOf SassRootNode)) {
71 | $parent = $parent->parent;
72 | }
73 |
74 | // Make a copy of the token before parsing in case we are in a loop and it contains variables
75 | $token = clone $this->token;
76 | $token->source = SassDirectiveNode::interpolate_nonstrict($token->source, $context);
77 |
78 | $node = new SassRuleNode($token, $context);
79 | $node->root = $parent->root;
80 |
81 | $rule = clone $parent;
82 | $rule->root = $node->root;
83 | $rule->children = $this->children;
84 |
85 | $try = $rule->parse($context);
86 | if (is_array($try)) {
87 | $rule->children = $try;
88 | }
89 | // Tests were failing with this, but I'm not sure if we cover every case.
90 | //else if (is_object($try) && method_exists($try, 'render')) {
91 | // $rule = $try;
92 | //}
93 |
94 | $node->children = array(new SassString($rule->render($context)));
95 |
96 | return array($node);
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassMixinDefinitionNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassMixinDefinitionNode class.
14 | * Represents a Mixin definition.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassMixinDefinitionNode extends SassNode
19 | {
20 | const NODE_IDENTIFIER = '=';
21 | const MATCH = '/^(=|@mixin\s+)([-\w]+)\s*(?:\((.*?)\))?\s*$/im';
22 | const IDENTIFIER = 1;
23 | const NAME = 2;
24 | const ARGUMENTS = 3;
25 |
26 | /**
27 | * @var string name of the mixin
28 | */
29 | private $name;
30 | /**
31 | * @var array arguments for the mixin as name=>value pairs were value is the
32 | * default value or null for required arguments
33 | */
34 | private $args = array();
35 |
36 | /**
37 | * SassMixinDefinitionNode constructor.
38 | *
39 | * @param object $token source token
40 | *
41 | * @throws SassMixinDefinitionNodeException
42 | * @return SassMixinDefinitionNode
43 | */
44 | public function __construct($token)
45 | {
46 | preg_match(self::MATCH, $token->source, $matches);
47 | parent::__construct($token);
48 | if (empty($matches)) {
49 | throw new SassMixinDefinitionNodeException('Invalid Mixin', $this);
50 | }
51 | $this->name = $matches[self::NAME];
52 | if (isset($matches[self::ARGUMENTS])) {
53 | $this->args = SassScriptFunction::extractArgs($matches[self::ARGUMENTS], true, new SassContext);
54 | }
55 | }
56 |
57 | /**
58 | * Parse this node.
59 | * Add this mixin to the current context.
60 | * @param SassContext $context the context in which this node is parsed
61 | * @return array the parsed node - an empty array
62 | */
63 | public function parse($context)
64 | {
65 | $context->addMixin($this->name, $this);
66 |
67 | return array();
68 | }
69 |
70 | /**
71 | * Returns the arguments with default values for this mixin
72 | * @return array the arguments with default values for this mixin
73 | */
74 | public function getArgs()
75 | {
76 | return $this->args;
77 | }
78 |
79 | /**
80 | * Returns a value indicating if the token represents this type of node.
81 | * @param object $token token
82 | * @return boolean true if the token represents this type of node, false if not
83 | */
84 | public static function isa($token)
85 | {
86 | return $token->source[0] === self::NODE_IDENTIFIER;
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassMixinNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassMixinNode class.
14 | * Represents a Mixin.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassMixinNode extends SassNode
19 | {
20 | const NODE_IDENTIFIER = '+';
21 | const MATCH = '/^(\+|@include\s+)([a-z0-9_-]+)\s*(?:\((.*?)\))?\s*$/i';
22 | const IDENTIFIER = 1;
23 | const NAME = 2;
24 | const ARGS = 3;
25 |
26 | /**
27 | * @var string name of the mixin
28 | */
29 | private $name;
30 | /**
31 | * @var array arguments for the mixin
32 | */
33 | private $args = '';
34 |
35 | /**
36 | * SassMixinDefinitionNode constructor.
37 | * @param object $token source token
38 | * @return SassMixinNode
39 | */
40 | public function __construct($token)
41 | {
42 | parent::__construct($token);
43 | preg_match(self::MATCH, $token->source, $matches);
44 |
45 | if (!isset($matches[self::NAME])) {
46 | throw new SassMixinNodeException('Invalid mixin invocation: ($token->source)', $this);
47 | }
48 | $this->name = $matches[self::NAME];
49 | if (isset($matches[self::ARGS]) && strlen($matches[self::ARGS])) {
50 | $this->args = $matches[self::ARGS];
51 | }
52 | }
53 |
54 | /**
55 | * Parse this node.
56 | * Set passed arguments and any optional arguments not passed to their
57 | * defaults, then render the children of the mixin definition.
58 | * @param SassContext $pcontext the context in which this node is parsed
59 | * @return array the parsed node
60 | */
61 | public function parse($pcontext)
62 | {
63 | $mixin = $pcontext->getMixin($this->name);
64 | $context = new SassContext($pcontext);
65 | $context->content = $this->children;
66 | $argc = count($this->args);
67 | $count = 0;
68 |
69 | $args = SassScriptFunction::extractArgs($this->args, false, $context);
70 |
71 | list($arguments) = SassScriptFunction::fill_parameters($mixin->args, $args, $context, $this);
72 | $context->setVariables($arguments);
73 |
74 | $children = array();
75 | foreach ($mixin->children as $child) {
76 | /** @var $child SassNode */
77 | $child->parent = $this;
78 | $children = array_merge($children, $child->parse($context));
79 | }
80 |
81 | // $context->merge();
82 | return $children;
83 | }
84 |
85 | /**
86 | * Returns a value indicating if the token represents this type of node.
87 | * @param object $token token
88 | * @return boolean true if the token represents this type of node, false if not
89 | */
90 | public static function isa($token)
91 | {
92 | return $token->source[0] === self::NODE_IDENTIFIER;
93 | }
94 |
95 | /**
96 | * Resolves selectors.
97 | * Interpolates SassScript in selectors and resolves any parent references or
98 | * appends the parent selectors.
99 | * @param SassContext $context the context in which this node is parsed
100 | * @return array
101 | */
102 | public function resolveSelectors($context){
103 | return $this->parent->resolveSelectors($context);
104 | }
105 | }
106 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | #require_once 'SassContext.php';
13 | #require_once 'SassCommentNode.php';
14 | #require_once 'SassDebugNode.php';
15 | #require_once 'SassDirectiveNode.php';
16 | #require_once 'SassImportNode.php';
17 | #require_once 'SassMixinNode.php';
18 | #require_once 'SassMixinDefinitionNode.php';
19 | #require_once 'SassPropertyNode.php';
20 | #require_once 'SassRootNode.php';
21 | #require_once 'SassRuleNode.php';
22 | #require_once 'SassVariableNode.php';
23 | #require_once 'SassExtendNode.php';
24 | #require_once 'SassEachNode.php';
25 | #require_once 'SassForNode.php';
26 | #require_once 'SassIfNode.php';
27 | #require_once 'SassElseNode.php';
28 | #require_once 'SassWhileNode.php';
29 | #require_once 'SassNodeExceptions.php';
30 | #require_once 'SassFunctionDefinitionNode.php';
31 | #require_once 'SassReturnNode.php';
32 | #require_once 'SassContentNode.php';
33 | #require_once 'SassWarnNode.php';
34 | #require_once 'SassMediaNode.php';
35 |
36 | /**
37 | * SassNode class.
38 | * Base class for all Sass nodes.
39 | * @package PHamlP
40 | * @subpackage Sass.tree
41 | */
42 | class SassNode
43 | {
44 | /**
45 | * @var SassNode parent of this node
46 | */
47 | public $parent;
48 | /**
49 | * @var SassNode root node
50 | */
51 | public $root;
52 | /**
53 | * @var array children of this node
54 | */
55 | public $children = array();
56 | /**
57 | * @var object source token
58 | */
59 | public $token;
60 |
61 | /**
62 | * Constructor.
63 | * @param object $token source token
64 | * @return SassNode
65 | */
66 | public function __construct($token)
67 | {
68 | $this->token = $token;
69 | }
70 |
71 | /**
72 | * Getter.
73 | *
74 | * @param string $name name of property to get
75 | *
76 | * @throws SassNodeException
77 | * @return mixed return value of getter function
78 | */
79 | public function __get($name)
80 | {
81 | $getter = 'get' . ucfirst($name);
82 | if (method_exists($this, $getter)) {
83 | return $this->$getter();
84 | }
85 | throw new SassNodeException('No getter function for ' . $name, $this);
86 | }
87 |
88 | /**
89 | * Setter.
90 | * @param string $name name of property to set
91 | * @param mixed $value value of property
92 | * @throws SassNodeException
93 | * @return SassNode this node
94 | */
95 | public function __set($name, $value)
96 | {
97 | $setter = 'set' . ucfirst($name);
98 | if (method_exists($this, $setter)) {
99 | $this->$setter($value);
100 |
101 | return $this;
102 | }
103 | throw new SassNodeException('No setter function for ' . $name, $this);
104 | }
105 |
106 | /**
107 | * Resets children when cloned
108 | * @see parse
109 | */
110 | public function __clone()
111 | {
112 | $this->children = array();
113 | }
114 |
115 | /**
116 | * Return a value indicating if this node has a parent
117 | * @return array the node's parent
118 | */
119 | public function hasParent()
120 | {
121 | return !empty($this->parent);
122 | }
123 |
124 | /**
125 | * Returns the node's parent
126 | * @return array the node's parent
127 | */
128 | public function getParent()
129 | {
130 | return $this->parent;
131 | }
132 |
133 | /**
134 | * Adds a child to this node.
135 | */
136 | public function addChild($child)
137 | {
138 | /** @var $child SassNode */
139 | if ($child instanceof SassElseNode) {
140 | if (!$this->getLastChild() instanceof SassIfNode) {
141 | throw new SassException('@else(if) directive must come after @(else)if', $child);
142 | }
143 | $this->getLastChild()->addElse($child);
144 | } else {
145 | $this->children[] = $child;
146 | $child->parent = $this;
147 | $child->setRoot($this->root);
148 | }
149 | }
150 |
151 | /**
152 | * Sets a root recursively.
153 | * @param SassNode $root the new root node
154 | */
155 | public function setRoot($root){
156 | $this->root = $root;
157 | foreach ($this->children as $child) {
158 | /** @var $child SassNode */
159 | $child->setRoot($this->root);
160 | }
161 | }
162 |
163 | /**
164 | * Returns a value indicating if this node has children
165 | * @return boolean true if the node has children, false if not
166 | */
167 | public function hasChildren()
168 | {
169 | return !empty($this->children);
170 | }
171 |
172 | /**
173 | * Returns the node's children
174 | * @return array the node's children
175 | */
176 | public function getChildren()
177 | {
178 | return $this->children;
179 | }
180 |
181 | /**
182 | * Returns a value indicating if this node is a child of the passed node.
183 | * This just checks the levels of the nodes. If this node is at a greater
184 | * level than the passed node if is a child of it.
185 | *
186 | * @param SassNode $node
187 | *
188 | * @return boolean true if the node is a child of the passed node, false if not
189 | */
190 | public function isChildOf($node)
191 | {
192 | return $this->getLevel() > $node->getLevel();
193 | }
194 |
195 | /**
196 | * Returns the last child node of this node.
197 | * @return SassNode the last child node of this node
198 | */
199 | public function getLastChild()
200 | {
201 | return $this->children[count($this->children) - 1];
202 | }
203 |
204 | /**
205 | * Returns the level of this node.
206 | * @return integer the level of this node
207 | */
208 | public function getLevel()
209 | {
210 | return $this->token->level;
211 | }
212 |
213 | /**
214 | * Returns the source for this node
215 | * @return string the source for this node
216 | */
217 | public function getSource()
218 | {
219 | return $this->token->source;
220 | }
221 |
222 | /**
223 | * Returns the debug_info option setting for this node
224 | * @return boolean the debug_info option setting for this node
225 | */
226 | public function getDebug_info()
227 | {
228 | return $this->getParser()->debug_info;
229 | }
230 |
231 | /**
232 | * Returns the line number for this node
233 | * @return string the line number for this node
234 | */
235 | public function getLine()
236 | {
237 | return $this->token->line;
238 | }
239 |
240 | /**
241 | * Returns the line_numbers option setting for this node
242 | * @return boolean the line_numbers option setting for this node
243 | */
244 | public function getLine_numbers()
245 | {
246 | return $this->getParser()->line_numbers;
247 | }
248 |
249 | /**
250 | * Returns the filename for this node
251 | * @return string the filename for this node
252 | */
253 | public function getFilename()
254 | {
255 | return $this->token->filename;
256 | }
257 |
258 | /**
259 | * Returns the Sass parser.
260 | * @return SassParser the Sass parser
261 | */
262 | public function getParser()
263 | {
264 | return $this->root->parser;
265 | }
266 |
267 | /**
268 | * Returns the property syntax being used.
269 | * @return string the property syntax being used
270 | */
271 | public function getPropertySyntax()
272 | {
273 | return $this->root->getParser()->propertySyntax;
274 | }
275 |
276 | /**
277 | * Returns the SassScript parser.
278 | * @return SassScriptParser the SassScript parser
279 | */
280 | public function getScript()
281 | {
282 | return $this->root->script;
283 | }
284 |
285 | /**
286 | * Returns the renderer.
287 | * @return SassRenderer the renderer
288 | */
289 | public function getRenderer()
290 | {
291 | return $this->root->renderer;
292 | }
293 |
294 | /**
295 | * Returns the render style of the document tree.
296 | * @return string the render style of the document tree
297 | */
298 | public function getStyle()
299 | {
300 | return $this->root->getParser()->style;
301 | }
302 |
303 | /**
304 | * Returns a value indicating whether this node is in a directive
305 | *
306 | * @param boolean true if the node is in a directive, false if not
307 | *
308 | * @return bool
309 | */
310 | public function inDirective()
311 | {
312 | return $this->parent instanceof SassDirectiveNode ||
313 | $this->parent instanceof SassDirectiveNode;
314 | }
315 |
316 | /**
317 | * Returns a value indicating whether this node is in a SassScript directive
318 | *
319 | * @param boolean true if this node is in a SassScript directive, false if not
320 | *
321 | * @return bool
322 | */
323 | public function inSassScriptDirective()
324 | {
325 | return $this->parent instanceof SassEachNode ||
326 | $this->parent->parent instanceof SassEachNode ||
327 | $this->parent instanceof SassForNode ||
328 | $this->parent->parent instanceof SassForNode ||
329 | $this->parent instanceof SassIfNode ||
330 | $this->parent->parent instanceof SassIfNode ||
331 | $this->parent instanceof SassWhileNode ||
332 | $this->parent->parent instanceof SassWhileNode;
333 | }
334 |
335 | /**
336 | * Evaluates a SassScript expression.
337 | *
338 | * @param string $expression expression to evaluate
339 | * @param SassContext $context the context in which the expression is evaluated
340 | * @param mixed $x
341 | *
342 | * @return SassLiteral value of parsed expression
343 | */
344 | public function evaluate($expression, $context, $x=null)
345 | {
346 | $context->node = $this;
347 |
348 | return $this->script->evaluate($expression, $context, $x);
349 | }
350 |
351 | /**
352 | * Replace interpolated SassScript contained in '#{}' with the parsed value.
353 | * @param string $expression the text to interpolate
354 | * @param SassContext $context the context in which the string is interpolated
355 | * @return string the interpolated text
356 | */
357 | public function interpolate($expression, $context)
358 | {
359 | $context->node = $this;
360 |
361 | return $this->getScript()->interpolate($expression, $context);
362 | }
363 |
364 | /**
365 | * Adds a warning to the node.
366 | * @param string $message warning message
367 | */
368 | public function addWarning($message)
369 | {
370 | $warning = new SassDebugNode($this->token, $message);
371 | $this->addChild($warning);
372 | }
373 |
374 | /**
375 | * Parse the children of the node.
376 | * @param SassContext $context the context in which the children are parsed
377 | * @return array the parsed child nodes
378 | */
379 | public function parseChildren($context)
380 | {
381 | $children = array();
382 | foreach ($this->children as $child) {
383 | # child could be a SassLiteral /or/ SassNode
384 | if (method_exists($child, 'parse')) {
385 | $kid = $child->parse($context);
386 | } else {
387 | $kid = array($child);
388 | }
389 | $children = array_merge($children, $kid);
390 | }
391 |
392 | return $children;
393 | }
394 |
395 | /**
396 | * Returns a value indicating if the token represents this type of node.
397 | *
398 | * @param object $token token
399 | *
400 | * @throws SassNodeException
401 | * @return boolean true if the token represents this type of node, false if not
402 | */
403 | public static function isa($token)
404 | {
405 | throw new SassNodeException('Child classes must override this method');
406 | }
407 |
408 | public function printDebugTree($i = 0)
409 | {
410 | echo str_repeat(' ', $i*2).get_class($this)." ".$this->getSource()."\n";
411 | $p = $this->getParent();
412 | if ($p) echo str_repeat(' ', $i*2)." parent: ".get_class($p)."\n";
413 | foreach ($this->getChildren() as $c) {
414 | /** @var $c SassNode */
415 | $c->printDebugTree($i+1);
416 | }
417 | }
418 | }
419 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassNodeExceptions.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | require_once(dirname(__FILE__).'/../SassException.php');
13 |
14 | /**
15 | * SassNodeException class.
16 | * @package PHamlP
17 | * @subpackage Sass.tree
18 | */
19 | class SassNodeException extends SassException {}
20 |
21 | /**
22 | * SassContextException class.
23 | * @package PHamlP
24 | * @subpackage Sass.tree
25 | */
26 | class SassContextException extends SassNodeException {}
27 |
28 | /**
29 | * SassCommentNodeException class.
30 | * @package PHamlP
31 | * @subpackage Sass.tree
32 | */
33 | class SassCommentNodeException extends SassNodeException {}
34 |
35 | /**
36 | * SassDebugNodeException class.
37 | * @package PHamlP
38 | * @subpackage Sass.tree
39 | */
40 | class SassDebugNodeException extends SassNodeException {}
41 |
42 | /**
43 | * SassDirectiveNodeException class.
44 | * @package PHamlP
45 | * @subpackage Sass.tree
46 | */
47 | class SassDirectiveNodeException extends SassNodeException {}
48 |
49 | /**
50 | * SassEachNodeException class.
51 | * @package PHamlP
52 | * @subpackage Sass.tree
53 | */
54 | class SassEachNodeException extends SassNodeException {}
55 |
56 | /**
57 | * SassExtendNodeException class.
58 | * @package PHamlP
59 | * @subpackage Sass.tree
60 | */
61 | class SassExtendNodeException extends SassNodeException {}
62 |
63 | /**
64 | * SassForNodeException class.
65 | * @package PHamlP
66 | * @subpackage Sass.tree
67 | */
68 | class SassForNodeException extends SassNodeException {}
69 |
70 | /**
71 | * SassFunctionDefinitionNodeException class.
72 | * @package PHamlP
73 | * @subpackage Sass.tree
74 | */
75 | class SassFunctionDefinitionNodeException extends SassNodeException {}
76 |
77 | /**
78 | * SassIfNodeException class.
79 | * @package PHamlP
80 | * @subpackage Sass.tree
81 | */
82 | class SassIfNodeException extends SassNodeException {}
83 |
84 | /**
85 | * SassImportNodeException class.
86 | * @package PHamlP
87 | * @subpackage Sass.tree
88 | */
89 | class SassImportNodeException extends SassNodeException {}
90 |
91 | /**
92 | * SassMixinDefinitionNodeException class.
93 | * @package PHamlP
94 | * @subpackage Sass.tree
95 | */
96 | class SassMixinDefinitionNodeException extends SassNodeException {}
97 |
98 | /**
99 | * SassMixinNodeException class.
100 | * @package PHamlP
101 | * @subpackage Sass.tree
102 | */
103 | class SassMixinNodeException extends SassNodeException {}
104 |
105 | /**
106 | * SassPropertyNodeException class.
107 | * @package PHamlP
108 | * @subpackage Sass.tree
109 | */
110 | class SassPropertyNodeException extends SassNodeException {}
111 |
112 | /**
113 | * SassRuleNodeException class.
114 | * @package PHamlP
115 | * @subpackage Sass.tree
116 | */
117 | class SassRuleNodeException extends SassNodeException {}
118 |
119 | /**
120 | * SassVariableNodeException class.
121 | * @package PHamlP
122 | * @subpackage Sass.tree
123 | */
124 | class SassVariableNodeException extends SassNodeException {}
125 |
126 | /**
127 | * SassWhileNodeException class.
128 | * @package PHamlP
129 | * @subpackage Sass.tree
130 | */
131 | class SassWhileNodeException extends SassNodeException {}
132 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassPropertyNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassPropertyNode class.
14 | * Represents a CSS property.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassPropertyNode extends SassNode
19 | {
20 | const MATCH_PROPERTY_SCSS = '/^([^\s=:"(\\\\:)]*)\s*(?:(= )|:)([^\:].*?)?(\s*!important[^;]*)?;*$/';
21 | const MATCH_PROPERTY_NEW = '/^([^\s=:"]+)\s*(?:(= )|:)([^\:].*?)?(\s*!important[^;]*)?;*$/';
22 | const MATCH_PROPERTY_OLD = '/^:([^\s=:]+)(?:\s*(=)\s*|\s+|$)(.*)(\s*!important.*)?/';
23 | const MATCH_PSUEDO_SELECTOR = '/^:*\w[-\w]+\(?/i';
24 | const MATCH_INTERPOLATION = '/^#\{(.*?)\}/i';
25 | const MATCH_PROPRIETARY_SELECTOR = '/^:?-(moz|webkit|o|ms)-/';
26 | const NAME = 1;
27 | const SCRIPT = 2;
28 | const VALUE = 3;
29 | const IS_SCRIPT = '= ';
30 |
31 | public static $psuedoSelectors = array(
32 | 'root',
33 | 'nth-child(',
34 | 'nth-last-child(',
35 | 'nth-of-type(',
36 | 'nth-last-of-type(',
37 | 'first-child',
38 | 'last-child',
39 | 'first-of-type',
40 | 'last-of-type',
41 | 'only-child',
42 | 'only-of-type',
43 | 'empty',
44 | 'link',
45 | 'visited',
46 | 'active',
47 | 'hover',
48 | 'focus',
49 | 'target',
50 | 'lang(',
51 | 'enabled',
52 | 'disabled',
53 | 'checked',
54 | ':first-line',
55 | ':first-letter',
56 | ':before',
57 | ':after',
58 | // CSS 2.1
59 | 'first-line',
60 | 'first-letter',
61 | 'before',
62 | 'after',
63 | // CSS 3
64 | 'not(',
65 | );
66 |
67 | /**
68 | * @var string property name
69 | */
70 | public $name;
71 | /**
72 | * @var string property value or expression to evaluate
73 | */
74 | public $value;
75 |
76 | /**
77 | * @var boolean, wether the property is important
78 | */
79 | public $important;
80 |
81 | /**
82 | * SassPropertyNode constructor.
83 | * @param object $token source token
84 | * @param string $syntax property syntax
85 | * @return SassPropertyNode
86 | */
87 | public function __construct($token, $syntax = 'new')
88 | {
89 | parent::__construct($token);
90 | $matches = self::match($token, $syntax);
91 | $this->name = @$matches[self::NAME];
92 | if (!isset($matches[self::VALUE])) {
93 | $this->value = '';
94 | } else {
95 | $this->value = $matches[self::VALUE];
96 | if ($matches[self::SCRIPT] === self::IS_SCRIPT) {
97 | $this->addWarning('Setting CSS properties with "=" is deprecated; use "{name}: {value};"',
98 | array('{name}'=>$this->name, '{value}'=>$this->value)
99 | );
100 | }
101 | }
102 | $this->important = trim(array_pop($matches)) == '!important';
103 | }
104 |
105 | /**
106 | * Parse this node.
107 | * If the node is a property namespace return all parsed child nodes. If not
108 | * return the parsed version of this node.
109 | * @param SassContext $context the context in which this node is parsed
110 | * @return array the parsed node
111 | */
112 | public function parse($context)
113 | {
114 | $return = array();
115 | if ($this->value !== "") {
116 | $node = clone $this;
117 | $node->name = ($this->inNamespace() ? "{$this->namespace}-" : '') . $this->interpolate($this->name, $context);
118 |
119 | $result = $this->evaluate($this->interpolate($this->value, $context), $context, SassScriptParser::CSS_PROPERTY);
120 |
121 | $node->value = $result && is_object($result) ? $result->toString() : $this->value;
122 | $return[] = $node;
123 | }
124 | if ($this->children) {
125 | $return = array_merge($return, $this->parseChildren($context));
126 | }
127 |
128 | return $return;
129 | }
130 |
131 | /**
132 | * Render this node.
133 | * @return string the rendered node
134 | */
135 | public function render()
136 | {
137 | return $this->renderer->renderProperty($this);
138 | }
139 |
140 | /**
141 | * Returns a value indicating if this node is in a namespace
142 | * @return boolean true if this node is in a property namespace, false if not
143 | */
144 | public function inNamespace()
145 | {
146 | $parent = $this->parent;
147 | do {
148 | if ($parent instanceof SassPropertyNode) {
149 | return true;
150 | }
151 | $parent = $parent->parent;
152 | } while (is_object($parent));
153 |
154 | return false;
155 | }
156 |
157 | /**
158 | * Returns the namespace for this node
159 | * @return string the namespace for this node
160 | */
161 | public function getNamespace()
162 | {
163 | $namespace = array();
164 | $parent = $this->parent;
165 | do {
166 | if ($parent instanceof SassPropertyNode) {
167 | $namespace[] = $parent->name;
168 | }
169 | $parent = $parent->parent;
170 | } while (is_object($parent));
171 |
172 | return join('-', array_reverse($namespace));
173 | }
174 |
175 | /**
176 | * Returns the name of this property.
177 | * If the property is in a namespace the namespace is prepended
178 | * @return string the name of this property
179 | */
180 | public function getName()
181 | {
182 | return $this->name;
183 | }
184 |
185 | /**
186 | * Returns the parsed value of this property.
187 | * @return string the parsed value of this property
188 | */
189 | public function getValue()
190 | {
191 | return $this->value;
192 | }
193 |
194 | /**
195 | * Returns a value indicating if the token represents this type of node.
196 | * @param object $token token
197 | * @return boolean true if the token represents this type of node, false if not
198 | */
199 | public static function isa($token)
200 | {
201 | if (!is_array($token)) {
202 | $syntax = 'old';
203 | } else {
204 | $syntax = $token['syntax'];
205 | $token = $token['token'];
206 | }
207 |
208 | $matches = self::match($token, $syntax);
209 |
210 | if (!empty($matches)) {
211 | if (isset($matches[self::VALUE]) && self::isPseudoSelector($matches[self::VALUE])) {
212 | return false;
213 | }
214 | if ($token->level === 0) {
215 | # RL - if it's on the first level it's probably a false positive, not an error.
216 | # even if it is a genuine error, no need to kill the compiler about it.
217 |
218 | return false;
219 | // throw new SassPropertyNodeException('Properties can not be assigned at root level', $token);
220 | } else {
221 | return true;
222 | }
223 | } else {
224 | return false;
225 | }
226 | }
227 |
228 | /**
229 | * Returns the matches for this type of node.
230 | * @param object $token
231 | * @param string $syntax the property syntax being used
232 | * @return array matches
233 | */
234 | public static function match($token, $syntax)
235 | {
236 | switch ($syntax) {
237 | case 'scss':
238 | preg_match(self::MATCH_PROPERTY_SCSS, $token->source, $matches);
239 | break;
240 | case 'new':
241 | preg_match(self::MATCH_PROPERTY_NEW, $token->source, $matches);
242 | break;
243 | case 'old':
244 | preg_match(self::MATCH_PROPERTY_OLD, $token->source, $matches);
245 | break;
246 | default:
247 | if (preg_match(self::MATCH_PROPERTY_NEW, $token->source, $matches) == 0) {
248 | preg_match(self::MATCH_PROPERTY_OLD, $token->source, $matches);
249 | }
250 | break;
251 | }
252 |
253 | return $matches;
254 | }
255 |
256 | /**
257 | * Returns a value indicating if the string starts with a pseudo selector.
258 | * This is used to reject pseudo selectors as property values as, for example,
259 | * "a:hover" and "text-decoration:underline" look the same to the property
260 | * match regex.
261 | * It will also match interpolation to allow for constructs such as
262 | * content:#{$pos}
263 | * @see isa()
264 | * @param string $string the string to test
265 | * @return bool true if the string starts with a pseudo selector, false if not
266 | */
267 | public static function isPseudoSelector($string)
268 | {
269 | preg_match(self::MATCH_PSUEDO_SELECTOR, $string, $matches);
270 |
271 | return (isset($matches[0]) && in_array($matches[0], self::$psuedoSelectors)) ||
272 | preg_match(self::MATCH_INTERPOLATION, $string) ||
273 | preg_match(self::MATCH_PROPRIETARY_SELECTOR, $string);
274 | }
275 | }
276 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassReturnNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassReturnNode class.
14 | * Represents a Return.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassReturnNode extends SassNode
19 | {
20 | const NODE_IDENTIFIER = '+';
21 | const MATCH = '/^(@return\s+)(.*)$/i';
22 | const IDENTIFIER = 1;
23 | const STATEMENT = 2;
24 |
25 | /**
26 | * @var mixed statement to execute and return
27 | */
28 | private $statement;
29 |
30 | /**
31 | * SassReturnNode constructor.
32 | * @param object $token source token
33 | * @return SassReturnNode
34 | */
35 | public function __construct($token)
36 | {
37 | parent::__construct($token);
38 | preg_match(self::MATCH, $token->source, $matches);
39 |
40 | if (empty($matches)) {
41 | return new SassBoolean('false');
42 | }
43 |
44 | $this->statement = $matches[self::STATEMENT];
45 | }
46 |
47 | /**
48 | * Parse this node.
49 | * Set passed arguments and any optional arguments not passed to their
50 | * defaults, then render the children of the return definition.
51 | * @param SassContext $pcontext the context in which this node is parsed
52 | * @throws SassReturn
53 | * @return array the parsed node
54 | */
55 | public function parse($pcontext)
56 | {
57 | $return = $this;
58 | $context = new SassContext($pcontext);
59 | $statement = $this->statement;
60 |
61 | $parent = $this->parent->parent->parser;
62 | $script = $this->parent->parent->script;
63 | $lexer = $script->lexer;
64 |
65 | $result = $script->evaluate($statement, $context);
66 |
67 | throw new SassReturn($result);
68 | }
69 |
70 | /**
71 | * Returns a value indicating if the token represents this type of node.
72 | * @param object $token token
73 | * @return boolean true if the token represents this type of node, false if not
74 | */
75 | public static function isa($token)
76 | {
77 | return $token->source[0] === self::NODE_IDENTIFIER;
78 | }
79 | }
80 |
81 | class SassReturn extends Exception
82 | {
83 | public function __construct($value)
84 | {
85 | $this->value = $value;
86 | }
87 | }
88 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassRootNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | #require_once(dirname(__FILE__).'/../script/SassScriptParser.php');
13 | #require_once(dirname(__FILE__).'/../renderers/SassRenderer.php');
14 |
15 | /**
16 | * SassRootNode class.
17 | * Also the root node of a document.
18 | * @package PHamlP
19 | * @subpackage Sass.tree
20 | */
21 | class SassRootNode extends SassNode
22 | {
23 | /**
24 | * @var SassScriptParser SassScript parser
25 | */
26 | public $script;
27 | /**
28 | * @var SassRenderer the renderer for this node
29 | */
30 | public $renderer;
31 | /**
32 | * @var SassParser
33 | */
34 | public $parser;
35 | /**
36 | * @var array extenders for this tree in the form extendee=>extender
37 | */
38 | public $extenders = array();
39 |
40 | /**
41 | * Extend_parent - for resolving extends across imported files.
42 | */
43 | public $extend_parent = null;
44 |
45 | /**
46 | * Root SassNode constructor.
47 | * @param SassParser $parser Sass parser
48 | * @return SassRootNode
49 | */
50 | public function __construct($parser)
51 | {
52 | parent::__construct((object) array(
53 | 'source' => '',
54 | 'level' => -1,
55 | 'filename' => $parser->filename,
56 | 'line' => 0,
57 | ));
58 | $this->parser = $parser;
59 | $this->script = new SassScriptParser();
60 | $this->renderer = SassRenderer::getRenderer($parser->style);
61 | $this->root = $this;
62 | }
63 |
64 | /**
65 | * Parses this node and its children into the render tree.
66 | * Dynamic nodes are evaluated, files imported, etc.
67 | * Only static nodes for rendering are in the resulting tree.
68 | * @param SassContext $context the context in which this node is parsed
69 | * @return SassNode root node of the render tree
70 | */
71 | public function parse($context)
72 | {
73 | $node = clone $this;
74 | $node->children = $this->parseChildren($context);
75 |
76 | return $node;
77 | }
78 |
79 | /**
80 | * Render this node.
81 | * @param mixed $context
82 | * @return string the rendered node
83 | */
84 | public function render($context = null)
85 | {
86 | $context = new SassContext($context);
87 | $node = $this->parse($context);
88 | $output = '';
89 | foreach ($node->children as $child) {
90 | $output .= $child->render();
91 | } // foreach
92 |
93 | return $output;
94 | }
95 |
96 | /**
97 | * @param $extendee
98 | * @param $selectors
99 | *
100 | * @return mixed|NULL
101 | */
102 | public function extend($extendee, $selectors)
103 | {
104 | if ($this->extend_parent && method_exists($this->extend_parent, 'extend')) {
105 | return $this->extend_parent->extend($extendee, $selectors);
106 | }
107 | $this->extenders[$extendee] = (isset($this->extenders[$extendee])
108 | ? array_merge($this->extenders[$extendee], $selectors) : $selectors);
109 | return NULL;
110 | }
111 |
112 | public function getExtenders()
113 | {
114 | if ($this->extend_parent && method_exists($this->extend_parent, 'getExtenders')) {
115 | return $this->extend_parent->getExtenders();
116 | }
117 |
118 | return $this->extenders;
119 | }
120 |
121 | /**
122 | * Returns a value indicating if the line represents this type of node.
123 | * Child classes must override this method.
124 | * @throws SassNodeException if not overriden
125 | */
126 | public static function isa($line)
127 | {
128 | throw new SassNodeException('Child classes must override this method');
129 | }
130 | }
131 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassRuleNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassRuleNode class.
14 | * Represents a CSS rule.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassRuleNode extends SassNode
19 | {
20 | const MATCH = '/^(.+?)(?:\s*\{)?$/';
21 | const SELECTOR = 1;
22 | const CONTINUED = ',';
23 |
24 | /**
25 | * @const string that is replaced with the parent node selector
26 | */
27 | const PARENT_REFERENCE = '&';
28 |
29 | /**
30 | * @var array selector(s)
31 | */
32 | private $selectors = array();
33 |
34 | /**
35 | * @var array parent selectors
36 | */
37 | private $parentSelectors = array();
38 |
39 | /**
40 | * @var boolean whether the node expects more selectors
41 | */
42 | private $isContinued;
43 |
44 | /**
45 | * SassRuleNode constructor.
46 | * @param object $token source token
47 | * @return SassRuleNode
48 | */
49 | public function __construct($token)
50 | {
51 | parent::__construct($token);
52 | preg_match(self::MATCH, $token->source, $matches);
53 | $this->addSelectors($matches[SassRuleNode::SELECTOR]);
54 | }
55 |
56 | /**
57 | * Adds selector(s) to the rule.
58 | * If the selectors are to continue for the rule the selector must end in a comma
59 | * @param string $selectors selector
60 | * @param boolean $explode
61 | */
62 | public function addSelectors($selectors, $explode = true)
63 | {
64 | $this->isContinued = substr($selectors, -1) === self::CONTINUED;
65 | $this->selectors = array_merge($this->selectors, $explode ? $this->explode($selectors) : $selectors);
66 | }
67 |
68 | /**
69 | * Returns a value indicating if the selectors for this rule are to be continued.
70 | *
71 | * @return bool rue if the selectors for this rule are to be continued false if not
72 | */
73 | public function getIsContinued()
74 | {
75 | return $this->isContinued;
76 | }
77 |
78 | /**
79 | * Parse this node and its children into static nodes.
80 | * @param SassContext $context the context in which this node is parsed
81 | * @return array the parsed node and its children
82 | */
83 | public function parse($context)
84 | {
85 | $node = clone $this;
86 | $node->selectors = $this->resolveSelectors($context);
87 | $node->children = $this->parseChildren($context);
88 |
89 | return array($node);
90 | }
91 |
92 | /**
93 | * Render this node and its children to CSS.
94 | * @return string the rendered node
95 | */
96 | public function render()
97 | {
98 | $this->extend();
99 | $rules = '';
100 | $properties = array();
101 |
102 | foreach ($this->children as $child) {
103 | $child->parent = $this;
104 | if ($child instanceof SassRuleNode) {
105 | $rules .= $child->render();
106 | } else {
107 | $properties[] = $child->render();
108 | }
109 | }
110 |
111 | return $this->getRenderer()->renderRule($this, $properties, $rules);
112 | }
113 |
114 | /**
115 | * Extend this nodes selectors
116 | * $extendee is the subject of the @extend directive
117 | * $extender is the selector that contains the @extend directive
118 | * $selector a selector or selector sequence that is to be extended
119 | */
120 | public function extend()
121 | {
122 | foreach ($this->root->getExtenders() as $extendee => $extenders) {
123 | if ($this->isPsuedo($extendee)) {
124 | $extendee = explode(':', $extendee);
125 | $pattern = preg_quote($extendee[0]).'((\.[-\w]+)*):'.preg_quote($extendee[1]);
126 | } else {
127 | $pattern = preg_quote($extendee);
128 | }
129 |
130 | foreach (preg_grep('/'.$pattern.'/', $this->selectors) as $selector) {
131 | foreach ($extenders as $extender) {
132 | # first if establishes that we are using a placeholder and the extendee begins with a tag
133 | if ($extendee{0} == '%' && $selector{0} != '%' && preg_match('/(^| )[a-zA-Z][^%]*' . preg_quote($extendee) . '([^a-z0-9_-]|$)/', $selector)) {
134 | # the second if establishes that the extender is a tag rather than a class/id
135 | $zero = ord(strtolower(substr($extender, 0, 1))); // cheaper than regex
136 | if ($zero >= 97 && $zero <= 122) {
137 | continue;
138 | }
139 | }
140 | if (is_array($extendee)) {
141 | $this->selectors[] = preg_replace('/(.*?)'.$pattern.'([^a-zA-Z0-9_-]|$)/', '$1' . $extender . '$2', $selector);
142 | } elseif ($this->isSequence($extender) || $this->isSequence($selector)) {
143 | $this->selectors = array_merge($this->selectors, $this->mergeSequence($extender, $extendee, $selector));
144 | } else {
145 | $this->selectors[] = str_replace($extendee, $extender, $selector);
146 | }
147 | }
148 | }
149 | $this->selectors = array_unique($this->selectors);
150 | }
151 | }
152 |
153 | /**
154 | * Tests whether the selector is a psuedo selector
155 | * @param string $selector selector to test
156 | * @return boolean true if the selector is a psuedo selector, false if not
157 | */
158 | private function isPsuedo($selector)
159 | {
160 | return strpos($selector, ':') !== false;
161 | }
162 |
163 | /**
164 | * Tests whether the selector is a sequence selector
165 | * @param string $selector selector to test
166 | * @return boolean true if the selector is a sequence selector, false if not
167 | */
168 | private function isSequence($selector)
169 | {
170 | return strpos($selector, ' ') !== false;
171 | }
172 |
173 | public function isPlaceholder($selector)
174 | {
175 | return strpos($selector, '%') !== false && !preg_match("/^[\d]+%$/", $selector);
176 | }
177 |
178 | /**
179 | * Merges selector sequences
180 | * @param string $extender the extender selector
181 | * @param string $extendee
182 | * @param string $selector selector to extend
183 | * @return array the merged sequences
184 | */
185 | private function mergeSequence($extender, $extendee, $selector)
186 | {
187 | // if it's a placeholder, be lazy. Needs tests.
188 | if ($extendee[0] == '%') {
189 | // need to stop things like a%foo accepting div { @extend %foo }
190 | return array(str_replace($extendee, $extender, $selector));
191 | }
192 |
193 | $extender = explode(' ', $extender);
194 | $end = array_pop($extender);
195 | $selector = explode(' ', $selector);
196 | array_pop($selector);
197 |
198 | $common = array();
199 | if (count($extender) && count($selector)) {
200 | while (trim($extender[0]) === trim($selector[0])) {
201 | $common[] = array_shift($selector);
202 | array_shift($extender);
203 | if (!count($extender)) {
204 | break;
205 | }
206 | }
207 | }
208 |
209 | $beginning = (!empty($common) ? join(' ', $common) . ' ' : '');
210 |
211 | # Richard Lyon - 2011-10-25 - removes duplicates by uniquing and trimming.
212 | # regex removes whitespace from start and and end of string as well as removing
213 | # whitespace following whitespace. slightly quicker than a trim and simpler replace
214 |
215 | return array_unique(array(
216 | preg_replace('/(^\s+|(\s)\s+|\s+$)/', '$2', $beginning.join(' ', $selector).' '.join(' ', $extender). ' ' . $end),
217 | preg_replace('/(^\s+|(\s)\s+|\s+$)/', '$2', $beginning.join(' ', $extender).' '.join(' ', $selector). ' ' . $end)
218 | ));
219 | }
220 |
221 | /**
222 | * Returns the selectors
223 | * @return array selectors
224 | */
225 | public function getSelectors()
226 | {
227 | return $this->selectors;
228 | }
229 |
230 | /**
231 | * Resolves selectors.
232 | * Interpolates SassScript in selectors and resolves any parent references or
233 | * appends the parent selectors.
234 | * @param SassContext $context the context in which this node is parsed
235 | *
236 | * Change: 7/Dec/11 - change to make selector ordering conform to Ruby compiler.
237 | * @return array
238 | */
239 | public function resolveSelectors($context)
240 | {
241 | $resolvedSelectors = $normalSelectors = array();
242 | $this->parentSelectors = $this->getParentSelectors($context);
243 |
244 | foreach ($this->selectors as $selector) {
245 | $selector = $this->interpolate($selector, $context);
246 | $selectors = SassList::_build_list($selector);
247 |
248 | foreach ($selectors as $selector_inner) {
249 | $selector_inner = trim($selector_inner, ' \'"'); // strip whitespace and quotes, just-in-case.
250 | if ($this->hasParentReference($selector_inner)) {
251 | $resolvedSelectors = array_merge($resolvedSelectors, $this->resolveParentReferences($selector_inner, $context));
252 | } else {
253 | $normalSelectors[] = $selector_inner;
254 | }
255 | }
256 | } // foreach
257 |
258 | // merge with parent selectors
259 | if ($this->parentSelectors) {
260 | $return = array();
261 | foreach ($this->parentSelectors as $parent) {
262 | foreach ($normalSelectors as $selector) {
263 | $spacer = (substr($selector, 0, 1) == '[') ? '' : ' ';
264 |
265 | $return[] = $parent . $spacer . $selector;
266 | }
267 | }
268 | $normalSelectors = $return;
269 | }
270 |
271 | return array_merge($normalSelectors, $resolvedSelectors);
272 | }
273 |
274 | /**
275 | * Returns the parent selector(s) for this node.
276 | * This in an empty array if there is no parent selector.
277 | * @param mixed $context
278 | * @return array the parent selector for this node
279 | */
280 | protected function getParentSelectors($context)
281 | {
282 | $ancestor = $this->parent;
283 | while (!$ancestor instanceof SassRuleNode && $ancestor->hasParent()) {
284 | $ancestor = $ancestor->parent;
285 | }
286 |
287 | if ($ancestor instanceof SassRuleNode) {
288 | return $ancestor->resolveSelectors($context);
289 | }
290 |
291 | return array();
292 | }
293 |
294 | /**
295 | * Returns the position of the first parent reference in the selector.
296 | * If there is no parent reference in the selector this function returns
297 | * boolean FALSE.
298 | * Note that the return value may be non-Boolean that evaluates to FALSE,
299 | * i.e. 0. The return value should be tested using the === operator.
300 | * @param string $selector selector to test
301 | * @return mixed integer: position of the the first parent reference,
302 | * boolean: false if there is no parent reference.
303 | */
304 | private function parentReferencePos($selector)
305 | {
306 | $inString = '';
307 | for ($i = 0, $l = strlen($selector); $i < $l; $i++) {
308 | $c = $selector[$i];
309 | if ($c === self::PARENT_REFERENCE && empty($inString)) {
310 | return $i;
311 | } elseif (empty($inString) && ($c === '"' || $c === "'")) {
312 | $inString = $c;
313 | } elseif ($c === $inString) {
314 | $inString = '';
315 | }
316 | }
317 |
318 | return false;
319 | }
320 |
321 | /**
322 | * Determines if there is a parent reference in the selector
323 | * @param string $selector selector
324 | * @return boolean true if there is a parent reference in the selector
325 | */
326 | private function hasParentReference($selector)
327 | {
328 | return $this->parentReferencePos($selector) !== false;
329 | }
330 |
331 | /**
332 | * Resolves parent references in the selector
333 | * @param string $selector selector
334 | * @param mixed $context
335 | * @throws SassRuleNodeException
336 | * @return string selector with parent references resolved
337 | */
338 | private function resolveParentReferences($selector, $context)
339 | {
340 | $resolvedReferences = array();
341 | if (!count($this->parentSelectors)) {
342 | throw new SassRuleNodeException('Can not use parent selector (' . self::PARENT_REFERENCE . ') when no parent selectors', $this);
343 | }
344 | foreach ($this->getParentSelectors($context) as $parentSelector) {
345 | $resolvedReferences[] = str_replace(self::PARENT_REFERENCE, $parentSelector, $selector);
346 | }
347 |
348 | return $resolvedReferences;
349 | }
350 |
351 | /**
352 | * Explodes a string of selectors into an array.
353 | * We can't use PHP::explode as this will potentially explode attribute
354 | * matches in the selector, e.g. div[title="some,value"] and interpolations.
355 | * @param string $string selectors
356 | * @return array selectors
357 | */
358 | private function explode($string)
359 | {
360 | $selectors = array();
361 | $inString = false;
362 | $interpolate = false;
363 | $selector = '';
364 |
365 | for ($i = 0, $l = strlen($string); $i < $l; $i++) {
366 | $c = $string[$i];
367 | if ($c === self::CONTINUED && !$inString && !$interpolate) {
368 | $selectors[] = trim($selector);
369 | $selector = '';
370 | } else {
371 | $selector .= $c;
372 | if ($c === '"' || $c === "'") {
373 | do {
374 | $_c = $string[++$i];
375 | $selector .= $_c;
376 | } while ($_c !== $c && isset($string[$i+1]));
377 | } elseif ($c === '#' && $string[$i+1] === '{') {
378 | do {
379 | $c = $string[++$i];
380 | $selector .= $c;
381 | } while ($c !== '}');
382 | }
383 | }
384 | }
385 |
386 | if (!empty($selector)) {
387 | $selectors[] = trim($selector);
388 | }
389 |
390 | return $selectors;
391 | }
392 | }
393 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassVariableNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassVariableNode class.
14 | * Represents a variable.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassVariableNode extends SassNode
19 | {
20 | const MATCH = '/^([!$])([\w-]+)\s*:?\s*((\|\|)?=)?\s*(.+?)\s*(!default)?;?$/i';
21 | const IDENTIFIER = 1;
22 | const NAME = 2;
23 | const SASS_ASSIGNMENT = 3;
24 | const SASS_DEFAULT = 4;
25 | const VALUE = 5;
26 | const SCSS_DEFAULT = 6;
27 | const SASS_IDENTIFIER = '!';
28 | const SCSS_IDENTIFIER = '$';
29 |
30 | /**
31 | * @var string name of the variable
32 | */
33 | private $name;
34 | /**
35 | * @var string value of the variable or expression to evaluate
36 | */
37 | private $value;
38 | /**
39 | * @var boolean whether the variable is optionally assigned
40 | */
41 | private $isDefault;
42 |
43 | /**
44 | * SassVariableNode constructor.
45 | * @param object $token source token
46 | * @throws SassVariableNodeException
47 | * @return SassVariableNode
48 | */
49 | public function __construct($token)
50 | {
51 | parent::__construct($token);
52 | preg_match(self::MATCH, $token->source, $matches);
53 | if (empty($matches[self::NAME]) || ($matches[self::VALUE] === '')) {
54 | throw new SassVariableNodeException('Invalid variable definition; name and expression required', $this);
55 | }
56 |
57 | $this->name = $matches[self::NAME];
58 | $this->value = $matches[self::VALUE];
59 | $this->isDefault = (!empty($matches[self::SASS_DEFAULT]) || !empty($matches[self::SCSS_DEFAULT]));
60 |
61 | // Warn about deprecated features
62 | if ($matches[self::IDENTIFIER] === self::SASS_IDENTIFIER) {
63 | $this->addWarning('Variables prefixed with "!" is deprecated; use "' . $this->name . '"');
64 | }
65 | if (!empty($matches[SassVariableNode::SASS_ASSIGNMENT])) {
66 | $this->addWarning('Setting variables with "' . (!empty($matches[SassVariableNode::SASS_DEFAULT])?'||':'') . '=" is deprecated; use "$' . $this->name . ': ' . $this->value . (!empty($matches[SassVariableNode::SASS_DEFAULT]) ? ' !default' : ''));
67 | }
68 | }
69 |
70 | /**
71 | * Parse this node.
72 | * Sets the variable in the current context.
73 | * @param SassContext $context the context in which this node is parsed
74 | * @return array the parsed node - an empty array
75 | */
76 | public function parse($context)
77 | {
78 | if (!$this->isDefault || !$context->hasVariable($this->name)) {
79 | $context->setVariable(
80 | $this->name, $this->evaluate($this->value, $context)
81 | );
82 | }
83 | $this->parseChildren($context); // Parse any warnings
84 |
85 | return array();
86 | }
87 |
88 | /**
89 | * Returns a value indicating if the token represents this type of node.
90 | * @param object $token token
91 | * @return boolean true if the token represents this type of node, false if not
92 | */
93 | public static function isa($token)
94 | {
95 | return $token->source[0] === self::SASS_IDENTIFIER || $token->source[0] === self::SCSS_IDENTIFIER;
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassWarnNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright none
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassReturnNode class.
14 | * Represents a Return.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassWarnNode extends SassNode
19 | {
20 | const NODE_IDENTIFIER = '+';
21 | const MATCH = '/^(@warn\s+)(["\']?)(.*?)(["\']?)$/i';
22 | const IDENTIFIER = 1;
23 | const STATEMENT = 3;
24 |
25 | /**
26 | * @var mixed statement to execute and return
27 | */
28 | private $statement;
29 |
30 | /**
31 | * SassReturnNode constructor.
32 | * @param object $token source token
33 | * @return SassWarnNode|void
34 | */
35 | public function __construct($token)
36 | {
37 | parent::__construct($token);
38 | preg_match(self::MATCH, $token->source, $matches);
39 |
40 | if (empty($matches)) {
41 | return new SassBoolean('false');
42 | }
43 |
44 | $this->statement = $matches[self::STATEMENT];
45 | }
46 |
47 | /**
48 | * Parse this node.
49 | * Set passed arguments and any optional arguments not passed to their
50 | * defaults, then render the children of the return definition.
51 | * @param SassContext $pcontext the context in which this node is parsed
52 | * @return array the parsed node
53 | */
54 | public function parse($pcontext)
55 | {
56 | $context = new SassContext($pcontext);
57 | $statement = $this->statement;
58 |
59 | try {
60 | $statement = $this->evaluate($this->statement, $context)->toString();
61 | } catch (Exception $e) {}
62 |
63 | if (SassParser::$instance->options['callbacks']['warn']) {
64 | call_user_func(SassParser::$instance->options['callbacks']['warn'], $statement, $context);
65 | }
66 |
67 | if (SassParser::$instance->getQuiet()) {
68 | return array(new SassString(''));
69 | } else {
70 | return array(new SassString('/* @warn: ' . str_replace('*/', '', $statement) . ' */'));
71 | }
72 | }
73 |
74 | /**
75 | * Returns a value indicating if the token represents this type of node.
76 | * @param object $token token
77 | * @return boolean true if the token represents this type of node, false if not
78 | */
79 | public static function isa($token)
80 | {
81 | return $token->source[0] === self::NODE_IDENTIFIER;
82 | }
83 | }
84 |
--------------------------------------------------------------------------------
/lib/phpsass/tree/SassWhileNode.php:
--------------------------------------------------------------------------------
1 |
6 | * @copyright Copyright (c) 2010 PBM Web Development
7 | * @license http://phamlp.googlecode.com/files/license.txt
8 | * @package PHamlP
9 | * @subpackage Sass.tree
10 | */
11 |
12 | /**
13 | * SassWhileNode class.
14 | * Represents a Sass @while loop and a Sass @do loop.
15 | * @package PHamlP
16 | * @subpackage Sass.tree
17 | */
18 | class SassWhileNode extends SassNode
19 | {
20 | const MATCH = '/^@(do|while)\s+(.+)$/i';
21 | const LOOP = 1;
22 | const EXPRESSION = 2;
23 | const IS_DO = 'do';
24 | /**
25 | * @var boolean whether this is a do/while.
26 | * A do/while loop is guarenteed to run at least once.
27 | */
28 | private $isDo;
29 | /**
30 | * @var string expression to evaluate
31 | */
32 | private $expression;
33 |
34 | /**
35 | * SassWhileNode constructor.
36 | * @param object $token source token
37 | * @return SassWhileNode
38 | */
39 | public function __construct($token)
40 | {
41 | parent::__construct($token);
42 | preg_match(self::MATCH, $token->source, $matches);
43 | $this->expression = $matches[self::EXPRESSION];
44 | $this->isDo = ($matches[self::LOOP] === SassWhileNode::IS_DO);
45 | }
46 |
47 | /**
48 | * Parse this node.
49 | * @param SassContext $context the context in which this node is parsed
50 | * @return array the parsed child nodes
51 | */
52 | public function parse($context)
53 | {
54 | $children = array();
55 | if ($this->isDo) {
56 | do {
57 | $children = array_merge($children, $this->parseChildren($context));
58 | } while ($this->evaluate($this->expression, $context)->toBoolean());
59 | } else {
60 | while ($this->evaluate($this->expression, $context)->toBoolean()) {
61 | $children = array_merge($children, $this->parseChildren($context));
62 | }
63 | }
64 |
65 | return $children;
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/templates/admin-page.php:
--------------------------------------------------------------------------------
1 |
4 |
--------------------------------------------------------------------------------
/templates/empty-scheme.php:
--------------------------------------------------------------------------------
1 |
4 |
7 |
14 |
--------------------------------------------------------------------------------
/templates/updated.php:
--------------------------------------------------------------------------------
1 |
4 |
7 |
14 |
--------------------------------------------------------------------------------