CLDR 48 tests in the green

Author: kipcole9

CHANGELOG.md

@@ -2,6 +2,14 @@
 
 Note that as of Cldr Locale Display version 1.5.0, Elixir 1.12 or later is required.
 
+## Cldr Locale Display v1.7.0
+
+This is the changelog for Cldr Locale Display v1.7.0 released on ______, 2025.  For older changelogs please consult the release tag on [GitHub](https://github.com/elixir-cldr/cldr_locale_display/tags)
+
+### Enhancements
+
+* Updates to [CLDR 48](https://cldr.unicode.org/downloads/cldr-48) data and tests.
+
 ## Cldr Locale Display v1.6.2
 
 This is the changelog for Cldr Locale Display v1.6.2 released on October 14th, 2025.  For older changelogs please consult the release tag on [GitHub](https://github.com/elixir-cldr/cldr_locale_display/tags)

lib/cldr/backend.ex

@@ -51,7 +51,7 @@ defmodule Cldr.LocaleDisplay.Backend do
 
         * `:prefer` signals the preferred name for
           a subtag when there are alternatives.
-          The default is `:default`. Few subtags
+          The default is `:standard`. Few subtags
           provide alternative renderings. Some of
           the alternative preferences are `:short`,
           `:long`, `:menu` and `:variant`.
@@ -126,7 +126,7 @@ defmodule Cldr.LocaleDisplay.Backend do
 
         * `:prefer` signals the preferred name for
           a subtag when there are alternatives.
-          The default is `:default`. Few subtags
+          The default is `:standard`. Few subtags
           provide alternative renderings. Some of
           the alternative preferences are`:short`,
           `:long`, `:menu` and `:variant`.

lib/cldr/locale_display.ex

@@ -52,7 +52,7 @@ defmodule Cldr.LocaleDisplay do
 
   * `:prefer` signals the preferred name for
     a subtag when there are alternatives.
-    The default is `:default`. Few subtags
+    The default is `:standard`. Few subtags
     provide alternative renderings. Some of
     the alternative preferences are`:short`,
     `:long`, `:menu` and `:variant`.
@@ -116,50 +116,55 @@ defmodule Cldr.LocaleDisplay do
 
   def display_name(%LanguageTag{} = language_tag, options) do
     {in_locale, backend} = Cldr.locale_and_backend_from(options)
-    language_display = Keyword.get(options, :language_display, :standard)
-    prefer = Keyword.get(options, :prefer, :default)
+    options = Keyword.merge(default_options(), options)
+
+    standard_or_dialect = Keyword.get(options, :language_display)
+    prefer = Keyword.get(options, :prefer)
+
+    # FIXME Catering for legacy
+    prefer =  if prefer == :default, do: :standard, else: prefer
 
     with {:ok, in_locale} <- Cldr.validate_locale(in_locale, backend) do
       options = Keyword.put(options, :locale, in_locale)
 
       {:ok, display_names} =
         Module.concat(in_locale.backend, :LocaleDisplay).display_names(in_locale)
 
-      match_fun = &language_match_fun(&1, &2, display_names.language)
-
-      case first_match(
-             language_tag,
-             match_fun,
-             @omit_script_if_only_one,
-             language_display,
-             prefer
-           ) do
-        {language_name, matched_tags} ->
-          language_tag = merge_extensions_and_private_use(language_tag)
-
-          subtag_names =
-            language_tag
-            |> subtag_names(@basic_tag_order -- matched_tags, display_names, prefer)
-            |> List.flatten()
-            |> Enum.map(&replace_parens_with_brackets/1)
-            |> join_subtags(display_names)
-
-          extension_names =
-            @extension_order
-            |> Enum.map(&Cldr.DisplayName.display_name(Map.fetch!(language_tag, &1), options))
-            |> Enum.reject(&empty?/1)
-            |> join_subtags(display_names)
-
-          {:ok, format_display_name(language_name, subtag_names, extension_names, display_names)}
-
-        nil ->
-          {:error,
-           {Cldr.DisplayName.NoDataError,
-            "The locale #{inspect(in_locale)} has no display name data."}}
-      end
+      match_fun =
+        &language_match_fun(&1, &2, :language, prefer, display_names)
+
+      {matched_tags, language_name} =
+        first_match(language_tag, match_fun, @omit_script_if_only_one, standard_or_dialect)
+
+      language_tag =
+        merge_extensions_and_private_use(language_tag)
+
+      subtag_names =
+        language_tag
+        |> subtag_names(@basic_tag_order -- matched_tags, prefer, display_names)
+        |> List.flatten()
+        |> Enum.map(&replace_parens_with_brackets/1)
+        |> join_subtags(display_names)
+
+      extension_names =
+        @extension_order
+        |> Enum.map(&Cldr.DisplayName.display_name(Map.fetch!(language_tag, &1), options))
+        |> Enum.reject(&empty?/1)
+        |> join_subtags(display_names)
+
+      {:ok, format_display_name(language_name, subtag_names, extension_names, display_names)}
     end
   end
 
+  defp default_options do
+    [
+      prefer: :standard,
+      add_likely_subtags: false,
+      language_display: :standard,
+      prefer: :standar
+    ]
+  end
+
   @doc """
   Returns a localised display name for a
   locale.
@@ -186,7 +191,7 @@ defmodule Cldr.LocaleDisplay do
 
   * `:prefer` signals the preferred name for
     a subtag when there are alternatives.
-    The default is `:default`. Few subtags
+    The default is `:standard`. Few subtags
     provide alternative renderings. Some of
     the alternative preferences are`:short`,
     `:long`, `:menu` and `:variant`.
@@ -249,30 +254,24 @@ defmodule Cldr.LocaleDisplay do
 
   # If matching on the compound locale then we
   # don't need to take any action
-  defp first_match(language_tag, match_fun, omit_script_if_only_one?, :dialect, prefer) do
-    case Cldr.Locale.first_match(language_tag, match_fun, omit_script_if_only_one?) do
-      {language_name, matched_tags} ->
-        {get_display_preference(language_name, prefer), matched_tags}
-
-      nil ->
-        nil
-    end
+  defp first_match(language_tag, match_fun, omit_script_if_only_one?, :dialect) do
+    Cldr.Locale.first_match(language_tag, match_fun, omit_script_if_only_one?)
   end
 
   # If we don't want a compound language then we need to omit
   # the territory when matching but restore it afterwards so
   # its generated as a subtag
   @reinstate_subtags [:territory, :script]
 
-  defp first_match(language_tag, match_fun, omit_script_if_only_one?, :standard, prefer) do
+  defp first_match(language_tag, match_fun, omit_script_if_only_one?, :standard) do
     language_tag =
       Enum.reduce(@reinstate_subtags, language_tag, fn key, tag ->
         Map.put(tag, key, nil)
       end)
 
     case Cldr.Locale.first_match(language_tag, match_fun, omit_script_if_only_one?) do
-      {language_name, matched_tags} ->
-        {get_display_preference(language_name, prefer), matched_tags -- @reinstate_subtags}
+      {matched_tags, display_name} ->
+        {matched_tags -- @reinstate_subtags, display_name}
 
       nil ->
         nil
@@ -297,11 +296,11 @@ defmodule Cldr.LocaleDisplay do
     |> List.to_string()
   end
 
-  defp subtag_names(_locale, [], _display_names, _prefer) do
+  defp subtag_names(_locale, [],  _prefer, _display_names) do
     []
   end
 
-  defp subtag_names(locale, subtags, display_names, prefer) do
+  defp subtag_names(locale, subtags, prefer, display_names) do
     subtags
     |> Enum.map(&get_display_name(locale, display_names, &1, prefer))
     |> Enum.reject(&empty?/1)
@@ -359,9 +358,9 @@ defmodule Cldr.LocaleDisplay do
     Enum.reduce(fields, &Cldr.Substitution.substitute([&2, &1], join_pattern))
   end
 
-  defp language_match_fun(locale_name, matched_tags, language_names) do
-    if display_name = Map.get(language_names, locale_name) do
-      {display_name, matched_tags}
+  defp language_match_fun(locale_name, matched_tags, field, prefer, display_names) do
+    if display_name = get_in(display_names, [field, locale_name, prefer]) do
+      {matched_tags, display_name}
     else
       nil
     end

lib/cldr/locale_display/t.ex

@@ -30,15 +30,15 @@ defmodule Cldr.LocaleDisplay.T do
   # Returns the localised value for the key. If there is
   # no available key name then just return the value.
 
-  defp display_value(:language, _key_name, value, transform, _in_locale, display_names, _prefer) do
+  defp display_value(:language, _key_name, value, transform, in_locale, display_names, prefer) do
     key_name =
       if transform.h0 == :hybrid,
         do: get_in(display_names, [:types, :h0, :hybrid]),
         else: get_in(display_names, [:keys, :t])
 
     value_name =
       value
-      |> Cldr.display_name()
+      |> Cldr.LocaleDisplay.display_name!(prefer: prefer, locale: in_locale)
       |> replace_parens_with_brackets()
 
     if key_name do

lib/cldr/locale_display/u.ex

@@ -126,25 +126,28 @@ defmodule Cldr.LocaleDisplay.U do
     backend_module.known_subdivisions(locale)[subdivision]
   end
 
-  def get_timezone(zone, locale) do
+  def get_timezone(timezone, locale) do
     backend_module = Module.concat(locale.backend, LocaleDisplay)
-    {:ok, zone_names} = backend_module.time_zone_names(locale)
     {:ok, territory_format} = backend_module.territory_format(locale)
-    zone_parts = String.split(zone, "/")
-    downcase_zone_parts = Enum.map(zone_parts, &String.downcase/1)
 
-    case get_in(zone_names, downcase_zone_parts) do
-      nil ->
-        derive_zone_name(zone, zone_names, downcase_zone_parts, zone_parts, territory_format)
+    with {:ok, display_name} <- timezone_display_name(timezone, locale) do
+      Cldr.Substitution.substitute([display_name], territory_format)
+    end
+  end
+
+  def timezone_display_name(timezone, locale) do
+    cond do
+      territory = territory_has_only_this_zone(timezone) ->
+        Cldr.Territory.display_name(territory, locale: locale)
 
-      zone_map ->
-        case Map.get(zone_map, :exemplar_city) do
-          nil ->
-            derive_zone_name(zone, zone_names, downcase_zone_parts, zone_parts, territory_format)
+      exemplar_city = exemplar_city(timezone, locale) ->
+        {:ok, exemplar_city}
 
-          exemplar_city ->
-            Cldr.Substitution.substitute([exemplar_city], territory_format)
-        end
+      derived_name = derive_zone_name(timezone, locale) ->
+        {:ok, derived_name}
+
+      true ->
+        {:ok, timezone}
     end
   end
 
@@ -153,23 +156,36 @@ defmodule Cldr.LocaleDisplay.U do
   # the second part as a city name by replacing "_" with " ". This applies to zones like
   # "America/Los_Angeles", "America/New_York" and so on.
 
-  defp derive_zone_name(zone, zone_names, downcase_zone_parts, zone_parts, territory_format) do
-    with [downcase_region, _downcase_city] <- downcase_zone_parts do
-      case Map.get(zone_names, downcase_region) do
-        nil ->
-          zone
-
-        _region ->
-          [_region, city] = zone_parts
-          zone_name = String.replace(city, "_", " ")
-          Cldr.Substitution.substitute([zone_name], territory_format)
-      end
-    else
-      _other ->
-        zone
+  defp derive_zone_name(zone, locale) do
+    backend_module = Module.concat(locale.backend, LocaleDisplay)
+    {:ok, zone_names} = backend_module.time_zone_names(locale)
+    zone_parts = String.split(zone, "/")
+    downcase_zone_parts = Enum.map(zone_parts, &String.downcase/1)
+
+    if Map.get(zone_names, hd(downcase_zone_parts)) do
+      zone_parts
+      |> List.last()
+      |> String.replace("_", " ")
+    end
+  end
+
+  defp territory_has_only_this_zone(zone) do
+    territory = Cldr.Timezone.territories_by_timezone[zone]
+
+    if Cldr.Timezone.timezone_count_for_territory(territory) == 1 do
+      territory
     end
   end
 
+  defp exemplar_city(zone, locale) do
+    backend_module = Module.concat(locale.backend, LocaleDisplay)
+    {:ok, zone_names} = backend_module.time_zone_names(locale)
+    zone_parts = String.split(zone, "/")
+    downcase_zone_parts = Enum.map(zone_parts, &String.downcase/1)
+
+    get_in(zone_names, downcase_zone_parts ++ [:exemplar_city])
+  end
+
   def get_currency(currency, locale) do
     case Cldr.Currency.currency_for_code(currency, locale.backend) do
       {:ok, currency} -> currency.symbol

mix.exs

@@ -1,7 +1,7 @@
 defmodule Cldr.LocaleDisplay.MixProject do
   use Mix.Project
 
-  @version "1.6.2"
+  @version "1.7.0"
 
   def project do
     [

test/locale_display_name_test.exs

@@ -60,10 +60,10 @@ defmodule Cldr.LocaleDisplayName.Test do
     assert Cldr.display_name(~l(zh-Hans), language_display: :dialect) ==
              "Simplified Chinese (China)"
 
-    assert Cldr.display_name(~l(zh-Hant)u) == "Chinese (Traditional)"
-    assert Cldr.display_name(~l(zh-Hans)u) == "Chinese (Simplified)"
-    assert Cldr.display_name(~l(zh-Hant)) == "Chinese (Traditional, Taiwan)"
-    assert Cldr.display_name(~l(zh-Hans)) == "Chinese (Simplified, China)"
+    assert Cldr.display_name(~l(zh-Hant)u) == "Traditional Chinese"
+    assert Cldr.display_name(~l(zh-Hans)u) == "Simplified Chinese"
+    assert Cldr.display_name(~l(zh-Hant)) == "Traditional Chinese (Taiwan)"
+    assert Cldr.display_name(~l(zh-Hans)) == "Simplified Chinese (China)"
   end
 
   test "More complex language tags" do