New PR for the cache function

src/Configuration.php

@@ -49,6 +49,22 @@ class Configuration
      **/
     private $xpath;
 
+    /**
+     * Boolean indicating if configuration results should be cached
+     *
+     * @access private
+     * @var boolean
+     **/
+    private $useCaching;
+
+    /**
+     * The cache (used only when caching is enabled)
+     *
+     * @access private
+     * @var array
+     **/
+    private $cache = ['alwaysArray' => [], 'optionalArray' => []];
+
     /**
      * __construct
      *
@@ -57,16 +73,19 @@ class Configuration
      * @access public
      * @param  string|null $defaultConfigurationFile Location of the default XML configuration file
      * @param  string|null $xsdSchemaFile            Location of the XSD file for configuration validation. Optional so that a default schema can also be provided by a subclass.
+     * @param  boolean     $useCaching               Boolean indicating if caching should be used
      * @return void
      **/
-    public function __construct($defaultConfigurationFile = null, $xsdSchemaFile = null)
+    public function __construct($defaultConfigurationFile = null, $xsdSchemaFile = null, $useCaching = true)
     {
         if (is_file($defaultConfigurationFile)) {
             $this->defaultConfigurationFile = $defaultConfigurationFile;
         }
         if (is_file($xsdSchemaFile)) {
             $this->xsdSchemaFile = $xsdSchemaFile;
         }
+
+        $this->useCaching = $useCaching;
     }
 
     /**
@@ -136,6 +155,35 @@ public function getDOMDocument()
      * @return array|null
      **/
     public function get($xpathExpression, $alwaysReturnArray = false)
+    {
+        if ($this->useCaching === true && $alwaysReturnArray === true) {
+            if (!array_key_exists($xpathExpression, $this->cache['alwaysArray'])) {
+                $this->cache['alwaysArray'][$xpathExpression] = $this->getFromDOMDocument($xpathExpression, $alwaysReturnArray);
+            }
+
+            return $this->cache['alwaysArray'][$xpathExpression];
+        } elseif ($this->useCaching === true) {
+            if (!array_key_exists($xpathExpression, $this->cache['optionalArray'])) {
+                $this->cache['optionalArray'][$xpathExpression] = $this->getFromDOMDocument($xpathExpression, $alwaysReturnArray);
+            }
+
+            return $this->cache['optionalArray'][$xpathExpression];
+        } else {
+            return $this->getFromDOMDocument($xpathExpression, $alwaysReturnArray);
+        }
+    }
+
+    /**
+     * getFromDOMDocument
+     *
+     * Returns an array representation of the XML nodes from the requested $xpathExpression in the loaded dom
+     *
+     * @access private
+     * @param  string     $xpathExpression
+     * @param  boolean    $alwaysReturnArray
+     * @return array|null
+     **/
+    private function getFromDOMDocument($xpathExpression, $alwaysReturnArray = false)
     {
         if (($this->xpath instanceof DOMXPath) === false) {
             return;
@@ -206,6 +254,7 @@ private function validateConfiguration(DOMDocument $dom)
                 $this->xpath = new DOMXPath($dom);
 
                 $this->cleanupDOMDocument();
+                $this->cache = ['alwaysArray' => [], 'optionalArray' => []]; // reset cache for the new dom
             } else {
                 $this->triggerHumanReadableErrors();
                 if (realpath(parse_url($dom->documentURI, PHP_URL_PATH)) !== realpath($this->defaultConfigurationFile)) {

tests/ConfigurationTest.php

@@ -71,9 +71,9 @@ public function testLoadInvalidConfigurationTriggersErrors()
     }
 
     /**
-     * testGetWithDefaultConfiguration
+     * testGetWithDefaultConfigurationWithoutCache
      *
-     * Tests if Configuration::get returns the expected result from the default configuration
+     * Tests if Configuration::get returns the expected result from the default configuration (without caching)
      *
      * @dataProvider provideTestGetWithDefaultConfiguration
      *
@@ -83,7 +83,29 @@ public function testLoadInvalidConfigurationTriggersErrors()
      * @param  array|string $expectedResult
      * @return void
      **/
-    public function testGetWithDefaultConfiguration($xpathExpression, $alwaysReturnArray, $expectedResult)
+    public function testGetWithDefaultConfigurationWithoutCache($xpathExpression, $alwaysReturnArray, $expectedResult)
+    {
+        $configuration = new Configuration(__DIR__ . '/Resources/configuration/default.xml', __DIR__ . '/Resources/xsd/default.xsd', false);
+        $configuration->loadConfiguration(null);
+
+        $this->assertEquals($expectedResult, $configuration->get($xpathExpression, $alwaysReturnArray));
+        $this->assertSame($expectedResult, $configuration->get($xpathExpression, $alwaysReturnArray));
+    }
+
+    /**
+     * testGetWithDefaultConfigurationWithCache
+     *
+     * Tests if Configuration::get returns the expected result from the default configuration (with caching)
+     *
+     * @dataProvider provideTestGetWithDefaultConfiguration
+     *
+     * @access public
+     * @param  string       $xpathExpression
+     * @param  boolean      $alwaysReturnArray
+     * @param  array|string $expectedResult
+     * @return void
+     **/
+    public function testGetWithDefaultConfigurationWithCache($xpathExpression, $alwaysReturnArray, $expectedResult)
     {
         $configuration = new Configuration(__DIR__ . '/Resources/configuration/default.xml', __DIR__ . '/Resources/xsd/default.xsd');
         $configuration->loadConfiguration(null);
@@ -92,13 +114,31 @@ public function testGetWithDefaultConfiguration($xpathExpression, $alwaysReturnA
         $this->assertSame($expectedResult, $configuration->get($xpathExpression, $alwaysReturnArray));
     }
 
+    /**
+     * testCachedResultsAreValidWhenLoadingNewFileInRuntime
+     *
+     * Confirms that the cache reads from the currenlty loaded configuration
+     *
+     * @access public
+     * @return void
+     **/
+    public function testCachedResultsAreValidWhenLoadingNewFileInRuntime()
+    {
+        $configuration = new Configuration(__DIR__ . '/Resources/configuration/default.xml', __DIR__ . '/Resources/xsd/default.xsd');
+        $configuration->loadConfiguration(null);
+        $this->assertEquals('Text content', $configuration->get('/test/fuzzy'));
+
+        $configuration->loadConfiguration(__DIR__ . '/Resources/configuration/optional.xml');
+        $this->assertEquals('Fuzzy text content', $configuration->get('/test/fuzzy'));
+    }
+
     /**
      * testLoadInvalidConfigurationLoadsDefaultConfigurationAfterTriggeringErrors
      *
      * Tests if loading an invalid configuration loads the default configuration after triggering errors (warnings)
      *
      * @depends testLoadInvalidConfigurationTriggersErrors
-     * @depends testGetWithDefaultConfiguration
+     * @depends testGetWithDefaultConfigurationWithCache
      *
      * @access public
      * @return void
@@ -149,7 +189,7 @@ public function testGetWithoutSchemaDoesNotTriggerAFatalError()
      *
      * Tests if Configuration::getDOMDocument returns the loaded DOMDocument instance
      *
-     * @depends testGetWithDefaultConfiguration
+     * @depends testGetWithDefaultConfigurationWithCache
      *
      * @access public
      * @return void

tests/Resources/configuration/optional.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<test>
+    <!-- Configuration for unit testing -->
+    <foo bar='bar attribute'>
+        <foo bar='more bar attribute'/>
+    </foo>
+    <bar>
+        <fuzz id='fuzzy'/>
+        <fuzz id='very fuzzy'/>
+    </bar>
+    <fuzzy>Fuzzy text content</fuzzy>
+</test>

tests/test_performance_cached_configuration.php

@@ -0,0 +1,35 @@
+<?php
+
+use Nijens\Utilities\Configuration;
+
+/*
+ * POC script to demonstrate caching is usually faster
+ * As it's not always faster, it's not suitable to be tested in a unit test
+ */
+require '../vendor/autoload.php';
+
+foreach ([2, 3] as $count) {
+    $success = 0;
+    for ($i = 0; $i < 100; ++$i) {
+        $cached = new Configuration(__DIR__ . '/Resources/configuration/default.xml', __DIR__ . '/Resources/xsd/default.xsd');
+        $cached->loadConfiguration(null);
+        $notCached = new Configuration(__DIR__ . '/Resources/configuration/default.xml', __DIR__ . '/Resources/xsd/default.xsd', false);
+        $notCached->loadConfiguration(null);
+        $cachedStart = microtime(true);
+        for ($j = 0; $j < $count; ++$j) {
+            $cached->get('/test/foo');
+        }
+        $cachedTime = microtime(true) - $cachedStart;
+
+        $notCachedStart = microtime(true);
+        for ($j = 0; $j < $count; ++$j) {
+            $notCached->get('/test/foo');
+        }
+        $notCachedTime = microtime(true) - $notCachedStart;
+
+        if ($notCachedTime > $cachedTime) {
+            ++$success;
+        }
+    }
+    echo "Cached was fastest {$success} times out of 100 on {$count} calls\n";
+}