guard-mthaml 0.1.0

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

@@ -0,0 +1,35 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class Root extends NestAbstract
+{
+  public function __construct(array $position = null)
+  {
+      parent::__construct($position ?: array('lineno' => 0, 'column' => 0));
+  }
+
+  public function getNodeName()
+  {
+    return 'root';
+  }
+
+  public function accept(NodeVisitorInterface $visitor)
+  {
+      if (false !== $visitor->enterRoot($this)) {
+
+          if (false !== $visitor->enterRootContent($this)) {
+              $this->visitContent($visitor);
+          }
+          $visitor->leaveRootContent($this);
+
+          if (false !== $visitor->enterRootChilds($this)) {
+              $this->visitChilds($visitor);
+          }
+          $visitor->leaveRootChilds($this);
+      }
+      $visitor->leaveRoot($this);
+  }
+}

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

@@ -0,0 +1,71 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+/**
+ * Run Node
+ *
+ * Represents code to execute. If there is children, the node should be
+ * rendered as a block (the renderer should emit a properly closed block).
+ */
+class Run extends NestAbstract
+{
+    private $midblock;
+
+    public function __construct(array $position, $content)
+    {
+        parent::__construct($position);
+        $this->setContent($content);
+    }
+
+    public function allowsNestingAndContent()
+    {
+        return true;
+    }
+
+    public function getNodeName()
+    {
+        return 'exec';
+    }
+
+    public function setMidblock(Run $midblock = null)
+    {
+        $this->midblock = $midblock;
+    }
+
+    public function getMidblock()
+    {
+        return $this->midblock;
+    }
+
+    public function hasMidblock()
+    {
+        return null !== $this->midblock;
+    }
+
+    public function isBlock()
+    {
+        return $this->hasChilds() || $this->hasMidblock();
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterRun($this)) {
+
+            if (false !== $visitor->enterRunChilds($this)) {
+                $this->visitChilds($visitor);
+            }
+            $visitor->leaveRunChilds($this);
+
+            if (false !== $visitor->enterRunMidblock($this)) {
+                if (null !== $block = $this->getMidblock()) {
+                    $block->accept($visitor);
+                }
+            }
+            $visitor->leaveRunMidblock($this);
+        }
+        $visitor->leaveRun($this);
+    }
+}

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

@@ -0,0 +1,45 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class Statement extends NodeAbstract
+{
+    protected $content;
+
+    public function __construct(array $position, NodeAbstract $content)
+    {
+        parent::__construct($position);
+        $this->content = $content;
+    }
+
+    public function getContent()
+    {
+        return $this->content;
+    }
+
+    public function hasContent()
+    {
+        return null !== $this->content;
+    }
+
+    public function getNodeName()
+    {
+        return 'statement';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterStatement($this)) {
+
+            if (false !== $visitor->enterStatementContent($this)) {
+                if ($this->hasContent()) {
+                    $this->getContent()->accept($visitor);
+                }
+            }
+            $visitor->leaveStatementContent($this);
+        }
+        $visitor->leaveStatement($this);
+    }
+}

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

@@ -0,0 +1,90 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class Tag extends NestAbstract
+{
+    const FLAG_REMOVE_INNER_WHITESPACES = 1;
+    const FLAG_REMOVE_OUTER_WHITESPACES = 2;
+    const FLAG_SELF_CLOSE = 4;
+
+    protected $tagName;
+    protected $attributes;
+    protected $flags;
+
+    public function __construct(array $position, $tagName, array $attributes, $flags = 0)
+    {
+        parent::__construct($position);
+        $this->tagName = $tagName;
+        $this->attributes = $attributes;
+        $this->flags = $flags;
+    }
+
+    public function getTagName()
+    {
+        return $this->tagName;
+    }
+
+    public function addAttribute(TagAttribute $attribute)
+    {
+        $this->attributes[] = $attribute;
+    }
+
+    public function hasAttributes()
+    {
+        return 0 < count($this->attributes);
+    }
+
+    public function getAttributes()
+    {
+        return $this->attributes;
+    }
+
+    public function removeAttribute(TagAttribute $attribute)
+    {
+        if (null !== $key = array_search($attribute, $this->attributes, true)) {
+            unset($this->attributes[$key]);
+        }
+    }
+
+    public function setFlag($flag)
+    {
+        $this->flags |= $flag;
+    }
+
+    public function getFlags()
+    {
+        return $this->flags;
+    }
+
+    public function getNodeName()
+    {
+        return 'tag';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterTag($this)) {
+
+            if (false !== $visitor->enterTagAttributes($this)) {
+                foreach ($this->getAttributes() as $attribute) {
+                    $attribute->accept($visitor);
+                }
+            }
+            $visitor->leaveTagAttributes($this);
+
+            if (false !== $visitor->enterTagContent($this)) {
+                $this->visitContent($visitor);
+            }
+            $visitor->leaveTagContent($this);
+
+            if (false !== $visitor->enterTagChilds($this)) {
+                $this->visitChilds($visitor);
+            }
+            $visitor->leaveTagChilds($this);
+        }
+        $visitor->leaveTag($this);
+    }
+}

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

@@ -0,0 +1,62 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class TagAttribute extends NodeAbstract
+{
+    protected $name;
+    protected $value;
+
+    public function __construct(array $position, NodeAbstract $name = null, NodeAbstract $value = null)
+    {
+        parent::__construct($position);
+        $this->name = $name;
+        $this->value = $value;
+    }
+
+    public function setName(NodeAbstract $name)
+    {
+        $this->name = $name;
+    }
+
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    public function setValue(NodeAbstract $value)
+    {
+        $this->value = $value;
+    }
+
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    public function getNodeName()
+    {
+        return 'attribute';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterTagAttribute($this)) {
+
+            if (false !== $visitor->enterTagAttributeName($this)) {
+                $this->getName()->accept($visitor);
+            }
+            $visitor->leaveTagAttributeName($this);
+
+            if ($this->getValue()) {
+                if (false !== $visitor->enterTagAttributeValue($this)) {
+                    $this->getValue()->accept($visitor);
+                }
+                $visitor->leaveTagAttributeValue($this);
+            }
+        }
+        $visitor->leaveTagAttribute($this);
+    }
+}

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

@@ -0,0 +1,24 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class TagAttributeInterpolation extends TagAttribute
+{
+    public function __construct(array $position, NodeAbstract $value = null)
+    {
+        parent::__construct($position, null, $value);
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterTagAttribute($this)) {
+            if (false !== $visitor->enterTagAttributeInterpolation($this)) {
+                $this->getValue()->accept($visitor);
+            }
+            $visitor->leaveTagAttributeInterpolation($this);
+        }
+        $visitor->leaveTagAttribute($this);
+    }
+}

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

@@ -0,0 +1,24 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\NodeVisitor\NodeVisitorInterface;
+
+class TagAttributeList extends TagAttribute
+{
+    public function __construct(array $position, NodeAbstract $value = null)
+    {
+        parent::__construct($position, null, $value);
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        if (false !== $visitor->enterTagAttribute($this)) {
+            if (false !== $visitor->enterTagAttributeList($this)) {
+                $this->getValue()->accept($visitor);
+            }
+            $visitor->leaveTagAttributeList($this);
+        }
+        $visitor->leaveTagAttribute($this);
+    }
+}

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

@@ -0,0 +1,37 @@
+<?php
+
+namespace MtHaml\Node;
+
+use MtHaml\Nodevisitor\NodeVisitorInterface;
+
+class Text extends EscapableAbstract
+{
+    private $content;
+
+    public function __construct(array $position, $content)
+    {
+        parent::__construct($position);
+        $this->content = $content;
+    }
+
+    public function getContent()
+    {
+        return $this->content;
+    }
+
+    public function getNodeName()
+    {
+        return 'text';
+    }
+
+    public function accept(NodeVisitorInterface $visitor)
+    {
+        $visitor->enterText($this);
+        $visitor->leaveText($this);
+    }
+
+    public function isConst()
+    {
+        return true;
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/NodeVisitor/Autoclose.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace MtHaml\NodeVisitor;
+
+use MtHaml\Node\Tag;
+
+class Autoclose extends NodeVisitorAbstract
+{
+    protected $autocloseTags;
+
+    public function __construct(array $autocloseTags)
+    {
+        $this->autocloseTags = $autocloseTags;
+    }
+
+    public function enterTag(Tag $tag)
+    {
+        if ($tag->hasChilds() || $tag->hasContent()) {
+            return;
+        }
+        if (in_array($tag->getTagName(), $this->autocloseTags)) {
+            $tag->setFlag(Tag::FLAG_SELF_CLOSE);
+        }
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/NodeVisitor/Escaping.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace MtHaml\NodeVisitor;
+
+use MtHaml\Node\Text;
+use MtHaml\Node\Insert;
+use MtHaml\Node\TagAttribute;
+use MtHaml\Node\NodeAbstract;
+use MtHaml\Node\InterpolatedString;
+
+class Escaping extends NodeVisitorAbstract
+{
+    /** do not auto-escape */
+    const ESCAPE_FALSE = 1;
+
+    /** do auto-escape */
+    const ESCAPE_TRUE = 2;
+
+    /** do auto-escape, but do not double-escape entities (haml compat) */
+    const ESCAPE_ONCE = 3;
+
+    protected $escapeHtml;
+    protected $escapeAttrs;
+
+    protected $inAttr = 0;
+    protected $inInterpolatedString = 0;
+
+    public function __construct($escapeHtml = self::ESCAPE_TRUE, $escapeAttrs = self::ESCAPE_TRUE)
+    {
+        $this->escapeHtml = $escapeHtml;
+        $this->escapeAttrs = $escapeAttrs;
+    }
+
+    protected function escape(NodeAbstract $node)
+    {
+        $enabled = $node->getEscaping()->isEnabled();
+
+        if ($enabled !== null) {
+            return;
+        }
+
+        if ($node instanceof Text) {
+            // interpolated strings that are not in attribute name/value
+            // are plain HTML and should not be escaped
+            if ($this->inInterpolatedString && !$this->inAttr) {
+                $node->getEscaping()->setEnabled(false);
+
+                return;
+            }
+        }
+
+        // everything we don't explicitly not escape is escaped
+
+        if ($this->inAttr) {
+            $this->setEscape($node, $this->escapeAttrs);
+        } else {
+            $this->setEscape($node, $this->escapeHtml);
+        }
+    }
+
+    protected function setEscape(NodeAbstract $node, $mode)
+    {
+        switch ($mode) {
+            case self::ESCAPE_FALSE:
+                $node->getEscaping()->setEnabled(false);
+                break;
+            case self::ESCAPE_ONCE:
+                $node->getEscaping()->setEnabled(true)->setOnce(true);
+                break;
+            case self::ESCAPE_TRUE:
+                $node->getEscaping()->setEnabled(true);
+                break;
+        }
+    }
+
+    public function enterTagAttribute(TagAttribute $node)
+    {
+        ++$this->inAttr;
+    }
+
+    public function leaveTagAttribute(TagAttribute $node)
+    {
+        --$this->inAttr;
+    }
+
+    public function enterInterpolatedString(InterpolatedString $node)
+    {
+        ++$this->inInterpolatedString;
+    }
+
+    public function leaveInterpolatedString(InterpolatedString $node)
+    {
+        --$this->inInterpolatedString;
+    }
+
+    public function enterText(Text $node)
+    {
+        $this->escape($node);
+    }
+
+    public function enterInsert(Insert $node)
+    {
+        $this->escape($node);
+    }
+}