guard-mthaml 0.1.0

data/vendor/mthaml/mthaml/lib/MtHaml/Parser/Buffer.php

@@ -0,0 +1,147 @@
+<?php
+
+namespace MtHaml\Parser;
+
+class Buffer
+{
+    protected $lines;
+    protected $line;
+
+    protected $lineno;
+    protected $column;
+
+    public function __construct($string, $lineno = 1)
+    {
+        $this->lines = preg_split('~\r\n|\n|\r~', $string);
+        $this->lineno = $lineno - 1;
+    }
+
+    public function nextLine()
+    {
+        $this->line = array_shift($this->lines);
+        if (null !== $this->line) {
+            ++$this->lineno;
+            $this->column = 1;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public function peekLine()
+    {
+        if (isset($this->lines[0])) {
+            return $this->lines[0];
+        }
+    }
+
+    public function hasNextLine()
+    {
+        return isset($this->lines[0]);
+    }
+
+    public function mergeNextLine()
+    {
+        if (!isset($this->lines[0])) {
+            return;
+        }
+        ++$this->lineno;
+        $this->line .= "\n" . array_shift($this->lines);
+    }
+
+    public function replaceLine($string)
+    {
+        $this->line = $string;
+    }
+
+    public function isEol()
+    {
+        return $this->line === '';
+    }
+
+    public function peekChar()
+    {
+        if (isset($this->line[0])) {
+            return $this->line[0];
+        }
+    }
+
+    public function eatChar()
+    {
+        if (isset($this->line[0])) {
+            $char = $this->line[0];
+            $this->line = (string) substr($this->line, 1);
+            ++$this->column;
+
+            return $char;
+        }
+    }
+
+    public function eatChars($n)
+    {
+        $chars = (string) substr($this->line, 0, $n);
+        $this->line = (string) substr($this->line, $n);
+        $this->column += strlen($chars);
+
+        return $chars;
+    }
+
+    public function match($pattern, &$match = null, $eat = true)
+    {
+        if ($count = preg_match($pattern, $this->line, $match, PREG_OFFSET_CAPTURE)) {
+            $pos = array();
+
+            foreach ($match as $key => &$capture) {
+                $pos[$key] = array(
+                    'lineno' => $this->lineno,
+                    'column' => $capture[1],
+                );
+                $capture = $capture[0];
+            }
+            unset($capture); // ref
+
+            $match['pos'] = $pos;
+
+            if ($eat) {
+                $this->eat($match[0]);
+            }
+        }
+
+        return $count > 0;
+    }
+
+    public function eat($string)
+    {
+        $this->line = (string) substr($this->line, strlen($string));
+        $this->column += strlen($string);
+    }
+
+    public function skipWs()
+    {
+        $this->match('~[ \t]+~A');
+    }
+
+    public function getColumn()
+    {
+        return $this->column;
+    }
+
+    public function getLineno()
+    {
+        return $this->lineno;
+    }
+
+    public function getPosition()
+    {
+        return array(
+            'lineno' => $this->lineno,
+            'column' => $this->column,
+        );
+    }
+
+    public function getLine()
+    {
+        return $this->line;
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Runtime.php

@@ -0,0 +1,218 @@
+<?php
+
+namespace MtHaml;
+
+use MtHaml\Runtime\AttributeInterpolation;
+use MtHaml\Runtime\AttributeList;
+
+class Runtime
+{
+    /**
+     * Renders a list of attributes
+     *
+     * Handles the following special cases:
+     * - attribute named 'data' with iterable value it rendered as multiple
+     *   html5 data- attributes
+     * - attribute with boolean value is rendered as boolean attribute. In html5
+     *   format, only the attribute name is rendered, like 'checked'. In
+     *   other formats, it is rendered with the attribute name as value, like
+     *   'checked="checked"'.
+     * - attribute with null or false value isn't rendered
+     * - multiple id attributes and id attributes with iterable values are
+     *   rendered concatenated with underscores
+     * - multiple class attributes and class attributes with iterable values are
+     *   rendered concatenated with spaces
+     *
+     * @param array  $list    A list of attributes (items are array($name, $value))
+     * @param string $format  Output format (e.g. html5)
+     * @param string $charset Output charset
+     */
+    public static function renderAttributes($list, $format, $charset, $escape = true)
+    {
+        $attributes = array();
+
+        self::mergeAttributes($attributes, $list, $format);
+
+        $result = null;
+
+        foreach ($attributes as $name => $value) {
+            if (null !== $result) {
+                $result .= ' ';
+            }
+            if ($value instanceof AttributeInterpolation) {
+                $result .= $value->value;
+            } elseif (true === $value) {
+                $result .= $escape ?
+                    htmlspecialchars($name, ENT_QUOTES, $charset) : $name;
+            } else {
+                $result .= ($escape ?
+                        htmlspecialchars($name, ENT_QUOTES, $charset) : $name)
+                    .'="'
+                    . ($escape ?
+                        htmlspecialchars($value, ENT_QUOTES, $charset) : $value)
+                    .'"';
+            }
+        }
+
+        return $result;
+    }
+
+    private static function mergeAttributes(&$dest, $list, $format)
+    {
+        foreach ($list as $item) {
+
+            if ($item instanceof AttributeInterpolation) {
+                $dest[] = $item;
+                continue;
+            } elseif ($item instanceof AttributeList) {
+                $pairs = array();
+                foreach ($item->attributes as $name => $value) {
+                    $pairs[] = array($name, $value);
+                }
+                self::mergeAttributes($dest, $pairs, $format);
+                continue;
+            }
+
+            list ($name, $value) = $item;
+
+            if ('data' === $name) {
+                self::renderDataAttributes($dest, $value);
+            } elseif ('id' === $name) {
+                $value = self::renderJoinedValue($value, '_');
+                if (null !== $value) {
+                    if (isset($dest['id'])) {
+                        $dest['id'] .= '_' . $value;
+                    } else {
+                        $dest['id'] = $value;
+                    }
+                }
+            } elseif ('class' === $name) {
+                $value = self::renderJoinedValue($value, ' ');
+                if (null !== $value) {
+                    if (isset($dest['class'])) {
+                        $dest['class'] .= ' ' . $value;
+                    } else {
+                        $dest['class'] = $value;
+                    }
+                }
+            } elseif (true === $value) {
+                if ('html5' === $format) {
+                    $dest[$name] = true;
+                } else {
+                    $dest[$name] = $name;
+                }
+            } elseif (false === $value || null === $value) {
+                // do not output
+            } else {
+                if (isset($dest[$name])) {
+                    // so that next assignment puts the attribute
+                    // at the end for the array
+                    unset($dest[$name]);
+                }
+                $dest[$name] = $value;
+            }
+        }
+    }
+
+    private static function renderDataAttributes(&$dest, $value, $prefix = 'data')
+    {
+        if (\is_array($value) || $value instanceof \Traversable) {
+            foreach ($value as $subname => $subvalue) {
+                self::renderDataAttributes($dest, $subvalue, $prefix.'-'.$subname);
+            }
+        } else {
+            if (!isset($dest[$prefix])) {
+                $dest[$prefix] = $value;
+            }
+        }
+    }
+
+    private static function renderJoinedValue($values, $separator)
+    {
+        $result = null;
+
+        if (\is_array($values) || $values instanceof \Traversable) {
+            foreach ($values as $value) {
+                if (\is_array($value) || $value instanceof \Traversable) {
+                    $value = self::renderJoinedValue($value, $separator);
+                }
+                if (null !== $value && false !== $value) {
+                    if (null !== $result) {
+                        $result .= $separator;
+                    }
+                    $result .= $value;
+                }
+            }
+        } else {
+            if (null !== $values && false !== $values) {
+                $result = $values;
+            }
+        }
+
+        return $result;
+    }
+
+    public static function renderObjectRefClass($object, $prefix = null)
+    {
+        if (!$object) {
+            return;
+        }
+
+        $class = self::getObjectRefClassString($object);
+
+        if (false !== $prefix && null !== $prefix) {
+            $class = $prefix . '_' . $class;
+        }
+
+        return $class;
+    }
+
+    public static function renderObjectRefId($object, $prefix = null)
+    {
+        if (!$object) {
+            return;
+        }
+
+        $id = null;
+
+        if (\is_callable(array($object, 'getId'))) {
+            $id = $object->getId();
+        } elseif (\is_callable(array($object, 'id'))) {
+            $id = $object->id();
+        }
+
+        if (false === $id || null === $id) {
+            $id = 'new';
+        }
+
+        $id = self::getObjectRefClassString($object) . '_' . $id;
+
+        if (false !== $prefix && null !== $prefix) {
+            $id = $prefix . '_' . $id;
+        }
+
+        return $id;
+    }
+
+    public static function getObjectRefClassString($object)
+    {
+        $class = self::getObjectRefName($object);
+        if (false !== $pos = \strrpos($class, '\\')) {
+            $class = \substr($class, $pos+1);
+        }
+
+        return \strtolower(\preg_replace('#(?<=[a-z])[A-Z]+#', '_$0', $class));
+    }
+
+    public static function getObjectRefName($object)
+    {
+        return \is_callable(array($object, 'hamlObjectRef'))
+            ? $object->hamlObjectRef()
+            : \get_class($object);
+    }
+
+    public static function filter(Environment $mthaml, $filter, array $context, $content)
+    {
+        return $mthaml->getFilter($filter)->filter($content, $context, $mthaml->getOptions());
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Runtime/AttributeInterpolation.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace MtHaml\Runtime;
+
+class AttributeInterpolation
+{
+    public $value;
+
+    public static function create($value)
+    {
+        $instance = new AttributeInterpolation;
+        $instance->value = $value;
+
+        return $instance;
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Runtime/AttributeList.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace MtHaml\Runtime;
+
+class AttributeList
+{
+    public $attributes;
+
+    public static function create($attributes)
+    {
+        $instance = new AttributeList;
+        $instance->attributes = $attributes;
+
+        return $instance;
+    }
+}

data/vendor/mthaml/mthaml/lib/MtHaml/Support/Php/Executor.php

@@ -0,0 +1,157 @@
+<?php
+
+namespace MtHaml\Support\Php;
+
+use MtHaml\Environment;
+use MtHaml\Exception;
+
+/**
+ * Executor is a simple helper that can compile haml files, cache them, and execute them
+ */
+class Executor
+{
+    private $environment;
+
+    private $options = array(
+        // Cache directory to store compiled templates
+        'cache' => null,
+        // Whether to by-pass cache, useful when debugging
+        'debug' => false,
+    );
+
+    public function __construct(Environment $environment, array $options)
+    {
+        $this->environment = $environment;
+        $this->options = $options + $this->options;
+
+        if (!$this->options['cache']) {
+            throw new Exception("A 'cache' option must be defined");
+        }
+    }
+
+    /**
+     * Executes and displays the template $file, with variables $variables
+     */
+    public function display($file, array $variables)
+    {
+        $fun = $this->compileFile($file);
+        $fun($variables);
+    }
+
+    /**
+     * Executes the template $file with variables $variables, and returns its output
+     */
+    public function render($file, array $variables)
+    {
+        $level = ob_get_level();
+        ob_start();
+
+        try {
+            $this->display($file, $variables);
+        } catch (\Exception $e) {
+            while (ob_get_level() > $level) {
+                ob_end_clean();
+            }
+
+            throw $e;
+        }
+
+        return ob_get_clean();
+    }
+
+    private function compileFile($file)
+    {
+        if (!file_exists($file)) {
+            throw new Exception(sprintf(
+                "File does not exist: `%s`"
+                , $file
+            ));
+        }
+
+        $hash = hash('sha256', $file);
+        $funName = '__MtHamlTemplate_' . $hash;
+
+        if (function_exists($funName)) {
+            return $funName;
+        }
+
+        $cacheFile = $this->options['cache']
+            . '/' . substr($hash, 0, 2) . '/' . substr($hash, 2, 2) . '/'
+            . substr($hash, 4) . '_' . basename($file) . '.php';
+
+        if ($this->options['debug'] || !file_exists($cacheFile) || filemtime($cacheFile) !== filemtime($file)) {
+
+            $hamlCode = file_get_contents($file);
+
+            if (false === $hamlCode) {
+                throw new Exception(sprintf(
+                    "Failed reading file: `%s`"
+                    , $file
+                ));
+            }
+
+            $compiledCode = $this->environment->compileString($hamlCode, $file);
+            $compiledCode = $this->wrapCompiledCode($compiledCode, $funName);
+
+            $this->writeCacheFile($cacheFile, $compiledCode);
+        }
+
+        require_once $cacheFile;
+
+        return $funName;
+    }
+
+    private function wrapCompiledCode($code, $funName)
+    {
+        // The code is wrapped in a function so that it can be parsed
+        // once, and executed multiple times. This is faster than repeatedly
+        // including the same PHP file.
+        return <<<PHP
+<?php
+
+function $funName(\$__variables)
+{
+    extract(\$__variables);
+?>$code<?php
+}
+PHP;
+    }
+
+    private function writeCacheFile($cacheFile, $contents)
+    {
+        $dir = dirname($cacheFile);
+
+        if (!is_dir($dir)) {
+            if (!mkdir($dir, 0777, true)) {
+                throw new Exception(sprintf(
+                    "Failed creating cache directory: `%s`"
+                    , $dir
+                ));
+            }
+        }
+
+        if (!is_writeable($dir)) {
+            throw new Exception(sprintf(
+                "Cache directory is not writeable: `%s`"
+                , $dir
+            ));
+        }
+
+        $tmpFile = tempnam($dir, basename($cacheFile));
+
+        if (false === file_put_contents($tmpFile, $contents)) {
+            throw new Exception(sprintf(
+                "Failed writing cache file: `%s`"
+                , $tmpFile
+            ));
+        }
+
+        if (!rename($tmpFile, $cacheFile)) {
+            @unlink($tmpFile);
+            throw new Exception(sprintf(
+                "Failed writing cache file: `%s`"
+                , $cacheFile
+            ));
+        }
+    }
+}