8f48423e47cc981c6dc639f5abf2f48daeddd137-PR-278

Committed 04 Sep 2023 03:04AM UTC coverage: 83.909% (-0.2%) from 84.107%

Build # 8f48423e47cc981c6dc639f5abf2f48daeddd137-PR-278

Build Type

Pull #278

github

Committed by

web-flow

Commit Message

Bump dialyxir from 1.4.0 to 1.4.1

Bumps [dialyxir](https://github.com/jeremyjh/dialyxir) from 1.4.0 to 1.4.1.
- [Release notes](https://github.com/jeremyjh/dialyxir/releases)
- [Changelog](https://github.com/jeremyjh/dialyxir/blob/master/CHANGELOG.md)
- [Commits](https://github.com/jeremyjh/dialyxir/compare/1.4.0...1.4.1)

---
updated-dependencies:
- dependency-name: dialyxir
  dependency-type: direct:development
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #278: Bump dialyxir from 1.4.0 to 1.4.1

Run Details

850 of 1013 relevant lines covered (83.91%)

203.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.29

/lib/k8s/version.ex

defmodule K8s.Version do
  @moduledoc """
  Kubernetes [API Versioning](https://kubernetes.io/docs/concepts/overview/kubernetes-api/#api-versioning)
  """
  alias K8s.Version

  @type t :: %__MODULE__{major: pos_integer, minor: binary, patch: pos_integer}
  defstruct [:major, :minor, :patch]

  @pattern ~r/v(?<major>\d{1,})(?<minor>(alpha|beta)?)(?<patch>\d{0,})/

  @doc """
  Returns the recommended version from a list of versions.

  It will return the most stable version if any, otherwise the newest "*edge*" version.

  ## Examples

      iex> K8s.Version.recommended(["v1beta1", "v1", "v2"])
      "v2"

      iex> K8s.Version.recommended(["v1beta1", "v1"])
      "v1"

      iex> K8s.Version.recommended(["v1beta2", "v1beta1"])
      "v1beta2"

      iex> K8s.Version.recommended(["v1alpha1", "v1alpha2", "v1beta1"])
      "v1beta1"

  """
  @spec recommended(list(binary)) :: binary
  def recommended(versions) do
    versions
    |> parse_list
    |> sort
    |> List.first()
    |> serialize
  end

  @doc """
  Sorts a list of `K8s.Version`s

  ## Examples

      iex> raw_versions = Enum.shuffle(["v1", "v2beta1", "v2", "v1alpha1", "v1alpha2"])
      iex> versions = raw_versions |> Enum.map(&(K8s.Version.parse(&1)))
      iex> sorted_versions = versions |> K8s.Version.sort()
      iex> sorted_versions |> Enum.map(&(K8s.Version.serialize(&1)))
      ["v2", "v1", "v2beta1", "v1alpha2", "v1alpha1"]

  """
  @spec sort(list(t)) :: list(t)
  def sort(versions), do: Enum.sort(versions, &compare/2)

  @spec compare(t, t) :: boolean
  defp compare(%Version{minor: "stable", major: a}, %Version{minor: "stable", major: b}),
    do: a >= b

  defp compare(%Version{minor: "stable"}, _), do: true
  defp compare(_, %Version{minor: "stable"}), do: false

  defp compare(%Version{minor: "beta"}, %Version{minor: "alpha"}), do: true
  defp compare(%Version{minor: "alpha"}, %Version{minor: "beta"}), do: false

  # Guard here catches case where minor is the same and major is greater.
  # If using >= it will get a flakey result when everything is the same except patch level
  defp compare(%Version{minor: m, major: a}, %Version{minor: m, major: b}) when a > b, do: true

  defp compare(%Version{patch: a}, %Version{patch: b}), do: a >= b
  defp compare(_, _), do: false

  @doc """
  Returns only stable versions

  ## Examples

      iex> K8s.Version.serialize(%K8s.Version{major: 1, minor: "stable", patch: nil})
      "v1"

      iex> K8s.Version.serialize(%K8s.Version{major: 1, minor: "beta", patch: 1})
      "v1beta1"

      iex> K8s.Version.serialize(%K8s.Version{major: 1, minor: "alpha", patch: 1})
      "v1alpha1"

  """
  @spec serialize(Version.t()) :: binary
  def serialize(%Version{major: major, minor: "stable"}), do: "v#{major}"

  def serialize(%Version{major: major, minor: minor, patch: patch}),
    do: "v#{major}#{minor}#{patch}"

  @doc """
  Returns only stable versions

  ## Examples

      iex> K8s.Version.stable(["v1alpha1", "v1", "v2beta1"])
      [%K8s.Version{major: 1, minor: "stable", patch: nil}]

  """
  @spec stable(list(binary)) :: list(Version.t())
  def stable(versions), do: parse_filter(versions, "stable")

  @doc """
  Returns only alpha versions

  ## Examples

      iex> K8s.Version.alpha(["v1alpha1", "v1", "v2beta1"])
      [%K8s.Version{major: 1, minor: "alpha", patch: 1}]

  """
  @spec alpha(list(binary)) :: list(Version.t())
  def alpha(versions), do: parse_filter(versions, "alpha")

  @doc """
  Returns only beta versions

  ## Examples

      iex> K8s.Version.beta(["v1alpha1", "v1", "v2beta1"])
      [%K8s.Version{major: 2, minor: "beta", patch: 1}]

  """
  @spec beta(list(binary)) :: list(Version.t())
  def beta(versions), do: parse_filter(versions, "beta")

  @doc """
  Retuns all non-stable versions

  ## Examples

      iex> K8s.Version.edge(["v1alpha1", "v1", "v2beta1"])
      [%K8s.Version{major: 1, minor: "alpha", patch: 1}, %K8s.Version{major: 2, minor: "beta", patch: 1}]

  """
  @spec edge(list(binary)) :: list(Version.t())
  def edge(versions), do: alpha(versions) ++ beta(versions)

  @spec parse_filter(list(binary), binary) :: list(Version.t())
  defp parse_filter(versions, keep) do
    versions
    |> parse_list
    |> Enum.filter(&is(&1, keep))
  end

  @spec is(Version.t(), binary) :: boolean()
  defp is(%Version{minor: minor}, minor), do: true
  defp is(_, _), do: false

  @doc """
  Parses a Kubernetes API version into a `K8s.Version` struct

  ## Examples

      iex> K8s.Version.parse("v1")
      %K8s.Version{major: 1, minor: "stable", patch: nil}

      iex> K8s.Version.parse("v1beta2")
      %K8s.Version{major: 1, minor: "beta", patch: 2}

      iex> K8s.Version.parse("v1alpha1")
      %K8s.Version{major: 1, minor: "alpha", patch: 1}

  """
  @spec parse(binary()) :: Version.t()
  def parse(version) do
    %{"major" => major, "minor" => minor, "patch" => patch} =
      Regex.named_captures(@pattern, version)

    format(major, minor, patch)
  end

  @spec format(binary | integer, binary, binary | integer | nil) :: t
  defp format(major, "", "") when is_integer(major), do: format(major, "stable", nil)

  defp format(major, minor, patch) when is_binary(major),
    do: major |> String.to_integer() |> format(minor, patch)

  defp format(major, minor, patch) when is_binary(patch),
    do: format(major, minor, String.to_integer(patch))

  defp format(major, minor, patch), do: %__MODULE__{major: major, minor: minor, patch: patch}

  # Parse a list of string versions
  @spec parse_list(list(binary)) :: list(K8s.Version.t())
  defp parse_list(versions), do: parse_list(versions, [])
  @spec parse_list(list(binary), list(K8s.Version.t()) | nil) :: list(K8s.Version.t())
  defp parse_list([], acc), do: acc
  defp parse_list([version | tail], acc), do: parse_list(tail, [parse(version) | acc])
end

1	defmodule K8s.Version do
2	@moduledoc """
3	Kubernetes [API Versioning](https://kubernetes.io/docs/concepts/overview/kubernetes-api/#api-versioning)
4	"""
5	alias K8s.Version
6
7	@type t :: %__MODULE__{major: pos_integer, minor: binary, patch: pos_integer}
8	defstruct [:major, :minor, :patch]
9
10	@pattern ~r/v(?<major>\d{1,})(?<minor>(alpha\|beta)?)(?<patch>\d{0,})/
11
12	@doc """
13	Returns the recommended version from a list of versions.
14
15	It will return the most stable version if any, otherwise the newest "edge" version.
16
17	## Examples
18
19	iex> K8s.Version.recommended(["v1beta1", "v1", "v2"])
20	"v2"
21
22	iex> K8s.Version.recommended(["v1beta1", "v1"])
23	"v1"
24
25	iex> K8s.Version.recommended(["v1beta2", "v1beta1"])
26	"v1beta2"
27
28	iex> K8s.Version.recommended(["v1alpha1", "v1alpha2", "v1beta1"])
29	"v1beta1"
30
31	"""
32	@spec recommended(list(binary)) :: binary
33	def recommended(versions) do
34	versions
35	\|> parse_list
36	\|> sort
37	\|> List.first()
38	\|> serialize	4✔
39	end
40
41	@doc """
42	Sorts a list of `K8s.Version`s
43
44	## Examples
45
46	iex> raw_versions = Enum.shuffle(["v1", "v2beta1", "v2", "v1alpha1", "v1alpha2"])
47	iex> versions = raw_versions \|> Enum.map(&(K8s.Version.parse(&1)))
48	iex> sorted_versions = versions \|> K8s.Version.sort()
49	iex> sorted_versions \|> Enum.map(&(K8s.Version.serialize(&1)))
50	["v2", "v1", "v2beta1", "v1alpha2", "v1alpha1"]
51
52	"""
53	@spec sort(list(t)) :: list(t)
54	def sort(versions), do: Enum.sort(versions, &compare/2)	5✔
55
56	@spec compare(t, t) :: boolean
57	defp compare(%Version{minor: "stable", major: a}, %Version{minor: "stable", major: b}),
58	do: a >= b	2✔
59
60	defp compare(%Version{minor: "stable"}, _), do: true	2✔
61	defp compare(_, %Version{minor: "stable"}), do: false	7✔
62
63	defp compare(%Version{minor: "beta"}, %Version{minor: "alpha"}), do: true	2✔
64	defp compare(%Version{minor: "alpha"}, %Version{minor: "beta"}), do: false	×
65
66	# Guard here catches case where minor is the same and major is greater.
67	# If using >= it will get a flakey result when everything is the same except patch level
68	defp compare(%Version{minor: m, major: a}, %Version{minor: m, major: b}) when a > b, do: true	×
69
70	defp compare(%Version{patch: a}, %Version{patch: b}), do: a >= b	3✔
71	defp compare(_, _), do: false	×
72
73	@doc """
74	Returns only stable versions
75
76	## Examples
77
78	iex> K8s.Version.serialize(%K8s.Version{major: 1, minor: "stable", patch: nil})
79	"v1"
80
81	iex> K8s.Version.serialize(%K8s.Version{major: 1, minor: "beta", patch: 1})
82	"v1beta1"
83
84	iex> K8s.Version.serialize(%K8s.Version{major: 1, minor: "alpha", patch: 1})
85	"v1alpha1"
86
87	"""
88	@spec serialize(Version.t()) :: binary
89	def serialize(%Version{major: major, minor: "stable"}), do: "v#{major}"	5✔
90
91	def serialize(%Version{major: major, minor: minor, patch: patch}),
92	do: "v#{major}#{minor}#{patch}"	7✔
93
94	@doc """
95	Returns only stable versions
96
97	## Examples
98
99	iex> K8s.Version.stable(["v1alpha1", "v1", "v2beta1"])
100	[%K8s.Version{major: 1, minor: "stable", patch: nil}]
101
102	"""
103	@spec stable(list(binary)) :: list(Version.t())
104	def stable(versions), do: parse_filter(versions, "stable")	1✔
105
106	@doc """
107	Returns only alpha versions
108
109	## Examples
110
111	iex> K8s.Version.alpha(["v1alpha1", "v1", "v2beta1"])
112	[%K8s.Version{major: 1, minor: "alpha", patch: 1}]
113
114	"""
115	@spec alpha(list(binary)) :: list(Version.t())
116	def alpha(versions), do: parse_filter(versions, "alpha")	2✔
117
118	@doc """
119	Returns only beta versions
120
121	## Examples
122
123	iex> K8s.Version.beta(["v1alpha1", "v1", "v2beta1"])
124	[%K8s.Version{major: 2, minor: "beta", patch: 1}]
125
126	"""
127	@spec beta(list(binary)) :: list(Version.t())
128	def beta(versions), do: parse_filter(versions, "beta")	2✔
129
130	@doc """
131	Retuns all non-stable versions
132
133	## Examples
134
135	iex> K8s.Version.edge(["v1alpha1", "v1", "v2beta1"])
136	[%K8s.Version{major: 1, minor: "alpha", patch: 1}, %K8s.Version{major: 2, minor: "beta", patch: 1}]
137
138	"""
139	@spec edge(list(binary)) :: list(Version.t())
140	def edge(versions), do: alpha(versions) ++ beta(versions)	1✔
141
142	@spec parse_filter(list(binary), binary) :: list(Version.t())
143	defp parse_filter(versions, keep) do
144	versions
145	\|> parse_list
146	\|> Enum.filter(&is(&1, keep))	5✔
147	end
148
149	@spec is(Version.t(), binary) :: boolean()
150	defp is(%Version{minor: minor}, minor), do: true	5✔
151	defp is(_, _), do: false	10✔
152
153	@doc """
154	Parses a Kubernetes API version into a `K8s.Version` struct
155
156	## Examples
157
158	iex> K8s.Version.parse("v1")
159	%K8s.Version{major: 1, minor: "stable", patch: nil}
160
161	iex> K8s.Version.parse("v1beta2")
162	%K8s.Version{major: 1, minor: "beta", patch: 2}
163
164	iex> K8s.Version.parse("v1alpha1")
165	%K8s.Version{major: 1, minor: "alpha", patch: 1}
166
167	"""
168	@spec parse(binary()) :: Version.t()
169	def parse(version) do
170	%{"major" => major, "minor" => minor, "patch" => patch} =	33✔
171	Regex.named_captures(@pattern, version)
172
173	format(major, minor, patch)	33✔
174	end
175
176	@spec format(binary \| integer, binary, binary \| integer \| nil) :: t
177	defp format(major, "", "") when is_integer(major), do: format(major, "stable", nil)	11✔
178
179	defp format(major, minor, patch) when is_binary(major),
180	do: major \|> String.to_integer() \|> format(minor, patch)	33✔
181
182	defp format(major, minor, patch) when is_binary(patch),
183	do: format(major, minor, String.to_integer(patch))	22✔
184
185	defp format(major, minor, patch), do: %__MODULE__{major: major, minor: minor, patch: patch}	33✔
186
187	# Parse a list of string versions
188	@spec parse_list(list(binary)) :: list(K8s.Version.t())
189	defp parse_list(versions), do: parse_list(versions, [])	9✔
190	@spec parse_list(list(binary), list(K8s.Version.t()) \| nil) :: list(K8s.Version.t())
191	defp parse_list([], acc), do: acc	9✔
192	defp parse_list([version \| tail], acc), do: parse_list(tail, [parse(version) \| acc])	25✔
193	end

coryodaniel / k8s / 8f48423e47cc981c6dc639f5abf2f48daeddd137-PR-278

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous