Merge pull request #23 from legalthings/mustache-template-types

Support multiple types in mustache enricher

src/DataEnricher/Processor/Mustache.php

@@ -26,11 +26,55 @@ class Mustache implements Processor
     public function applyToNode(Node $node)
     {
         $template = $node->getInstruction($this);
-        $result = $this->parse($template);
 
+        if (!is_string($template) && !is_array($template) && !is_object($template)) {
+            return trigger_error("Unable to parse given template of type: " . gettype($template), E_WARNING);
+        }
+
+        $result = $this->getParsedResult($template);
         $node->setResult($result);
     }
 
+    /**
+     * Parse a template by mustache if possible and return the result
+     * 
+     * @param mixed $template
+     *
+     * @return mixed $result
+     */
+    protected function getParsedResult($template)
+    {
+        if (is_string($template)) {
+            return $this->parse($template);
+        } elseif (is_array($template)) {
+            return array_map([$this, 'parse'], $template);
+        } elseif (is_object($template)) {
+            return $this->parseObject($template);
+        }
+
+        return $template;
+    }
+
+    /**
+     * Parse an object with mustache
+     * 
+     * @param  object $template
+     *
+     * @return object $result
+     */
+    protected function parseObject($template)
+    {
+        $result = new \stdClass();
+
+        foreach ($template as $key => $value) {
+            $parsedKey = $this->parse($key);
+            $parsedValue = $this->getParsedResult($value);
+            $result->$parsedKey = $parsedValue;
+        }
+
+        return $result;
+    }
+
     /**
      * Parse as mustache template
      * 

tests/DataEnricher/Processor/MustacheTest.php

@@ -0,0 +1,89 @@
+<?php
+
+namespace LegalThings\DataEnricher\Processor;
+
+use LegalThings\DataEnricher\Node;
+use LegalThings\DataEnricher\Processor;
+
+/**
+ * @covers LegalThings\DataEnricher\Processor\Mustache
+ */
+class MustacheTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @var Processor\Mustache;
+     */
+    protected $processor;
+
+    public function setUp()
+    {
+        $this->processor = new Processor\Mustache('<tpl>');
+    }
+
+
+    public function instructionProvider()
+    {
+        return [
+            [
+                'hello {{ name }}',
+                (object)['name' => 'world'],
+                [],
+                'hello world'
+            ],
+            [
+                ['{{ today }}', '{{ tomorrow }}'],
+                (object)['today' => 'monday', 'tomorrow' => 'tuesday'],
+                [],
+                ['monday', 'tuesday']
+            ],
+            [
+                (object)['{{ key }}' => '{{ value }}'],
+                (object)['key' => 'name', 'value' => 'John Doe'],
+                [],
+                (object)['name' => 'John Doe']
+            ],
+            [
+                (object)[
+                    '{{ key }}' => (object)[
+                        '{{ nested_key }}' => '{{ nested_value }}'
+                    ],
+                    'ignore_this' => 'okay'
+                ],
+                (object)['key' => 'organization', 'nested_key' => 'name', 'nested_value' => 'Acme'],
+                [],
+                (object)[
+                    'organization' => (object)[
+                        'name' => 'Acme'
+                    ],
+                    'ignore_this' => 'okay'
+                ]
+            ]
+        ];
+    }
+
+    /**
+     * @dataProvider instructionProvider
+     * 
+     * @param string|object|array $instruction
+     * @param object              $source
+     * @param array|object        $target
+     * @param string|object|array $result
+     */
+    public function testApplyToNode($instruction, $source, $target, $result)
+    {
+        $processor = $this->processor->withSourceAndTarget($source, $target);
+
+        $node = $this->createMock(Node::class);
+
+        $node->expects($this->atLeastOnce())
+            ->method('getInstruction')
+            ->with($processor)
+            ->willReturn($instruction);
+
+        $node->expects($this->atLeastOnce())
+            ->method('setResult')
+            ->with($result);
+
+        $processor->applyToNode($node);
+    }
+}