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, show_help/1, parse/2, parse_argv/1]).
-export_type([parser/0]).
-type parser() :: {parser,
list(glap@arguments:argument()),
binary(),
gleam@option:option(glap@parser_settings:parser_settings()),
gleam@option:option(glap@help_settings:help_settings())}.
-file("src/glap/parser.gleam", 30).
-spec parser_print(parser()) -> nil.
parser_print(Parser) ->
{parser, Args, Description, _, _} = 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", 118).
-spec run_on_parse_error(glap@parser_settings:parser_settings()) -> nil.
run_on_parse_error(Settings) ->
case erlang:element(3, Settings) of
{some, F} ->
F();
none ->
nil
end.
-file("src/glap/parser.gleam", 157).
-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(), list(glap@arguments:argument())}}.
parse_aux(Args, Commands, Flags, Unnamed_arguments, Parser_settings) ->
Arguments = gleam@list:flatten([Unnamed_arguments, Flags, Commands]),
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 => 168,
value => _assert_fail,
start => 4728,
'end' => 4782,
pattern_start => 4739,
pattern_end => 4775})
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 => 173,
value => _assert_fail@1,
start => 4862,
'end' => 4919,
pattern_start => 4873,
pattern_end => 4909})
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 => 179,
value => _assert_fail@2,
start => 5013,
'end' => 5066,
pattern_start => 5024,
pattern_end => 5056})
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]
)},
Arguments}},
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 => 197,
value => _assert_fail@3,
start => 5556,
'end' => 5610,
pattern_start => 5567,
pattern_end => 5601}
)
end,
Name@3
end
),
gleam@string:join(_pipe@1, <<", "/utf8>>)
end]
),
_pipe@3 = {missing_required_flag, _pipe@2},
(fun(E) -> {error, {E, Arguments}} end)(_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 => 209,
value => _assert_fail@4,
start => 5784,
'end' => 5823,
pattern_start => 5795,
pattern_end => 5816})
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 => 224,
value => _assert_fail@5,
start => 6404,
'end' => 6453,
pattern_start => 6415,
pattern_end => 6445}
)
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 => 238,
value => _assert_fail@6,
start => 6984,
'end' => 7029,
pattern_start => 6995,
pattern_end => 7017}
)
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 => 253,
value => _assert_fail@7,
start => 7371,
'end' => 7413,
pattern_start => 7382,
pattern_end => 7397}
)
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 => 265,
value => _assert_fail@8,
start => 7870,
'end' => 7912,
pattern_start => 7881,
pattern_end => 7896}
)
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 => 274,
value => _assert_fail@9,
start => 8236,
'end' => 8292,
pattern_start => 8247,
pattern_end => 8283}
)
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},
(fun(E@1) -> {error, {E@1, Arguments}} end)(
_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 => 287,
value => _assert_fail@10,
start => 8686,
'end' => 8740,
pattern_start => 8697,
pattern_end => 8731}
)
end,
Name@6
end
),
gleam@string:join(
_pipe@7,
<<", "/utf8>>
)
end]
),
_pipe@9 = {missing_required_flag, _pipe@8},
(fun(E@2) -> {error, {E@2, Arguments}} end)(
_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 => 308,
value => _assert_fail@11,
start => 9534,
'end' => 9576,
pattern_start => 9545,
pattern_end => 9560}
)
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},
(fun(E@3) -> {error, {E@3, Arguments}} end)(
_pipe@11
)
end
end
)
end
)
end
).
-file("src/glap/parser.gleam", 49).
-spec show_help_aux(
list(glap@arguments:argument()),
glap@help_settings:help_settings(),
fun((binary()) -> nil),
integer(),
integer()
) -> nil.
show_help_aux(Args, Showhelp_settings, Printfun, Tabdesc_length, Indent_level) ->
gleam@bool:guard(
Args =:= [],
nil,
fun() ->
{Args_h@1, Args_rest@1} = case Args of
[Args_h | Args_rest] -> {Args_h, Args_rest};
_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 => <<"show_help_aux"/utf8>>,
line => 57,
value => _assert_fail,
start => 1200,
'end' => 1239,
pattern_start => 1211,
pattern_end => 1232})
end,
Indentstr = gleam@string:repeat(
erlang:element(3, Showhelp_settings),
Indent_level
),
case Args_h@1 of
{flag, _, _, _, _, _} ->
_pipe = glap@help_settings:format_argument_without_desc(
Args_h@1
),
_pipe@1 = gleam@string:append(Indentstr, _pipe),
_pipe@2 = gleam@string:pad_end(
_pipe@1,
Tabdesc_length,
<<" "/utf8>>
),
_pipe@3 = gleam@string:append(
_pipe@2,
<<(glap@arguments:get_description(Args_h@1))/binary,
"\n"/utf8>>
),
Printfun(_pipe@3);
{unnamed_argument, _, _} ->
_pipe@4 = glap@help_settings:format_argument_without_desc(
Args_h@1
),
_pipe@5 = gleam@string:append(Indentstr, _pipe@4),
_pipe@6 = gleam@string:pad_end(
_pipe@5,
Tabdesc_length,
<<" "/utf8>>
),
_pipe@7 = gleam@string:append(
_pipe@6,
<<(glap@arguments:get_description(Args_h@1))/binary,
"\n"/utf8>>
),
Printfun(_pipe@7);
{command, _, _, _, Subcommands} ->
case Indent_level < erlang:element(5, Showhelp_settings) of
true ->
Printfun(<<"\n"/utf8>>);
false ->
nil
end,
_pipe@8 = glap@help_settings:format_argument_without_desc(
Args_h@1
),
_pipe@9 = gleam@string:append(Indentstr, _pipe@8),
_pipe@10 = gleam@string:pad_end(
_pipe@9,
Tabdesc_length,
<<" "/utf8>>
),
_pipe@11 = gleam@string:append(
_pipe@10,
<<(glap@arguments:get_description(Args_h@1))/binary,
"\n"/utf8>>
),
Printfun(_pipe@11),
case erlang:element(4, Showhelp_settings) of
true when Indent_level < erlang:element(
5,
Showhelp_settings
) ->
show_help_aux(
Subcommands,
Showhelp_settings,
Printfun,
Tabdesc_length,
Indent_level + 1
);
_ ->
nil
end
end,
show_help_aux(
Args_rest@1,
Showhelp_settings,
Printfun,
Tabdesc_length,
Indent_level
)
end
).
-file("src/glap/parser.gleam", 101).
-spec show_help(parser()) -> nil.
show_help(Parser) ->
Settings = gleam@option:unwrap(
erlang:element(5, Parser),
glap@help_settings:default_help_settings()
),
Printfun = case erlang:element(2, Settings) of
true ->
fun gleam_stdlib:print_error/1;
false ->
fun gleam_stdlib:print/1
end,
Tabdesc_length = glap@help_settings:get_tabdesc_string_length(
erlang:element(2, Parser)
)
+ 4,
_pipe = glap@utils:strformat(
<<"Usage: {} [OPTS...]\n{}\n\n"/utf8>>,
[erlang:element(3, argv:load()), erlang:element(3, Parser)]
),
Printfun(_pipe),
show_help_aux(
erlang:element(2, Parser),
Settings,
Printfun,
Tabdesc_length,
0
).
-file("src/glap/parser.gleam", 125).
-spec parse(parser(), list(binary())) -> {ok, list(glap@cliargs:c_l_i_arg())} |
{error, glap@error:parsing_error()}.
parse(Parser, Args) ->
Settings = gleam@option:unwrap(
erlang:element(4, Parser),
glap@parser_settings:default_parser_settings()
),
Subcommands = gleam@list:filter(
erlang:element(2, Parser),
fun glap@arguments:is_command/1
),
Subflags = gleam@list:filter(
erlang:element(2, Parser),
fun glap@arguments:is_flag/1
),
Subunnamedarguments = gleam@list:filter(
erlang:element(2, Parser),
fun glap@arguments:is_unnamed_argument/1
),
case {parse_aux(Args, Subcommands, Subflags, Subunnamedarguments, Settings),
erlang:element(4, Settings)} of
{{ok, X}, _} ->
{ok, X};
{{error, {E, Args@1}}, true} ->
Showhelp_settings = gleam@option:unwrap(
erlang:element(5, Parser),
glap@help_settings:default_help_settings()
),
Printfun = case erlang:element(2, Showhelp_settings) of
true ->
fun gleam_stdlib:print_error/1;
false ->
fun gleam_stdlib:print/1
end,
Tabdesc_length = glap@help_settings:get_tabdesc_string_length(
erlang:element(2, Parser)
)
+ 4,
show_help_aux(
Args@1,
Showhelp_settings,
Printfun,
Tabdesc_length,
0
),
run_on_parse_error(Settings),
{error, E};
{{error, {E@1, _}}, false} ->
run_on_parse_error(Settings),
{error, E@1}
end.
-file("src/glap/parser.gleam", 321).
-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())).