Continue supporting iodata in link/2

Author: José Valim

lib/phoenix_html/link.ex

@@ -176,32 +176,27 @@ defmodule Phoenix.HTML.Link do
     {value, opts}
   end
 
-  defp valid_destination!(to, calling_func) do
-    if invalid_destination?(to) do
-      raise ArgumentError, """
-      unsupported scheme given to #{calling_func}. In case you want to link to an
-      unknown or unsafe scheme, such as javascript, use a tuple: {:javascript, rest}
-      """
-    end
-
-    valid_destination!(to)
-  end
-  defp valid_destination!({:safe, to}) do
-    {:safe, valid_destination!(to)}
+  defp valid_destination!({:safe, to}, context) do
+    {:safe, valid_string_destination!(IO.iodata_to_binary(to), context)}
   end
-  defp valid_destination!({other, to}) when is_atom(other) do
+  defp valid_destination!({other, to}, _context) when is_atom(other) do
     [Atom.to_string(other), ?:, to]
   end
-  defp valid_destination!(to), do: to
+  defp valid_destination!(to, context) do
+    valid_string_destination!(IO.iodata_to_binary(to), context)
+  end
 
   for scheme <- @valid_uri_schemes do
-    defp invalid_destination?(unquote(scheme) <> _), do: false
+    defp valid_string_destination!(unquote(scheme) <> _ = string, _context), do: string
   end
-  defp invalid_destination?({scheme, _}) when is_atom(scheme) do
-    false
-  end
-  defp invalid_destination?(to) when is_binary(to) do
-    String.contains?(to, ":")
+  defp valid_string_destination!(to, context) do
+    if String.contains?(to, ":") do
+      raise ArgumentError, """
+      unsupported scheme given to #{context}. In case you want to link to an
+      unknown or unsafe scheme, such as javascript, use a tuple: {:javascript, rest}
+      """
+    else
+      to
+    end
   end
-  defp invalid_destination?(_), do: true
 end

test/phoenix_html/link_test.exs

@@ -35,10 +35,13 @@ defmodule Phoenix.HTML.LinkTest do
     assert safe_to_string(link("foo", to: {:javascript, "alert(1)"})) ==
            ~s[<a href="javascript:alert(1)">foo</a>]
 
+    assert safe_to_string(link("foo", to: {:javascript, 'alert(1)'})) ==
+           ~s[<a href="javascript:alert(1)">foo</a>]
+
     assert safe_to_string(link("foo", to: {:javascript, {:safe, "alert(1)"}})) ==
            ~s[<a href="javascript:alert(1)">foo</a>]
 
-    assert safe_to_string(link("foo", to: {:safe, {:javascript, "alert(1)"}})) ==
+    assert safe_to_string(link("foo", to: {:javascript, {:safe, 'alert(1)'}})) ==
            ~s[<a href="javascript:alert(1)">foo</a>]
   end
 
@@ -58,13 +61,17 @@ defmodule Phoenix.HTML.LinkTest do
       link(to: "/hello-world")
     end
 
-    msg = """
-          unsupported scheme given to link/2. In case you want to link to an
-          unknown or unsafe scheme, such as javascript, use a tuple: {:javascript, rest}
-          """
-    assert_raise ArgumentError, msg, fn ->
+    assert_raise ArgumentError, ~r"unsupported scheme given to link/2", fn ->
       link("foo", to: "javascript:alert(1)")
     end
+
+    assert_raise ArgumentError, ~r"unsupported scheme given to link/2", fn ->
+      link("foo", to: {:safe, "javascript:alert(1)"})
+    end
+
+    assert_raise ArgumentError, ~r"unsupported scheme given to link/2", fn ->
+      link("foo", to: {:safe, 'javascript:alert(1)'})
+    end
   end
 
   test "button with post (default)" do