introduce resolveOnly to not always merge all defaults

Author: Litarnus

src/Options.php

@@ -58,7 +58,7 @@ public function __construct(array $options = [])
 
         $this->configureOptions($this->resolver);
 
-        $this->options = $this->resolveWithLogger($options);
+        $this->options = $this->resolver->resolve($options, $this->getLoggerOrNullLogger($options));
     }
 
     /**
@@ -268,10 +268,15 @@ public function getLogger(): ?LoggerInterface
 
     /**
      * Helper to always get a logger instance even if it was not set.
+     *
+     * it will check for a logger using the following order:
+     * 1. the passed `$options`
+     * 2. already configured `logger` option
+     * 3. `NullLogger` as fallback
      */
-    public function getLoggerOrNullLogger(): LoggerInterface
+    public function getLoggerOrNullLogger(array $options = []): LoggerInterface
     {
-        return $this->getLogger() ?? new NullLogger();
+        return $options['logger'] ?? $this->getLogger() ?? new NullLogger();
     }
 
     /**
@@ -1167,24 +1172,6 @@ private function validateContextLinesOption(?int $contextLines): bool
         return $contextLines === null || $contextLines >= 0;
     }
 
-    /**
-     * Calls the resolve method of the internal resolver with a logger so that
-     * validation failures can be logged and investigated.
-     *
-     * @param array<string, mixed> $options
-     *
-     * @return array<string, mixed>
-     */
-    private function resolveWithLogger(array $options = []): array
-    {
-        /**
-         * @var LoggerInterface $logger
-         */
-        $logger = $options['logger'] ?? $this->getLoggerOrNullLogger();
-
-        return $this->resolver->resolve($options, $logger);
-    }
-
     /**
      * Merges the passed options with the current options and resolves them.
      * The result is stored back onto the class field.
@@ -1193,9 +1180,9 @@ private function resolveWithLogger(array $options = []): array
      */
     private function updateOptions(array $override = []): self
     {
-        $options = array_merge($this->options, $override);
+        $resolved = $this->resolver->resolveOnly($override, $this->getLoggerOrNullLogger($override));
 
-        $this->options = $this->resolveWithLogger($options);
+        $this->options = array_merge($this->options, $resolved);
 
         return $this;
     }

src/OptionsResolver.php

@@ -109,7 +109,21 @@ public function setNormalizer(string $path, callable $normalizer): void
      */
     public function resolve(array $options = [], ?LoggerInterface $logger = null): array
     {
-        $result = $this->defaults;
+        return array_merge($this->defaults, $this->resolveOnly($options, $logger));
+    }
+
+    /**
+     * Resolves passed options against the defaults but in contrast to {@see self::resolve}, it will not merge
+     * defaults into the result. This means that the returning array will always be equal or smaller than
+     * the input array.
+     *
+     * @param array<string, mixed> $options
+     *
+     * @return array<string, mixed>
+     */
+    public function resolveOnly(array $options = [], ?LoggerInterface $logger = null): array
+    {
+        $result = [];
 
         foreach ($options as $option => $value) {
             if (!\array_key_exists($option, $this->defaults)) {
@@ -124,6 +138,7 @@ public function resolve(array $options = [], ?LoggerInterface $logger = null): a
                 if ($logger !== null) {
                     $logger->debug(\sprintf('Invalid value for option "%s". Using default value.', $option));
                 }
+                $result[$option] = $this->defaults[$option];
                 continue;
             }
 

tests/OptionResolverTest.php

@@ -98,6 +98,17 @@ public function testNormalizers(array $defaults, array $options, array $normaliz
         $this->assertEquals($result, $expectedResult);
     }
 
+    /**
+     * @dataProvider resolveOnlyTestProvider
+     */
+    public function testResolveOnly(array $defaults, array $options, array $expectedResult): void
+    {
+        $resolver = new OptionsResolver();
+        $resolver->setDefaults($defaults);
+        $result = $resolver->resolveOnly($options);
+        $this->assertEquals($expectedResult, $result);
+    }
+
     public function testNormalizerReturnsInvalidType()
     {
         $resolver = new OptionsResolver();
@@ -242,7 +253,30 @@ public function allowedValueTestProvider(): \Generator
         ];
     }
 
-    public function normalizerTestProvider()
+    public function resolveOnlyTestProvider(): \Generator
+    {
+        $defaults = ['foo' => 'bar', 'test' => 'example', 'a' => 'b'];
+
+        yield 'Result only contains passed values' => [
+            $defaults,
+            ['foo' => 'test'],
+            ['foo' => 'test'],
+        ];
+
+        yield 'Result does not contain invalid key' => [
+            $defaults,
+            ['foo' => 'test', 'example' => 'abcde'],
+            ['foo' => 'test'],
+        ];
+
+        yield 'Empty input returns empty output' => [
+            $defaults,
+            [],
+            [],
+        ];
+    }
+
+    public function normalizerTestProvider(): \Generator
     {
         yield 'Normalizes successful' => [
             ['a' => 'b'],
@@ -254,21 +288,9 @@ public function normalizerTestProvider()
         ];
     }
 
-    public function testDebugLogsProduced()
+    public function testDebugLogsProduced(): void
     {
-        $logger = new class extends AbstractLogger {
-            private $logs = [];
-
-            public function log($level, $message, array $context = []): void
-            {
-                $this->logs[] = $message;
-            }
-
-            public function getLogs(): array
-            {
-                return $this->logs;
-            }
-        };
+        $logger = new TestLogger();
         $resolver = new OptionsResolver();
         $resolver->setAllowedValues('test', ['foo']);
         $resolver->setDefaults([
@@ -282,4 +304,35 @@ public function getLogs(): array
         $this->assertCount(2, $logger->getLogs());
         $this->assertEquals('Invalid value for option "test". Using default value.', $logger->getLogs()[1]);
     }
+
+    public function testDebugLogsProducedForResolveOnly(): void
+    {
+        $logger = new TestLogger();
+        $resolver = new OptionsResolver();
+        $resolver->setAllowedValues('test', ['foo']);
+        $resolver->setDefaults(['test' => 'foo', 'abc' => 'def', 'bar' => 'baz']);
+
+        $resolver->resolveOnly(['example' => 'test'], $logger);
+        $this->assertCount(1, $logger->getLogs());
+        $this->assertEquals('Option "example" does not exist and will be ignored', $logger->getLogs()[0]);
+
+        $resolver->resolveOnly(['test' => 'abc'], $logger);
+        $this->assertCount(2, $logger->getLogs());
+        $this->assertEquals('Invalid value for option "test". Using default value.', $logger->getLogs()[1]);
+    }
+}
+
+class TestLogger extends AbstractLogger
+{
+    private $logs = [];
+
+    public function log($level, $message, array $context = []): void
+    {
+        $this->logs[] = $message;
+    }
+
+    public function getLogs(): array
+    {
+        return $this->logs;
+    }
 }