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

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[]
  15.      */
  16.     private static array $registeredFeatures = [];
  18.     public static function normalizeName(string $name): string
  19.     {
  20.         /*
  21.          * Examples:
  22.          * - NEXT-1234
  23.          * - FEATURE_NEXT_1234
  24.          * - SAAS_321
  25.          * - v6.5.0.0 => v6_5_0_0
  26.          */
  27.         return \strtoupper(\str_replace(['.', ':', '-'], '_', $name));
  28.     }
  30.     public static function isActive(string $feature): bool
  31.     {
  32.         $env = EnvironmentHelper::getVariable('APP_ENV', 'prod');
  33.         $feature = self::normalizeName($feature);
  35.         if (self::$registeredFeatures !== []
  36.             && !isset(self::$registeredFeatures[$feature])
  37.             && $env !== 'prod'
  38.         ) {
  39.             trigger_error('Unknown feature "' . $feature . '"', \E_USER_WARNING);
  40.         }
  42.         $featureAll = EnvironmentHelper::getVariable('FEATURE_ALL', '');
  43.         if (self::isTrue((string) $featureAll) && (self::$registeredFeatures === [] || \array_key_exists($feature, self::$registeredFeatures))) {
  44.             if ($featureAll === Feature::ALL_MAJOR) {
  45.                 return true;
  46.             }
  48.             // return true if it's registered and not a major feature
  49.             if (isset(self::$registeredFeatures[$feature]) && (self::$registeredFeatures[$feature]['major'] ?? false) === false) {
  50.                 return true;
  51.             }
  52.         }
  54.         if (!EnvironmentHelper::hasVariable($feature) && !EnvironmentHelper::hasVariable(\strtolower($feature))) {
  55.             $fallback = self::$registeredFeatures[$feature]['default'] ?? false;
  57.             return (bool) $fallback;
  58.         }
  60.         return self::isTrue(trim((string) EnvironmentHelper::getVariable($feature)));
  61.     }
  63.     public static function ifActive(string $flagName, \Closure $closure): void
  64.     {
  65.         self::isActive($flagName) && $closure();
  66.     }
  68.     /**
  69.      * @param object $object
  70.      * @param mixed[] $arguments
  71.      */
  72.     public static function ifActiveCall(string $flagName, $object, string $methodName, ...$arguments): void
  73.     {
  74.         $closure = function () use ($object, $methodName, $arguments): void {
  75.             $object->{$methodName}(...$arguments);
  76.         };
  78.         self::ifActive($flagName, \Closure::bind($closure, $object, $object));
  79.     }
  81.     public static function skipTestIfInActive(string $flagName, TestCase $test): void
  82.     {
  83.         if (self::isActive($flagName)) {
  84.             return;
  85.         }
  87.         $test::markTestSkipped('Skipping feature test for flag  "' . $flagName . '"');
  88.     }
  90.     public static function skipTestIfActive(string $flagName, TestCase $test): void
  91.     {
  92.         if (!self::isActive($flagName)) {
  93.             return;
  94.         }
  96.         $test::markTestSkipped('Skipping feature test for flag  "' . $flagName . '"');
  97.     }
  99.     /**
  100.      * Triggers a silenced deprecation notice.
  101.      *
  102.      * @param string $sinceVersion  The version of the package that introduced the deprecation
  103.      * @param string $removeVersion The version of the package when the deprectated code will be removed
  104.      * @param string $message       The message of the deprecation
  105.      * @param mixed  ...$args       Values to insert in the message using printf() formatting
  106.      *
  107.      * @deprecated tag:v6.5.0 - will be removed, use `triggerDeprecationOrThrow` instead
  108.      */
  109.     public static function triggerDeprecated(string $flag, string $sinceVersion, string $removeVersion, string $message, ...$args): void
  110.     {
  111.         self::triggerDeprecationOrThrow(
  112.             'v6.5.0.0',
  113.             self::deprecatedMethodMessage(__CLASS__, __METHOD__, 'v6.5.0.0', 'Feature::triggerDeprecationOrThrow()')
  114.         );
  116.         $message = 'Deprecated tag:' . $removeVersion . '(flag:' . $flag . '). ' . $message;
  118.         if (self::isActive($flag) || !self::has($flag)) {
  119.             if (\PHP_SAPI !== 'cli') {
  120.                 ScriptTraces::addDeprecationNotice(sprintf($message, ...$args));
  121.             }
  123.             trigger_deprecation('shopware/core', $sinceVersion, $message, $args);
  124.         }
  125.     }
  127.     public static function throwException(string $flag, string $message, bool $state = true): void
  128.     {
  129.         if (self::isActive($flag) === $state || !self::has($flag)) {
  130.             throw new \RuntimeException($message);
  131.         }
  133.         if (\PHP_SAPI !== 'cli') {
  134.             ScriptTraces::addDeprecationNotice($message);
  135.         }
  136.     }
  138.     public static function triggerDeprecationOrThrow(string $majorFlag, string $message): void
  139.     {
  140.         if (self::isActive($majorFlag) || !self::has($majorFlag)) {
  141.             throw new \RuntimeException('Tried to access deprecated functionality: ' . $message);
  142.         }
  144.         if (\PHP_SAPI !== 'cli') {
  145.             ScriptTraces::addDeprecationNotice($message);
  146.         }
  148.         trigger_deprecation('shopware/core', '', $message);
  149.     }
  151.     public static function deprecatedMethodMessage(string $class, string $method, string $majorVersion, ?string $replacement = null): string
  152.     {
  153.         $message = \sprintf(
  154.             'Method "%s::%s()" is deprecated and will be removed in %s.',
  155.             $class,
  156.             $method,
  157.             $majorVersion
  158.         );
  160.         if ($replacement) {
  161.             $message = \sprintf('%s Use "%s" instead.', $message, $replacement);
  162.         }
  164.         return $message;
  165.     }
  167.     public static function deprecatedClassMessage(string $class, string $majorVersion, ?string $replacement = null): string
  168.     {
  169.         $message = \sprintf(
  170.             'Class "%s" is deprecated and will be removed in %s.',
  171.             $class,
  172.             $majorVersion
  173.         );
  175.         if ($replacement) {
  176.             $message = \sprintf('%s Use "%s" instead.', $message, $replacement);
  177.         }
  179.         return $message;
  180.     }
  182.     public static function has(string $flag): bool
  183.     {
  184.         $flag = self::normalizeName($flag);
  186.         return isset(self::$registeredFeatures[$flag]);
  187.     }
  189.     public static function getAll(bool $denormalized = true): array
  190.     {
  191.         $resolvedFlags = [];
  193.         foreach (self::$registeredFeatures as $name => $_) {
  194.             $active = self::isActive($name);
  195.             $resolvedFlags[$name] = $active;
  197.             if (!$denormalized) {
  198.                 continue;
  199.             }
  200.             $resolvedFlags[self::denormalize($name)] = $active;
  201.         }
  203.         return $resolvedFlags;
  204.     }
  206.     /**
  207.      * @internal
  208.      */
  209.     public static function registerFeature(string $name, array $metaData = []): void
  210.     {
  211.         $name = self::normalizeName($name);
  213.         // merge with existing data
  214.         $metaData = array_merge(
  215.             self::$registeredFeatures[$name] ?? [],
  216.             $metaData
  217.         );
  219.         // set defaults
  220.         $metaData['major'] = (bool) ($metaData['major'] ?? false);
  221.         $metaData['default'] = (bool) ($metaData['default'] ?? false);
  222.         $metaData['description'] = (string) ($metaData['description'] ?? '');
  224.         self::$registeredFeatures[$name] = $metaData;
  225.     }
  227.     /**
  228.      * @internal
  229.      */
  230.     public static function registerFeatures(iterable $registeredFeatures): void
  231.     {
  232.         foreach ($registeredFeatures as $flag => $data) {
  233.             // old format
  234.             if (\is_string($data)) {
  235.                 $flag = $data;
  236.                 $data = [];
  237.             }
  239.             self::registerFeature($flag, $data);
  240.         }
  241.     }
  243.     /**
  244.      * @internal
  245.      */
  246.     public static function resetRegisteredFeatures(): void
  247.     {
  248.         self::$registeredFeatures = [];
  249.     }
  251.     /**
  252.      * @internal
  253.      */
  254.     public static function getRegisteredFeatures(): array
  255.     {
  256.         return self::$registeredFeatures;
  257.     }
  259.     private static function isTrue(string $value): bool
  260.     {
  261.         return $value
  262.             && $value !== 'false'
  263.             && $value !== '0'
  264.             && $value !== '';
  265.     }
  267.     private static function denormalize(string $name): string
  268.     {
  269.         return \strtolower(\str_replace(['_'], '.', $name));
  270.     }
  271. }