Merge pull request #1195 from alco/string-fixes

String fixes

Author: alco

lib/elixir/lib/string.ex

@@ -811,12 +811,24 @@ defmodule String do
   """
   @spec starts_with?(t, t | [t]) :: boolean
 
-  def starts_with?(string, prefixes) do
-    case :binary.match(string, prefixes) do
-      :nomatch -> false
-      {0, _}   -> true
-      _        -> false
-    end
+  def starts_with?(string, prefixes) when is_list(prefixes) do
+    Enum.any?(prefixes, do_starts_with(string, &1))
+  end
+
+  def starts_with?(string, prefix) do
+    do_starts_with(string, prefix)
+  end
+
+  defp do_starts_with(_, "") do
+    true
+  end
+
+  defp do_starts_with(string, prefix) when is_binary(prefix) do
+    match?({0,_}, :binary.match(string, prefix))
+  end
+
+  defp do_starts_with(_, _) do
+    raise ArgumentError
   end
 
   @doc """
@@ -836,18 +848,31 @@ defmodule String do
   @spec ends_with?(t, t | [t]) :: boolean
 
   def ends_with?(string, suffixes) when is_list(suffixes) do
+    Enum.any?(suffixes, do_ends_with(string, &1))
+  end
+
+  def ends_with?(string, suffix) do
+    do_ends_with(string, suffix)
+  end
+
+  defp do_ends_with(_, "") do
+    true
+  end
+
+  defp do_ends_with(string, suffix) when is_binary(suffix) do
     string_size = size(string)
-    Enum.any? suffixes, fn suffix ->
-      suffix_size = size(suffix)
-      (suffix_size <= string_size) and suffix == :binary.part(string, {string_size, -suffix_size})
-    end
+    suffix_size = size(suffix)
+    scope = {string_size - suffix_size, suffix_size}
+    (suffix_size <= string_size) and (:nomatch != :binary.match(string, suffix, [scope: scope]))
   end
 
-  def ends_with?(string, suffix), do: ends_with?(string, [ suffix ])
+  defp do_ends_with(_, _) do
+    raise ArgumentError
+  end
 
   @doc """
   Returns true if `string` contains match, otherwise false.
-  `matches` can be either a single match of a list of matches.
+  `matches` can be either a single string or a list of strings.
 
   ## Examples
 
@@ -859,13 +884,25 @@ defmodule String do
       false
 
   """
+  @spec contains?(t, t | [t]) :: boolean
+
   def contains?(string, matches) when is_list(matches) do
-    case :binary.match(string, matches) do
-      :nomatch -> false
-      _        -> true
-    end
+    Enum.any?(matches, do_contains(string, &1))
   end
 
-  def contains?(string, match), do: contains?(string, [ match ])
+  def contains?(string, match) do
+    do_contains(string, match)
+  end
+
+  defp do_contains(_, "") do
+    true
+  end
 
+  defp do_contains(string, match) when is_binary(match) do
+    :nomatch != :binary.match(string, match)
+  end
+
+  defp do_contains(_, _) do
+    raise ArgumentError
+  end
 end

lib/elixir/test/elixir/string_test.exs

@@ -281,6 +281,7 @@ defmodule StringTest do
   end
 
   test :starts_with? do
+    ## Normal cases ##
     assert String.starts_with? "hello", "he"
     assert String.starts_with? "hello", "hello"
     assert String.starts_with? "hello", ["hellö", "hell"]
@@ -289,9 +290,28 @@ defmodule StringTest do
     refute String.starts_with? "hello", "hellö"
     refute String.starts_with? "hello", ["hellö", "goodbye"]
     refute String.starts_with? "エリクシア", "仙丹"
+
+    ## Edge cases ##
+    assert String.starts_with? "", ""
+    assert String.starts_with? "", ["", "a"]
+    assert String.starts_with? "b", ["", "a"]
+
+    assert String.starts_with? "abc", ""
+    assert String.starts_with? "abc", [""]
+
+    refute String.starts_with? "", "abc"
+    refute String.starts_with? "", [" "]
+
+    ## Sanity checks ##
+    assert String.starts_with? "", ["", ""]
+    assert String.starts_with? "abc", ["", ""]
+    assert_raise ArgumentError, fn ->
+      String.starts_with? "abc", [["a"], "a"]
+    end
   end
 
   test :ends_with? do
+    ## Normal cases ##
     assert String.ends_with? "hello", "lo"
     assert String.ends_with? "hello", "hello"
     assert String.ends_with? "hello", ["hell", "lo", "xx"]
@@ -301,15 +321,49 @@ defmodule StringTest do
     refute String.ends_with? "hello", "hellö"
     refute String.ends_with? "hello", ["hel", "goodbye"]
     refute String.ends_with? "エリクシア", "仙丹"
+
+    ## Edge cases ##
+    assert String.ends_with? "", ""
+    assert String.ends_with? "", ["", "a"]
+    refute String.ends_with? "", ["a", "b"]
+
+    assert String.ends_with? "abc", ""
+    assert String.ends_with? "abc", ["", "x"]
+
+    refute String.ends_with? "", "abc"
+    refute String.ends_with? "", [" "]
+
+    ## Sanity checks ##
+    assert String.ends_with? "", ["", ""]
+    assert String.ends_with? "abc", ["", ""]
+    assert_raise ArgumentError, fn ->
+      String.ends_with? "abc", [["c"], "c"]
+    end
   end
 
   test :contains? do
+    ## Normal cases ##
     assert String.contains? "elixir of life", "of"
     assert String.contains? "エリクシア", "シ"
     assert String.contains? "elixir of life", ["mercury", "life"]
     refute String.contains? "exlixir of life", "death"
     refute String.contains? "エリクシア", "仙"
     refute String.contains? "elixir of life", ["death", "mercury", "eternal life"]
+
+    ## Edge cases ##
+    assert String.contains? "", ""
+    assert String.contains? "abc", ""
+    assert String.contains? "abc", ["", "x"]
+
+    refute String.contains? "", " "
+    refute String.contains? "", "a"
+
+    ## Sanity checks ##
+    assert String.contains? "", ["", ""]
+    assert String.contains? "abc", ["", ""]
+    assert_raise ArgumentError, fn ->
+      String.contains? "abc", [["b"], "b"]
+    end
   end
 
 end