Ensure File.cwd works with utf-8 file names

Author: José Valim

lib/elixir/lib/file.ex

@@ -922,7 +922,7 @@ defmodule File do
   """
   def cwd() do
     case F.get_cwd do
-      { :ok, cwd } -> { :ok, list_to_binary(cwd) }
+      { :ok, cwd } -> { :ok, :unicode.characters_to_binary(cwd) }
       { :error, _ } = error -> error
     end
   end
@@ -932,7 +932,7 @@ defmodule File do
   """
   def cwd!() do
     case F.get_cwd do
-      { :ok, cwd } -> list_to_binary(cwd)
+      { :ok, cwd } -> :unicode.characters_to_binary(cwd)
       { :error, reason } ->
           raise File.Error, reason: reason, action: "get current working directory"
     end

lib/elixir/lib/kernel/cli.ex

@@ -8,10 +8,10 @@ defmodule Kernel.CLI do
 
   # This is the API invoked by Elixir boot process.
   @doc false
-  def main(options) do
-    { config, argv } = process_argv(options, Kernel.CLI.Config.new)
-
+  def main(argv) do
     argv = lc arg inlist argv, do: list_to_binary(arg)
+
+    { config, argv } = process_argv(argv, Kernel.CLI.Config.new)
     :gen_server.call(:elixir_code_server, { :argv, argv })
 
     run fn ->
@@ -98,7 +98,7 @@ defmodule Kernel.CLI do
   end
 
   defp invalid_option(option) do
-    IO.puts(:stderr, "Unknown option #{list_to_binary(option)}")
+    IO.puts(:stderr, "Unknown option #{option}")
     System.halt(1)
   end
 
@@ -113,44 +113,44 @@ defmodule Kernel.CLI do
 
   # Process shared options
 
-  defp process_shared(['-v'|t], config) do
+  defp process_shared(["-v"|t], config) do
     IO.puts "Elixir #{System.version}"
     process_shared t, config
   end
 
-  defp process_shared(['--app',h|t], config) do
+  defp process_shared(["--app",h|t], config) do
     process_shared t, config.update_commands [{:app,h}|&1]
   end
 
-  defp process_shared(['--no-halt'|t], config) do
+  defp process_shared(["--no-halt"|t], config) do
     process_shared t, config.halt(false)
   end
 
-  defp process_shared(['-e',h|t], config) do
+  defp process_shared(["-e",h|t], config) do
     process_shared t, config.update_commands [{:eval,h}|&1]
   end
 
-  defp process_shared(['-pa',h|t], config) do
+  defp process_shared(["-pa",h|t], config) do
     Enum.each Path.wildcard(Path.expand(h)), Code.prepend_path(&1)
     process_shared t, config
   end
 
-  defp process_shared(['-pz',h|t], config) do
+  defp process_shared(["-pz",h|t], config) do
     Enum.each Path.wildcard(Path.expand(h)), Code.append_path(&1)
     process_shared t, config
   end
 
-  defp process_shared(['-r',h|t], config) do
+  defp process_shared(["-r",h|t], config) do
     process_shared t, Enum.reduce(Path.wildcard(h), config, fn path, config ->
       config.update_commands [{:require,path}|&1]
     end)
   end
 
-  defp process_shared(['-pr',h|t], config) do
+  defp process_shared(["-pr",h|t], config) do
     process_shared t, config.update_commands [{:parallel_require,h}|&1]
   end
 
-  defp process_shared([erl,_|t], config) when erl in ['--erl', '--sname', '--remsh', '--name'] do
+  defp process_shared([erl,_|t], config) when erl in ["--erl", "--sname", "--remsh", "--name"] do
     process_shared t, config
   end
 
@@ -160,15 +160,15 @@ defmodule Kernel.CLI do
 
   # Process init options
 
-  defp process_argv(['--'|t], config) do
+  defp process_argv(["--"|t], config) do
     { config, t }
   end
 
-  defp process_argv(['--compile'|t], config) do
+  defp process_argv(["--compile"|t], config) do
     process_compiler t, config
   end
 
-  defp process_argv(['-S',h|t], config) do
+  defp process_argv(["-S",h|t], config) do
     exec = System.find_executable(h)
     if exec do
       { config.update_commands([{:require,exec}|&1]), t }
@@ -180,7 +180,7 @@ defmodule Kernel.CLI do
 
   defp process_argv([h|t] = list, config) do
     case h do
-      '-' ++ _ ->
+      "-" <> _ ->
         shared_option? list, config, process_argv(&1, &2)
       _ ->
         { config.update_commands([{:require,h}|&1]), t }
@@ -193,32 +193,31 @@ defmodule Kernel.CLI do
 
   # Process compiler options
 
-  defp process_compiler(['--'|t], config) do
+  defp process_compiler(["--"|t], config) do
     { config, t }
   end
 
-  defp process_compiler(['-o',h|t], config) do
-    process_compiler t, config.output(list_to_binary(h))
+  defp process_compiler(["-o",h|t], config) do
+    process_compiler t, config.output(h)
   end
 
-  defp process_compiler(['--no-docs'|t], config) do
+  defp process_compiler(["--no-docs"|t], config) do
     process_compiler t, config.update_compiler_options([{:docs,false}|&1])
   end
 
-  defp process_compiler(['--no-debug-info'|t], config) do
+  defp process_compiler(["--no-debug-info"|t], config) do
     process_compiler t, config.update_compiler_options([{:debug_info,false}|&1])
   end
 
-  defp process_compiler(['--ignore-module-conflict'|t], config) do
+  defp process_compiler(["--ignore-module-conflict"|t], config) do
     process_compiler t, config.update_compiler_options([{:ignore_module_conflict,true}|&1])
   end
 
   defp process_compiler([h|t] = list, config) do
     case h do
-      '-' ++ _ ->
+      "-" <> _ ->
         shared_option? list, config, process_compiler(&1, &2)
       _ ->
-        h = list_to_binary(h)
         pattern = if File.dir?(h), do: "#{h}/**/*.ex", else: h
         process_compiler t, config.update_compile [pattern|&1]
     end
@@ -230,12 +229,12 @@ defmodule Kernel.CLI do
 
   # Process commands
 
-  defp process_command({:eval, expr}, _config) when is_list(expr) do
+  defp process_command({:eval, expr}, _config) when is_binary(expr) do
     Code.eval(expr, [])
   end
 
-  defp process_command({:app, app}, _config) when is_list(app) do
-    case Application.Behaviour.start(list_to_atom(app)) do
+  defp process_command({:app, app}, _config) when is_binary(app) do
+    case Application.Behaviour.start(binary_to_atom(app)) do
       { :error, reason } ->
         IO.puts(:stderr, "Could not start application #{app}: #{inspect reason}")
         System.halt(1)
@@ -244,12 +243,12 @@ defmodule Kernel.CLI do
     end
   end
 
-  defp process_command({:require, file}, _config) when is_list(file) do
-    Code.require_file(list_to_binary(file))
+  defp process_command({:require, file}, _config) when is_binary(file) do
+    Code.require_file(file)
   end
 
-  defp process_command({:parallel_require, pattern}, _config) when is_list(pattern) do
-    files = Path.wildcard(list_to_binary(pattern))
+  defp process_command({:parallel_require, pattern}, _config) when is_binary(pattern) do
+    files = Path.wildcard(pattern)
     files = Enum.uniq(files)
     files = Enum.filter files, File.regular?(&1)
     Kernel.ParallelRequire.files(files)

lib/elixir/lib/path.ex

@@ -309,12 +309,12 @@ defmodule Path do
 
   """
   def wildcard(glob) when is_binary(glob) do
-    paths = :elixir_glob.wildcard binary_to_list(glob)
-    Enum.map paths, list_to_binary(&1)
+    paths = :elixir_glob.wildcard :unicode.characters_to_list(glob)
+    Enum.map paths, :unicode.characters_to_binary(&1)
   end
 
   def wildcard(glob) when is_list(glob) do
-    :elixir_glob.wildcard(glob)
+    Enum.map wildcard(list_to_binary(glob)), binary_to_list(&1)
   end
 
   ## Helpers

lib/elixir/lib/system.ex

@@ -59,7 +59,7 @@ defmodule System do
   """
   def cwd do
     case :file.get_cwd do
-      { :ok, list } -> list_to_binary(list)
+      { :ok, list } -> :unicode.characters_to_binary(list)
       _ -> nil
     end
   end

lib/elixir/test/elixir/file_test.exs

@@ -1047,6 +1047,12 @@ defmodule FileTest do
     end
   end
 
+  test :cwd_and_cd_with_utf8 do
+    File.cd!(fixture_path("héllò"), fn ->
+      assert Path.basename(File.cwd!) == "héllò"
+    end)
+  end
+
   test :invalid_cd do
     assert File.cd(fixture_path("file.txt")) == { :error, :enotdir }
   end

lib/elixir/test/elixir/fixtures/héllò/.gitkeep

@@ -3,6 +3,11 @@ Code.require_file "../test_helper.exs", __FILE__
 defmodule PathTest do
   use ExUnit.Case, async: true
 
+  test :wildcard do
+    import PathHelpers
+    assert Path.wildcard(fixture_path("héllò")) == [fixture_path("héllò")]
+  end
+
   test :absname_with_binary do
     assert Path.absname("/foo/bar") == "/foo/bar"
     assert Path.absname("/foo/bar/") == "/foo/bar"

lib/elixir/test/elixir/path_test.exs

@@ -17,6 +17,14 @@ defmodule SystemTest do
     assert is_binary System.cwd!
   end
 
+  test :cwd_with_utf8 do
+    import PathHelpers
+
+    File.cd!(fixture_path("héllò"), fn ->
+      assert Path.basename(System.cwd!) == "héllò"
+    end)
+  end
+
   test :user_home do
     assert is_binary System.user_home
     assert is_binary System.user_home!