Redesigned module architecture

Module.php

@@ -70,7 +70,8 @@ public function onBootstrap(EventInterface $e)
         $em  = $app->getEventManager();
         $sm  = $app->getServiceManager();
 
-        $listener = new Listener\Cache($sm);
-        $listener->attach($em);
+        $listener = $sm->get('CacheListener');
+
+        $em->attach($listener);
     }
 }

config/module.config.php

@@ -1,9 +1,18 @@
 <?php
 
+namespace SlmCache;
+
 return array(
     'slm_cache' => array(
         'cache'  => null,
         'routes' => array(
         ),
     ),
+
+    'service_manager' => array(
+        'factories' => array(
+            'CacheService' => 'SlmCache\Factory\ServiceFactory',
+            'CacheListener' => 'SlmCache\Factory\ListenerFactory',
+        ),
+    ),
 );

src/SlmCache/Factory/ListenerFactory.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace SlmCache\Factory;
+
+use SlmCache\Listener\CacheListener;
+
+use Zend\ServiceManager\FactoryInterface;
+use Zend\ServiceManager\ServiceLocatorInterface;
+
+class ListenerFactory implements FactoryInterface
+{
+    /**
+     * Create service
+     *
+     * @param ServiceLocatorInterface $serviceLocator
+     * @return mixed
+     */
+    public function createService(ServiceLocatorInterface $serviceLocator)
+    {
+        return new CacheListener($serviceLocator->get('CacheService'));
+    }
+
+}

src/SlmCache/Factory/ServiceFactory.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace SlmCache\Factory;
+
+use SlmCache\Service\CacheService;
+
+use Zend\ServiceManager\FactoryInterface;
+use Zend\ServiceManager\ServiceLocatorInterface;
+
+class ServiceFactory implements FactoryInterface
+{
+    /**
+     * Create service
+     *
+     * @param ServiceLocatorInterface $serviceLocator
+     * @return mixed
+     */
+    public function createService(ServiceLocatorInterface $serviceLocator)
+    {
+        return new CacheService($serviceLocator);
+    }
+
+}

src/SlmCache/Listener/CacheListener.php

@@ -0,0 +1,78 @@
+<?php
+/**
+ * Copyright (c) 2013 Jurian Sluiman.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in
+ *     the documentation and/or other materials provided with the
+ *     distribution.
+ *
+ *   * Neither the names of the copyright holders nor the names of the
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * @author      Jurian Sluiman <[email protected]>
+ * @copyright   2013 Jurian Sluiman.
+ * @license     http://www.opensource.org/licenses/bsd-license.php  BSD License
+ * @link        http://juriansluiman.nl
+ */
+
+namespace SlmCache\Listener;
+
+use SlmCache\Service\CacheService;
+
+use Zend\EventManager\AbstractListenerAggregate;
+use Zend\EventManager\EventManagerInterface;
+use Zend\Mvc\MvcEvent;
+use Zend\ServiceManager\ServiceLocatorInterface;
+
+class CacheListener extends AbstractListenerAggregate
+{
+    protected $cacheService;
+
+    public function __construct(CacheService $cacheService)
+    {
+        $this->cacheService = $cacheService;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function attach(EventManagerInterface $events)
+    {
+        $events->attach(MvcEvent::EVENT_ROUTE, array($this, 'onRoute'), -100);
+        $events->attach(MvcEvent::EVENT_FINISH, array($this, 'onFinish'), 100);
+    }
+
+    public function onRoute(MvcEvent $e)
+    {
+        $this->cacheService->matchRoute($e);
+    }
+
+    public function onFinish(MvcEvent $e)
+    {
+        $this->cacheService->saveRoute($e);
+    }
+
+}

src/SlmCache/Listener/Cache.php → src/SlmCache/Service/CacheService.php

@@ -38,42 +38,42 @@
  * @link        http://juriansluiman.nl
  */
 
-namespace SlmCache\Listener;
+namespace SlmCache\Service;
 
-use Zend\EventManager\AbstractListenerAggregate;
-use Zend\EventManager\EventManagerInterface;
+use Zend\ServiceManager\ServiceLocatorInterface;
+use Zend\ServiceManager\ServiceLocatorAwareInterface;
 use Zend\Mvc\MvcEvent;
 use Zend\Mvc\Router\RouteMatch;
-use Zend\Http\Response;
-use Zend\ServiceManager\ServiceLocatorInterface;
 use Zend\Cache\StorageFactory;
 use Zend\Cache\Storage\StorageInterface;
 
-class Cache extends AbstractListenerAggregate
+class CacheService implements ServiceLocatorAwareInterface
 {
-    protected $cache_prefix = 'slm_cache_';
 
-    protected $match;
     protected $serviceLocator;
 
-    public function __construct(ServiceLocatorInterface $sl)
-    {
-        $this->serviceLocator = $sl;
+    protected $config = array();
 
-        $config = $sl->get('Config');
+    protected $match;
 
-        if (isset($config['slm_cache']['cache_prefix'])) {
-            $this->cache_prefix = $config['slm_cache']['cache_prefix'];
-        }
+    public function __construct(ServiceLocatorInterface $serviceLocator)
+    {
+        $this->serviceLocator = $serviceLocator;
+
+        $this->configSetup();
     }
 
-    /**
-     * {@inheritDoc}
-     */
-    public function attach(EventManagerInterface $events)
+    protected function configSetup()
     {
-        $events->attach(MvcEvent::EVENT_ROUTE, array($this, 'matchRoute'));
-        $events->attach(MvcEvent::EVENT_FINISH, array($this, 'saveRoute'));
+        $config = $this->serviceLocator->get('Config');
+
+        if (!isset($config['slm_cache']['cache_prefix'])) {
+            $config['slm_cache']['cache_prefix'] = 'slm_cache_';
+        }
+
+        // TODO: implement config validation?!
+
+        $this->config = $config;
     }
 
     public function matchRoute(MvcEvent $e)
@@ -201,4 +201,24 @@ protected function getCache(MvcEvent $e)
 
         return $cache;
     }
-}
+    /**
+     * Set service locator
+     *
+     * @param ServiceLocatorInterface $serviceLocator
+     */
+    public function setServiceLocator(ServiceLocatorInterface $serviceLocator)
+    {
+        $this->serviceLocator = $serviceLocator;
+    }
+
+    /**
+     * Get service locator
+     *
+     * @return ServiceLocatorInterface
+     */
+    public function getServiceLocator()
+    {
+        return $this->serviceLocator;
+    }
+
+}

tests/SlmCacheTest/Factory/ListenerFactoryTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace SlmCacheTest\Factory;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+use SlmCache\Service\CacheService;
+use SlmCache\Listener\CacheListener;
+use SlmCache\Factory\CacheFactory;
+
+use Zend\ServiceManager\ServiceManager;
+
+class ListenerFactoryTest extends TestCase
+{
+    public function testSuccessfullyCreateListener()
+    {
+        $sl = new ServiceManager;
+        $sl->setService('Config', array());
+
+        $cacheService = new CacheService($sl);
+
+        $mock = $this->getMock('SlmCache\Factory\ListenerFactory', array('createService'));
+        $mock->expects($this->once())
+            ->method('createService')
+            ->with($this->equalTo($sl))
+            ->will($this->returnValue(new CacheListener($cacheService)));
+
+        $this->assertInstanceOf('SlmCache\Listener\CacheListener', $mock->createService($sl));
+    }
+}

tests/SlmCacheTest/Factory/ServiceFactoryTest.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace SlmCacheTest\Factory;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+use SlmCache\Service\CacheService;
+use SlmCache\Factory\CacheFactory;
+
+use Zend\ServiceManager\ServiceManager;
+
+class ServiceFactoryTest extends TestCase
+{
+    public function testSuccessfullyCreateService()
+    {
+        $sl = new ServiceManager;
+        $sl->setService('Config', array());
+
+        $mock = $this->getMock('SlmCache\Factory\ServiceFactory', array('createService'));
+        $mock->expects($this->once())
+             ->method('createService')
+             ->with($this->equalTo($sl))
+             ->will($this->returnValue(new CacheService($sl)));
+
+        $this->assertInstanceOf('SlmCache\Service\CacheService', $mock->createService($sl));
+    }
+}