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

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\Script\Debugging\ScriptTraces;
  9. class Feature
  10. {
  11.     public const ALL_MAJOR = 'major';
  13.     /**
  14.      * @var array<bool>
  15.      */
  16.     private static array $silent = [];
  18.     /**
  19.      * @var array<string, array{name?: string, default?: boolean, major?: boolean, description?: string}>
  20.      */
  21.     private static array $registeredFeatures = [];
  23.     public static function normalizeName(string $name): string
  24.     {
  25.         /*
  26.          * Examples:
  27.          * - NEXT-1234
  28.          * - FEATURE_NEXT_1234
  29.          * - SAAS_321
  30.          * - v6.5.0.0 => v6_5_0_0
  31.          */
  32.         return \strtoupper(\str_replace(['.', ':', '-'], '_', $name));
  33.     }
  35.     /**
  36.      * @param array<string> $features
  37.      *
  38.      * @return mixed|null
  39.      */
  40.     public static function fake(array $features, \Closure $closure)
  41.     {
  42.         $before = self::$registeredFeatures;
  43.         $serverVarsBackup = $_SERVER;
  45.         $result = null;
  47.         try {
  48.             self::$registeredFeatures = [];
  49.             foreach ($_SERVER as $key => $value) {
  50.                 if (str_starts_with($key, 'v6.') || $key === 'PERFORMANCE_TWEAKS' || str_starts_with($key, 'FEATURE_') || str_starts_with($key, 'V6_')) {
  51.                     // set to false so that $_ENV is not checked
  52.                     $_SERVER[$key] = false;
  53.                 }
  54.             }
  56.             if ($features) {
  57.                 foreach ($features as $feature) {
  58.                     $_SERVER[Feature::normalizeName($feature)] = true;
  59.                 }
  60.             }
  62.             $result = $closure();
  63.         } finally {
  64.             self::$registeredFeatures = $before;
  65.             $_SERVER = $serverVarsBackup;
  66.         }
  68.         return $result;
  69.     }
  71.     public static function isActive(string $feature): bool
  72.     {
  73.         $env = EnvironmentHelper::getVariable('APP_ENV', 'prod');
  74.         $feature = self::normalizeName($feature);
  76.         if (self::$registeredFeatures !== []
  77.             && !isset(self::$registeredFeatures[$feature])
  78.             && $env !== 'prod'
  79.         ) {
  80.             trigger_error('Unknown feature "' . $feature . '"', \E_USER_WARNING);
  81.         }
  83.         $featureAll = EnvironmentHelper::getVariable('FEATURE_ALL', '');
  84.         if (self::isTrue((string) $featureAll) && (self::$registeredFeatures === [] || \array_key_exists($feature, self::$registeredFeatures))) {
  85.             if ($featureAll === Feature::ALL_MAJOR) {
  86.                 return true;
  87.             }
  89.             // return true if it's registered and not a major feature
  90.             if (isset(self::$registeredFeatures[$feature]) && (self::$registeredFeatures[$feature]['major'] ?? false) === false) {
  91.                 return true;
  92.             }
  93.         }
  95.         if (!EnvironmentHelper::hasVariable($feature) && !EnvironmentHelper::hasVariable(\strtolower($feature))) {
  96.             $fallback = self::$registeredFeatures[$feature]['default'] ?? false;
  98.             return (bool) $fallback;
  99.         }
  101.         return self::isTrue(trim((string) EnvironmentHelper::getVariable($feature)));
  102.     }
  104.     public static function ifActive(string $flagName, \Closure $closure): void
  105.     {
  106.         self::isActive($flagName) && $closure();
  107.     }
  109.     public static function callSilentIfInactive(string $flagName, \Closure $closure): void
  110.     {
  111.         $before = isset(self::$silent[$flagName]);
  112.         self::$silent[$flagName] = true;
  114.         try {
  115.             if (!self::isActive($flagName)) {
  116.                 $closure();
  117.             }
  118.         } finally {
  119.             if (!$before) {
  120.                 unset(self::$silent[$flagName]);
  121.             }
  122.         }
  123.     }
  125.     /**
  126.      * @deprecated tag:v6.5.0 - Will be removed, use Feature::isActive instead
  127.      *
  128.      * @param object $object
  129.      * @param mixed[] $arguments
  130.      */
  131.     public static function ifActiveCall(string $flagName, $object, string $methodName, ...$arguments): void
  132.     {
  133.         Feature::triggerDeprecationOrThrow(
  134.             'v6.5.0.0',
  135.             Feature::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'Feature::isActive')
  136.         );
  137.         $closure = function () use ($object, $methodName, $arguments): void {
  138.             $object->{$methodName}(...$arguments);
  139.         };
  141.         self::ifActive($flagName, \Closure::bind($closure, $object, $object));
  142.     }
  144.     public static function skipTestIfInActive(string $flagName, TestCase $test): void
  145.     {
  146.         if (self::isActive($flagName)) {
  147.             return;
  148.         }
  150.         $test::markTestSkipped('Skipping feature test for flag  "' . $flagName . '"');
  151.     }
  153.     public static function skipTestIfActive(string $flagName, TestCase $test): void
  154.     {
  155.         if (!self::isActive($flagName)) {
  156.             return;
  157.         }
  159.         $test::markTestSkipped('Skipping feature test for flag  "' . $flagName . '"');
  160.     }
  162.     /**
  163.      * Triggers a silenced deprecation notice.
  164.      *
  165.      * @param string $sinceVersion  The version of the package that introduced the deprecation
  166.      * @param string $removeVersion The version of the package when the deprectated code will be removed
  167.      * @param string $message       The message of the deprecation
  168.      * @param mixed  ...$args       Values to insert in the message using printf() formatting
  169.      *
  170.      * @deprecated tag:v6.5.0 - will be removed, use `triggerDeprecationOrThrow` instead
  171.      */
  172.     public static function triggerDeprecated(string $flag, string $sinceVersion, string $removeVersion, string $message, ...$args): void
  173.     {
  174.         self::triggerDeprecationOrThrow(
  175.             'v6.5.0.0',
  176.             self::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'Feature::triggerDeprecationOrThrow()')
  177.         );
  179.         $message = 'Deprecated tag:' . $removeVersion . '(flag:' . $flag . '). ' . $message;
  181.         if (self::isActive($flag) || !self::has($flag)) {
  182.             if (\PHP_SAPI !== 'cli') {
  183.                 ScriptTraces::addDeprecationNotice(sprintf($message, ...$args));
  184.             }
  186.             trigger_deprecation('shopware/core', $sinceVersion, $message, $args);
  187.         }
  188.     }
  190.     public static function throwException(string $flag, string $message, bool $state = true): void
  191.     {
  192.         if (self::isActive($flag) === $state || (self::$registeredFeatures !== [] && !self::has($flag))) {
  193.             throw new \RuntimeException($message);
  194.         }
  196.         if (\PHP_SAPI !== 'cli') {
  197.             ScriptTraces::addDeprecationNotice($message);
  198.         }
  199.     }
  201.     public static function triggerDeprecationOrThrow(string $majorFlag, string $message): void
  202.     {
  203.         if (self::isActive($majorFlag) || (self::$registeredFeatures !== [] && !self::has($majorFlag))) {
  204.             throw new \RuntimeException('Tried to access deprecated functionality: ' . $message);
  205.         }
  207.         if (!isset(self::$silent[$majorFlag]) || !self::$silent[$majorFlag]) {
  208.             if (\PHP_SAPI !== 'cli') {
  209.                 ScriptTraces::addDeprecationNotice($message);
  210.             }
  212.             trigger_deprecation('shopware/core', '', $message);
  213.         }
  214.     }
  216.     public static function deprecatedMethodMessage(string $class, string $method, string $majorVersion, ?string $replacement = null): string
  217.     {
  218.         $message = \sprintf(
  219.             'Method "%s::%s()" is deprecated and will be removed in %s.',
  220.             $class,
  221.             $method,
  222.             $majorVersion
  223.         );
  225.         if ($replacement) {
  226.             $message = \sprintf('%s Use "%s" instead.', $message, $replacement);
  227.         }
  229.         return $message;
  230.     }
  232.     public static function deprecatedClassMessage(string $class, string $majorVersion, ?string $replacement = null): string
  233.     {
  234.         $message = \sprintf(
  235.             'Class "%s" is deprecated and will be removed in %s.',
  236.             $class,
  237.             $majorVersion
  238.         );
  240.         if ($replacement) {
  241.             $message = \sprintf('%s Use "%s" instead.', $message, $replacement);
  242.         }
  244.         return $message;
  245.     }
  247.     public static function has(string $flag): bool
  248.     {
  249.         $flag = self::normalizeName($flag);
  251.         return isset(self::$registeredFeatures[$flag]);
  252.     }
  254.     /**
  255.      * @return array<string, bool>
  256.      */
  257.     public static function getAll(bool $denormalized = true): array
  258.     {
  259.         $resolvedFlags = [];
  261.         foreach (self::$registeredFeatures as $name => $_) {
  262.             $active = self::isActive($name);
  263.             $resolvedFlags[$name] = $active;
  265.             if (!$denormalized) {
  266.                 continue;
  267.             }
  268.             $resolvedFlags[self::denormalize($name)] = $active;
  269.         }
  271.         return $resolvedFlags;
  272.     }
  274.     /**
  275.      * @param array{name?: string, default?: boolean, major?: boolean, description?: string} $metaData
  276.      *
  277.      * @internal
  278.      */
  279.     public static function registerFeature(string $name, array $metaData = []): void
  280.     {
  281.         $name = self::normalizeName($name);
  283.         // merge with existing data
  285.         /** @var array{name?: string, default?: boolean, major?: boolean, description?: string} $metaData */
  286.         $metaData = array_merge(
  287.             self::$registeredFeatures[$name] ?? [],
  288.             $metaData
  289.         );
  291.         // set defaults
  292.         $metaData['major'] = (bool) ($metaData['major'] ?? false);
  293.         $metaData['default'] = (bool) ($metaData['default'] ?? false);
  294.         $metaData['description'] = (string) ($metaData['description'] ?? '');
  296.         self::$registeredFeatures[$name] = $metaData;
  297.     }
  299.     /**
  300.      * @param array<string, array{name?: string, default?: boolean, major?: boolean, description?: string}>|string[] $registeredFeatures
  301.      *
  302.      * @internal
  303.      */
  304.     public static function registerFeatures(iterable $registeredFeatures): void
  305.     {
  306.         foreach ($registeredFeatures as $flag => $data) {
  307.             // old format
  308.             if (\is_string($data)) {
  309.                 $flag = $data;
  310.                 $data = [];
  311.             }
  313.             self::registerFeature($flag, $data);
  314.         }
  315.     }
  317.     /**
  318.      * @internal
  319.      */
  320.     public static function resetRegisteredFeatures(): void
  321.     {
  322.         self::$registeredFeatures = [];
  323.     }
  325.     /**
  326.      * @internal
  327.      *
  328.      * @return array<string, array{'name'?: string, 'default'?: boolean, 'major'?: boolean, 'description'?: string}>
  329.      */
  330.     public static function getRegisteredFeatures(): array
  331.     {
  332.         return self::$registeredFeatures;
  333.     }
  335.     private static function isTrue(string $value): bool
  336.     {
  337.         return $value
  338.             && $value !== 'false'
  339.             && $value !== '0'
  340.             && $value !== '';
  341.     }
  343.     private static function denormalize(string $name): string
  344.     {
  345.         return \strtolower(\str_replace(['_'], '.', $name));
  346.     }
  347. }