graded

-module(graded@internal@config).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/graded/internal/config.gleam").
-export([default_cache_dir/0, default_spec_file/1, read/1, defaults_for/1, spec_file_for/2, module_path_for_source/2]).
-export_type([graded_config/0, config_error/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 graded_config() :: {graded_config, binary(), binary(), binary()}.

-type config_error() :: {toml_read_error, binary(), simplifile:file_error()} |
    {missing_package_name, binary()} |
    {toml_parse_error, binary()}.

-file("src/graded/internal/config.gleam", 87).
?DOC(false).
-spec default_cache_dir() -> binary().
default_cache_dir() ->
    <<"build/.graded"/utf8>>.

-file("src/graded/internal/config.gleam", 83).
?DOC(false).
-spec default_spec_file(binary()) -> binary().
default_spec_file(Package_name) ->
    <<Package_name/binary, ".graded"/utf8>>.

-file("src/graded/internal/config.gleam", 49).
?DOC(false).
-spec read(binary()) -> {ok, graded_config()} | {error, config_error()}.
read(Gleam_toml_path) ->
    gleam@result:'try'(
        begin
            _pipe = simplifile:read(Gleam_toml_path),
            gleam@result:map_error(
                _pipe,
                fun(_capture) ->
                    {toml_read_error, Gleam_toml_path, _capture}
                end
            )
        end,
        fun(Content) ->
            gleam@result:'try'(
                begin
                    _pipe@1 = tom:parse(Content),
                    gleam@result:replace_error(
                        _pipe@1,
                        {toml_parse_error, Gleam_toml_path}
                    )
                end,
                fun(Toml) ->
                    gleam@result:'try'(
                        begin
                            _pipe@2 = tom:get_string(Toml, [<<"name"/utf8>>]),
                            gleam@result:replace_error(
                                _pipe@2,
                                {missing_package_name, Gleam_toml_path}
                            )
                        end,
                        fun(Package_name) ->
                            Spec_file = case tom:get_string(
                                Toml,
                                [<<"tools"/utf8>>,
                                    <<"graded"/utf8>>,
                                    <<"spec_file"/utf8>>]
                            ) of
                                {ok, Value} ->
                                    Value;

                                {error, _} ->
                                    default_spec_file(Package_name)
                            end,
                            Cache_dir = case tom:get_string(
                                Toml,
                                [<<"tools"/utf8>>,
                                    <<"graded"/utf8>>,
                                    <<"cache_dir"/utf8>>]
                            ) of
                                {ok, Value@1} ->
                                    Value@1;

                                {error, _} ->
                                    default_cache_dir()
                            end,
                            {ok,
                                {graded_config,
                                    Package_name,
                                    Spec_file,
                                    Cache_dir}}
                        end
                    )
                end
            )
        end
    ).

-file("src/graded/internal/config.gleam", 75).
?DOC(false).
-spec defaults_for(binary()) -> graded_config().
defaults_for(Package_name) ->
    {graded_config,
        Package_name,
        default_spec_file(Package_name),
        default_cache_dir()}.

-file("src/graded/internal/config.gleam", 95).
?DOC(false).
-spec spec_file_for(binary(), binary()) -> binary().
spec_file_for(Package_root, Package_name) ->
    Spec_file = case read(filepath:join(Package_root, <<"gleam.toml"/utf8>>)) of
        {ok, Cfg} ->
            erlang:element(3, Cfg);

        {error, _} ->
            default_spec_file(Package_name)
    end,
    filepath:join(Package_root, Spec_file).

-file("src/graded/internal/config.gleam", 108).
?DOC(false).
-spec module_path_for_source(binary(), binary()) -> binary().
module_path_for_source(Gleam_path, Source_directory) ->
    Prefix = <<Source_directory/binary, "/"/utf8>>,
    Relative = case gleam_stdlib:string_starts_with(Gleam_path, Prefix) of
        true ->
            gleam@string:drop_start(Gleam_path, string:length(Prefix));

        false ->
            Gleam_path
    end,
    filepath:strip_extension(Relative).