dagger_gleam

-module(dagger@dsl@search_result).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/dagger/dsl/search_result.gleam").
-export([search_result/1, absolute_offset/3, file_path/3, id/1, line_number/3, matched_lines/3, submatches/4]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-file("src/dagger/dsl/search_result.gleam", 9).
-spec search_result(dagger@dsl@types:search_result()) -> dagger@dsl@types:search_result().
search_result(Id) ->
    Field = {field,
        <<"loadSearchResultFromID"/utf8>>,
        [{<<"id"/utf8>>, {g_deferred, erlang:element(2, Id)}}],
        []},
    {search_result, {pure, [Field]}}.

-file("src/dagger/dsl/search_result.gleam", 15).
?DOC(" The byte offset of this line within the file.\n").
-spec absolute_offset(
    dagger@dsl@types:search_result(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> XKZ)
) -> XKZ.
absolute_offset(Parent, Client, Handler) ->
    Field = {field, <<"absoluteOffset"/utf8>>, [], []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder, fun gleam@dynamic@decode:decode_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error,
                                            <<"absoluteOffset"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/search_result.gleam", 36).
?DOC(" The path to the file that matched.\n").
-spec file_path(
    dagger@dsl@types:search_result(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XLB)
) -> XLB.
file_path(Parent, Client, Handler) ->
    Field = {field, <<"filePath"/utf8>>, [], []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error, <<"filePath"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/search_result.gleam", 57).
?DOC(" A unique identifier for this SearchResult.\n").
-spec id(dagger@dsl@types:search_result()) -> dagger@dsl@types:search_result().
id(Parent) ->
    Field = {field, <<"id"/utf8>>, [], []},
    New_op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) -> {pure, lists:append(Q, [Field])} end
        )
    end,
    {search_result, New_op}.

-file("src/dagger/dsl/search_result.gleam", 67).
?DOC(" The first line that matched.\n").
-spec line_number(
    dagger@dsl@types:search_result(),
    dagger@types:client(),
    fun(({ok, integer()} | {error, dagger@types:query_error()}) -> XLD)
) -> XLD.
line_number(Parent, Client, Handler) ->
    Field = {field, <<"lineNumber"/utf8>>, [], []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder, fun gleam@dynamic@decode:decode_int/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error, <<"lineNumber"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/search_result.gleam", 88).
?DOC(" The line content that matched.\n").
-spec matched_lines(
    dagger@dsl@types:search_result(),
    dagger@types:client(),
    fun(({ok, binary()} | {error, dagger@types:query_error()}) -> XLF)
) -> XLF.
matched_lines(Parent, Client, Handler) ->
    Field = {field, <<"matchedLines"/utf8>>, [], []},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            )
                        ) of
                            {ok, Val} ->
                                {pure, {ok, Val}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error,
                                            <<"matchedLines"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).

-file("src/dagger/dsl/search_result.gleam", 109).
?DOC(" Sub-match positions and content within the matched lines.\n").
-spec submatches(
    dagger@dsl@types:search_result(),
    fun((dagger@dsl@types:search_submatch()) -> list(dagger@types:field())),
    dagger@types:client(),
    fun(({ok, list(dagger@dsl@types:search_submatch())} |
        {error, dagger@types:query_error()}) -> XLJ)
) -> XLJ.
submatches(Parent, Select, Client, Handler) ->
    Subfields = Select({search_submatch, {pure, []}}),
    Field = {field, <<"submatches"/utf8>>, [], Subfields},
    Op = begin
        dagger@types:bind(
            erlang:element(2, Parent),
            fun(Q) ->
                Full_query = lists:append(Q, [Field]),
                {fetch,
                    Full_query,
                    {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
                    fun(Dyn) ->
                        Path = dagger@types:make_path(Full_query),
                        case gleam@dynamic@decode:run(
                            Dyn,
                            gleam@dynamic@decode:at(
                                Path,
                                gleam@dynamic@decode:list(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_dynamic/1}
                                )
                            )
                        ) of
                            {ok, Items} ->
                                {pure,
                                    {ok,
                                        gleam@list:map(
                                            Items,
                                            fun(_) ->
                                                {search_submatch,
                                                    {pure, Full_query}}
                                            end
                                        )}};

                            {error, _} ->
                                {pure,
                                    {error,
                                        {decoding_error, <<"submatches"/utf8>>}}}
                        end
                    end}
            end
        )
    end,
    Handler(dagger@interpreter:run(Op, Client)).