Packages
glint
0.17.1
1.3.0
1.2.1
1.2.0
1.1.1
1.1.0
1.0.1
1.0.0
1.0.0-rc5
1.0.0-rc4
1.0.0-rc3
1.0.0-rc2
1.0.0-rc1
0.18.1
0.18.0
0.17.1
0.17.0
0.16.0
0.16.0-rc1
0.15.0
0.15.0-rc2
0.15.0-rc1
0.14.0
0.13.0
0.12.0
0.12.0-rc6
0.12.0-rc5
0.12.0-rc4
0.12.0-rc3
0.12.0-rc2
0.12.0-rc1
0.11.4
0.11.3
0.11.2
0.11.0
0.10.0
0.9.0
0.8.0
0.7.4
0.7.3
0.7.2
0.7.1
0.7.0
0.6.0
0.5.0
0.4.0
0.3.0
0.2.0
0.1.3
0.1.2
0.1.1
0.1.0
Gleam command-line argument parsing with flags and automated help text generation.
Current section
Files
Jump to
Current section
Files
src/glint.erl
-module(glint).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-export([with_config/2, with_pretty_help/2, without_pretty_help/1, with_name/2, as_gleam_module/1, command/1, description/2, unnamed_args/2, named_args/2, flag/3, flag_tuple/2, flags/2, global_flag/3, global_flag_tuple/2, global_flags/2, default_pretty_help/0, add/3, new/0, help_flag/0, execute/2, run_and_handle/3, run/2]).
-export_type([config/0, pretty_help/0, glint/1, args_count/0, command/1, command_input/0, command_node/1, out/1, metadata/0, flag_help/0, command_help/0]).
-type config() :: {config,
gleam@option:option(pretty_help()),
gleam@option:option(binary()),
boolean()}.
-type pretty_help() :: {pretty_help,
gleam_community@colour:colour(),
gleam_community@colour:colour(),
gleam_community@colour:colour()}.
-opaque glint(GKV) :: {glint,
config(),
command_node(GKV),
gleam@dict:dict(binary(), glint@flag:flag())}.
-type args_count() :: {eq_args, integer()} | {min_args, integer()}.
-opaque command(GKW) :: {command,
fun((command_input()) -> GKW),
gleam@dict:dict(binary(), glint@flag:flag()),
binary(),
gleam@option:option(args_count()),
list(binary())}.
-type command_input() :: {command_input,
list(binary()),
gleam@dict:dict(binary(), glint@flag:flag()),
gleam@dict:dict(binary(), binary())}.
-type command_node(GKX) :: {command_node,
gleam@option:option(command(GKX)),
gleam@dict:dict(binary(), command_node(GKX))}.
-type out(GKY) :: {out, GKY} | {help, binary()}.
-type metadata() :: {metadata, binary(), binary()}.
-type flag_help() :: {flag_help, metadata(), binary()}.
-type command_help() :: {command_help,
metadata(),
list(flag_help()),
list(metadata()),
gleam@option:option(args_count()),
list(binary())}.
-spec with_config(glint(GLE), config()) -> glint(GLE).
with_config(Glint, Config) ->
erlang:setelement(2, Glint, Config).
-spec with_pretty_help(glint(GLH), pretty_help()) -> glint(GLH).
with_pretty_help(Glint, Pretty) ->
_pipe = erlang:setelement(2, erlang:element(2, Glint), {some, Pretty}),
with_config(Glint, _pipe).
-spec without_pretty_help(glint(GLK)) -> glint(GLK).
without_pretty_help(Glint) ->
_pipe = erlang:setelement(2, erlang:element(2, Glint), none),
with_config(Glint, _pipe).
-spec with_name(glint(GLN), binary()) -> glint(GLN).
with_name(Glint, Name) ->
_pipe = erlang:setelement(3, erlang:element(2, Glint), {some, Name}),
with_config(Glint, _pipe).
-spec as_gleam_module(glint(GLQ)) -> glint(GLQ).
as_gleam_module(Glint) ->
_pipe = erlang:setelement(4, erlang:element(2, Glint), true),
with_config(Glint, _pipe).
-spec empty_command() -> command_node(any()).
empty_command() ->
{command_node, none, gleam@dict:new()}.
-spec do_add(command_node(GMA), list(binary()), command(GMA)) -> command_node(GMA).
do_add(Root, Path, Contents) ->
case Path of
[] ->
erlang:setelement(2, Root, {some, Contents});
[X | Xs] ->
erlang:setelement(
3,
Root,
(gleam@dict:update(
erlang:element(3, Root),
X,
fun(Node) -> _pipe = Node,
_pipe@1 = gleam@option:lazy_unwrap(
_pipe,
fun empty_command/0
),
do_add(_pipe@1, Xs, Contents) end
))
)
end.
-spec command(fun((command_input()) -> GMJ)) -> command(GMJ).
command(Runner) ->
{command, Runner, gleam@dict:new(), <<""/utf8>>, none, []}.
-spec description(command(GMM), binary()) -> command(GMM).
description(Cmd, Description) ->
erlang:setelement(4, Cmd, Description).
-spec unnamed_args(command(GMP), args_count()) -> command(GMP).
unnamed_args(Cmd, Count) ->
erlang:setelement(5, Cmd, {some, Count}).
-spec named_args(command(GMS), list(binary())) -> command(GMS).
named_args(Cmd, Args) ->
erlang:setelement(6, Cmd, Args).
-spec flag(command(GMW), binary(), glint@flag:flag_builder(any())) -> command(GMW).
flag(Cmd, Key, Flag) ->
erlang:setelement(
3,
Cmd,
gleam@dict:insert(erlang:element(3, Cmd), Key, glint@flag:build(Flag))
).
-spec flag_tuple(command(GNB), {binary(), glint@flag:flag_builder(any())}) -> command(GNB).
flag_tuple(Cmd, Tup) ->
flag(Cmd, erlang:element(1, Tup), erlang:element(2, Tup)).
-spec flags(command(GNG), list({binary(), glint@flag:flag()})) -> command(GNG).
flags(Cmd, Flags) ->
gleam@list:fold(
Flags,
Cmd,
fun(Cmd@1, _use1) ->
{Key, Flag} = _use1,
erlang:setelement(
3,
Cmd@1,
gleam@dict:insert(erlang:element(3, Cmd@1), Key, Flag)
)
end
).
-spec global_flag(glint(GNK), binary(), glint@flag:flag_builder(any())) -> glint(GNK).
global_flag(Glint, Key, Flag) ->
erlang:setelement(
4,
Glint,
gleam@dict:insert(erlang:element(4, Glint), Key, glint@flag:build(Flag))
).
-spec global_flag_tuple(glint(GNP), {binary(), glint@flag:flag_builder(any())}) -> glint(GNP).
global_flag_tuple(Glint, Tup) ->
global_flag(Glint, erlang:element(1, Tup), erlang:element(2, Tup)).
-spec global_flags(glint(GNU), list({binary(), glint@flag:flag()})) -> glint(GNU).
global_flags(Glint, Flags) ->
erlang:setelement(
4,
Glint,
(gleam@list:fold(
Flags,
erlang:element(4, Glint),
fun(Acc, Elem) ->
gleam@dict:insert(
Acc,
erlang:element(1, Elem),
erlang:element(2, Elem)
)
end
))
).
-spec args_compare(args_count(), integer()) -> {ok, nil} | {error, snag:snag()}.
args_compare(Expected, Actual) ->
_pipe = case Expected of
{eq_args, Expected@1} when Actual =:= Expected@1 ->
{ok, nil};
{min_args, Expected@2} when Actual >= Expected@2 ->
{ok, nil};
{eq_args, Expected@3} ->
{error, gleam@int:to_string(Expected@3)};
{min_args, Expected@4} ->
{error,
<<"at least "/utf8, (gleam@int:to_string(Expected@4))/binary>>}
end,
gleam@result:map_error(
_pipe,
fun(Err) ->
snag:new(
<<<<<<"expected: "/utf8, Err/binary>>/binary,
" argument(s), provided: "/utf8>>/binary,
(gleam@int:to_string(Actual))/binary>>
)
end
).
-spec default_pretty_help() -> pretty_help().
default_pretty_help() ->
_assert_subject = gleam_community@colour:from_rgb255(182, 255, 234),
{ok, Usage_colour} = case _assert_subject of
{ok, _} -> _assert_subject;
_assert_fail ->
erlang:error(#{gleam_error => let_assert,
message => <<"Assertion pattern match failed"/utf8>>,
value => _assert_fail,
module => <<"glint"/utf8>>,
function => <<"default_pretty_help"/utf8>>,
line => 517})
end,
_assert_subject@1 = gleam_community@colour:from_rgb255(255, 175, 243),
{ok, Flags_colour} = case _assert_subject@1 of
{ok, _} -> _assert_subject@1;
_assert_fail@1 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Assertion pattern match failed"/utf8>>,
value => _assert_fail@1,
module => <<"glint"/utf8>>,
function => <<"default_pretty_help"/utf8>>,
line => 518})
end,
_assert_subject@2 = gleam_community@colour:from_rgb255(252, 226, 174),
{ok, Subcommands_colour} = case _assert_subject@2 of
{ok, _} -> _assert_subject@2;
_assert_fail@2 ->
erlang:error(#{gleam_error => let_assert,
message => <<"Assertion pattern match failed"/utf8>>,
value => _assert_fail@2,
module => <<"glint"/utf8>>,
function => <<"default_pretty_help"/utf8>>,
line => 519})
end,
{pretty_help, Usage_colour, Flags_colour, Subcommands_colour}.
-spec is_not_empty(binary()) -> boolean().
is_not_empty(S) ->
S /= <<""/utf8>>.
-spec sanitize_path(list(binary())) -> list(binary()).
sanitize_path(Path) ->
_pipe = Path,
_pipe@1 = gleam@list:map(_pipe, fun gleam@string:trim/1),
gleam@list:filter(_pipe@1, fun is_not_empty/1).
-spec add(glint(GLV), list(binary()), command(GLV)) -> glint(GLV).
add(Glint, Path, Contents) ->
erlang:setelement(
3,
Glint,
begin
_pipe = Path,
_pipe@1 = sanitize_path(_pipe),
do_add(erlang:element(3, Glint), _pipe@1, Contents)
end
).
-spec heading_style(binary(), gleam_community@colour:colour()) -> binary().
heading_style(Heading, Colour) ->
_pipe = Heading,
_pipe@1 = gleam_community@ansi:bold(_pipe),
_pipe@2 = gleam_community@ansi:underline(_pipe@1),
_pipe@3 = gleam_community@ansi:italic(_pipe@2),
_pipe@4 = gleam_community@ansi:hex(
_pipe@3,
gleam_community@colour:to_rgb_hex(Colour)
),
gleam_community@ansi:reset(_pipe@4).
-spec flag_type_info(glint@flag:flag()) -> binary().
flag_type_info(Flag) ->
case erlang:element(2, Flag) of
{i, _} ->
<<"INT"/utf8>>;
{b, _} ->
<<"BOOL"/utf8>>;
{f, _} ->
<<"FLOAT"/utf8>>;
{lf, _} ->
<<"FLOAT_LIST"/utf8>>;
{li, _} ->
<<"INT_LIST"/utf8>>;
{ls, _} ->
<<"STRING_LIST"/utf8>>;
{s, _} ->
<<"STRING"/utf8>>
end.
-spec build_flags_help(gleam@dict:dict(binary(), glint@flag:flag())) -> list(flag_help()).
build_flags_help(Flag) ->
gleam@dict:fold(
Flag,
[],
fun(Acc, Name, Flag@1) ->
[{flag_help,
{metadata, Name, erlang:element(3, Flag@1)},
flag_type_info(Flag@1)} |
Acc]
end
).
-spec build_subcommands_help(gleam@dict:dict(binary(), command_node(any()))) -> list(metadata()).
build_subcommands_help(Subcommands) ->
gleam@dict:fold(
Subcommands,
[],
fun(Acc, Name, Cmd) ->
[{metadata,
Name,
begin
_pipe = erlang:element(2, Cmd),
_pipe@1 = gleam@option:map(
_pipe,
fun(Command) -> erlang:element(4, Command) end
),
gleam@option:unwrap(_pipe@1, <<""/utf8>>)
end} |
Acc]
end
).
-spec build_command_help_metadata(
binary(),
command_node(any()),
gleam@dict:dict(binary(), glint@flag:flag())
) -> command_help().
build_command_help_metadata(Name, Node, Global_flags) ->
{Description, Flags, Unnamed_args, Named_args} = case erlang:element(
2,
Node
) of
none ->
{<<""/utf8>>, [], none, []};
{some, Cmd} ->
{erlang:element(4, Cmd),
build_flags_help(
gleam@dict:merge(Global_flags, erlang:element(3, Cmd))
),
erlang:element(5, Cmd),
erlang:element(6, Cmd)}
end,
{command_help,
{metadata, Name, Description},
Flags,
build_subcommands_help(erlang:element(3, Node)),
Unnamed_args,
Named_args}.
-spec args_count_to_usage_string(args_count()) -> binary().
args_count_to_usage_string(Count) ->
case Count of
{eq_args, 0} ->
<<""/utf8>>;
{eq_args, 1} ->
<<"[ 1 argument ]"/utf8>>;
{eq_args, N} ->
<<<<"[ "/utf8, (gleam@int:to_string(N))/binary>>/binary,
" arguments ]"/utf8>>;
{min_args, N@1} ->
<<<<"[ "/utf8, (gleam@int:to_string(N@1))/binary>>/binary,
" or more arguments ]"/utf8>>
end.
-spec args_to_usage_string(gleam@option:option(args_count()), list(binary())) -> binary().
args_to_usage_string(Unnamed, Named) ->
Named_args = begin
_pipe = Named,
_pipe@1 = gleam@list:map(
_pipe,
fun(S) -> <<<<"<"/utf8, S/binary>>/binary, ">"/utf8>> end
),
gleam@string:join(_pipe@1, <<" "/utf8>>)
end,
Unnamed_args = begin
_pipe@2 = gleam@option:map(Unnamed, fun args_count_to_usage_string/1),
gleam@option:unwrap(_pipe@2, <<"[ ARGS ]"/utf8>>)
end,
case {Named_args, Unnamed_args} of
{<<""/utf8>>, <<""/utf8>>} ->
<<""/utf8>>;
{<<""/utf8>>, _} ->
Unnamed_args;
{_, <<""/utf8>>} ->
Named_args;
{_, _} ->
<<<<Named_args/binary, " "/utf8>>/binary, Unnamed_args/binary>>
end.
-spec flag_help_to_string(flag_help()) -> binary().
flag_help_to_string(Help) ->
<<<<<<<<(<<"--"/utf8>>)/binary,
(erlang:element(2, erlang:element(2, Help)))/binary>>/binary,
"=<"/utf8>>/binary,
(erlang:element(3, Help))/binary>>/binary,
">"/utf8>>.
-spec flags_help_to_usage_strings(list(flag_help())) -> list(binary()).
flags_help_to_usage_strings(Help) ->
_pipe = Help,
_pipe@1 = gleam@list:map(_pipe, fun flag_help_to_string/1),
gleam@list:sort(_pipe@1, fun gleam@string:compare/2).
-spec flags_help_to_usage_string(list(flag_help())) -> binary().
flags_help_to_usage_string(Help) ->
gleam@bool:guard(Help =:= [], <<""/utf8>>, fun() -> _pipe = Help,
_pipe@1 = flags_help_to_usage_strings(_pipe),
_pipe@2 = gleam@list:intersperse(_pipe@1, <<" "/utf8>>),
_pipe@3 = gleam@string_builder:from_strings(_pipe@2),
_pipe@4 = gleam@string_builder:prepend(_pipe@3, <<"[ "/utf8>>),
_pipe@5 = gleam@string_builder:append(_pipe@4, <<" ]"/utf8>>),
gleam@string_builder:to_string(_pipe@5) end).
-spec flag_help_to_string_with_description(flag_help()) -> binary().
flag_help_to_string_with_description(Help) ->
<<<<(flag_help_to_string(Help))/binary, "\t\t"/utf8>>/binary,
(erlang:element(3, erlang:element(2, Help)))/binary>>.
-spec subcommand_help_to_string(metadata()) -> binary().
subcommand_help_to_string(Help) ->
case erlang:element(3, Help) of
<<""/utf8>> ->
erlang:element(2, Help);
_ ->
<<<<(erlang:element(2, Help))/binary, "\t\t"/utf8>>/binary,
(erlang:element(3, Help))/binary>>
end.
-spec string_map(binary(), fun((binary()) -> binary())) -> binary().
string_map(S, F) ->
case S of
<<""/utf8>> ->
<<""/utf8>>;
_ ->
F(S)
end.
-spec new() -> glint(any()).
new() ->
{glint, {config, none, none, false}, empty_command(), gleam@dict:new()}.
-spec subcommands_help_to_string(list(metadata()), config()) -> binary().
subcommands_help_to_string(Help, Config) ->
gleam@bool:guard(
Help =:= [],
<<""/utf8>>,
fun() -> <<(case erlang:element(2, Config) of
none ->
<<"SUBCOMMANDS:"/utf8>>;
{some, Pretty} ->
heading_style(
<<"SUBCOMMANDS:"/utf8>>,
erlang:element(4, Pretty)
)
end)/binary, (begin
_pipe = Help,
_pipe@1 = gleam@list:map(
_pipe,
fun subcommand_help_to_string/1
),
_pipe@2 = gleam@list:sort(
_pipe@1,
fun gleam@string:compare/2
),
_pipe@3 = gleam@list:map(
_pipe@2,
fun(_capture) ->
gleam@string:append(<<"\n\t"/utf8>>, _capture)
end
),
gleam@string:concat(_pipe@3)
end)/binary>> end
).
-spec command_help_to_usage_string(command_help(), config()) -> binary().
command_help_to_usage_string(Help, Config) ->
App_name = case erlang:element(3, Config) of
{some, Name} when erlang:element(4, Config) ->
<<"gleam run -m "/utf8, Name/binary>>;
{some, Name@1} ->
Name@1;
none ->
<<"gleam run"/utf8>>
end,
Flags = flags_help_to_usage_string(erlang:element(3, Help)),
Args = args_to_usage_string(
erlang:element(5, Help),
erlang:element(6, Help)
),
<<<<<<<<<<(case erlang:element(2, Config) of
none ->
<<"USAGE:"/utf8>>;
{some, Pretty} ->
heading_style(
<<"USAGE:"/utf8>>,
erlang:element(2, Pretty)
)
end)/binary, "\n\t"/utf8>>/binary, App_name/binary>>/binary, (string_map(
erlang:element(2, erlang:element(2, Help)),
fun(_capture) ->
gleam@string:append(<<" "/utf8>>, _capture)
end
))/binary>>/binary, (case Args of
<<""/utf8>> ->
<<" "/utf8>>;
_ ->
<<<<" "/utf8, Args/binary>>/binary, " "/utf8>>
end)/binary>>/binary, Flags/binary>>.
-spec help_flag() -> binary().
help_flag() ->
<<(<<"--"/utf8>>)/binary, "help"/utf8>>.
-spec flags_help_to_string(list(flag_help()), config()) -> binary().
flags_help_to_string(Help, Config) ->
gleam@bool:guard(
Help =:= [],
<<""/utf8>>,
fun() -> <<(case erlang:element(2, Config) of
none ->
<<"FLAGS:"/utf8>>;
{some, Pretty} ->
heading_style(
<<"FLAGS:"/utf8>>,
erlang:element(3, Pretty)
)
end)/binary, (begin
_pipe = [<<"--help\t\t\tPrint help information"/utf8>> |
gleam@list:map(
Help,
fun flag_help_to_string_with_description/1
)],
_pipe@1 = gleam@list:sort(_pipe, fun gleam@string:compare/2),
_pipe@2 = gleam@list:map(
_pipe@1,
fun(_capture) ->
gleam@string:append(<<"\n\t"/utf8>>, _capture)
end
),
gleam@string:concat(_pipe@2)
end)/binary>> end
).
-spec command_help_to_string(command_help(), config()) -> binary().
command_help_to_string(Help, Config) ->
Header_items = begin
_pipe = [erlang:element(2, erlang:element(2, Help)),
erlang:element(3, erlang:element(2, Help))],
_pipe@1 = gleam@list:filter(_pipe, fun is_not_empty/1),
gleam@string:join(_pipe@1, <<"\n"/utf8>>)
end,
_pipe@2 = [Header_items,
command_help_to_usage_string(Help, Config),
flags_help_to_string(erlang:element(3, Help), Config),
subcommands_help_to_string(erlang:element(4, Help), Config)],
_pipe@3 = gleam@list:filter(_pipe@2, fun is_not_empty/1),
gleam@string:join(_pipe@3, <<"\n\n"/utf8>>).
-spec cmd_help(
list(binary()),
command_node(any()),
config(),
gleam@dict:dict(binary(), glint@flag:flag())
) -> binary().
cmd_help(Path, Cmd, Config, Global_flags) ->
_pipe = Path,
_pipe@1 = gleam@list:reverse(_pipe),
_pipe@2 = gleam@string:join(_pipe@1, <<" "/utf8>>),
_pipe@3 = build_command_help_metadata(_pipe@2, Cmd, Global_flags),
command_help_to_string(_pipe@3, Config).
-spec execute_root(
list(binary()),
config(),
command_node(GOK),
gleam@dict:dict(binary(), glint@flag:flag()),
list(binary()),
list(binary())
) -> {ok, out(GOK)} | {error, binary()}.
execute_root(Path, Config, Cmd, Global_flags, Args, Flag_inputs) ->
Res = begin
_pipe@7 = (gleam@option:map(
erlang:element(2, Cmd),
fun(Contents) ->
gleam@result:'try'(
gleam@list:try_fold(
Flag_inputs,
gleam@dict:merge(
Global_flags,
erlang:element(3, Contents)
),
fun glint@flag:update_flags/2
),
fun(New_flags) ->
gleam@result:'try'(
begin
Named = gleam@list:zip(
erlang:element(6, Contents),
Args
),
case gleam@list:length(Named) =:= gleam@list:length(
erlang:element(6, Contents)
) of
true ->
{ok, maps:from_list(Named)};
false ->
snag:error(
<<"unmatched named arguments: "/utf8,
(begin
_pipe = erlang:element(
6,
Contents
),
_pipe@1 = gleam@list:drop(
_pipe,
gleam@list:length(Named)
),
_pipe@2 = gleam@list:map(
_pipe@1,
fun(S) ->
<<<<"'"/utf8,
S/binary>>/binary,
"'"/utf8>>
end
),
gleam@string:join(
_pipe@2,
<<", "/utf8>>
)
end)/binary>>
)
end
end,
fun(Named_args) ->
Args@1 = gleam@list:drop(
Args,
maps:size(Named_args)
),
gleam@result:map(
case erlang:element(5, Contents) of
{some, Count} ->
_pipe@3 = Count,
_pipe@4 = args_compare(
_pipe@3,
gleam@list:length(Args@1)
),
snag:context(
_pipe@4,
<<"invalid number of arguments provided"/utf8>>
);
none ->
{ok, nil}
end,
fun(_) ->
_pipe@5 = {command_input,
Args@1,
New_flags,
Named_args},
_pipe@6 = (erlang:element(2, Contents))(
_pipe@5
),
{out, _pipe@6}
end
)
end
)
end
)
end
)),
_pipe@8 = gleam@option:unwrap(
_pipe@7,
snag:error(<<"command not found"/utf8>>)
),
_pipe@9 = snag:context(_pipe@8, <<"failed to run command"/utf8>>),
gleam@result:map_error(
_pipe@9,
fun(Err) -> {Err, cmd_help(Path, Cmd, Config, Global_flags)} end
)
end,
case Res of
{ok, Out} ->
{ok, Out};
{error, {Snag, Help}} ->
{error,
<<<<(snag:pretty_print(Snag))/binary,
"\nSee the following help text, available via the '--help' flag.\n\n"/utf8>>/binary,
Help/binary>>}
end.
-spec do_execute(
command_node(GOC),
config(),
gleam@dict:dict(binary(), glint@flag:flag()),
list(binary()),
list(binary()),
boolean(),
list(binary())
) -> {ok, out(GOC)} | {error, binary()}.
do_execute(Cmd, Config, Global_flags, Args, Flags, Help, Command_path) ->
case Args of
[] when Help ->
_pipe = Command_path,
_pipe@1 = cmd_help(_pipe, Cmd, Config, Global_flags),
_pipe@2 = {help, _pipe@1},
{ok, _pipe@2};
[] ->
execute_root(Command_path, Config, Cmd, Global_flags, [], Flags);
[Arg | Rest] ->
case gleam@dict:get(erlang:element(3, Cmd), Arg) of
{ok, Cmd@1} ->
do_execute(
Cmd@1,
Config,
Global_flags,
Rest,
Flags,
Help,
[Arg | Command_path]
);
_ when Help ->
_pipe@3 = Command_path,
_pipe@4 = cmd_help(_pipe@3, Cmd, Config, Global_flags),
_pipe@5 = {help, _pipe@4},
{ok, _pipe@5};
_ ->
execute_root(
Command_path,
Config,
Cmd,
Global_flags,
Args,
Flags
)
end
end.
-spec execute(glint(GNY), list(binary())) -> {ok, out(GNY)} | {error, binary()}.
execute(Glint, Args) ->
Help_flag = help_flag(),
{Help, Args@2} = case gleam@list:pop(Args, fun(S) -> S =:= Help_flag end) of
{ok, {_, Args@1}} ->
{true, Args@1};
_ ->
{false, Args}
end,
{Flags, Args@3} = gleam@list:partition(
Args@2,
fun(_capture) -> gleam@string:starts_with(_capture, <<"--"/utf8>>) end
),
do_execute(
erlang:element(3, Glint),
erlang:element(2, Glint),
erlang:element(4, Glint),
Args@3,
Flags,
Help,
[]
).
-spec run_and_handle(glint(GOS), list(binary()), fun((GOS) -> any())) -> nil.
run_and_handle(Glint, Args, Handle) ->
case execute(Glint, Args) of
{error, S} ->
gleam@io:println(S);
{ok, {help, S}} ->
gleam@io:println(S);
{ok, {out, Out}} ->
Handle(Out),
nil
end.
-spec run(glint(any()), list(binary())) -> nil.
run(Glint, Args) ->
run_and_handle(Glint, Args, fun(_) -> nil end).