Use single property for caching

Author: Riimu

CHANGELOG.md

@@ -5,7 +5,13 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+
+## [0.3.0] - 2018-10-17
+### Added
+- The `Container::getCacheFile()` now accepts an optional callable parameter for encoding values.
+
 ### Changed
+- The container now stores cached information only in a single property
 - Improved tests and some failure conditions with mutation testing
 
 ## [0.2.1] - 2018-07-18
@@ -26,6 +32,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Added
 - Initial development release
 
-[Unreleased]: https://github.com/simply-framework/container/compare/v0.2.1...HEAD
+[Unreleased]: https://github.com/simply-framework/container/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/simply-framework/container/compare/v0.2.1...v0.3.0
 [0.2.1]: https://github.com/simply-framework/container/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/simply-framework/container/compare/v0.1.0...v0.2.0

composer.json

@@ -25,7 +25,7 @@
     "psr/container-implementation": "^1.0"
   },
   "require-dev": {
-    "phpunit/phpunit": "^7.3",
+    "phpunit/phpunit": "^7.4",
     "riimu/php-cs-fixer-config": "^0.1.1",
     "riimu/sami-config": "^0.1.0"
   },

src/Container.php

@@ -19,11 +19,8 @@
  */
 class Container implements ContainerInterface, \ArrayAccess
 {
-    /** @var string[] Lists the names of classes used by different container entries */
-    protected $types = [];
-
-    /** @var array[] Cached container entry parameters for initializing the entries */
-    protected $parameters = [];
+    /** @var array[] Information about cached container entries */
+    protected $entries = [];
 
     /** @var EntryInterface[] Cached entries used to resolve values */
     private $entryCache;
@@ -55,27 +52,27 @@ public function setDelegate(ContainerInterface $delegate): void
 
     /**
      * Returns PHP code for a cached container that can be loaded quickly on runtime.
+     * @param callable $encoder Encoder to turn the cached entry data into PHP code or null for default
      * @return string The PHP code for the cached container
      * @throws ContainerException If the container contains entries that cannot be cached
      */
-    public function getCacheFile(): string
+    public function getCacheFile(callable $encoder = null): string
     {
-        $this->loadCacheParameters();
+        if (\is_null($encoder)) {
+            $encoder = function ($value): string {
+                return var_export($value, true);
+            };
+        }
 
-        ksort($this->types);
-        ksort($this->parameters);
+        $this->loadCacheParameters();
+        ksort($this->entries);
+        $encoded = $encoder($this->entries);
 
-        $template = <<<'TEMPLATE'
+        return <<<TEMPLATE
 <?php return new class extends \Simply\Container\Container {
-    protected $types = ['TYPES'];
-    protected $parameters = ['PARAMETERS'];
+    protected \$entries = $encoded;
 };
 TEMPLATE;
-
-        return strtr($template, [
-            "['TYPES']" => var_export($this->types, true),
-            "['PARAMETERS']" => var_export($this->parameters, true),
-        ]);
     }
 
     /**
@@ -84,7 +81,7 @@ public function getCacheFile(): string
      */
     private function loadCacheParameters(): void
     {
-        foreach ($this->types as $id => $class) {
+        foreach ($this->entries as $id => $data) {
             if (!isset($this->entryCache[$id])) {
                 continue;
             }
@@ -95,7 +92,7 @@ private function loadCacheParameters(): void
                 throw new ContainerException("Unable to cache entry '$id', the cache parameters are not static");
             }
 
-            $this->parameters[$id] = $parameters;
+            $this->entries[$id] = [\get_class($this->entryCache[$id]), $parameters];
         }
     }
 
@@ -127,11 +124,11 @@ private function isConstantValue($value): bool
      */
     public function addEntry(string $id, EntryInterface $type): void
     {
-        if (isset($this->types[$id])) {
+        if (isset($this->entries[$id])) {
             throw new ContainerException("Entry for identifier '$id' already exists");
         }
 
-        $this->types[$id] = \get_class($type);
+        $this->entries[$id] = [];
         $this->entryCache[$id] = $type;
     }
 
@@ -165,20 +162,21 @@ public function get($id)
      * @param string $id The entry identifier to look for
      * @return EntryInterface The container entry for the given identifier
      * @throws NotFoundExceptionInterface If the entry cannot be found
+     * @throws ContainerException If the cached type is not a valid entry type
      */
     private function getEntry(string $id): EntryInterface
     {
         if (isset($this->entryCache[$id])) {
             return $this->entryCache[$id];
         }
 
-        if (isset($this->types[$id])) {
-            /** @var EntryInterface $entryClass */
-            $entryClass = $this->types[$id];
-            return $entryClass::createFromCacheParameters($this->parameters[$id]);
+        if (!isset($this->entries[$id])) {
+            throw new NotFoundException("No entry was found for the identifier '$id'");
         }
 
-        throw new NotFoundException("No entry was found for the identifier '$id'");
+        /** @var EntryInterface $class */
+        [$class, $parameters] = $this->entries[$id];
+        return $class::createFromCacheParameters($parameters);
     }
 
     /**
@@ -188,7 +186,7 @@ private function getEntry(string $id): EntryInterface
      */
     public function has($id): bool
     {
-        return isset($this->types[$id]);
+        return isset($this->entries[$id]);
     }
 
     /**
@@ -231,8 +229,7 @@ public function offsetSet($offset, $value): void
     public function offsetUnset($offset): void
     {
         unset(
-            $this->types[$offset],
-            $this->parameters[$offset],
+            $this->entries[$offset],
             $this->entryCache[$offset],
             $this->valueCache[$offset]
         );

tests/tests/ContainerTest.php

@@ -194,13 +194,10 @@ public function testSortingOnCache()
             'a' => 'a_value',
         ]);
 
-        $types = new \ReflectionProperty($container, 'types');
-        $types->setAccessible(true);
-        $parameters = new \ReflectionProperty($container, 'parameters');
-        $parameters->setAccessible(true);
+        $entries = new \ReflectionProperty($container, 'entries');
+        $entries->setAccessible(true);
 
-        $this->assertSame(['a', 'b', 'c'], array_keys($types->getValue($container)));
-        $this->assertSame(['a', 'b', 'c'], array_keys($parameters->getValue($container)));
+        $this->assertSame(['a', 'b', 'c'], array_keys($entries->getValue($container)));
     }
 
     private function withContainer(array $values, \Closure $suite)