Deprecate is_regex/1 and is_range/1

Conflicts:
	lib/elixir/lib/string.ex

Author: José Valim

CHANGELOG.md

@@ -7,6 +7,7 @@
 
 * Deprecations
   * [Kernel] `%` for sigils is deprecated in favor of `~`
+  * [Kernel] `is_range/1` and `is_regex/1` are deprecated in favor of `Range.range?/1` and `Regex.regex?/1`
 
 * Backwards incompatible changes
 

lib/elixir/lib/kernel.ex

@@ -1739,23 +1739,19 @@ defmodule Kernel do
     end
   end
 
-  @doc """
-  Checks if the given argument is a regex.
-
-  Works in guard clauses.
-  """
+  @doc false
   defmacro is_regex(thing) do
+    IO.puts :stderr, "is_regex/1 is deprecated in favor of Regex.regex?/1\n" <>
+                     Exception.format_stacktrace(__CALLER__.stacktrace)
     quote do
       Kernel.is_record(unquote(thing), Regex)
     end
   end
 
-  @doc """
-  Checks if the given argument is a range.
-
-  Works in guard clauses.
-  """
+  @doc false
   defmacro is_range(thing) do
+    IO.puts :stderr, "is_range/1 is deprecated in favor of Range.range?/1\n" <>
+                     Exception.format_stacktrace(__CALLER__.stacktrace)
     quote do
       Kernel.is_record(unquote(thing), Range)
     end

lib/elixir/lib/range.ex

@@ -26,6 +26,20 @@ defmodule Range do
   def last({ Range, _, last }) do
     last
   end
+
+  @doc """
+  Returns true if the given argument is a range.
+
+  ## Examples
+
+      iex> Range.range?(1..3)
+      true
+      iex> Range.range?(0)
+      false
+
+  """
+  def range?({ Range, _, _ }), do: true
+  def range?(_), do: false
 end
 
 defprotocol Range.Iterator do

lib/elixir/lib/regex.ex

@@ -120,6 +120,20 @@ defmodule Regex do
     :re.run(string, compiled, [{ :capture, :none }]) == :match
   end
 
+  @doc """
+  Returns true if the given argument is a regex.
+
+  ## Examples
+
+      iex> Regex.regex?(~r/foo/)
+      true
+      iex> Regex.regex?(0)
+      false
+
+  """
+  def regex?(regex()), do: true
+  def regex?(_), do: false
+
   @doc """
   Runs the regular expression against the given string until the first match.
   It returns a list with all captures or `nil` if no match occurred.

lib/elixir/lib/string.ex

@@ -224,18 +224,18 @@ defmodule String do
 
   def split(binary, "", options), do: split(binary, ~r"", options)
 
-  def split(binary, pattern, options) when is_regex(pattern) do
-    Regex.split(pattern, binary, options)
-  end
-
   def split(binary, pattern, options) do
-    opts = if options[:global] != false, do: [:global], else: []
-    splits  = :binary.split(binary, pattern, opts)
-
-    if Keyword.get(options, :trim, false) do
-      lc split inlist splits, split != "", do: split
+    if Regex.regex?(pattern) do
+      Regex.split(pattern, binary, options)
     else
-      splits
+      opts = if options[:global] != false, do: [:global], else: []
+      splits = :binary.split(binary, pattern, opts)
+
+      if Keyword.get(options, :trim, false) do
+        lc split inlist splits, split != "", do: split
+      else
+        splits
+      end
     end
   end
 
@@ -521,13 +521,13 @@ defmodule String do
 
   def replace(subject, pattern, replacement, options \\ [])
 
-  def replace(subject, pattern, replacement, options) when is_regex(pattern) do
-    Regex.replace(pattern, subject, replacement, global: options[:global])
-  end
-
   def replace(subject, pattern, replacement, options) do
-    opts = translate_replace_options(options)
-    :binary.replace(subject, pattern, replacement, opts)
+    if Regex.regex?(pattern) do
+      Regex.replace(pattern, subject, replacement, global: options[:global])
+    else
+      opts = translate_replace_options(options)
+      :binary.replace(subject, pattern, replacement, opts)
+    end
   end
 
   defp translate_replace_options(options) do

lib/elixir/test/doc_test.exs

@@ -22,6 +22,7 @@ defmodule KernelTest do
   doctest OptionParser
   doctest Path
   doctest Protocol.Consolidation
+  doctest Range
   doctest Regex
   doctest Set
   doctest Stream

lib/elixir/test/elixir/range_test.exs

@@ -21,9 +21,9 @@ defmodule RangeTest do
     assert (1..3).last  == 3
   end
 
-  test :is_range do
-    assert is_range(range)
-    refute is_range(not_range)
+  test :range? do
+    assert Range.range?(1..3)
+    refute Range.range?(0)
   end
 
   test :enum do
@@ -46,12 +46,4 @@ defmodule RangeTest do
     assert inspect(1..3) == "1..3"
     assert inspect(3..1) == "3..1"
   end
-
-  defp range do
-    1..3
-  end
-
-  defp not_range do
-    1
-  end
 end

lib/elixir/test/elixir/regex_test.exs

@@ -17,8 +17,7 @@ defmodule RegexTest do
   end
 
   test :compile! do
-    assert is_record(Regex.compile!("foo"), Regex)
-    assert is_regex(Regex.compile!("foo"))
+    assert Regex.regex?(Regex.compile!("foo"))
 
     assert_raise Regex.CompileError, ~r/position 0$/, fn ->
       Regex.compile!("*foo")
@@ -27,7 +26,7 @@ defmodule RegexTest do
 
   test :compile do
     { :ok, regex } = Regex.compile("foo")
-    assert is_regex(regex)
+    assert Regex.regex?(regex)
     assert { :error, _ } = Regex.compile("*foo")
     assert { :error, _ } = Regex.compile("foo", "y")
   end
@@ -37,6 +36,11 @@ defmodule RegexTest do
     assert "foo\nbar" =~ regex
   end
 
+  test :regex? do
+    assert Regex.regex?(~r/foo/)
+    refute Regex.regex?(0)
+  end
+
   test :source do
     assert Regex.source(Regex.compile!("foo")) == "foo"
   end

lib/ex_unit/lib/ex_unit/assertions.ex

@@ -332,9 +332,9 @@ defmodule ExUnit.Assertions do
   def assert_raise(exception, message, function) when is_function(function) do
     error = assert_raise(exception, function)
 
-    is_match = case message do
-      re  when is_regex(re)   -> error.message =~ re
-      bin when is_binary(bin) -> error.message == bin
+    is_match = cond do
+      is_binary(message) -> error.message == message
+      Regex.regex?(message) -> error.message =~ message
     end
 
     assert is_match, message, error.message,

lib/mix/lib/mix/deps/loader.ex

@@ -55,44 +55,41 @@ defmodule Mix.Deps.Loader do
   """
   def vsn_match?(nil, _actual, _app),
     do: true
-  def vsn_match?(req, actual, _app) when is_regex(req),
-    do: actual =~ req
   def vsn_match?(req, actual, app) do
-    case Version.parse(actual) do
-      { :ok, version } ->
-        case Version.parse_requirement(req) do
-          { :ok, req } ->
-            Version.match?(version, req)
-          :error ->
-            raise Mix.Error, message: "Invalid requirement #{req} for app #{app}"
-        end
-
-      :error ->
-        raise Mix.Error, message: "The application #{app} specified a non Semantic Version #{actual}. " <>
-          "Mix can only match the requirement #{req} against Semantic Versions, to match against any " <>
-          "version, please use a regex as requirement"
+    if Regex.regex?(req) do
+      actual =~ req
+    else
+      case Version.parse(actual) do
+        { :ok, version } ->
+          case Version.parse_requirement(req) do
+            { :ok, req } ->
+              Version.match?(version, req)
+            :error ->
+              raise Mix.Error, message: "Invalid requirement #{req} for app #{app}"
+          end
+
+        :error ->
+          raise Mix.Error, message: "The application #{app} specified a non Semantic Version #{actual}. " <>
+            "Mix can only match the requirement #{req} against Semantic Versions, to match against any " <>
+            "version, please use a regex as requirement"
+      end
     end
   end
 
   ## Helpers
 
   defp to_dep(tuple, scms, from, manager \\ nil) do
-    dep = with_scm_and_app(tuple, scms).from(from).manager(manager)
-
-    if match?({ _, req, _ } when is_regex(req), tuple) and
-        not String.ends_with?(from, "rebar.config") do
-      invalid_dep_format(tuple)
-    end
-
-    dep
+    with_scm_and_app(tuple, scms).from(from).manager(manager)
   end
 
   defp with_scm_and_app({ app, opts }, scms) when is_atom(app) and is_list(opts) do
     with_scm_and_app({ app, nil, opts }, scms)
   end
 
-  defp with_scm_and_app({ app, req, opts }, scms) when is_atom(app) and
-      (is_binary(req) or is_regex(req) or req == nil) and is_list(opts) do
+  defp with_scm_and_app({ app, req, opts } = other, scms) when is_atom(app) and is_list(opts) do
+    unless is_binary(req) or Regex.regex?(req) or nil?(req) do
+      invalid_dep_format(other)
+    end
 
     dest  = Path.join(Mix.Project.deps_path, app)
     build = Path.join([Mix.Project.build_path, "lib", app])
@@ -148,8 +145,16 @@ defmodule Mix.Deps.Loader do
   end
 
   defp invalid_dep_format(dep) do
-    raise Mix.Error, message: ~s(Dependency specified in the wrong format: #{inspect dep}, ) <>
-      ~s(expected { app :: atom, opts :: Keyword.t } | { app :: atom, requirement :: String.t, opts :: Keyword.t })
+    raise Mix.Error, message: """
+    Dependency specified in the wrong format:
+
+        #{inspect dep}
+
+    Expected:
+
+        { app :: atom, opts :: Keyword.t } |
+        { app :: atom, requirement :: String.t | regex, opts :: Keyword.t }
+    """
   end
 
   ## Fetching