From e1f239785bc10f13fc153613aa26eca85ca773ff Mon Sep 17 00:00:00 2001 From: Juan Jose Comellas Date: Sun, 29 Jan 2012 12:13:36 -0300 Subject: [PATCH] Make multiple repetitions with implicit arguments more 'intuitive' --- README.markdown | 72 +++++++++--- src/getopt.erl | 257 ++++++++++++++++++++++--------------------- test/getopt_test.erl | 9 +- 3 files changed, 194 insertions(+), 144 deletions(-) diff --git a/README.markdown b/README.markdown index d999988..f3cbb0e 100644 --- a/README.markdown +++ b/README.markdown @@ -80,7 +80,7 @@ added to the list of options. For the example given above we could get something like ``{port, 5432}``. The non-option arguments are just a list of strings with all the arguments that did not have corresponding options. -e.g. For a program named ``ex.escript`` with the following option specifications: +e.g. Given the following option specifications: OptSpecList = [ @@ -114,7 +114,6 @@ Will return: {verbose,3}], ["dummy1","dummy2"]}} - The other functions exported by the ``getopt`` module (``usage/2``, ``usage/3`` and ``usage/4``) are used to show the command line syntax for the program. For example, given the above-mentioned option specifications, the call to @@ -184,7 +183,7 @@ A short option can have the following syntax: -afoo Single option 'a', argument "foo" -abc Multiple options: 'a'; 'b'; 'c' -bcafoo Multiple options: 'b'; 'c'; 'a' with argument "foo" - -aaa Multiple repetitions of option 'a' (when 'a' has integer arguments) + -aaa Multiple repetitions of option 'a' A long option can have the following syntax: @@ -192,6 +191,62 @@ A long option can have the following syntax: --foo=bar Single option 'foo', argument "bar" --foo bar Single option 'foo', argument "bar" + +Argument Types +-------------- + +The arguments allowed for options are: *atom*; *binary*; *boolean*; *float*; *integer*; *string*. +The ``getopt`` module checks every argument to see if it can be converted to its +correct type. + +In the case of boolean arguments, the following values (in lower or +upper case) are considered ``true``: *true*; *t*; *yes*; *y*; *on*; *enabled*; *1*. +These ones are considered ``false``: *false*; *f*; *no*; *n*; *off*; *disabled*; *0*. + +Numeric arguments can only be negative when passed as part of an assignment expression. + +e.g. ``--increment=-100`` is a valid expression; whereas ``--increment -100`` is invalid + + +Implicit Arguments +------------------ + +The arguments for options with the *boolean* and *integer* data types can sometimes +be omitted. In those cases a the value assigned to the option is *true* for *boolean* +arguments and *1* for integer arguments. + + +Multiple Repetitions +-------------------- + +An option can be repeated several times, in which case there will be multiple +appearances of the option in the resulting list. The only exceptions are short +options with integer arguments. In that particular case, each appearance of +the short option within a single command line argument will increment the +number that will be returned for that specific option. + +e.g. Given an option specification list with the following format: + + OptSpecList = + [ + {define, $D, "define", string, "Define a variable"}, + {debug, $d, "debug", integer, "Debug level"} + ], + +The following invocation: + + getopt:parse(OptSpecList, "-DFOO -DVAR1=VAL1 -DBAR --debug --debug=3 -d -dddd dummy"). + +would return: + + {ok,{[{define,"FOO"}, {define,"VAR1=VAL1"}, {define,"BAR"}, + {debug,1}, {debug,3}, {debug,1}, {debug,4}], + ["dummy"]}} + + +Positional Options +------------------ + We can also have options with neither short nor long option name. In this case, the options will be taken according to their position in the option specification list passed to ``getopt:/parse2``. @@ -221,14 +276,3 @@ Will return: Finally, the string ``--`` is considered an option terminator (i.e. all arguments after it are considered non-option arguments) and the single ``-`` character is considered as non-option argument too. - - -Argument Types --------------- - -The arguments allowed for options are: *atom*; *binary*; *boolean*; *float*; *integer*; *string*. -The ``getopt`` module checks every argument to see if it can be converted to its -correct type. In the case of boolean arguments, the following values (in lower or -upper case) are considered ``true``: *true*; *t*; *yes*; *y*; *on*; *enabled*; *1*. - -And these ones are considered ``false``: *false*; *f*; *no*; *n*; *off*; *disabled*; *0*. diff --git a/src/getopt.erl b/src/getopt.erl index 2a6575e..77c8342 100644 --- a/src/getopt.erl +++ b/src/getopt.erl @@ -81,26 +81,25 @@ parse(OptSpecList, CmdLine) -> {ok, {[option()], [string()]}}. %% Process the option terminator. parse(OptSpecList, OptAcc, ArgAcc, _ArgPos, ["--" | Tail]) -> - % Any argument present after the terminator is not considered an option. + %% Any argument present after the terminator is not considered an option. {ok, {lists:reverse(append_default_options(OptSpecList, OptAcc)), lists:reverse(ArgAcc, Tail)}}; %% Process long options. parse(OptSpecList, OptAcc, ArgAcc, ArgPos, ["--" ++ OptArg = OptStr | Tail]) -> - parse_option_long(OptSpecList, OptAcc, ArgAcc, ArgPos, Tail, OptStr, OptArg); + parse_long_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Tail, OptStr, OptArg); %% Process short options. parse(OptSpecList, OptAcc, ArgAcc, ArgPos, ["-" ++ ([_Char | _] = OptArg) = OptStr | Tail]) -> - parse_option_short(OptSpecList, OptAcc, ArgAcc, ArgPos, Tail, OptStr, OptArg); + parse_short_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Tail, OptStr, OptArg); %% Process non-option arguments. parse(OptSpecList, OptAcc, ArgAcc, ArgPos, [Arg | Tail]) -> case find_non_option_arg(OptSpecList, ArgPos) of {value, OptSpec} when ?IS_OPT_SPEC(OptSpec) -> - parse(OptSpecList, add_option_arg(OptSpec, Arg, OptAcc), - ArgAcc, ArgPos + 1, Tail); + parse(OptSpecList, add_option_with_arg(OptSpec, Arg, OptAcc), ArgAcc, ArgPos + 1, Tail); false -> parse(OptSpecList, OptAcc, [Arg | ArgAcc], ArgPos, Tail) end; parse(OptSpecList, OptAcc, ArgAcc, _ArgPos, []) -> - % Once we have completed gathering the options we add the ones that were - % not present but had default arguments in the specification. + %% Once we have completed gathering the options we add the ones that were + %% not present but had default arguments in the specification. {ok, {lists:reverse(append_default_options(OptSpecList, OptAcc)), lists:reverse(ArgAcc)}}. @@ -110,14 +109,14 @@ parse(OptSpecList, OptAcc, ArgAcc, _ArgPos, []) -> %% --foo Single option 'foo', no argument %% --foo=bar Single option 'foo', argument "bar" %% --foo bar Single option 'foo', argument "bar" --spec parse_option_long([option_spec()], [option()], [string()], integer(), [string()], string(), string()) -> +-spec parse_long_option([option_spec()], [option()], [string()], integer(), [string()], string(), string()) -> {ok, {[option()], [string()]}}. -parse_option_long(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, OptArg) -> +parse_long_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, OptArg) -> case split_assigned_arg(OptArg) of {Long, Arg} -> - % Get option that has its argument within the same string - % separated by an equal ('=') character (e.g. "--port=1000"). - parse_option_assigned_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, Long, Arg); + %% Get option that has its argument within the same string + %% separated by an equal ('=') character (e.g. "--port=1000"). + parse_long_option_assigned_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, Long, Arg); Long -> case lists:keyfind(Long, ?OPT_LONG, OptSpecList) of @@ -125,9 +124,10 @@ parse_option_long(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, OptArg) -> parse(OptSpecList, [Name | OptAcc], ArgAcc, ArgPos, Args); {_Name, _Short, Long, _ArgSpec, _Help} = OptSpec -> - % The option argument string is empty, but the option requires - % an argument, so we look into the next string in the list. - parse_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptSpec); + %% The option argument string is empty, but the option requires + %% an argument, so we look into the next string in the list. + %% e.g ["--port", "1000"] + parse_long_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptSpec); false -> throw({error, {invalid_option, OptStr}}) end @@ -137,17 +137,17 @@ parse_option_long(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, OptArg) -> %% @doc Parse an option where the argument is 'assigned' in the same string using %% the '=' character, add it to the option accumulator and continue parsing the %% rest of the arguments recursively. This syntax is only valid for long options. --spec parse_option_assigned_arg([option_spec()], [option()], [string()], integer(), - [string()], string(), string(), string()) -> - {ok, {[option()], [string()]}}. -parse_option_assigned_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, Long, Arg) -> +-spec parse_long_option_assigned_arg([option_spec()], [option()], [string()], integer(), + [string()], string(), string(), string()) -> + {ok, {[option()], [string()]}}. +parse_long_option_assigned_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, Long, Arg) -> case lists:keyfind(Long, ?OPT_LONG, OptSpecList) of {_Name, _Short, Long, ArgSpec, _Help} = OptSpec -> case ArgSpec of undefined -> throw({error, {invalid_option_arg, OptStr}}); _ -> - parse(OptSpecList, add_option_assigned_arg(OptSpec, Arg, OptAcc), ArgAcc, ArgPos, Args) + parse(OptSpecList, add_option_with_assigned_arg(OptSpec, Arg, OptAcc), ArgAcc, ArgPos, Args) end; false -> throw({error, {invalid_option, OptStr}}) @@ -168,6 +168,25 @@ split_assigned_arg(OptStr, [], _Acc) -> OptStr. +%% @doc Retrieve the argument for an option from the next string in the list of +%% command-line parameters or set the value of the argument from the argument +%% specification (for boolean and integer arguments), if possible. +parse_long_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, {Name, _Short, _Long, ArgSpec, _Help} = OptSpec) -> + ArgSpecType = arg_spec_type(ArgSpec), + case Args =:= [] orelse is_implicit_arg(ArgSpecType, hd(Args)) of + true -> + parse(OptSpecList, add_option_with_implicit_arg(OptSpec, OptAcc), ArgAcc, ArgPos, Args); + false -> + [Arg | Tail] = Args, + try + parse(OptSpecList, [{Name, to_type(ArgSpecType, Arg)} | OptAcc], ArgAcc, ArgPos, Tail) + catch + error:_ -> + throw({error, {invalid_option_arg, {Name, Arg}}}) + end + end. + + %% @doc Parse a short option, add it to the option accumulator and continue %% parsing the rest of the arguments recursively. %% A short option can have the following syntax: @@ -177,61 +196,62 @@ split_assigned_arg(OptStr, [], _Acc) -> %% -abc Multiple options: 'a'; 'b'; 'c' %% -bcafoo Multiple options: 'b'; 'c'; 'a' with argument "foo" %% -aaa Multiple repetitions of option 'a' (only valid for options with integer arguments) --spec parse_option_short([option_spec()], [option()], [string()], integer(), [string()], string(), string()) -> +-spec parse_short_option([option_spec()], [option()], [string()], integer(), [string()], string(), string()) -> {ok, {[option()], [string()]}}. -parse_option_short(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, [Short | Arg]) -> +parse_short_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, OptArg) -> + parse_short_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, first, OptArg). + +parse_short_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, OptPos, [Short | Arg]) -> case lists:keyfind(Short, ?OPT_SHORT, OptSpecList) of {Name, Short, _Long, undefined, _Help} -> - parse_option_short(OptSpecList, [Name | OptAcc], ArgAcc, ArgPos, Args, OptStr, Arg); + parse_short_option(OptSpecList, [Name | OptAcc], ArgAcc, ArgPos, Args, OptStr, first, Arg); {_Name, Short, _Long, ArgSpec, _Help} = OptSpec -> + %% The option has a specification, so it requires an argument. case Arg of [] -> %% The option argument string is empty, but the option requires %% an argument, so we look into the next string in the list. - parse_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptSpec); + parse_short_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptSpec, OptPos); _ -> case is_valid_arg(ArgSpec, Arg) of true -> - parse(OptSpecList, add_option_arg(OptSpec, Arg, OptAcc), ArgAcc, ArgPos, Args); + parse(OptSpecList, add_option_with_arg(OptSpec, Arg, OptAcc), ArgAcc, ArgPos, Args); _ -> - %% There are 2 valid cases in which we may not receive an argument but we'll - %% end up adding it anyway: - %% 1) When the expected argument is a boolean: in this case the presence - %% of the option makes the argument true. - %% 2) When the expected argument is an integer: in this case the presence - %% of the option sets the value to 1 and any additional appearances of - %% the option increment it by 1 (e.g. "-vvv" would return {verbose, 3}). - parse_option_short(OptSpecList, add_option_no_arg(OptSpec, OptAcc), ArgAcc, ArgPos, Args, OptStr, Arg) + NewOptAcc = case OptPos of + first -> add_option_with_implicit_arg(OptSpec, OptAcc); + _ -> add_option_with_implicit_incrementable_arg(OptSpec, OptAcc) + end, + parse_short_option(OptSpecList, NewOptAcc, ArgAcc, ArgPos, Args, OptStr, next, Arg) end end; false -> throw({error, {invalid_option, OptStr}}) end; -parse_option_short(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, _OptStr, []) -> +parse_short_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, _OptStr, _OptPos, []) -> parse(OptSpecList, OptAcc, ArgAcc, ArgPos, Args). %% @doc Retrieve the argument for an option from the next string in the list of %% command-line parameters or set the value of the argument from the argument %% specification (for boolean and integer arguments), if possible. -parse_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, [Arg | Tail] = Args, {Name, _Short, _Long, ArgSpec, _Help} = OptSpec) -> - ArgSpecType = arg_spec_type(ArgSpec), - case is_implicit_arg(ArgSpec, Arg) of +parse_short_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, {Name, _Short, _Long, ArgSpec, _Help} = OptSpec, OptPos) -> + case Args =:= [] orelse is_implicit_arg(ArgSpec, hd(Args)) of + true when OptPos =:= first -> + parse(OptSpecList, add_option_with_implicit_arg(OptSpec, OptAcc), ArgAcc, ArgPos, Args); true -> - parse(OptSpecList, add_option_no_arg(OptSpec, OptAcc), ArgAcc, ArgPos, Args); + parse(OptSpecList, add_option_with_implicit_incrementable_arg(OptSpec, OptAcc), ArgAcc, ArgPos, Args); false -> + [Arg | Tail] = Args, try - parse(OptSpecList, add_arg(OptSpec, to_type(ArgSpecType, Arg), OptAcc), ArgAcc, ArgPos, Tail) + parse(OptSpecList, [{Name, to_type(ArgSpec, Arg)} | OptAcc], ArgAcc, ArgPos, Tail) catch error:_ -> throw({error, {invalid_option_arg, {Name, Arg}}}) end - end; -parse_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, [] = Args, OptSpec) -> - parse(OptSpecList, add_option_no_arg(OptSpec, OptAcc), ArgAcc, ArgPos, Args). + end. %% @doc Find the option for the discrete argument in position specified in the @@ -265,9 +285,58 @@ append_default_options([], OptAcc) -> OptAcc. -%% @doc Add an option with no argument. --spec add_option_no_arg(option_spec(), [option()]) -> [option()]. -add_option_no_arg({Name, _Short, _Long, ArgSpec, _Help}, OptAcc) -> +%% @doc Add an option with argument converting it to the data type indicated by the +%% argument specification. +-spec add_option_with_arg(option_spec(), string(), [option()]) -> [option()]. +add_option_with_arg({Name, _Short, _Long, ArgSpec, _Help} = OptSpec, Arg, OptAcc) -> + case is_valid_arg(ArgSpec, Arg) of + true -> + try + [{Name, to_type(ArgSpec, Arg)} | OptAcc] + catch + error:_ -> + throw({error, {invalid_option_arg, {Name, Arg}}}) + end; + false -> + add_option_with_implicit_arg(OptSpec, OptAcc) + end. + + +%% @doc Add an option with argument that was part of an assignment expression +%% (e.g. "--verbose=3") converting it to the data type indicated by the +%% argument specification. +-spec add_option_with_assigned_arg(option_spec(), string(), [option()]) -> [option()]. +add_option_with_assigned_arg({Name, _Short, _Long, ArgSpec, _Help}, Arg, OptAcc) -> + try + [{Name, to_type(ArgSpec, Arg)} | OptAcc] + catch + error:_ -> + throw({error, {invalid_option_arg, {Name, Arg}}}) + end. + + +%% @doc Add an option that required an argument but did not have one. Some data +%% types (boolean, integer) allow implicit or assumed arguments. +-spec add_option_with_implicit_arg(option_spec(), [option()]) -> [option()]. +add_option_with_implicit_arg({Name, _Short, _Long, ArgSpec, _Help}, OptAcc) -> + case arg_spec_type(ArgSpec) of + boolean -> + %% Special case for boolean arguments: if there is no argument we + %% set the value to 'true'. + [{Name, true} | OptAcc]; + integer -> + %% Special case for integer arguments: if the option had not been set + %% before we set the value to 1. This is needed to support options like + %% "-v" to return something like {verbose, 1}. + [{Name, 1} | OptAcc]; + _ -> + throw({error, {missing_option_arg, Name}}) + end. + + +%% @doc Add an option with an implicit or assumed argument. +-spec add_option_with_implicit_incrementable_arg(option_spec() | arg_spec(), [option()]) -> [option()]. +add_option_with_implicit_incrementable_arg({Name, _Short, _Long, ArgSpec, _Help}, OptAcc) -> case arg_spec_type(ArgSpec) of boolean -> %% Special case for boolean arguments: if there is no argument we @@ -278,10 +347,10 @@ add_option_no_arg({Name, _Short, _Long, ArgSpec, _Help}, OptAcc) -> %% before we set the value to 1; if not we increment the previous value %% the option had. This is needed to support options like "-vvv" to %% return something like {verbose, 3}. - case lists:keyfind(Name, 1, OptAcc) of - {Name, Count} -> - lists:keyreplace(Name, 1, OptAcc, {Name, Count + 1}); - false -> + case OptAcc of + [{Name, Count} | Tail] -> + [{Name, Count + 1} | Tail]; + _ -> [{Name, 1} | OptAcc] end; _ -> @@ -289,54 +358,6 @@ add_option_no_arg({Name, _Short, _Long, ArgSpec, _Help}, OptAcc) -> end. -%% @doc Add an option with argument converting it to the data type indicated by the -%% argument specification. --spec add_option_arg(option_spec(), string(), [option()]) -> [option()]. -add_option_arg({Name, _Short, _Long, ArgSpec, _Help} = OptSpec, Arg, OptAcc) -> - case is_valid_arg(ArgSpec, Arg) of - true -> - try - add_arg(OptSpec, to_type(arg_spec_type(ArgSpec), Arg), OptAcc) - catch - error:_ -> - throw({error, {invalid_option_arg, {Name, Arg}}}) - end; - false -> - add_option_no_arg(OptSpec, OptAcc) - end. - - -%% @doc Add an option with argument that was part of an assignment expression -%% (e.g. "--verbose=3") converting it to the data type indicated by the -%% argument specification. --spec add_option_assigned_arg(option_spec(), string(), [option()]) -> [option()]. -add_option_assigned_arg({Name, _Short, _Long, ArgSpec, _Help} = OptSpec, Arg, OptAcc) -> - case is_valid_assigned_arg(ArgSpec, Arg) of - true -> - try - add_arg(OptSpec, to_type(arg_spec_type(ArgSpec), Arg), OptAcc) - catch - error:_ -> - throw({error, {invalid_option_arg, {Name, Arg}}}) - end; - false -> - add_option_no_arg(OptSpec, OptAcc) - end. - - -%% @doc Add an option with an argument and convert it to the data type corresponding -%% to the argument specification. --spec add_arg(option_spec(), arg_value(), [option()]) -> [option()]. -add_arg({Name, _Short, _Long, _ArgSpec, _Help}, Arg, OptAcc) -> -%% case arg_spec_type(ArgSpec) of -%% integer -> -%% [{Name, Arg} | lists:keydelete(Name, 1, OptAcc)]; -%% _ -> -%% [{Name, Arg} | OptAcc] -%% end. - [{Name, Arg} | OptAcc]. - - %% @doc Retrieve the data type form an argument specification. -spec arg_spec_type(arg_spec()) -> arg_type() | undefined. arg_spec_type({Type, _DefaultArg}) -> @@ -346,7 +367,9 @@ arg_spec_type(Type) when is_atom(Type) -> %% @doc Convert an argument string to its corresponding data type. --spec to_type(arg_type(), string()) -> arg_value(). +-spec to_type(arg_spec() | arg_type(), string()) -> arg_value(). +to_type({Type, _DefaultArg}, Arg) -> + to_type(Type, Arg); to_type(binary, Arg) -> list_to_binary(Arg); to_type(atom, Arg) -> @@ -401,19 +424,6 @@ is_valid_arg(_Type, _Arg) -> true. --spec is_valid_assigned_arg(arg_spec(), nonempty_string()) -> boolean(). -is_valid_assigned_arg({Type, _DefaultArg}, Arg) -> - is_valid_assigned_arg(Type, Arg); -is_valid_assigned_arg(boolean, Arg) -> - is_boolean_arg(Arg); -is_valid_assigned_arg(integer, Arg) -> - is_integer_arg(Arg); -is_valid_assigned_arg(float, Arg) -> - is_float_arg(Arg); -is_valid_assigned_arg(_Type, _Arg) -> - true. - - -spec is_implicit_arg(arg_spec(), nonempty_string()) -> boolean(). is_implicit_arg({Type, _DefaultArg}, Arg) -> is_implicit_arg(Type, Arg); @@ -447,13 +457,6 @@ is_non_neg_integer_arg([]) -> true. --spec is_float_arg(string()) -> boolean(). -is_float_arg([$- | Tail]) -> - is_non_neg_float_arg(Tail); -is_float_arg(Arg) -> - is_non_neg_float_arg(Arg). - - -spec is_non_neg_float_arg(string()) -> boolean(). is_non_neg_float_arg([Head | Tail]) when (Head >= $0 andalso Head =< $9) orelse Head =:= $. -> is_non_neg_float_arg(Tail); @@ -524,10 +527,10 @@ usage_cmd_line([{Name, Short, Long, ArgSpec, _Help} | Tail], Acc) -> case ArgSpec of undefined -> if - % For options with short form and no argument. + %% For options with short form and no argument. Short =/= undefined -> [$\s, $[, $-, Short, $]]; - % For options with only long form and no argument. + %% For options with only long form and no argument. Long =/= undefined -> [$\s, $[, $-, $-, Long, $]]; true -> @@ -535,13 +538,13 @@ usage_cmd_line([{Name, Short, Long, ArgSpec, _Help} | Tail], Acc) -> end; _ -> if - % For options with short form and argument. + %% For options with short form and argument. Short =/= undefined -> [$\s, $[, $-, Short, $\s, $<, atom_to_list(Name), $>, $]]; - % For options with only long form and argument. + %% For options with only long form and argument. Long =/= undefined -> [$\s, $[, $-, $-, Long, $\s, $<, atom_to_list(Name), $>, $]]; - % For options with neither short nor long form and argument. + %% For options with neither short nor long form and argument. true -> [$\s, $<, atom_to_list(Name), $>] end @@ -562,19 +565,19 @@ usage_options_reverse([{Name, Short, Long, _ArgSpec, Help} | Tail], Acc) -> case Long of undefined -> case Short of - % Neither short nor long form (non-option argument). + %% Neither short nor long form (non-option argument). undefined -> [$<, atom_to_list(Name), $>]; - % Only short form. + %% Only short form. _ -> [$-, Short] end; _ -> case Short of - % Only long form. + %% Only long form. undefined -> [$-, $- | Long]; - % Both short and long form. + %% Both short and long form. _ -> [$-, Short, $,, $\s, $-, $- | Long] end diff --git a/test/getopt_test.erl b/test/getopt_test.erl index 394ad48..fa1b67d 100644 --- a/test/getopt_test.erl +++ b/test/getopt_test.erl @@ -223,10 +223,13 @@ parse_2_test_() -> OptSpecList = [ {define, $D, "define", string, "Define a variable"}, - {verbose, $v, "verbose", integer, "Verbosity level"} + {debug, $d, "debug", integer, "Debug level"}, + {offset, $o, "offset", float, "Offset"}, + {verbose, $v, "verbose", boolean, "Enable verbose output"} ], [ {"Multiple repetitions of the same option", - ?_assertEqual({ok, {[{define, "FOO"}, {define, "VAR1=VAL1"}, {define, "BAR"}, {verbose, 3}], ["dummy1", "dummy2"]}}, - parse(OptSpecList, ["-DFOO", "-DVAR1=VAL1", "-DBAR", "-vv", "-v", "dummy1", "dummy2"]))} + ?_assertEqual({ok, {[{define, "FOO"}, {define, "VAR1=VAL1"}, {define, "BAR"}, + {verbose, true}, {verbose, true}, {debug, 2}, {offset, -61.0}, {debug, 1}, {debug, 4}], ["dummy1", "dummy2"]}}, + parse(OptSpecList, "-DFOO -DVAR1=VAL1 -DBAR -vv -dd --offset=-61.0 --debug -dddd dummy1 dummy2"))} ].