checkmark

-module(checkmark).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/checkmark.gleam").
-export([new/2, file/2, should_contain_contents_of/3, update/1, check/1, check_or_update/2]).
-export_type([checker/1, file/1, check_error/1, snippet/0]).

-opaque checker(EWT) :: {checker,
        fun((binary()) -> {ok, binary()} | {error, EWT}),
        fun((binary(), binary()) -> {ok, nil} | {error, EWT})}.

-opaque file(EWU) :: {file, binary(), checker(EWU), list({binary(), binary()})}.

-type check_error(EWV) :: {could_not_read_file, EWV} |
    {could_not_write_file, EWV} |
    {tag_not_found, binary()} |
    {multiple_tags_found, binary(), list(integer())} |
    {content_did_not_match, binary()}.

-type snippet() :: {snippet,
        binary(),
        checkmark@internal@parser:fence(),
        gleam@option:option(checkmark@internal@parser:fence())}.

-file("src/checkmark.gleam", 28).
-spec new(
    fun((binary()) -> {ok, binary()} | {error, EWW}),
    fun((binary(), binary()) -> {ok, nil} | {error, EWW})
) -> checker(EWW).
new(Read_file, Write_file) ->
    {checker, Read_file, Write_file}.

-file("src/checkmark.gleam", 35).
-spec file(checker(EXC), binary()) -> file(EXC).
file(Checker, Filename) ->
    {file, Filename, Checker, []}.

-file("src/checkmark.gleam", 39).
-spec should_contain_contents_of(file(EXF), binary(), binary()) -> file(EXF).
should_contain_contents_of(File, Source, Tag) ->
    {file,
        erlang:element(2, File),
        erlang:element(3, File),
        [{Source, Tag} | erlang:element(4, File)]}.

-file("src/checkmark.gleam", 138).
-spec indent(splitter:splitter(), binary(), binary(), list(binary())) -> binary().
indent(Line_ends, With, Rest, Parts) ->
    case Rest of
        <<""/utf8>> ->
            _pipe = Parts,
            _pipe@1 = lists:reverse(_pipe),
            gleam@string:join(_pipe@1, <<""/utf8>>);

        _ ->
            {Content, Ending, Rest@1} = splitter_ffi:split(Line_ends, Rest),
            indent(Line_ends, With, Rest@1, [Ending, Content, With | Parts])
    end.

-file("src/checkmark.gleam", 153).
-spec render_fence(checkmark@internal@parser:fence()) -> binary().
render_fence(Fence) ->
    <<<<(gleam@string:repeat(<<" "/utf8>>, erlang:element(4, Fence)))/binary,
            (erlang:element(2, Fence))/binary>>/binary,
        (erlang:element(3, Fence))/binary>>.

-file("src/checkmark.gleam", 113).
-spec render_code(
    checkmark@internal@parser:fence(),
    binary(),
    gleam@option:option(checkmark@internal@parser:fence())
) -> binary().
render_code(Start_fence, Content, End_fence) ->
    Content@1 = case erlang:element(4, Start_fence) of
        0 ->
            Content;

        Amount ->
            indent(
                splitter:new([<<"\n"/utf8>>, <<"\r\n"/utf8>>]),
                gleam@string:repeat(<<" "/utf8>>, Amount),
                Content,
                []
            )
    end,
    Without_end = <<(render_fence(Start_fence))/binary, Content@1/binary>>,
    case End_fence of
        none ->
            Without_end;

        {some, End_fence@1} ->
            <<Without_end/binary, (render_fence(End_fence@1))/binary>>
    end.

-file("src/checkmark.gleam", 94).
-spec render_replacements(
    list(checkmark@internal@parser:section()),
    gleam@dict:dict(binary(), binary())
) -> binary().
render_replacements(Contents, Replacements) ->
    _pipe = Contents,
    _pipe@1 = gleam@list:map(_pipe, fun(Section) -> case Section of
                {fenced_code, _, Content, Start_fence, End_fence} ->
                    case gleam_stdlib:map_get(
                        Replacements,
                        gleam@string:trim(erlang:element(3, Start_fence))
                    ) of
                        {ok, Replacement} ->
                            render_code(Start_fence, Replacement, End_fence);

                        {error, _} ->
                            render_code(Start_fence, Content, End_fence)
                    end;

                {other, _, Content@1} ->
                    Content@1
            end end),
    gleam@string:join(_pipe@1, <<""/utf8>>).

-file("src/checkmark.gleam", 165).
-spec read_file(checker(EYM), binary()) -> {ok, binary()} |
    {error, check_error(EYM)}.
read_file(Checker, Filename) ->
    _pipe = (erlang:element(2, Checker))(Filename),
    gleam@result:map_error(
        _pipe,
        fun(Field@0) -> {could_not_read_file, Field@0} end
    ).

-file("src/checkmark.gleam", 157).
-spec parse_file(file(EYF)) -> {ok, list(checkmark@internal@parser:section())} |
    {error, list(check_error(EYF))}.
parse_file(File) ->
    _pipe = read_file(erlang:element(3, File), erlang:element(2, File)),
    _pipe@1 = gleam@result:map_error(_pipe, fun gleam@list:wrap/1),
    gleam@result:map(_pipe@1, fun checkmark@internal@parser:parse/1).

-file("src/checkmark.gleam", 188).
-spec find_match(
    list(checkmark@internal@parser:section()),
    binary(),
    list({integer(), snippet()})
) -> {ok, snippet()} | {error, check_error(any())}.
find_match(Content, Tag, Found) ->
    case Content of
        [] ->
            case Found of
                [] ->
                    {error, {tag_not_found, Tag}};

                [{_, Snippet}] ->
                    {ok, Snippet};

                _ ->
                    {error,
                        {multiple_tags_found,
                            Tag,
                            begin
                                _pipe = Found,
                                _pipe@1 = lists:reverse(_pipe),
                                gleam@list:map(
                                    _pipe@1,
                                    fun(Pair) -> erlang:element(1, Pair) end
                                )
                            end}}
            end;

        [{fenced_code, Line, Content@1, Start_fence, End_fence} | Rest] ->
            case gleam@string:trim(erlang:element(3, Start_fence)) =:= Tag of
                true ->
                    Result = {Line,
                        {snippet, Content@1, Start_fence, End_fence}},
                    find_match(Rest, Tag, [Result | Found]);

                false ->
                    find_match(Rest, Tag, Found)
            end;

        [_ | Rest@1] ->
            find_match(Rest@1, Tag, Found)
    end.

-file("src/checkmark.gleam", 73).
-spec update(file(EXU)) -> {ok, nil} | {error, list(check_error(EXU))}.
update(File) ->
    gleam@result:'try'(
        parse_file(File),
        fun(Contents) ->
            Results = begin
                gleam@list:map(
                    erlang:element(4, File),
                    fun(_use0) ->
                        {Filename, Tag} = _use0,
                        gleam@result:'try'(
                            find_match(Contents, Tag, []),
                            fun(_) ->
                                gleam@result:'try'(
                                    read_file(erlang:element(3, File), Filename),
                                    fun(Expected) -> {ok, {Tag, Expected}} end
                                )
                            end
                        )
                    end
                )
            end,
            {Replacements, Errors} = gleam@result:partition(Results),
            case Errors of
                [] ->
                    Contents@1 = render_replacements(
                        Contents,
                        maps:from_list(Replacements)
                    ),
                    _pipe = (erlang:element(3, erlang:element(3, File)))(
                        erlang:element(2, File),
                        Contents@1
                    ),
                    gleam@result:map_error(
                        _pipe,
                        fun(E) -> [{could_not_write_file, E}] end
                    );

                _ ->
                    {error, Errors}
            end
        end
    ).

-file("src/checkmark.gleam", 172).
-spec check_one(list(checkmark@internal@parser:section()), binary(), binary()) -> {ok,
        nil} |
    {error, check_error(any())}.
check_one(Content, Expected, Tag) ->
    gleam@result:'try'(
        find_match(Content, Tag, []),
        fun(Snippet) -> case erlang:element(2, Snippet) =:= Expected of
                true ->
                    {ok, nil};

                false ->
                    {error, {content_did_not_match, Tag}}
            end end
    ).

-file("src/checkmark.gleam", 57).
-spec check(file(EXO)) -> {ok, nil} | {error, list(check_error(EXO))}.
check(File) ->
    gleam@result:'try'(
        parse_file(File),
        fun(Contents) ->
            Results = begin
                gleam@list:map(
                    erlang:element(4, File),
                    fun(_use0) ->
                        {Filename, Tag} = _use0,
                        gleam@result:'try'(
                            read_file(erlang:element(3, File), Filename),
                            fun(Expected) ->
                                check_one(Contents, Expected, Tag)
                            end
                        )
                    end
                )
            end,
            {_, Errors} = gleam@result:partition(Results),
            case Errors of
                [] ->
                    {ok, nil};

                _ ->
                    {error, Errors}
            end
        end
    ).

-file("src/checkmark.gleam", 47).
-spec check_or_update(file(EXI), boolean()) -> {ok, nil} |
    {error, list(check_error(EXI))}.
check_or_update(File, Should_update) ->
    case Should_update of
        true ->
            update(File);

        false ->
            check(File)
    end.