gleager

-module(gleager@internal@filesystem).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleager/internal/filesystem.gleam").
-export([find_migrations/1, make_migrations/1]).

-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).

-file("src/gleager/internal/filesystem.gleam", 10).
?DOC(false).
-spec find_migrations(binary()) -> {ok, list(binary())} |
    {error, gleager@types:migration_error()}.
find_migrations(Migrations_dir) ->
    case simplifile:get_files(Migrations_dir) of
        {ok, Files} ->
            {ok, Files};

        {error, _} ->
            {error, {file_not_found, Migrations_dir}}
    end.

-file("src/gleager/internal/filesystem.gleam", 19).
?DOC(false).
-spec make_migrations(list(binary())) -> {ok, list(gleager@types:migration())} |
    {error, gleager@types:migration_error()}.
make_migrations(Files) ->
    Re@1 = case gleam@regexp:from_string(
        <<"(?s)-- migrate:up\\s*(.*?)\\s*-- migrate:down\\s*(.*)"/utf8>>
    ) of
        {ok, Re} -> Re;
        _assert_fail ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"gleager/internal/filesystem"/utf8>>,
                        function => <<"make_migrations"/utf8>>,
                        line => 20,
                        value => _assert_fail,
                        start => 468,
                        'end' => 567,
                        pattern_start => 479,
                        pattern_end => 485})
    end,
    Whitespace_re@1 = case gleam@regexp:from_string(<<"(?<!,)\\s{2,}"/utf8>>) of
        {ok, Whitespace_re} -> Whitespace_re;
        _assert_fail@1 ->
            erlang:error(#{gleam_error => let_assert,
                        message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                        file => <<?FILEPATH/utf8>>,
                        module => <<"gleager/internal/filesystem"/utf8>>,
                        function => <<"make_migrations"/utf8>>,
                        line => 23,
                        value => _assert_fail@1,
                        start => 571,
                        'end' => 637,
                        pattern_start => 582,
                        pattern_end => 599})
    end,
    _pipe@9 = gleam@list:try_map(
        Files,
        fun(File) ->
            gleam@result:'try'(
                begin
                    _pipe = simplifile:read(File),
                    gleam@result:replace_error(_pipe, {unable_to_read, File})
                end,
                fun(Content) ->
                    gleam@result:'try'(
                        begin
                            _pipe@1 = gleam@string:split(File, <<"/"/utf8>>),
                            _pipe@2 = gleam@list:last(_pipe@1),
                            _pipe@4 = gleam@result:map(
                                _pipe@2,
                                fun(Val) ->
                                    _pipe@3 = gleam@string:split(
                                        Val,
                                        <<"_"/utf8>>
                                    ),
                                    gleam@list:first(_pipe@3)
                                end
                            ),
                            _pipe@5 = gleam@result:flatten(_pipe@4),
                            gleam@result:replace_error(
                                _pipe@5,
                                {invalid_migration_version, File}
                            )
                        end,
                        fun(Version) ->
                            Serialized = begin
                                _pipe@6 = gleam@regexp:split(Re@1, Content),
                                _pipe@7 = gleam@list:filter(
                                    _pipe@6,
                                    fun(It) -> not gleam@string:is_empty(It) end
                                ),
                                gleam@list:map(
                                    _pipe@7,
                                    fun(It@1) ->
                                        _pipe@8 = gleam@string:replace(
                                            It@1,
                                            <<"\n"/utf8>>,
                                            <<""/utf8>>
                                        ),
                                        gleam_regexp_ffi:replace(
                                            Whitespace_re@1,
                                            _pipe@8,
                                            <<""/utf8>>
                                        )
                                    end
                                )
                            end,
                            {Up@1, Down@1} = case Serialized of
                                [Up, Down | _] -> {Up, Down};
                                _assert_fail@2 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"gleager/internal/filesystem"/utf8>>,
                                                function => <<"make_migrations"/utf8>>,
                                                line => 45,
                                                value => _assert_fail@2,
                                                start => 1255,
                                                'end' => 1293,
                                                pattern_start => 1266,
                                                pattern_end => 1280})
                            end,
                            {ok, {migration, Version, Up@1, Down@1}}
                        end
                    )
                end
            )
        end
    ),
    gleam@result:map(
        _pipe@9,
        fun(_capture) ->
            gleam@list:sort(
                _capture,
                fun(A, B) ->
                    gleam@string:compare(
                        erlang:element(2, A),
                        erlang:element(2, B)
                    )
                end
            )
        end
    ).