Merge pull request #1 from Incenteev/cache

Implement caching of the asset hashes for prod

Author: stof

.travis.yml

@@ -11,11 +11,9 @@ matrix:
   fast_finish: true
   include:
     - php: 7.0
-      env: COMPOSER_FLAGS="--prefer-lowest"SYMFONY_DEPRECATIONS_HELPER=weak
+      env: COMPOSER_FLAGS="--prefer-lowest" SYMFONY_DEPRECATIONS_HELPER=weak
     - php: 7.1
       env: DEPENDENCIES=dev SYMFONY_DEPRECATIONS_HELPER=weak
-    - php: 7.0
-      env: SYMFONY_VERSION=2.8.*
   allow_failures:
     - php: nightly
 
@@ -24,7 +22,6 @@ cache:
     - $HOME/.composer/cache/files
 
 before_install:
-  - if [ "$SYMFONY_VERSION" != "" ]; then composer require "symfony/symfony:${SYMFONY_VERSION}" --no-update; fi;
   - if [ "$DEPENDENCIES" = "dev" ]; then perl -pi -e 's/^}$/,"minimum-stability":"dev"}/' composer.json; fi;
 
 install: composer update $COMPOSER_FLAGS

README.md

@@ -43,21 +43,6 @@ framework:
         version_strategy: incenteev_hashed_asset.strategy
 ```
 
-If you are using Symfony <3.1, this configuration setting is not available.
-Here is the workaround:
-
-```yaml
-# app/config/config.yml
-framework:
-    assets:
-        version: dummy # set a dummy version so that the package does not use the empty version
-
-services:
-    assets._version__default:
-        alias: incenteev_hashed_asset.strategy
-# If you use additional packages, you may need to create additional aliases for other packages than `_default`
-```
-
 ## Advanced configuration
 
 The default configuration should fit common needs, but the bundle exposes

composer.json

@@ -11,10 +11,13 @@
     ],
     "require": {
         "php": "^7.0",
-        "symfony/asset": "^2.8 || ^3.0",
-        "symfony/config": "^2.8 || ^3.0",
-        "symfony/dependency-injection": "^2.8 || ^3.0",
-        "symfony/http-kernel": "^2.8 || ^3.0"
+        "symfony/asset": "^3.2",
+        "symfony/cache": "^3.2",
+        "symfony/config": "^3.2",
+        "symfony/dependency-injection": "^3.2",
+        "symfony/finder": "^3.2",
+        "symfony/framework-bundle": "^3.2",
+        "symfony/http-kernel": "^3.2"
     },
     "require-dev": {
         "symfony/phpunit-bridge": "^3.2"

src/Asset/HashingVersionStrategy.php

@@ -2,33 +2,28 @@
 
 namespace Incenteev\HashedAssetBundle\Asset;
 
+use Incenteev\HashedAssetBundle\Hashing\AssetHasherInterface;
 use Symfony\Component\Asset\VersionStrategy\VersionStrategyInterface;
 
 class HashingVersionStrategy implements VersionStrategyInterface
 {
-    private $webRoot;
+    private $hasher;
     private $format;
 
-    public function __construct(string $webRoot, string $format = null)
+    public function __construct(AssetHasherInterface $hasher, string $format = null)
     {
         $this->format = $format ?: '%s?%s';
-        $this->webRoot = $webRoot;
+        $this->hasher = $hasher;
     }
 
     public function getVersion($path)
     {
-        $fullPath = $this->webRoot.'/'.ltrim($path, '/');
-
-        if (!is_file($fullPath)) {
-            return '';
-        }
-
-        return substr(sha1_file($fullPath), 0, 7);
+        return $this->hasher->computeHash($path);
     }
 
     public function applyVersion($path)
     {
-        $versionized = sprintf($this->format, ltrim($path, '/'), $this->getVersion($path));
+        $versionized = sprintf($this->format, ltrim($path, '/'), $this->hasher->computeHash($path));
 
         if ($path && '/' === $path[0]) {
             return '/'.$versionized;

src/CacheWarmer/AssetFinder.php

@@ -0,0 +1,27 @@
+<?php
+
+namespace Incenteev\HashedAssetBundle\CacheWarmer;
+
+use Symfony\Component\Finder\Finder;
+use Symfony\Component\Finder\SplFileInfo;
+
+class AssetFinder
+{
+    private $webRoot;
+
+    public function __construct(string $webRoot)
+    {
+        $this->webRoot = $webRoot;
+    }
+
+    public function getAssetPaths(): \Traversable
+    {
+        $finder = (new Finder())->files()
+            ->in($this->webRoot);
+
+        /** @var SplFileInfo $file */
+        foreach ($finder as $file) {
+            yield $file->getRelativePathname();
+        }
+    }
+}

src/CacheWarmer/HashCacheWarmer.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Incenteev\HashedAssetBundle\CacheWarmer;
+
+use Incenteev\HashedAssetBundle\Hashing\AssetHasherInterface;
+use Incenteev\HashedAssetBundle\Hashing\CachedHasher;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\Adapter\AdapterInterface;
+use Symfony\Component\Cache\Adapter\ArrayAdapter;
+use Symfony\Component\Cache\Adapter\PhpArrayAdapter;
+use Symfony\Component\Cache\Adapter\ProxyAdapter;
+use Symfony\Component\HttpKernel\CacheWarmer\CacheWarmerInterface;
+
+final class HashCacheWarmer implements CacheWarmerInterface
+{
+    private $assetFinder;
+    private $cacheFile;
+    private $hasher;
+    private $fallbackPool;
+
+    public function __construct(AssetFinder $assetFinder, string $cacheFile, AssetHasherInterface $hasher, CacheItemPoolInterface $fallbackPool)
+    {
+        $this->assetFinder = $assetFinder;
+        $this->cacheFile = $cacheFile;
+        $this->hasher = $hasher;
+
+        if (!$fallbackPool instanceof AdapterInterface) {
+            $fallbackPool = new ProxyAdapter($fallbackPool);
+        }
+
+        $this->fallbackPool = $fallbackPool;
+    }
+
+    public function warmUp($cacheDir)
+    {
+        $phpArrayPool = new PhpArrayAdapter($this->cacheFile, $this->fallbackPool);
+        $arrayPool = new ArrayAdapter(0, false);
+
+        $hasher = new CachedHasher($this->hasher, $arrayPool);
+
+        foreach ($this->assetFinder->getAssetPaths() as $path) {
+            $hasher->computeHash($path);
+        }
+
+        $values = $arrayPool->getValues();
+        $phpArrayPool->warmUp($values);
+
+        foreach ($values as $k => $v) {
+            $item = $this->fallbackPool->getItem($k);
+            $this->fallbackPool->saveDeferred($item->set($v));
+        }
+        $this->fallbackPool->commit();
+    }
+
+    public function isOptional()
+    {
+        return true;
+    }
+}

src/DependencyInjection/IncenteevHashedAssetExtension.php

@@ -17,8 +17,17 @@ protected function loadInternal(array $config, ContainerBuilder $container)
         $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
         $loader->load('services.xml');
 
+        $container->getDefinition('incenteev_hashed_asset.file_hasher')
+            ->replaceArgument(0, $config['web_root']);
+
         $container->getDefinition('incenteev_hashed_asset.strategy')
-            ->replaceArgument(0, $config['web_root'])
             ->replaceArgument(1, $config['version_format']);
+
+        if (!$container->getParameter('kernel.debug')) {
+            $loader->load('cache.xml');
+
+            $container->getDefinition('incenteev_hashed_asset.asset_finder')
+                ->replaceArgument(0, $config['web_root']);
+        }
     }
 }

src/Hashing/AssetHasherInterface.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Incenteev\HashedAssetBundle\Hashing;
+
+interface AssetHasherInterface
+{
+    public function computeHash(string $path): string;
+}

src/Hashing/CachedHasher.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace Incenteev\HashedAssetBundle\Hashing;
+
+use Psr\Cache\CacheItemPoolInterface;
+
+final class CachedHasher implements AssetHasherInterface
+{
+    private $hasher;
+    private $cache;
+
+    public function __construct(AssetHasherInterface $hasher, CacheItemPoolInterface $cache)
+    {
+        $this->hasher = $hasher;
+        $this->cache = $cache;
+    }
+
+    public function computeHash(string $path): string
+    {
+        // The hashing implementation does not care about leading slashes in the path, so share cache keys for them
+        $item = $this->cache->getItem(base64_encode(ltrim($path, '/')));
+
+        if ($item->isHit()) {
+            return $item->get();
+        }
+
+        $hash = $this->hasher->computeHash($path);
+
+        $item->set($hash);
+        $this->cache->save($item);
+
+        return $hash;
+    }
+}

src/Hashing/FileHasher.php

@@ -0,0 +1,23 @@
+<?php
+
+namespace Incenteev\HashedAssetBundle\Hashing;
+
+final class FileHasher implements AssetHasherInterface
+{
+    private $webRoot;
+
+    public function __construct(string $webRoot)
+    {
+        $this->webRoot = $webRoot;
+    }
+    public function computeHash(string $path): string
+    {
+        $fullPath = $this->webRoot.'/'.ltrim($path, '/');
+
+        if (!is_file($fullPath)) {
+            return '';
+        }
+
+        return substr(sha1_file($fullPath), 0, 7);
+    }
+}