1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
# Vendored from hex_solver v0.2.2 (2634e31), do not edit manually
defmodule Hex.Solver.Constraints.Version do
@moduledoc false
use Hex.Solver.Constraints.Impl, for: Version
import Kernel, except: [match?: 2]
alias Hex.Solver.Constraint
alias Hex.Solver.Constraints.{Empty, Range, Union, Util}
def any?(%Version{}), do: false
def empty?(%Version{}), do: false
def allows?(%Version{} = left, %Version{} = right), do: left == right
def allows_any?(%Version{}, %Empty{}), do: true
def allows_any?(%Version{} = left, right), do: Constraint.allows?(right, left)
def allows_all?(%Version{}, %Empty{}) do
true
end
def allows_all?(%Version{} = left, %Version{} = right) do
left == right
end
def allows_all?(%Version{}, %Range{min: nil}) do
false
end
def allows_all?(%Version{}, %Range{max: nil}) do
false
end
def allows_all?(%Version{} = version, %Range{
min: min,
max: max,
include_min: true,
include_max: true
}) do
version == min and version == max
end
def allows_all?(%Version{}, %Range{}) do
false
end
def allows_all?(%Version{} = version, %Union{ranges: ranges}) do
Enum.all?(ranges, &allows_all?(version, &1))
end
def difference(%Version{} = version, constraint) do
if Constraint.allows?(constraint, version), do: %Empty{}, else: version
end
def intersect(%Version{} = version, constraint) do
if Constraint.allows?(constraint, version), do: version, else: %Empty{}
end
def union(%Version{} = version, constraint) do
if Constraint.allows?(constraint, version) do
constraint
else
case constraint do
%Range{min: ^version} = range -> %{range | include_min: true}
%Range{max: ^version} = range -> %{range | include_max: true}
_ -> Util.union([version, constraint])
end
end
end
def compare(%Version{} = left, %Version{} = right) do
Version.compare(left, right)
end
def compare(%Version{} = version, %Range{min: min, include_min: include_min}) do
if min == nil do
:gt
else
case Version.compare(version, min) do
:eq when include_min -> :eq
:eq -> :lt
:lt -> :lt
:gt -> :gt
end
end
end
def compare(%Version{} = version, %Union{ranges: [range | _]}) do
compare(version, range)
end
def min(left, right) do
case compare(left, right) do
:lt -> left
:eq -> left
:gt -> right
end
end
def max(left, right) do
case compare(left, right) do
:lt -> right
:eq -> left
:gt -> left
end
end
def to_range(%Version{} = version) do
%Range{min: version, max: version, include_min: true, include_max: true}
end
def to_range(%Range{} = range) do
range
end
def prioritize(%Version{} = left, %Version{} = right) do
do_prioritize(left, right) == :gt
end
defp do_prioritize(left, right) do
cond do
left.pre != [] and right.pre == [] -> :lt
left.pre == [] and right.pre != [] -> :gt
true -> Version.compare(left, right)
end
end
end
|
