Provide :greek and :ascii mappings in String upcase/downcase/capitalize

Closes #7105.

Author: José Valim

lib/elixir/lib/string.ex

@@ -208,6 +208,8 @@ defmodule String do
   @type grapheme :: t
   @type pattern :: t | [t] | :binary.cp()
 
+  @conditional_mappings [:greek]
+
   @doc """
   Checks if a string contains only printable characters.
 
@@ -604,7 +606,12 @@ defmodule String do
   defdelegate normalize(string, form), to: String.Normalizer
 
   @doc """
-  Converts all characters in the given string to uppercase.
+  Converts all characters in the given string to uppercase according to `mode`.
+
+  `mode` may be `:default`, `:ascii` or `:greek`. The `:default` mode considers
+  all non-conditional transformations outlined in the Unicode standard. `:ascii`
+  uppercases only the letters a to z. `:greek` includes the context sensitive
+  mappings found in Greek.
 
   ## Examples
 
@@ -617,12 +624,38 @@ defmodule String do
       iex> String.upcase("olá")
       "OLÁ"
 
+  The `:ascii` mode ignores Unicode characters and provides a more
+  performant implementation when you know the string contains only
+  ASCII characters:
+
+      iex> String.upcase("olá", :ascii)
+      "OLá"
+
   """
-  @spec upcase(t) :: t
-  defdelegate upcase(binary), to: String.Casing
+  @spec upcase(t, :default | :ascii | :greek) :: t
+  def upcase(string, mode \\ :default)
+
+  def upcase(string, :default) when is_binary(string) do
+    String.Casing.upcase(string, "", :default)
+  end
+
+  def upcase(string, :ascii) when is_binary(string) do
+    for <<x <- string>>,
+        do: if(x >= ?a and x <= ?z, do: <<x - 32>>, else: <<x>>),
+        into: ""
+  end
+
+  def upcase(string, mode) when mode in @conditional_mappings do
+    String.Casing.upcase(string, "", mode)
+  end
 
   @doc """
-  Converts all characters in the given string to lowercase.
+  Converts all characters in the given string to lowercase according to `mode`.
+
+  `mode` may be `:default`, `:ascii` or `:greek`. The `:default` mode considers
+  all non-conditional transformations outlined in the Unicode standard. `:ascii`
+  lowercases only the letters A to Z. `:greek` includes the context sensitive
+  mappings found in Greek.
 
   ## Examples
 
@@ -635,18 +668,47 @@ defmodule String do
       iex> String.downcase("OLÁ")
       "olá"
 
+  The `:ascii` mode ignores Unicode characters and provides a more
+  performant implementation when you know the string contains only
+  ASCII characters:
+
+      iex> String.downcase("OLÁ", :ascii)
+      "olÁ"
+
+  And `:greek` properly handles the context sensitive sigma in Greek:
+
+      iex> String.downcase("ΣΣ")
+      "ςς"
+
+      iex> String.downcase("ΣΣ", :greek)
+      "σς"
+
   """
-  @spec downcase(t) :: t
-  defdelegate downcase(binary), to: String.Casing
+  @spec downcase(t, :default | :ascii | :greek) :: t
+  def downcase(string, mode \\ :default)
+
+  def downcase(string, :default) when is_binary(string) do
+    String.Casing.downcase(string, "", :default)
+  end
+
+  def downcase(string, :ascii) when is_binary(string) do
+    for <<x <- string>>,
+        do: if(x >= ?A and x <= ?Z, do: <<x + 32>>, else: <<x>>),
+        into: ""
+  end
+
+  def downcase(string, mode) when mode in @conditional_mappings do
+    String.Casing.downcase(string, "", mode)
+  end
 
   @doc """
   Converts the first character in the given string to
-  uppercase and the remainder to lowercase.
+  uppercase and the remainder to lowercase according to `mode`.
 
-  This relies on the titlecase information provided
-  by the Unicode Standard. Note this function makes
-  no attempt to capitalize all words in the string
-  (usually known as titlecase).
+  `mode` may be `:default`, `:ascii` or `:greek`. The `:default` mode considers
+  all non-conditional transformations outlined in the Unicode standard. `:ascii`
+  lowercases only the letters A to Z. `:greek` includes the context sensitive
+  mappings found in Greek.
 
   ## Examples
 
@@ -660,10 +722,17 @@ defmodule String do
       "Olá"
 
   """
-  @spec capitalize(t) :: t
-  def capitalize(string) when is_binary(string) do
-    {char, rest} = String.Casing.titlecase_once(string)
-    char <> downcase(rest)
+  @spec capitalize(t, :default | :ascii | :greek) :: t
+  def capitalize(string, mode \\ :default)
+
+  def capitalize(<<char, rest::binary>>, :ascii) do
+    char = if char >= ?a and char <= ?z, do: char - 32, else: char
+    <<char>> <> downcase(rest, :ascii)
+  end
+
+  def capitalize(string, mode) when is_binary(string) do
+    {char, rest} = String.Casing.titlecase_once(string, mode)
+    char <> downcase(rest, mode)
   end
 
   @doc false

lib/elixir/test/elixir/string_test.exs

@@ -164,8 +164,15 @@ defmodule StringTest do
   end
 
   test "downcase/1 with greek final sigma" do
-    assert String.downcase("ΣΣ") == "σς"
-    assert String.downcase("ΣΣ ΣΣ") == "σς σς"
+    assert String.downcase("ΣΣ") == "ςς"
+    assert String.downcase("ΣΣ ΣΣ") == "ςς ςς"
+
+    assert String.downcase("ΣΣ", :greek) == "σς"
+    assert String.downcase("ΣΣ ΣΣ", :greek) == "σς σς"
+  end
+
+  test "downcase/1 with ascii" do
+    assert String.downcase("OLÁ", :ascii) == "olÁ"
   end
 
   test "capitalize/1" do
@@ -188,6 +195,11 @@ defmodule StringTest do
     assert String.capitalize("fin") == "Fin"
   end
 
+  test "capitalize/1 with ascii" do
+    assert String.capitalize("àáâ", :ascii) == "àáâ"
+    assert String.capitalize("aáA", :ascii) == "Aáa"
+  end
+
   test "replace_leading/3" do
     assert String.replace_leading("aa abc   ", "a", "b") == "bb abc   "
     assert String.replace_leading("__ abc   ", "_", "b") == "bb abc   "

lib/elixir/unicode/properties.ex

@@ -105,33 +105,31 @@ defmodule String.Casing do
 
   # Downcase
 
-  def downcase(string) when is_binary(string), do: downcase(string, "")
-
-  defp downcase(<<0x03A3::utf8, codepoint::utf8, rest::bits>>, acc) do
+  def downcase(<<0x03A3::utf8, codepoint::utf8, rest::bits>>, acc, :greek) do
     downcased =
       case letter?(codepoint) do
         true -> 0x03C3
         false -> 0x03C2
       end
 
-    downcase(<<codepoint::utf8, rest::bits>>, <<acc::binary, downcased::utf8>>)
+    downcase(<<codepoint::utf8, rest::bits>>, <<acc::binary, downcased::utf8>>, :greek)
   end
 
-  defp downcase(<<0x03A3::utf8, rest::bits>>, acc) do
-    downcase(rest, <<acc::binary, 0x03C2::utf8>>)
+  def downcase(<<0x03A3::utf8, rest::bits>>, acc, mode) do
+    downcase(rest, <<acc::binary, 0x03C2::utf8>>, mode)
   end
 
   for {codepoint, _upper, lower, _title} <- codes, lower && lower != codepoint do
-    defp downcase(<<unquote(codepoint), rest::bits>>, acc) do
-      downcase(rest, acc <> unquote(lower))
+    def downcase(<<unquote(codepoint), rest::bits>>, acc, mode) do
+      downcase(rest, acc <> unquote(lower), mode)
     end
   end
 
-  defp downcase(<<char, rest::bits>>, acc) do
-    downcase(rest, <<acc::binary, char>>)
+  def downcase(<<char, rest::bits>>, acc, mode) do
+    downcase(rest, <<acc::binary, char>>, mode)
   end
 
-  defp downcase("", acc), do: acc
+  def downcase("", acc, _mode), do: acc
 
   # Sigma handling
 
@@ -149,35 +147,33 @@ defmodule String.Casing do
 
   # Upcase
 
-  def upcase(string) when is_binary(string), do: upcase(string, "")
-
   for {codepoint, upper, _lower, _title} <- codes, upper && upper != codepoint do
-    defp upcase(<<unquote(codepoint), rest::bits>>, acc) do
-      upcase(rest, acc <> unquote(upper))
+    def upcase(<<unquote(codepoint), rest::bits>>, acc, mode) do
+      upcase(rest, acc <> unquote(upper), mode)
     end
   end
 
-  defp upcase(<<char, rest::bits>>, acc) do
-    upcase(rest, <<acc::binary, char>>)
+  def upcase(<<char, rest::bits>>, acc, mode) do
+    upcase(rest, <<acc::binary, char>>, mode)
   end
 
-  defp upcase("", acc), do: acc
+  def upcase("", acc, _mode), do: acc
 
   # Titlecase once
 
-  def titlecase_once(""), do: {"", ""}
+  def titlecase_once("", _mode), do: {"", ""}
 
   for {codepoint, _upper, _lower, title} <- codes, title && title != codepoint do
-    def titlecase_once(unquote(codepoint) <> rest) do
+    def titlecase_once(unquote(codepoint) <> rest, _mode) do
       {unquote(title), rest}
     end
   end
 
-  def titlecase_once(<<char::utf8, rest::binary>>) do
+  def titlecase_once(<<char::utf8, rest::binary>>, _mode) do
     {<<char::utf8>>, rest}
   end
 
-  def titlecase_once(<<char, rest::binary>>) do
+  def titlecase_once(<<char, rest::binary>>, _mode) do
     {<<char>>, rest}
   end
 end