Kolab Groupware OBS

erlang-getopt.spec Changed

debian.changelog Changed

erlang-getopt.dsc Changed

getopt-0.8.2.tar.gz/rebar Deleted

getopt-0.8.2.tar.gz/Makefile -> getopt-1.0.1.tar.gz/Makefile Changed

getopt-0.8.2.tar.gz/README.md -> getopt-1.0.1.tar.gz/README.md Changed

@@ -8,40 +8,37 @@
 ------------
 
 You should only need a somewhat recent version of Erlang/OTP. The module has
-been tested with Erlang R13B, R14B, R15B and R16B.
-
-You also need a recent version of rebar(http://github.com/basho/rebar) in
-the system path. If you're going to run the unit tests you need the latest
-version of rebar to make sure that the latest version of *getopt* is being
-used. rebar already includes a compiled copy of the ``getopt`` module in its
-own binary file and will give precedence to its own modules over the ones in
-the project.
+been tested with all versions of Erlang starting with R13B and ending with 20.
 
+You also need a recent version of rebar3(http://www.rebar3.org/) in
+the system path.
 
 Installation
 ------------
 
-To compile the module you simply run ``make``.
-
-To run the unit tests run ``make test``.
-
-To run the example module run ``make example``.
+To compile the module you simply run `rebar3 compile`.
 
-To build the (very) limited documentation run ``make doc``.
+To run the unit tests run `rebar3 eunit`.
 
-After the module is compiled with ``make``, insert getopt into the Erlang lib directory (e.g. by soft link or copying).
+To build the (very) limited documentation run `rebar edoc`.
 
+To use getopt in your project you can just add it as a dependency in your
+`rebar.config` file in the following way:
 ```sh
-ln -s . /usr/local/lib/erlang/lib/getopt-0.8.2
+{deps,
+ 
+  {getopt, "1.0.1"}
+ 
+}
 ```
 
 
 Usage
 -----
 
-The *getopt* module provides four functions:
+The `getopt` module provides four functions:
 
-``` erlang
+```erlang
 parse({Name, Short, Long, ArgSpec, Help}, Args :: string() | string()) ->
     {ok, {Options, NonOptionArgs}} | {error, {Reason, Data}}
 
@@ -56,10 +53,10 @@
       CmdLineTail :: string(), OptionsTail :: {string(), string}) -> ok
 ```
 
-The ``parse/2`` function receives a list of tuples with the command line option
+The `parse/2` function receives a list of tuples with the command line option
 specifications. The type specification for the tuple is:
 
-``` erlang
+```erlang
 -type arg_type() :: 'atom' | 'binary' | 'boolean' | 'float' | 'integer' | 'string'.
 
 -type arg_value() :: atom() | binary() | boolean() | float() | integer() | string().
@@ -77,33 +74,33 @@
 
 The elements of the tuple are:
 
-  - ``Name``: name of the option.
-  - ``Short``: character for the short option (e.g. $i for -i).
-  - ``Long``: string for the long option (e.g. "info" for --info).
-  - ``ArgSpec``: data type and optional default value the argument will be converted to.
-  - ``Help``: help message that is shown for the option when ``usage/2`` is called.
+  - `Name`: name of the option.
+  - `Short`: character for the short option (e.g. $i for -i).
+  - `Long`: string for the long option (e.g. "info" for --info).
+  - `ArgSpec`: data type and optional default value the argument will be converted to.
+  - `Help`: help message that is shown for the option when `usage/2` is called.
 
 e.g.
 
-``` erlang
+```erlang
 {port, $p, "port", {integer, 5432}, "Database server port"}
 ```
 
-The second parameter receives the list of arguments as passed to the ``main/1``
+The second parameter receives the list of arguments as passed to the `main/1`
 function in escripts or the unparsed command line as a string.
 
 If the function is successful parsing the command line arguments it will return
 a tuple containing the parsed options and the non-option arguments. The options
-will be represented by a list of key-value pairs with the ``Name`` of the
+will be represented by a list of key-value pairs with the `Name` of the
 option as *key* and the argument from the command line as *value*. If the option
-doesn't have an argument, only the atom corresponding to its ``Name`` will be
+doesn't have an argument, only the atom corresponding to its `Name` will be
 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
+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. Given the following option specifications:
 
-``` erlang
+```erlang
 OptSpecList =
     
      {host,    $h,        "host",    {string, "localhost"}, "Database server host"},
@@ -117,25 +114,25 @@
 
 And this command line:
 
-``` erlang
+```erlang
 Args = "-h myhost --port=1000 -x myfile.txt -vvv dummy1 dummy2"
 ```
 
-Which could also be passed in the format the ``main/1`` function receives the arguments in escripts:
+Which could also be passed in the format the `main/1` function receives the arguments in escripts:
 
-``` erlang
+```erlang
 Args = "-h", "myhost", "--port=1000", "-x", "file.txt", "-vvv", "dummy1", "dummy2".
 ```
 
-The call to ``getopt:parse/2``:
+The call to `getopt:parse/2`:
 
-``` erlang
+```erlang
 getopt:parse(OptSpecList, Args).
 ```
 
 Will return:
 
-``` erlang
+```erlang
 {ok,{{host,"myhost"},
       {port,1000},
       xml,
@@ -145,27 +142,27 @@
      "dummy1","dummy2"}}
 ```
 
-The ``tokenize/1`` function will separate a command line string into
+The `tokenize/1` function will separate a command line string into
 tokens, taking into account whether an argument is single or double
 quoted, a character is escaped or if there are environment variables to
 be expanded. e.g.:
 
-``` erlang
+```erlang
 getopt:tokenize("  --name John\\ Smith --path \"John's Files\" -u ${USER}").
 ```
 
 Will return something like:
 
-``` erlang
+```erlang
 "--name","John Smith","--path","John's Files","-u","jsmith"
 ```
 
-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.
+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
-``getopt:usage/2``:
+`getopt:usage/2`:
 
-``` erlang
+```erlang
 getopt:usage(OptSpecList, "ex1").
 ```
 
@@ -180,10 +177,10 @@
       -v                            Verbosity level
       <file>                        Output file
 
-This call to ``getopt:usage/3`` will add a string after the usage command line:
+This call to `getopt:usage/3` will add a string after the usage command line:
 
-``` erlang
-    getopt:usage(OptSpecList, "ex1", "var=value ... command ...").
+```erlang
+getopt:usage(OptSpecList, "ex1", "var=value ... command ...").
 ```
 
 Will show (on *standard_error*):
@@ -197,10 +194,10 @@
       -v, --verbose         Verbosity level
       <file>                Output file
 
-Whereas this call to ``getopt:usage/3`` will also add some lines to the options

getopt-0.8.2.tar.gz/rebar.config -> getopt-1.0.1.tar.gz/rebar.config Changed

getopt-1.0.1.tar.gz/rebar.lock Added

getopt-0.8.2.tar.gz/src/getopt.app.src -> getopt-1.0.1.tar.gz/src/getopt.app.src Changed

getopt-0.8.2.tar.gz/src/getopt.erl -> getopt-1.0.1.tar.gz/src/getopt.erl Changed

@@ -1,6 +1,6 @@
 %%%-------------------------------------------------------------------
 %%% @author Juan Jose Comellas <juanjo@comellas.org>
-%%% @copyright (C) 2009 Juan Jose Comellas
+%%% @copyright (C) 2009-2017 Juan Jose Comellas
 %%% @doc Parses command line options with a format similar to that of GNU getopt.
 %%% @end
 %%%
@@ -12,7 +12,7 @@
 -author('juanjo@comellas.org').
 
 -export(parse/2, check/2, parse_and_check/2, format_error/2,
-         usage/2, usage/3, usage/4, tokenize/1).
+         usage/2, usage/3, usage/4, usage/6, tokenize/1).
 -export(usage_cmd_line/2).
 
 -define(LINE_LENGTH, 75).
@@ -149,8 +149,13 @@
 format_error(OptSpecList, {error, Reason}) ->
     format_error(OptSpecList, Reason);
 format_error(OptSpecList, {missing_required_option, Name}) ->
-    {_Name, Short, Long, _Type, _Help} = lists:keyfind(Name, 1, OptSpecList),
-    lists:flatten("missing required option: -", Short, " (", to_string(Long), ")");
+    OptStr = case lists:keyfind(Name, 1, OptSpecList) of
+                 {Name,  undefined, undefined, _Type, _Help} -> "<", to_string(Name), ">";
+                 {_Name, undefined,      Long, _Type, _Help} -> "--", Long;
+                 {_Name,     Short, undefined, _Type, _Help} -> "-", Short;
+                 {_Name,     Short,      Long, _Type, _Help} -> "-", Short, " (", Long, ")"
+             end,
+    lists:flatten("missing required option: ", OptStr);
 format_error(_OptSpecList, {invalid_option, OptStr}) ->
     lists:flatten("invalid option: ", to_string(OptStr));
 format_error(_OptSpecList, {invalid_option_arg, {Name, Arg}}) ->
@@ -437,7 +442,7 @@
 to_type(float, Arg) ->
     list_to_float(Arg);
 to_type(boolean, Arg) ->
-    LowerArg = string:to_lower(Arg),
+    LowerArg = lowercase(Arg),
     case is_arg_true(LowerArg) of
         true ->
             true;
@@ -495,7 +500,7 @@
 
 -spec is_boolean_arg(string()) -> boolean().
 is_boolean_arg(Arg) ->
-    LowerArg = string:to_lower(Arg),
+    LowerArg = lowercase(Arg),
     is_arg_true(LowerArg) orelse is_arg_false(LowerArg).
 
 
@@ -535,8 +540,8 @@
 %%       arguments that are supported by the program.
 -spec usage(option_spec(), string(), output_stream() | string()) -> ok.
 usage(OptSpecList, ProgramName, OutputStream) when is_atom(OutputStream) ->
-    io:format(OutputStream, "~s~n~n~s~n",
-              usage_cmd_line(ProgramName, OptSpecList), usage_options(OptSpecList));
+    io:format(OutputStream, "~ts~n~n~ts~n",
+              unicode:characters_to_list(usage_cmd_line(ProgramName, OptSpecList)), unicode:characters_to_list(usage_options(OptSpecList)));
 %% @doc  Show a message on standard_error indicating the command line options and
 %%       arguments that are supported by the program. The CmdLineTail argument
 %%       is a string that is added to the end of the usage command line.
@@ -549,8 +554,8 @@
 %%       is a string that is added to the end of the usage command line.
 -spec usage(option_spec(), ProgramName :: string(), CmdLineTail :: string(), output_stream() | {string(), string()}) -> ok.
 usage(OptSpecList, ProgramName, CmdLineTail, OutputStream) when is_atom(OutputStream) ->
-    io:format(OutputStream, "~s~n~n~s~n",
-              usage_cmd_line(ProgramName, OptSpecList, CmdLineTail), usage_options(OptSpecList));
+    io:format(OutputStream, "~ts~n~n~ts~n",
+              unicode:characters_to_list(usage_cmd_line(ProgramName, OptSpecList, CmdLineTail)), unicode:characters_to_list(usage_options(OptSpecList)));
 %% @doc  Show a message on standard_error indicating the command line options and
 %%       arguments that are supported by the program. The CmdLineTail and OptionsTail
 %%       arguments are a string that is added to the end of the usage command line
@@ -566,8 +571,24 @@
 -spec usage(option_spec(), ProgramName :: string(), CmdLineTail :: string(),
             {OptionName :: string(), Help :: string()}, output_stream()) -> ok.
 usage(OptSpecList, ProgramName, CmdLineTail, OptionsTail, OutputStream) ->
-    io:format(OutputStream, "~s~n~n~s~n",
-              usage_cmd_line(ProgramName, OptSpecList, CmdLineTail), usage_options(OptSpecList, OptionsTail)).
+    io:format(OutputStream, "~ts~n~n~ts~n",
+              unicode:characters_to_list(usage_cmd_line(ProgramName, OptSpecList, CmdLineTail)), unicode:characters_to_list(usage_options(OptSpecList, OptionsTail))).
+
+%% @doc Show a message on standard_error or standard_io indicating the
+%%      command line options and arguments that are supported by the
+%%      program. The Description allows for structured command line usage
+%%      that works in addition to the standard options, and appears between
+%%      the usage_cmd_line and usage_options sections.  The CmdLineTail and
+%%      OptionsTail arguments are a string that is added to the end of the
+%%      usage command line and a list of tuples that are added to the end of
+%%      the options' help lines.
+-spec usage(option_spec(), ProgramName :: string(), CmdLineTail :: string(),
+            Description :: string(),
+            {OptionName :: string(), Help :: string()},
+            output_stream()) -> ok.
+usage(OptSpecList, ProgramName, CmdLineTail, Description, OptionsTail, OutputStream) ->
+    io:format(OutputStream, "~ts~n~n~ts~n~n~ts~n",
+              unicode:characters_to_list(usage_cmd_line(ProgramName, OptSpecList, CmdLineTail)), Description, unicode:characters_to_list(usage_options(OptSpecList, OptionsTail))).
 
 
 -spec usage_cmd_line(ProgramName :: string(), option_spec()) -> iolist().
@@ -598,7 +619,7 @@
 %%      already wrapped according to the maximum MaxLineLength.
 -spec usage_cmd_line_options(MaxLineLength :: non_neg_integer(), option_spec(), CmdLineTail :: string()) -> iolist().
 usage_cmd_line_options(MaxLineLength, OptSpecList, CmdLineTail) ->
-    usage_cmd_line_options(MaxLineLength, OptSpecList ++ string:tokens(CmdLineTail, " "), , 0, ).
+    usage_cmd_line_options(MaxLineLength, OptSpecList ++ lexemes(CmdLineTail, " "), , 0, ).
 
 usage_cmd_line_options(MaxLineLength, OptSpec | Tail, LineAcc, LineAccLength, Acc) ->
     Option = $\s | lists:flatten(usage_cmd_line_option(OptSpec)),
@@ -769,7 +790,7 @@
     %% Look for the first whitespace character in the current (reversed) line
     %% buffer to get a wrapped line. If there is no whitespace just cut the
     %% line at the position corresponding to the maximum length.
-    {NextLineAcc, WrappedLine} = case string:cspan(CurrentLineAcc, " \t") of
+    {NextLineAcc, WrappedLine} = case cspan(CurrentLineAcc, " \t") of
                                      WhitespacePos when WhitespacePos < Count ->
                                          lists:split(WhitespacePos, CurrentLineAcc);
                                      _ ->
@@ -912,3 +933,15 @@
     atom_to_list(Atom);
 to_string(Value) ->
     io_lib:format("~p", Value).
+
+%% OTP-20/21 conversion to unicode string module
+-ifdef(unicode_str).
+lowercase(Str) -> string:lowercase(Str).
+lexemes(Str, Separators) -> string:lexemes(Str, Separators).
+cspan(Str, Chars) -> length(element(1,string:take(Str, Chars, true))).
+-else.
+lowercase(Str) -> string:to_lower(Str).
+lexemes(Str, Separators) -> string:tokens(Str, Separators).
+cspan(Str, Chars) -> string:cspan(Str, Chars).
+-endif.
+

getopt-0.8.2.tar.gz/test/getopt_test.erl -> getopt-1.0.1.tar.gz/test/getopt_test.erl Changed

@@ -287,7 +287,10 @@
 check_test_() ->
     OptSpecList =
         
-         {arg,        $a,        "arg",        string,   "Required arg"}
+         {  arg,        $a,     "arg",   string,   "Required arg"},
+         {short,        $s, undefined,   string,   "short option"},
+         { long, undefined,    "long",   string,   "long option"},
+         {other, undefined, undefined,   string,   "task"}
         ,
     {ok, {Opts, _}} = parse(OptSpecList, ""),
     
@@ -301,6 +304,15 @@
      {"Format missing option error test 2",
       ?_assertEqual("missing required option: -a (arg)",
                     format_error(OptSpecList, {missing_required_option, arg}))},
+     {"Format missing option error test 3",
+      ?_assertEqual("missing required option: -s",
+                    format_error(OptSpecList, {missing_required_option, short}))},
+     {"Format missing option error test 4",
+      ?_assertEqual("missing required option: --long",
+                    format_error(OptSpecList, {missing_required_option, long}))},
+     {"Format missing option error test 5",
+      ?_assertEqual("missing required option: <other>",
+                    format_error(OptSpecList, {missing_required_option, other}))},
      {"Format invalid option error test 1",
       ?_assertEqual("invalid option: --verbose",
                     format_error(OptSpecList, {error, {invalid_option, "--verbose"}}))},

Changes of Revision 3