wproot 0.0.1

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

@@ -0,0 +1,222 @@
+<?php
+
+require_once 'RootNode.php';
+require_once 'HamlNode.php';
+require_once 'Element.php';
+
+class ElementNode extends HamlNode
+{
+	private $_phpVariable;
+	
+	/**
+	 * @var Element
+	 */
+	private $_el;
+
+	public function __construct($line, $compiler)
+	{
+		parent::__construct($line);
+		$this->_phpVariable = false;
+		$this->_el = new Element($this->getHaml(), $compiler);
+		$this->_phpVariable = $this->_el->isPhpVariable();
+	}
+
+	public function render()
+	{
+		return $this->renderHtml($this->_el);
+	}
+
+	private function renderHtml(Element $element)
+	{
+		$output = '';
+		
+		if ($this->getIndentationLevel() > 0)
+		{
+			$output .= $this->getSpaces() . '<' . $element->getTag();
+		}
+		else
+		{
+			$output .= '<' . $element->getTag();
+		}
+		
+		if ($element->useAttsHelper())
+		{
+			$output .= ' <?php atts(array(';
+			if (($atts = $element->getAttributes()) != null)
+			{
+				if (isset($atts['id'])) {
+					$output .= "'id' => " . $this->_renderArrayValue($atts['id'], '_', 'php').', ';
+					unset($atts['id']);
+				}
+				
+				if (isset($atts['class'])) {
+					$output .= "'class' => " . $this->_renderArrayValue($atts['class'], ' ', 'php').', ';
+					unset($atts['class']);
+				}
+				
+				foreach ($atts as $name => $att)
+				{
+					$output .= "";
+					switch ($att['t'])
+					{
+						case 'str':
+							$output .= "'$name' => {$att['v']}, ";
+							continue;
+						case 'php':
+							if (is_array($att['v']))
+								$output .= "'$name' => array(" . join(',', $att['v']) . ')';
+							else
+								$output .= "'$name' => {$att['v']}, ";
+							
+							continue;
+						case 'static':
+							$output .= "'$name' => '$name', ";
+							continue;
+						case 'function':
+							$output .= "{$att['v']}, ";
+							continue;
+					}
+				}
+			}
+			
+			$output = rtrim($output, ', ');
+			$output .= ')); ?>';
+		}
+		else
+		{
+			if (($atts = $element->getAttributes()) !== null)
+			{
+				if (isset($atts['id'])) {
+					$output .= ' id="'.$this->_renderArrayValue($atts['id'], '_', 'txt').'"';
+					unset($atts['id']);
+				}
+				
+				if (isset($atts['class'])) {
+					$output .= ' class="'.$this->_renderArrayValue($atts['class'], ' ', 'txt').'"';
+					unset($atts['class']);
+				}
+				
+				foreach ($atts as $name => $att)
+				{
+					switch ($att['t'])
+					{
+						case 'str':
+							$output .= " {$name}={$att['v']}";
+							continue;
+						case 'php':
+							$output .= " $name=<?php {$att['v']}; ?>";
+							
+							continue;
+						case 'static':
+							$output .= " $name=\"$name\"";
+							continue;
+					}
+				}
+			}
+		}
+		
+		$content = $this->renderTagContent($element->getInlineContent());
+		
+		$interpolation = new Interpolation($output);
+		$output = $interpolation->render();
+		
+		// render inline content
+		$output .= '>' . $content . '</' . $element->getTag() . '>';
+		return $output . "\n";
+	}
+
+	/**
+	 * Joins the string $parts together using $separator but format the return according to context.
+	 * This method concatenates all the parts using $separtor as glue. If the context is 'txt'
+	 * and at least one part is php, the returned string will be encapsuled inside <?php ... ?>
+	 * If the context is 'php' the string returned will be a valid php code.
+	 * @code
+	 *   _renderArrayValue(array(
+	 *     array('t' => 'str', 'v' => 'a',
+	 *     array('t' => 'str', 'v' => 'b'));			# -> a_b
+	 *     
+	 *   _renderArrayValue(array(
+	 *     array('t' => 'str', 'v' => 'a',
+	 *     array('t' => 'str', 'v' => 'b'), 'php');	# -> 'a_b'
+	 *     
+	 *   _renderArrayValue(array(
+	 *     array('t' => 'str', 'v' => 'a',
+	 *     array('t' => 'php', 'v' => '$b'));			# -> <?php echo 'a_'.$b; ?>
+	 *     
+	 *   _renderArrayValue(array(
+	 *     array('t' => 'str', 'v' => 'a',
+	 *     array('t' => 'php', 'v' => '$b'), 'php');	# -> 'a_'.$b
+	 * @endcode
+	 * 
+	 * @param $arr_parts The components of the id
+	 * @param $context The context into which the value will be inserted. Can be 'txt' (default) or 'php'
+	 */
+	private function _renderArrayValue($parts, $separator = ' ', $context = 'txt')
+	{
+		$hasPhp = false;
+		$values = array();
+		
+		foreach ($parts as $p)
+		{
+			if ($p['t'] == 'php')
+			{
+				$hasPhp = true;
+				$values[] = $p['v'];
+			}
+			else
+			{
+				$values[] = "'{$p['v']}'";
+			}
+		}
+		
+		if (!$hasPhp)
+		{
+			$quote = '';
+			if ('php' == $context)
+				$quote = "'";
+			
+			$value = '';
+			foreach($parts as $p)
+				$value .= "$separator{$p['v']}";
+			
+			return $quote . trim($value, $separator) . $quote;
+		}
+		else
+		{
+			$value = join(".", $values);
+			$value = str_replace("'.'", $separator, $value);
+			$value = str_replace(".'", ".'$separator", $value);
+			$value = str_replace("'.", "$separator'.", $value);
+				
+			if('txt' == $context)
+				return '<?php echo '.$value.'; ?>';
+				
+			return $value;
+		}
+	}
+
+	private function renderTagContent($content)
+	{
+		if ($this->hasChildren())
+		{
+			$content = "\n" . $this->renderChildren() . $this->getSpaces();
+		}
+		
+		if ($content === null)
+		{
+			$content = '';
+		}
+		
+		if ($this->_phpVariable)
+		{
+			$content = "<?php echo " . $content . " ?>";
+		}
+		else
+		{
+			$interpolation = new Interpolation($content);
+			$content = $interpolation->render();
+		}
+		
+		return $content;
+	}
+}

data/vendor/HamlPHP/src/HamlPHP/Filter/CssFilter.php

@@ -0,0 +1,31 @@
+<?php
+
+require_once 'Filter.php';
+
+class CssFilter implements Filter
+{
+  public function getIdentifier()
+  {
+    return 'css';
+  }
+
+  public function filter(HamlNode $node)
+  {
+    if (null === $node) {
+      throw new Exception("CssFilter: node is null.");
+    }
+
+    $plainFilter = new PlainFilter();
+
+    $output = $node->getSpaces() . "<style type=\"text/css\">\n";
+
+    $oldLevel = $node->getIndentationLevel();
+    $node->setIndentationLevel($oldLevel + 2);
+    $output .= $plainFilter->filter($node);
+    $node->setIndentationLevel($oldLevel);
+
+    $output .= $node->getSpaces() . "</style>";
+
+    return $output . "\n";
+  }
+}

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

@@ -0,0 +1,18 @@
+<?php
+
+interface Filter
+{
+  /**
+   * Returns an identifier of this filter.
+   * 
+   * @return string
+   */
+  public function getIdentifier();
+
+  /**
+   * Filters given node.
+   * 
+   * @param HamlNode object
+   */
+  public function filter(HamlNode $node);
+}

data/vendor/HamlPHP/src/HamlPHP/Filter/FilterContainer.php

@@ -0,0 +1,34 @@
+<?php
+
+require_once 'Filter.php';
+
+class FilterContainer
+{
+  private $_filters = array();
+
+  public function __construct($filters = array())
+  {
+    foreach ($filters as $filter) {
+      $this->addFilter($filter);
+    }
+  }
+
+  public function addFilter(Filter $filter)
+  {
+    $this->_filters[$filter->getIdentifier()] = $filter;
+  }
+
+  public function getFilters()
+  {
+    return $this->_filters;
+  }
+
+  public function getFilter($identifier)
+  {
+    if (isset($this->_filters[$identifier])) {
+      return $this->_filters[$identifier];
+    }
+
+    return null;
+  }
+}

data/vendor/HamlPHP/src/HamlPHP/Filter/JavascriptFilter.php

@@ -0,0 +1,29 @@
+<?php
+
+class JavascriptFilter implements Filter
+{
+  public function getIdentifier()
+  {
+    return 'javascript';
+  }
+
+  public function filter(HamlNode $node)
+  {
+    if ($node === null) {
+      throw new Exception('Javascript filter: node is null');
+    }
+
+    $plainFilter = new PlainFilter();
+
+    $output = $node->getSpaces() . "<script type=\"text/javascript\">\n";
+
+    $oldLevel = $node->getIndentationLevel();
+    $node->setIndentationLevel($oldLevel + 2);
+    $output .= $plainFilter->filter($node);
+    $node->setIndentationLevel($oldLevel);
+
+    $output .= $node->getSpaces() . "</script>";
+
+    return $output . "\n";
+  }
+}

data/vendor/HamlPHP/src/HamlPHP/Filter/PhpFilter.php

@@ -0,0 +1,24 @@
+<?php
+
+class PhpFilter implements Filter
+{
+  public function getIdentifier()
+  {
+    return 'php';
+  }
+
+  public function filter(HamlNode $node)
+  {
+    if ($node === null) {
+      throw new Exception('PHP filter: node is null');
+    }
+
+    $plainFilter = new PlainFilter();
+
+    $output = $node->getSpaces() . "<?php\n";
+    $output .= $plainFilter->filter($node);
+    $output .= $node->getSpaces() . "?>";
+
+    return $output . "\n";
+  }
+}

data/vendor/HamlPHP/src/HamlPHP/Filter/PlainFilter.php

@@ -0,0 +1,46 @@
+<?php
+
+require_once 'Filter.php';
+
+class PlainFilter implements Filter
+{
+  public function getIdentifier()
+  {
+    return 'plain';
+  }
+
+  public function filter(HamlNode $node)
+  {
+    if (null === $node) {
+      throw new Exception("PlainFilter: node is null.");
+    }
+
+    $children = $node->getChildren();
+    $output = '';
+
+    foreach ($children as $childNode) {
+      $output .= $this->renderChildrenHaml($childNode);
+    } 
+
+    return $output;
+  }
+
+  protected function renderChildrenHaml(HamlNode $node)
+  {
+    $parent = $node->getParent();
+    $haml = $parent !== null
+        ? $parent->getSpaces() . $node->getHaml() : $node->getRawHaml();
+
+    $output = $haml . "\n";
+
+    if ($node->hasChildren()) {
+      $children = $node->getChildren();
+
+      for ($i = 0, $count = count($children); $i < $count; ++$i) {
+        $output .= $this->renderChildrenHaml($children[$i]);
+      }
+    }
+
+    return $output;
+  }
+}

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

@@ -0,0 +1,29 @@
+<?php
+
+class FilterNode extends HamlNode
+{
+  private $_filterContainer = null;
+
+  public function __construct($line, FilterContainer $container = null)
+  {
+    parent::__construct($line);
+    $this->_filterContainer = $container;
+  }
+
+  public function render()
+  {
+    if (null === $this->_filterContainer) {
+      return '';
+    }
+
+    $identifier = str_replace(':', '', $this->getHaml());
+    $filter = $this->_filterContainer->getFilter($identifier);
+
+    if (null === $filter) {
+      throw new Exception(sprintf("Unknown filter '%s'.", $identifier));
+    }
+
+    $interpolation = new Interpolation($filter->filter($this));
+    return $interpolation->render();
+  }
+}

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

@@ -0,0 +1,75 @@
+<?php
+
+class HamlNode extends RootNode
+{
+  private $_rawHaml;
+  private $_haml;
+  private $_spaces;
+
+  public function __construct($line)
+  {
+    parent::__construct();
+    $this->_rawHaml = $line;
+    $this->_haml = trim($line);
+    $this->setIndentationLevel(strlen($line) - strlen(ltrim($line)));
+  }
+
+  public function getSpaces()
+  {
+    return $this->_spaces;
+  }
+
+  public function setIndentationLevel($level)
+  {
+    $oldLevel = $this->getIndentationLevel();
+    parent::setIndentationLevel($level);
+    $this->_spaces = $this->createSpaces();
+
+    if ($this->hasChildren()) {
+      $children = $this->getChildren();
+
+      for ($i = 0, $len = count($children); $i < $len; $i++) {
+        $childNode = $children[$i];
+        $currentLevel = $this->getIndentationLevel();
+        $childLevel = $childNode->getIndentationLevel();
+        $oldDiff = $childLevel - $oldLevel;
+        $newLevel = $currentLevel + $oldDiff;
+        $childNode->setIndentationLevel($newLevel);
+      }
+    }
+  }
+
+  public function getRawHaml()
+  {
+    return $this->_rawHaml;
+  }
+
+  public function getHaml()
+  {
+    return $this->_haml;
+  }
+
+  private function createSpaces()
+  {
+    $spaces = '';
+
+    for ($i = 0; $i < $this->getIndentationLevel(); ++$i) {
+      $spaces .= ' ';
+    }
+
+    return $spaces;
+  }
+
+  public function render()
+  {
+    $output = $this->_spaces . $this->_haml . "\n";
+    $interpolation = new Interpolation($output);
+    $output = $interpolation->render();
+
+    if ($this->hasChildren()) {
+      $output = $output . $this->renderChildren();
+    }
+
+    return $output;
+  }
+}