Added a TagHeaderFormatter that limits the header values from another formatter to a given size

Author: Toflar

src/Exception/InvalidTagException.php

@@ -12,7 +12,7 @@
 namespace FOS\HttpCache\Exception;
 
 /**
- * Thrown during tagging with an empty value.
+ * Thrown during tagging with an invalid value.
  */
 class InvalidTagException extends \InvalidArgumentException implements HttpCacheException
 {

src/TagHeaderFormatter/MaxHeaderValueLengthFormatter.php

@@ -0,0 +1,119 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache package.
+ *
+ * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace FOS\HttpCache\TagHeaderFormatter;
+
+use FOS\HttpCache\Exception\InvalidTagException;
+
+/**
+ * A header formatter that splits the value(s) from a given
+ * other header formatter (e.g. the CommaSeparatedTagHeaderFormatter)
+ * into multiple headers making sure none of the header values
+ * exceeds the configured limit
+ *
+ * @author Yanick Witschi <[email protected]>
+ */
+class MaxHeaderValueLengthFormatter implements TagHeaderFormatter
+{
+    /**
+     * @var TagHeaderFormatter
+     */
+    private $inner;
+
+    /**
+     * @var int
+     */
+    private $maxHeaderValueLength;
+
+    /**
+     * The default value of the maximum header length is 4096 because most
+     * servers limit header values to 4kb.
+     * HTTP messages cannot carry characters outside the ISO-8859-1 standard so they all
+     * use up just one byte.
+     *
+     * @param TagHeaderFormatter $inner
+     * @param int $maxHeaderValueLength
+     */
+    public function __construct(TagHeaderFormatter $inner, $maxHeaderValueLength = 4096)
+    {
+        $this->inner = $inner;
+        $this->maxHeaderValueLength = $maxHeaderValueLength;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTagsHeaderName()
+    {
+        $this->inner->getTagsHeaderName();
+    }
+
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getTagsHeaderValue(array $tags)
+    {
+        $values = (array) $this->inner->getTagsHeaderValue($tags);
+        $newValues = [[]];
+
+        foreach ($values as $value) {
+            if ($this->isHeaderTooLong($value)) {
+                list ($firstTags, $secondTags) = $this->splitTagsInHalves($tags);
+
+                $newValues[] = (array) $this->getTagsHeaderValue($firstTags);
+                $newValues[] = (array) $this->getTagsHeaderValue($secondTags);
+            } else {
+                $newValues[] = [$value];
+            }
+        }
+
+        $newValues = array_merge(...$newValues);
+
+        if (1 === count($newValues)) {
+            return $newValues[0];
+        }
+
+        return $newValues;
+    }
+
+    /**
+     * @param string $value
+     *
+     * @return bool
+     */
+    private function isHeaderTooLong($value)
+    {
+        return mb_strlen($value) > $this->maxHeaderValueLength;
+    }
+
+    /**
+     * Split an array of tags in two more or less equal sized arrays.
+     *
+     * @param array $tags
+     *
+     * @return array
+     * @throws InvalidTagException
+     */
+    private function splitTagsInHalves(array $tags) {
+
+        if (1 === count($tags)) {
+            throw new InvalidTagException(sprintf(
+                'You configured a maximum header length of %d but the tag "%s" is too long.',
+                $this->maxHeaderValueLength,
+                $tags[0]
+            ));
+        }
+
+        $size = ceil(count($tags) / 2);
+        return array_chunk($tags, $size);
+    }
+}

src/TagHeaderFormatter/TagHeaderFormatter.php

@@ -39,7 +39,7 @@ public function getTagsHeaderName();
      *
      * @param array $tags
      *
-     * @return string
+     * @return string|string[]
      */
     public function getTagsHeaderValue(array $tags);
 }

tests/Unit/TagHeaderFormatter/MaxHeaderValueLengthFormatterTest.php

@@ -0,0 +1,73 @@
+<?php
+
+/*
+ * This file is part of the FOSHttpCache package.
+ *
+ * (c) FriendsOfSymfony <http://friendsofsymfony.github.com/>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace FOS\HttpCache\Tests\Unit\TagHeaderFormatter;
+
+
+use FOS\HttpCache\Exception\InvalidTagException;
+use FOS\HttpCache\TagHeaderFormatter\CommaSeparatedTagHeaderFormatter;
+use FOS\HttpCache\TagHeaderFormatter\MaxHeaderValueLengthFormatter;
+use PHPUnit\Framework\TestCase;
+
+class MaxHeaderValueLengthFormatterTest extends TestCase
+{
+    public function testNotTooLong()
+    {
+        $formatter = $this->getFormatter(50);
+        $tags = ['foo', 'bar', 'baz'];
+
+        $this->assertSame('foo,bar,baz', $formatter->getTagsHeaderValue($tags));
+    }
+
+    /**
+     * @dataProvider tooLongProvider
+     * @param int $maxLength
+     * @param array $tags
+     * @param mixed $expectedHeaderValue
+     */
+    public function testTooLong($maxLength, $tags, $expectedHeaderValue)
+    {
+        $formatter = $this->getFormatter($maxLength);
+        $this->assertSame($expectedHeaderValue, $formatter->getTagsHeaderValue($tags));
+    }
+
+    public function testOneTagExceedsMaximum()
+    {
+        $this->expectException(InvalidTagException::class);
+        $this->expectExceptionMessage('You configured a maximum header length of 3 but the tag "way-too-long-tag" is too long.');
+
+        $formatter = $this->getFormatter(3);
+        $formatter->getTagsHeaderValue(['way-too-long-tag']);
+    }
+
+    /**
+     * @param int $maxLength
+     *
+     * @return MaxHeaderValueLengthFormatter
+     */
+    private function getFormatter($maxLength)
+    {
+        return new MaxHeaderValueLengthFormatter(
+            new CommaSeparatedTagHeaderFormatter(),
+            $maxLength
+        );
+    }
+
+    public function tooLongProvider()
+    {
+        return [
+            [3, ['foo', 'bar', 'baz'], ['foo', 'bar', 'baz']],
+            [6, ['foo', 'bar', 'baz'], ['foo', 'bar', 'baz']], // with the , that equals 7
+            [7, ['foo', 'bar', 'baz'], ['foo,bar', 'baz']],
+            [50, ['foo', 'bar', 'baz'], 'foo,bar,baz'], // long enough, must not be an array
+        ];
+    }
+}