Current section
Files
Jump to
Current section
Files
src/go_over.erl
-module(go_over).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/go_over.gleam").
-export([warnings_for_json_results/1, print_json_warnings/1, skipped_workspace_warnings/1, print_warnings/3, audit_project/2, main/0]).
-export_type([audit_result/0]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(false).
-type audit_result() :: {audit_result,
binary(),
list(go_over@warning:warning()),
list(go_over@warning:warning()),
boolean(),
go_over@config:format()}.
-file("src/go_over.gleam", 35).
?DOC(false).
-spec prefix_label(gleam@option:option(binary()), binary()) -> binary().
prefix_label(Prefix, Label) ->
case Prefix of
{some, Path} ->
<<<<<<"["/utf8, Path/binary>>/binary, "] "/utf8>>/binary,
Label/binary>>;
none ->
Label
end.
-file("src/go_over.gleam", 42).
?DOC(false).
-spec print_warnings_output(
list(go_over@warning:warning()),
go_over@config:config(),
binary(),
gleam@option:option(binary())
) -> nil.
print_warnings_output(Vulns, Conf, Label, Prefix) ->
Label@1 = prefix_label(Prefix, Label),
gleam_stdlib:print_error(Label@1),
case erlang:element(6, Conf) of
minimal ->
_pipe = Vulns,
_pipe@1 = gleam@list:map(
_pipe,
fun go_over@warning:format_as_string_minimal/1
),
_pipe@2 = gleam@string:join(_pipe@1, <<""/utf8>>),
gleam_stdlib:print_error(_pipe@2);
j_s_o_n ->
nil;
s_a_r_i_f ->
nil;
_ ->
_pipe@3 = Vulns,
_pipe@4 = gleam@list:map(
_pipe@3,
fun go_over@warning:format_as_string/1
),
_pipe@5 = gleam@string:join(
_pipe@4,
<<"\n-----------------------------------------------\n"/utf8>>
),
gleam_stdlib:print_error(_pipe@5)
end.
-file("src/go_over.gleam", 70).
?DOC(false).
-spec warnings_label(list(go_over@warning:warning()), binary()) -> binary().
warnings_label(Vulns, Kind) ->
<<<<<<<<<<"⛔ "/utf8,
(erlang:integer_to_binary(erlang:length(Vulns)))/binary>>/binary,
" "/utf8>>/binary,
Kind/binary>>/binary,
"(s) FOUND!"/utf8>>/binary,
(<<"\n-----------------------------------------------\n"/utf8>>)/binary>>.
-file("src/go_over.gleam", 79).
?DOC(false).
-spec info_label(list(go_over@warning:warning())) -> binary().
info_label(Vulns) ->
<<<<<<"ℹ️ "/utf8, (erlang:integer_to_binary(erlang:length(Vulns)))/binary>>/binary,
" Item(s) of Note"/utf8>>/binary,
(<<"\n-----------------------------------------------\n"/utf8>>)/binary>>.
-file("src/go_over.gleam", 86).
?DOC(false).
-spec warnings_for_json(audit_result()) -> list(go_over@warning:warning()).
warnings_for_json(Result) ->
lists:append(erlang:element(4, Result), erlang:element(3, Result)).
-file("src/go_over.gleam", 90).
?DOC(false).
-spec warnings_for_json_results(list(audit_result())) -> list(go_over@warning:warning()).
warnings_for_json_results(Results) ->
gleam@list:flat_map(Results, fun warnings_for_json/1).
-file("src/go_over.gleam", 94).
?DOC(false).
-spec print_json_warnings(list(go_over@warning:warning())) -> nil.
print_json_warnings(Warnings) ->
_pipe = Warnings,
_pipe@1 = gleam@list:map(_pipe, fun go_over@warning:format_as_json/1),
_pipe@2 = gleam@json:preprocessed_array(_pipe@1),
_pipe@3 = gleam@json:to_string(_pipe@2),
gleam_stdlib:print_error(_pipe@3).
-file("src/go_over.gleam", 102).
?DOC(false).
-spec write_sarif(list(audit_result()), gleam@option:option(binary())) -> nil.
write_sarif(Results, Output) ->
Runs = gleam@list:map(
Results,
fun(Result) ->
{erlang:element(2, Result), warnings_for_json(Result)}
end
),
Content = begin
_pipe = go_over@sarif:to_sarif_log(Runs),
gleam@json:to_string(_pipe)
end,
case Output of
none ->
_pipe@1 = Content,
gleam_stdlib:println(_pipe@1);
{some, Path} ->
case begin
_pipe@2 = Path,
simplifile:write(_pipe@2, Content)
end of
{ok, nil} ->
nil;
{error, _} ->
gleam_stdlib:println_error(
<<"could not write SARIF output to "/utf8, Path/binary>>
),
shellout_ffi:os_exit(1)
end
end.
-file("src/go_over.gleam", 128).
?DOC(false).
-spec skipped_workspace_warnings(list(binary())) -> list(go_over@warning:warning()).
skipped_workspace_warnings(Skipped) ->
gleam@list:map(
Skipped,
fun(Path) ->
go_over@warning:info_to_warning(
Path,
<<<<"Info: project at '"/utf8, Path/binary>>/binary,
"' was skipped (exceeds workspace_max_depth)"/utf8>>
)
end
).
-file("src/go_over.gleam", 139).
?DOC(false).
-spec print_warnings(
list(go_over@warning:warning()),
go_over@config:config(),
gleam@option:option(binary())
) -> nil.
print_warnings(Vulns, Conf, Prefix) ->
print_warnings_output(
Vulns,
Conf,
warnings_label(Vulns, <<"WARNING"/utf8>>),
Prefix
),
shellout_ffi:os_exit(1).
-file("src/go_over.gleam", 148).
?DOC(false).
-spec read_project_config(binary()) -> go_over@config:config().
read_project_config(Project_root) ->
Gleam_toml = filepath:join(Project_root, <<"gleam.toml"/utf8>>),
case simplifile:read(Gleam_toml) of
{ok, _} ->
go_over@config:read_config(Gleam_toml);
{error, _} ->
go_over@config:default_config()
end.
-file("src/go_over.gleam", 435).
?DOC(false).
-spec run_deps_outdated(binary()) -> boolean().
run_deps_outdated(Project_root) ->
go_over@util@print:high(
<<"The --outdated flag is deprecated. Use `gleam deps outdated` instead."/utf8>>
),
case shellout:command(
<<"gleam"/utf8>>,
[<<"deps"/utf8>>, <<"outdated"/utf8>>],
Project_root,
[let_be_stdout]
) of
{ok, _} ->
false;
{error, _} ->
true
end.
-file("src/go_over.gleam", 157).
?DOC(false).
-spec audit_project(go_over@config:flags(), binary()) -> {ok, audit_result()} |
{error, binary()}.
audit_project(Flags, Project_root) ->
Manifest_toml = filepath:join(Project_root, <<"manifest.toml"/utf8>>),
Project_config = read_project_config(Project_root),
gleam@result:'try'(
go_over@config:merge_flags_and_config(Flags, Project_config),
fun(Conf) ->
go_over@util@globals:set_project_root(Project_root),
go_over@util@globals:set_verbose(erlang:element(7, Conf)),
go_over@util@globals:set_use_global_cache(erlang:element(8, Conf)),
go_over@util@globals:set_force(erlang:element(5, Conf)),
Machine_output = (erlang:element(6, Conf) =:= s_a_r_i_f) orelse (erlang:element(
6,
Conf
)
=:= j_s_o_n),
Spinner = case Machine_output of
true ->
none;
false ->
go_over@util@spinner:new_spinner(<<"Let's do this!"/utf8>>)
end,
gxyz@function:ignore_result(
erlang:element(5, Conf),
gxyz@function:freeze1(
fun simplifile_erl:delete/1,
go_over@util@globals:go_over_path()
)
),
go_over@util@spinner:set_text_spinner(
Spinner,
<<"Reading manifest"/utf8>>
),
Manifest_pkgs = go_over@packages:read_manifest(Manifest_toml),
Pkgs_audited = begin
_pipe = Manifest_pkgs,
_pipe@1 = go_over@config:filter_dev_dependencies(Conf, _pipe),
go_over@config:filter_indirect(Conf, _pipe@1)
end,
Hex_pkgs = gleam@list:filter(
Pkgs_audited,
fun(P) -> erlang:element(6, P) =:= package_source_hex end
),
go_over@util@spinner:set_text_spinner(
Spinner,
<<"Checking packages: "/utf8,
(go_over@util@print:raw(
<<"vulnerable"/utf8>>,
<<"red"/utf8>>
))/binary>>
),
All_advisories = go_over@advisories@advisories:fetch_all(),
Vulnerable_warnings = go_over@sources:get_vulnerable_warnings(
Pkgs_audited,
Conf,
All_advisories
),
go_over@util@spinner:set_text_spinner(
Spinner,
<<"Checking packages: "/utf8,
(go_over@util@print:raw(
<<"retired"/utf8>>,
<<"yellow"/utf8>>
))/binary>>
),
Retired_warnings = go_over@sources:get_retired_warnings(
Hex_pkgs,
Conf
),
{Hex_warnings, Dependency_licenses} = case erlang:element(10, Conf) of
[] ->
{[], []};
_ ->
go_over@util@spinner:set_text_spinner(
Spinner,
<<"Checking packages: "/utf8,
(go_over@util@print:raw(
<<"licenses"/utf8>>,
<<"brightmagenta"/utf8>>
))/binary>>
),
go_over@sources:get_hex_warnings(Hex_pkgs, Conf)
end,
go_over@util@spinner:set_text_spinner(
Spinner,
<<"Filtering warnings"/utf8>>
),
Audit_warnings = begin
_pipe@2 = lists:append(Retired_warnings, Vulnerable_warnings),
lists:append(_pipe@2, Hex_warnings)
end,
Unnecessary_warnings = go_over@config:unnecessary_ignore_warnings(
Conf,
Manifest_pkgs,
Audit_warnings,
Dependency_licenses,
All_advisories
),
Fatal_warnings = begin
_pipe@3 = Audit_warnings,
_pipe@4 = go_over@config:filter_package_warnings(Conf, _pipe@3),
go_over@config:filter_severity(Conf, _pipe@4)
end,
go_over@util@spinner:stop_spinner(Spinner),
Outdated_failed = case erlang:element(3, Conf) of
false ->
false;
true ->
run_deps_outdated(Project_root)
end,
Info_warnings = lists:append(
Unnecessary_warnings,
go_over@warning:git_deps_to_warnings(Manifest_pkgs)
),
{ok,
{audit_result,
Project_root,
Fatal_warnings,
Info_warnings,
Outdated_failed,
erlang:element(6, Conf)}}
end
).
-file("src/go_over.gleam", 266).
?DOC(false).
-spec print_no_issues_success(integer()) -> nil.
print_no_issues_success(Info_count) ->
case Info_count of
0 ->
go_over@util@print:success(<<"✅ No warnings found!"/utf8>>);
_ ->
go_over@util@print:success(
<<<<"✅ No security issues found ("/utf8,
(erlang:integer_to_binary(Info_count))/binary>>/binary,
" item(s) of note)"/utf8>>
)
end.
-file("src/go_over.gleam", 278).
?DOC(false).
-spec run(go_over@config:flags()) -> nil.
run(Flags) ->
Workspace_mode = gleam@option:is_some(erlang:element(10, Flags)),
{Results, Workspace_skipped} = case erlang:element(10, Flags) of
{some, Scan_root} ->
Scan_config = read_project_config(Scan_root),
Max_depth = erlang:element(15, Scan_config),
case go_over@workspace:discover_or_error(Scan_root, Max_depth) of
{ok, {discover_result, Projects, Skipped}} ->
{gleam@list:map(
Projects,
fun(Project_root) ->
case audit_project(Flags, Project_root) of
{ok, Result} ->
Result;
{error, E} ->
gleam_stdlib:println_error(E),
shellout_ffi:os_exit(1),
go_over@util@util:do_panic()
end
end
),
Skipped};
{error, E@1} ->
gleam_stdlib:println_error(E@1),
shellout_ffi:os_exit(1),
go_over@util@util:do_panic()
end;
none ->
Project_root@1 = gleam@option:unwrap(
erlang:element(9, Flags),
<<"."/utf8>>
),
Result@2 = case audit_project(Flags, Project_root@1) of
{ok, Result@1} -> Result@1;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"go_over"/utf8>>,
function => <<"run"/utf8>>,
line => 309,
value => _assert_fail,
start => 7678,
'end' => 7736,
pattern_start => 7689,
pattern_end => 7699})
end,
{[Result@2], []}
end,
Skipped_warnings = skipped_workspace_warnings(Workspace_skipped),
Results@1 = case Skipped_warnings of
[] ->
Results;
_ ->
case Results of
[First | Rest] ->
[{audit_result,
erlang:element(2, First),
erlang:element(3, First),
lists:append(
Skipped_warnings,
erlang:element(4, First)
),
erlang:element(5, First),
erlang:element(6, First)} |
Rest];
[] ->
Results
end
end,
case {Workspace_mode, erlang:element(7, Flags)} of
{true, none} ->
case go_over@config:validate_workspace_formats(
gleam@list:map(
Results@1,
fun(R) -> {erlang:element(6, R), erlang:element(2, R)} end
)
) of
{error, E@2} ->
gleam_stdlib:println_error(E@2),
shellout_ffi:os_exit(1),
go_over@util@util:do_panic();
{ok, nil} ->
nil
end;
{_, _} ->
nil
end,
Prefix_for = fun(Result@3) -> case Workspace_mode of
true ->
{some, erlang:element(2, Result@3)};
false ->
none
end end,
Display_conf = fun(Result@4) -> _record = go_over@config:default_config(),
{config,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, Result@4),
erlang:element(7, _record),
erlang:element(8, _record),
erlang:element(9, _record),
erlang:element(10, _record),
erlang:element(11, _record),
erlang:element(12, _record),
erlang:element(13, _record),
erlang:element(14, _record),
erlang:element(15, _record),
erlang:element(16, _record),
erlang:element(17, _record)} end,
Output_format = case Results@1 of
[] ->
minimal;
[First@1 | _] ->
erlang:element(6, First@1)
end,
Sarif_output = Output_format =:= s_a_r_i_f,
Json_output = Output_format =:= j_s_o_n,
case {erlang:element(11, Flags), Sarif_output} of
{{some, _}, false} ->
gleam_stdlib:println_error(
<<"--sarif-output requires --format sarif"/utf8>>
),
shellout_ffi:os_exit(1);
{_, _} ->
nil
end,
case {Sarif_output, Json_output} of
{false, false} ->
gleam@list:each(
Results@1,
fun(Result@5) -> case erlang:element(4, Result@5) of
[] ->
nil;
Info ->
print_warnings_output(
Info,
Display_conf(Result@5),
info_label(Info),
Prefix_for(Result@5)
)
end end
);
{false, true} ->
print_json_warnings(warnings_for_json_results(Results@1));
{true, _} ->
nil
end,
Any_fatal = gleam@list:any(
Results@1,
fun(R@1) -> not gleam@list:is_empty(erlang:element(3, R@1)) end
),
Any_outdated_failed = gleam@list:any(
Results@1,
fun(R@2) -> erlang:element(5, R@2) end
),
Info_count = begin
_pipe = gleam@list:flat_map(
Results@1,
fun(R@3) -> erlang:element(4, R@3) end
),
erlang:length(_pipe)
end,
case {Any_fatal, Any_outdated_failed, Sarif_output, Json_output} of
{false, false, true, _} ->
write_sarif(Results@1, erlang:element(11, Flags)),
nil;
{false, false, false, _} ->
print_no_issues_success(Info_count),
nil;
{false, true, true, _} ->
write_sarif(Results@1, erlang:element(11, Flags)),
shellout_ffi:os_exit(1);
{false, true, false, _} ->
shellout_ffi:os_exit(1);
{true, _, true, _} ->
write_sarif(Results@1, erlang:element(11, Flags)),
shellout_ffi:os_exit(1);
{true, _, false, true} ->
shellout_ffi:os_exit(1);
{true, _, false, false} ->
gleam@list:each(
Results@1,
fun(Result@6) -> case erlang:element(3, Result@6) of
[] ->
nil;
Vulns ->
print_warnings_output(
Vulns,
Display_conf(Result@6),
warnings_label(Vulns, <<"WARNING"/utf8>>),
Prefix_for(Result@6)
)
end end
),
shellout_ffi:os_exit(1)
end.
-file("src/go_over.gleam", 259).
?DOC(false).
-spec main() -> nil.
main() ->
case go_over@config:parse_flags(shellout_ffi:start_arguments()) of
{error, Message} ->
gleam_stdlib:println(Message);
{ok, Flags} ->
run(Flags)
end.