taffy

-module(taffy@parser@scalar).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/taffy/parser/scalar.gleam").
-export([parse_scalar/1, value_to_key_string/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/taffy/parser/scalar.gleam", 41).
?DOC(false).
-spec try_parse_hex(binary()) -> {ok, integer()} | {error, nil}.
try_parse_hex(S) ->
    case gleam_stdlib:string_starts_with(string:lowercase(S), <<"0x"/utf8>>) of
        true ->
            gleam@int:base_parse(gleam@string:drop_start(S, 2), 16);

        false ->
            {error, nil}
    end.

-file("src/taffy/parser/scalar.gleam", 48).
?DOC(false).
-spec try_parse_octal(binary()) -> {ok, integer()} | {error, nil}.
try_parse_octal(S) ->
    case gleam_stdlib:string_starts_with(string:lowercase(S), <<"0o"/utf8>>) of
        true ->
            gleam@int:base_parse(gleam@string:drop_start(S, 2), 8);

        false ->
            {error, nil}
    end.

-file("src/taffy/parser/scalar.gleam", 55).
?DOC(false).
-spec parse_special_float(binary()) -> {ok, float()} | {error, nil}.
parse_special_float(S) ->
    case S of
        <<".inf"/utf8>> ->
            {ok, +0.0};

        <<".Inf"/utf8>> ->
            {ok, +0.0};

        <<".INF"/utf8>> ->
            {ok, +0.0};

        <<"-.inf"/utf8>> ->
            {ok, +0.0};

        <<"-.Inf"/utf8>> ->
            {ok, +0.0};

        <<"-.INF"/utf8>> ->
            {ok, +0.0};

        <<".nan"/utf8>> ->
            {ok, +0.0};

        <<".NaN"/utf8>> ->
            {ok, +0.0};

        <<".NAN"/utf8>> ->
            {ok, +0.0};

        _ ->
            {error, nil}
    end.

-file("src/taffy/parser/scalar.gleam", 21).
?DOC(false).
-spec parse_numeric_or_string(binary()) -> taffy@value:yaml_value().
parse_numeric_or_string(S) ->
    Int_result = begin
        _pipe = try_parse_hex(S),
        _pipe@1 = gleam@result:lazy_or(_pipe, fun() -> try_parse_octal(S) end),
        gleam@result:lazy_or(_pipe@1, fun() -> gleam_stdlib:parse_int(S) end)
    end,
    case Int_result of
        {ok, I} ->
            {int, I};

        {error, _} ->
            case gleam_stdlib:parse_float(S) of
                {ok, F} ->
                    {float, F};

                {error, _} ->
                    case parse_special_float(S) of
                        {ok, F@1} ->
                            {float, F@1};

                        {error, _} ->
                            {string, S}
                    end
            end
    end.

-file("src/taffy/parser/scalar.gleam", 10).
?DOC(false).
-spec parse_scalar(binary()) -> taffy@value:yaml_value().
parse_scalar(S) ->
    Trimmed = gleam@string:trim(S),
    case string:lowercase(Trimmed) of
        <<"null"/utf8>> ->
            null;

        <<"~"/utf8>> ->
            null;

        <<""/utf8>> ->
            null;

        <<"true"/utf8>> ->
            {bool, true};

        <<"yes"/utf8>> ->
            {bool, true};

        <<"on"/utf8>> ->
            {bool, true};

        <<"false"/utf8>> ->
            {bool, false};

        <<"no"/utf8>> ->
            {bool, false};

        <<"off"/utf8>> ->
            {bool, false};

        _ ->
            parse_numeric_or_string(Trimmed)
    end.

-file("src/taffy/parser/scalar.gleam", 64).
?DOC(false).
-spec value_to_key_string(taffy@value:yaml_value()) -> binary().
value_to_key_string(Val) ->
    case Val of
        {string, S} ->
            S;

        {int, I} ->
            erlang:integer_to_binary(I);

        {float, F} ->
            gleam_stdlib:float_to_string(F);

        {bool, true} ->
            <<"true"/utf8>>;

        {bool, false} ->
            <<"false"/utf8>>;

        null ->
            <<""/utf8>>;

        {sequence, Items} ->
            Item_strs = gleam@list:map(Items, fun value_to_key_string/1),
            <<<<"["/utf8, (gleam@string:join(Item_strs, <<", "/utf8>>))/binary>>/binary,
                "]"/utf8>>;

        {mapping, Pairs} ->
            Pair_strs = begin
                _pipe = Pairs,
                gleam@list:map(
                    _pipe,
                    fun(Pair) ->
                        {K, V} = Pair,
                        <<<<K/binary, ": "/utf8>>/binary,
                            (value_to_key_string(V))/binary>>
                    end
                )
            end,
            <<<<"{"/utf8, (gleam@string:join(Pair_strs, <<", "/utf8>>))/binary>>/binary,
                "}"/utf8>>
    end.