frontsau 0.0.1

data/lib/Phamlp/sass/script/SassScriptLexer.php

@@ -0,0 +1,114 @@
+<?php
+/* SVN FILE: $Id: SassScriptLexer.php 118 2010-09-21 09:45:11Z chris.l.yates@gmail.com $ */
+/**
+ * SassScriptLexer class file.
+ * @author			Chris Yates <chris.l.yates@gmail.com>
+ * @copyright 	Copyright (c) 2010 PBM Web Development
+ * @license			http://phamlp.googlecode.com/files/license.txt
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+
+require_once('literals/SassBoolean.php');
+require_once('literals/SassColour.php');
+require_once('literals/SassNumber.php');
+require_once('literals/SassString.php');
+require_once('SassScriptFunction.php');
+require_once('SassScriptOperation.php');
+require_once('SassScriptVariable.php');
+
+/**
+ * SassScriptLexer class.
+ * Lexes SassSCript into tokens for the parser.
+ * 
+ * Implements a {@link http://en.wikipedia.org/wiki/Shunting-yard_algorithm Shunting-yard algorithm} to provide {@link http://en.wikipedia.org/wiki/Reverse_Polish_notation Reverse Polish notation} output.
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+class SassScriptLexer {
+	const MATCH_WHITESPACE = '/^\s+/';
+
+	/**
+	 * @var SassScriptParser the parser object
+	 */
+	private $parser;
+
+	/**
+	* SassScriptLexer constructor.
+	* @return SassScriptLexer
+	*/
+	public function __construct($parser) {
+		$this->parser = $parser;
+	}
+	
+	/**
+	 * Lex an expression into SassScript tokens.
+	 * @param string expression to lex
+	 * @param SassContext the context in which the expression is lexed
+	 * @return array tokens
+	 */
+	public function lex($string, $context) {
+		$tokens = array();
+		while ($string !== false) {
+			if (($match = $this->isWhitespace($string)) !== false) {
+				$tokens[] = null;
+			}
+			elseif (($match = SassScriptFunction::isa($string)) !== false) {
+				preg_match(SassScriptFunction::MATCH_FUNC, $match, $matches);
+				
+				$args = array();
+				foreach (SassScriptFunction::extractArgs($matches[SassScriptFunction::ARGS])
+						as $expression) {
+					$args[] = $this->parser->evaluate($expression, $context);
+				}
+				
+				$tokens[] = new SassScriptFunction(
+						$matches[SassScriptFunction::NAME], $args);
+			}
+			elseif (($match = SassString::isa($string)) !== false) {
+				$tokens[] = new SassString($match);
+			}
+			elseif (($match = SassBoolean::isa($string)) !== false) {
+				$tokens[] = new SassBoolean($match);
+			}
+			elseif (($match = SassColour::isa($string)) !== false) {
+				$tokens[] = new SassColour($match);
+			}
+			elseif (($match = SassNumber::isa($string)) !== false) {				
+				$tokens[] = new SassNumber($match);
+			}
+			elseif (($match = SassScriptOperation::isa($string)) !== false) {
+				$tokens[] = new SassScriptOperation($match);
+			}
+			elseif (($match = SassScriptVariable::isa($string)) !== false) {
+				$tokens[] = new SassScriptVariable($match);
+			}
+			else {
+				$_string = $string;
+				$match = '';
+				while (strlen($_string) && !$this->isWhitespace($_string)) {
+					foreach (SassScriptOperation::$inStrOperators as $operator) {
+						if (substr($_string, 0, strlen($operator)) == $operator) {
+							break 2;
+						}
+					}
+					$match .= $_string[0];
+					$_string = substr($_string, 1);			
+				}
+				$tokens[] = new SassString($match);
+			}			
+			$string = substr($string, strlen($match));
+		}
+		return $tokens; 
+	}
+
+	/**
+	 * Returns a value indicating if a token of this type can be matched at
+	 * the start of the subject string.
+	 * @param string the subject string
+	 * @return mixed match at the start of the string or false if no match
+	 */
+	public function isWhitespace($subject) {
+		return (preg_match(self::MATCH_WHITESPACE, $subject, $matches) ? $matches[0] : false);
+	}
+}

data/lib/Phamlp/sass/script/SassScriptOperation.php

@@ -0,0 +1,151 @@
+<?php
+/* SVN FILE: $Id: SassScriptOperation.php 118 2010-09-21 09:45:11Z chris.l.yates@gmail.com $ */
+/**
+ * SassScriptOperation class file.
+ * @author			Chris Yates <chris.l.yates@gmail.com>
+ * @copyright 	Copyright (c) 2010 PBM Web Development
+ * @license			http://phamlp.googlecode.com/files/license.txt
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+
+/**
+ * SassScriptOperation class.
+ * The operation to perform.
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+class SassScriptOperation {
+  const MATCH = '/^(\(|\)|\+|-|\*|\/|%|<=|>=|<|>|==|!=|=|#{|}|,|and\b|or\b|xor\b|not\b)/';
+
+	/**
+	 * @var array map symbols to tokens.
+	 * A token is function, associativity, precedence, number of operands
+	 */
+	public static $operators = array(
+		'*'		=> array('times',		'l', 8, 2),
+		'/'		=> array('div',			'l', 8, 2),
+		'%'		=> array('modulo',	'l', 8, 2),
+		'+'		=> array('plus',		'l', 7, 2),
+		'-'		=> array('minus',		'l', 7, 2),
+		'<<'	=> array('shiftl',	'l', 6, 2),
+		'>>'	=> array('shiftr',	'l', 6, 2),
+		'<='	=> array('lte',			'l', 5, 2),
+		'>='	=> array('gte',			'l', 5, 2),
+		'<'		=> array('lt',			'l', 5, 2),
+		'>'		=> array('gt',			'l', 5, 2),
+		'=='	=> array('eq',			'l', 4, 2),
+		'!='	=> array('neq',			'l', 4, 2),
+		'and'	=> array('and',			'l', 3, 2),
+		'or'	=> array('or',			'l', 3, 2),
+		'xor'	=> array('xor',			'l', 3, 2),
+		'not'	=> array('not',			'l', 3, 1),
+		'='		=> array('assign',	'l', 2, 2),
+		')'		=> array('rparen',	'l', 1),
+		'('		=> array('lparen',	'l', 0),
+		','		=> array('comma',		'l', 0, 2),
+		'#{'	=> array('begin_interpolation'),
+		'}'		=> array('end_interpolation'),
+	);
+	
+	/**
+	 * @var array operators with meaning in uquoted strings;
+	 * selectors, property names and values
+	 */
+	public static $inStrOperators = array(',', '#{');
+ 
+	/**
+	 * @var array default operator token.
+	 */
+	public static $defaultOperator = array('concat', 'l', 0, 2);
+
+	/**
+	 * @var string operator for this operation
+	 */
+	private $operator;
+	/**
+	 * @var string associativity of the operator; left or right
+	 */
+	private $associativity;
+	/**
+	 * @var integer precedence of the operator
+	 */
+	private $precedence;
+	/**
+	 * @var integer number of operands required by the operator
+	 */
+	private $operandCount;
+
+	/**
+	 * SassScriptOperation constructor
+	 *
+	 * @param mixed string: operator symbol; array: operator token
+	 * @return SassScriptOperation
+	 */
+	public function __construct($operation) {
+		if (is_string($operation)) {
+			$operation = self::$operators[$operation];
+		}
+		$this->operator			 = $operation[0];
+		if (isset($operation[1])) {
+			$this->associativity = $operation[1];
+			$this->precedence		 = $operation[2];
+			$this->operandCount	 = (isset($operation[3]) ?
+					$operation[3] : null);
+		}
+	}
+
+	/**
+	 * Getter function for properties
+	 * @param string name of property
+	 * @return mixed value of the property
+	 * @throws SassScriptOperationException if the property does not exist
+	 */
+	public function __get($name) {
+		if (property_exists($this, $name)) {
+			return $this->$name;
+		}
+	  else {
+			throw new SassScriptOperationException('Unknown property: {name}', array('{name}'=>$name), SassScriptParser::$context->node);
+	  }
+	}
+
+	/**
+	 * Performs this operation.
+	 * @param array operands for the operation. The operands are SassLiterals
+	 * @return SassLiteral the result of the operation
+	 * @throws SassScriptOperationException if the oprand count is incorrect or
+	 * the operation is undefined
+	 */
+	public function perform($operands) {
+		if (count($operands) !== $this->operandCount) {
+			throw new SassScriptOperationException('Incorrect operand count for {operation}; expected {expected}, received {received}', array('{operation}'=>get_class($operands[0]), '{expected}'=>$this->operandCount, '{received}'=>count($operands)), SassScriptParser::$context->node);
+		}
+		
+		if (count($operands) > 1 && is_null($operands[1])) {
+			$operation = 'op_unary_' . $this->operator;
+		}
+		else {
+			$operation = 'op_' . $this->operator;
+			if ($this->associativity == 'l') {
+				$operands = array_reverse($operands);
+			}
+		}
+		
+		if (method_exists($operands[0], $operation)) {
+			return $operands[0]->$operation(!empty($operands[1]) ? $operands[1] : null);
+		}
+
+		throw new SassScriptOperationException('Undefined operation "{operation}" for {what}',  array('{operation}'=>$operation, '{what}'=>get_class($operands[0])), SassScriptParser::$context->node);
+	}
+
+	/**
+	 * Returns a value indicating if a token of this type can be matched at
+	 * the start of the subject string.
+	 * @param string the subject string
+	 * @return mixed match at the start of the string or false if no match
+	 */
+	public static function isa($subject) {
+		return (preg_match(self::MATCH, $subject, $matches) ? trim($matches[0]) : false);
+	}
+}

data/lib/Phamlp/sass/script/SassScriptParser.php

@@ -0,0 +1,192 @@
+<?php
+/* SVN FILE: $Id: SassScriptParser.php 118 2010-09-21 09:45:11Z chris.l.yates@gmail.com $ */
+/**
+ * SassScriptParser class file.
+ * @author			Chris Yates <chris.l.yates@gmail.com>
+ * @copyright 	Copyright (c) 2010 PBM Web Development
+ * @license			http://phamlp.googlecode.com/files/license.txt
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+
+require_once('SassScriptLexer.php');
+require_once('SassScriptParserExceptions.php');
+
+/**
+ * SassScriptParser class.
+ * Parses SassScript. SassScript is lexed into {@link http://en.wikipedia.org/wiki/Reverse_Polish_notation Reverse Polish notation} by the SassScriptLexer and
+ *  the calculated result returned.
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+class SassScriptParser {
+	const MATCH_INTERPOLATION = '/(?<!\\\\)#\{(.*?)\}/';
+	const DEFAULT_ENV = 0;
+	const CSS_RULE = 1;
+	const CSS_PROPERTY = 2;
+	
+	/**
+	 * @var SassContext Used for error reporting
+	 */
+	public static $context;
+
+	/**
+	 * @var SassScriptLexer the lexer object
+	 */
+	private $lexer;
+
+	/**
+	* SassScriptParser constructor.
+	* @return SassScriptParser
+	*/
+	public function __construct() {
+		$this->lexer = new SassScriptLexer($this);
+	}
+
+	/**
+	 * Replace interpolated SassScript contained in '#{}' with the parsed value.
+	 * @param string the text to interpolate
+	 * @param SassContext the context in which the string is interpolated
+	 * @return string the interpolated text
+	 */
+	public function interpolate($string, $context) {
+		for ($i = 0, $n = preg_match_all(self::MATCH_INTERPOLATION, $string, $matches);
+				$i < $n; $i++) {
+			$matches[1][$i] = $this->evaluate($matches[1][$i], $context)->toString();
+		}
+	  return str_replace($matches[0], $matches[1], $string);
+	}
+
+	/**
+	 * Evaluate a SassScript.
+	 * @param string expression to parse
+	 * @param SassContext the context in which the expression is evaluated
+	 * @param	integer the environment in which the expression is evaluated
+	 * @return SassLiteral parsed value
+	 */
+	public function evaluate($expression, $context, $environment=self::DEFAULT_ENV) {
+		self::$context = $context;
+		$operands = array();
+
+		$tokens = $this->parse($expression, $context, $environment);
+		
+		while (count($tokens)) {
+			$token = array_shift($tokens);
+			if ($token instanceof SassScriptFunction) {
+				array_push($operands, $token->perform());
+			}
+			elseif ($token instanceof SassLiteral) {
+				if ($token instanceof SassString) {
+					$token = new SassString($this->interpolate($token->toString(), self::$context));
+				}
+				array_push($operands, $token);
+			}
+			else {
+				$args = array();
+				for ($i = 0, $c = $token->operandCount; $i < $c; $i++) {
+					$args[] = array_pop($operands);
+				}
+				array_push($operands, $token->perform($args));
+			}
+		}
+	  return array_shift($operands);
+	}
+
+	/**
+	 * Parse SassScript to a set of tokens in RPN
+	 * using the Shunting Yard Algorithm.
+	 * @param string expression to parse
+	 * @param SassContext the context in which the expression is parsed
+	 * @param	integer the environment in which the expression is parsed
+	 * @return array tokens in RPN
+	 */
+	public function parse($expression, $context, $environment=self::DEFAULT_ENV) {
+		$outputQueue = array();
+		$operatorStack = array();
+		$parenthesis = 0;
+		
+		$tokens = $this->lexer->lex($expression, $context);
+
+		foreach($tokens as $i=>$token) {
+			// If two literals/expessions are seperated by whitespace use the concat operator
+			if (empty($token)) {
+				if ($i > 0 && (!$tokens[$i-1] instanceof SassScriptOperation || $tokens[$i-1]->operator === SassScriptOperation::$operators[')'][0]) &&
+						(!$tokens[$i+1] instanceof SassScriptOperation || $tokens[$i+1]->operator === SassScriptOperation::$operators['('][0])) {
+					$token = new SassScriptOperation(SassScriptOperation::$defaultOperator, $context);
+				}
+				else {
+					continue;
+				}				
+			}
+			elseif ($token instanceof SassScriptVariable) {
+				$token = $token->evaluate($context);
+				$environment = self::DEFAULT_ENV;
+			}
+
+			// If the token is a number or function add it to the output queue.
+ 			if ($token instanceof SassLiteral || $token instanceof SassScriptFunction) {
+ 				if ($environment === self::CSS_PROPERTY && $token instanceof SassNumber && !$parenthesis) {
+					$token->inExpression = false; 
+ 				}
+				array_push($outputQueue, $token);
+			}
+			// If the token is an operation
+			elseif ($token instanceof SassScriptOperation) {
+				// If the token is a left parenthesis push it onto the stack.
+				if ($token->operator == SassScriptOperation::$operators['('][0]) {
+					array_push($operatorStack, $token);
+					$parenthesis++;
+				}
+				// If the token is a right parenthesis:
+				elseif ($token->operator == SassScriptOperation::$operators[')'][0]) {
+					$parenthesis--;
+					while ($c = count($operatorStack)) {
+						// If the token at the top of the stack is a left parenthesis
+						if ($operatorStack[$c - 1]->operator == SassScriptOperation::$operators['('][0]) {
+							// Pop the left parenthesis from the stack, but not onto the output queue.
+							array_pop($operatorStack);
+							break;
+						}
+						// else pop the operator off the stack onto the output queue.
+						array_push($outputQueue, array_pop($operatorStack));
+					}
+					// If the stack runs out without finding a left parenthesis
+					// there are mismatched parentheses.
+					if ($c == 0) {
+						throw new SassScriptParserException('Unmatched parentheses', array(), $context->node);
+					}
+				}
+				// the token is an operator, o1, so:
+				else {
+					// while there is an operator, o2, at the top of the stack
+					while ($c = count($operatorStack)) {
+						$operation = $operatorStack[$c - 1];
+						// if o2 is left parenthesis, or
+						// the o1 has left associativty and greater precedence than o2, or
+						// the o1 has right associativity and lower or equal precedence than o2
+						if (($operation->operator == SassScriptOperation::$operators['('][0]) ||
+							($token->associativity == 'l' && $token->precedence > $operation->precedence) ||
+							($token->associativity == 'r' && $token->precedence <= $operation->precedence)) {
+							break; // stop checking operators
+						}
+						//pop o2 off the stack and onto the output queue
+						array_push($outputQueue, array_pop($operatorStack));
+					}
+					// push o1 onto the stack
+					array_push($operatorStack, $token);
+				}
+			}
+		}
+
+		// When there are no more tokens
+		while ($c = count($operatorStack)) { // While there are operators on the stack:
+			if ($operatorStack[$c - 1]->operator !== SassScriptOperation::$operators['('][0]) {
+				array_push($outputQueue, array_pop($operatorStack));
+			}
+			else {
+				throw new SassScriptParserException('Unmatched parentheses', array(), $context->node);
+			}
+		}
+		return $outputQueue;
+	}
+}

data/lib/Phamlp/sass/script/SassScriptParserExceptions.php

@@ -0,0 +1,40 @@
+<?php
+/* SVN FILE: $Id: SassScriptParserExceptions.php 61 2010-04-16 10:19:59Z chris.l.yates $ */
+/**
+ * SassScript Parser exception class file.
+ * @author			Chris Yates <chris.l.yates@gmail.com>
+ * @copyright 	Copyright (c) 2010 PBM Web Development
+ * @license			http://phamlp.googlecode.com/files/license.txt
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+
+require_once(dirname(__FILE__).'/../SassException.php');
+
+/**
+ * SassScriptParserException class.
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+class SassScriptParserException extends SassException {}
+
+/**
+ * SassScriptLexerException class.
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+class SassScriptLexerException extends SassScriptParserException {}
+
+/**
+ * SassScriptOperationException class.
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+class SassScriptOperationException extends SassScriptParserException {}
+
+/**
+ * SassScriptFunctionException class.
+ * @package			PHamlP
+ * @subpackage	Sass.script
+ */
+class SassScriptFunctionException extends SassScriptParserException {}

data/lib/Phamlp/sass/script/SassScriptVariable.php

@@ -0,0 +1,57 @@
+<?php
+/* SVN FILE: $Id: SassVariable.php 49 2010-04-04 10:51:24Z chris.l.yates $ */
+/**
+ * SassVariable class file.
+ * @author			Chris Yates <chris.l.yates@gmail.com>
+ * @copyright 	Copyright (c) 2010 PBM Web Development
+ * @license			http://phamlp.googlecode.com/files/license.txt
+ * @package			PHamlP
+ * @subpackage	Sass.script.literals
+ */
+ 
+/**
+ * SassVariable class.
+ * @package			PHamlP
+ * @subpackage	Sass.script.literals
+ */
+class SassScriptVariable {
+	/**
+	 * Regex for matching and extracting Variables
+	 */
+	const MATCH = '/^(?<!\\\\)(?(?!!important\b)[!\$]([\w-]+))/';
+	
+	/**
+	 * @var string name of variable
+	 */
+	private $name;
+
+	/**
+	 * SassVariable constructor
+	 * @param string value of the Variable type
+	 * @return SassVariable
+	 */
+	public function __construct($value) {
+		$this->name = substr($value, 1);
+	}
+
+	/**
+	 * Returns the SassScript object for this variable.
+	 * @param SassContext context of the variable
+	 * @return SassLiteral the SassScript object for this variable
+	 */
+	public function evaluate($context) {
+		return $context->getVariable($this->name);
+	}
+
+	/**
+	 * Returns a value indicating if a token of this type can be matched at
+	 * the start of the subject string.
+	 * @param string the subject string
+	 * @return mixed match at the start of the string or false if no match
+	 */
+	public static function isa($subject) {
+		// we need to do the check as preg_match returns a count of 1 if
+		// subject == '!important'; the match being an empty match
+		return (preg_match(self::MATCH, $subject, $matches) ? (empty($matches[0]) ? false : $matches[0]) : false);
+	}
+}

data/lib/Phamlp/sass/script/literals/SassBoolean.php

@@ -0,0 +1,67 @@
+<?php
+/* SVN FILE: $Id: SassBoolean.php 118 2010-09-21 09:45:11Z chris.l.yates@gmail.com $ */
+/**
+ * SassBoolean class file.
+ * @author			Chris Yates <chris.l.yates@gmail.com>
+ * @copyright 	Copyright (c) 2010 PBM Web Development
+ * @license			http://phamlp.googlecode.com/files/license.txt
+ * @package			PHamlP
+ * @subpackage	Sass.script.literals
+ */
+
+require_once('SassLiteral.php');
+
+/**
+ * SassBoolean class.
+ * @package			PHamlP
+ * @subpackage	Sass.script.literals
+ */
+class SassBoolean extends SassLiteral {
+	/**@#+
+	 * Regex for matching and extracting booleans
+	 */
+	const MATCH = '/^(true|false)\b/';
+
+	/**
+	 * SassBoolean constructor
+	 * @param string value of the boolean type
+	 * @return SassBoolean
+	 */
+	public function __construct($value) {
+		if (is_bool($value)) {
+			$this->value = $value;
+		}
+		elseif ($value === 'true' || $value === 'false') {
+			$this->value = ($value === 'true' ? true : false);
+		}
+		else {
+			throw new SassBooleanException('Invalid {what}', array('{what}'=>'SassBoolean'), SassScriptParser::$context->node);
+		}
+	}
+
+	/**
+	 * Returns the value of this boolean.
+	 * @return boolean the value of this boolean
+	 */
+	public function getValue() {
+		return $this->value;
+	}
+
+	/**
+	 * Returns a string representation of the value.
+	 * @return string string representation of the value.
+	 */
+	public function toString() {
+		return $this->getValue() ? 'true' : 'false';
+	}
+
+	/**
+	 * Returns a value indicating if a token of this type can be matched at
+	 * the start of the subject string.
+	 * @param string the subject string
+	 * @return mixed match at the start of the string or false if no match
+	 */
+	public static function isa($subject) {
+		return (preg_match(self::MATCH, $subject, $matches) ? $matches[0] : false);
+	}
+}