guard-mthaml 0.1.0

data/vendor/mthaml/mthaml/lib/MtHaml/Node/EscapableAbstract.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\Escaping;
+
+abstract class EscapableAbstract extends NodeAbstract
+{
+    private $escaping;
+
+    public function getEscaping()
+    {
+        if (null === $this->escaping) {
+            $this->escaping = new Escaping;
+        }
+
+        return $this->escaping;
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/Filter.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class Filter extends NodeAbstract
+{
+    private $childs = array();
+    private $filter;
+
+    public function __construct(array $position, $filter)
+    {
+        parent::__construct($position);
+        $this->filter = $filter;
+    }
+
+    public function getFilter()
+    {
+        return $this->filter;
+    }
+
+    public function addChild(NodeAbstract $node)
+    {
+        $this->childs[] = $node;
+    }
+
+    public function getChilds()
+    {
+        return $this->childs;
+    }
+
+    public function getNodeName()
+    {
+        return 'filter';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterFilter($this)) {
+
+            if (false !== $visitor->enterFilterChilds($this)) {
+                foreach ($this->getChilds() as $child) {
+                    $child->accept($visitor);
+                }
+            }
+            $visitor->leaveFilterChilds($this);
+        }
+        $visitor->leaveFilter($this);
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/Insert.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+/**
+ * Insert Node
+ *
+ * Represents code to execute and whose result is inserted in the document.
+ */
+class Insert extends EscapableAbstract
+{
+    protected $content;
+
+    public function __construct(array $position, $content)
+    {
+        parent::__construct($position);
+        $this->content = $content;
+    }
+
+    public function getContent()
+    {
+        return $this->content;
+    }
+
+    public function hasContent()
+    {
+        return null !== $this->content;
+    }
+
+    public function getNodeName()
+    {
+        return 'echo';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        $visitor->enterInsert($this);
+        $visitor->leaveInsert($this);
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/InterpolatedString.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+/**
+ * InterpolatedString Node
+ *
+ * Represents a ruby-like interpolated string. Children are Text and Insert
+ * nodes.
+ */
+class InterpolatedString extends NodeAbstract
+{
+    protected $childs;
+
+    public function __construct(array $position, array $childs = array())
+    {
+        parent::__construct($position);
+        $this->childs = $childs;
+    }
+
+    /**
+     * @param Text|Insert $child Child
+     */
+    public function addChild(NodeAbstract $child)
+    {
+
+        if (!$child instanceof Text && !$child instanceof Insert) {
+            throw new \InvalidArgumentException(sprintf('Argument 1 passed to %s() must be an instance of MtHaml\Node\Text or MtHaml\Node\Insert, instance of %s given', __METHOD__, get_class($child)));
+        }
+
+        $this->childs[] = $child;
+    }
+
+    /**
+     * @return Text|Insert
+     */
+    public function getChilds()
+    {
+        return $this->childs;
+    }
+
+    public function getNodeName()
+    {
+        return 'interpolated string';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterInterpolatedString($this)) {
+
+            if (false !== $visitor->enterInterpolatedStringChilds($this)) {
+                foreach ($this->getChilds() as $child) {
+                    $child->accept($visitor);
+                }
+                $visitor->leaveInterpolatedStringChilds($this);
+            }
+            $visitor->leaveInterpolatedString($this);
+        }
+    }
+
+    public function isConst()
+    {
+        foreach ($this->childs as $child) {
+            if (!$child->isConst()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/NestAbstract.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\Exception;
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+abstract class NestAbstract extends NodeAbstract implements NestInterface
+{
+    private $content;
+    private $childs = array();
+
+    public function addChild(NodeAbstract $node)
+    {
+        if (!$this->allowsNestingAndContent() && $this->hasContent()) {
+            throw new Exception('A node cannot have both content and nested nodes');
+        }
+        if (null !== $parent = $node->getParent()) {
+            $parent->removeChild($node);
+        }
+
+        $prev = end($this->childs) ?: null;
+
+        $this->childs[] = $node;
+        $node->setParent($this);
+
+        if ($prev) {
+            $prev->setNextSibling($node);
+        }
+        $node->setPreviousSibling($prev);
+        $node->setNextSibling(null);
+    }
+
+    public function removeChild(NodeAbstract $node)
+    {
+        if (false === $key = array_search($node, $this->childs, true)) {
+            return;
+        }
+
+        unset($this->childs[$key]);
+
+        $prev = $node->getPreviousSibling();
+        $next = $node->getNextSibling();
+
+        if ($prev) {
+            $prev->setNextSibling($next);
+        }
+        if ($next) {
+            $next->setPreviousSibling($prev);
+        }
+
+        $node->setParent(null);
+        $node->setPreviousSibling(null);
+        $node->setNextSibling(null);
+    }
+
+    public function hasChilds()
+    {
+        return 0 < count($this->childs);
+    }
+
+    public function getChilds()
+    {
+        return $this->childs;
+    }
+
+    public function getFirstChild()
+    {
+        if (false !== $child = reset($this->childs)) {
+            return $child;
+        }
+    }
+
+    public function getLastChild()
+    {
+        if (false !== $child = end($this->childs)) {
+            return $child;
+        }
+    }
+
+    public function setContent($content)
+    {
+        if (!$this->allowsNestingAndContent() && $this->hasChilds()) {
+            throw new Exception('A node cannot have both content and nested nodes');
+        }
+        $this->content = $content;
+    }
+
+    public function hasContent()
+    {
+        return null !== $this->content;
+    }
+
+    public function getContent()
+    {
+        return $this->content;
+    }
+
+    public function allowsNestingAndContent()
+    {
+        return false;
+    }
+
+    public function visitContent(NodeVisitorInterface $visitor)
+    {
+        if ($this->hasContent()) {
+            $this->getContent()->accept($visitor);
+        }
+    }
+
+    public function visitChilds(NodeVisitorInterface $visitor)
+    {
+        foreach ($this->getChilds() as $child) {
+            $child->accept($visitor);
+        }
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/NestInterface.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace MtHaml\Node;
+
+interface NestInterface
+{
+    public function addChild(NodeAbstract $child);
+    public function hasContent();
+    public function allowsNestingAndContent();
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/NodeAbstract.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+abstract class NodeAbstract
+{
+    private $position;
+    private $parent;
+    private $nextSibling;
+    private $previousSibling;
+
+    public function __construct(array $position)
+    {
+        $this->position = $position;
+    }
+
+    public function getPosition()
+    {
+        return $this->position;
+    }
+
+    public function getLineno()
+    {
+        return $this->position['lineno'];
+    }
+
+    public function getColumn()
+    {
+        return $this->position['column'];
+    }
+
+    protected function setParent(NodeAbstract $parent = null)
+    {
+        $this->parent = $parent;
+    }
+
+    public function hasParent()
+    {
+        return null !== $this->parent;
+    }
+
+    public function getParent()
+    {
+        return $this->parent;
+    }
+
+    abstract public function getNodeName();
+
+    abstract public function accept(NodeVisitorInterface $visitor);
+
+    protected function setNextSibling(NodeAbstract $node = null)
+    {
+        $this->nextSibling = $node;
+    }
+
+    public function getNextSibling()
+    {
+        return $this->nextSibling;
+    }
+
+    protected function setPreviousSibling(NodeAbstract $node = null)
+    {
+        $this->previousSibling = $node;
+    }
+
+    public function getPreviousSibling()
+    {
+        return $this->previousSibling;
+    }
+
+    public function isConst()
+    {
+        return false;
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/ObjectRefClass.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class ObjectRefClass extends NodeAbstract
+{
+    protected $object;
+    protected $prefix;
+
+    public function __construct($position, NodeAbstract $object, NodeAbstract $prefix = null)
+    {
+        parent::__construct($position);
+        $this->object = $object;
+        $this->prefix = $prefix;
+    }
+
+    public function getNodeName()
+    {
+        return 'object_ref_class';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterObjectRefClass($this)) {
+
+            if (false !== $visitor->enterObjectRefObject($this)) {
+                $this->object->accept($visitor);
+            }
+            $visitor->leaveObjectRefObject($this);
+
+            if ($this->prefix) {
+                if (false !== $visitor->enterObjectRefPrefix($this)) {
+                    $this->prefix->accept($visitor);
+                }
+                $visitor->leaveObjectRefPrefix($this);
+            }
+        }
+        $visitor->leaveObjectRefClass($this);
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Node/ObjectRefId.php

@@ -0,0 +1,42 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class ObjectRefId extends NodeAbstract
+{
+    protected $object;
+    protected $prefix;
+
+    public function __construct($position, NodeAbstract $object, NodeAbstract $prefix = null)
+    {
+        parent::__construct($position);
+        $this->object = $object;
+        $this->prefix = $prefix;
+    }
+
+    public function getNodeName()
+    {
+        return 'object_ref_id';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterObjectRefId($this)) {
+
+            if (false !== $visitor->enterObjectRefObject($this)) {
+                $this->object->accept($visitor);
+            }
+            $visitor->leaveObjectRefObject($this);
+
+            if ($this->prefix) {
+                if (false !== $visitor->enterObjectRefPrefix($this)) {
+                    $this->prefix->accept($visitor);
+                }
+                $visitor->leaveObjectRefPrefix($this);
+            }
+        }
+        $visitor->leaveObjectRefId($this);
+    }
+}