Merge branch '7.4' into 8.0

nicolas-grekas · nicolas-grekas · commit 85f51cdac685 · 2025-09-01T11:26:06.000+02:00
* 7.4: (31 commits)
  [Validator] Update Romanian translations
  fix tests
  [JsonStreamer] Fix decoding iterable lists
  [String][Inflector] Fix edge cases
  [Serializer][Validator] Add JSON schema for validating and autocompleting YAML config files
  [DependencyInjection] Allow adding resource tags using any config formats
  Fix merge
  Add missing Sweego Mailer Bridge webhook events
  [Security] Fix attribute-based chained user providers
  [Intl] Fix Intl::getIcuStubVersion()
  [Intl] Add methods to filter currencies more precisely
  [Notifier] Add tests for option classes
  Sync intl scripts
  [Intl] Add metadata about currencies' validtity dates
  Bump Symfony version to 7.3.4
  Update VERSION for 7.3.3
  Update CHANGELOG for 7.3.3
  Bump Symfony version to 6.4.26
  Update VERSION for 6.4.25
  Update CONTRIBUTORS for 6.4.25
  ...
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,8 @@ CHANGELOG
 ---
 
  * Allow Kosovo as a component region, controlled by the `SYMFONY_INTL_WITH_USER_ASSIGNED` env var
+ * Generate legal and validity metadata for currencies
+ * Add `isValidInAnyCountry`, `isValidInCountry`, `forCountry` methods in `Symfony\Component\Intl\Currencies`
 
 7.1
 ---
diff --git a/Currencies.php b/Currencies.php
@@ -139,6 +139,140 @@ public static function forNumericCode(int $numericCode): array
         return self::readEntry(['NumericToAlpha3', (string) $numericCode], 'meta');
     }
 
+    /**
+     * @param string             $country     e.g. 'FR'
+     * @param ?bool              $legalTender If the currency must be a legal tender; null to not filter anything
+     * @param ?bool              $active      Indicates whether the currency should always be active for the given $date; null to not filter anything
+     * @param \DateTimeInterface $date        The date on which the check will be performed
+     *
+     * @return list<string> a list of unique currencies
+     *
+     * @throws MissingResourceException if the given $country does not exist
+     */
+    public static function forCountry(string $country, ?bool $legalTender = true, ?bool $active = true, \DateTimeInterface $date = new \DateTimeImmutable('today', new \DateTimeZone('Etc/UTC'))): array
+    {
+        $currencies = [];
+
+        foreach (self::readEntry(['Map', $country], 'meta') as $currency => $currencyMetadata) {
+            if (null !== $legalTender && $legalTender !== self::isLegalTender($currencyMetadata)) {
+                continue;
+            }
+
+            if (null === $active) {
+                $currencies[] = $currency;
+
+                continue;
+            }
+
+            if (self::isDateActive($country, $currency, $currencyMetadata, $date) !== $active) {
+                continue;
+            }
+
+            $currencies[] = $currency;
+        }
+
+        return $currencies;
+    }
+
+    /**
+     * @param string             $country     e.g. 'FR'
+     * @param string             $currency    e.g. 'USD'
+     * @param ?bool              $legalTender If the currency must be a legal tender; null to not filter anything
+     * @param ?bool              $active      Indicates whether the currency should always be active for the given $date; null to not filter anything
+     * @param \DateTimeInterface $date        The date that will be checked when $active is set to true
+     */
+    public static function isValidInCountry(string $country, string $currency, ?bool $legalTender = true, ?bool $active = true, \DateTimeInterface $date = new \DateTimeImmutable('today', new \DateTimeZone('Etc/UTC'))): bool
+    {
+        if (!self::exists($currency)) {
+            throw new \InvalidArgumentException("The currency $currency does not exist.");
+        }
+
+        try {
+            $currencyMetadata = self::readEntry(['Map', $country, $currency], 'meta');
+        } catch (MissingResourceException) {
+            return false;
+        }
+
+        if (null !== $legalTender && $legalTender !== self::isLegalTender($currencyMetadata)) {
+            return false;
+        }
+
+        if (null === $active) {
+            return true;
+        }
+
+        return self::isDateActive($country, $currency, $currencyMetadata, $date) === $active;
+    }
+
+    /**
+     * @param array{tender?: bool} $currencyMetadata When the `tender` property does not exist, it means it is a legal tender
+     */
+    private static function isLegalTender(array $currencyMetadata): bool
+    {
+        return !\array_key_exists('tender', $currencyMetadata) || false !== $currencyMetadata['tender'];
+    }
+
+    /**
+     * @param string                            $country          e.g. 'FR'
+     * @param string                            $currency         e.g. 'USD'
+     * @param array{from?: string, to?: string} $currencyMetadata
+     * @param \DateTimeInterface                $date             The date on which the check will be performed
+     */
+    private static function isDateActive(string $country, string $currency, array $currencyMetadata, \DateTimeInterface $date): bool
+    {
+        if (!\array_key_exists('from', $currencyMetadata)) {
+            // Note: currencies that are not legal tender don't have often validity dates.
+            throw new \RuntimeException("Cannot check whether the currency $currency is active or not in $country because they are no validity dates available.");
+        }
+
+        $from = \DateTimeImmutable::createFromFormat('Y-m-d', $currencyMetadata['from']);
+
+        if (\array_key_exists('to', $currencyMetadata)) {
+            $to = \DateTimeImmutable::createFromFormat('Y-m-d', $currencyMetadata['to']);
+        } else {
+            $to = null;
+        }
+
+        return $from <= $date && (null === $to || $to >= $date);
+    }
+
+    /**
+     * @param string             $currency    e.g. 'USD'
+     * @param ?bool              $legalTender If the currency must be a legal tender; null to not filter anything
+     * @param ?bool              $active      Indicates whether the currency should always be active for the given $date; null to not filter anything
+     * @param \DateTimeInterface $date        the date on which the check will be performed if $active is set to true
+     */
+    public static function isValidInAnyCountry(string $currency, ?bool $legalTender = true, ?bool $active = true, \DateTimeInterface $date = new \DateTimeImmutable('today', new \DateTimeZone('Etc/UTC'))): bool
+    {
+        if (!self::exists($currency)) {
+            throw new \InvalidArgumentException("The currency $currency does not exist.");
+        }
+
+        foreach (self::readEntry(['Map'], 'meta') as $countryCode => $country) {
+            foreach ($country as $currencyCode => $currencyMetadata) {
+                if ($currencyCode !== $currency) {
+                    continue;
+                }
+
+                if (null !== $legalTender && $legalTender !== self::isLegalTender($currencyMetadata)) {
+                    continue;
+                }
+
+                if (null === $active) {
+                    return true;
+                }
+
+                if (self::isDateActive($countryCode, $currencyCode, $currencyMetadata, $date) !== $active) {
+                    continue;
+                }
+
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     protected static function getPath(): string
     {
         return Intl::getDataDirectory().'/'.Intl::CURRENCY_DIR;
diff --git a/Data/Generator/CurrencyDataGenerator.php b/Data/Generator/CurrencyDataGenerator.php
@@ -102,6 +102,7 @@ protected function generateDataForMeta(BundleEntryReaderInterface $reader, strin
         $data = [
             'Currencies' => $this->currencyCodes,
             'Meta' => $this->generateCurrencyMeta($supplementalDataBundle),
+            'Map' => $this->generateCurrencyMap($supplementalDataBundle),
             'Alpha3ToNumeric' => $this->generateAlpha3ToNumericMapping($numericCodesBundle, $this->currencyCodes),
         ];
 
@@ -125,6 +126,70 @@ private function generateCurrencyMeta(ArrayAccessibleResourceBundle $supplementa
         return iterator_to_array($supplementalDataBundle['CurrencyMeta']);
     }
 
+    /**
+     * @return array<string, array>
+     */
+    private function generateCurrencyMap(mixed $supplementalDataBundle): array
+    {
+        /**
+         * @var list<string, list<string, array{from?: string, to?: string, tender?: false}>> $regionsData
+         */
+        $regionsData = [];
+
+        foreach ($supplementalDataBundle['CurrencyMap'] as $regionId => $region) {
+            foreach ($region as $metadata) {
+                /**
+                 * Note 1: The "to" property (if present) is always greater than "from".
+                 * Note 2: The "to" property may be missing if the currency is still in use.
+                 * Note 3: The "tender" property indicates whether the country legally recognizes the currency within
+                 *         its borders. This property is explicitly set to `false` only if that is not the case;
+                 *         otherwise, it is `true` by default.
+                 * Note 4: The "from" and "to" dates are not stored as strings; they are stored as a pair of integers.
+                 * Note 5: The "to" property may be missing if "tender" is set to `false`.
+                 *
+                 * @var array{
+                 *        from?: array{0: int, 1: int},
+                 *        to?: array{0: int, 2: int},
+                 *        tender?: bool,
+                 *        id: string
+                 *      } $metadata
+                 */
+                $metadata = iterator_to_array($metadata);
+
+                $id = $metadata['id'];
+
+                unset($metadata['id']);
+
+                if (\array_key_exists($id, self::DENYLIST)) {
+                    continue;
+                }
+
+                if (\array_key_exists('from', $metadata)) {
+                    $metadata['from'] = self::icuPairToDate($metadata['from']);
+                }
+
+                if (\array_key_exists('to', $metadata)) {
+                    $metadata['to'] = self::icuPairToDate($metadata['to']);
+                }
+
+                if (\array_key_exists('tender', $metadata)) {
+                    $metadata['tender'] = filter_var($metadata['tender'], \FILTER_VALIDATE_BOOLEAN, \FILTER_NULL_ON_FAILURE);
+
+                    if (null === $metadata['tender']) {
+                        throw new \RuntimeException('Unexpected boolean value for tender attribute.');
+                    }
+                }
+
+                $regionsData[$regionId][$id] = $metadata;
+            }
+
+            // Do not exclude countries with no currencies or excluded currencies (e.g. Antartica)
+            $regionsData[$regionId] ??= [];
+        }
+
+        return $regionsData;
+    }
+
     private function generateAlpha3ToNumericMapping(ArrayAccessibleResourceBundle $numericCodesBundle, array $currencyCodes): array
     {
         $alpha3ToNumericMapping = iterator_to_array($numericCodesBundle['codeMap']);
@@ -152,4 +217,41 @@ private function generateNumericToAlpha3Mapping(array $alpha3ToNumericMapping):
 
         return $numericToAlpha3Mapping;
     }
+
+    /**
+     * Decodes ICU "date pair" into a DateTimeImmutable (UTC).
+     *
+     * ICU stores UDate = milliseconds since 1970-01-01T00:00:00Z in a signed 64-bit.
+     *
+     * @param array{0: int, 1: int} $pair
+     */
+    private static function icuPairToDate(array $pair): string
+    {
+        [$highBits32, $lowBits32] = $pair;
+
+        // Recompose a 64-bit unsigned integer from two 32-bit chunks.
+        $unsigned64 = ((($highBits32 & 0xFFFFFFFF) << 32) | ($lowBits32 & 0xFFFFFFFF));
+
+        // Convert to signed 64-bit (two's complement) if sign bit is set.
+        if ($unsigned64 >= (1 << 63)) {
+            $unsigned64 -= (1 << 64);
+        }
+
+        // Split into seconds and milliseconds.
+        $seconds = intdiv($unsigned64, 1000);
+        $millisecondsRemainder = $unsigned64 - $seconds * 1000;
+
+        // Normalize negative millisecond remainders (e.g., for pre-1970 values)
+        if (0 > $millisecondsRemainder) {
+            --$seconds;
+        }
+
+        $datetime = \DateTimeImmutable::createFromFormat('U', $seconds, new \DateTimeZone('Etc/UTC'));
+
+        if (false === $datetime) {
+            throw new \RuntimeException('Unable to parse ICU milliseconds pair.');
+        }
+
+        return $datetime->format('Y-m-d');
+    }
 }
diff --git a/Intl.php b/Intl.php
@@ -106,7 +106,7 @@ public static function getIcuDataVersion(): string
      */
     public static function getIcuStubVersion(): string
     {
-        return '76.1';
+        return '77.1';
     }
 
     /**
diff --git a/Resources/bin/compile b/Resources/bin/compile
@@ -8,5 +8,5 @@ docker run \
     -v /tmp/symfony/icu:/tmp \
     -v $(pwd):/symfony \
     -w /symfony \
-    jakzal/php-intl:8.3-74.1 \
+    jakzal/php-intl:8.4-77.1 \
     php src/Symfony/Component/Intl/Resources/bin/update-data.php
diff --git a/Resources/data/currencies/meta.php b/Resources/data/currencies/meta.php
diff --git a/Tests/CurrenciesTest.php b/Tests/CurrenciesTest.php

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ public static function getIcuDataVersion(): string`
`106`	`106`	`*/`
`107`	`107`	`public static function getIcuStubVersion(): string`
`108`	`108`	`{`
`109`		`- return '76.1';`
	`109`	`+ return '77.1';`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`/**`