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. }