Skip to content
Browse files

Add 'deps/getopt/' from commit '659a28f4145bc9843598972854299dc4ea77e…

…4cb'

git-subtree-dir: deps/getopt
git-subtree-mainline: 2c03aa2
git-subtree-split: 659a28f
  • Loading branch information...
2 parents 2c03aa2 + 659a28f commit cbe1cee82a0d9fbd23c1bcabbee235877fcdb382 Yurii Rashkovskii committed Apr 23, 2012
View
11 deps/getopt/ChangeLog
@@ -0,0 +1,11 @@
+2010-09-23 Juan Jose Comellas <juanjo@comellas.org>
+
+ * Released v0.3.0
+ * Added support for rebar.
+ * Cleaned up dialyzer warnings.
+
+2009-11-16 Juan Jose Comellas <juanjo@comellas.org>
+
+ * Released v0.1.0
+ * Dropped record syntax for the option specifications to simplify use
+ from escripts.
View
3 deps/getopt/Emakefile
@@ -0,0 +1,3 @@
+{"src/*", [debug_info, {outdir, "ebin"}, {i, "include"}]}.
+{"test/*", [debug_info, {outdir, "ebin"}, {i, "include"}]}.
+{"examples/*", [debug_info, {outdir, "ebin"}, {i, "include"}]}.
View
27 deps/getopt/LICENSE.txt
@@ -0,0 +1,27 @@
+Copyright (c) 2009 Juan Jose Comellas
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+ - Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+
+ - Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+ - Neither the name of Juan Jose Comellas nor the names of its contributors may
+ be used to endorse or promote products derived from this software without
+ specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
View
45 deps/getopt/Makefile
@@ -0,0 +1,45 @@
+APPLICATION := getopt
+
+ERL := erl
+EPATH := -pa ebin
+TEST_EPATH := -pa .eunit
+
+DIALYZER=dialyzer
+DIALYZER_OPTS=-Wno_return -Wrace_conditions -Wunderspecs -Wbehaviours
+PLT_FILE=.getopt_plt
+APPS=kernel stdlib
+
+.PHONY: all clean test
+
+all: compile
+
+compile:
+ @rebar compile
+
+doc:
+ @rebar doc
+
+plt: compile
+ @$(DIALYZER) --build_plt --output_plt $(PLT_FILE) --apps $(APPS) ebin
+
+check_plt: compile
+ @$(DIALYZER) --check_plt --plt $(PLT_FILE) --apps $(APPS) ebin
+
+analyze: compile
+ @$(DIALYZER) --plt $(PLT_FILE) $(DIALYZER_OPTS) -r ebin
+
+clean:
+ @rebar clean
+
+test:
+ @rebar eunit
+
+dialyzer:
+ @rebar analyze
+
+console: compile
+ $(ERL) -sname $(APPLICATION) $(EPATH)
+
+testshell: test
+ $(ERL) -sname $(APPLICATION)_test $(TEST_EPATH)
+
View
353 deps/getopt/README.md
@@ -0,0 +1,353 @@
+Getopt for Erlang
+=================
+
+Command-line parsing module that uses a syntax similar to that of GNU *getopt*.
+
+
+Requirements
+------------
+
+You should only need a somewhat recent version of Erlang/OTP. The module has
+been tested with Erlang R13B, R14B and R15B.
+
+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.
+
+
+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 build the (very) limited documentation run ``make doc``.
+
+
+Usage
+-----
+
+The *getopt* module provides four functions:
+
+``` erlang
+ parse([{Name, Short, Long, ArgSpec, Help}], Args :: string() | [string()]) ->
+ {ok, {Options, NonOptionArgs}} | {error, {Reason, Data}}
+
+ usage([{Name, Short, Long, ArgSpec, Help}], ProgramName :: string()) -> ok
+
+ usage([{Name, Short, Long, ArgSpec, Help}], ProgramName :: string(),
+ CmdLineTail :: string()) -> ok
+
+ usage([{Name, Short, Long, ArgSpec, Help}], ProgramName :: string(),
+ CmdLineTail :: string(), OptionsTail :: [{string(), string}]) -> ok
+```
+
+The ``parse/2`` function receives a list of tuples with the command line option
+specifications. The type specification for the tuple is:
+
+``` erlang
+ -type arg_type() :: 'atom' | 'binary' | 'boolean' | 'float' | 'integer' | 'string'.
+
+ -type arg_value() :: atom() | binary() | boolean() | float() | integer() | string().
+
+ -type arg_spec() :: arg_type() | {arg_type(), arg_value()} | undefined.
+
+ -type option_spec() :: {
+ Name :: atom(),
+ Short :: char() | undefined,
+ Long :: string() | undefined,
+ ArgSpec :: arg_spec(),
+ Help :: string() | undefined
+ }.
+```
+
+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.
+
+e.g.
+
+``` erlang
+ {port, $p, "port", {integer, 5432}, "Database server port"}
+```
+
+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
+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
+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. Given the following option specifications:
+
+``` erlang
+ OptSpecList =
+ [
+ {host, $h, "host", {string, "localhost"}, "Database server host"},
+ {port, $p, "port", integer, "Database server port"},
+ {dbname, undefined, "dbname", {string, "users"}, "Database name"},
+ {xml, $x, undefined, undefined, "Output data in XML"},
+ {verbose, $v, "verbose", integer, "Verbosity level"},
+ {file, undefined, undefined, string, "Output file"}
+ ].
+```
+
+And this command line:
+
+``` 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:
+
+``` erlang
+ Args = ["-h", "myhost", "--port=1000", "-x", "file.txt", "-vvv", "dummy1", "dummy2"].
+```
+
+The call to ``getopt:parse/2``:
+
+``` erlang
+ getopt:parse(OptSpecList, Args).
+```
+
+Will return:
+
+``` erlang
+ {ok,{[{host,"myhost"},
+ {port,1000},
+ xml,
+ {file,"file.txt"},
+ {dbname,"users"},
+ {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
+``getopt:usage/2``:
+
+``` erlang
+ getopt:usage(OptSpecList, "ex1").
+```
+
+Will show (on *standard_error*):
+
+ Usage: ex1 [-h <host>] [-p <port>] [--dbname <dbname>] [-x] [-v] <file>
+
+ -h, --host Database server host
+ -p, --port Database server port
+ --dbname Database name
+ -x Output data in XML
+ -v Verbosity level
+ <file> Output file
+
+This call to ``getopt:usage/3`` will add a string after the usage command line:
+
+ getopt:usage(OptSpecList, "ex1", "[var=value ...] [command ...]").
+
+Will show (on *standard_error*):
+
+ Usage: ex1 [-h <host>] [-p <port>] [--dbname <dbname>] [-x] [-v <verbose>] <file> [var=value ...] [command ...]
+
+ -h, --host Database server host
+ -p, --port Database server port
+ --dbname Database name
+ -x Output data in XML
+ -v, --verbose Verbosity level
+ <file> Output file
+
+Whereas this call to ``getopt:usage/3`` will also add some lines to the options
+help text:
+
+``` erlang
+ getopt:usage(OptSpecList, "ex1", "[var=value ...] [command ...]",
+ [{"var=value", "Variables that will affect the execution (e.g. debug=1)"},
+ {"command", "Commands that will be executed (e.g. count)"}]).
+```
+
+Will show (on *standard_error*):
+
+ Usage: ex1 [-h <host>] [-p <port>] [--dbname <dbname>] [-x] [-v <verbose>] <file> [var=value ...] [command ...]
+
+ -h, --host Database server host
+ -p, --port Database server port
+ --dbname Database name
+ -x Output data in XML
+ -v, --verbose Verbosity level
+ <file> Output file
+ var=value Variables that will affect the execution (e.g. debug=1)
+ command Commands that will be executed (e.g. count)
+
+
+Command-line Syntax
+-------------------
+
+The syntax supported by the ``getopt`` module is very similar to that followed
+by GNU programs, which is described [here](http://www.gnu.org/s/libc/manual/html_node/Argument-Syntax.html).
+
+Options can have both short (single character) and long (string) option names.
+
+A short option can have the following syntax:
+
+ -a Single option 'a', no argument or implicit boolean argument
+ -a foo Single option 'a', argument "foo"
+ -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'
+
+A long option can have the following syntax:
+
+ --foo Single option 'foo', no argument
+ --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 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:
+
+``` erlang
+ OptSpecList =
+ [
+ {define, $D, "define", string, "Define a variable"},
+ {verbose, $v, "verbose", integer, "Verbosity level"}
+ ].
+```
+
+The following invocation:
+
+``` erlang
+ getopt:parse(OptSpecList, "-DFOO -DVAR1=VAL1 -DBAR --verbose --verbose=3 -v -vvvv dummy").
+```
+
+would return:
+
+``` erlang
+ {ok,{[{define,"FOO"}, {define,"VAR1=VAL1"}, {define,"BAR"},
+ {verbose,1}, {verbose,3}, {verbose,1}, {verbose,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``.
+
+For example, with the following option specifications:
+
+``` erlang
+ OptSpecList =
+ [
+ {xml, $x, "xml", undefined, "Output data as XML"},
+ {dbname, undefined, undefined, string, "Database name"},
+ {output_file, undefined, undefined, string, "File where the data will be saved to"}
+ ].
+```
+
+This call to ``getopt:parse/2``:
+
+``` erlang
+ getopt:parse(OptSpecList, "-x mydb file.out dummy dummy").
+```
+
+Will return:
+
+``` erlang
+ {ok,{[xml,{dbname,"mydb"},{output_file,"file.out"}],
+ ["dummy","dummy"]}}
+```
+
+
+Option Terminators
+------------------
+
+The string ``--`` is considered an option terminator. This means that all the
+command-line arguments after it are considered non-option arguments and will be
+returned without being evaluated even if they follow the *getopt* syntax.
+
+e.g. This invocation using the first option specification list in the document:
+
+``` erlang
+ getopt:parse(OptSpecList, "-h myhost -p 1000 -- --dbname mydb dummy").
+```
+
+will return:
+
+``` erlang
+ {ok,{[{host,"myhost"}, {port,1000},{dbname,"users"}],
+ ["--dbname","mydb","dummy"]}}
+```
+
+Notice that the *dbname* option was assigned the value ``users`` instead of ``mydb``.
+This happens because the option terminator prevented *getopt* from evaluating it
+and the default value was assigned to it.
+
+
+Non-option Arguments
+--------------------
+
+The single ``-`` character is always considered as a non-option argument.
+
+e.g. This invocation using the specification list from the previous example:
+
+``` erlang
+ getopt:parse(OptSpecList, "-h myhost -p 1000 - --dbname mydb dummy").
+```
+
+will return:
+
+``` erlang
+ {ok,{[{host,"myhost"}, {port,1000}, {dbname,"mydb"}],
+ ["-","dummy"]}}
+```
View
2 deps/getopt/TODO
@@ -0,0 +1,2 @@
+* Add support for non-option arguments where the first character is '-'.
+ e.g. For "test -a -- -b" "-b" should be interpreted as a non option argument.
View
1 deps/getopt/doc/.gitignore
@@ -0,0 +1 @@
+*
View
1 deps/getopt/ebin/.gitignore
@@ -0,0 +1 @@
+*.beam
View
47 deps/getopt/examples/ex1.erl
@@ -0,0 +1,47 @@
+%%%-------------------------------------------------------------------
+%%% @author Juan Jose Comellas <juanjo@comellas.org>
+%%% @copyright (C) 2009 Juan Jose Comellas
+%%% @doc Example file for the getopt module.
+%%% @end
+%%%
+%%% This source file is subject to the New BSD License. You should have received
+%%% a copy of the New BSD license with this software. If not, it can be
+%%% retrieved from: http://www.opensource.org/licenses/bsd-license.php
+%%%-------------------------------------------------------------------
+-module(ex1).
+-author('juanjo@comellas.org').
+
+-export([test/0, test/1]).
+
+test() ->
+ test("-U myuser -P mypassword --host myhost -x -o myfile.dump mydb dummy1").
+
+
+test(CmdLine) ->
+ OptSpecList = option_spec_list(),
+
+ io:format("For command line: ~p~n"
+ "getopt:parse/2 returns:~n~n", [CmdLine]),
+ case getopt:parse(OptSpecList, CmdLine) of
+ {ok, {Options, NonOptArgs}} ->
+ io:format("Options:~n ~p~n~nNon-option arguments:~n ~p~n", [Options, NonOptArgs]);
+ {error, {Reason, Data}} ->
+ io:format("Error: ~s ~p~n~n", [Reason, Data]),
+ getopt:usage(OptSpecList, "ex1")
+ end.
+
+
+option_spec_list() ->
+ CurrentUser = os:getenv("USER"),
+ [
+ %% {Name, ShortOpt, LongOpt, ArgSpec, HelpMsg}
+ {help, $?, "help", undefined, "Show the program options"},
+ {username, $U, "username", string, "Username to connect to the database"},
+ {password, $P, "password", {string, CurrentUser}, "Password to connect to the database"},
+ {host, $h, "host", {string, "localhost"}, "Database server host name or IP address"},
+ {port, $p, "port", {integer, 1000}, "Database server port"},
+ {output_file, $o, "output-file", string, "File where the data will be saved to"},
+ {xml, $x, "xml", undefined, "Output data as XML"},
+ {verbose, $v, "verbose", integer, "Verbosity level"},
+ {dbname, undefined, undefined, string, "Database name"}
+ ].
View
51 deps/getopt/examples/ex1.escript
@@ -0,0 +1,51 @@
+#!/usr/bin/env escript
+%% -*- erlang -*-
+%%! -sname ex1 -pz ebin
+
+%%%-------------------------------------------------------------------
+%%% @author Juan Jose Comellas <juanjo@comellas.org>
+%%% @copyright (C) 2009 Juan Jose Comellas
+%%% @doc Example file for the getopt module.
+%%% @end
+%%%
+%%% This source file is subject to the New BSD License. You should have received
+%%% a copy of the New BSD license with this software. If not, it can be
+%%% retrieved from: http://www.opensource.org/licenses/bsd-license.php
+%%%-------------------------------------------------------------------
+-module(ex1).
+-author('juanjo@comellas.org').
+
+main([]) ->
+ getopt:usage(option_spec_list(), escript:script_name());
+main(Args) ->
+ OptSpecList = option_spec_list(),
+ io:format("For command line: ~p~n"
+ "getopt:parse/2 returns:~n~n", [Args]),
+ case getopt:parse(OptSpecList, Args) of
+ {ok, {Options, NonOptArgs}} ->
+ io:format("Options:~n ~p~n~nNon-option arguments:~n ~p~n", [Options, NonOptArgs]);
+ {error, {Reason, Data}} ->
+ io:format("Error: ~s ~p~n~n", [Reason, Data]),
+ getopt:usage(OptSpecList, "ex1.escript")
+ end.
+
+
+option_spec_list() ->
+ CurrentUser = case os:getenv("USER") of
+ false ->
+ "user";
+ User ->
+ User
+ end,
+ [
+ %% {Name, ShortOpt, LongOpt, ArgSpec, HelpMsg}
+ {help, $?, "help", undefined, "Show the program options"},
+ {username, $U, "username", string, "Username to connect to the database"},
+ {password, $P, "password", {string, CurrentUser}, "Password to connect to the database"},
+ {host, $h, "host", {string, "localhost"}, "Database server host name or IP address"},
+ {port, $p, "port", {integer, 1000}, "Database server port"},
+ {output_file, $o, "output-file", string, "File where the data will be saved to"},
+ {xml, $x, "xml", undefined, "Output data as XML"},
+ {verbose, $v, "verbose", integer, "Verbosity level"},
+ {dbname, undefined, undefined, string, "Database name"}
+ ].
View
50 deps/getopt/examples/rebar_test.erl
@@ -0,0 +1,50 @@
+%%%-------------------------------------------------------------------
+%%% @author Juan Jose Comellas <juanjo@comellas.org>
+%%% @copyright (C) 2009 Juan Jose Comellas
+%%% @doc Example file for the getopt module.
+%%% @end
+%%%
+%%% This source file is subject to the New BSD License. You should have received
+%%% a copy of the New BSD license with this software. If not, it can be
+%%% retrieved from: http://www.opensource.org/licenses/bsd-license.php
+%%%-------------------------------------------------------------------
+-module(rebar_test).
+-author('juanjo@comellas.org').
+
+-export([test/0, test/1, usage/0]).
+
+test() ->
+ test("-f verbose=1 --quiet=on -j2 dummy1 dummy2").
+
+
+test(CmdLine) ->
+ OptSpecList = option_spec_list(),
+
+ io:format("For command line: ~p~n"
+ "getopt:parse/2 returns:~n~n", [CmdLine]),
+ case getopt:parse(OptSpecList, CmdLine) of
+ {ok, {Options, NonOptArgs}} ->
+ io:format("Options:~n ~p~n~nNon-option arguments:~n ~p~n", [Options, NonOptArgs]);
+ {error, {Reason, Data}} ->
+ io:format("Error: ~s ~p~n~n", [Reason, Data]),
+ usage(OptSpecList)
+ end.
+
+
+usage() ->
+ usage(option_spec_list()).
+
+usage(OptSpecList) ->
+ getopt:usage(OptSpecList, "rebar_test", "[var1=val1 ...] [command1 ...]",
+ [{"var=value", "Variables that will affect the compilation (e.g. debug=1)"},
+ {"command", "Commands that will be executed by rebar (e.g. compile)"}]).
+
+option_spec_list() ->
+ CpuCount = erlang:system_info(logical_processors),
+ [
+ %% {Name, ShortOpt, LongOpt, ArgSpec, HelpMsg}
+ {help, $h, "help", undefined, "Show the program options"},
+ {jobs, $j, "jobs", {integer, CpuCount}, "Number of concurrent jobs"},
+ {verbose, $v, "verbose", {boolean, false}, "Be verbose about what gets done"},
+ {force, $f, "force", {boolean, false}, "Force"}
+ ].
View
50 deps/getopt/examples/rebar_test.escript
@@ -0,0 +1,50 @@
+#!/usr/bin/env escript
+%% -*- erlang -*-
+%%! -sname ex1 -pz ebin
+
+%%%-------------------------------------------------------------------
+%%% @author Juan Jose Comellas <juanjo@comellas.org>
+%%% @copyright (C) 2009 Juan Jose Comellas
+%%% @doc Example file for the getopt module.
+%%% @end
+%%%
+%%% This source file is subject to the New BSD License. You should have received
+%%% a copy of the New BSD license with this software. If not, it can be
+%%% retrieved from: http://www.opensource.org/licenses/bsd-license.php
+%%%-------------------------------------------------------------------
+-module(rebar_test).
+-author('juanjo@comellas.org').
+
+main([]) ->
+ usage();
+main(Args) ->
+ OptSpecList = option_spec_list(),
+ io:format("For command line: ~p~n"
+ "getopt:parse/2 returns:~n~n", [Args]),
+ case getopt:parse(OptSpecList, Args) of
+ {ok, {Options, NonOptArgs}} ->
+ io:format("Options:~n ~p~n~nNon-option arguments:~n ~p~n", [Options, NonOptArgs]);
+ {error, {Reason, Data}} ->
+ io:format("Error: ~s ~p~n~n", [Reason, Data]),
+ usage(OptSpecList)
+ end.
+
+
+usage() ->
+ usage(option_spec_list()).
+
+usage(OptSpecList) ->
+ getopt:usage(OptSpecList, escript:script_name(), "[var1=val1 ...] [command1 ...]",
+ [{"var=value", "Variables that will affect the compilation (e.g. debug=1)"},
+ {"command", "Commands that will be executed by rebar (e.g. compile)"}]).
+
+
+option_spec_list() ->
+ CpuCount = erlang:system_info(logical_processors),
+ [
+ %% {Name, ShortOpt, LongOpt, ArgSpec, HelpMsg}
+ {help, $h, "help", undefined, "Show the program options"},
+ {jobs, $j, "jobs", {integer, CpuCount}, "Number of concurrent jobs"},
+ {verbose, $v, "verbose", {boolean, false}, "Be verbose about what gets done"},
+ {force, $f, "force", {boolean, false}, "Force"}
+ ].
View
15 deps/getopt/rebar.config
@@ -0,0 +1,15 @@
+{erl_opts, [warn_unused_vars,
+ warn_export_all,
+ warn_shadow_vars,
+ warn_unused_import,
+ warn_unused_function,
+ warn_bif_clash,
+ warn_unused_record,
+ warn_deprecated_function,
+ warn_obsolete_guard,
+ strict_validation,
+ warn_export_vars,
+ warn_exported_vars,
+ warn_missing_spec,
+ warn_untyped_record, debug_info]}.
+{xref_checks, [undefined_function_calls]}.
View
7 deps/getopt/src/getopt.app.src
@@ -0,0 +1,7 @@
+%% -*- mode: Erlang; fill-column: 75; comment-column: 50; -*-
+{application, getopt,
+ [{description, "Command-line options parser for Erlang"},
+ {vsn, "0.4.3"},
+ {modules, []},
+ {registered, []},
+ {applications, [kernel, stdlib]}]}.
View
621 deps/getopt/src/getopt.erl
@@ -0,0 +1,621 @@
+%%%-------------------------------------------------------------------
+%%% @author Juan Jose Comellas <juanjo@comellas.org>
+%%% @copyright (C) 2009 Juan Jose Comellas
+%%% @doc Parses command line options with a format similar to that of GNU getopt.
+%%% @end
+%%%
+%%% This source file is subject to the New BSD License. You should have received
+%%% a copy of the New BSD license with this software. If not, it can be
+%%% retrieved from: http://www.opensource.org/licenses/bsd-license.php
+%%%-------------------------------------------------------------------
+-module(getopt).
+-author('juanjo@comellas.org').
+
+-export([parse/2, usage/2, usage/3, usage/4]).
+
+-export_type([arg_type/0,
+ arg_value/0,
+ arg_spec/0,
+ simple_option/0,
+ compound_option/0,
+ option/0,
+ option_spec/0]).
+
+-define(TAB_LENGTH, 8).
+%% Indentation of the help messages in number of tabs.
+-define(INDENTATION, 3).
+
+%% Position of each field in the option specification tuple.
+-define(OPT_NAME, 1).
+-define(OPT_SHORT, 2).
+-define(OPT_LONG, 3).
+-define(OPT_ARG, 4).
+-define(OPT_HELP, 5).
+
+-define(IS_OPT_SPEC(Opt), (tuple_size(Opt) =:= ?OPT_HELP)).
+
+
+%% Atom indicating the data type that an argument can be converted to.
+-type arg_type() :: 'atom' | 'binary' | 'boolean' | 'float' | 'integer' | 'string'.
+%% Data type that an argument can be converted to.
+-type arg_value() :: atom() | binary() | boolean() | float() | integer() | string().
+%% Argument specification.
+-type arg_spec() :: arg_type() | {arg_type(), arg_value()} | undefined.
+%% Option type and optional default argument.
+-type simple_option() :: atom().
+-type compound_option() :: {atom(), arg_value()}.
+-type option() :: simple_option() | compound_option().
+%% Command line option specification.
+-type option_spec() :: {
+ Name :: atom(),
+ Short :: char() | undefined,
+ Long :: string() | undefined,
+ ArgSpec :: arg_spec(),
+ Help :: string() | undefined
+ }.
+%% Output streams
+-type output_stream() :: 'standard_io' | 'standard_error'.
+
+
+%% @doc Parse the command line options and arguments returning a list of tuples
+%% and/or atoms using the Erlang convention for sending options to a
+%% function.
+-spec parse([option_spec()], string() | [string()]) ->
+ {ok, {[option()], [string()]}} | {error, {Reason :: atom(), Data :: any()}}.
+parse(OptSpecList, CmdLine) ->
+ try
+ Args = if
+ is_integer(hd(CmdLine)) ->
+ string:tokens(CmdLine, " \t\n");
+ true ->
+ CmdLine
+ end,
+ parse(OptSpecList, [], [], 0, Args)
+ catch
+ throw: {error, {_Reason, _Data}} = Error ->
+ Error
+ end.
+
+
+-spec parse([option_spec()], [option()], [string()], integer(), [string()]) ->
+ {ok, {[option()], [string()]}}.
+%% Process the option terminator.
+parse(OptSpecList, OptAcc, ArgAcc, _ArgPos, ["--" | Tail]) ->
+ %% 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_long_option(OptSpecList, OptAcc, ArgAcc, ArgPos, Tail, OptStr, OptArg);
+%% Process short options.
+parse(OptSpecList, OptAcc, ArgAcc, ArgPos, ["-" ++ ([_Char | _] = OptArg) = OptStr | Tail]) ->
+ 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_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.
+ {ok, {lists:reverse(append_default_options(OptSpecList, OptAcc)), lists:reverse(ArgAcc)}}.
+
+
+%% @doc Parse a long option, add it to the option accumulator and continue
+%% parsing the rest of the arguments recursively.
+%% A long option can have the following syntax:
+%% --foo Single option 'foo', no argument
+%% --foo=bar Single option 'foo', argument "bar"
+%% --foo bar Single option 'foo', argument "bar"
+-spec parse_long_option([option_spec()], [option()], [string()], integer(), [string()], string(), string()) ->
+ {ok, {[option()], [string()]}}.
+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_long_option_assigned_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptStr, Long, Arg);
+
+ Long ->
+ case lists:keyfind(Long, ?OPT_LONG, OptSpecList) of
+ {Name, _Short, Long, undefined, _Help} ->
+ 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.
+ %% e.g ["--port", "1000"]
+ parse_long_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptSpec);
+ false ->
+ throw({error, {invalid_option, OptStr}})
+ end
+ end.
+
+
+%% @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_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_with_assigned_arg(OptSpec, Arg, OptAcc), ArgAcc, ArgPos, Args)
+ end;
+ false ->
+ throw({error, {invalid_option, OptStr}})
+ end.
+
+
+%% @doc Split an option string that may contain an option with its argument
+%% separated by an equal ('=') character (e.g. "port=1000").
+-spec split_assigned_arg(string()) -> {Name :: string(), Arg :: string()} | string().
+split_assigned_arg(OptStr) ->
+ split_assigned_arg(OptStr, OptStr, []).
+
+split_assigned_arg(_OptStr, "=" ++ Tail, Acc) ->
+ {lists:reverse(Acc), Tail};
+split_assigned_arg(OptStr, [Char | Tail], Acc) ->
+ split_assigned_arg(OptStr, Tail, [Char | Acc]);
+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:
+%% -a Single option 'a', no argument or implicit boolean argument
+%% -a foo Single option 'a', argument "foo"
+%% -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' (only valid for options with integer arguments)
+-spec parse_short_option([option_spec()], [option()], [string()], integer(), [string()], string(), string()) ->
+ {ok, {[option()], [string()]}}.
+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_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_short_option_next_arg(OptSpecList, OptAcc, ArgAcc, ArgPos, Args, OptSpec, OptPos);
+
+ _ ->
+ case is_valid_arg(ArgSpec, Arg) of
+ true ->
+ parse(OptSpecList, add_option_with_arg(OptSpec, Arg, OptAcc), ArgAcc, ArgPos, Args);
+ _ ->
+ 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_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_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_with_implicit_incrementable_arg(OptSpec, OptAcc), ArgAcc, ArgPos, Args);
+ false ->
+ [Arg | Tail] = Args,
+ try
+ parse(OptSpecList, [{Name, to_type(ArgSpec, Arg)} | OptAcc], ArgAcc, ArgPos, Tail)
+ catch
+ error:_ ->
+ throw({error, {invalid_option_arg, {Name, Arg}}})
+ end
+ end.
+
+
+%% @doc Find the option for the discrete argument in position specified in the
+%% Pos argument.
+-spec find_non_option_arg([option_spec()], integer()) -> {value, option_spec()} | false.
+find_non_option_arg([{_Name, undefined, undefined, _ArgSpec, _Help} = OptSpec | _Tail], 0) ->
+ {value, OptSpec};
+find_non_option_arg([{_Name, undefined, undefined, _ArgSpec, _Help} | Tail], Pos) ->
+ find_non_option_arg(Tail, Pos - 1);
+find_non_option_arg([_Head | Tail], Pos) ->
+ find_non_option_arg(Tail, Pos);
+find_non_option_arg([], _Pos) ->
+ false.
+
+
+%% @doc Append options that were not present in the command line arguments with
+%% their default arguments.
+-spec append_default_options([option_spec()], [option()]) -> [option()].
+append_default_options([{Name, _Short, _Long, {_Type, DefaultArg}, _Help} | Tail], OptAcc) ->
+ append_default_options(Tail,
+ case lists:keymember(Name, 1, OptAcc) of
+ false ->
+ [{Name, DefaultArg} | OptAcc];
+ _ ->
+ OptAcc
+ end);
+%% For options with no default argument.
+append_default_options([_Head | Tail], OptAcc) ->
+ append_default_options(Tail, OptAcc);
+append_default_options([], OptAcc) ->
+ 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
+ %% 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; 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 OptAcc of
+ [{Name, Count} | Tail] ->
+ [{Name, Count + 1} | Tail];
+ _ ->
+ [{Name, 1} | OptAcc]
+ end;
+ _ ->
+ throw({error, {missing_option_arg, Name}})
+ end.
+
+
+%% @doc Retrieve the data type form an argument specification.
+-spec arg_spec_type(arg_spec()) -> arg_type() | undefined.
+arg_spec_type({Type, _DefaultArg}) ->
+ Type;
+arg_spec_type(Type) when is_atom(Type) ->
+ Type.
+
+
+%% @doc Convert an argument string to its corresponding data type.
+-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) ->
+ list_to_atom(Arg);
+to_type(integer, Arg) ->
+ list_to_integer(Arg);
+to_type(float, Arg) ->
+ list_to_float(Arg);
+to_type(boolean, Arg) ->
+ LowerArg = string:to_lower(Arg),
+ case is_arg_true(LowerArg) of
+ true ->
+ true;
+ _ ->
+ case is_arg_false(LowerArg) of
+ true ->
+ false;
+ false ->
+ erlang:error(badarg)
+ end
+ end;
+to_type(_Type, Arg) ->
+ Arg.
+
+
+-spec is_arg_true(string()) -> boolean().
+is_arg_true(Arg) ->
+ (Arg =:= "true") orelse (Arg =:= "t") orelse
+ (Arg =:= "yes") orelse (Arg =:= "y") orelse
+ (Arg =:= "on") orelse (Arg =:= "enabled") orelse
+ (Arg =:= "1").
+
+
+-spec is_arg_false(string()) -> boolean().
+is_arg_false(Arg) ->
+ (Arg =:= "false") orelse (Arg =:= "f") orelse
+ (Arg =:= "no") orelse (Arg =:= "n") orelse
+ (Arg =:= "off") orelse (Arg =:= "disabled") orelse
+ (Arg =:= "0").
+
+
+-spec is_valid_arg(arg_spec(), nonempty_string()) -> boolean().
+is_valid_arg({Type, _DefaultArg}, Arg) ->
+ is_valid_arg(Type, Arg);
+is_valid_arg(boolean, Arg) ->
+ is_boolean_arg(Arg);
+is_valid_arg(integer, Arg) ->
+ is_non_neg_integer_arg(Arg);
+is_valid_arg(float, Arg) ->
+ is_non_neg_float_arg(Arg);
+is_valid_arg(_Type, _Arg) ->
+ true.
+
+
+-spec is_implicit_arg(arg_spec(), nonempty_string()) -> boolean().
+is_implicit_arg({Type, _DefaultArg}, Arg) ->
+ is_implicit_arg(Type, Arg);
+is_implicit_arg(boolean, Arg) ->
+ not is_boolean_arg(Arg);
+is_implicit_arg(integer, Arg) ->
+ not is_integer_arg(Arg);
+is_implicit_arg(_Type, _Arg) ->
+ false.
+
+
+-spec is_boolean_arg(string()) -> boolean().
+is_boolean_arg(Arg) ->
+ LowerArg = string:to_lower(Arg),
+ is_arg_true(LowerArg) orelse is_arg_false(LowerArg).
+
+
+-spec is_integer_arg(string()) -> boolean().
+is_integer_arg("-" ++ Tail) ->
+ is_non_neg_integer_arg(Tail);
+is_integer_arg(Arg) ->
+ is_non_neg_integer_arg(Arg).
+
+
+-spec is_non_neg_integer_arg(string()) -> boolean().
+is_non_neg_integer_arg([Head | Tail]) when Head >= $0, Head =< $9 ->
+ is_non_neg_integer_arg(Tail);
+is_non_neg_integer_arg([_Head | _Tail]) ->
+ false;
+is_non_neg_integer_arg([]) ->
+ true.
+
+
+-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);
+is_non_neg_float_arg([_Head | _Tail]) ->
+ false;
+is_non_neg_float_arg([]) ->
+ true.
+
+
+%% @doc Show a message on standard_error indicating the command line options and
+%% arguments that are supported by the program.
+-spec usage([option_spec()], string()) -> ok.
+usage(OptSpecList, ProgramName) ->
+ usage(OptSpecList, ProgramName, standard_error).
+
+
+%% @doc Show a message on standard_error or standard_io indicating the command line options and
+%% 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, "Usage: ~s~s~n~n~s~n",
+ [ProgramName, usage_cmd_line(OptSpecList), 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.
+usage(OptSpecList, ProgramName, CmdLineTail) ->
+ usage(OptSpecList, ProgramName, CmdLineTail, standard_error).
+
+
+%% @doc Show a message on standard_error or standard_io 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.
+-spec usage([option_spec()], string(), string(), output_stream() | [{string(), string()}]) -> ok.
+usage(OptSpecList, ProgramName, CmdLineTail, OutputStream) when is_atom(OutputStream) ->
+ io:format(OutputStream, "Usage: ~s~s ~s~n~n~s~n",
+ [ProgramName, usage_cmd_line(OptSpecList), CmdLineTail, 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
+%% and a list of tuples that are added to the end of the options' help lines.
+usage(OptSpecList, ProgramName, CmdLineTail, OptionsTail) ->
+ usage(OptSpecList, ProgramName, CmdLineTail, OptionsTail, standard_error).
+
+
+%% @doc Show a message on standard_error or standard_io 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
+%% and a list of tuples that are added to the end of the options' help lines.
+-spec usage([option_spec()], string(), string(), [{string(), string()}], output_stream()) -> ok.
+usage(OptSpecList, ProgramName, CmdLineTail, OptionsTail, OutputStream) ->
+ UsageOptions = lists:foldl(
+ fun ({Prefix, Help}, Acc) ->
+ add_option_help(Prefix, Help, Acc)
+ end, usage_options_reverse(OptSpecList, []), OptionsTail),
+ io:format(OutputStream, "Usage: ~s~s ~s~n~n~s~n",
+ [ProgramName, usage_cmd_line(OptSpecList), CmdLineTail,
+ lists:flatten(lists:reverse(UsageOptions))]).
+
+
+%% @doc Return a string with the syntax for the command line options and
+%% arguments.
+-spec usage_cmd_line([option_spec()]) -> string().
+usage_cmd_line(OptSpecList) ->
+ usage_cmd_line(OptSpecList, []).
+
+usage_cmd_line([{Name, Short, Long, ArgSpec, _Help} | Tail], Acc) ->
+ CmdLine =
+ case ArgSpec of
+ undefined ->
+ if
+ %% For options with short form and no argument.
+ Short =/= undefined ->
+ [$\s, $[, $-, Short, $]];
+ %% For options with only long form and no argument.
+ Long =/= undefined ->
+ [$\s, $[, $-, $-, Long, $]];
+ true ->
+ []
+ end;
+ _ ->
+ if
+ %% For options with short form and argument.
+ Short =/= undefined ->
+ [$\s, $[, $-, Short, $\s, $<, atom_to_list(Name), $>, $]];
+ %% 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.
+ true ->
+ [$\s, $<, atom_to_list(Name), $>]
+ end
+ end,
+ usage_cmd_line(Tail, [CmdLine | Acc]);
+usage_cmd_line([], Acc) ->
+ lists:flatten(lists:reverse(Acc)).
+
+
+%% @doc Return a string with the help message for each of the options and
+%% arguments.
+-spec usage_options([option_spec()]) -> string().
+usage_options(OptSpecList) ->
+ lists:flatten(lists:reverse(usage_options_reverse(OptSpecList, []))).
+
+usage_options_reverse([{Name, Short, Long, _ArgSpec, Help} | Tail], Acc) ->
+ Prefix =
+ case Long of
+ undefined ->
+ case Short of
+ %% Neither short nor long form (non-option argument).
+ undefined ->
+ [$<, atom_to_list(Name), $>];
+ %% Only short form.
+ _ ->
+ [$-, Short]
+ end;
+ _ ->
+ case Short of
+ %% Only long form.
+ undefined ->
+ [$-, $- | Long];
+ %% Both short and long form.
+ _ ->
+ [$-, Short, $,, $\s, $-, $- | Long]
+ end
+ end,
+ usage_options_reverse(Tail, add_option_help(Prefix, Help, Acc));
+usage_options_reverse([], Acc) ->
+ Acc.
+
+
+%% @doc Add the help message corresponding to an option specification to a list
+%% with the correct indentation.
+-spec add_option_help(Prefix :: string(), Help :: string(), Acc :: string()) -> string().
+add_option_help(Prefix, Help, Acc) when is_list(Help), Help =/= [] ->
+ FlatPrefix = lists:flatten(Prefix),
+ case ((?INDENTATION * ?TAB_LENGTH) - 2 - length(FlatPrefix)) of
+ TabSize when TabSize > 0 ->
+ Tab = lists:duplicate(ceiling(TabSize / ?TAB_LENGTH), $\t),
+ [[$\s, $\s, FlatPrefix, Tab, Help, $\n] | Acc];
+ _ ->
+ % The indentation for the option description is 3 tabs (i.e. 24 characters)
+ % IMPORTANT: Change the number of tabs below if you change the
+ % value of the INDENTATION macro.
+ [[$\t, $\t, $\t, Help, $\n], [$\s, $\s, FlatPrefix, $\n] | Acc]
+ end;
+add_option_help(_Opt, _Prefix, Acc) ->
+ Acc.
+
+
+
+%% @doc Return the smallest integral value not less than the argument.
+-spec ceiling(float()) -> integer().
+ceiling(X) ->
+ T = erlang:trunc(X),
+ case (X - T) of
+ % Neg when Neg < 0 ->
+ % T;
+ Pos when Pos > 0 ->
+ T + 1;
+ _ ->
+ T
+ end.
View
235 deps/getopt/test/getopt_test.erl
@@ -0,0 +1,235 @@
+%%%-------------------------------------------------------------------
+%%% @author Juan Jose Comellas <juanjo@comellas.org>
+%%% @copyright (C) 2009 Juan Jose Comellas
+%%% @doc Parses command line options with a format similar to that of GNU getopt.
+%%%
+%%% This source file is subject to the New BSD License. You should have received
+%%% a copy of the New BSD license with this software. If not, it can be
+%%% retrieved from: http://www.opensource.org/licenses/bsd-license.php
+%%%-------------------------------------------------------------------
+
+-module(getopt_test).
+-author('juanjo@comellas.org').
+
+-include_lib("eunit/include/eunit.hrl").
+
+-import(getopt, [parse/2]).
+
+-define(NAME(Opt), element(1, Opt)).
+-define(SHORT(Opt), element(2, Opt)).
+-define(LONG(Opt), element(3, Opt)).
+-define(ARG_SPEC(Opt), element(4, Opt)).
+-define(HELP(Opt), element(5, Opt)).
+
+
+%%%-------------------------------------------------------------------
+%%% UNIT TESTS
+%%%-------------------------------------------------------------------
+
+%%% Test for the getopt/1 function
+parse_1_test_() ->
+ Short = {short, $a, undefined, undefined, "Option with only short form and no argument"},
+ Short2 = {short2, $b, undefined, undefined, "Second option with only short form and no argument"},
+ Short3 = {short3, $c, undefined, undefined, "Third option with only short form and no argument"},
+ ShortArg = {short_arg, $d, undefined, string, "Option with only short form and argument"},
+ ShortDefArg = {short_def_arg, $e, undefined, {string, "default-short"}, "Option with only short form and default argument"},
+ ShortBool = {short_bool, $f, undefined, boolean, "Option with only short form and boolean argument"},
+ ShortInt = {short_int, $g, undefined, integer, "Option with only short form and integer argument"},
+ ShortFloat = {short_float, $h, undefined, float, "Option with only short form and float argument"},
+ Long = {long, undefined, "long", undefined, "Option with only long form and no argument"},
+ LongArg = {long_arg, undefined, "long-arg", string, "Option with only long form and argument"},
+ LongDefArg = {long_def_arg, undefined, "long-def-arg", {string, "default-long"}, "Option with only long form and default argument"},
+ LongBool = {long_bool, undefined, "long-bool", boolean, "Option with only long form and boolean argument"},
+ LongInt = {long_int, undefined, "long-int", integer, "Option with only long form and integer argument"},
+ LongFloat = {long_float, undefined, "long-float", float, "Option with only long form and float argument"},
+ ShortLong = {short_long, $i, "short-long", undefined, "Option with short form, long form and no argument"},
+ ShortLongArg = {short_long_arg, $j, "short-long-arg", string, "Option with short form, long form and argument"},
+ ShortLongDefArg = {short_long_def_arg, $k, "short-long-def-arg", {string, "default-short-long"}, "Option with short form, long form and default argument"},
+ ShortLongBool = {short_long_bool, $l, "short-long-bool", boolean, "Option with short form, long form and boolean argument"},
+ ShortLongInt = {short_long_int, $m, "short-long-int", integer, "Option with short form, long form and integer argument"},
+ ShortLongFloat = {short_long_float, $n, "short-long-float", float, "Option with short form, long form and float argument"},
+ NonOptArg = {non_opt_arg, undefined, undefined, undefined, "Non-option argument"},
+ NonOptBool = {non_opt_bool, undefined, undefined, boolean, "Non-option boolean argument"},
+ NonOptInt = {non_opt_int, undefined, undefined, integer, "Non-option integer argument"},
+ NonOptFloat = {non_opt_float, undefined, undefined, float, "Non-option float argument"},
+ CombinedOptSpecs =
+ [
+ Short,
+ ShortArg,
+ ShortBool,
+ ShortInt,
+ Short2,
+ Short3,
+ Long,
+ LongArg,
+ LongBool,
+ LongInt,
+ ShortLong,
+ ShortLongArg,
+ ShortLongBool,
+ ShortLongInt,
+ NonOptArg,
+ NonOptInt,
+ ShortDefArg,
+ LongDefArg,
+ ShortLongDefArg
+ ],
+ CombinedArgs =
+ [
+ [$-, ?SHORT(Short)],
+ [$-, ?SHORT(ShortArg)], "value1",
+ [$-, ?SHORT(ShortBool)],
+ [$-, ?SHORT(ShortInt)], "100",
+ [$-, ?SHORT(Short2), ?SHORT(Short3)],
+ "--long",
+ "--long-arg", "value2",
+ "--long-bool", "true",
+ "--long-int", "101",
+ [$-, ?SHORT(ShortLong)],
+ "--short-long-arg", "value3",
+ "--short-long-bool", "false",
+ "--short-long-int", "103",
+ "value4",
+ "104",
+ "dummy1",
+ "dummy2"
+ ],
+ CombinedOpts =
+ [
+ ?NAME(Short),
+ {?NAME(ShortArg), "value1"},
+ {?NAME(ShortBool), true},
+ {?NAME(ShortInt), 100},
+ ?NAME(Short2),
+ ?NAME(Short3),
+ ?NAME(Long),
+ {?NAME(LongArg), "value2"},
+ {?NAME(LongBool), true},
+ {?NAME(LongInt), 101},
+ ?NAME(ShortLong),
+ {?NAME(ShortLongArg), "value3"},
+ {?NAME(ShortLongBool), false},
+ {?NAME(ShortLongInt), 103},
+ {?NAME(NonOptArg), "value4"},
+ {?NAME(NonOptInt), 104},
+ {?NAME(ShortDefArg), "default-short"},
+ {?NAME(LongDefArg), "default-long"},
+ {?NAME(ShortLongDefArg), "default-short-long"}
+ ],
+ CombinedRest = ["dummy1", "dummy2"],
+
+ [
+ {"No options and no arguments",
+ ?_assertMatch({ok, {[], []}}, parse([], []))},
+ {"Options and no arguments",
+ ?_assertMatch({ok, {[], []}}, parse([Short], []))},
+ {"No options and single argument",
+ ?_assertMatch({ok, {[], ["arg1"]}}, parse([], ["arg1"]))},
+ {"No options and arguments",
+ ?_assertMatch({ok, {[], ["arg1", "arg2"]}}, parse([], ["arg1", "arg2"]))},
+ {"Unused options and arguments",
+ ?_assertMatch({ok, {[], ["arg1", "arg2"]}}, parse([Short], ["arg1", "arg2"]))},
+ %% Option terminator
+ {"Option terminator before arguments",
+ ?_assertEqual({ok, {[], [[$-, ?SHORT(Short)], "arg1", "arg2"]}}, parse([Short], ["--", [$-, ?SHORT(Short)], "arg1", "arg2"]))},
+ {"Option terminator between arguments",
+ ?_assertEqual({ok, {[], ["arg1", [$-, ?SHORT(Short)], "arg2"]}}, parse([Short], ["arg1", "--", [$-, ?SHORT(Short)], "arg2"]))},
+ {"Option terminator after options",
+ ?_assertMatch({ok, {[short], ["arg1", "arg2"]}}, parse([Short], [[$-, ?SHORT(Short)], "--", "arg1", "arg2"]))},
+ {"Option terminator at the end",
+ ?_assertMatch({ok, {[short], ["arg1", "arg2"]}}, parse([Short], [[$-, ?SHORT(Short)], "arg1", "arg2", "--"]))},
+ %% Options with only the short form
+ {?HELP(Short), ?_assertMatch({ok, {[short], []}}, parse([Short], [[$-, ?SHORT(Short)]]))},
+ {?HELP(ShortArg), ?_assertMatch({ok, {[{short_arg, "value"}], []}}, parse([ShortArg], [[$-, ?SHORT(ShortArg)], "value"]))},
+ {?HELP(ShortDefArg), ?_assertMatch({ok, {[{short_def_arg, "default-short"}], []}}, parse([ShortDefArg], []))},
+ {?HELP(ShortBool), ?_assertMatch({ok, {[{short_bool, true}], []}}, parse([ShortBool], [[$-, ?SHORT(ShortBool)]]))},
+ {?HELP(ShortBool), ?_assertMatch({ok, {[{short_bool, true}], []}}, parse([ShortBool], [[$-, ?SHORT(ShortBool), $t]]))},
+ {?HELP(ShortBool), ?_assertMatch({ok, {[{short_bool, true}], []}}, parse([ShortBool], [[$-, ?SHORT(ShortBool), $1]]))},
+ {?HELP(ShortBool), ?_assertMatch({ok, {[{short_bool, true}], []}}, parse([ShortBool], [[$-, ?SHORT(ShortBool)], "true"]))},
+ {?HELP(ShortBool), ?_assertMatch({ok, {[{short_bool, false}], []}}, parse([ShortBool], [[$-, ?SHORT(ShortBool), $f]]))},
+ {?HELP(ShortBool), ?_assertMatch({ok, {[{short_bool, false}], []}}, parse([ShortBool], [[$-, ?SHORT(ShortBool), $0]]))},
+ {?HELP(ShortBool), ?_assertMatch({ok, {[{short_bool, false}], []}}, parse([ShortBool], [[$-, ?SHORT(ShortBool)], "false"]))},
+ {?HELP(ShortInt), ?_assertMatch({ok, {[{short_int, 100}], []}}, parse([ShortInt], [[$-, ?SHORT(ShortInt), $1, $0, $0]]))},
+ {?HELP(ShortInt), ?_assertMatch({ok, {[{short_int, 100}], []}}, parse([ShortInt], [[$-, ?SHORT(ShortInt)], "100"]))},
+ {?HELP(ShortInt), ?_assertMatch({ok, {[{short_int, 3}], []}}, parse([ShortInt], [[$-, ?SHORT(ShortInt), ?SHORT(ShortInt), ?SHORT(ShortInt)]]))},
+ {?HELP(ShortFloat), ?_assertMatch({ok, {[{short_float, 1.0}], []}}, parse([ShortFloat], [[$-, ?SHORT(ShortFloat), $1, $., $0]]))},
+ {?HELP(ShortFloat), ?_assertMatch({ok, {[{short_float, 1.0}], []}}, parse([ShortFloat], [[$-, ?SHORT(ShortFloat)], "1.0"]))},
+ {"Unsorted multiple short form options and arguments in a single string",
+ ?_assertMatch({ok, {[short, short2, short3], ["arg1", "arg2"]}}, parse([Short, Short2, Short3], "arg1 -abc arg2"))},
+ {"Short form option and arguments",
+ ?_assertMatch({ok, {[short], ["arg1", "arg2"]}}, parse([Short], [[$-, ?SHORT(Short)], "arg1", "arg2"]))},
+ {"Short form option and arguments (unsorted)",
+ ?_assertMatch({ok, {[short], ["arg1", "arg2"]}}, parse([Short], ["arg1", [$-, ?SHORT(Short)], "arg2"]))},
+ %% Options with only the long form
+ {?HELP(Long), ?_assertMatch({ok, {[long], []}}, parse([Long], ["--long"]))},
+ {?HELP(LongArg), ?_assertMatch({ok, {[{long_arg, "value"}], []}}, parse([LongArg], ["--long-arg", "value"]))},
+ {?HELP(LongArg), ?_assertMatch({ok, {[{long_arg, "value"}], []}}, parse([LongArg], ["--long-arg=value"]))},
+ {?HELP(LongArg), ?_assertMatch({ok, {[{long_arg, "value=1"}], []}}, parse([LongArg], ["--long-arg=value=1"]))},
+ {?HELP(LongDefArg), ?_assertMatch({ok, {[{long_def_arg, "default-long"}], []}}, parse([LongDefArg], []))},
+ {?HELP(LongBool), ?_assertMatch({ok, {[{long_bool, true}], []}}, parse([LongBool], ["--long-bool"]))},
+ {?HELP(LongBool), ?_assertMatch({ok, {[{long_bool, true}], []}}, parse([LongBool], ["--long-bool=t"]))},
+ {?HELP(LongBool), ?_assertMatch({ok, {[{long_bool, true}], []}}, parse([LongBool], ["--long-bool=1"]))},
+ {?HELP(LongBool), ?_assertMatch({ok, {[{long_bool, true}], []}}, parse([LongBool], ["--long-bool", "true"]))},
+ {?HELP(LongBool), ?_assertMatch({ok, {[{long_bool, false}], []}}, parse([LongBool], ["--long-bool=f"]))},
+ {?HELP(LongBool), ?_assertMatch({ok, {[{long_bool, false}], []}}, parse([LongBool], ["--long-bool=0"]))},
+ {?HELP(LongBool), ?_assertMatch({ok, {[{long_bool, false}], []}}, parse([LongBool], ["--long-bool", "false"]))},
+ {?HELP(LongInt), ?_assertMatch({ok, {[{long_int, 100}], []}}, parse([LongInt], ["--long-int", "100"]))},
+ {?HELP(LongInt), ?_assertMatch({ok, {[{long_int, 100}], []}}, parse([LongInt], ["--long-int=100"]))},
+ {?HELP(LongFloat), ?_assertMatch({ok, {[{long_float, 1.0}], []}}, parse([LongFloat], ["--long-float", "1.0"]))},
+ {?HELP(LongFloat), ?_assertMatch({ok, {[{long_float, 1.0}], []}}, parse([LongFloat], ["--long-float=1.0"]))},
+ {"Long form option and arguments",
+ ?_assertMatch({ok, {[long], ["arg1", "arg2"]}}, parse([Long], ["--long", "arg1", "arg2"]))},
+ {"Long form option and arguments (unsorted)",
+ ?_assertMatch({ok, {[long], ["arg1", "arg2"]}}, parse([Long], ["arg1", "--long", "arg2"]))},
+ %% Options with both the short and long form
+ {?HELP(ShortLong), ?_assertMatch({ok, {[short_long], []}}, parse([ShortLong], [[$-, ?SHORT(ShortLong)]]))},
+ {?HELP(ShortLong), ?_assertMatch({ok, {[short_long], []}}, parse([ShortLong], ["--short-long"]))},
+ {?HELP(ShortLongArg), ?_assertMatch({ok, {[{short_long_arg, "value"}], []}}, parse([ShortLongArg], [[$-, ?SHORT(ShortLongArg)], "value"]))},
+ {?HELP(ShortLongArg), ?_assertMatch({ok, {[{short_long_arg, "value"}], []}}, parse([ShortLongArg], ["--short-long-arg", "value"]))},
+ {?HELP(ShortLongArg), ?_assertMatch({ok, {[{short_long_arg, "value"}], []}}, parse([ShortLongArg], ["--short-long-arg=value"]))},
+ {?HELP(ShortLongDefArg), ?_assertMatch({ok, {[{short_long_def_arg, "default-short-long"}], []}}, parse([ShortLongDefArg], []))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, true}], []}}, parse([ShortLongBool], [[$-, ?SHORT(ShortLongBool)]]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, true}], []}}, parse([ShortLongBool], [[$-, ?SHORT(ShortLongBool), $1]]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, true}], []}}, parse([ShortLongBool], [[$-, ?SHORT(ShortLongBool)], "yes"]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, true}], []}}, parse([ShortLongBool], ["--short-long-bool", "on"]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, true}], []}}, parse([ShortLongBool], ["--short-long-bool=enabled"]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, false}], []}}, parse([ShortLongBool], [[$-, ?SHORT(ShortLongBool), $0]]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, false}], []}}, parse([ShortLongBool], [[$-, ?SHORT(ShortLongBool)], "no"]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, false}], []}}, parse([ShortLongBool], ["--short-long-bool", "off"]))},
+ {?HELP(ShortLongBool), ?_assertMatch({ok, {[{short_long_bool, false}], []}}, parse([ShortLongBool], ["--short-long-bool=disabled"]))},
+ {?HELP(ShortLongInt), ?_assertMatch({ok, {[{short_long_int, 1234}], []}}, parse([ShortLongInt], [[$-, ?SHORT(ShortLongInt)], "1234"]))},
+ {?HELP(ShortLongInt), ?_assertMatch({ok, {[{short_long_int, 1234}], []}}, parse([ShortLongInt], ["--short-long-int", "1234"]))},
+ {?HELP(ShortLongInt), ?_assertMatch({ok, {[{short_long_int, 1234}], []}}, parse([ShortLongInt], ["--short-long-int=1234"]))},
+ {?HELP(ShortLongFloat), ?_assertMatch({ok, {[{short_long_float, 1.0}], []}}, parse([ShortLongFloat], [[$-, ?SHORT(ShortLongFloat)], "1.0"]))},
+ {?HELP(ShortLongFloat), ?_assertMatch({ok, {[{short_long_float, 1.0}], []}}, parse([ShortLongFloat], ["--short-long-float", "1.0"]))},
+ {?HELP(ShortLongFloat), ?_assertMatch({ok, {[{short_long_float, 1.0}], []}}, parse([ShortLongFloat], ["--short-long-float=1.0"]))},
+ %% Non-option arguments
+ {?HELP(NonOptArg), ?_assertMatch({ok, {[{non_opt_arg, "value"}], []}}, parse([NonOptArg], ["value"]))},
+ {?HELP(NonOptBool), ?_assertMatch({ok, {[{non_opt_bool, false}], []}}, parse([NonOptBool], ["n"]))},
+ {?HELP(NonOptInt), ?_assertMatch({ok, {[{non_opt_int, 1234}], []}}, parse([NonOptInt], ["1234"]))},
+ {?HELP(NonOptFloat), ?_assertMatch({ok, {[{non_opt_float, 1.0}], []}}, parse([NonOptFloat], ["1.0"]))},
+ {"Declared and undeclared non-option arguments",
+ ?_assertMatch({ok, {[{non_opt_arg, "arg1"}], ["arg2", "arg3"]}}, parse([NonOptArg], ["arg1", "arg2", "arg3"]))},
+ %% Combined
+ {"Combined short, long and non-option arguments",
+ ?_assertEqual({ok, {CombinedOpts, CombinedRest}}, parse(CombinedOptSpecs, CombinedArgs))},
+ {"Option with only short form and non-integer argument",
+ ?_assertEqual({ok, {[{short_int, 1}], ["value"]}}, parse([ShortInt], [[$-, ?SHORT(ShortInt)], "value"]))}
+ ].
+
+
+%% Real world test for getopt/1
+parse_2_test_() ->
+ OptSpecList =
+ [
+ {define, $D, "define", string, "Define a variable"},
+ {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, 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"))}
+ ].

0 comments on commit cbe1cee

Please sign in to comment.
Something went wrong with that request. Please try again.