Current section
Files
Jump to
Current section
Files
src/glap@parser.erl
-module(glap@parser).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-define(FILEPATH, "src/glap/parser.gleam").
-export([parser_print/1, parse/2, parse_argv/1]).
-export_type([parser/0]).
-type parser() :: {parser,
binary(),
list(glap@arguments:argument()),
glap@parser_settings:parser_settings()}.
-file("src/glap/parser.gleam", 21).
-spec parser_print(parser()) -> nil.
parser_print(Parser) ->
{parser, Description, Args, _} = Parser,
gleam_stdlib:println(<<"Parser { "/utf8>>),
gleam_stdlib:print(<<"\tdescription: "/utf8>>),
gleam_stdlib:print(Description),
gleam_stdlib:println(<<", "/utf8>>),
gleam_stdlib:println(<<"\tcommands:"/utf8>>),
gleam_stdlib:print(<<"\t\t"/utf8>>),
_pipe = Args,
_pipe@1 = gleam@list:map(_pipe, fun glap@arguments:argument_to_string/1),
_pipe@2 = gleam@string:join(_pipe@1, <<"\n\t\t"/utf8>>),
gleam_stdlib:println(_pipe@2),
gleam_stdlib:println(<<" }"/utf8>>).
-file("src/glap/parser.gleam", 49).
-spec parse_aux(
list(binary()),
list(glap@arguments:argument()),
list(glap@arguments:argument()),
list(glap@arguments:argument()),
glap@parser_settings:parser_settings()
) -> {ok, list(glap@cliargs:c_l_i_arg())} | {error, glap@error:parsing_error()}.
parse_aux(Args, Commands, Flags, Unnamed_arguments, Parser_settings) ->
Required_flags = gleam@list:filter(
Flags,
fun(Flag) ->
Required@1 = case Flag of
{flag, _, _, _, Required, _} -> Required;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 57,
value => _assert_fail,
start => 1478,
'end' => 1532,
pattern_start => 1489,
pattern_end => 1525})
end,
Required@1
end
),
Required_commands = gleam@list:filter(
Commands,
fun(Command) ->
Required@3 = case Command of
{command, _, _, Required@2, _} -> Required@2;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 62,
value => _assert_fail@1,
start => 1612,
'end' => 1669,
pattern_start => 1623,
pattern_end => 1659})
end,
Required@3
end
),
Required_commands_str = begin
_pipe = gleam@list:map(
Required_commands,
fun(Command@1) ->
Name@1 = case Command@1 of
{command, Name, _, _, _} -> Name;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 68,
value => _assert_fail@2,
start => 1763,
'end' => 1816,
pattern_start => 1774,
pattern_end => 1806})
end,
Name@1
end
),
gleam@string:join(_pipe, <<" | "/utf8>>)
end,
gleam@bool:guard(
((Args =:= []) andalso (Required_commands /= [])) andalso erlang:element(
2,
Parser_settings
),
{error,
{missing_command,
glap@utils:strformat(
<<"missing required command: {}"/utf8>>,
[Required_commands_str]
)}},
fun() ->
gleam@bool:guard(
((Args =:= []) andalso (Unnamed_arguments /= [])) andalso erlang:element(
2,
Parser_settings
),
begin
_pipe@2 = glap@utils:strformat(
<<"missing required flags: {}"/utf8>>,
[begin
_pipe@1 = gleam@list:map(
Unnamed_arguments,
fun(Cliarg) ->
Name@3 = case Cliarg of
{unnamed_argument, Name@2, _} -> Name@2;
_assert_fail@3 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 77,
value => _assert_fail@3,
start => 2266,
'end' => 2320,
pattern_start => 2277,
pattern_end => 2311}
)
end,
Name@3
end
),
gleam@string:join(_pipe@1, <<", "/utf8>>)
end]
),
_pipe@3 = {missing_required_flag, _pipe@2},
{error, _pipe@3}
end,
fun() ->
gleam@bool:guard(
Args =:= [],
{ok, []},
fun() ->
{H_args@1, Rest_args@1} = case Args of
[H_args | Rest_args] -> {H_args, Rest_args};
_assert_fail@4 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 89,
value => _assert_fail@4,
start => 2467,
'end' => 2506,
pattern_start => 2478,
pattern_end => 2499})
end,
Should_be_flag = gleam_stdlib:string_starts_with(
H_args@1,
<<"-"/utf8>>
),
case {Commands, Flags, Unnamed_arguments} of
{_,
[{flag, Short, Long, _, _, Holds_value} |
Rest_flag],
_} when Should_be_flag ->
gleam@bool:lazy_guard(
not gleam_stdlib:string_starts_with(
H_args@1,
Short
)
andalso not gleam_stdlib:string_starts_with(
H_args@1,
Long
),
fun() ->
{
H_flag@1,
H2_flag@1,
Rest_flag@2} = case Flags of
[H_flag, H2_flag | Rest_flag@1] -> {
H_flag,
H2_flag,
Rest_flag@1};
_assert_fail@5 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 105,
value => _assert_fail@5,
start => 3172,
'end' => 3221,
pattern_start => 3183,
pattern_end => 3213}
)
end,
parse_aux(
Args,
Commands,
[H2_flag@1 |
glap@utils:push_back(
Rest_flag@2,
H_flag@1
)],
Unnamed_arguments,
Parser_settings
)
end,
fun() ->
{Content, Rest_args2} = case Holds_value of
true ->
case gleam@string:split_once(
H_args@1,
<<"="/utf8>>
) of
{ok, {_, Value}} ->
{{some,
gleam@string:trim(
Value
)},
Rest_args@1};
{error, nil} ->
{
Flag_content@1,
Rest@1} = case Rest_args@1 of
[Flag_content |
Rest] -> {
Flag_content,
Rest};
_assert_fail@6 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 119,
value => _assert_fail@6,
start => 3752,
'end' => 3797,
pattern_start => 3763,
pattern_end => 3785}
)
end,
{{some,
Flag_content@1},
Rest@1}
end;
false ->
{none, Rest_args@1}
end,
Flag_cliarg = {flag,
Short,
Long,
Content},
Rest_result_r = parse_aux(
Rest_args2,
Commands,
Rest_flag,
Unnamed_arguments,
Parser_settings
),
gleam@bool:guard(
gleam@result:is_error(
Rest_result_r
),
Rest_result_r,
fun() ->
Rest_result@1 = case Rest_result_r of
{ok, Rest_result} -> Rest_result;
_assert_fail@7 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 134,
value => _assert_fail@7,
start => 4139,
'end' => 4181,
pattern_start => 4150,
pattern_end => 4165}
)
end,
{ok,
[Flag_cliarg |
Rest_result@1]}
end
)
end
);
{_,
_,
[{unnamed_argument, Name@4, _} |
Rest_unnamed_argument]} ->
Unnamed_argument_cliarg = {unnamed_argument,
Name@4,
H_args@1},
Rest_result_r@1 = parse_aux(
Rest_args@1,
Commands,
Flags,
Rest_unnamed_argument,
Parser_settings
),
gleam@bool:guard(
gleam@result:is_error(Rest_result_r@1),
Rest_result_r@1,
fun() ->
Rest_result@3 = case Rest_result_r@1 of
{ok, Rest_result@2} -> Rest_result@2;
_assert_fail@8 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 146,
value => _assert_fail@8,
start => 4638,
'end' => 4680,
pattern_start => 4649,
pattern_end => 4664}
)
end,
{ok,
[Unnamed_argument_cliarg |
Rest_result@3]}
end
);
{[_ | _], _, _} when (Required_flags =/= []) andalso erlang:element(
2,
Parser_settings
) ->
_pipe@5 = glap@utils:strformat(
<<"missing required flags: {}"/utf8>>,
[begin
_pipe@4 = gleam@list:map(
Required_flags,
fun(Cliarg@1) ->
{Short@2, Long@2} = case Cliarg@1 of
{flag,
Short@1,
Long@1,
_,
_,
_} -> {
Short@1,
Long@1};
_assert_fail@9 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 155,
value => _assert_fail@9,
start => 5004,
'end' => 5060,
pattern_start => 5015,
pattern_end => 5051}
)
end,
<<<<<<<<"["/utf8,
Short@2/binary>>/binary,
"|"/utf8>>/binary,
Long@2/binary>>/binary,
"]"/utf8>>
end
),
gleam@string:join(
_pipe@4,
<<", "/utf8>>
)
end]
),
_pipe@6 = {missing_required_flag, _pipe@5},
{error, _pipe@6};
{[_ | _], _, _} when (Unnamed_arguments =/= []) andalso erlang:element(
2,
Parser_settings
) ->
_pipe@8 = glap@utils:strformat(
<<"missing required flags: {}"/utf8>>,
[begin
_pipe@7 = gleam@list:map(
Unnamed_arguments,
fun(Cliarg@2) ->
Name@6 = case Cliarg@2 of
{unnamed_argument,
Name@5,
_} -> Name@5;
_assert_fail@10 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 168,
value => _assert_fail@10,
start => 5427,
'end' => 5481,
pattern_start => 5438,
pattern_end => 5472}
)
end,
Name@6
end
),
gleam@string:join(
_pipe@7,
<<", "/utf8>>
)
end]
),
_pipe@9 = {missing_required_flag, _pipe@8},
{error, _pipe@9};
{[{command, Name@7, _, _, Subs} | Rest_command],
_,
_} ->
gleam@bool:lazy_guard(
H_args@1 /= Name@7,
fun() ->
parse_aux(
Args,
Rest_command,
Flags,
Unnamed_arguments,
Parser_settings
)
end,
fun() ->
Subcommands = gleam@list:filter(
Subs,
fun glap@arguments:is_command/1
),
Subflags = gleam@list:filter(
Subs,
fun glap@arguments:is_flag/1
),
Subunnamedarguments = gleam@list:filter(
Subs,
fun glap@arguments:is_unnamed_argument/1
),
Result_rest_r = parse_aux(
Rest_args@1,
Subcommands,
Subflags,
Subunnamedarguments,
Parser_settings
),
gleam@bool:guard(
gleam@result:is_error(
Result_rest_r
),
Result_rest_r,
fun() ->
Rest_result@5 = case Result_rest_r of
{ok, Rest_result@4} -> Rest_result@4;
_assert_fail@11 ->
erlang:error(
#{gleam_error => let_assert,
message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
file => <<?FILEPATH/utf8>>,
module => <<"glap/parser"/utf8>>,
function => <<"parse_aux"/utf8>>,
line => 189,
value => _assert_fail@11,
start => 6248,
'end' => 6290,
pattern_start => 6259,
pattern_end => 6274}
)
end,
Command_cliarg = {command,
Name@7,
true,
Rest_result@5},
{ok, [Command_cliarg]}
end
)
end
);
{_, _, _} ->
_pipe@10 = glap@utils:strformat(
<<"argument '{}' unknown"/utf8>>,
[H_args@1]
),
_pipe@11 = {unknown_argument, _pipe@10},
{error, _pipe@11}
end
end
)
end
)
end
).
-file("src/glap/parser.gleam", 40).
-spec parse(parser(), list(binary())) -> {ok, list(glap@cliargs:c_l_i_arg())} |
{error, glap@error:parsing_error()}.
parse(Parser, Args) ->
Subcommands = gleam@list:filter(
erlang:element(3, Parser),
fun glap@arguments:is_command/1
),
Subflags = gleam@list:filter(
erlang:element(3, Parser),
fun glap@arguments:is_flag/1
),
Subunnamedarguments = gleam@list:filter(
erlang:element(3, Parser),
fun glap@arguments:is_unnamed_argument/1
),
parse_aux(
Args,
Subcommands,
Subflags,
Subunnamedarguments,
erlang:element(4, Parser)
).
-file("src/glap/parser.gleam", 202).
-spec parse_argv(parser()) -> {ok, list(glap@cliargs:c_l_i_arg())} |
{error, glap@error:parsing_error()}.
parse_argv(Parser) ->
parse(Parser, erlang:element(4, argv:load())).