wproot 0.0.1

data/vendor/HamlPHP/src/HamlPHP/HamlPHP.php

@@ -0,0 +1,191 @@
+<?php
+
+require_once 'Storage/Storage.php';
+require_once 'Compiler.php';
+require_once 'ContentEvaluator/DefaultContentEvaluator.php';
+
+class HamlPHP
+{
+  private $_compiler = null;
+  private $_storage = null;
+  private $_contentEvaluator = null;
+  private $_nodeFactory = null;
+  private $_filterContainer = null;
+  private $_cacheEnabled = true;
+
+  // Placeholder until config gets properly implemented
+  public static $Config = array(
+  	'escape_html' => false
+  );
+
+  public function __construct(Storage $storage)
+  {
+    $this->_compiler = $this->getCompiler();
+    $this->_storage = $storage;
+
+    if ($this->_storage instanceof ContentEvaluator) {
+      $this->setContentEvaluator($this->_storage);
+    } else {
+      $this->setContentEvaluator(new DefaultContentEvaluator());
+    }
+  }
+
+  /**
+   * Sets a content evaluator.
+   *
+   * @param ContentEvaluator $contentEvaluator
+   */
+  public function setContentEvaluator(ContentEvaluator $contentEvaluator)
+  {
+    $this->_contentEvaluator = $contentEvaluator;
+  }
+
+  /**
+   * Sets a filter container and updates the node factory to use it.
+   *
+   * @param FilterContainer $container
+   */
+  public function setFilterContainer(FilterContainer $container)
+  {
+    $this->_filterContainer = $container;
+    $this->getNodeFactory()->setFilterContainer($this->getFilterContainer());
+  }
+
+  /**
+   * Returns a filter container object. Initializes the filter container with
+   * default filters if it's null.
+   *
+   * @return FilterContainer
+   */
+  public function getFilterContainer()
+  {
+    if ($this->_filterContainer === null) {
+      $filterContainer = new FilterContainer();
+      $filterContainer->addFilter(new CssFilter());
+      $filterContainer->addFilter(new PlainFilter());
+      $filterContainer->addFilter(new JavascriptFilter());
+      $filterContainer->addFilter(new PhpFilter());
+
+      $this->_filterContainer = $filterContainer;
+    }
+
+    return $this->_filterContainer;
+  }
+
+  /**
+   * Sets a node factory.
+   *
+   * @param NodeFactory $factory
+   */
+  public function setNodeFactory(NodeFactory $factory)
+  {
+    $this->_nodeFactory = $factory;
+    $this->getNodeFactory()->setFilterContainer($this->getFilterContainer());
+  }
+
+  /**
+   * Returns a node factory object.
+   *
+   * @return NodeFactory
+   */
+  public function getNodeFactory()
+  {
+    if ($this->_nodeFactory === null) {
+      $this->setNodeFactory(new NodeFactory());
+    }
+
+    return $this->_nodeFactory;
+  }
+
+  /**
+   * Sets a compiler.
+   *
+   * @param Compiler $compiler
+   */
+  public function setCompiler(Compiler $compiler)
+  {
+    $this->_compiler = $compiler;
+  }
+
+  /**
+   * Returns a compiler object.
+   *
+   * @return Compiler
+   */
+  public function getCompiler()
+  {
+    if ($this->_compiler === null) {
+      $this->_compiler = new Compiler($this);
+    }
+
+    return $this->_compiler;
+  }
+
+  /**
+   * Enables caching.
+   */
+  public function enableCache()
+  {
+    $this->_cacheEnabled = true;
+  }
+
+  /**
+   * Disables caching.
+   */
+  public function disableCache()
+  {
+    $this->_cacheEnabled = false;
+  }
+
+  /**
+   * Returns true if caching is enabled.
+   *
+   * @return bool
+   */
+  public function isCacheEnabled()
+  {
+    return $this->_cacheEnabled;
+  }
+
+  /**
+   * Parses a haml file and returns a cached path to the file.
+   *
+   * @param string $fileName
+   */
+  public function parseFile($fileName, array $templateVars = array())
+  {
+    $content = $this->getContentFromStorage($fileName);
+
+    return $this->_contentEvaluator->evaluate(
+        $content, $templateVars, $this->generateFileId($fileName));
+  }
+
+  /**
+   * Returns content from a storage
+   *
+   * @param string $fileName
+   * @return string
+   */
+  public function getContentFromStorage($fileName)
+  {
+  	$fileId = $this->generateFileId($fileName);
+
+    if ($this->_storage === null) {
+        throw new Exception('Storage not set');
+    }
+
+    if ($this->isCacheEnabled()
+        && $this->_storage->isFresh($fileId)) {
+      return $this->_storage->fetch($fileId);
+    }
+
+    // file is not fresh, so compile and cache it
+    $this->_storage->cache($fileId, $this->_compiler->parseFile($fileName));
+    return $this->_storage->fetch($fileId);
+  }
+
+  private function generateFileId($filename)
+  {
+  	return str_replace(array(':','/','\\'), '_', ltrim($filename, '/\\'));
+  }
+}

data/vendor/HamlPHP/src/HamlPHP/Helpers.php

@@ -0,0 +1,136 @@
+<?php
+
+/**
+ * Returns a double or single quoted string. whatever works without changing the content of the string.
+ * Example:
+ * @code
+ *   quote("McDonald's")            # -> "\"McDonad's\""
+ *   quote("You \"win\", looser")     # -> "'You \"win\", looser'" 
+ * @endcode
+ * 
+ * If it can't be done. It will return false.
+ * 
+ * @param $str
+ * @return mixed The quoted string or false
+ */
+function quote($str)
+{
+	if(strpos($str, '"') === false)
+		return "\"$str\"";
+		
+	if(strpos($str, "'") === false)
+		return "'$str'";
+	
+	return false;
+}
+
+/**
+ * Prints a list of attributes specified by an array of (att_name => att_value)
+ * 
+ * @param array $atts
+ * @param bool $echo [optional] Wheter to echo the result or not (default: true)
+ * 
+ * @return string The list of attributes
+ */
+function atts($atts, $echo=true)
+{
+	$str = '';
+	$flatten = array();
+	
+	foreach ($atts as $name => $value)
+	{
+		if((string)$name != 'id' && (string)$name != 'class' && is_array($value))
+		{
+			foreach($value as $k => $v)
+			{
+				// TODO: if we found an Id or a Class attribute here. What should we do? For now, it will replace the original ones instead of append
+				$flatten[$k] = $v;	
+			}
+			unset($atts[$name]);
+		}
+	}
+	
+	$atts = array_merge($atts, $flatten);
+	
+	foreach ($atts as $name => $value)
+	{
+		if($value === false)
+			continue;
+		
+		if($value === true)
+		{
+			$str .= " $name=\"$name\"";
+		}
+		else
+		{
+			if('id' == (string)$name && is_array($value))
+			{
+				$str .= ' id="'.join('_', $value);
+			}
+			elseif ('class' == (string)$name && is_array($value))
+				$str .= ' class="'.join(' ', $value);
+			else
+				$str .= " $name=".quote($value);
+		}
+	}
+	
+	if($echo)
+		echo $str;
+	
+	return $str;
+}
+
+/**
+ * Returns an id generated by joining the class of $obj and the id of $obj, joined by a underscore (_), and prefixing it with $prefix.
+ * To get the class, this method will call the class_for() helper.
+ * To get the id, this method first check if the \c $id variable is set, if not, it checks for a \c getId()
+ * method. If none of them is found, it will use an internal, class specific, object counter.
+ * 
+ * @param object $obj
+ * @param string $prefix [Optional]
+ */
+function id_for($obj, $prefix = '')
+{
+	static $counter = array();
+	
+	if(!empty($prefix))
+		$prefix .= '_';
+
+	$klass = class_for($obj).'_';
+	
+	if(isset($obj->id))
+		return $prefix.$klass.$obj->id;
+		
+	if(method_exists($obj, 'getId'))
+		return $prefix.$klass.$obj->getId();
+	
+	if(!isset($counter[$klass]))
+		$counter[$klass] = 0;
+	
+	$counter[$klass]++;
+	
+	return $prefix.$klass.$counter[$klass];
+}
+
+/**
+ * Returns the class name of an object to be used in the class attribute.
+ * This behaviour can be overloaded by implement a haml_obj_ref (or hamlObjRef) method.
+ * Which MUST return a string. If such method isn't present, it will use php's get_class() function.
+ * If prefix is not empty, both, the object's class and the prefix, will be returned separated by one space.
+ * 
+ * @param object $obj
+ * @param string $prefix [Optional]
+ */
+function class_for($obj, $prefix = '')
+{
+	if(!empty($prefix))
+		$prefix .= ' ';
+		
+	if(method_exists($obj, 'haml_obj_ref'))
+		return $prefix.$obj->haml_obj_ref();
+	
+	if(method_exists($obj, 'hamlObjRef'))
+		return $prefix.$obj->hamlObjRef();
+	
+	return $prefix.get_class($obj);
+}

data/vendor/HamlPHP/src/HamlPHP/Interpolation.php

@@ -0,0 +1,71 @@
+<?php
+
+class Interpolation
+{
+  const REGEXP = '/(?:\#\{([^\}]+)\})+/';
+  const REPLACEMENT = '<?php echo $1; ?>';
+
+  private $_text = null;
+
+  public function __construct($text)
+  {
+    $this->_text = $text;
+  }
+
+  /**
+   * @todo Refactor!
+   * @throws LogicException
+   */
+  public function render()
+  {
+    $interpolationStarted = false;
+    $content = "";
+    $interpolationContent = "";
+    $len = strlen($this->_text);
+    $i = 0;
+
+    while ($i < $len) {
+      $currentChar = $this->_text[$i];
+      $nextChar = ($i + 1 <= $len - 1) ? $this->_text[$i + 1] : null;
+
+      if ($interpolationStarted) {
+        if ($currentChar === '}') {
+          $interpolationStarted = false;
+
+          if (empty($interpolationContent)) {
+            throw new LogicException("Empty interpolation: " . $this->_text);
+          }
+
+          $content .= "<?php echo " . $interpolationContent . "; ?>";
+          $interpolationContent = '';
+          $i++;
+          continue;
+        }
+
+        if (null !== $nextChar && '#{' === $currentChar . $nextChar) {
+          throw new LogicException(
+              "Nested interpolation not allowed: " . $this->_text);
+        }
+
+        $interpolationContent .= $currentChar;
+        $i++;
+        continue;
+      }
+
+      if (null !== $nextChar && '#{' === $currentChar . $nextChar) {
+        $interpolationStarted = true;
+        $i += 2;
+        continue;
+      }
+
+      $content .= $currentChar;
+      $i++;
+    }
+
+    if ($interpolationStarted) {
+      throw new LogicException("Unclosed interpolation: " . $this->_text);
+    }
+
+    return $content;
+  }
+}

data/vendor/HamlPHP/src/HamlPHP/NodeFactory.php

@@ -0,0 +1,80 @@
+<?php
+
+require_once 'ElementNode.php';
+require_once 'HamlNode.php';
+require_once 'DoctypeNode.php';
+require_once 'TagNode.php';
+require_once 'CommentNode.php';
+require_once 'FilterNode.php';
+
+class NodeFactory
+{
+  const ELEMENT = '%';
+  const ID = '#';
+  const KLASS = '.';
+
+  const HTML_COMMENT = '/';
+  const HAML_COMMENT = '-#';
+  const DOCTYPE = '!!!';
+
+  const VARIABLE = '=';
+  const TAG = '-';
+  const FILTER = ':';
+  const LOUD_SCRIPT = '=';
+
+  private $_filterContainer = null;
+
+  public function setFilterContainer(FilterContainer $container)
+  {
+    $this->_filterContainer = $container;
+  }
+
+  protected function getNodeObject($line, Compiler $compiler) {
+    $strippedLine = trim($line);
+
+    if($strippedLine == '')
+    	return null;
+    	
+    if (strpos($strippedLine, self::FILTER, 0) === 0) {
+      return new FilterNode($line, $this->_filterContainer);
+    }
+
+    if (strpos($strippedLine, NodeFactory::DOCTYPE, 0) !== false) {
+      return new DoctypeNode($line);
+    }
+
+    if (substr($strippedLine, 0, 1) === NodeFactory::HTML_COMMENT
+        || substr($strippedLine, 0, 2) === NodeFactory::HAML_COMMENT) {
+      return new CommentNode($line);
+    }
+
+    $elements = array(
+      NodeFactory::ELEMENT,
+      NodeFactory::ID,
+      NodeFactory::KLASS,
+    );
+
+    if (in_array($strippedLine[0], $elements)) {
+      return new ElementNode($line, $compiler);
+    }
+
+    if ($strippedLine[0] === NodeFactory::TAG
+        ||$strippedLine[0] === NodeFactory::LOUD_SCRIPT) {
+      return new TagNode($line);
+    }
+
+    return new HamlNode($line);
+  }
+
+  public function createNode($line, $lineNumber, Compiler $compiler)
+  {
+    $node = $this->getNodeObject($line, $compiler);
+
+    if ($node !== null) {
+      $node->setLineNumber($lineNumber);
+      $node->setCompiler($compiler);
+    }
+
+    return $node;
+  }
+}