Remove some cruft from Version and fix to_string/1

Author: meh

lib/elixir/lib/version.ex

@@ -417,49 +417,45 @@ defmodule Version do
     defp to_condition([:'>', version | _]) do
       {major, minor, patch, pre} = parse_condition(version)
 
-      {:andalso, {:not, {:is_binary, :'$1'}},
-                 {:orelse, {:'>', {{:'$1', :'$2', :'$3'}},
-                                  {:const, {major, minor, patch}}},
-                           {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
-                                                  {:const, {major, minor, patch}}},
-                           {:orelse, {:andalso, {:'==', {:length, :'$4'}, 0},
-                                                {:'/=', length(pre), 0}},
-                                     {:andalso, {:'/=', length(pre), 0},
-                                                {:orelse, {:'>', {:length, :'$4'}, length(pre)},
-                                                {:andalso, {:'==', {:length, :'$4'}, length(pre)},
-                                                           {:'>', :'$4', {:const, pre}}}}}}}}}
+      {:orelse, {:'>', {{:'$1', :'$2', :'$3'}},
+                       {:const, {major, minor, patch}}},
+                {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
+                                        {:const, {major, minor, patch}}},
+                {:orelse, {:andalso, {:'==', {:length, :'$4'}, 0},
+                                     {:'/=', length(pre), 0}},
+                          {:andalso, {:'/=', length(pre), 0},
+                                     {:orelse, {:'>', {:length, :'$4'}, length(pre)},
+                                     {:andalso, {:'==', {:length, :'$4'}, length(pre)},
+                                                {:'>', :'$4', {:const, pre}}}}}}}}
     end
 
     defp to_condition([:'>=', version | _]) do
       matchable = parse_condition(version)
 
-      {:orelse, {:andalso, {:not, {:is_binary, :'$1'}},
-                           {:'==', :'$_', {:const, matchable}}},
-                 to_condition([:'>', version])}
+      {:orelse, {:'==', :'$_', {:const, matchable}},
+                to_condition([:'>', version])}
     end
 
     defp to_condition([:'<', version | _]) do
       {major, minor, patch, pre} = parse_condition(version)
 
-      {:andalso, {:not, {:is_binary, :'$1'}},
-                 {:orelse, {:'<', {{:'$1', :'$2', :'$3'}},
-                                  {:const, {major, minor, patch}}},
-                           {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
-                                              {:const, {major, minor, patch}}},
-                           {:orelse, {:andalso, {:'/=', {:length, :'$4'}, 0},
-                                                {:'==', length(pre), 0}},
-                                     {:andalso, {:'/=', {:length, :'$4'}, 0},
-                                     {:orelse, {:'<', {:length, :'$4'}, length(pre)},
-                                               {:andalso, {:'==', {:length, :'$4'}, length(pre)},
-                                                          {:'<', :'$4', {:const, pre}}}}}}}}}
+      {:orelse, {:'<', {{:'$1', :'$2', :'$3'}},
+                       {:const, {major, minor, patch}}},
+                {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
+                                   {:const, {major, minor, patch}}},
+                {:orelse, {:andalso, {:'/=', {:length, :'$4'}, 0},
+                                     {:'==', length(pre), 0}},
+                          {:andalso, {:'/=', {:length, :'$4'}, 0},
+                          {:orelse, {:'<', {:length, :'$4'}, length(pre)},
+                                    {:andalso, {:'==', {:length, :'$4'}, length(pre)},
+                                               {:'<', :'$4', {:const, pre}}}}}}}}
     end
 
     defp to_condition([:'<=', version | _]) do
       matchable = parse_condition(version)
 
-      {:orelse, {:andalso, {:not, {:is_binary, :'$1'}},
-                           {:'==', :'$_', {:const, matchable}}},
-                 to_condition([:'<', version])}
+      {:orelse, {:'==', :'$_', {:const, matchable}},
+                to_condition([:'<', version])}
     end
 
     defp to_condition(current, []) do
@@ -491,7 +487,7 @@ end
 
 defimpl String.Chars, for: Version do
   def to_string(version) do
-    pre = if pre = version.pre, do: "-#{pre}"
+    pre = unless Enum.empty?(pre = version.pre), do: "-#{pre}"
     build = if build = version.build, do: "+#{build}"
     "#{version.major}.#{version.minor}.#{version.patch}#{pre}#{build}"
   end

lib/elixir/test/elixir/version_test.exs

@@ -67,6 +67,13 @@ defmodule VersionTest do
     assert :error = V.parse("2.3.0-01")
   end
 
+  test "to_string" do
+    assert V.parse("1.0.0") |> elem(1) |> to_string == "1.0.0"
+    assert V.parse("1.0.0-dev") |> elem(1) |> to_string == "1.0.0-dev"
+    assert V.parse("1.0.0+lol") |> elem(1) |> to_string == "1.0.0+lol"
+    assert V.parse("1.0.0-dev+lol") |> elem(1) |> to_string == "1.0.0-dev+lol"
+  end
+
   test "invalid match" do
     assert_raise V.InvalidVersion, fn ->
       V.match?("foo", "2.3.0")