Version 0.2

README.md

@@ -20,14 +20,15 @@ a `CouldNotRenderExceptionInterface` MUST be thrown.
 
 ### Interfaces
 - [`RendererInterface`] - Represents a renderer, i.e. something that can produce output.
-- [`ContextRendererInterface`] - A renderer that uses context to render.
+- [`TemplateInterface`] - A renderer that uses context to render.
 - [`BlockInterface`] - A renderer that has access to the render context, and is also [stringable].
 - [`RendererAwareInterface`] - Something that exposes a renderer.
 - [`ContextAwareInterface`] - Something that can have a rendering context retrieved.
 - [`BlockAwareInterface`] - Something that can have a block retrieved.
+- [`TemplateAwareInterface`] - Something that can have a template retrieved.
 - [`RendererExceptionInterface`] - An exception that occurs in relation to a renderer, and is aware of it.
 - [`CouldNotRenderExceptionInterface`] - A specialized renderer exception that signals problems during rendering.
-- [`ContextRenderExceptionInterface`] - A specialized "could-not-render" exception that is aware
+- [`TemplateRenderExceptionInterface`] - A specialized "could-not-render" exception that is aware
 of the rendering context.
 
 
@@ -36,11 +37,12 @@ of the rendering context.
 [stringable]:                           https://github.com/Dhii/stringable-interface
 
 [`RendererInterface`]:                  src/RendererInterface.php
-[`ContextRendererInterface`]:           src/ContextRendererInterface.php
+[`TemplateInterface`]:           src/TemplateInterface.php
 [`BlockInterface`]:                     src/BlockInterface.php
 [`RendererAwareInterface`]:             src/RendererAwareInterface.php
 [`ContextAwareInterface`]:              src/ContextAwareInterface.php
 [`BlockAwareInterface`]:                src/BlockAwareInterface.php
+[`TemplateAwareInterface`]:                src/TemplateAwareInterface.php
 [`RendererExceptionInterface`]:         src/Exception/RendererExceptionInterface.php
 [`CouldNotRenderExceptionInterface`]:   src/Exception/CouldNotRenderExceptionInterface.php
-[`ContextRenderExceptionInterface`]:    src/Exception/ContextRenderExceptionInterface.php
+[`TemplateRenderExceptionInterface`]:    src/Exception/ContextRenderExceptionInterface.php

src/Exception/ContextRenderExceptionInterface.php → src/Exception/TemplateRenderExceptionInterface.php

@@ -3,14 +3,14 @@
 namespace Dhii\Output\Exception;
 
 use Dhii\Output\ContextAwareInterface;
-use Dhii\Output\ContextRendererInterface;
+use Dhii\Output\TemplateInterface;
 
 /**
  * An exception that occurs when cannot render with a context.
  *
  * @since 0.1
  */
-interface ContextRenderExceptionInterface extends
+interface TemplateRenderExceptionInterface extends
     CouldNotRenderExceptionInterface,
     ContextAwareInterface
 {
@@ -19,7 +19,7 @@ interface ContextRenderExceptionInterface extends
      *
      * @since 0.1
      * 
-     * @return ContextRendererInterface The renderer.
+     * @return TemplateInterface The renderer.
      */
     public function getRenderer();
 }

src/RendererInterface.php

@@ -2,6 +2,7 @@
 
 namespace Dhii\Output;
 
+use Dhii\Util\String\StringableInterface as Stringable;
 use Dhii\Output\Exception\CouldNotRenderExceptionInterface;
 use Dhii\Output\Exception\RendererExceptionInterface;
 

src/TemplateAwareInterface.php

@@ -0,0 +1,20 @@
+<?php
+
+namespace Dhii\Output;
+
+/**
+ * Something that can have a template retrieved from it.
+ *
+ * @since [*next-version*]
+ */
+interface TemplateAwareInterface
+{
+    /**
+     * Retrieves the template associated with this instance.
+     *
+     * @since [*next-version*]
+     *
+     * @return TemplateInterface|null The template, if any.
+     */
+    public function getTemplate();
+}

src/ContextRendererInterface.php → src/TemplateInterface.php

@@ -3,7 +3,7 @@
 namespace Dhii\Output;
 
 use Dhii\Util\String\StringableInterface as Stringable;
-use Dhii\Output\Exception\ContextRenderExceptionInterface;
+use Dhii\Output\Exception\TemplateRenderExceptionInterface;
 use Dhii\Output\Exception\RendererExceptionInterface;
 
 /**
@@ -15,7 +15,7 @@
  *
  * @since 0.1
  */
-interface ContextRendererInterface extends RendererInterface
+interface TemplateInterface extends RendererInterface
 {
     /**
      * Produce output based on context.
@@ -25,7 +25,7 @@ interface ContextRendererInterface extends RendererInterface
      * @param mixed|null $context The context;
      *                            something that can provide more information on how to perform rendering.
      *
-     * @throws ContextRenderExceptionInterface If cannot render.
+     * @throws TemplateRenderExceptionInterface If cannot render.
      * @throws RendererExceptionInterface      Any other problem related to the renderer.
      *
      * @return string|Stringable The output.

test/unit/Exception/ContextRenderExceptionInterfaceTest.php → test/unit/Exception/TemplateRenderExceptionInterfaceTest.php

@@ -17,7 +17,7 @@ class ContextRenderExceptionInterfaceTest extends TestCase
      *
      * @since 0.1
      */
-    const TEST_SUBJECT_CLASSNAME = 'Dhii\Output\Exception\ContextRenderExceptionInterface';
+    const TEST_SUBJECT_CLASSNAME = 'Dhii\Output\Exception\TemplateRenderExceptionInterface';
 
     /**
      * Creates a new instance of the test subject.

test/unit/TemplateAwareInterfaceTest.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Dhii\Output\UnitTest;
+
+use Xpmock\TestCase;
+use Dhii\Output\TemplateAwareInterface as TestSubject;
+
+/**
+ * Tests {@see TestSubject}.
+ *
+ * @since [*next-version*]
+ */
+class TemplateAwareInterfaceTest extends TestCase
+{
+    /**
+     * The class name of the test subject.
+     *
+     * @since [*next-version*]
+     */
+    const TEST_SUBJECT_CLASSNAME = 'Dhii\Output\TemplateAwareInterface';
+
+    /**
+     * Creates a new instance of the test subject.
+     *
+     * @since [*next-version*]
+     *
+     * @return TestSubject
+     */
+    public function createInstance()
+    {
+        $mock = $this->mock(static::TEST_SUBJECT_CLASSNAME)
+                     ->getTemplate();
+
+        return $mock->new();
+    }
+
+    /**
+     * Tests whether a valid instance of the test subject can be created.
+     *
+     * @since [*next-version*]
+     */
+    public function testCanBeCreated()
+    {
+        $subject = $this->createInstance();
+
+        $this->assertInstanceOf(
+            static::TEST_SUBJECT_CLASSNAME, $subject,
+            'Could not create a valid instance of the test subject.'
+        );
+    }
+}

test/unit/ContextRendererInterfaceTest.php → test/unit/TemplateInterfaceTest.php

@@ -2,7 +2,7 @@
 
 namespace Dhii\Output\UnitTest;
 
-use Dhii\Output\ContextRendererInterface as TestSubject;
+use Dhii\Output\TemplateInterface as TestSubject;
 use Xpmock\TestCase;
 
 /**
@@ -17,7 +17,7 @@ class ContextRendererInterfaceTest extends TestCase
      *
      * @since 0.1
      */
-    const TEST_SUBJECT_CLASSNAME = 'Dhii\Output\ContextRendererInterface';
+    const TEST_SUBJECT_CLASSNAME = 'Dhii\Output\TemplateInterface';
 
     /**
      * Creates a new instance of the test subject.