Packages

fnord

0.8.35

AI code archaeology

Current section

Files

Jump to
fnord lib cmd config approvals.ex
Raw

lib/cmd/config/approvals.ex

defmodule Cmd.Config.Approvals do
@moduledoc false
alias Cmd.Config.Utils
@spec run(map(), list(), list()) :: :ok
def run(opts, [:approvals], _unknown) do
cond do
opts[:global] && opts[:project] ->
build_list()
|> Jason.encode!(pretty: true)
|> IO.puts()
opts[:global] ->
build_list(:global)
|> Jason.encode!(pretty: true)
|> IO.puts()
true ->
case Settings.get_selected_project() do
{:ok, _proj} ->
build_list(:project)
|> Jason.encode!(pretty: true)
|> IO.puts()
{:error, _} ->
UI.error("Project not specified or not found")
end
end
end
# Unified approve entry
def run(opts, [:approve], args) do
cond do
opts[:global] && opts[:project] ->
UI.error("Cannot use both --global and --project.")
is_nil(opts[:kind]) ->
UI.error("Missing --kind option.")
true ->
case Utils.require_key(opts, args, :pattern, "Pattern") do
{:error, msg} ->
UI.error(msg)
{:ok, pattern} ->
scope = if opts[:global], do: :global, else: :project
if scope == :project && opts[:project], do: Settings.set_project(opts[:project])
settings = Settings.new()
case build_approve(settings, scope, opts[:kind], pattern) do
{:ok, data} ->
data
|> Jason.encode!(pretty: true)
|> IO.puts()
{:error, err} ->
UI.error(err)
end
end
end
end
# ----------------------------------------------------------------------------
# Helpers
# ----------------------------------------------------------------------------
defp build_list(:global) do
Settings.new()
|> Settings.Approvals.get_approvals(:global)
end
defp build_list(:project) do
Settings.new()
|> Settings.Approvals.get_approvals(:project)
end
defp build_list() do
global = build_list(:global)
project = build_list(:project)
Enum.concat([
Map.keys(global),
Map.keys(project)
])
|> Enum.uniq()
|> Enum.map(fn kind ->
{
kind,
%{
global: Map.get(global, kind, []),
project: Map.get(project, kind, [])
}
}
end)
|> Enum.into(%{})
end
defp build_approve(settings, scope, kind, pattern) do
# validate that the pattern is a valid regex
case Regex.compile(pattern) do
{:error, reason} ->
# reason is a tuple {message, position}
msg = elem(reason, 0)
msg_str = to_string(msg)
{:error, "Invalid regex: #{msg_str}"}
{:ok, _regex} ->
# add the approved prefix and output updated patterns
new_settings = Settings.Approvals.approve(settings, scope, kind, pattern)
patterns = Settings.Approvals.get_approvals(new_settings, scope, kind)
{:ok, %{kind => patterns}}
end
end
end