vendor/shopware/core/Framework/Feature.php line 203

Open in your IDE?
  1. <?php declare(strict_types=1);
  3. namespace Shopware\Core\Framework;
  5. use PHPUnit\Framework\TestCase;
  6. use Shopware\Core\DevOps\Environment\EnvironmentHelper;
  7. use Shopware\Core\Framework\Log\Package;
  8. use Shopware\Core\Framework\Script\Debugging\ScriptTraces;
  10. #[Package('core')]
  11. class Feature
  12. {
  13.     public const ALL_MAJOR = 'major';
  15.     /**
  16.      * @var array<bool>
  17.      */
  18.     private static array $silent = [];
  20.     /**
  21.      * @var array<string, array{name?: string, default?: boolean, major?: boolean, description?: string}>
  22.      */
  23.     private static array $registeredFeatures = [];
  25.     public static function normalizeName(string $name): string
  26.     {
  27.         /*
  28.          * Examples:
  29.          * - NEXT-1234
  30.          * - FEATURE_NEXT_1234
  31.          * - SAAS_321
  32.          * - v6.5.0.0 => v6_5_0_0
  33.          */
  34.         return \strtoupper(\str_replace(['.', ':', '-'], '_', $name));
  35.     }
  37.     /**
  38.      * @param array<string> $features
  39.      *
  40.      * @return mixed|null
  41.      */
  42.     public static function fake(array $features, \Closure $closure)
  43.     {
  44.         $before = self::$registeredFeatures;
  45.         $serverVarsBackup = $_SERVER;
  47.         $result = null;
  49.         try {
  50.             self::$registeredFeatures = [];
  51.             foreach ($_SERVER as $key => $value) {
  52.                 if (str_starts_with($key, 'v6.') || $key === 'PERFORMANCE_TWEAKS' || str_starts_with($key, 'FEATURE_') || str_starts_with($key, 'V6_')) {
  53.                     // set to false so that $_ENV is not checked
  54.                     $_SERVER[$key] = false;
  55.                 }
  56.             }
  58.             if ($features) {
  59.                 foreach ($features as $feature) {
  60.                     $_SERVER[Feature::normalizeName($feature)] = true;
  61.                 }
  62.             }
  64.             $result = $closure();
  65.         } finally {
  66.             self::$registeredFeatures = $before;
  67.             $_SERVER = $serverVarsBackup;
  68.         }
  70.         return $result;
  71.     }
  73.     public static function isActive(string $feature): bool
  74.     {
  75.         $env = EnvironmentHelper::getVariable('APP_ENV', 'prod');
  76.         $feature = self::normalizeName($feature);
  78.         if (self::$registeredFeatures !== []
  79.             && !isset(self::$registeredFeatures[$feature])
  80.             && $env !== 'prod'
  81.         ) {
  82.             trigger_error('Unknown feature "' . $feature . '"', \E_USER_WARNING);
  83.         }
  85.         $featureAll = EnvironmentHelper::getVariable('FEATURE_ALL', '');
  86.         if (self::isTrue((string) $featureAll) && (self::$registeredFeatures === [] || \array_key_exists($feature, self::$registeredFeatures))) {
  87.             if ($featureAll === Feature::ALL_MAJOR) {
  88.                 return true;
  89.             }
  91.             // return true if it's registered and not a major feature
  92.             if (isset(self::$registeredFeatures[$feature]) && (self::$registeredFeatures[$feature]['major'] ?? false) === false) {
  93.                 return true;
  94.             }
  95.         }
  97.         if (!EnvironmentHelper::hasVariable($feature) && !EnvironmentHelper::hasVariable(\strtolower($feature))) {
  98.             $fallback = self::$registeredFeatures[$feature]['default'] ?? false;
  100.             return (bool) $fallback;
  101.         }
  103.         return self::isTrue(trim((string) EnvironmentHelper::getVariable($feature)));
  104.     }
  106.     public static function ifActive(string $flagName, \Closure $closure): void
  107.     {
  108.         self::isActive($flagName) && $closure();
  109.     }
  111.     public static function callSilentIfInactive(string $flagName, \Closure $closure): void
  112.     {
  113.         $before = isset(self::$silent[$flagName]);
  114.         self::$silent[$flagName] = true;
  116.         try {
  117.             if (!self::isActive($flagName)) {
  118.                 $closure();
  119.             }
  120.         } finally {
  121.             if (!$before) {
  122.                 unset(self::$silent[$flagName]);
  123.             }
  124.         }
  125.     }
  127.     /**
  128.      * @deprecated tag:v6.5.0 - Will be removed, use Feature::isActive instead
  129.      *
  130.      * @param object $object
  131.      * @param mixed[] $arguments
  132.      */
  133.     public static function ifActiveCall(string $flagName, $object, string $methodName, ...$arguments): void
  134.     {
  135.         Feature::triggerDeprecationOrThrow(
  136.             'v6.5.0.0',
  137.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'Feature::isActive')
  138.         );
  139.         $closure = function () use ($object, $methodName, $arguments): void {
  140.             $object->{$methodName}(...$arguments);
  141.         };
  143.         self::ifActive($flagName, \Closure::bind($closure, $object, $object));
  144.     }
  146.     public static function skipTestIfInActive(string $flagName, TestCase $test): void
  147.     {
  148.         if (self::isActive($flagName)) {
  149.             return;
  150.         }
  152.         $test::markTestSkipped('Skipping feature test for flag  "' . $flagName . '"');
  153.     }
  155.     public static function skipTestIfActive(string $flagName, TestCase $test): void
  156.     {
  157.         if (!self::isActive($flagName)) {
  158.             return;
  159.         }
  161.         $test::markTestSkipped('Skipping feature test for flag  "' . $flagName . '"');
  162.     }
  164.     /**
  165.      * Triggers a silenced deprecation notice.
  166.      *
  167.      * @param string $sinceVersion  The version of the package that introduced the deprecation
  168.      * @param string $removeVersion The version of the package when the deprectated code will be removed
  169.      * @param string $message       The message of the deprecation
  170.      * @param mixed  ...$args       Values to insert in the message using printf() formatting
  171.      *
  172.      * @deprecated tag:v6.5.0 - will be removed, use `triggerDeprecationOrThrow` instead
  173.      */
  174.     public static function triggerDeprecated(string $flag, string $sinceVersion, string $removeVersion, string $message, ...$args): void
  175.     {
  176.         self::triggerDeprecationOrThrow(
  177.             'v6.5.0.0',
  178.             self::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'Feature::triggerDeprecationOrThrow()')
  179.         );
  181.         $message = 'Deprecated tag:' . $removeVersion . '(flag:' . $flag . '). ' . $message;
  183.         if (self::isActive($flag) || !self::has($flag)) {
  184.             if (\PHP_SAPI !== 'cli') {
  185.                 ScriptTraces::addDeprecationNotice(sprintf($message, ...$args));
  186.             }
  188.             trigger_deprecation('shopware/core', $sinceVersion, $message, $args);
  189.         }
  190.     }
  192.     public static function throwException(string $flag, string $message, bool $state = true): void
  193.     {
  194.         if (self::isActive($flag) === $state || (self::$registeredFeatures !== [] && !self::has($flag))) {
  195.             throw new \RuntimeException($message);
  196.         }
  198.         if (\PHP_SAPI !== 'cli') {
  199.             ScriptTraces::addDeprecationNotice($message);
  200.         }
  201.     }
  203.     public static function triggerDeprecationOrThrow(string $majorFlag, string $message): void
  204.     {
  205.         if (self::isActive($majorFlag) || (self::$registeredFeatures !== [] && !self::has($majorFlag))) {
  206.             throw new \RuntimeException('Tried to access deprecated functionality: ' . $message);
  207.         }
  209.         if (!isset(self::$silent[$majorFlag]) || !self::$silent[$majorFlag]) {
  210.             if (\PHP_SAPI !== 'cli') {
  211.                 ScriptTraces::addDeprecationNotice($message);
  212.             }
  214.             trigger_deprecation('shopware/core', '', $message);
  215.         }
  216.     }
  218.     public static function deprecatedMethodMessage(string $class, string $method, string $majorVersion, ?string $replacement = null): string
  219.     {
  220.         $message = \sprintf(
  221.             'Method "%s::%s()" is deprecated and will be removed in %s.',
  222.             $class,
  223.             $method,
  224.             $majorVersion
  225.         );
  227.         if ($replacement) {
  228.             $message = \sprintf('%s Use "%s" instead.', $message, $replacement);
  229.         }
  231.         return $message;
  232.     }
  234.     public static function deprecatedClassMessage(string $class, string $majorVersion, ?string $replacement = null): string
  235.     {
  236.         $message = \sprintf(
  237.             'Class "%s" is deprecated and will be removed in %s.',
  238.             $class,
  239.             $majorVersion
  240.         );
  242.         if ($replacement) {
  243.             $message = \sprintf('%s Use "%s" instead.', $message, $replacement);
  244.         }
  246.         return $message;
  247.     }
  249.     public static function has(string $flag): bool
  250.     {
  251.         $flag = self::normalizeName($flag);
  253.         return isset(self::$registeredFeatures[$flag]);
  254.     }
  256.     /**
  257.      * @return array<string, bool>
  258.      */
  259.     public static function getAll(bool $denormalized = true): array
  260.     {
  261.         $resolvedFlags = [];
  263.         foreach (self::$registeredFeatures as $name => $_) {
  264.             $active = self::isActive($name);
  265.             $resolvedFlags[$name] = $active;
  267.             if (!$denormalized) {
  268.                 continue;
  269.             }
  270.             $resolvedFlags[self::denormalize($name)] = $active;
  271.         }
  273.         return $resolvedFlags;
  274.     }
  276.     /**
  277.      * @param array{name?: string, default?: boolean, major?: boolean, description?: string} $metaData
  278.      *
  279.      * @internal
  280.      */
  281.     public static function registerFeature(string $name, array $metaData = []): void
  282.     {
  283.         $name = self::normalizeName($name);
  285.         // merge with existing data
  287.         /** @var array{name?: string, default?: boolean, major?: boolean, description?: string} $metaData */
  288.         $metaData = array_merge(
  289.             self::$registeredFeatures[$name] ?? [],
  290.             $metaData
  291.         );
  293.         // set defaults
  294.         $metaData['major'] = (bool) ($metaData['major'] ?? false);
  295.         $metaData['default'] = (bool) ($metaData['default'] ?? false);
  296.         $metaData['description'] = (string) ($metaData['description'] ?? '');
  298.         self::$registeredFeatures[$name] = $metaData;
  299.     }
  301.     /**
  302.      * @param array<string, array{name?: string, default?: boolean, major?: boolean, description?: string}>|string[] $registeredFeatures
  303.      *
  304.      * @internal
  305.      */
  306.     public static function registerFeatures(iterable $registeredFeatures): void
  307.     {
  308.         foreach ($registeredFeatures as $flag => $data) {
  309.             // old format
  310.             if (\is_string($data)) {
  311.                 $flag = $data;
  312.                 $data = [];
  313.             }
  315.             self::registerFeature($flag, $data);
  316.         }
  317.     }
  319.     /**
  320.      * @internal
  321.      */
  322.     public static function resetRegisteredFeatures(): void
  323.     {
  324.         self::$registeredFeatures = [];
  325.     }
  327.     /**
  328.      * @internal
  329.      *
  330.      * @return array<string, array{'name'?: string, 'default'?: boolean, 'major'?: boolean, 'description'?: string}>
  331.      */
  332.     public static function getRegisteredFeatures(): array
  333.     {
  334.         return self::$registeredFeatures;
  335.     }
  337.     private static function isTrue(string $value): bool
  338.     {
  339.         return $value
  340.             && $value !== 'false'
  341.             && $value !== '0'
  342.             && $value !== '';
  343.     }
  345.     private static function denormalize(string $name): string
  346.     {
  347.         return \strtolower(\str_replace(['_'], '.', $name));
  348.     }
  349. }