diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to the [Haskell Package Versioning Policy](https://pvp.haskell.org/). +## [1.1.0] - 2026-10-20 + +### Changed + +- **Breaking:** `fluent` 1.1.0 breaking changes: + - `SomeValue` is now `Value`. + - The `Value` class is now `ToValue`. + - Constructors are used qualified: `Value.String`, `Value.Number`, `Value.Time`. + - `CustomValue` and `ToValue.format` are replaced by `Value.Formatted`. + - The `fluent` quasi-quoter and `messageIdentifiers` fail to compile on a syntax error. + - `parseResource` fails on a syntax error. `parseResourceLenient` returns a `JunkEntry` instead. + +### Fixed + +- Huge digit options, such as `minimumIntegerDigits: 1000000000`, are capped to the ranges of `Intl.NumberFormat`. + ## [1.0.0] - 2026-10-01 ### Added diff --git a/Setup.hs b/Setup.hs deleted file mode 100644 --- a/Setup.hs +++ /dev/null @@ -1,2 +0,0 @@ -import Distribution.Simple -main = defaultMain diff --git a/fluent-icu.cabal b/fluent-icu.cabal --- a/fluent-icu.cabal +++ b/fluent-icu.cabal @@ -1,6 +1,6 @@ cabal-version: 3.0 name: fluent-icu -version: 1.0.0 +version: 1.1.0 synopsis: ICU backend for fluent description: ICU backend for . license: EUPL-1.2 @@ -45,7 +45,7 @@ build-depends: base >=4.11 && <5, - fluent >=1.0 && <1.1, + fluent >=1.1 && <1.2, text >=2.0 && <2.2, library @@ -69,7 +69,7 @@ import: common type: exitcode-stdio-1.0 hs-source-dirs: test - main-is: Spec.hs + main-is: Main.hs other-modules: BuiltinSpec LocaleSpec diff --git a/src/Language/Fluent/ICU.hs b/src/Language/Fluent/ICU.hs --- a/src/Language/Fluent/ICU.hs +++ b/src/Language/Fluent/ICU.hs @@ -9,7 +9,7 @@ -- -- localisation backed by -- using the --- library. +-- library. -- -- This module re-exports everything needed to translate Fluent messages. -- @@ -39,6 +39,8 @@ -- -- > resource <- either fail pure . parseResource =<< Text.readFile "resource.ftl" -- +-- A syntax error fails the whole file. 'parseResourceLenient' returns a 'JunkEntry' instead. +-- -- == 2. Building bundles -- -- Combine 'Resource's and 'Locale's into a 'Bundle' using 'bundle': @@ -55,38 +57,39 @@ -- -- Pass parameters as name-value tuples: -- --- >>> translate "unread-emails" ("count", value @Int 1) english :: Either String Text +-- >>> translate "unread-emails" ("count", 1) english :: Either String Text -- Right "You have one unread email." --- >>> translate "unread-emails" ("count", value @Int 5) english :: Either String Text +-- >>> translate "unread-emails" ("count", 5) english :: Either String Text -- Right "You have several unread emails." -- -- You can chain multiple arguments and configure Unicode isolation marks using 'UseIsolating': -- --- >>> translate "greeting" ("name", value @Text "Ann") ("count", value @Int 3) (UseIsolating False) english :: Either String Text +-- >>> translate "greeting" ("name", "Ann") ("count", 3) (UseIsolating False) english :: Either String Text -- Right "Hello, Ann! You have 3 new messages." -- -- == 4. Formatting numbers, currencies, and units -- -- Number formatting adapts to the target locale: -- --- >>> translate "amount" ("amount", value @Int 1234567) english :: Either String Text +-- >>> translate "amount" ("amount", 1234567 :: Int) english :: Either String Text -- Right "1,234,567" --- >>> translate "amount" ("amount", value @Int 1234567) german :: Either String Text +-- >>> translate "amount" ("amount", 1234567 :: Int) german :: Either String Text -- Right "1'234'567" --- >>> translate "price" ("amount", value @Double 1234.5) english :: Either String Text +-- >>> translate "price" ("amount", 1234.5 :: Double) english :: Either String Text -- Right "1,234.50 euros" --- >>> translate "price" ("amount", value @Double 1234.5) german :: Either String Text +-- >>> translate "price" ("amount", 1234.5 :: Double) german :: Either String Text -- Right "1'234.50 Euro" --- >>> translate "temperature" ("degrees", value @Int 21) english :: Either String Text +-- >>> translate "temperature" ("degrees", 21 :: Int) english :: Either String Text -- Right "21 degrees Celsius" --- >>> translate "temperature" ("degrees", value @Int 21) german :: Either String Text +-- >>> translate "temperature" ("degrees", 21 :: Int) german :: Either String Text -- Right "21 Grad Celsius" -- -- You can pass formatting options directly via structured values: -- --- >>> translate "amount" ("amount", NumberValue 1234.5 numberOptions{style = Currency "EUR", currencyDisplay = Name}) english :: Either String Text +-- >>> import Language.Fluent.Value qualified as Value +-- >>> translate "amount" ("amount", Value.Number 1234.5 numberOptions{style = Currency "EUR", currencyDisplay = Name}) english :: Either String Text -- Right "1,234.50 euros" --- >>> translate "amount" ("amount", NumberValue 21 numberOptions{style = Unit "metre-per-second", unitDisplay = Short}) english :: Either String Text +-- >>> translate "amount" ("amount", Value.Number 21 numberOptions{style = Unit "metre-per-second", unitDisplay = Short}) english :: Either String Text -- Right "21 m/s" module Language.Fluent.ICU ( -- * Re-exports @@ -139,7 +142,7 @@ withLocaleName a \source -> withLocaleName b \target -> allocaBytes capacity \name -> do - written <- fluentGetDisplayLanguage source target name (fromIntegral capacity) + written <- fluentGetDisplayLanguage source target name $ fromIntegral capacity if written < 0 then pure Nothing else Just . Text.decodeUtf8 <$> ByteString.packCStringLen (name, fromIntegral written) @@ -151,7 +154,7 @@ ByteString.useAsCStringLen utf8 \(source, sourceLength) -> allocaBytes capacity \out -> do written <- - fluentFormatTitlecase locale source (fromIntegral sourceLength) out (fromIntegral capacity) + fluentFormatTitlecase locale source (fromIntegral sourceLength) out $ fromIntegral capacity if written < 0 then pure text else Text.decodeUtf8 <$> ByteString.packCStringLen (out, fromIntegral written) @@ -172,7 +175,7 @@ decimal (fromIntegral decimalLength) keyword - (fromIntegral capacity) + $ fromIntegral capacity if written < 0 then pure Plural.Other else fromMaybe Plural.Other . readMaybe <$> peekCStringLen (keyword, fromIntegral written) @@ -195,7 +198,7 @@ decimal (fromIntegral decimalLength) out - (fromIntegral capacity) + $ fromIntegral capacity if written < 0 then Left . ("NUMBER: " <>) <$> icuErrorMessage written else Right . Text.decodeUtf8 <$> ByteString.packCStringLen (out, fromIntegral written) @@ -209,7 +212,7 @@ withLocaleName locale \name -> withUtf8Text skeleton \wanted -> allocaBytes capacity \ptr -> do - written <- fluentResolveDatePattern name wanted ptr (fromIntegral capacity) + written <- fluentResolveDatePattern name wanted ptr $ fromIntegral capacity if written < 0 then pure skeleton else Text.decodeUtf8 <$> ByteString.packCStringLen (ptr, fromIntegral written) @@ -223,7 +226,7 @@ skeleton = Time.skeleton options millisecondsSinceEpoch :: UTCTime -> Double - millisecondsSinceEpoch = (* 1000) . realToFrac . utcTimeToPOSIXSeconds + millisecondsSinceEpoch = (1000 *) . realToFrac . utcTimeToPOSIXSeconds setMillis :: Calendar -> Double -> IO () setMillis calendar ms = do @@ -251,7 +254,7 @@ withMany withLocaleName (NonEmpty.toList preferences) \accept -> withArrayLen accept \count array -> allocaBytes capacity \out -> do - written <- fluentNegotiateSupportedLocale array (fromIntegral count) out (fromIntegral capacity) + written <- fluentNegotiateSupportedLocale array (fromIntegral count) out $ fromIntegral capacity if written < 0 then pure Nothing else Just . ICU.Locale <$> peekCStringLen (out, fromIntegral written) diff --git a/test/BuiltinSpec.hs b/test/BuiltinSpec.hs --- a/test/BuiltinSpec.hs +++ b/test/BuiltinSpec.hs @@ -13,7 +13,7 @@ it "omits the grouping separators when turned off" $ translate "foo" - [("arg", number 1234567)] + [("arg", 1234567 :: Int)] [fluent|foo = { NUMBER($arg, useGrouping: "false") }|] `shouldBe` Right "1234567" it "selects by the plural category of the number" $ @@ -66,10 +66,10 @@ `shouldBe` Left "DATETIME: the positional argument is not a time" written :: Resource -> Either String Text -written = translate "foo" [("arg", number 3)] +written = translate "foo" [("arg", 3 :: Int)] when' :: Resource -> Either String Text -when' = translate "foo" [("arg", value afternoon)] +when' = translate "foo" [("arg", afternoon)] -- | 2026-08-10, a Monday, 12:34:56 UTC. afternoon :: UTCTime diff --git a/test/Main.hs b/test/Main.hs new file mode 100644 --- /dev/null +++ b/test/Main.hs @@ -0,0 +1,1 @@ +{-# OPTIONS_GHC -F -pgmF hspec-discover #-} diff --git a/test/NumberSpec.hs b/test/NumberSpec.hs --- a/test/NumberSpec.hs +++ b/test/NumberSpec.hs @@ -1,94 +1,95 @@ module NumberSpec (spec) where +import Language.Fluent.Value qualified as Value import Prelude spec :: Spec spec = do it "groups the digits the way the locale groups them" $ - translate "foo" ("arg", NumberValue 1234567 numberOptions) resource `shouldBe` Right "1,234,567" + translate "foo" ("arg", Value.Number 1234567 numberOptions) resource `shouldBe` Right "1,234,567" it "leaves the grouping out when it is turned off" $ - translate "foo" ("arg", NumberValue 1234567 numberOptions{useGrouping = False}) resource + translate "foo" ("arg", Value.Number 1234567 numberOptions{useGrouping = False}) resource `shouldBe` Right "1234567" it "pads the integer part to the given width" $ - translate "foo" ("arg", NumberValue 5 numberOptions{minimumIntegerDigits = 3}) resource + translate "foo" ("arg", Value.Number 5 numberOptions{minimumIntegerDigits = 3}) resource `shouldBe` Right "005" it "limits the fraction digits to the maximum given" $ - translate "foo" ("arg", NumberValue 1.5 numberOptions{maximumFractionDigits = Just 0}) resource + translate "foo" ("arg", Value.Number 1.5 numberOptions{maximumFractionDigits = Just 0}) resource `shouldBe` Right "2" it "limits the significant digits it is given" $ translate "foo" - ("arg", NumberValue 1234 numberOptions{maximumSignificantDigits = Just 2}) + ("arg", Value.Number 1234 numberOptions{maximumSignificantDigits = Just 2}) resource `shouldBe` Right "1,200" it "is shown as a percentage" $ - translate "foo" ("arg", NumberValue 0.25 numberOptions{style = Percent}) resource + translate "foo" ("arg", Value.Number 0.25 numberOptions{style = Percent}) resource `shouldBe` Right "25%" it "is an amount of a currency" $ - translate "foo" ("arg", NumberValue 12.5 numberOptions{style = Currency "EUR"}) resource + translate "foo" ("arg", Value.Number 12.5 numberOptions{style = Currency "EUR"}) resource `shouldBe` Right "€12.50" it "spells the currency's name out, not its symbol" $ translate "foo" - ("arg", NumberValue 12.5 numberOptions{style = Currency "EUR", currencyDisplay = Name}) + ("arg", Value.Number 12.5 numberOptions{style = Currency "EUR", currencyDisplay = Name}) resource `shouldBe` Right "12.50 euros" it "is an amount of a unit" $ - translate "foo" ("arg", NumberValue 5 numberOptions{style = Unit "kilometre-per-hour"}) resource + translate "foo" ("arg", Value.Number 5 numberOptions{style = Unit "kilometre-per-hour"}) resource `shouldBe` Right "5 km/h" it "is an amount of a unit of one thing per another" $ - translate "foo" ("arg", NumberValue 5 numberOptions{style = Unit "litre-per-kilometre"}) resource + translate "foo" ("arg", Value.Number 5 numberOptions{style = Unit "litre-per-kilometre"}) resource `shouldBe` Right "5 l/km" it "shows the unit's symbol when narrow, its name when long" $ do translate "foo" - ("arg", NumberValue 5 numberOptions{style = Unit "litre", unitDisplay = Narrow}) + ("arg", Value.Number 5 numberOptions{style = Unit "litre", unitDisplay = Narrow}) resource `shouldBe` Right "5l" translate "foo" - ("arg", NumberValue 5 numberOptions{style = Unit "litre", unitDisplay = Long}) + ("arg", Value.Number 5 numberOptions{style = Unit "litre", unitDisplay = Long}) resource `shouldBe` Right "5 litres" it "accepts a unit identifier written in British spelling" $ do - translate "foo" ("arg", NumberValue 5 numberOptions{style = Unit "litre"}) resource + translate "foo" ("arg", Value.Number 5 numberOptions{style = Unit "litre"}) resource `shouldBe` Right "5 l" - translate "foo" ("arg", NumberValue 5 numberOptions{style = Unit "millilitre"}) resource + translate "foo" ("arg", Value.Number 5 numberOptions{style = Unit "millilitre"}) resource `shouldBe` Right "5 ml" - translate "foo" ("arg", NumberValue 5 numberOptions{style = Unit "square-kilometre"}) resource + translate "foo" ("arg", Value.Number 5 numberOptions{style = Unit "square-kilometre"}) resource `shouldBe` Right "5 km²" it "keeps the fraction digits a unit is given" $ translate "foo" - ("arg", NumberValue 5 numberOptions{style = Unit "megabyte", minimumFractionDigits = 1}) + ("arg", Value.Number 5 numberOptions{style = Unit "megabyte", minimumFractionDigits = 1}) resource `shouldBe` Right "5.0 MB" it "spells the unit the way the locale spells it, whatever it is called" $ do translate "foo" - ("arg", NumberValue 5 numberOptions{style = Unit "kilometre", unitDisplay = Long}) + ("arg", Value.Number 5 numberOptions{style = Unit "kilometre", unitDisplay = Long}) resource `shouldBe` Right "5 kilometres" translate "foo" - ("arg", NumberValue 5 numberOptions{style = Unit "litre", unitDisplay = Long}) + ("arg", Value.Number 5 numberOptions{style = Unit "litre", unitDisplay = Long}) deCH resource `shouldBe` Right "5 Liter" it "rejects a unit it does not know" $ - translate "foo" ("arg", NumberValue 5 numberOptions{style = Unit "banana"}) resource + translate "foo" ("arg", Value.Number 5 numberOptions{style = Unit "banana"}) resource `shouldBe` Left "NUMBER: U_NUMBER_SKELETON_SYNTAX_ERROR" it "uses the first known locale in the chain" $ do - translate "foo" ("arg", NumberValue 1234.5 numberOptions) [deCH, enGB] resource + translate "foo" ("arg", Value.Number 1234.5 numberOptions) [deCH, enGB] resource `shouldBe` Right "1'234.5" - translate "foo" ("arg", NumberValue 1234.5 numberOptions) [enGB, deCH] resource + translate "foo" ("arg", Value.Number 1234.5 numberOptions) [enGB, deCH] resource `shouldBe` Right "1,234.5" - translate "foo" ("arg", NumberValue 1234.5 numberOptions) [unknown, deCH] resource + translate "foo" ("arg", Value.Number 1234.5 numberOptions) [unknown, deCH] resource `shouldBe` Right "1'234.5" it "falls back to an ancestor locale when the exact one is unknown" $ do - translate "foo" ("arg", NumberValue 1234.5 numberOptions) deSince1996 resource + translate "foo" ("arg", Value.Number 1234.5 numberOptions) deSince1996 resource `shouldBe` Right "1'234.5" - translate "foo" ("arg", NumberValue 1234.5 numberOptions) deInAnUnknownScript resource + translate "foo" ("arg", Value.Number 1234.5 numberOptions) deInAnUnknownScript resource `shouldBe` Right "1.234,5" resource :: Resource diff --git a/test/Prelude.hs b/test/Prelude.hs --- a/test/Prelude.hs +++ b/test/Prelude.hs @@ -21,6 +21,7 @@ import Language.Fluent.Bundle qualified as Bundle import Language.Fluent.ICU import Language.Fluent.Locale qualified as Locale +import Language.Fluent.Value qualified as Value import Test.Hspec import "base" Prelude @@ -40,12 +41,12 @@ instance (r ~ Either String Text) => Translate (Resource -> r) where translate arguments = translate arguments $ Locale.fromCode @LocaleName "en-GB" -number :: Scientific -> SomeValue +number :: Scientific -> Value number = numberWith Cardinal 0 -ordinal :: Scientific -> SomeValue +ordinal :: Scientific -> Value ordinal = numberWith Ordinal 0 -numberWith :: Form -> Int -> Scientific -> SomeValue +numberWith :: Form -> Int -> Scientific -> Value numberWith form minimumFractionDigits amount = - NumberValue amount numberOptions{form, minimumFractionDigits} + Value.Number amount numberOptions{form, minimumFractionDigits} diff --git a/test/Spec.hs b/test/Spec.hs deleted file mode 100644 --- a/test/Spec.hs +++ /dev/null @@ -1,1 +0,0 @@ -{-# OPTIONS_GHC -F -pgmF hspec-discover #-} diff --git a/test/TimeSpec.hs b/test/TimeSpec.hs --- a/test/TimeSpec.hs +++ b/test/TimeSpec.hs @@ -1,43 +1,45 @@ module TimeSpec (spec) where import Data.Time +import Language.Fluent.Value qualified as Value import Prelude spec :: Spec spec = do it "is a date of numbers when given nothing" $ - translate "foo" ("when", TimeValue afternoon timeOptions) resource `shouldBe` Right "10/08/2026" + translate "foo" ("when", Value.Time afternoon timeOptions) resource `shouldBe` Right "10/08/2026" it "formats the date to match the locale's convention" $ - translate "foo" ("when", TimeValue afternoon timeOptions) deCH resource `shouldBe` Right "10.8.2026" + translate "foo" ("when", Value.Time afternoon timeOptions) deCH resource + `shouldBe` Right "10.8.2026" it "spells the month out at the width it is given" $ translate "foo" - ("when", TimeValue afternoon dated{month = Just (Right Long)}) + ("when", Value.Time afternoon dated{month = Just $ Right Long}) resource `shouldBe` Right "10 August 2026" it "formats only the field it is given" $ - translate "foo" ("when", TimeValue afternoon timeOptions{month = Just (Right Long)}) resource + translate "foo" ("when", Value.Time afternoon timeOptions{month = Just $ Right Long}) resource `shouldBe` Right "August" it "spells the weekday out" $ - translate "foo" ("when", TimeValue afternoon timeOptions{weekday = Just Long}) resource + translate "foo" ("when", Value.Time afternoon timeOptions{weekday = Just Long}) resource `shouldBe` Right "Monday" it "shows the time of day it is given" $ - translate "foo" ("when", TimeValue afternoon clock) resource `shouldBe` Right "12:34" + translate "foo" ("when", Value.Time afternoon clock) resource `shouldBe` Right "12:34" it "formats the month in digits or in words, beside a year of digits" $ do translate "foo" - ("when", TimeValue afternoon timeOptions{year = Just Numeric, month = Just (Right Narrow)}) + ("when", Value.Time afternoon timeOptions{year = Just Numeric, month = Just $ Right Narrow}) resource `shouldBe` Right "A 2026" translate "foo" - ("when", TimeValue afternoon timeOptions{year = Just Numeric, month = Just (Left TwoDigit)}) + ("when", Value.Time afternoon timeOptions{year = Just Numeric, month = Just $ Left TwoDigit}) resource `shouldBe` Right "08/2026" it "reads the time in the zone it is given" $ - translate "foo" ("when", TimeValue afternoon berlin) resource `shouldBe` Right "14:34" + translate "foo" ("when", Value.Time afternoon berlin) resource `shouldBe` Right "14:34" it "keeps the hour the zone keeps at that time of year" $ - translate "foo" ("when", TimeValue midwinter berlin) resource `shouldBe` Right "13:34" + translate "foo" ("when", Value.Time midwinter berlin) resource `shouldBe` Right "13:34" resource :: Resource resource = [fluent|foo = { $when }|]