Serialize constraints as version requirements

Author: ericmj

lib/hex_solver.ex

@@ -24,7 +24,7 @@ defmodule HexSolver do
   @type result() :: %{package() => {Version.t(), repo()}}
   @opaque constraint() :: HexSolver.Requirement.t()
 
-  alias HexSolver.{Failure, Requirement, Solver}
+  alias HexSolver.{Constraint, Failure, Requirement, Solver}
 
   @doc """
   Runs the version solver.
@@ -83,4 +83,14 @@ defmodule HexSolver do
   def parse_constraint!(string) do
     Requirement.to_constraint!(string)
   end
+
+  @doc """
+  Serializes an internal solver constraint as an Elixir version requirement.
+  """
+  @spec constraint_to_requirement!(constraint()) :: String.t()
+  def constraint_to_requirement!(constraint) do
+    requirement = Constraint.to_requirement(constraint)
+    Version.parse_requirement!(requirement)
+    requirement
+  end
 end

lib/hex_solver/constraint.ex

@@ -10,4 +10,5 @@ defprotocol HexSolver.Constraint do
   def intersect(left, right)
   def union(left, right)
   def compare(left, right)
+  def to_requirement(constraint)
 end

lib/hex_solver/constraints/empty.ex

@@ -34,6 +34,10 @@ defmodule HexSolver.Constraints.Empty do
       clauses: []
   end
 
+  def to_requirement(%Empty{}) do
+    "< 0.0.0-0"
+  end
+
   def to_string(%Empty{}) do
     "empty"
   end

lib/hex_solver/constraints/impl.ex

@@ -32,6 +32,9 @@ defmodule HexSolver.Constraints.Impl do
 
         def compare(left, right),
           do: unquote(__CALLER__.module).compare(left, right)
+
+        def to_requirement(constraint),
+          do: unquote(__CALLER__.module).to_requirement(constraint)
       end
     end
   end

lib/hex_solver/constraints/range.ex

@@ -381,6 +381,14 @@ defmodule HexSolver.Constraints.Range do
   def normalize(%Range{} = range), do: range
   def normalize(%Elixir.Version{} = version), do: version
 
+  def to_requirement(%Range{min: nil, max: nil}) do
+    ">= 0.0.0-0"
+  end
+
+  def to_requirement(%Range{} = range) do
+    Range.to_string(range)
+  end
+
   def to_string(%Range{min: nil, max: nil}) do
     "any"
   end

lib/hex_solver/constraints/union.ex

@@ -152,6 +152,10 @@ defmodule HexSolver.Constraints.Union do
   defp maybe_to_range(%Elixir.Version{} = version), do: Version.to_range(version)
   defp maybe_to_range(other), do: other
 
+  def to_requirement(%Union{ranges: ranges}) do
+    Enum.map_join(ranges, " or ", &Constraint.to_requirement/1)
+  end
+
   def to_string(%Union{ranges: ranges}) do
     Enum.map_join(ranges, " or ", &Kernel.to_string/1)
   end

lib/hex_solver/constraints/version.ex

@@ -99,6 +99,10 @@ defmodule HexSolver.Constraints.Version do
     end
   end
 
+  def to_requirement(%Version{} = version) do
+    Kernel.to_string(version)
+  end
+
   def max(left, right) do
     case compare(left, right) do
       :lt -> right

lib/hex_solver/requirement.ex

@@ -1,7 +1,7 @@
 defmodule HexSolver.Requirement do
   @moduledoc false
 
-  alias HexSolver.Constraints.{Range, Util}
+  alias HexSolver.Constraints.{Empty, Range, Util}
   alias HexSolver.Requirement.Parser
 
   @allowed_range_ops [:>, :>=, :<, :<=, :~>]
@@ -43,7 +43,9 @@ defmodule HexSolver.Requirement do
   end
 
   defp delex([], acc) do
-    Util.union(acc)
+    acc
+    |> Enum.map(&normalize_constraint/1)
+    |> Util.union()
   end
 
   defp delex([op | rest], acc) when op in [:||, :or] do
@@ -144,6 +146,24 @@ defmodule HexSolver.Requirement do
   defp to_version({major, minor, patch, pre, _build}),
     do: %Elixir.Version{major: major, minor: minor, patch: patch, pre: pre}
 
+  defp normalize_constraint(%Range{
+         max: %Elixir.Version{major: 0, minor: 0, patch: 0, pre: [0]},
+         include_max: false
+       }) do
+    %Empty{}
+  end
+
+  defp normalize_constraint(
+         %Range{
+           min: %Elixir.Version{major: 0, minor: 0, patch: 0, pre: [0]},
+           include_min: true
+         } = range
+       ) do
+    %{range | min: nil, include_min: false}
+  end
+
+  defp normalize_constraint(constraint), do: constraint
+
   # Vendored from https://github.com/elixir-lang/elixir/blob/0ff6522/lib/elixir/lib/version.ex#L495
   defmodule Parser do
     @moduledoc false

test/hex_solver/constraint_test.exs

@@ -179,4 +179,13 @@ defmodule HexSolver.ConstraintTest do
       end
     end
   end
+
+  property "constraint requirements round-trip" do
+    check all constraint <- constraint() do
+      requirement = Constraint.to_requirement(constraint)
+
+      assert {:ok, _requirement} = Version.parse_requirement(requirement)
+      assert HexSolver.parse_constraint!(requirement) == constraint
+    end
+  end
 end

test/hex_solver/constraints/empty_test.exs

@@ -17,6 +17,10 @@ defmodule HexSolver.Constraints.EmptyTest do
     assert Empty.to_string(%Empty{}) == "empty"
   end
 
+  test "to_requirement/1" do
+    assert Constraint.to_requirement(%Empty{}) == "< 0.0.0-0"
+  end
+
   test "Kernel.inspect/1" do
     assert inspect(%Empty{}) == "#Empty<>"
   end